diff --git a/hurdat2parser/__init__.py b/hurdat2parser/__init__.py new file mode 100644 index 0000000..a44820e --- /dev/null +++ b/hurdat2parser/__init__.py @@ -0,0 +1,1682 @@ +"""hurdat2parser v2.3.0.1 + +https://github.com/ksgwxfan/hurdat2parser + +hurdat2parser v2.x is provides a convenient access to interpret and work with +tropical cyclone data that is contained in a widely-used and updated dataset, +HURDAT2 (https://www.nhc.noaa.gov/data/#hurdat). The purpose of this module is to +provide a quick way to investigate HURDAT2 data. It includes methods for +retrieving, inspecting, ranking, or even exporting data for seasons, individual +storms, or climatological eras. + +To get started: +1) Install: >>> pip install hurdat2parser +2a) Download HURDAT2 Data: https://www.nhc.noaa.gov/data/#hurdat + OR See example call below to have the program attempt to download it for you +3) In python, import and invoke call using the hurdat2 file you downloaded (the + following is just an example): + + >>> import hurdat2parser + >>> atl = hurdat2parser.Hurdat2("path_to_hurdat2.txt") + + OR ATTEMPT TO RETRIEVE FROM ONLINE + >>> atl = hurdat2parser.Hurdat2(basin="atl") + # Use "pac" to get the NE/CEN Pacific version + +hurdat2parser, Copyright (c) 2019-2024, Kyle Gentry (github.com/ksgwxfan) +License: MIT +ksgwxfan.github.io + + +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import calendar +import difflib +import math +import re +import urllib.request +import itertools +import datetime +import os +import collections + +from . import _aliases, _calculations, _reports, _gis + +class Hurdat2(_aliases.Hurdat2Aliases, _calculations.Hurdat2Calculations, _reports.Hurdat2Reports, _gis.Hurdat2GIS): + + BASIN_DICT = dict( + AL = "North Atlantic", + NA = "North Atlantic", + SL = "South Atlantic", + SA = "South Atlantic", + EP = "East Pacific", + CP = "Central Pacific", + WP = "West Pacific", + SH = "Southern Hemisphere", + IO = "North Indian", + NI = "North Indian", + SI = "South Indian", + SP = "South Pacific", + AS = "Arabian Sea", + BB = "Bay of Bengal", + ) + + def __init__(self, *hurdat2file_list, **kw): + """Initializes a new Hurdat2 object. + + Arguments: + *hurdat2file_list: the local file-paths (or URLs) of the hurdat2 + record(s) + + Keyword Arguments: + basin (None): If you want to try to retrieve the latest hurdat2 + file from the NHC to ingest, let it know which basin you want + to download. Acceptable strings to use would be "atl", "al", or + "atlantic" for the North Atlantic hurdat2. For the North-East/ + Central Pacific, "pac", "nepac", and "pacific" are recognized. + Of note, the Atlantic hurdat2 file is around 6MB. + urlcheck (False): If True, urls are accepted. This enables the + download of a remote version of a Hurdat2 dataset. The url + string is passed as if a local file and will eventually be + attempted to be downloaded. + + Example call: + atl = hurdat2parser.Hurdat2("atlantic_hurdat2.txt") + * Attempts to load a local file named "hurdat2_file.txt" + atl = hurdat2parser.Hurdat2(basin="pac") + * Attempts to download the latest NE/CEN Pacific hurdat2 file + atl = hurdat2parser.Hurdat2("https://somewebsite.zxcv/hd2.txt", urlcheck=True) + * Attempts to download inspect the passed-string as a url and + tries to download + + """ + self._tc = {} # Dictionary containing all hurdat2 storm data + self._season = {} # Dictionary containing all relevant season data + + # Validity checking ------------------------------- + # no local path given and Non-existent or invalid basin + if len(hurdat2file_list) == 0 \ + and (kw.get("basin") is None or type(kw.get("basin")) != str): + raise ValueError( + "No path to a local hurdat2 file given and no valid basin " + "indicated to attempt online retrieval." + ) + # No online, but invalid local paths + if kw.get("basin") is None \ + and len(hurdat2file_list) != 0 \ + and all(os.path.exists(fi) == False for fi in hurdat2file_list) \ + and kw.get("urlcheck", False) is False: + raise FileNotFoundError( + "{} {} not {}valid file path{}.".format( + ", ".join([ + "'{}'".format(fi) for fi in hurdat2file_list + ]), + "is" if len(hurdat2file_list) == 1 else "are", + "a " if len(hurdat2file_list) == 1 else "", + "" if len(hurdat2file_list) == 1 else "s", + ) + ) + # ------------------------------------------------------- + + # Download from online + if type(kw.get("basin")) == str \ + and kw.get("basin").lower() in [ + "al", "atl", "atlantic", "pac", "nepac", "pacific" + ]: + BASIN = "atl" if kw.get("basin").lower() in ["al", "atl", "atlantic"] else "nepac" + + # https://www.nhc.noaa.gov/data/hurdat/hurdat2-1851-2021-100522.txt + with urllib.request.urlopen("https://www.nhc.noaa.gov/data/hurdat", timeout=5) as u: + _pgdata = u.read().decode() + + # HEY HEY HEY I NEED TO CHECK THIS LOGIC. SOMETHING + # DOESN'T SEEM RIGHT. DO I ALSO NEED TO ADD CONSOLE MESSAGE + # ABOUT THE BASIN BEING RETRIEVED? + + _hd2list_raw = sorted( + [ + result for result in re.findall( + # r"hurdat2-.*\d{4}\-\d{4}.*\.txt", + r"hurdat2-(?!format).*\.txt", + _pgdata, + flags=re.I + # ) if BASIN == "nepac" or "nepac" not in result + ) if BASIN in result or ( + BASIN == "atl" and "nepac" not in result + ) + ], + reverse=True + ) + URLTime = collections.namedtuple( + "URLTime", + ["url", "date"] + ) + _hd2list_urls = [] # container to hold info about the files + for url in _hd2list_raw: + # time format is included at the end of the url + timestr = re.search( + r"(\d+)\w*\.txt", + url + )[1] + + _hd2list_urls.append( + URLTime( + url, + datetime.date( + int(timestr[-4:]) if len(timestr) == 8 + else 2000 + int(timestr[-2:]), + int(timestr[:2]), + int(timestr[2:4]) + ) + ) + ) + + # sort the URLs by date + _hd2list_urls.sort(key=lambda u: u.date) + + # the newest one will be the last one in the list + _urlobj = _hd2list_urls[-1] + + hd2url = "https://www.nhc.noaa.gov/data/hurdat/" \ + + _urlobj.url + + # read in the url + try: + with urllib.request.urlopen(hd2url, timeout=5) as u: + hd2fileobj = u.read().decode() + try: + localsave = False + with open(_urlobj.url, "w") as w: + w.write(hd2fileobj) + localsave = True + except Exception as ee: + print("* local save of '{}' failed: {}".format(_urlobj.url, ee)) + # print("* Downloaded '{}'".format(hd2url)) + except: + if len(hurdat2file_list) == 0: + raise + self._build_tc_dictionary(hd2fileobj, False) + print("* Download{}{} and read-in of `{}` successful!".format( + ", local save" if localsave is True else "", + "," if localsave is True else "", + hd2url + )) + # invalid basin listed + elif type(kw.get("basin")) == str: + if len(hurdat2file_list) == 0: + raise ValueError( + "'{}' is an unrecognized basin. ".format(kw.get("basin")) \ + + "Please use something like 'atl' or 'pac' to direct the " \ + + "module to retrieve the deisred hurdat2 file from online." + ) + else: + print( + "* Skipping basin download. " \ + + "'{}' is an unrecognized basin. ".format(kw.get("basin")) \ + + "Please use something like 'atl' or 'pac' to direct the " \ + + "module to retrieve the deisred hurdat2 file from online." + ) + + for hd2file in hurdat2file_list: + if os.path.exists(hd2file): + self._build_tc_dictionary(hd2file) # Call to build/analyze the hurdat2 file + # print("* Read-in of `{}` successful!".format(hd2file)) + # download a given url + elif kw.get("urlcheck"): + try: + with urllib.request.urlopen(hd2file, timeout=5) as u: + hd2fileobj = u.read().decode() + # print("* Downloaded '{}'".format(hd2file)) + except Exception as e: + print("* Skipping '{}' due to {}".format(hd2file, e)) + hd2fileobj = None + if hd2fileobj is not None: + self._build_tc_dictionary(hd2fileobj, False) + # print("* Download and read-in of `{}` successful!".format( + # hd2file + # )) + else: + print("* Skipping `{}` because that path doesn't exist!".format( + hd2file + )) + + if len(self) == 0: + raise ValueError("No storm data ingested!") + + def __repr__(self): + return "<{} object - {}: {}-{} - at 0x{:0>16}>".format( + re.search(r"'(.*)'", str(type(self)))[1], + self.basin(), + *self.record_range, + "{:X}".format(id(self)) + ) + + def __len__(self): + """Returns the number of tracked systems in the Hurdat2 record""" + return len(self.tc) + + def __str__(self): + return "{}, {}".format( + self.basin(), + "{}-{}".format(*self.record_range) + ) + + def __getattr__(self, name): + # if an atcfid is passed as an attribute + if re.search(r"^\w{2}\d{6}$", name): + return self.tc[name.upper()] + match = self.storm_name_search( + name, + feeling_lucky=True, + attr_query=True + ) + if match is not None: + return match + else: + return self.__getattribute__(name) + + def __getitem__(self, s): + """Indexing handling here is designed more of as a 'switchboard + operator.' It handles multiple types and interprets their passage and + routes them to the proper methods, providing shortcuts of sorts. + + Accepted types: + slice: calls the multi_season_info method, using the slice's start + and stop attributes for it. In an effort to preserve the + typical implementation of slice, the end year is decremented by + 1. So [2000:2005] would include stats from 2000 thru 2004; + excluding 2005. For different behavior, see the next entry, for + tuples. + tuple or list: returns the Season(1), TropicalCyclone(2), or + TCRecordEntry(3) desired, depending on length of tuple passed. + int: grabs the object matching the year passed. + str: inspects the string and returns either a storm object, a + season object, or a call to the name-search function + """ + # multi-season info + if type(s) == slice: + st = s.start + en = s.stop-1 + return self.multi_season_info(st, en) + # use items of an iterable as season, tcnumber, and entry index + elif type(s) in [tuple, list]: + if len(s) == 1: + return self[s[0]] + elif len(s) == 2: + return self[ + max(s, default=s[0]) + ][ + min(s, default=s[1]) + ] + else: + return self[s[0]][s[1:]] + # Season passed as int + elif type(s) == int: + # year at the end + # 19991 + # 11999 + # 011999 + # test for shortcut atcfid (if 5 or 6 digits) + if s < 9999: + return self.season[s] + elif 9999 < s <= 99999: + # 31999 202005 + # 19993 200520 + tcycnum, yr = int(str(s)[0]), int(str(s)[-4:]) + if self.record_range[0] <= yr <= self.record_range[1]: + return self[yr, tcycnum] + yr, tcycnum = int(str(s)[:4]), int(str(s)[-1]) + return self[yr, tcycnum] + elif 99999 < s <= 999999: + tcycnum, yr = int(str(s)[:2]), int(str(s)[-4:]) + if self.record_range[0] <= yr <= self.record_range[1]: + return self[yr, tcycnum] + yr, tcycnum = int(str(s)[:4]), int(str(s)[-2:]) + return self[yr, tcycnum] + # String based + elif type(s) == str: + # ATCFID Request + if re.search(r"^[A-Z]{2}[0-9]{6}.*", s, flags=re.I): + return self.tc[s.upper()[:8]] + # Season Request + elif s.isnumeric(): + return self.season[int(s[:4])] + # Name Search implied (will return the last storm so-named) + else: + return self.storm_name_search(s, False, True if "_" in s or "-" in s else False) + # try handling all other types by converting to str then search by name + else: + return self.storm_name_search(str(s), False) + + def _build_tc_dictionary(self, hurdat2file, path=True): + """Populate the Hurdat2 object with data from a hurdat2 file. + + Arguments: + hurdat2file: the file-path (or string version) of the hurdat2 file + + Default Arguments: + path (True): this tells the method what kind object to expect. By + default, it will be considered a file-path. If False, it will + expect a stringified version of the database. + """ + if path is True: + with open(hurdat2file) as h: + _hd2data = h.read().splitlines() + else: + _hd2data = hurdat2file.splitlines() + + for indx, line in enumerate(_hd2data): + lineparsed = re.split(r", *", re.sub(r", *$", "", line)) + # New Storm + if re.search(r"^[A-Z]{2}\d{6}",lineparsed[0]): + atcfid = lineparsed[0] + tcyr = int(atcfid[4:]) + # Create Season + if tcyr not in self.season: + self.season[tcyr] = Season(tcyr, self) + # Duplicate storm in the database! Notify the user + if atcfid in self.tc: + print( + "* Data for`{}`".format(atcfid) \ + + " has already been ingested." \ + + " Overwriting will take place." + ) + # Create TropicalCyclone + self.tc[atcfid] = TropicalCyclone( + atcfid, + lineparsed[1], + self.season[tcyr], + self + ) + # Add storm to that particular season + self.season[tcyr].tc[atcfid] = self.tc[atcfid] + # TCRecordEntry for storm indicated + else: + try: + self.tc[atcfid].entry.append( + TCRecordEntry( + lineparsed.copy(), + line, + self.tc[atcfid], + self.season[tcyr], + self + ) + ) + except Exception as e: + print("{}:".format(indx+1), line) + print("*Error ingesting the line above: {}".format(e)) + + def storm_name_search(self, searchname, info=True, feeling_lucky=False, attr_query=False): + """Search the Hurdat2 object's records by storm name. Returns the + matches info method or returns the matching object itself. + + Required Argument: + searchname: the storm name to search + + Default Arguments: + info = True: if True, the method will return the info method of the + chosen search result. Otherwise it will simply return the + object (used in __getitem__) + feeling_lucky = False: if True, and if there are multiple search + results, it will return the newest one. This kw is employed + by a 'global' search for a storm by name. This is included due + to the assumption that users, when operating on the entire + Hurdat2 record, are inquiring about a particular storm that + would now have a retired name, and as such, would be the + newest storm to be issued that identifying name. + attr_query = False: primarily an internal kwarg. Used to control + the type of object returned if called by 's __getattr__ + method. In addition, this is only valid if feeling_lucky is + True. + + """ + searchname = str(searchname).upper() # Capitalize the search term + + # Searching for a storm of a particular name; will return the most + # recent storm where a match was found in the name + if feeling_lucky is True: + searchname = searchname.replace("_", "").replace("-", "") + # 1st pass + matchlist = [(TC, 1.0) for TC in self.tc.values() if searchname == TC.name] + + if len(matchlist) > 0: + return matchlist[-1][0] + # 2nd pass + else: + matchlist = sorted( + filter( + lambda tup: tup[1] >= 0.8, + [ + ( + TC, + difflib.SequenceMatcher( + None, + searchname, + TC.name + ).quick_ratio() + ) for TC in self.tc.values() if TC.name[0] == searchname[0] + ] + ), key=lambda tup: tup[0].year, reverse=True + ) + if len(matchlist) == 0: + if attr_query: + return None + else: + raise Exception( + "No matching tropical cyclones with the same or similar " + "name as '{}' found.".format(searchname) + ) + return matchlist[0][0] + + # All other searches + # ----------------------------- + + # 1st pass - Limit the search results to exact matches + matchlist = [(TC, 1.0) for TC in self.tc.values() if searchname == TC.name] + + # 2nd pass - Limit the search results by requiring that + # the first is letter correct + if len(matchlist) == 0: + matchlist = sorted( + filter( + lambda tup: tup[1] >= 0.8, + [ + ( + TC, + difflib.SequenceMatcher( + None, + searchname, + TC.name + ).quick_ratio() + ) for TC in self.tc.values() if TC.name[0] == searchname[0] + ] + ), + key=lambda tup: tup[1], + reverse=True + ) + #3rd pass - if necessary; if no match found + if len(matchlist) == 0: + matchlist = sorted( + filter( + lambda tup: tup[1] >= 0.6, + [ + ( + TC, + difflib.SequenceMatcher( + None, + searchname, + TC.name + ).quick_ratio() + ) for TC in self.tc.values() if TC.name[0] == searchname[0] + ] + ), key=lambda tup: tup[1], reverse=True + ) + + # No Matches Determined + if len(matchlist) == 0: + print("* No Matches Found for '{}'*".format(searchname)) + return None + + # If only one match found, return it! + elif len(matchlist) == 1: + # Manual Search call + if info is True: + return matchlist[0][0].info() + # Indexing being attempted; return TropicalCyclone Object + else: + return matchlist[0][0] + + # Display a choice for multiple matches (up to the first 7) + else: + i = itertools.count(1) + for tc, qratio in matchlist[:7]: + print("{}. {:.1%} - {}: {}{}".format( + next(i), + qratio, + tc.atcfid, + "{} ".format(tc.status_highest) \ + if tc.name != "UNNAMED" \ + else "", + tc.name.title() if tc.name != "UNNAMED" else tc.name + )) + print("") + while True: + choice = input("Which storm are you inquiring about? ") + if choice.isnumeric() and 1 <= int(choice) <= 7: + print("--------------------") + if info is True: + return matchlist[int(choice) - 1][0].info() + else: + return matchlist[int(choice) - 1][0] + else: + print("* OOPS! Invalid Entry! Try again.") + + @staticmethod + def coord_contains(testcoord, ux, lx): + """Returns True or False whether the coordinates (testcoord) would be + contained in a box defined by 'upper' coordinates (ux) and 'lower' + coordinates (lx). + """ + if lx[0] <= testcoord[0] <= ux[0] and ux[1] <= testcoord[1] <= lx[1]: + return True + else: + return False + + def basin_abbr(self, season_obj=None): + """Returns a list of basin abbreviations used in the hurdat2 record. + + This is primarily of use to the .basin() method. + """ + try: + return list(set([ + tc.atcfid[:2] + for tc in ( + self.tc.values() + if season_obj is None + else season_obj.tc.values() + ) + ])) + except: + return ["UNK"] + + def basin(self, season_obj=None): + """Returns a string containing the various oceanic basins represented in the hurdat2 database(s) being analyzed. As an example, the NHC releases a East/Central Pacific Hurdat2. + + Keyword Argument: + season_obj (None): This is used to isolate a basin names from a particular season. It's possible in the aforementioned East/Central Pacific that cyclones occur in the east pacific but not central. So a report or inquired stats from a particular season wouldn't need to show data from the non-existent basin. + """ + + basin_names = [] + try: + basin_names = list(set([ + self.BASIN_DICT[basin] + for basin in self.basin_abbr(season_obj) + ])) + except: + pass + if len(basin_names) > 0: + return " / ".join(basin_names) \ + + " Basin{}".format( + "s" if len(self.basin_abbr(season_obj)) > 1 else "" + ) + else: + return "Unknown Region" + + @property + def record_range(self): + """Returns a tuple containing the beginning and end seasons covered by + the Hurdat2 object. + """ + return (min(self.season), max(self.season)) + +class Season(_aliases.SeasonAliases, _calculations.SeasonCalculations, _reports.SeasonReports): + """Represents a single hurricane season; represented by its year.""" + def __init__(self,yr,hd2obj): + self._year = yr + self._tc = {} + self._hd2 = hd2obj + + def __repr__(self): + return "<{} object - {} - {} - at 0x{:0>16}>".format( + re.search(r"'(.*)'", str(type(self)))[1], + self.year, + self._hd2.basin(self), + "{:X}".format(id(self)) + ) + + def __len__(self): + """Returns the number of tropical cyclones from a particular season.""" + return len(self.tc) + + def __getitem__(self, s): + # Storm Number passed + if type(s) == int and s >= 0: + tcmatches = [ + tc for atcfid, tc in self.tc.items() + if re.search( + r"[A-Z][A-Z]{:0>2}\d\d\d\d".format(s), + atcfid + ) + ] + if len(tcmatches) == 0: + return list(self.tc.values())[s] + elif len(tcmatches) == 1: + return tcmatches[0] + else: + print("* Multiple matches found. Choose intended storm:") + print("------------------------------------------------") + for indx, tc in enumerate(tcmatches): + print("{}. {} - '{}'".format( + indx+1, + tc.atcfid, + tc.name + )) + print("------------------------------------------------") + choice = input(" -- Enter selection ('c' to cancel): ") + while True: + if choice.isnumeric() \ + and 0 < int(choice) <= len(tcmatches): + return tcmatches[int(choice)-1] + elif len(choice) > 0 and choice.lower()[0] == "c": + raise KeyboardInterrupt + else: + choice = input(" -- Invalid selection. Try again: ") + + elif type(s) == int and s < 0: + return list(self.tc.values())[s] + # List/Tuple (storm number, tcrecord index) + elif type(s) in [tuple, list]: + if len(s) == 1: + return self[s[0]] + else: + return self[s[0]][s[1]] + elif type(s) == str: + # ATCFID + if re.search(r"^[A-Z]{2}\d{6}", s, flags=re.I): + return self.tc[str(s).upper()] + # Storm name / Starting first-letter + else: + num_name = {tc.atcfid : tc.name for tc in self.tc.values()} + for atcfid, name in {tc.atcfid : tc.name for tc in self.tc.values()}.items(): + if s.upper()[0] == name[0]: + return self.tc[atcfid] + + def stats(self, year1=None, year2=None, start=None, thru=None, width=70, report_type=print, **kw): + """Returns a report of a host of stats from the season and their ranks + relative to compared seasons. It also fully supports partial season + stats (like rank_seasons_thru). + + * Of note, this can be quite slow especially when comparing full + seasons to the full record. + + Default Arguments (all are used strictly for comparison purposes): + year1 (None): start year of the comparison. + year2 (None): end year of the comparison. + start (None): accepts a 2-member tuple representing month and day; + the start month and day for the comparison. + thru (None): accepts a 2-member tuple representing month and day; + the end month and day for the comparison. + width (70): used to control the width of the report + report_type (print): controls the format of the seasonal stats + requested. By default, it prints out to the console. if <> + (no quotations needed), it returns a stringified version of the + stats + + Keyword Arguments: + descending: bool used to determine sorting method of rank results + (defaults to True) + + Examples: + atl[1984].stats() :: Return stat-report for the 1984 season. + atl[2005].stats(1967) :: Return stat-report for 2005, compared to + seasons since 1967 (satellite era). If year2 is not specified, + the comparison would include all seasons beyond 1967, including + those beyond 2005. + atl[2020].stats(1967, start=(9,1)) :: Return a 2020 stat-report, + compared to seasons since 1967, limited from September to the + end of the year. + atl[1981].stats(1971, 1990, thru=(6,30)) :: Return a 1981 report + with comparisons to seasons between 1971 and 1990, limited to + data before July. + """ + # set bounds to years for comparison + if year1 is None: + year1 = self._hd2.record_range[0] + if year2 is None: + year2 = self._hd2.record_range[1] + + # set bound on calendar dates for comparison + if start is None: + start = (1,1) + if thru is None: + thru = (12,31) + if report_type == print: + # just print; don't return anything + self._hd2._season_stats( + self.year, + year1, + year2, + start, + thru, + width, + descending=kw.get("descending", True), + instruction=report_type + ) + else: + return self._hd2._season_stats( + self.year, + year1, + year2, + start, + thru, + width, + descending=kw.get("descending", True), + instruction=report_type + ) + + def summary(self): + """Returns a report detailing all individual systems/storms tracked + during a particular season. + """ + print("") + print("{:-^67}".format("")) + print("{:^67}".format( + "Tropical Cyclone Summary for {}".format(self.year) + )) + try: + print("{:^67}".format(self._hd2.basin(self))) + except: + pass + print("{:-^67}".format("")) + print("{:^67}".format( + "Tropical Cyclones: {} // {} TS // {} HU ({} Major)".format( + self.tracks, + self.TSreach, + self.HUreach, + self.MHUreach + ) + )) + print("{:^67}".format( + "ACE: {} * 10^4 kt^2; Track Distance (TC): {} nmi".format( + "{:>6.3f}".format(self.ACE * math.pow(10,-4)), + "{:>6.1f}".format(self.track_distance_TC) + ) + )) + print("{:-^67}".format("")) + print(" {:^10} {:^8} {:^4} {:^4} {:^4} {:^6} {:^22}".format( + "","","LAND","","","TC TRK","ENERGY INDICES" + )) + print(" {:^10} {:^8} {:^4} {:>4} {:>4} {:^6} {:^22}".format( + "","","FALL","MIN","MAX","DSTNCE","x10^4 kt^2" + )) + print(" {:<10} {:^8} {:<4} {:^4} {:^4} {:^6} {:^6} {:^6} {:^6}".format( + "NAME","ATCFID","QTY","MSLP","WIND","(nmi)","ACE","HDP","MHDP" + )) + print(" {:-^10} {:-^8} {:-^4} {:-^4} {:-^4} {:-^6} {:-^6} {:-^6} {:-^6}".format( + "","","","","","","","","" + )) + for tcid, trop in self.tc.items(): + print(" {:<10} {:8} {:^4} {:>4} {:>4} {:>6.1f} {:^6} {:^6} {:^6}".format( + trop.name.title(), + trop.atcfid, + trop.landfalls, + trop.minmslp if trop.minmslp != None else "N/A", + trop.maxwind if trop.maxwind > 0 else "N/A", + trop.track_distance_TC, + "{:>6.3f}".format(trop.ACE * math.pow(10,-4)) if trop.ACE > 0 else "--", + "{:>6.3f}".format(trop.HDP * math.pow(10,-4)) if trop.HDP > 0 else "--", + "{:>6.3f}".format(trop.MHDP * math.pow(10,-4)) if trop.MHDP > 0 else "--" + )) + print("") + + def hurdat2(self, original=False): + """ + Returns a Hurdat2-formatted string summary of the entire season. + + Default Arguments: + original (False): By default, some objective license with wind- + extents is taken. If wanting to use the original lines from the + actual ingested database, set this to True. See the + .hurdat2 docstring for a more detailed + explanation. + """ + _data = [tc.hurdat2(original) for tc in self.tc.values()] + return "\n".join(_data) + + @property + def tc_entries(self): + """ + Returns a temporally-ascending list of <>s of all + tropical cyclones occurring during the season. + """ + return sorted([ + en for tcid, TC in self.tc.items() + for en in TC.entry + if en.is_TC + ], key = lambda moment: moment.entrytime) + + @property + def tracks(self): + """Returns the total number of tropical cyclones from the season. It's + the same as calling len(self). It's included for readability in other + methods. + """ + return len(self) + + @property + def TDonly(self): + """Returns the quantity of tropical cyclones occurring during the + season that reached tropical depression designation (SD, TD) but never + strengthened to become at least a tropical storm. + """ + return self.tracks - self.TSreach + + @property + def landfalls(self): + """Returns the aggregate of all landfalls from the season made by + tropical cyclones. Keep in mind TC's can make multiple landfalls + """ + return sum([self.tc[trop].landfalls for trop in self.tc]) + + @property + def landfall_TC(self): + """Returns the quantity of tropical cyclones during the season that + recorded at least one landfall. + """ + return len(["L" for trop in self.tc if self.tc[trop].landfalls > 0]) + + @property + def landfall_TD(self): + """Returns the quantity of tropical cyclones during the season that + recorded at least one landfall as a tropical depression (SD, TD). + Exclusive of other categorized strengths. + """ + return len(["L_TD" for trop in self.tc if self.tc[trop].landfall_TD is True]) + + @property + def landfall_TS(self): + """Returns the quantity of tropical cyclones during the season that + recorded at least one landfall as a tropical storm (SS, TS). + + Exclusive of other categorized strengths. + """ + return len(["L_TS" for trop in self.tc if self.tc[trop].landfall_TS is True]) + + @property + def landfall_HU(self): + """Returns the quantity of tropical cyclones during the season that + recorded at least one landfall while designated a hurricane. + + This is inclusive of major-hurricane landfalls. + """ + return len(["L_HU" for trop in self.tc if self.tc[trop].landfall_HU is True]) + + @property + def landfall_MHU(self): + """Returns the quantity of tropical cyclones during the season that + recorded at-least one landfall as a major hurricane (>= 96kts). + """ + return len(["L_MHU" for trop in self.tc if self.tc[trop].landfall_MHU is True]) + + @property + def TSreach(self): + """Returns the quantity of tropical cyclones during the season if they + were objectively issued the status of at-least tropical storm (SS, TS, + or HU) during their life span. + """ + return len(["TS" for trop in self.tc if self.tc[trop].TSreach is True]) + + @property + def TSonly(self): + """Returns the quantity of tropical cyclones occurring during the + season that reached tropical storm designation (SS, TS) but never + became a hurricane. + """ + return self.TSreach - self.HUreach + + @property + def HUreach(self): + """Returns the quantity of tropical cyclones during the season if they + were objectively issued the status of Hurricane (HU) during their life. + + This is inclusive of those hurricanes that would eventually reach + major-hurricane status. + """ + return len(["HU" for trop in self.tc if self.tc[trop].HUreach is True]) + + @property + def HUonly(self): + """Returns the quantity of hurricanes that were only Category 1 or + Category 2 hurricanes. + + *** THIS IS DIFFERENT *** from HUreach as it EXCLUDES category 3+ + hurricanes. + """ + return self.HUreach - self.MHUreach + + @property + def MHUreach(self): + """Returns the quantity of tropical cyclones during the season that at + any point became a major hurricane (>= 96kts). + """ + return len(["MHUreach" for trop in self.tc if self.tc[trop].MHUreach is True]) + + @property + def cat45reach(self): + """Returns the quantity of tropical cyclones from the season that + reached category-4 or 5 (saffir-simpson scale) strength at any point + during its life. + """ + return len(["cat5" for tc in self.tc.values() if tc.maxwind >= 114]) + + @property + def cat5reach(self): + """Returns the quantity of tropical cyclones from the season that + reached category-5 (saffir-simpson scale) strength at any point during + its life. + """ + return len(["cat5" for tc in self.tc.values() if tc.maxwind >= 136]) + +class TropicalCyclone(_aliases.TropicalCycloneAliases, _calculations.TropicalCycloneCalculations, _reports.TropicalCycloneReports): + """Object holding data for an individual tropical cyclone.""" + def __init__(self, storm_id, storm_name, seasonobj, hd2obj): + self._atcfid = storm_id + self._atcf_num = int(storm_id[2:4]) + self._year = int(storm_id[4:]) + self._name = storm_name + self._entry = [] # List to keep track of indiv time entries + self._season = seasonobj + self._hd2 = hd2obj + + def __len__(self): + """Returns the number of record entries for the particular storm in the + Hurdat2 record. + """ + return len(self.entry) + + def __repr__(self): + return "<{} object - {}:{} - at 0x{:0>16}>".format( + re.search(r"'(.*)'", str(type(self)))[1], + self.atcfid, + self.name, + "{:X}".format(id(self)) + ) + + def __getitem__(self, indx): + return self.entry[ + int(indx) if type(indx) not in [list, tuple] else indx[0] + ] + + def stats(self): + self.info() + + def info(self): + """Prints a basic report of information on the tropical cyclone.""" + print("") + print("{:^40}".format( + "Statistics for {}{}".format( + "{} ".format( + self.status_highest if self.name != "UNNAMED" else "" + ), + self.name + ) + )) + print("{:-^40}".format("")) + print("* ATCF ID: {}".format(self.atcfid)) + print("* Track Entries: {}".format(len(self))) + print("* TC Track Distance: {:.1f} nmi".format(self.track_distance_TC)) + if self.track_distance_TS > 0: + print(" -- TS Track Distance: {:.1f} nmi".format( + self.track_distance_TS + )) + if self.track_distance_HU > 0: + print(" -- HU Track Distance: {:.1f} nmi".format( + self.track_distance_HU + )) + if self.track_distance_MHU > 0: + print(" -- MHU Track Distance: {:.1f} nmi".format( + self.track_distance_MHU + )) + if self.maxwind > 0: + print("* Peak Winds: {} kts".format(self.maxwind)) + else: + print("* Peak Winds: N/A") + print("* Minimum MSLP: {}{}".format( + self.minmslp if self.minmslp != None else "N/A", + " hPa" if self.minmslp != None else "" + )) + print("* ACE: {:.3f} * 10^4 kts^2".format( + self.ACE * math.pow(10,-4) + )) if self.ACE > 0 else print("* ACE: N/A") + if self.HDP > 0: + print("* HDP: {:.3f} * 10^4 kts^2".format( + self.HDP * math.pow(10,-4) + )) + if self.MHDP > 0: + print("* MHDP: {:.3f} * 10^4 kts^2".format( + self.MHDP * math.pow(10,-4) + )) + print("* Genesis: {:%Y-%m-%d %H}Z".format(self.start_date)) + print("* End: {:%Y-%m-%d %H}Z".format(self.end_date)) + print(" - Life as Tropical Cyclone: {} days".format(self.duration_TC)) + print("* Landfall: {}{}".format( + "Yes" if self.landfalls > 0 else "None", + ", {} Record{}".format( + self.landfalls, + "s" if self.landfalls > 1 else "" + ) if self.landfalls > 0 else "" + )) + print("") + + def summary(self): + """Prints a detailed report for all entries recorded during the + system's life-span. + + Vector information is calculated using the previous entry as the + initial point. + """ + + print("") + print(" {:-^79}".format("")) + print(" {:^79}".format( + "Track Summary for '{}', {}".format( + self.atcfid, + self.name + ) + )) + print(" {:-^79}".format("")) + print("\n".join([ + " ENTRY LAND LOCATION VECTOR INTENSITY", + " INDEX DATE FALL LAT LON DIR SPD MSLP WIND SAFFIR STATUS", + " ----- ---------------- ---- ----- ------- --- --- ---- ---- ------ ------" + ])) + for en in self.entry: + print(" {:^5} {:%Y-%m-%d %H%M}Z {:^4} {:>5} {:>7} {:^3} {:^3} {:>4} {:>4} {:^6} {:^6}".format( + self.entry.index(en), + en.entrytime, + en.record_identifier if en.record_identifier == "L" else "", + en.lat_str, + en.lon_str, + en.direction(True) if en.direction() is not None else "N/A", + int(en.speed) if en.speed is not None else "N/A", + en.mslp if en.mslp is not None else "N/A", + en.wind, + "" if en.saffir_simpson <= 0 + else en.saffir_simpson if ( + en.previous_entry is not None + and en.saffir_simpson != en.previous_entry.saffir_simpson + ) else "\u02dd", + "MHU" if en.wind >= 96 and en.status == "HU" else en.status + )) + print("") + + def hurdat2(self, original=False): + """ + Returns a Hurdat2-formatted string summary of the tropical cyclone. + + Default Arguments: + original (False): By default, some objective license with wind- + extents is taken. If wanting to use the original line from the + actual ingested database, set this to True. See the + .hurdat2 docstring for a more detailed + explanation. + """ + _data= [ + "{:>8},{:>19},{:>7},".format( + self.atcfid, + self.name, + len(self.entry) + ) + ] + _data.extend( + en.hurdat2(original) for en in self.entry + ) + return "\n".join(_data) + + @property + def tc_entries(self): + """ + Returns a list of <>'s where the storm is designated a + tropical cyclone. + """ + return [ + en for en in self.entry + if en.is_TC + ] + + @property + def gps(self): + """Return a list of tuples containing the gps coordinates of the + tropical cyclone's track + """ + return [en.location for en in self.entry] + + @property + def minmslp(self): + """Returns the minimum mean sea-level pressure (MSLP) recorded during + the life of the storm. + + If insufficient data exists to determine MSLP, None will be returned. + """ + return min( + [en.mslp for en in self.entry if en.mslp != None], + default=None + ) + + @property + def maxwind(self): + """Returns the max peak-wind recorded during the life of the storm.""" + return max(en.wind for en in self.entry) + + @property + def max_maxwind_radius(self): + """ + Returns the maximum radius of maximum winds recorded during the life of + the storm. + """ + return max([en.maxwind_radius for en in self.entry if en.maxwind_radius is not None], default=None) + + @property + def landfalls(self): + """Returns the QUANTITY of landfalls recorded made by the system + as a tropical cyclone. + """ + return len([ + "L" for en in self.entry + if en.record_identifier == "L" + and en.is_TC + ]) + + @property + def landfall_TC(self): + """Bool indicating whether at-least one landfall was made while a + tropical cyclone. + """ + return self.landfalls > 0 + + @property + def landfall_TD(self): + """Bool indicating whether at-least one landfall was made while a + tropical depression. + """ + return any( + en.record_identifier == "L" + for en in self.entry + if en.status in ["SD","TD"] + ) + + @property + def landfall_TS(self): + """Bool indicating whether at-least one landfall was recorded by the + tropical cyclone while designated as a tropical storm (TS) or + sub-tropical storm (SS). + """ + return any( + en.record_identifier == "L" + for en in self.entry + if en.status in ["SS","TS"] + ) + + @property + def landfall_HU(self): + """Bool indicating whether at-least one landfall was recorded by the + tropical cyclone while designated as a Hurricane. + """ + return any( + en.record_identifier == "L" + for en in self.entry + if en.status == "HU" + ) + + @property + def landfall_MHU(self): + """Bool indicating whether at-least one landfall was recorded by the + tropical cyclone while a hurricane at major-hurricane strength + (>= 96kts). + """ + return any( + en.record_identifier == "L" + for en in self.entry + if en.wind >= 96 and en.status == "HU" + ) + + @property + def TSreach(self): + """Bool indicating whether the storm was ever objectively designated as + a tropical storm (TS) or sub-tropical storm (SS). Hurricane's (HU) are + tested for as well with an explanation below. + + The inclusivity of hurricanes may seem a bit-too overzealous, as a + tropical cyclone MUST become a tropical storm before it could become a + hurricane since max-wind tendency is a continuous function. But in + HURDAT2, they are represented as discrete or time-stepped. Because of + this, though exceptionally rare, it is possible for a storm to have a + hurricane entry but zero tropical storm entries. For example, in the + Atlantic HURDAT2, this occurrence happens, but virtually all storms of + this nature occur before 1900. + """ + return any(en.status in ["TS","SS","HU"] for en in self.entry) + + @property + def HUreach(self): + """Bool indicating whether the storm was ever objectively designated as + a hurricane (HU). + """ + return any(en.status == "HU" for en in self.entry) + + @property + def MHUreach(self): + """Bool indicating whether the storm ever reached major hurricane + status (>= 96kts). + """ + return any(en.wind >= 96 for en in self.entry if en.status == "HU") + + @property + def cat45reach(self): + """Returns a bool indicating if the tropical cyclone ever reached at- + least Category 4 strength during its life. + """ + return any(en.wind >= 114 for en in self.entry if en.status == "HU") + + @property + def cat5reach(self): + """Returns a bool indicating if the tropical cyclone ever reached + Category 5 strength during its life. + """ + return any(en.wind >= 136 for en in self.entry if en.status == "HU") + + @property + def maxwind_mslp(self): + """Returns the MSLP recorded at the time of the tropical cyclone's peak + wind-based intensity. This attribute was included as peak-winds and + minimum MSLP, though closely related, may not necessarily occur at the + same time. + """ + return max( + filter( + lambda en: en.wind is not None, + self.entry + ), + key = lambda en: en.wind, + default=None + ).mslp + + @property + def minmslp_wind(self): + """Returns the wind recorded at the time of the tropical cyclone's + minimum MSLP reading. This attribute was included as peak-winds and + minimum MSLP, though closely related, may not necessarily occur at the + same time. + """ + return min( + filter( + lambda en: en.mslp is not None, + self.entry + ), + key = lambda en: en.mslp, + default=None + ).wind + + @property + def statuses_reached(self): + """Returns a list of all designated statuses during the tropical + cyclone's life. + """ + return list(set([ + en.status for en in self.entry + ])) + + @property + def status_highest(self): + """ + Returns a readable descriptor for the storm based on its highest-order + status designated. + + Examples + ------- + TS -> 'Tropical Storm' + HU -> 'Hurricane' + HU and self.maxwind >= 96 -> 'Major Hurricane' + """ + order = ["HU", "TS", "SS", "TD", "SD", "EX", "LO", "DB"] + for status in order: + if status in self.statuses_reached: + return format_status(status, self.maxwind) + +class TCRecordEntry(_aliases.TCEntryAliases, _calculations.TCEntryCalculations): + """Object that holds information from one individual (one line) HURDAT2 + entry. + """ + + __slots__ = [ + "_entrytime", "_record_identifier", "_status", + "_lat_str", "_lon_str", "_location", "_lat", "_lon", + "_wind", "_status_desc", "_mslp", + "_tsNE", "_tsSE", "_tsSW", "_tsNW", + "_ts50NE", "_ts50SE", "_ts50SW", "_ts50NW", + "_huNE", "_huSE", "_huSW", "_huNW", "_maxwind_radius", + "_tc", "_season", "_hd2", "_hurdat2line" + ] + + TCRecordLine = collections.namedtuple( + "TCRecordLine", + [ + "day", "time", "record_identifier", "status", + "latitude", "longitude", "wind", "mslp", + "tsNE", "tsSE", "tsSW", "tsNW", + "ts50NE", "ts50SE", "ts50SW", "ts50NW", + "huNE", "huSE", "huSW", "huNW", "maxwind_radius" + ], + # defaults necessary to maintain backward compatibility + # This would be backward compatible + defaults = (None, None, None, None, None) + ) + + def __init__(self, tc_entry, hurdat2line, tcobj, seasonobj, hd2obj): + + tcentry = self.TCRecordLine(*tc_entry) + + # The original hurdat2 line that this entry was created from + self._hurdat2line = hurdat2line + + # Date + self._entrytime = datetime.datetime( + int(tcentry[0][:4]), #year + int(tcentry[0][4:6]), #month + int(tcentry[0][-2:]), #day + int(tcentry[1][:2]), + int(tcentry[1][-2:]), + tzinfo = datetime.timezone.utc + ) + + self._record_identifier = tcentry[2] if tcentry[2] != '' else None + self._status = tcentry[3] + self._lat_str = tcentry[4] + self._lon_str = tcentry[5] + self._lat = coord_conv(self.lat_str) + self._lon = coord_conv(self.lon_str) + self._wind = int(tcentry[6]) + self._status_desc = format_status(self.status, self.wind) + self._mslp = int(tcentry[7]) if tcentry[7] != '-999' else None + # Extent Indices - 0 = NE, 1 = SE, 2 = SW, 3 = NW + # Tropical Storm extents + self._tsNE = int(tcentry[8]) \ + if tcentry[8] != "-999" \ + else 0 if self._wind < 34 \ + else None + self._tsSE = int(tcentry[9]) \ + if tcentry[9] != "-999" \ + else 0 if self._wind < 34 \ + else None + self._tsSW = int(tcentry[10]) \ + if tcentry[10] != "-999" \ + else 0 if self._wind < 34 \ + else None + self._tsNW = int(tcentry[11]) \ + if tcentry[11] != "-999" \ + else 0 if self._wind < 34 \ + else None + # 50kt extents + self._ts50NE = int(tcentry[12]) \ + if tcentry[12] != "-999" \ + else 0 if self._wind < 50 \ + else None + self._ts50SE = int(tcentry[13]) \ + if tcentry[13] != "-999" \ + else 0 if self._wind < 50 \ + else None + self._ts50SW = int(tcentry[14]) \ + if tcentry[14] != "-999" \ + else 0 if self._wind < 50 \ + else None + self._ts50NW = int(tcentry[15]) \ + if tcentry[15] != "-999" \ + else 0 if self._wind < 50 \ + else None + # Hurricane extents + self._huNE = int(tcentry[16]) \ + if tcentry[16] != "-999" \ + else 0 if self._wind < 64 \ + else None + self._huSE = int(tcentry[17]) \ + if tcentry[17] != "-999" \ + else 0 if self._wind < 64 \ + else None + self._huSW = int(tcentry[18]) \ + if tcentry[18] != "-999" \ + else 0 if self._wind < 64 \ + else None + self._huNW = int(tcentry[19]) \ + if tcentry[19] != "-999" \ + else 0 if self._wind < 64 \ + else None + self._maxwind_radius = int(tcentry[20]) \ + if len(tcentry) >= 21 \ + and tcentry[20] not in ["-999", None] \ + else None + + # Record parent objects + self._tc = tcobj + self._season = seasonobj + self._hd2 = hd2obj + + def __repr__(self): + return "<{} object - {}:{} - Index {}: {:%Y%m%d %H%MZ} - at 0x{:0>16}>".format( + re.search(r"'(.*)'", str(type(self)))[1], + self._tc.atcfid, + self._tc.name, + self._tc.entry.index(self), + self.date, + "{:X}".format(id(self)) + ) + + @property + def location(self): + """ + Returns a tuple of the latitude and longitude (in decimal degrees and + in that respective order) for this entry. + """ + return (self.lat, self.lon) + + @property + def location_reversed(self): + """ + Returns a tuple of the longitude and latitude (in decimal degrees and + in that respective order) for this entry. + + This was included as GIS programs seem to prefer this order. + """ + return (self.lon, self.lat) + + @property + def is_TC(self): + """Returns whether or not the storm was designated as a tropical + cyclone at the time of this <>. + + The entry status must be one of the following: "SD", "TD", "SS", "TS", "HU". + """ + return self.status in ["SD", "TD", "SS", "TS", "HU"] + + @property + def is_synoptic(self): + """Returns whether or not the <>.entrytime is considered + to be synoptic. + + To be True, it must have a recorded hour of 0Z, 6Z, 12Z, or 18Z 'on the + dot' (minute, second == 0). + + This is helpful in calculating energy indices. + """ + return self.hour in [0, 6, 12, 18] and self.minute == 0 + + @property + def previous_entries(self): + """ + Returns a list of preceding s in the parent + .entry list. + """ + return self._tc.entry[0:self._tc.entry.index(self)] + + @property + def previous_entry(self): + """ + Returns the that occurred PREVIOUS (preceding this + entry) in the parent .entry list. Returns None if it + is the first index (index 0). + """ + if self._tc.entry.index(self)-1 >= 0: + return self._tc[self._tc.entry.index(self)-1] + else: + return None + + @property + def next_entries(self): + """ + Returns a list of succeeding s in the parent + .entry list. + """ + return self._tc.entry[self._tc.entry.index(self)+1:] + + @property + def next_entry(self): + """ + Returns the that occurs NEXT (following this entry) in + the parent .entry list. Returns None if it is the last + entry. + """ + try: + return self._tc[self._tc.entry.index(self)+1] + except: + return None + + def hurdat2(self, original=False): + """ + Returns a string of a hurdat2-formatted line of the entry information. + + A few minor differences will exist between this output and the actual + line found in the hurdat2 database. If using an older hurdat2 database + (prior to 2022 release), it won't have maxwind radii available. Though + this field is not part of that older database, this method will report + it as null ('-999'). + + Also, wind extent information will likely be + different. This is because upon ingest, this module infers non- + applicable wind-extents as 0. For example, a tropical storm, having + winds < 64kt, will objectively have a hurricane wind-extent of 0, but + for cyclones that occurred before 2004, they are recorded in the + database as -999 (null or not-available). It mostly is an + inconsequential approach, but oh well. + + One other possible difference would occur if this version of the module + is used with future hurdat2 databases that include more variables + (which this version of the module would be oblivious to). + + Continue reading on how to return the original line. + + Default Argument: + original (False): if True, the original line recorded from the + hurdat2 database will be used. + """ + if original: + return self._hurdat2line + else: + return "{:>8},{:>5},{:>2},{:>3},{:>6},{:>7},{:>4},{:>5},".format( + "{:%Y%m%d}".format(self.entrytime), + "{:%H%M}".format(self.entrytime), + "" if self.record_identifier != "L" else "L", + self.status, + self.lat_str, + self.lon_str, + self.wind, + self.mslp if self.mslp is not None else -999, + ) + "{:>5},{:>5},{:>5},{:>5},".format( + *[quad if quad is not None else -999 for quad in self.extent_TS] + ) + "{:>5},{:>5},{:>5},{:>5},".format( + *[quad if quad is not None else -999 for quad in self.extent_TS50] + ) + "{:>5},{:>5},{:>5},{:>5},".format( + *[quad if quad is not None else -999 for quad in self.extent_HU] + ) + "{:>5},".format(self.maxwind_radius if self.maxwind_radius is not None else -999) + + @property + def extent_TS(self): + """ + Returns a list of recorded quadrant-based tropical storm wind-extents + for this entry. The results are ordered NE, SE, SW, and NW. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + + Units are in nautical miles. + """ + return [self.tsNE, self.tsSE, self.tsSW, self.tsNW] + + @property + def extent_TS50(self): + """ + Returns a list of recorded quadrant-based 50kt+ wind-extents for this + entry. The results are ordered NE, SE, SW, and NW. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + + Units are in nautical miles. + """ + return [self.ts50NE, self.ts50SE, self.ts50SW, self.ts50NW] + + @property + def extent_HU(self): + """ + Returns a list of recorded quadrant-based hurricane-force wind-extents + for this entry. The results are ordered NE, SE, SW, and NW. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + + Units are in nautical miles. + """ + return [self.huNE, self.huSE, self.huSW, self.huNW] + +def coord_conv(coordstr): + """ + Takes a hurdat2-formatted lat/lon coordinate and returns a float + representation thereof. + + Example: + coord_conv("26.1N") --> 26.1 + coord_conv("98.6W") --> -98.6 + """ + if coordstr[-1] in ["N", "E"]: + return round(float(coordstr[:-1]), 1) + else: + return round(-1 * float(coordstr[:-1]), 1) + +def format_record_identifier(ri): + """Returns a description about an entry's record_identifier. + + Definitions/interpretations found in hurdat2-format pdf found online. + """ + if ri == "L": return "Landfall" + elif ri == "W": return "Maximum sustained wind speed" + elif ri == "P": return "Minimum in central pressure" + elif ri == "I": return "An intensity peak in terms of both pressure and wind" + elif ri == "C": return "Closest approach to a coast, not followed by a landfall" + elif ri == "S": return "Change of status of the system" + elif ri == "G": return "Genesis" + elif ri == "T": return "Provides additional detail on the track (position) of the cyclone" + else: return "* No Description Available *" + +def format_status(status, wind): + """Returns a description about a record's 2-letter status. + + Definitions/interpretations found in hurdat2-format pdf found online. + """ + if status == "DB" or status == "LO" or status == "WV": return "Disturbance, Low, or Tropical Wave" + elif status == "SD": return "Subtropical Depression" + elif status == "TD": return "Tropical Depression" + elif status == "SS": return "Subtropical Storm" + elif status == "TS": return "Tropical Storm" + elif status == "EX": return "Extratropical Cyclone" + elif status == "HU" and wind < 96: return "Hurricane" + elif status == "HU" and wind >= 96: return "Major Hurricane" + else: return "Unknown" diff --git a/hurdat2parser/_aliases.py b/hurdat2parser/_aliases.py new file mode 100644 index 0000000..141e773 --- /dev/null +++ b/hurdat2parser/_aliases.py @@ -0,0 +1,414 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + + +class Hurdat2Aliases: + + @property + def tc(self): + return self._tc + + @property + def season(self): + return self._season + +class SeasonAliases: + + @property + def year(self): + return self._year + + @property + def tc(self): + return self._tc + + # Energy Indices lower-case shortcuts + @property + def ace(self): + return self.ACE + + @property + def hdp(self): + return self.HDP + + @property + def mhdp(self): + return self.MHDP + + @property + def genesis_entry(self): + """The of the birth of the seasons.""" + return self.start_date_entry + + @property + def genesis(self): + """The moment (datetime) that the season began.""" + return self.start_date + +class TropicalCycloneAliases: + + @property + def atcfid(self): + return self._atcfid + + @property + def atcf_num(self): + return self._atcf_num + + @property + def storm_number(self): + return self.atcf_num + + @property + def year(self): + return self._year + + @property + def name(self): + return self._name + + @property + def entry(self): + return self._entry + + @property + def genesis_entry(self): + """The of the birth of the cyclone.""" + return self.start_date_entry + + @property + def genesis(self): + """The moment (datetime) of the birth of the cyclone.""" + return self.start_date + + # Energy Indices lower-case shortcuts + @property + def ace(self): + return self.ACE + + @property + def hdp(self): + return self.HDP + + @property + def mhdp(self): + return self.MHDP + + @property + def max_rmw(self): + """ + Returns the maximum radius of maximum winds recorded during the life of + the storm. + """ + return self.max_maxwind_radius + +class TCEntryAliases: + __slots__ = [] + + @property + def index(self): + """ + Returns the index that this object appears in the parent + .entry list. + """ + return self._tc.entry.index(self) + + # Datetime stuff + @property + def entrytime(self): + """Returns the datetime.datetime for this entry.""" + return self._entrytime + + @property + def time(self): + """Returns the datetime.datetime for this entry.""" + return self.entrytime + + @property + def date(self): + """Returns the datetime.datetime for this entry.""" + return self.entrytime + + @property + def hour(self): + """Returns the recorded hour of this entry.""" + return self.entrytime.hour + + @property + def minute(self): + """Returns the recorded minute of this entry.""" + return self.entrytime.minute + + @property + def month_day_tuple(self): + """Returns a tuple of the month and day of the month for this entry.""" + return (self.date.month, self.date.day) + + # Stats + @property + def category(self): + """Alias for saffir simpson rating.""" + return self.saffir_simpson + + @property + def record_identifier(self): + """ + Returns the record identifier (think Landfall indicator) for this + entry. + """ + return self._record_identifier + + @property + def status(self): + """ + Returns the designated storm status acquired at the time of this entry. + """ + return self._status + + @property + def lat_str(self): + """Returns the Hurdat2-formatted latitude string for this entry.""" + return self._lat_str + + @property + def lon_str(self): + """Returns the Hurdat2-formatted longitude string for this entry.""" + return self._lon_str + + + @property + def lat(self): + """Returns the latitude coordinate in decimal degrees for this entry.""" + return self._lat + + @property + def latitude(self): + """Returns the latitude coordinate in decimal degrees for this entry.""" + return self.lat + + @property + def lon(self): + """Returns the longitude coordinate in decimal degrees for this entry.""" + return self._lon + + @property + def longitude(self): + """Returns the longitude coordinate in decimal degrees for this entry.""" + return self.lon + + @property + def location_rev(self): + return self.location_reversed + + @property + def wind(self): + """ + Returns the recorded maximum sustained winds in knots for this entry. + """ + return self._wind + + @property + def status_desc(self): + """ + Returns a readable description of the designated status of the storm at + the time of this entry. + """ + return self._status_desc + + @property + def mslp(self): + """Returns the Mean Sea Level Pressure in hPa (same as mb).""" + return self._mslp + + # extent_TS + @property + def tsNE(self): + """ + Returns the tropical storm-strength (>= 34kts) wind extent experienced + in the cyclone's northeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._tsNE + + @property + def tsSE(self): + """ + Returns the tropical storm-strength (>= 34kts) wind extent experienced + in the cyclone's southeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._tsSE + + @property + def tsSW(self): + """ + Returns the tropical storm-strength (>= 34kts) wind extent experienced + in the cyclone's southwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._tsSW + + @property + def tsNW(self): + """ + Returns the tropical storm-strength (>= 34kts) wind extent experienced + in the cyclone's northwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._tsNW + + # extent_TS50 + @property + def ts50NE(self): + """ + Returns the 50kt+ wind extent found in the cyclone's northeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._ts50NE + + @property + def ts50SE(self): + """ + Returns the 50kt+ wind extent found in the cyclone's southeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._ts50SE + + @property + def ts50SW(self): + """ + Returns the 50kt+ wind extent found in the cyclone's southwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._ts50SW + + @property + def ts50NW(self): + """ + Returns the 50kt+ wind extent found in the cyclone's northwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._ts50NW + + # extent_HU + @property + def huNE(self): + """ + Returns the hurricane-force (>= 64kts) wind extent experienced in the + cyclone's northeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._huNE + + @property + def huSE(self): + """ + Returns the hurricane-force (>= 64kts) wind extent experienced in the + cyclone's southeast quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._huSE + + @property + def huSW(self): + """ + Returns the hurricane-force (>= 64kts) wind extent experienced in the + cyclone's southwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._huSW + + @property + def huNW(self): + """ + Returns the hurricane-force (>= 64kts) wind extent experienced in the + cyclone's northwest quadrant. + + Of note: as of the most-recent hurdat2 database releases, these extents + are only available for cyclones occurring since 2004. + """ + return self._huNW + + @property + def maxwind_radius(self): + """ + Returns the radius from the center where the maximum winds are being + experienced in nautical miles. + + Of note: as of the most-recent hurdat2 database releases, this variable + is present for all cyclones since 2021. Select cyclones from previous + years may also have this available. + """ + return self._maxwind_radius + + @property + def rmw(self): + """ + Returns the radius from the center where the maximum winds are being + experienced in nautical miles. (Also known as Radius of Maximum Winds) + + Of note: as of the most-recent hurdat2 database releases, this variable + is present for all cyclones since 2021. Select cyclones from previous + years may also have this available. + """ + return self.maxwind_radius + + + + + + + + + + + + + + + + + diff --git a/hurdat2parser/_calculations.py b/hurdat2parser/_calculations.py new file mode 100644 index 0000000..3c0bdc9 --- /dev/null +++ b/hurdat2parser/_calculations.py @@ -0,0 +1,2148 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import statistics +import math +import textwrap +import datetime +import calendar +import collections +import secrets +import operator + +from . import _gis + +class Hurdat2Calculations: + + def random(self): + """ + Returns a random object from the database. + """ + return secrets.choice(list(self.tc.values())) + + def rank_seasons(self, quantity, stattr, year1=None, year2=None, descending=True, **kw): + """Rank and compare full tropical cyclone seasons to one another. + + Required Arguments: + quantity: how long of a list of ranks do you want; an integer. + stattr: the storm attribute that you'd like to rank seasons by. + + * Storm Attributes: + "tracks", "landfall_TC", "TSreach", "HUreach", "MHUreach", + "track_distance_TC", "ACE", "track_distance_TS", "HDP", + "track_distance_HU", "MHDP", "track_distance_MHU" + + * Note: Other <> attributes are valid to rank by, but their quantities will not be visible in the ranking output. + + Default Arguments: + year1 (None): begin year. If included, the indicated year will + represent the low-end of years to assess. In the absence of + the end-year, all years from this begin year to the end of the + record-range will be used in ranking. + year2 (None): end year. If included, the indicated year will + represent the upper-end of years to assess. In the absence of + the begin-year, all years from the start of the record-range + to this indicated year will be used in ranking. + descending (True): bool to indicate sorting seasons in descending + (higher-to-lower) or not. The default of True implies seasons + will be ranked from higher-to-lower. + method ("D"): what ranking method to use. "D" (the default) will + report dense (quantity-based) ranks, while "C" will report + competition-method ranks. + + * (D)ense: rank-placement will be based on their quantities. + For example, if a season has the 3rd highest quantity of a + value, its rank will be 3, regardless of the number of + seasons that rank higher. + * (C)ompetiton: rank-placement will be based on the season + compared to other seasons. For example, though a season may + have the 3rd highest value, its rank could be 28th because + there could be 27 seasons that have a higher value. This is + common in sports (golf as a prime example). + + Examples: + --------- + .rank_seasons(10,"ACE"): Retrieve a report of tropical + cyclone seasons sorted by the top-10 Accumulated Cyclone + Energy values. + .rank_seasons(15,"HDP",1967): Retrieve a report of tropical + cyclone seasons sorted by the top-15 Hurricane Destruction + Potential values occurring since 1967 (the beginning of the + satellite era). + .rank_seasons(5,"track_distance_TS",1951,2000,True): + Retrieve a report of the bottom-5 seasons of distance + traversed by, at-least, tropical storms, all between 1951 and + 2000. + .rank_seasons(10,"HUreach",year2=2000): Retrieves a report + of the top-10 seasons with the most Hurricanes prior-to, and + including the year 2000. + """ + from .__init__ import Season, TropicalCyclone + + class DerivedTropicalCyclone(TropicalCyclone): + @property + def track_distance(self): + """Returns the distance (in nmi) traversed by the system, regardless of + status (whether or not the system is designated as a tropical cyclone). + """ + return sum( + haversine(en.location, en.next_entry.location) + for en in self.entry + if en.next_entry is not None + ) + + @property + def track_distance_TC(self): + """The distance (in nmi) trekked by the system when a designated + tropical cyclone (status as a tropical or sub-tropical depression, a + tropical or sub-tropical storm, or a hurricane). + """ + return sum( + haversine(en.location, en.next_entry.location) + for en in self.entry + if en.next_entry is not None + and en.is_TC + ) + + @property + def track_distance_TS(self): + """The distance (in nmi) trekked by the system while a tropical storm + or hurricane. + """ + return sum( + haversine(en.location, en.next_entry.location) + for en in self.entry + if en.next_entry is not None + and en.status in ["SS", "TS", "HU"] + ) + + @property + def track_distance_HU(self): + """The distance (in nmi) trekked by the system while a hurricane.""" + return sum( + haversine(en.location, en.next_entry.location) + for en in self.entry + if en.next_entry is not None + and en.status == "HU" + ) + + @property + def track_distance_MHU(self): + """The distance (in nmi) trekked by the system while a major + hurricane. + """ + return sum( + haversine(en.location, en.next_entry.location) + for en in self.entry + if en.next_entry is not None + and en.wind >= 96 + and en.status == "HU" + ) + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + + rank_method = str(kw.get("method", "D")) + if len(rank_method) > 0 and rank_method[0] in ["C", "c"]: + rank_method = "C" + else: + rank_method = "D" + + # Partial-Season Bookened Month, Day Tuples + start = kw.get("start", (1,1)) + thru = kw.get("thru", (12,31)) + + # error if thru or start are not list/tuples + if type(thru) not in [list,tuple]: + return print("OOPS! Ensure thru is a list or tuple of (month,day)") + if type(start) not in [list,tuple]: + return print("OOPS! Ensure start is a list or tuple of (month,day)") + + start = tuple(start) + thru = tuple(thru) + + partyear = False + + rseason = {} + + infoseason = None + valid_seasons = [s for s in self.season.values() if year1 <= s.year <= year2] + + # account for a non-existent season being requested by stats method + if all([ + kw.get("info") is not None, + kw.get("info") not in self.season + ]): + infoseason = Season(kw.get("info"), self) + valid_seasons.append(infoseason) + + # Full year being asked for + if start == (1,1) and thru == (12,31): + # List seasons sorted by stattr + sorted_seasons = sorted( + valid_seasons, + key=lambda czen: getattr(czen, stattr), + reverse = descending + ) + # Values sorted + ranks = sorted( + [ + getattr(s, stattr) + for s in sorted_seasons + if descending is False + or ( + getattr(s, stattr) > 0 + and kw.get("info") is None + ) or kw.get("info") is not None + ], + reverse = descending + ) + # partial year + else: + partyear = True + rseason = {} + for season in [ + s for s in self.season.values() \ + if year1 <= s.year <= year2 \ + or ( + kw.get("info") is not None \ + and s.year == kw.get("info") + ) + ]: + if season.year not in rseason: + rseason[season.year] = Season(season.year, self) + for tcyc in season.tc.values(): + for en in tcyc.entry: + if start <= en.month_day_tuple <= thru: + # ensure cyclone exists in rseason + if tcyc.atcfid not in rseason[season.year].tc: + rseason[season.year].tc[tcyc.atcfid] = DerivedTropicalCyclone( + tcyc.atcfid, + tcyc.name, + rseason[season.year], + self + ) + # append the entry + # BUT !!!! What about handling of Track Distance related vars? + # if INDX >= 1 and start <= tc.entry[INDX-1].month_day_tuple <= thru ???? + rseason[season.year].tc[tcyc.atcfid]._entry.append(en) + # append missing (info) season to rseason so next command will work + if kw.get("info") and kw.get("info") not in rseason: + rseason[kw.get("info")] = Season(kw.get("info"), self) + sorted_seasons = sorted( + valid_seasons, + key=lambda s: getattr(rseason[s.year], stattr), + reverse = descending + ) + # Values sorted + ranks = sorted( + [ + getattr(rseason[s.year], stattr) + for s in sorted_seasons + if descending is False + or ( + getattr(rseason[s.year], stattr) > 0 + and kw.get("info") is None + ) or kw.get("info") is not None + ], + reverse = descending + ) + # return rseason + + # List that holds printed quantities + printedqty = [] + + # RETURN if info method called this method + if kw.get("info", None) is not None: + stat_season_obj = infoseason if infoseason is not None \ + else rseason[kw.get("info")] if partyear \ + else self.season[kw.get("info")] + if (year1 <= kw["info"] <= year2) is False: + ranks = sorted( + set(ranks + [getattr(stat_season_obj, stattr)]), + reverse = descending + ) + + return { + "seasonvalu": getattr(stat_season_obj, stattr), + "rank": sorted(set(ranks), reverse=descending).index(getattr(stat_season_obj, stattr)) + 1, + "tied": len([ + "tie" for season in ( + rseason.values() if partyear else self.season.values() + ) if getattr(season, stattr) == getattr(stat_season_obj, stattr) + ]) - 1, + "outof": len(sorted(set(ranks),reverse=descending)), + # the .index() method works because it finds the index of the first inst. + "golf_rank": ranks.index(getattr(stat_season_obj, stattr)) + 1, + "golf_outof": len(ranks) - len([valu for valu in ranks if valu == ranks[-1]]) + 1, + } + + print("") + print("TOP {} SEASONS RANKED BY {}{}".format( + quantity, + stattr.upper(), + "" if partyear is False + else ", {}{}".format( + "from {} {}".format( + calendar.month_abbr[start[0]], start[1] + ) if start != (1,1) else "", + "{}through {} {}".format( + " " if start != (1,1) else "", + calendar.month_abbr[thru[0]] + if thru != (12,31) else "the End of", + thru[1] + if thru != (12,31) else "Season" + ) + ), + ).center(79) + ) + + print("{}{}".format( + str(self.basin()), + ", {}-{}".format(year1, year2) + ).center(79)) + + print( + "{} Rankings".format( + "Dense" if rank_method == "D" else "Competition" + ).center(79) + ) + print("-" * 79) + + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","","LAND","QTY","","","TC DIST", + "STATUS-RELATED TRACK" if "track_distance" in stattr else "ENERGY INDICES" + )) + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","NUM OF","FALL","TRPC","QTY","QTY","TRAVRSD", + "DISTANCES (nmi)" if "track_distance" in stattr else "x10^4 kt^2" + )) + print("RANK YEAR {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^7} {:^7} {:^7}".format( + "TRACKS","TCs","STRM","HURR","MAJ","(nmi)", + "TRPCSTM" if "track_distance" in stattr else "ACE", + "HURRICN" if "track_distance" in stattr else "HDP", + "MAJHURR" if "track_distance" in stattr else "MHDP" + )) + print("{:-^4} {:-^4} {:-^6} {:-^4} {:-^4} {:-^4} {:-^3} {:-^7} {:-^7} {:-^7} {:-^7}".format( + "","","","","","","","","","","" + )) + + # set up ranks for default dense mode (1-2-3-4) + if rank_method == "D": + ranks = sorted(set(ranks), reverse=descending) + + for season in sorted_seasons: + # only print stats if ordering by least-to-greatest + # or if greatest-to-least at stat != 0 + if descending is False or ( + partyear is False and getattr(season, stattr) != 0 + or + partyear is True and getattr(rseason[season.year], stattr) != 0 + ): + season_obj = rseason[season.year] if partyear else season + + current_rank = ranks.index(getattr(season_obj, stattr)) + 1 \ + if ranks.index(getattr(season_obj, stattr)) + 1 \ + not in printedqty else None + if current_rank is not None and current_rank > quantity: + break + + print("{:>3}{:1} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:>7.1f} {:>{ACELEN}f} {:>{ACELEN}f} {:>{ACELEN}f}".format( + current_rank if current_rank is not None else "", + "." if current_rank is not None else "", + season.year, + season_obj.tracks, + season_obj.landfall_TC, + season_obj.TSreach, + season_obj.HUreach, + season_obj.MHUreach, + season_obj.track_distance_TC, + season_obj.track_distance_TS if "track_distance" in stattr else season_obj.ACE * math.pow(10,-4), + season_obj.track_distance_HU if "track_distance" in stattr else season_obj.HDP * math.pow(10,-4), + season_obj.track_distance_MHU if "track_distance" in stattr else season_obj.MHDP * math.pow(10,-4), + ACELEN = 7.1 if "track_distance" in stattr else 7.3 + )) + if current_rank is not None and current_rank not in printedqty: + printedqty.append(current_rank) + print("") + + def rank_storms(self, quantity, stattr, year1=None, year2=None, coordextent=None, contains_method="anywhere"): + """Rank and compare individual tropical cyclones to one another. + + Required Arguments: + quantity: how long of a list of ranks do you want; an integer. + stattr: the storm attribute that you'd like to rank seasons by. + + * Working Storm Attributes for ranking: + "track_distance_TC", "landfalls", "maxwind", "minmslp", + "ACE", "track_distance_TS", "HDP", "track_distance_HU", + "MHDP", "track_distance_MHU" + + * The following attributes will not work because at the + individual storm level these are bools: + "landfall_TC", "landfall_TD", "landfall_TS", "landfall_HU", + "landfall_MHU", "TSreach", "HUreach", "MHUreach", + "cat45reach", "cat5reach" + + * Other attributes of class TropicalCyclone that are not + mentioned here will work for ranking too, but their actual + values will not display on the printed report. + + Default Arguments: + year1 (None): begin year. If included, the indicated year will + represent the low-end of years to assess. In the absence of + the end-year, all years from this begin year to the end of the + record-range will be used to determine ranking. + year2 (None): end year. If included, the indicated year will + represent the upper-end of years to assess. In the absence of + the begin-year, all years from the start of the record-range + to this indicated year will be used to determine ranking. + coordextent (None): **EXPERIMENTAL** This accepts 2 tupled latitude + and longitude coordinates, representing a geographical + bounding-box. The use of this bounding-box is determined by the + kwarg, contains_method. See the documentation for determination + of use. The results from using these two arguments only + indicates that the track of the storm identified *AT SOME + POINT* tracked into this bounding-box. It in no way indicates + that the ranked value occurred within. + contains_method ("anywhere"): if a coordinate extent is included (see + above), this default argument determines this method's + strategy. The default of 'anywhere' implies that all matching + storms will be further discriminated by whether or not any point of their track occurred within the bounding-box (coordextent). A value of "start" means if the start of the storm's track occurred in the bounding-box. + + Examples: + --------- + .rank_storms(10, "ACE"): Retrieve a report of tropical + cyclones sorted by the top-10 values of Accumulated Cyclone + Energy on record. + .rank_storms(20, "HDP", 1967): Retrieve a report of tropical + cyclones sorted by the top-20 values of Hurricane Destruction + Potential since 1967 (the beginning of the satellite era). + .rank_storms(5, "minmslp", 1901, 1940): Retrieve a report of the + top-5 tropical cyclones with the lowest minimum pressure + readings between 1901 and 1940. + .rank_storms(10, "maxwind", coordextent=[(31,-98), (18,-80)]) + Retrieve a report of the top 10 storms, ranked by max-wind, + whose genesis occurred in (roughly) the Gulf of Mexico. + """ + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + + # List of tropical-cyclones sorted by stattr + sorted_storms = sorted( + [tc for tc in self.tc.values() if year1 <= tc.year <= year2], + key=lambda tc: getattr(tc, stattr), + reverse = False if stattr == "minmslp" else True + ) + # Values sorted + ranks = sorted( + set([ + getattr(tc, stattr) for tc in sorted_storms \ + if stattr == "minmslp" \ + or getattr(tc, stattr) > 0 + ]), + reverse = False if stattr == "minmslp" else True + )[:quantity] + + # If bounding-box coords provided... + if coordextent is not None: + contains_method = contains_method.lower() # Ensure lowercase + # Warning message + if contains_method not in ["start", "anywhere"]: + print( + "* Defaulting to 'anywhere' location method. The only " + "valid values for the contains_method keyword argument " + "are 'start' and 'anywhere'." + ) + contains_method = "anywhere" + # Just search starting point + if contains_method == "start": + sorted_storms = [ + TC for TC in sorted_storms if self.coord_contains( + TC.entry[0].location, + coordextent[0], + coordextent[1] + ) + ] + # Any point within the bounding-box + else: + sorted_storms = [ + TC for TC in sorted_storms \ + if any( + self.coord_contains( + entry.location, + *coordextent + ) for entry in TC.entry + ) + ] + ranks = sorted( + set([ + getattr(TC, stattr) for TC in sorted_storms \ + if stattr == "minmslp" \ + or getattr(TC, stattr) > 0 + ]), + reverse = False if stattr == "minmslp" else True + )[:quantity] + + # List that holds printed quantities + printedqty = [] + + print("") + print("TOP {} STORMS RANKED BY {}".format( + len(ranks), + stattr.upper() + ).center(79)) + if coordextent is not None: + print("{:^79}".format( + "* Coordinate Bounding-Box: {}; {}".format( + "{}{} {}{}".format( + abs(coordextent[0][0]), + "N" if coordextent[1][0] >= 0 else "S", + abs(coordextent[0][1]), + "W" if -180 < coordextent[1][1] <= 0 else "E" + ), + "{}{} {}{}".format( + abs(coordextent[1][0]), + "N" if coordextent[1][0] >= 0 else "S", + abs(coordextent[1][1]), + "W" if -180 < coordextent[1][1] <= 0 else "E" + ) + ) + )) + + print("{}{}".format( + str(self.basin()), + ", {}-{}".format(year1, year2) + ).center(79)) + print("-" * 79) + + print("{:^4} {:^10} {:^8} {:^4} {:^4} {:^4} {:^6} {:^22}".format( + "","","","LAND","","","TCDIST", + "STATUS-RELATED TRACK" if "track" in stattr else "ENERGY INDICES" + )) + print("{:^4} {:^10} {:^8} {:^4} {:>4} {:>4} {:^6} {:^22}".format( + "","","","FALL","MIN","MAX","TRVRSD", + "DISTANCES (nmi)" if "track" in stattr else "x10^4 kt^2" + )) + print("{:^4} {:<10} {:^8} {:<4} {:^4} {:^4} {:^6} {:^6} {:^6} {:^6}".format( + "RANK","NAME","ATCFID","QTY","MSLP","WIND","(nmi)", + "TRPCST" if "track" in stattr else "ACE", + "HURRCN" if "track" in stattr else "HDP", + "MAJHUR" if "track" in stattr else "MHDP" + )) + print("{:-^4} {:-^10} {:-^8} {:-^4} {:-^4} {:-^4} {:-^6} {:-^6} {:-^6} {:-^6}".format( + "","","","","","","","","","" + )) + + for TC in sorted_storms: + try: + current_rank = ranks.index(getattr(TC, stattr)) + 1 \ + if ranks.index(getattr(TC, stattr)) + 1 \ + not in printedqty else None + except: + break + print("{:>3}{:1} {:<10} {:8} {:^4} {:>4} {:>4} {:>6.1f} {:>{ACELEN}f} {:>{ACELEN}f} {:>{ACELEN}f}".format( + current_rank if current_rank is not None else "", + "." if current_rank is not None else "", + TC.name.title(), + TC.atcfid, + TC.landfalls, + TC.minmslp if TC.minmslp is not None else "N/A", + TC.maxwind if TC.maxwind > 0 else "N/A", + TC.track_distance_TC, + TC.track_distance_TS if "track" in stattr else TC.ACE * math.pow(10,-4), + TC.track_distance_HU if "track" in stattr else TC.HDP * math.pow(10,-4), + TC.track_distance_MHU if "track" in stattr else TC.MHDP * math.pow(10,-4), + ACELEN = 6.1 if "track" in stattr else 6.3 + )) + if current_rank is not None and current_rank not in printedqty: + printedqty.append(current_rank) + print("") + + def rank_climo(self, quantity, stattr, year1=None, year2=None, descending=True, **climoparam): + """Rank and compare climatological eras to one another. + + Required Arguments: + quantity: how long of a list of ranks do you want; an integer. + stattr: the storm attribute that you'd like to rank seasons by. + + * Working Storm Attributes for ranking: + "track_distance_TC", "landfalls", "maxwind", "minmslp", + "ACE", "track_distance_TS", "HDP", "track_distance_HU", + "MHDP", "track_distance_MHU" + + * The following attributes will not work because at the + individual storm level these are bools: + "landfall_TC", "landfall_TD", "landfall_TS", "landfall_HU", + "landfall_MHU", "TSreach", "HUreach", "MHUreach", + "cat45reach", "cat5reach" + + * Other attributes of class TropicalCyclone that are not + mentioned here will work for ranking too, but their actual + values will not display on the printed report. + + Default Arguments: + year1 (None): begin year. If included, the indicated year will + represent the low-end of years to assess. In the absence of + the end-year, all years from this begin year to the end of the + record-range will be used to determine ranking. + year2 (None): end year. If included, the indicated year will + represent the upper-end of years to assess. In the absence of + the begin-year, all years from the start of the record-range + to this indicated year will be used to determine ranking. + descending (True): parallel bool used to determine reverse kw of + sorted calls; whether results will be printed higher-to-lower + or not. + + Optional Keyword Arguments (**climoparam): + * These control Climatological Spans and Extents * + climatology (30): the quantity of years that will be assessed per + climate era. + increment (5): the time (in years) between one climate era and the + next (ex. 1981-2010, 1986-2015, etc). + + Examples: + --------- + .rank_climo(10,"ACE"): Retrieve the top 10 climate eras in the + record that have the largest ACE (30yr climo; 5yr incremented) + .rank_climo(20,"track_distance_TC", climatology=10, increment=1): + Retrieve the top 20 10-year climatological eras (incremented by 1 + year) of accumulated tropical cyclone track-distance. + """ + climatology = climoparam.get("climatology", 30) + increment = climoparam.get("increment", 5) + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + + Era = collections.namedtuple("Era", ["era", stattr]) + + climo = {} # dictionary to hold the climatology data + + for yr1, yr2 in [(y, y+climatology-1) \ + for y in range(1801, year2, increment) \ + if year1 <= y <= year2 \ + and year1 <= y+climatology-1 <= year2]: + climo[yr1, yr2] = Era( + (yr1, yr2), + sum(getattr(self.season[s], stattr) for s in range(yr1, yr2+1)) + ) + + # List of tropical-cyclones sorted by stattr + sorted_climo = sorted( + [era for era in climo.values()], + key=lambda era: getattr(era, stattr), + reverse = descending + ) + # Values sorted + ranks = sorted( + set([ + getattr(era, stattr) for era in sorted_climo \ + if descending is False \ + or getattr(era, stattr) > 0 + ]), + reverse = descending + )[:quantity] + + # Rank printed list + printedqty = [] + + print("") + print("{:^41}".format( + "TOP {} CLIMATOLOGICAL PERIODS".format(quantity) + )) + print("{:^41}".format( + "RANKED BY {}".format(stattr.upper()) + )) + print("{}{}".format( + str(self.basin()), + ", {}-{}".format(year1, year2) + ).center(41)) + + print("{:-^41}".format("")) + print("{:^41}".format( + "{}-Year Climatologies; {}-Year Incremented".format( + climatology, + increment + ) + )) + print("{:-^41}".format("")) + print(" {:^4} {:^9} {:^12}".format( + "RANK", + "PERIOD", + stattr.upper() + )) + print(" {:-^4} {:-^9} {:-^12}".format( + "","","" + )) + for clmt in sorted_climo: + try: + current_rank = ranks.index(getattr(clmt, stattr)) + 1 \ + if ranks.index(getattr(clmt, stattr)) + 1 \ + not in printedqty else None + except: + break + print(" {:>4} {:9} {}".format( + "{:>3}{:1}".format( + current_rank if current_rank is not None else "", + "." if current_rank is not None else "" + ), + "{}-{}".format(*clmt.era), + getattr(clmt,stattr) + )) + if current_rank is not None and current_rank not in printedqty: + printedqty.append(current_rank) + print("") + + def _season_stats(self, seasonreq, year1, year2, rstart, rthru, width, **kw): + """ + Handler for .stats calls. + """ + class SuperList(list): + def __init__(self, *args): + self.printed = [] + super().__init__(*args) + + def continue_print(self): + print_queue = [] + for indx, line in enumerate(self): + if indx not in self.printed: + print_queue.append(line) + self.printed.append(indx) + print("\n".join(print_queue)) + + def reset_printed(self): + self.printed = [] + + instruction = kw.get("instruction", print) + + strlist = SuperList() + yr = seasonreq + strlist.append("-" * width) + strlist.append("Tropical Cyclone Stats for {}".format(yr).center(width)) + strlist.append( + "{}{}".format( + self.basin(), + "" + ).center(width) + ) + strlist[-1] += "\n" + + statyrline = "Stats calculated for Seasons {}".format( + "{}-{}".format( + year1, + year2 + ) if year2 != self.record_range[1] \ + else "since {} ({} total seasons)".format( + year1, + self.record_range[1] - year1 + 1 + ) + ).center(width) + strlist.append(statyrline) + + if rstart != (1,1) or rthru != (12,31): + strlist.append( + "from {} thru {}".format( + "{} {}".format( + calendar.month_name[rstart[0]], + rstart[1], + ), + "{} {}".format( + calendar.month_name[rthru[0]], + rthru[1], + ) + ).center(width) + ) + strlist[-1] += "\n" + for line in textwrap.wrap( + "* TS-related Statistics include Hurricanes in their totals" \ + " except for landfall data", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4 + ): + strlist.append(line.center(width)) + strlist[-1] += "\n" + if any(1971 <= y <= 1990 for y in range(year1, year2 + 1)): + for line in textwrap.wrap( + "* Hurdat2 Landfall data incomplete for seasons 1971-1990", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4 + ): + strlist.append(line.center(width)) + strlist.append( + "* Reported ranks are Dense (value-based) " + "and Competition (if different)", + ) + strlist.append("-" * width) + if instruction == print: strlist.continue_print() + for attr, label in [ + ("tracks", "Tropical Cyclones"), + ("track_distance_TC", "TC Track Distance"), + ("track_distance_TS", "TS Distance"), + ("track_distance_HU", "HU Distance"), + ("track_distance_MHU", "MHU Distance"), + ("TSreach", "Tropical Storms"), + ("ACE", "ACE"), + ("HUreach", "Hurricanes"), + ("HDP", "HDP"), + ("MHUreach", "Major Hurricanes"), + ("MHDP", "MHDP"), + ("landfall_TC", "Total Landfalling TC's"), + ("landfall_TS", "TS Landfalls"), + ("landfall_HU", "HU Landfalls") + ]: + if "landfall" not in attr or ( + "landfall" in attr and all( + 1971 <= y <= 1990 for y in range(year1, year2) + ) is False + ): + rankinfo = self.rank_seasons( + 1337, + attr, + year1, + year2, + start = rstart, + thru = rthru, + descending=kw.get("descending", True), + info=yr + ) + strlist.append('{:<35}Ranks: {:>{LEN}}{}{}'.format( + "* {}: {}{} ".format( + label, + "{:.1f}".format(rankinfo["seasonvalu"]) + if "distance" in attr + else "{:.1f}".format(rankinfo["seasonvalu"] * pow(10,-4)) + if attr in ["ACE", "HDP", "MHDP"] + else rankinfo["seasonvalu"], + " nmi" + if "track_distance" in attr + else " * 10^4 kt^2" + if attr in ["ACE", "HDP", "MHDP"] + else "", + ), + "{}/{}".format( + rankinfo["rank"], + rankinfo["outof"], + ), + " :: {:>{LEN}}".format( + "{}/{}".format( + rankinfo["golf_rank"], + rankinfo["golf_outof"], + ), + LEN = len(str(year2-year1+1)) * 2 + 1, + ) if rankinfo["rank"] != rankinfo["golf_rank"] + or rankinfo["outof"] != rankinfo["golf_outof"] + else "", + " (tied w/{} season{})".format( + rankinfo["tied"], + "s" if rankinfo["tied"] >= 2 else "" + ) if rankinfo["tied"] > 0 else "", + LEN = len(str(year2-year1+1)) * 2 + 1, + )) + if instruction == print: strlist.continue_print() + if instruction == print: strlist.continue_print() + if instruction != print: + return "\n".join(strlist) + # if instruction == print: + # print("\n".join(strlist)) + # else: + # return "\n".join(strlist) + +class SeasonCalculations: + + @property + def start_date_entry(self): + """The <> of the start of the season.""" + return self.tc_entries[0] + + @property + def start_date(self): + """The <> of the start of the season.""" + return self.start_date_entry.entrytime + + @property + def start_ordinal(self): + """The day-number (1-365) of the year that the start of the season took + place. + """ + return self.start_date.replace(year=1).toordinal() + + @property + def end_date(self): + """The <> of the end of the season.""" + last_tc_en = self.tc_entries[-1] + return last_tc_en.next_entry.entrytime \ + if last_tc_en.next_entry is not None \ + else last_tc_en.entrytime + + @property + def end_ordinal(self): + """The day-number (1-365) of the year that the end of the season + occurred. + + In the event that the day number exceeds 365, it generally means that + the season extended into the following year. + """ + end = self.end_date.replace(year=1).toordinal() + # provide for seasons that extend into the following year + if end <= self.start_ordinal: + return self.end_date.replace(year=2).toordinal() + else: + return end + + @property + def duration(self): + """Returns the duration of the season in days. + + This is calculated using the .start_date and .end_date for the season + """ + tdelta = self.end_date - self.start_date + # return all_times[-1] - all_times[0] + return tdelta.days + tdelta.seconds / 86400 + + @property + def track_distance(self): + """Returns the accumulated track distances (in nmi) of all systems + during the season, regardless of the systems' status. + """ + return sum(tcyc.track_distance for tcyc in self.tc.values()) + + @property + def track_distance_TC(self): + """Returns the accumulated track distances (in nmi) of all systems + during the season, while the systems were designated as tropical + cyclones ("SD","SS","TD","TS","HU"). + """ + return sum(tcyc.track_distance_TC for tcyc in self.tc.values()) + + @property + def ACE(self): + """Returns the accumulated cyclone energy (ACE) for the entire season, + being the sum of all individual tropical cyclone ACE's. + """ + return sum(tcyc.ACE for tcyc in self.tc.values()) + + @property + def track_distance_TS(self): + """Returns the sum of track distances (in nmi) of all tropical + cyclones while they were designated as at-least tropical storms (SS, + TS, or HU). + """ + return sum(tcyc.track_distance_TS for tcyc in self.tc.values()) + + @property + def HDP(self): + """Returns the hurricane destruction potential (HDP) for the entire + season, being the sum of all individual tropical cyclone HDP's. + """ + return sum(tcyc.HDP for tcyc in self.tc.values()) + + @property + def track_distance_HU(self): + """Returns the sum of track distances (in nmi) of all tropical + cyclones while they were of hurricane status. + """ + return sum(tcyc.track_distance_HU for tcyc in self.tc.values()) + + @property + def MHDP(self): + """Returns the major hurricane destruction potential (MHDP) for the + entire season, being the sum of all individual tropical cyclone MHDP's. + """ + return sum(tcyc.MHDP for tcyc in self.tc.values()) + + @property + def track_distance_MHU(self): + """Returns the sum of track distances (in nmi) of all tropical + cyclones when the storms were designated as major hurricanes. + """ + return sum(tcyc.track_distance_MHU for tcyc in self.tc.values()) + +class TropicalCycloneCalculations: + + @property + def bounding_box(self): + """The bounding box enclosing all of the cyclones s.""" + return _gis.BoundingBox( + _gis.Coordinate( + min(en.lon for en in self.entry), + max(en.lat for en in self.entry) + ), + _gis.Coordinate( + max(en.lon for en in self.entry), + min(en.lat for en in self.entry) + ) + ) + + @property + def bounding_box_TC(self): + """ + The bounding box enclosing all s where the system was + designated as a tropical cyclone + """ + return _gis.BoundingBox( + _gis.Coordinate( + min(en.lon for en in self.tc_entries), + max(en.lat for en in self.tc_entries) + ), + _gis.Coordinate( + max(en.lon for en in self.tc_entries), + min(en.lat for en in self.tc_entries) + ) + ) + + @staticmethod + def test(point, point2): + # the segment to inspect if the track crosses + segbb = _gis.BoundingBox( + _gis.Coordinate(*point), + _gis.Coordinate(*point2) + ) + # find the angle that is perpendicular to the segment + perpendicular = direction( + segbb.p1.lat, + segbb.p1.lon, + segbb.p2.lat, + segbb.p2.lon, + right_hand_rule=True + ) + p2 = abs(segbb.theta-180) + return [tuple(point), (round(point2[0],5), round(point2[1],5)), segbb.theta, segbb.heading, perpendicular, p2] + + + def crosses(self, *reference, direction_range=None, landfall=False, category=None, is_TC=False): + """ + Returns whether or not the track of this system intersects a referenced + list of tupled coordinates (longitude, latitude). Optional + discriminators are detailed below. + + Arguments: + reference: the list of coordinates in (lon, lat) tuples. It is + recommended to use the .from_map() method to formulate + the coordinate list. For convenience, there are coastline + coordinate lists that are part of the object. See + README about those. + + Default Keyword Arguments: + direction_range (None): an optional list/tuple of direction range + only matching if the storm crosses the coordinates while its + direction is within the given range. + + Direction Reference: + 0 or 360: North + 90: East + 180: South + 270: West + + Examples: + Tuple Scope + ----- ----- + North: (316, 44) Broad + (346, 14) Narrow + East: (46, 134) Broad + (75, 105) Narrow + South: (136, 224) Broad + (165, 205) Narrow + West: (226, 314) Broad + (255, 285) Narrow + + landfall (False): if True, it assesses crossings from a particular + side of segments of the reference. Think of this as a "right + hand rule", being perpendicular to a reference segment. So the + referenced list must be prepared using this in mind. As you + sketch around the landmass, envision an arrow pointing to the + right of the segment, with respect to its forward direction. + + Example: To find systems that made landfall along the Carolina + coasts, the reference must be compiled starting from the + northern-most tip of the Outer Banks of North Carolina, + tracing generally southwestward thru South Carolina. + category (None): represents an optional saffir-simpson (ss) + equivalent integer that will further discriminate whether a + cyclone crossed while its ss scale value was >= the category + given. Of note, this does NOT discriminate via the cyclone's + status at the time of crossing. See the is_TC kw for more info. + is_TC (False): if True, this will test if the system was a tropical + cyclone at the time of crossing (status of SD, SS, TD, TS, or + HU). It is recommended to use this in conjunction with the + category kw, as the saffir-simpson rating is strictly wind- + based. + """ + + if len(reference) == 1: # if a list of tupled coords are passed (like from_map method) + reference = [(x, y) for x, y in reference[0]] + if len(reference) <= 1: + raise ValueError( + "the list `reference` must contain 2 or more coordinate pairs " + "for comparison" + ) + + # if category is given, there is no need to check if the storm + # never reached the magnitude inquired + if category is not None and saffir_simpson_scale(self.maxwind) < category: + return False + + # if bounding boxes never cross, no need to check + refbb = _gis.BoundingBox( + _gis.Coordinate( + min(lon for lon, lat in reference), + max(lat for lon, lat in reference) + ), + _gis.Coordinate( + max(lon for lon, lat in reference), + min(lat for lon, lat in reference) + ) + ) + + # no need to check if no track points are in the reference bounding box + # if all([en.location_rev not in refbb for en in self.entry]): + # return False + + # iterate over each point + for indx, point in enumerate(reference): + try: + point2 = reference[indx+1] + except: + # no more segments to test + return False + if point2 == point: + # skip if points are the same + continue + + # the segment to inspect if the track crosses + segbb = _gis.BoundingBox( + _gis.Coordinate(*point), + _gis.Coordinate(*point2) + ) + + # No need to check (so skip) if the reference segment doesn't even + # intersect the track bounding box + if not segbb.intersects(self.bounding_box): + continue + + # find the angle that is perpendicular to the segment + perpendicular = direction( + segbb.p1.lat, + segbb.p1.lon, + segbb.p2.lat, + segbb.p2.lon, + right_hand_rule=True + ) + # perpendicular = math.fabs(segbb.theta-180) + + # iterate over segments made by the cyclone's entries + # for entry in self.entry[1:]: + for entry in [ + EN for EN in self.entry[1:] + if ( + category is None + or EN.previous_entry.saffir_simpson >= category + ) and ( + not is_TC + or EN.previous_entry.is_TC + ) and ( + # EN.location_rev in refbb + # or EN.previous_entry.location_rev in refbb + # ) + EN.previous_entry.bounding_box.intersects(segbb) + ) + ]: + # the track segment to compare/inspect + enbb = entry.previous_entry.bounding_box + + # determine if the entry's direction lies within the requested + # range of angles (used for landfall testing) + angle_is_valid = is_angle_bounded( + entry.direction(), + perpendicular + ) + + # parallel test - if slopes are the same they will never cross + # and conditionally tests if cyclone's direction is within a requested range + if segbb.slope != enbb.slope and ( + direction_range is None + or direction_range[0] <= entry.direction() <= direction_range[1] + ): + # ilon = longitude intersection (x intersection) + # put 2 equations equal to one another; solve for x + # x = (b2 - b1) / (m1 - m2) + try: + ilon = (enbb.b - segbb.b) / (segbb.slope - enbb.slope) + # if the x-intercept is bounded by the e/w points of each segment, + # PRESENCE HERE MEANS CROSSING HAS OCCURRED + if enbb.w <= ilon <= enbb.e and segbb.w <= ilon <= segbb.e: + # if testing for "landfall" (entry crosses from a + # compatible direction (to negate crossing the + # reference when going from land to sea) + if landfall is True: + # tests the crossing angle if it falls within a + # 180deg sweep of the perpendicular angle of + # the 'land' segment + if angle_is_valid is True and ( + category is None + or entry.previous_entry.saffir_simpson >= category + ): + return True + # No landfall but >= category is requested + elif category is not None: + if entry.previous_entry.saffir_simpson >= category: + return True + # otherwise, the crossing has been guaranteed + else: + return True + # This block will run if one of the segments fail the + # vertical line test (segment runs north/south) + except Exception as e: + # solve the line formula for segbb with the enbb x value + # and test if that value lies within the n/s scope of enbb + # and if the enbb x value is withing the e/w scope of segbb + if enbb.isvertical and ( + enbb.s <= segbb.slope * enbb.p1.x + segbb.b <= enbb.n + and segbb.w <= enbb.p1.x <= segbb.e + # solve the line formula for enbb with the segbb lon. value + # and test if that value lies within the n/s scope of segbb + # and if the segbb lon value is withing the e/w scope of enbb + ) or segbb.isvertical and ( + segbb.s <= enbb.slope * segbb.p1.x + enbb.b <= segbb.n + and enbb.w <= segbb.p1.x <= enbb.e + ): + # PRESENCE HERE MEANS CROSSING GUARANTEED + # landfall test + if landfall is True: + if angle_is_valid is True and ( + category is None + or entry.previous_entry.saffir_simpson >= category + ): + return True + # No landfall but >= category is requested + elif category is not None: + if entry.previous_entry.saffir_simpson >= category: + return True + # otherwise, the crossing has been guaranteed + else: + return True + return False + + @property + def start_date_entry(self): + """The of the birth of the cyclone.""" + return self.tc_entries[0] if len(self.tc_entries) > 0 else None + + @property + def start_date(self): + """The <> of the birth of the tropical cyclone.""" + return self.start_date_entry.entrytime \ + if len(self.tc_entries) > 0 else None + + @property + def start_ordinal(self): + """ + The day-number (1-365) of the year that the birth of the tropical + cyclone took place. + """ + return self.tc_entries[0].entrytime.replace(year=1).toordinal() \ + if len(self.tc_entries) > 0 else None + + @property + def end_date(self): + """The <> where the storm became post-tropical.""" + if len(self.tc_entries) > 0: + return self.tc_entries[-1].next_entry.entrytime \ + if self.tc_entries[-1].next_entry is not None \ + else self.tc_entries[-1].entrytime + else: + return None + + @property + def end_ordinal(self): + """ + The day-number (1-365) of the year that the tropical cyclone became + post-tropical. + + In the event that the day number exceeds 365, it generally means that + the tropical storm didn't become post-tropical until the following + year. + """ + if len(self.tc_entries) > 0: + end = self.end_date.replace(year=1).toordinal() + # protect against seasons that extend into the following year + if end <= self.start_ordinal: + return self.end_date.replace(year=2).toordinal() + else: + return end + else: + return None + + @property + def duration(self): + """ + The track duration in days; simply the end time minus the beginning + time. In essence, this variable disregards the status of the storm. + + For more substantive properties, try duration_ for + aggregated measurements as storms can lose and regain statuses + """ + + return (self.entry[-1].entrytime - self.entry[0].entrytime).days \ + + (self.entry[-1].entrytime - self.entry[0].entrytime).seconds / 86400 + + @property + def track_distance(self): + """Returns the distance (in nmi) traversed by the system, regardless of + status (whether or not the system is designated as a tropical cyclone). + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + ) + + @property + def duration_TC(self): + """ + This is the total time that a storm was a designated tropical cyclone. + + * Of note * A storm can lose previous tropical cyclone status but + regain it. For the Atlantic Hurdat2, this occurs in around 2.6% of + storms, but almost 8% of storms since the year 2000. So if one compares + track life versus this duration property, it isn't out of the question + that they'll be different. See Hurricane Ivan (2004) as a prime + example. + """ + + totes = sum( + (en.next_entry.entrytime - en.entrytime).days + + (en.next_entry.entrytime - en.entrytime).seconds / 86400 + if en.next_entry is not None + and en.is_TC + else 0 + for en in self.entry + ) + + return totes + + @property + def track_distance_TC(self): + """The distance (in nmi) trekked by the system when a designated + tropical cyclone (status as a tropical or sub-tropical depression, a + tropical or sub-tropical storm, or a hurricane). + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.is_TC + ) + + @property + def ACE(self): + """Returns the tropical cyclone's Accumulated Cyclone Energy (ACE). + + Using values from required observations (0Z, 6Z, 12Z, and 18Z), this + variable is "calculated by summing the squares of the estimated + 6-hourly maximum sustained surface wind speed in knots for all periods + while the system is either a tropical storm or hurricane." (G. Bell, + M. Chelliah. Journal of Climate. Vol. 19, Issue 4. pg 593. 15 February + 2006.). + + Because sub-tropical storms (SS) still have some tropical + characteristics, their values are included as well. Regardless of the + case for or against, note that it is a very small contribution. Using + the Atlantic Hurdat2 Database as an example, when included in the + calculation (using only storms since 1968, as that is when the SS + designation first appears in the Atlantic HURDAT2), only around 2.5% of ACE + contribution has occurred from sub-tropical storms. + """ + return sum( + math.pow(en.wind,2) for en in self.entry + if en.wind >= 34 + and en.is_synoptic + and en.status in ("SS","TS","HU") + ) + + @property + def perc_ACE(self): + """The percent (decimal form) of total season ACE contributed by this + storm. + """ + if self._season.ACE > 0: + return self.ACE / self._season.ACE + else: + return 0 + + @property + def duration_TS(self): + """ + This is the total time that a storm was designated at least a tropical + storm. + """ + + totes = sum( + (en.next_entry.entrytime - en.entrytime).days + + (en.next_entry.entrytime - en.entrytime).seconds / 86400 + if en.next_entry is not None + and en.status in ["SS", "TS", "HU"] + else 0 + for en in self.entry + ) + + return totes + + @property + def track_distance_TS(self): + """The distance (in nmi) trekked by the system while a tropical storm + or hurricane. + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.status in ["SS", "TS", "HU"] + ) + + @property + def track_TS_perc_TC(self): + """Returns the system's tropical storm track-distance divided by its + tropical cyclone track-distance. + + This value represents the proportional distance of a storm that + occurred while it was at-least a tropical storm compared to when it was + a designated tropical cyclone. + + None will be returned if track_distance_TC == 0 + """ + if self.track_distance_TC != 0: + return round(self.track_distance_HU / self.track_distance_TC,2) + else: + return None + + @property + def ACE_per_nmi(self): + """Returns the Accumulated Cyclone Energy (ACE) divided by the + systems's track-distance when it was at-least a tropical storm. + """ + return self.ACE / self.track_distance_TS if self.track_distance_TS > 0 else 0 + + @property + def ACE_no_landfall(self): + """Returns the ACE of the storm prior to any landfall made (if + applicable). + """ + + ace_no_lf = 0 + for en in self.entry: + if en.record_identifier == "L": + break + if en.wind >= 34 \ + and en.is_synoptic \ + and en.status in ("SS","TS","HU"): + ace_no_lf += math.pow(en.wind, 2) + return ace_no_lf + + @property + def HDP(self): + """Returns the tropical cyclone's Hurricane Destruction Potential + (HDP). + + Using values from required observations (0Z, 6Z, 12Z, and 18Z), this + variable is "calculated by summing the squares of the estimated + 6-hourly maximum sustained wind speed for all periods in which the + system is a hurricane." (Bell, et. al. Climate Assessment for 1999. + Bulletin of the American Meteorological Society. Vol 81, No. 6. June + 2000. S19.) + """ + return sum( + math.pow(en.wind, 2) for en in self.entry + if en.wind >= 64 + and en.is_synoptic + and en.status == "HU" + ) + + @property + def perc_HDP(self): + """The percent (decimal form) of total season HDP contributed by this + storm. + """ + if self._season.HDP > 0: + return self.HDP / self._season.HDP + else: + return 0 + + @property + def duration_HU(self): + """ + This is the total time that a storm was designated at a hurricane. + """ + + totes = sum( + (en.next_entry.entrytime - en.entrytime).days + + (en.next_entry.entrytime - en.entrytime).seconds / 86400 + if en.next_entry is not None + and en.status == "HU" + else 0 + for en in self.entry + ) + + return totes + + @property + def track_distance_HU(self): + """The distance (in nmi) trekked by the system while a hurricane.""" + return sum( + haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.status == "HU" + ) + + @property + def HDP_per_nmi(self): + """Returns the system's Hurricane Destruction Potential (HDP) divided + by the systems's track-distance when it was a hurricane. + """ + + return self.HDP / self.track_distance_HU if self.track_distance_HU > 0 else 0 + + @property + def HDP_perc_ACE(self): + """Returns the system's HDP divided by its ACE. + + This is the value (0 is lowest; 1 highest) representing how much + contribution to ACE was made while a system was designated as a + hurricane. + + return None will occur if ACE is 0 for the system. + """ + if self.ACE != 0: return round(self.HDP / self.ACE,2) + else: return None + + @property + def track_HU_perc_TC(self): + """Returns the system's hurricane track-distance divided by its + tropical cyclone track-distance + + This value represents the proportional distance of a storm that + occurred while it was a hurricane compared to when it was a designated + tropical cyclone. + + None will be returned if track_distance_TC == 0 + """ + if self.track_distance_TC != 0: + return round(self.track_distance_HU / self.track_distance_TC,2) + else: + return None + + @property + def track_HU_perc_TS(self): + """Returns the system's hurricane track-distance divided by its + tropical storm track-distance. + + This value represents the proportional distance of a storm that + occurred while it was a hurricane compared to when it was at-least a + tropical storm. + + None will be returned if track_distance_TS == 0 + """ + if self.track_distance_TS != 0: + return round(self.track_distance_HU / self.track_distance_TS,2) + else: + return None + + @property + def MHDP(self): + """Returns the tropical cyclone's Major Hurricane Destruction Potential + (MHDP). + + This inclusion of this variable is merely an extension of the + definitions of ACE and HDP, which are widely referenced indices. This + takes the logic of those definitions and applies it only to major- + hurricanes (max-wind >= 96kts). + """ + return sum( + math.pow(en.wind, 2) for en in self.entry + if en.wind >= 96 + and en.is_synoptic + and en.status == "HU" + ) + + @property + def perc_MHDP(self): + """The percent (decimal form) of total season MHDP contributed by this + storm. + """ + if self._season.MHDP > 0: + return self.MHDP / self._season.MHDP + else: + return 0 + + @property + def duration_MHU(self): + """ + This is the total time that a storm was designated at a hurricane. + """ + + totes = sum( + (en.next_entry.entrytime - en.entrytime).days + + (en.next_entry.entrytime - en.entrytime).seconds / 86400 + if en.next_entry is not None + and en.status == "HU" and en.wind >= 96 + else 0 + for en in self.entry + ) + + return totes + + @property + def track_distance_MHU(self): + """The distance (in nmi) trekked by the system while a major + hurricane. + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.wind >= 96 + and en.previous_entry.status == "HU" + ) + + @property + def MHDP_per_nmi(self): + """Returns the system's Major Hurricane Destruction Potential (MHDP) + divided by the systems's track-distance when it was a major hurricane. + """ + return self.MHDP / self.track_distance_MHU if self.track_distance_MHU > 0 else 0 + + @property + def MHDP_perc_ACE(self): + """Returns the system's MHDP divided by its ACE. + + This is the value (0 is lowest; 1 highest) representing how much + contribution to ACE was made while a system was designated as a + major hurricane. + + return None will occur if ACE is 0 for the system. + """ + if self.ACE != 0: return round(self.MHDP / self.ACE,2) + else: return None + + @property + def track_MHU_perc_TC(self): + """Returns the system's major-hurricane track-distance divided by its + tropical cyclone track-distance. + + This value represents the proportional distance of a storm that + occurred while it was a major-hurricane compared to when it was a + designated tropical cyclone. + + None will be returned if track_distance_TC == 0 + """ + if self.track_distance_TC != 0: + return round(self.track_distance_MHU / self.track_distance_TC,2) + else: + return None + + @property + def track_MHU_perc_TS(self): + """Returns the system's major-hurricane track-distance divided by its + tropical storm track-distance. + + This value represents the proportional distance of a storm that + occurred while it was a major-hurricane compared to when it was at- + least a tropical storm. + + None will be returned if track_distance_TS == 0 + """ + if self.track_distance_TS != 0: + return round(self.track_distance_MHU / self.track_distance_TS,2) + else: + return None + + @property + def MHDP_perc_HDP(self): + """Returns the system's MHDP divided by its HDP. + + This is the value (0 is lowest; 1 highest) representing how much + contribution to its HDP was made while a system was designated as a + major hurricane. + + return None will occur if HDP is 0 for the system. + """ + if self.HDP != 0: return round(self.MHDP / self.HDP,2) + else: return None + + @property + def track_MHU_perc_HU(self): + """Returns the system's major-hurricane track-distance divided by its + hurricane track-distance. + + This value represents the proportional distance of a storm that + occurred while it was a major-hurricane compared to when it was a + hurricane. + + None will be returned if track_distance_HU == 0 + """ + if self.track_distance_HU != 0: + return round(self.track_distance_MHU / self.track_distance_HU,2) + else: + return None + +class TCEntryCalculations: + + __slots__ = [] + + @property + def bounding_box(self): + """ + The bounding box (or really, segment) defined by the point of this + entry and the next entry (if applicable). + """ + + if self.next_entry is not None: + return _gis.BoundingBox( + _gis.Coordinate(self.lon, self.lat), + _gis.Coordinate(self.next_entry.lon, self.next_entry.lat), + ) + else: + return None + + @property + def track_distance(self): + """ + The track distance traversed by the system (regardless of status) from + the start of the track to the time of this <> + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self._tc.entry + if self._tc.entry.index(en) <= self._tc.entry.index(self) + and en.previous_entry is not None + ) + + @property + def track_distance_TC(self): + """ + The track distance traversed by the system while designated a tropical + cyclone from the start of the track to the time of this + <>. + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self._tc.entry[:self._tc.entry.index(self)+1] + if en.previous_entry is not None + and en.previous_entry.is_TC + ) + + @property + def track_distance_TS(self): + """ + The track distance traversed by the system while a tropical storm or + stronger, from the start of the track to the time of this + <> + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self._tc.entry[:self._tc.entry.index(self)+1] + if en.previous_entry is not None + and en.previous_entry.status in ("SS", "TS", "HU") + ) + + @property + def track_distance_HU(self): + """ + The track distance traversed by the system while designated a hurricane + from the start of the track to the time of this <> + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self._tc.entry[:self._tc.entry.index(self)+1] + if en.previous_entry is not None + and en.previous_entry.status == "HU" + ) + + @property + def track_distance_MHU(self): + """ + The track distance traversed by the system while designated a major- + hurricane, from the start of the track to the time of this + <> + """ + return sum( + haversine(en.previous_entry.location, en.location) + for en in self._tc.entry[:self._tc.entry.index(self)+1] + if en.previous_entry is not None + and en.previous_entry.status == "HU" + and en.previous_entry.wind >= 96 + ) + + def direction(self, cardinal=False, right_hand_rule=False): + """Returns the heading (in degrees) of the tropical cyclone at the time + of the . + + This is calculated using this and the previous entry locations. + + Default Argument + ---------------- + cardinal (False): if True, it will return an accurate cardinal + direction abbreviation (ex: 'NNW' == North-Northwest) instead + of degrees. + right_hand_rule (False): if True, it will return the direction + normal or perpendicular to the heading following the right-hand + rule. + + Of note, the first entry (index of 0) of any tropical cyclone will not + have any associated direction because there is no previous entry to + compare it with. + + For reference: + Degrees Direction + ---------- ------------------- + 0 // 45 North // Northeast + 90 // 135 East // Southeast + 180 // 225 South // Southwest + 270 // 315 West // Northwest + """ + if self._tc.entry.index(self) != 0: + dlat = self.latitude - self.previous_entry.latitude + # account for longitudinal traversals of 180E/-180W + if abs(self.longitude - self.previous_entry.longitude) < 180: + dlon = self.longitude - self.previous_entry.longitude + else: + dlon = self.longitude + ( + 360 * (1 if self.longitude < 0 else -1) + ) - self.previous_entry.longitude + deg_dir = math.degrees(math.atan2(dlon, dlat)) + + if right_hand_rule: + deg_dir += 90 + if cardinal is True: + return cardinal_direction( + deg_dir + (360 if deg_dir < 0 else 0) + ) + else: + return deg_dir + (360 if deg_dir < 0 else 0) + if cardinal is True: + return cardinal_direction( + deg_dir + (360 if deg_dir < 0 else 0) + ) + else: + return deg_dir + (360 if deg_dir < 0 else 0) + else: + return None + + @property + def speed(self): + """ + Returns the forward lateral speed of the tropical cyclone at the time + of the in knots (nautical miles per hour). + + This is calculated using this and the previous entry locations (gps + coordinates) and the time of the entry. + + Of note, the first entry (index of 0) of any tropical cyclone will not + have any associated speed because there is no previous entry to compare + it to. + """ + if self._tc.entry.index(self) != 0: + dist = haversine(self.location, self.previous_entry.location) + et = (self.entrytime - self.previous_entry.entrytime).seconds / 60 / 60 + return dist / et + else: + return None + + @property + def saffir_simpson(self): + """ + Returns the saffir-simpson scale rating of the tropical cyclone. This + is solely based upon the maximum sustained wind value. If at-least + hurricane-strength, this will return a category between 1 and 5. For Non- + hurricane strength storms will return 0 if tropical storm strength or + -1 for depression strength or less. 0 or -1 does not appear on the + saffir-simpson scale but were included in this method for continuity + and distinguishing between those weaker systems. + """ + return saffir_simpson_scale(self.wind) + + @property + def avg_wind_extent_TS(self): + """Returns the average extent of at-least tropical storm winds.""" + return statistics.mean(self.extent_TS) + + @property + def areal_extent_TS(self): + """Return the instantaneous maximum tropical-storm-strength wind areal + expanse (in nmi^2) covered by the storm. + + This is calculated by taking each TS-wind quadrant value and summing + their areal-extents (those extents being considered 1/4 of a circle). + """ + return sum( + math.pi * math.pow(r, 2) / 4 + for r in self.extent_TS + if r is not None + ) + + @property + def avg_wind_extent_TS50(self): + """Returns the average extent of at-least 50kt winds.""" + return statistics.mean(self.extent_TS50) + + @property + def areal_extent_TS50(self): + """Return the instantaneous maximum 50kt+ wind (TS50) areal expanse (in + nmi^2) covered by the storm. + + This is calculated by taking each TS50-wind quadrant value and summing + their areal-extents (those extents being considered 1/4 of a circle). + """ + return sum( + math.pi * math.pow(r, 2) / 4 \ + for r in self.extent_TS50 \ + if r is not None + ) + + @property + def avg_wind_extent_HU(self): + """Returns the average extent of hurricane-strength winds.""" + return statistics.mean(self.extent_HU) + + @property + def areal_extent_HU(self): + """Return the instantaneous maximum hurricane-strength wind areal + expanse (in nmi^2) covered by the storm. + + This is calculated by taking each HU-wind quadrant value and summing + their areal-extents (those extents being considered 1/4 of a circle). + """ + + return sum( + math.pi * math.pow(r, 2) / 4 \ + for r in self.extent_HU \ + if r is not None + ) + +def saffir_simpson_scale(spd): + """Returns the equivalent Saffir-Simpson scale rating, based on wind-speed + in knots. + + This is a very common scale used to generalize tropical cyclone intensity. + Though not officially part of the scale, cyclones that have Tropical Storm + speeds will return 0 while even-weaker storms will return -1. + + Example: saffir_simpson_scale(100) --> 3 (implying category 3). + """ + if 34 <= spd < 64: return 0 + elif 64 <= spd < 83: return 1 + elif 83 <= spd < 96: return 2 + elif 96 <= spd < 113: return 3 + elif 113 <= spd < 137: return 4 + elif spd >= 137: return 5 + else: return -1 + +def distance_from_coordinates(lat, lon, distance, direction): + direction = direction.upper() + latr = math.radians(lat) + lonr = math.radians(lon) + if distance == None: + distance = 0 + r = 3440.065 # mean radius of earth in nmi + + if direction in ["N", "S"]: + y = (1 if direction == "N" else -1) * distance / r + latr + return (math.degrees(y), lon) + else: + # x = (2 if direction == "E" else -1) * math.asin(distance / (2 * r * math.pow(math.cos(latr), 2))) + lonr + # x = (2 if direction == "E" else -2) * math.asin(math.sqrt(distance / math.pow(math.cos(latr), 2))) + lonr + # x = (1 if direction == "E" else -1) * math.acos(2 * distance / math.cos(latr)**2) + lonr + x = (2 if direction == "E" else -2) * math.asin(math.sqrt(math.pow(math.sin(distance / (2 * r)), 2) / math.pow(math.cos(latr), 2))) + lonr + return (lat, math.degrees(x)) + +def haversine(startpos, endpos, gis=False): + """Returns the distance (in nmi) between two tupled GPS coordinates. + + Args: + startpos: the starting gps-coordinate point; in tuple form of + (latitude, longitude) unless gis kw is True. Both need to be an int + or float. + endpos: the ending gps-coordinate point; in tuple form of (latitude, + longitude) unless gis kw is Ture. Both need to be an int or float. + + Default Args: + gis (False): the function wants coordinates in (lat, lon) format. If this kw is True, then it expects (lon, lat) order. + + The formula used was found on Wikipedia + (https://en.wikipedia.org/wiki/Haversine_formula). + """ + lat1 = math.radians(startpos[0 if gis is False else 1]) + lon1 = math.radians(startpos[1 if gis is False else 0]) + lat2 = math.radians(endpos[0 if gis is False else 1]) + lon2 = math.radians(endpos[1 if gis is False else 0]) + r = 3440.065 # mean radius of earth in nmi + d = 2 * r * math.asin(math.sqrt(math.pow(math.sin((lat2 - lat1)/2),2) + math.cos(lat1) * math.cos(lat2) * math.pow(math.sin((lon2-lon1)/2),2))) + return d + +def cardinal_direction(deg): + """ + Returns the cardinal direction (an abbreviation) based on a degree-heading. + + Examples: + 10.5 --> 'N' + 257 --> 'WSW' + 20.2 --> 'NNE' + 93 --> 'E' + 165 --> 'SSE' + """ + if deg <= 11.25: return "N" + elif deg <= 33.75: return "NNE" + elif deg <= 56.25: return "NE" + elif deg <= 78.75: return "ENE" + elif deg <= 101.25: return "E" + elif deg <= 123.75: return "ESE" + elif deg <= 146.25: return "SE" + elif deg <= 168.75: return "SSE" + elif deg <= 191.25: return "S" + elif deg <= 213.75: return "SSW" + elif deg <= 236.25: return "SW" + elif deg <= 258.75: return "WSW" + elif deg <= 281.25: return "W" + elif deg <= 303.75: return "WNW" + elif deg <= 326.25: return "NW" + elif deg <= 348.75: return "NNW" + else: return "N" + +def direction(lat1, lon1, lat2, lon2, cardinal=False, right_hand_rule=False): + """ + Return the navigational heading (0deg = North) between two points (going + from point 1 towards point 2. + + Arguments + --------- + lat1 = latitude of point 1 + lon1 = longitude of point 1 + lat2 = latitude of point 2 + lon2 = longitude of point 2 + + Default Arguments + ----------------- + cardinal (False): if True, this will return a string representation of + the heading (its abbreviation actually). + Examples: + 0 -> "N" + 45 -> "NE" + 225 -> "SW" + right_hand_rule (False): if True, the returned value will be rotated 90 + degrees "to the right" of the heading. + + This is essentially a mirror function of .direction so + it could be accessible to other functions/methods in this file. + """ + dlat = lat2 - lat1 + # account for longitudinal traversals of 180E/-180W + if abs(lon2 - lon1) < 180: + dlon = lon2 - lon1 + else: + dlon = lon2 + ( + 360 * (1 if lon2 < 0 else -1) + ) - lon1 + deg_dir = math.degrees(math.atan2(dlon, dlat)) + if right_hand_rule: + deg_dir = deg_dir + 90 + if cardinal is True: + return cardinal_direction( + deg_dir + (360 if deg_dir < 0 else 0) + ) + else: + return deg_dir + (360 if deg_dir < 0 else 0) + +def is_angle_bounded(deg, reference, scope=180): + """ + Tests (and returns) whether or not an angle falls within a certain range + that is centered at a reference angle. + + Args: + deg = the angle to be tested + reference = the angle that will be the center of the determined range + + Default Keyword Arguments: + scope (180): the angle spectrum centered at the reference angle from + which the test will be made. For example: + + Deg Reference Angle Scope Angle Range Result + ---- --------------- ----- ---------------- ------ + 70 85 180 (>=355, <=175) True + 200 175 40 (>=155, <=195) False + 325 350 60 (>=320, <=20) True + """ + _min = reference - scope/2 + _max = reference + scope/2 + + return _min < deg < _max \ + if not deg < _min < _max \ + and not _min < _max < deg \ + else _min < deg + 360 < _max \ + if not _min < _max < deg \ + else _min < deg - 360 < _max + +def operator_map(logic): + opmap = { + "<" : operator.lt, + "<=" : operator.le, + "==" : operator.eq, + "!=" : operator.ne, + ">=" : operator.ge, + ">" : operator.gt, + } + return opmap[logic] + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/hurdat2parser/_deprecated.py b/hurdat2parser/_deprecated.py new file mode 100644 index 0000000..47e6ce1 --- /dev/null +++ b/hurdat2parser/_deprecated.py @@ -0,0 +1,725 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import math +import datetime +import calendar +import textwrap + +from ._calculations import haversine + +class Hurdat2: + def rank_seasons(self, quantity, stattr, year1=None, year2=None, descending=True, **kw): + """Rank and compare full tropical cyclone seasons to one another. + + Required Arguments: + quantity: how long of a list of ranks do you want; an integer. + stattr: the storm attribute that you'd like to rank seasons by. + + * Storm Attributes: + "tracks", "landfall_TC", "TSreach", "HUreach", "MHUreach", + "track_distance_TC", "ACE", "track_distance_TS", "HDP", + "track_distance_HU", "MHDP", "track_distance_MHU" + + * Note: Though attributes "track_distance", "landfalls", + "landfall_TD", "landfall_TS", "landfall_HU", + "landfall_MHU", "TDonly", "TSonly", "HUonly", "cat45reach", + and "cat5reach" are valid storm attributes to rank by, + their quantities will not be visible in the ranking output. + + Default Arguments: + year1 (None): begin year. If included, the indicated year will + represent the low-end of years to assess. In the absence of + the end-year, all years from this begin year to the end of the + record-range will be used in ranking. + year2 (None): end year. If included, the indicated year will + represent the upper-end of years to assess. In the absence of + the begin-year, all years from the start of the record-range + to this indicated year will be used in ranking. + descending (True): bool to indicate sorting seasons in descending + (higher-to-lower) or not. The default of True implies seasons + will be ranked from higher-to-lower. + + Examples: + --------- + .rank_seasons(10,"ACE"): Retrieve a report of tropical + cyclone seasons sorted by the top-10 Accumulated Cyclone + Energy values. + .rank_seasons(15,"HDP",1967): Retrieve a report of tropical + cyclone seasons sorted by the top-15 Hurricane Destruction + Potential values occurring since 1967 (the beginning of the + satellite era). + .rank_seasons(5,"track_distance_TS",1951,2000,True): + Retrieve a report of the bottom-5 seasons of distance + traversed by, at-least, tropical storms, all between 1951 and + 2000. + .rank_seasons(10,"HUreach",year2=2000): Retrieves a report + of the top-10 seasons with the most Hurricanes prior-to, and + including the year 2000. + """ + + # -------------------- + year1 = abs(year1) \ + if type(year1) == int \ + and abs(year1) >= self.record_range[0] \ + else self.record_range[0] + year2 = abs(year2) \ + if type(year2) == int \ + and abs(year2) <= self.record_range[1] \ + else self.record_range[1] + + year1, year2 = [ + min([year1, year2]), + max([year1, year2]) + ] + + if len(range(year1, year2)) == 0: + raise ValueError("The years given must be different!") + + # List seasons sorted by stattr + sorted_seasons = sorted( + [s for s in self.season.values() if year1 <= s.year <= year2], + key=lambda czen: getattr(czen, stattr), + reverse = descending + ) + # Values sorted + ranks = sorted( + set([ + getattr(s, stattr) for s in sorted_seasons \ + if descending is False \ + or (getattr(s, stattr) > 0 and kw.get("info") is None) \ + or kw.get("info") is not None + ]), + reverse = descending + )[:quantity] + + # RETURN if _season_stats (via rank_seasons_thru) method called this method + if kw.get("info", None) is not None: + # insert years data if not included in original ranking + if (year1 <= kw["info"] <= year2) is False: + ranks = sorted( + ranks + [getattr(self.season[kw["info"]], stattr)], + reverse = descending + ) + return { + "seasonvalu": getattr(self.season[kw["info"]], stattr), + "rank": ranks.index(getattr(self.season[kw["info"]], stattr)) + 1, + "tied": len(["tie" for season in sorted_seasons if getattr(season, stattr) == getattr(self.season[kw["info"]], stattr)]) - 1, + "outof": len(ranks) + } + # List that holds printed quantities + printedqty = [] + + print("") + print("TOP {} SEASONS RANKED BY {}".format( + len(ranks), + stattr.upper() + ).center(79)) + + print("{}{}".format( + str(self.basin()), + ", {}-{}".format(year1, year2) + ).center(79)) + print("-" * 79) + + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","","LAND","QTY","","","TC DIST", + "STATUS-RELATED TRACK" if "track_distance" in stattr else "ENERGY INDICES" + )) + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","NUM OF","FALL","TRPC","QTY","QTY","TRAVRSD", + "DISTANCES (in nmi)" if "track_distance" in stattr else "x10^4 kt^2" + )) + print("RANK YEAR {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^7} {:^7} {:^7}".format( + "TRACKS","TCs","STRM","HURR","MAJ","(nmi)", + "TRPCSTM" if "track_distance" in stattr else "ACE", + "HURRICN" if "track_distance" in stattr else "HDP", + "MAJHURR" if "track_distance" in stattr else "MHDP" + )) + print("{:-^4} {:-^4} {:-^6} {:-^4} {:-^4} {:-^4} {:-^3} {:-^7} {:-^7} {:-^7} {:-^7}".format( + "","","","","","","","","","","" + )) + for season in sorted_seasons: + try: + current_rank = ranks.index(getattr(season, stattr)) + 1 \ + if ranks.index(getattr(season, stattr)) + 1 \ + not in printedqty else None + except: + break + print("{:>3}{:1} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:>7.1f} {:>{ACELEN}f} {:>{ACELEN}f} {:>{ACELEN}f}".format( + current_rank if current_rank is not None else "", + "." if current_rank is not None else "", + season.year, + season.tracks, + season.landfall_TC, + season.TSreach, + season.HUreach, + season.MHUreach, + season.track_distance_TC, + season.track_distance_TS if "track_distance" in stattr \ + else season.ACE * math.pow(10,-4), + season.track_distance_HU if "track_distance" in stattr \ + else season.HDP * math.pow(10,-4), + season.track_distance_MHU if "track_distance" in stattr \ + else season.MHDP * math.pow(10,-4), + ACELEN = 7.1 if "track_distance" in stattr else 7.3 + )) + if current_rank is not None and current_rank not in printedqty: + printedqty.append(current_rank) + print("") + + def rank_seasons_thru(self, quantity, stattr, year1=None, year2=None, descending=True, **kw): + """Rank and compare *partial* tropical cyclone seasons to one another. + + * Of note, if neither `start` or `thru` keywords are included, this + function becomes a wrapper for .rank_seasons + + Required Arguments: + quantity: how long of a list of ranks do you want; an integer. + stattr: the storm attribute that you'd like to rank seasons by. + + * Storm Attributes: + "tracks", "landfall_TC", "TSreach", "HUreach", "MHUreach", + "track_distance_TC", "ACE", "track_distance_TS", "HDP", + "track_distance_HU", "MHDP", "track_distance_MHU" + + * Note: Though attributes "track_distance", "landfalls", + "landfall_TD", "landfall_TS", "landfall_HU", + "landfall_MHU", "TDonly", "TSonly", "HUonly", "cat45reach", + and "cat5reach" are valid storm attributes to rank by, + their quantities will not be visible in the ranking output. + + Default Arguments: + year1 = None: begin year. If included, the indicated year will + represent the low-end of years to assess. In the absence of + the end-year, all years from this begin year to the end of the + record-range will be used in ranking. + year2 = None: end year. If included, the indicated year will + represent the upper-end of years to assess. In the absence of + the begin-year, all years from the start of the record-range + to this indicated year will be used in ranking. + descending = True: parallel bool used to determine reverse kw of + sorted calls; whether results will be printed higher-to-lower + or not. + + Keyword Arguments: + start = (1, 1): list/tuple given to indicate the starting month and + day wherein a season's calculations will be made. + thru = (12,31): list/tuple representing the month and day that you + want to assess the seasons through. If start != (1,1) but thru + == (12,31), the stats reported will be through the Season's + ending. + + Examples: + --------- + .rank_seasons_thru(10, "ACE", thru=[8,31]): Retrieve a report + of tropical cyclone seasons sorted by the top-10 ACE values through + August 31. + .rank_seasons_thru(10, "TSreach", 1967, thru=[9,15]): Retrieve + a report of tropical cyclone seasons sorted by the top-10 totals of + tropical storms through September 15, since 1967 (the satellite + era). + .rank_seasons_thru(20, "track_distance_TC", start=[7,1], thru=(10,31)): + Retrieve a report of the top-20 seasons of total distance traversed + by storms while being designated as tropical cyclones, between July + 1st and the end of October. + """ + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + + # Partial-Season Bookened Month, Day Tuples + start = kw.get("start", (1,1)) + thru = kw.get("thru", (12,31)) + + # error if thru or start are not list/tuples + if type(thru) not in [list,tuple]: + return print("OOPS! Ensure thru is a list or tuple of (month,day)") + if type(start) not in [list,tuple]: + return print("OOPS! Ensure start is a list or tuple of (month,day)") + + # If the full year is being asked for, this is essentially just a + # wrapper for the regular rank_seasons method + if start == (1,1) and thru == (12,31): + # result = self.rank_seasons( + result = rank_seasons( + self, + quantity, + stattr, + year1, + year2, + descending, + info=kw.get("info") + ) + return result + + rseason = {} + # account for a non-existant season being requested by stats method + if kw.get("info") is not None and kw.get("info") not in self.season: + rseason[kw.get("info")] = dict( + tracks = 0, landfalls=0, landfall_TC = 0, landfall_TD = 0, + landfall_TS = 0, landfall_HU = 0, landfall_MHU = 0, + TSreach = 0, HUreach = 0, MHUreach = 0, track_distance = 0, + track_distance_TC = 0, track_distance_TS = 0, + track_distance_HU = 0, track_distance_MHU = 0, + ACE = 0, HDP = 0, MHDP = 0, cat45reach = 0, cat5reach = 0 + ) + for season in [ + s for s in self.season.values() \ + if year1 <= s.year <= year2 \ + or ( + kw.get("info") is not None \ + and s.year == kw.get("info") + ) + ]: + yr = season.year + rseason[yr] = dict( + tracks = 0, landfalls=0, landfall_TC = 0, landfall_TD = 0, + landfall_TS = 0, landfall_HU = 0, landfall_MHU = 0, + TSreach = 0, HUreach = 0, MHUreach = 0, track_distance = 0, + track_distance_TC = 0, track_distance_TS = 0, + track_distance_HU = 0, track_distance_MHU = 0, + ACE = 0, HDP = 0, MHDP = 0, cat45reach = 0, cat5reach = 0 + ) + for tc in season.tc.values(): + track_added = False + lndfls = False; lndfl_TC = False; lndfl_TD = False; + lndfl_TS = False; lndfl_HU = False; lndfl_MHU = False; + rTS = False; rHU = False; rMHU = False; r45 = False; r5 = False + entries = [ + trk for trk in tc.entry #\ + # if start <= trk.month_day_tuple <= thru + ] + for INDX, ENTRY in enumerate(tc.entry): + # Handle Track Distance related vars; + # only need to check validity of INDX-1 + # if INDX >= 1 and start <= tc.entry[INDX-1].month_day_tuple <= thru: + if INDX >= 1 \ + and ((thru != (12,31) and start <= tc.entry[INDX-1].month_day_tuple <= thru) \ + or (thru == (12,31) and datetime.date(tc.year, *start) <= tc.entry[INDX-1].entrytime.date())): + rseason[yr]["track_distance"] += haversine( + tc.entry[INDX-1].location, + tc.entry[INDX].location + ) + rseason[yr]["track_distance_TC"] += haversine( + tc.entry[INDX-1].location, + tc.entry[INDX].location + ) if tc.entry[INDX-1].status in ("SD","TD","SS","TS","HU") else 0 + rseason[yr]["track_distance_TS"] += haversine( + tc.entry[INDX-1].location, + tc.entry[INDX].location + ) if tc.entry[INDX-1].status in ("SS","TS","HU") else 0 + rseason[yr]["track_distance_HU"] += haversine( + tc.entry[INDX-1].location, + tc.entry[INDX].location + ) if tc.entry[INDX-1].status == "HU" else 0 + rseason[yr]["track_distance_MHU"] += haversine( + tc.entry[INDX-1].location, + tc.entry[INDX].location + ) if tc.entry[INDX-1].status == "HU" \ + and tc.entry[INDX-1].wind >= 96 else 0 + # Handle everything else + if (thru != (12,31) and start <= ENTRY.month_day_tuple <= thru) \ + or (thru == (12,31) and datetime.date(tc.year, *start) <= ENTRY.entrytime.date()): + # if start <= ENTRY.month_day_tuple <= thru: + rseason[yr]["ACE"] += math.pow(ENTRY.wind,2) \ + if ENTRY.wind >= 34 \ + and ENTRY.status in ("SS","TS","HU") \ + and ENTRY.is_synoptic \ + else 0 + rseason[yr]["HDP"] += math.pow(ENTRY.wind,2) \ + if ENTRY.wind >= 64 \ + and ENTRY.status == "HU" \ + and ENTRY.is_synoptic \ + else 0 + rseason[yr]["MHDP"] += math.pow(ENTRY.wind,2) \ + if ENTRY.wind >= 96 and ENTRY.status == "HU" \ + and ENTRY.is_synoptic \ + else 0 + if track_added is False: + rseason[yr]["tracks"] += 1 + track_added = True + if lndfls is False and ENTRY.record_identifier == "L": + rseason[yr]["landfalls"] += 1 + lndfls = True + if lndfl_TC is False and ENTRY.record_identifier == "L" \ + and ENTRY.is_TC: + rseason[yr]["landfall_TC"] += 1 + lndfl_TC = True + if lndfl_TD is False and ENTRY.record_identifier == "L" \ + and ENTRY.status in ["SD","TD"]: + rseason[yr]["landfall_TD"] += 1 + lndfl_TD = True + if lndfl_TS is False and ENTRY.record_identifier == "L" \ + and ENTRY.status in ["SS","TS","HU"]: + rseason[yr]["landfall_TS"] += 1 + lndfl_TS = True + if lndfl_HU is False and ENTRY.record_identifier == "L" \ + and ENTRY.status == "HU": + rseason[yr]["landfall_HU"] += 1 + lndfl_HU = True + if lndfl_MHU is False and ENTRY.record_identifier == "L" \ + and ENTRY.status == "HU" and ENTRY.wind >= 96: + rseason[yr]["landfall_MHU"] += 1 + lndfl_MHU = True + if rTS is False and ENTRY.status in ["SS","TS","HU"]: + rseason[yr]["TSreach"] += 1 + rTS = True + if rHU is False and ENTRY.status in ["HU"]: + rseason[yr]["HUreach"] += 1 + rHU = True + if rMHU is False and ENTRY.wind >= 96: + rseason[yr]["MHUreach"] += 1 + rMHU = True + if r45 is False and ENTRY.wind >= 114: + rseason[yr]["cat45reach"] += 1 + r45 = True + if r5 is False and ENTRY.wind >= 136: + rseason[yr]["cat5reach"] += 1 + r5 = True + + sorted_seasons = sorted( + [s for s in self.season.values() if year1 <= s.year <= year2], + key=lambda s: rseason[s.year][stattr], + reverse = descending + ) + # Values sorted + ranks = sorted( + set([ + rseason[s.year][stattr] for s in sorted_seasons \ + if descending is False \ + or (rseason[s.year][stattr] > 0 and kw.get("info") is None) \ + or kw.get("info") is not None + ]), + reverse = descending + )[:quantity] + + # RETURN if info method called this method + if kw.get("info", None) is not None: + if (year1 <= kw["info"] <= year2) is False: + ranks = sorted( + set(ranks + [rseason[kw["info"]][stattr]]), + reverse = descending + ) + return { + "seasonvalu": rseason[kw["info"]][stattr], + "rank": ranks.index(rseason[kw["info"]][stattr]) + 1, + "tied": len(["tie" for season in rseason.values() if season[stattr] == rseason[kw["info"]][stattr]]) - 1, + "outof": len(ranks) + } + + # List that holds printed quantities + printedqty = [] + + print("") + print("TOP {} SEASONS RANKED BY {}, {}".format( + len(ranks), + stattr.upper(), + "{}through {}".format( + "from {} ".format( + "{} {}".format( + calendar.month_abbr[start[0]], start[1] + ) + ) if "start" in kw else "", + "{} {}".format( + calendar.month_abbr[thru[0]], thru[1] + ) if thru != (12,31) else "End of Season" + ) + ).center(79) + ) + + print("{}{}".format( + str(self.basin()), + ", {}-{}".format(year1, year2) + ).center(79)) + print("-" * 79) + + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","","LAND","QTY","","","TC DIST", + "STATUS-RELATED TRACK" if "track_distance" in stattr else "ENERGY INDICES" + )) + print("{:4} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^25}".format( + "","","NUM OF","FALL","TRPC","QTY","QTY","TRAVRSD", + "DISTANCES (nmi)" if "track_distance" in stattr else "x10^4 kt^2" + )) + print("RANK YEAR {:^6} {:^4} {:^4} {:^4} {:^3} {:^7} {:^7} {:^7} {:^7}".format( + "TRACKS","TCs","STRM","HURR","MAJ","(nmi)", + "TRPCSTM" if "track_distance" in stattr else "ACE", + "HURRICN" if "track_distance" in stattr else "HDP", + "MAJHURR" if "track_distance" in stattr else "MHDP" + )) + print("{:-^4} {:-^4} {:-^6} {:-^4} {:-^4} {:-^4} {:-^3} {:-^7} {:-^7} {:-^7} {:-^7}".format( + "","","","","","","","","","","" + )) + for season in sorted_seasons: + try: + current_rank = ranks.index(rseason[season.year][stattr]) + 1 \ + if ranks.index(rseason[season.year][stattr]) + 1 \ + not in printedqty else None + except: + # indicates bounds beyond quantity asked for exceeded + break + print("{:>3}{:1} {:4} {:^6} {:^4} {:^4} {:^4} {:^3} {:>7.1f} {:>{ACELEN}f} {:>{ACELEN}f} {:>{ACELEN}f}".format( + current_rank if current_rank is not None else "", + "." if current_rank is not None else "", + season.year, + rseason[season.year]["tracks"], + rseason[season.year]["landfall_TC"], + rseason[season.year]["TSreach"], + rseason[season.year]["HUreach"], + rseason[season.year]["MHUreach"], + rseason[season.year]["track_distance_TC"], + rseason[season.year]["track_distance_TS"] if "track_distance" in stattr else rseason[season.year]["ACE"] * math.pow(10,-4), + rseason[season.year]["track_distance_HU"] if "track_distance" in stattr else rseason[season.year]["HDP"] * math.pow(10,-4), + rseason[season.year]["track_distance_MHU"] if "track_distance" in stattr else rseason[season.year]["MHDP"] * math.pow(10,-4), + ACELEN = 7.1 if "track_distance" in stattr else 7.3 + )) + if current_rank is not None and current_rank not in printedqty: + printedqty.append(current_rank) + print("") + + def _season_stats_str(self, seasonreq, year1, year2, rstart, rthru, width, **kw): + strlist = [] + yr = seasonreq + strlist.append("-" * width) + strlist.append("Tropical Cyclone Stats for {}".format(yr).center(width)) + strlist.append( + "{}{}".format( + self.basin(), + "" + ).center(width) + ) + strlist[-1] += "\n" + + statyrline = "Stats calculated for Seasons {}".format( + "{}-{}".format( + year1, + year2 + ) if year2 != self.record_range[1] \ + else "since {} ({} total seasons)".format( + year1, + self.record_range[1] - year1 + 1 + ) + ).center(width) + strlist.append(statyrline) + + if rstart != (1,1) or rthru != (12,31): + strlist.append( + "from {} thru {}".format( + "{} {}".format( + calendar.month_name[rstart[0]], + rstart[1], + ), + "{} {}".format( + calendar.month_name[rthru[0]], + rthru[1], + ) + ).center(width) + ) + strlist[-1] += "\n" + for line in textwrap.wrap( + "* TS-related Statistics include Hurricanes in their totals" \ + " except for landfall data", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4 + ): + strlist.append(line.center(width)) + strlist[-1] += "\n" + if any(1971 <= y <= 1990 for y in range(year1, year2 + 1)): + for line in textwrap.wrap( + "* Hurdat2 Landfall data incomplete for seasons 1971-1990", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4 + ): + strlist.append(line.center(width)) + strlist.append("-" * width) + + for attr, label in [ + ("tracks", "Tropical Cyclones"), + ("track_distance_TC", "TC Track Distance"), + ("track_distance_TS", "TS Distance"), + ("track_distance_HU", "HU Distance"), + ("track_distance_MHU", "MHU Distance"), + ("TSreach", "Tropical Storms"), + ("ACE", "ACE"), + ("HUreach", "Hurricanes"), + ("HDP", "HDP"), + ("MHUreach", "Major Hurricanes"), + ("MHDP", "MHDP"), + ("landfall_TC", "Total Landfalling TC's"), + ("landfall_TS", "TS Landfalls"), + ("landfall_HU", "HU Landfalls") + ]: + if "landfall" not in attr or ("landfall" in attr and all(1971 <= y <= 1990 for y in range(year1, year2)) is False): + rankinfo = self.rank_seasons_thru( + 1337, + attr, + year1, + year2, + start = rstart, + thru = rthru, + descending=kw.get("descending", True), + info=yr + ) + strlist.append('{:<35}Rank {}/{}{}'.format( + "* {}: {}{} ".format( + label, + "{:.1f}".format(rankinfo["seasonvalu"]) \ + if "distance" in attr \ + else ("{:.1f}".format(rankinfo["seasonvalu"] * 10 ** (-4)) \ + if attr in ["ACE", "HDP", "MHDP"] \ + else rankinfo["seasonvalu"] + ), + " nmi" if "track_distance" in attr \ + else (" * 10^4 kt^2" \ + if attr in ["ACE", "HDP", "MHDP"] else "" + ), + ), + rankinfo["rank"], + rankinfo["outof"], + " (tied w/{} other season{})".format( + rankinfo["tied"], + "s" if rankinfo["tied"] >= 2 else "" + ) if rankinfo["tied"] > 0 else "" + )) + strlist.append("\n") + return "\n".join(strlist) + + def _season_stats(self, seasonreq, year1, year2, rstart, rthru, width, **kw): + + yr = seasonreq + + print("") + print("-" * width) + print("Tropical Cyclone Stats for {}".format(yr).center(width)) + print("{}{}".format( + self.basin(), + "" + ).center(width) + ) + print("") + for line in textwrap.wrap( + "Stats calculated for Seasons {}".format( + "{}-{}".format( + year1, + year2 + ) if year2 != self.record_range[1] \ + else "since {} ({} total seasons)".format( + year1, + self.record_range[1] - year1 + 1 + ) + ), + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4): + print(line.center(width)) + if rstart != (1,1) or rthru != (12,31): + print( + "from {} thru {}".format( + "{} {}".format( + calendar.month_name[rstart[0]], + rstart[1], + ), + "{} {}".format( + calendar.month_name[rthru[0]], + rthru[1], + ) + ).center(width) + ) + print("") + for line in textwrap.wrap( + "* TS-related Statistics include Hurricanes in their totals" \ + " except for landfall data", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4): + print(line.center(width)) + + print("") + # Only print this disclaimer if years in this range overlap + if any(1971 <= y <= 1990 for y in range(year1, year2 + 1)): + for line in textwrap.wrap( + "* Hurdat2 Landfall data incomplete for seasons 1971-1990", + width, + initial_indent=" " * 4, + subsequent_indent=" " * 4): + print(line.center(width)) + print("-" * width) + + for attr, label in [ + ("tracks", "Tropical Cyclones"), + ("track_distance_TC", "TC Track Distance"), + ("track_distance_TS", "TS Distance"), + ("track_distance_HU", "HU Distance"), + ("track_distance_MHU", "MHU Distance"), + ("TSreach", "Tropical Storms"), + ("ACE", "ACE"), + ("HUreach", "Hurricanes"), + ("HDP", "HDP"), + ("MHUreach", "Major Hurricanes"), + ("MHDP", "MHDP"), + ("landfall_TC", "Total Landfalling TC's"), + ("landfall_TS", "TS Landfalls"), + ("landfall_HU", "HU Landfalls") + ]: + if "landfall" not in attr or ("landfall" in attr and all(1971 <= y <= 1990 for y in range(year1, year2)) is False): + # rankinfo = self.rank_seasons_thru( + rankinfo = self.new_rank_seasons( + 1337, + attr, + year1, + year2, + start = rstart, + thru = rthru, + descending=kw.get("descending", True), + info=yr + ) + print('{:<35}Rank {}/{}{}'.format( + "* {}: {}{} ".format( + label, + "{:.1f}".format(rankinfo["seasonvalu"]) \ + if "distance" in attr \ + else ("{:.1f}".format(rankinfo["seasonvalu"] * 10 ** (-4)) \ + if attr in ["ACE", "HDP", "MHDP"] \ + else rankinfo["seasonvalu"] + ), + " nmi" if "track_distance" in attr \ + else (" * 10^4 kt^2" \ + if attr in ["ACE", "HDP", "MHDP"] else "" + ), + ), + rankinfo["rank"], + rankinfo["outof"], + " (tied w/{} other season{})".format( + rankinfo["tied"], + "s" if rankinfo["tied"] >= 2 else "" + ) if rankinfo["tied"] > 0 else "" + )) + print("") + +class Null: pass \ No newline at end of file diff --git a/hurdat2parser/_future.py b/hurdat2parser/_future.py new file mode 100644 index 0000000..3012a17 --- /dev/null +++ b/hurdat2parser/_future.py @@ -0,0 +1,495 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import statistics +import math +import operator +import secrets + +from . import _maps +from . import _calculations + +import matplotlib +import matplotlib.style as mplstyle +import matplotlib.pyplot as plt +import matplotlib.ticker as _ticker +import matplotlib.dates as _dates +import matplotlib.figure as _figure +import matplotlib.patches as _patches + +class Hurdat2: + def draw_ellipse_quadrants(self, xy, width, height, angle=0, **kwargs): + e = Ellipsoid(xy, width, height, angle, **kwargs) + + a = plt.axes(aspect="equal", adjustable="datalim") + a.fill([x for x,y in e.slice_ne], [y for x,y in e.slice_ne], color="blue") + a.fill([x for x,y in e.slice_se], [y for x,y in e.slice_se], color="red") + a.fill([x for x,y in e.slice_sw], [y for x,y in e.slice_sw], color="green") + a.fill([x for x,y in e.slice_nw], [y for x,y in e.slice_nw], color="yellow") + a.autoscale() + plt.show(block=False) + + def random(self, year1=None, year2=None, **kw): + """ + *** ONLY positional keywords (year1 and year2) recognized right now *** + + Returns a random object from the database, optionally + based upon various criteria. + + Required Keyword Arguments + ------------------------- + year1 (None): the start year; defaults to beginning year of the + database. + year2 (None): the end year; defaults to the end of the database. + + Other criteria + -------------- + * All other keyword arguments can be valid + properties/attributes. Their values can be tuples of a stringified + comparison operator and a value or just a value (the "==" operator + will be implied) + + Examples: + ========= + atl.random(saffir_simpson = 5) -> A TCyc where winds reached + category 5 strength + atl.random(minmslp=("<=", 920), ace=(">=", 30)) -> minimum mslp + was less-than-or-equal to 920mb and ACE >= 30*10^-4 + atl.random(1967, duration_TC=(">=", 10)) -> a TCyc occurring no + sooner than 1967 that persisted for an accumulated 10+ days + as a designated tropical cyclone. + """ + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + + return secrets.choice([ + tcyc for tcyc in self.tc.values() + if year1 <= tcyc.year <= year2 + ]) + +class Season: + + def track_map(self, **kw): + fig = plt.figure( + # figsize = (_w, _h), + layout = "constrained", + ) + figman = plt.get_current_fig_manager() + # figman.set_window_title( + # "{} - {} Tracks".format( + # self.atcfid, + # self.name + # ) + # ) + rc = matplotlib.rcParams + ax = plt.axes( + facecolor = kw.get("ocean", "lightblue") + ) + + for tc in self.tc.values(): + ax.plot( + [entry.lon for entry in tc.entry], + [entry.lat for entry in tc.entry], + color = "hotpink" if _calculations.saffir_simpson_scale(tc.maxwind) == 5 else \ + "purple" if _calculations.saffir_simpson_scale(tc.maxwind) == 4 else \ + "red" if _calculations.saffir_simpson_scale(tc.maxwind) == 3 else \ + "orange" if _calculations.saffir_simpson_scale(tc.maxwind) == 2 else \ + "yellow" if _calculations.saffir_simpson_scale(tc.maxwind) == 1 else \ + "green" if _calculations.saffir_simpson_scale(tc.maxwind) == 0 else \ + "black", + ) + ax.text( + tc.entry[0].lon, + tc.entry[0].lat, + "{}{}".format( + tc.name if tc.name != "UNNAMED" else "", + "{}{}{}".format( + " (" if tc.name != "UNNAMED" else "", + tc.atcfid, + ")" if tc.name != "UNNAMED" else "", + ) + ) + ) + # Draw Map + for postal, geo in _maps._polygons: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = kw.get("land", "lightseagreen"), + edgecolor = "black", + linewidth = 0.5, + ) + for lake, geo in _maps._lakes: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = kw.get("ocean", "lightblue"), + edgecolor = "black", + linewidth = 0.3, + ) + + ax.set_xlim( + int(min(entry.lon for tc in self.tc.values() for entry in tc.entry))-5, + int(max(entry.lon for tc in self.tc.values() for entry in tc.entry))+5, + ) + ax.set_ylim( + int(min(entry.lat for tc in self.tc.values() for entry in tc.entry))-5, + int(max(entry.lat for tc in self.tc.values() for entry in tc.entry))+5, + ) + + plt.show() + + @property + def wind_volume_TSstrength(self): + """ + Returns the seasonal aggregated tropical storm-strength wind volume, an + integration of areal tropical-storm wind extent over distance. + + Units are nmi^3. + + README.md write-up: - `wind_volume_` + - Wind Volumes: integrated areal-extents over distances. The goal of including these variables are to complement energy indices through representing wind-field areal expanse. + - `` can be `TSstrength`, `TS`, `TS50strength`, `TS50`, `HUstrength`, or `HU`. + - Of note, quadrant-based wind-field extents have only been recorded in the atlantic and pacific Hurdat2 databases since 2004. So this variable will have no use for prior years to that time. + attributes/methods table entry: `wind_volume_`
*\*<SUFFIX> can be TSstrength, TS, TS50strength, TS50, HUstrength, or HU.* | An integration of wind-field expanse over distance | `atl[2019,13].wind_volume_HU` + """ + return sum(tcyc.wind_volume_TSstrength for tcyc in self.tc.values()) + + @property + def wind_volume_TS(self): + """ + Returns the seasonal aggregated tropical storm wind volume, an + integration of areal tropical-storm wind extent over distance while the + storm acquired the objective designation of at-least Tropical Storm + (SS, TS, HU). + + Units are nmi^3. + """ + return sum(tcyc.wind_volume_TS for tcyc in self.tc.values()) + + @property + def wind_volume_TS50strength(self): + """ + Returns the seasonal aggregated gale-force wind volume, an integration + of areal gale-force wind extent (>= 50kts) over distance. + + Units are nmi^3. + """ + return sum(tcyc.wind_volume_TS50strength for tcyc in self.tc.values()) + + @property + def wind_volume_TS50(self): + """ + Returns the seasonal aggregated gale-force wind volume, an integration + of areal gale-force wind extent (>= 50kts) over distance, while the + storm acquired the objective designation of at-least Tropical Storm + (SS, TS, HU). + + Units are nmi^3 + """ + return sum(tcyc.wind_volume_TS50 for tcyc in self.tc.values()) + + + @property + def wind_volume_HUstrength(self): + """ + Returns the seasonal aggregated hurricane-strength wind volume, an + integration of areal hurricane wind extent over distance. + + Units are nmi^3. + """ + return sum(tcyc.wind_volume_HUstrength for tcyc in self.tc.values()) + + @property + def wind_volume_HU(self): + """ + Returns the seasonal aggregated hurricane wind volume, an integration + of areal hurricane wind extent over distance, while the storm acquired + the objective designation of Hurricane (HU). + + Units are nmi^3. + """ + return sum(tcyc.wind_volume_HU for tcyc in self.tc.values()) + +class TropicalCyclone: + + def stats_graph(self): + fig = plt.figure( + layout = "constrained", + ) + + ax = plt.axes( + + ) + ax2 = ax.twinx( + + ) + self._hd2.ax = ax + self._hd2.ax2 = ax2 + # Primary + ax.plot_date( + [entry.entrytime for entry in self.entry], + [entry.wind for entry in self.entry], + "-", + color = "red", + ) + ax.xaxis.set_major_locator(_dates.DayLocator()) + ax.tick_params("x", labelrotation=90) + ax.yaxis.set_major_locator( + _ticker.MaxNLocator( + nbins = 11, + steps = [5,10], + integer = True, + min_n_ticks = 5 + ) + ) + ax.set_xlabel("Date") + ax.set_ylabel("Max Wind") + # Secondary + ax2.plot_date( + [entry.entrytime for entry in self.entry], + [ + entry.mslp if entry.mslp is not None else 1013 + for entry in self.entry + ], + "--", + color = "blue", + ) + ax2.set_ylabel("MSLP (hPa)") + # ax2.yaxis.set_major_locator( + # _ticker.MaxNLocator( + # nbins = 11, + # steps = [5,10], + # integer = True, + # min_n_ticks = 5 + # ) + # ) + # 917.5 + # Make graph even + ax.set_ylim( + math.floor(ax.get_ylim()[0]) - math.floor(ax.get_ylim()[0]) % 10, + math.ceil(ax.get_ylim()[1]) + math.ceil(ax.get_ylim()[1]) % 10 + ) + # ax2.set_ylim(bottom=math.floor(ax2.get_ylim()[0]) - math.floor(ax2.get_ylim()[0]) % 10) + ax2.set_ylim( + math.floor(ax2.get_ylim()[0]) - math.floor(ax2.get_ylim()[0]) % 10, + math.ceil(ax2.get_ylim()[1]) + math.ceil(ax2.get_ylim()[1]) % 10 + ) + while operator.sub(*(list(reversed(ax2.get_ylim())))) % len(ax.get_yticks()) != 0: + if (ax2.get_ylim()[1]-ax2.get_ylim()[0]) % 10 != 0: + ax2.set_ylim(bottom=ax2.get_ylim()[0] - 1) + else: + ax2.set_ylim(top=ax2.get_ylim()[1] + 1) + ax2.yaxis.set_major_locator( + _ticker.LinearLocator( + len(ax.get_yticks()) + ) + ) + + ax.grid(True) + ax2.grid(True) + plt.show(block=False) + + @property + def wind_volume_TSstrength(self): + """ + Returns the tropical storm-strength wind volume, an integration of + areal tropical-storm wind extent over distance. Resultant units of + integration are nmi^3, hence the variable name. + + *Important Note: As recorded wind-extents aren't dependent on tropical- + cyclone status, this variable is also non-discriminatory of status. For + a status-based wind-volume, use one of the following suffixes: TS, + TS50, or HU. + """ + return sum( + 1 / 2 * (en.areal_extent_TS + en.previous_entry.areal_extent_TS) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + ) + + @property + def wind_volume_TS(self): + """ + Returns the tropical storm wind volume, an integration of areal + tropical-storm wind extent over distance while the storm acquired the + objective designation of at-least Tropical Storm (SS, TS, HU). + Resultant units of integration are nmi^3, hence the variable name. + """ + return sum( + 1 / 2 * (en.areal_extent_TS + en.previous_entry.areal_extent_TS) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.status in ("SS", "TS", "HU") + ) + + @property + def wind_volume_TS50strength(self): + """ + Returns the gale-force-strength wind volume, an integration of areal + gale-force wind extent (>=50kts) over distance. Resultant units of + integration are nmi^3, hence the variable name. + + *Important Note: As recorded wind-extents aren't dependent on tropical- + cyclone status, this variable is also non-discriminatory of status. For + a status-based wind-volume, use one of the following suffixes: TS, + TS50, or HU. + """ + return sum( + 1 / 2 * (en.areal_extent_TS50 + en.previous_entry.areal_extent_TS50) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + ) + + @property + def wind_volume_TS50(self): + """ + Returns the gale-force tropical storm wind volume, an integration of + areal tropical-storm wind extent over distance while the storm acquired + the objective designation of at-least Tropical Storm (SS, TS, HU). + Resultant units of integration are nmi^3, hence the variable name. + """ + return sum( + 1 / 2 * (en.areal_extent_TS50 + en.previous_entry.areal_extent_TS50) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.status in ("SS", "TS", "HU") + ) + + @property + def wind_volume_HUstrength(self): + """ + Returns the hurricane-strength wind volume, an integration of areal + hurricane wind extent over distance. Resultant units of integration are + nmi^3, hence the variable name. + + *Important Note: As recorded wind-extents aren't dependent on tropical- + cyclone status, this variable is also non-discriminatory of status. For + a status-based wind-volume, use one of the following suffixes: TS, + TS50, or HU. + """ + return sum( + 1 / 2 * (en.areal_extent_HU + en.previous_entry.areal_extent_HU) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + ) + + + @property + def wind_volume_HU(self): + """ + Returns the hurricane wind volume, an integration of areal hurricane + wind extent over distance while the storm acquired the objective + designation of Hurricane (HU). Resultant units of integration are + nmi^3, hence the variable name. + """ + return sum( + 1 / 2 * (en.areal_extent_HU + en.previous_entry.areal_extent_HU) + * haversine(en.previous_entry.location, en.location) + for en in self.entry + if en.previous_entry is not None + and en.previous_entry.status == "HU" + ) + + def areal_extent_graph(self): + fig = plt.figure( + # figsize = (_w, _h), + layout = "constrained", + ) + # tropical storm extent + plt.fill_between( + [ + en.track_distance + for en in self.entry + if any( + direction is not None + for direction in en.extent_TS + ) + ], + [ + en.areal_extent_TS + for en in self.entry + if any( + direction is not None + for direction in en.extent_TS + ) + ], + color = "green", + ) + # ts extent - outline + # plt.plot( + # [ + # en.track_distance + # for en in self.entry + # if any( + # direction is not None + # for direction in en.extent_TS + # ) + # ], + # [ + # en.areal_extent_TS + # for en in self.entry + # if any( + # direction is not None + # for direction in en.extent_TS + # ) + # ], + # color="black", + # linewidth=1, + # ) + + # gale extent (ts50) + plt.fill_between( + [en.track_distance for en in self.entry], + [en.areal_extent_TS50 for en in self.entry], + color = (0, 1, 0.5), + ) + + # hu extent + plt.fill_between( + [en.track_distance for en in self.entry], + [en.areal_extent_HU for en in self.entry], + color = (1, 1, 0), + ) + + plt.ylabel("Area (sq. nautical miles)") + plt.xlabel("Track Distance (nautical miles)") + plt.grid(True, "both", color="black", linestyle=":") + plt.show(block=False) + +class TCRecordEntry: + pass + +class blah: + pass \ No newline at end of file diff --git a/hurdat2parser/_gis.py b/hurdat2parser/_gis.py new file mode 100644 index 0000000..10043ce --- /dev/null +++ b/hurdat2parser/_gis.py @@ -0,0 +1,359 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import collections +import math + +from . import _calculations + +class Coordinate(collections.namedtuple("Coordinate", ["lon", "lat"])): + """ + Simple class that allows x and y as aliases of longitude (lon) and latitude + (lat). Represents a point in a cartesian plane. + """ + @property + def x(self): + return self.lon + + @property + def y(self): + return self.lat + +class BoundingBox(collections.namedtuple("BoundingBox", ["p1", "p2"])): + """ + A box (rectangle) whose extents are defined from two points (coordinates) + in space. + + An alternate (and maybe more preferable) way to name (or at least think of) this class would be Segment, as two points also make a line. + + Arguments must be of type + """ + + def __repr__(self): + return str({ + k:v + for k, v in list(self._asdict().items()) + [ + + ] + }) + + def __contains__(self, point): + if not isinstance(point, Coordinate): + point = Coordinate(*point) + return ( + self.w <= point.lon <= self.e + ) and ( + self.s <= point.lat <= self.n + ) + + @property + def area(self): + """The width * height of the box""" + return abs(self.delta_lon * self.delta_lat) + + @property + def delta_lon(self): + """The change in longitude (x).""" + return self.p2.lon - self.p1.lon + + @property + def delta_x(self): + """The change in longitude (x).""" + return self.delta_lon + + @property + def delta_lat(self): + """The change in latitude (y).""" + return self.p2.lat - self.p1.lat + + @property + def delta_y(self): + """The change in latitude (y).""" + return self.delta_lat + + @property + def hypotenuse(self): + """ + The length of the segment made of the two defined Bounding + Box points. + """ + return math.hypot(self.delta_lat, self.delta_lon) + + @property + def length(self): + """ + The length of the segment (in degrees) made of the two defined Bounding + Box points. + """ + return self.hypotenuse + + @property + def theta(self): + """The angle made by the bounding-box defined points.""" + return math.degrees( + math.atan2(self.delta_lat, self.delta_lon) + ) + + @property + def heading(self): + """ + The vector direction (navigational; 0 = North) of the bounding-box + segment in degrees (0-360). + """ + return _calculations.direction( + self.p1.lat, self.p1.lon, + self.p2.lat, self.p2.lon, + ) + + def intersects(self, otherbb): + """ + Returns whether or not this bounding box shares space with another + bounding box. + + Arguments: + otherbb: The other bounding box needed for comparison + """ + if ( + otherbb.s <= self.s <= otherbb.n + or otherbb.s <= self.n <= otherbb.n + or self.s <= otherbb.s <= self.n + or self.s <= otherbb.n <= self.n + ) and ( + otherbb.w <= self.w <= otherbb.e + or otherbb.w <= self.e <= otherbb.e + or self.w <= otherbb.w <= self.e + or self.w <= otherbb.e <= self.e + ): + return True + return False + + def rotate(self, deg, rpoint=None): + """ + Rotates the (or segment) by a requested angle (in + degrees) with respect to an optionally-requested origin or rotational + point. It then returns a new instance. + + Arguments + --------- + deg: the angle shift in degrees + + Default Arguments + ----------------- + rpoint (None): If nothing is passed, the center of the + is used as the rotational point. If one would + want a different point to rotate about, pass it in (x, y) + tuple form + """ + if rpoint is None: + rpoint = Coordinate(*self.center) + else: + rpoint = Coordinate(*rpoint) + + # print(rpoint, self, self.center) + theta = math.radians(self.theta + deg) + dx = math.cos(theta) * self.hypotenuse + dy = math.sin(theta) * self.hypotenuse + + return BoundingBox( + rpoint, + Coordinate( + rpoint.x + dx, + rpoint.y + dy + ) + ) + + def scale(self, factor=1, return_bb=True): + scaled_coords = ( + self.p1.x + self.delta_x * factor, + self.p1.y + self.delta_y * factor + ) + if return_bb: + return BoundingBox( + self.p1, + Coordinate(*scaled_coords) + ) + else: + return scaled_coords + + def delta_hypot(self, length): + # sin(0) = opp / hypot + return BoundingBox( + self.p1, + Coordinate( + self.p1.x + length * math.cos(math.radians(self.theta)), + self.p1.y + length * math.sin(math.radians(self.theta)) + ) + ) + + @property + def center(self): + """The center of the bounding box.""" + return ( + (self.p2.lon - self.p1.lon) / 2 + self.p1.lon, + (self.p2.lat - self.p1.lat) / 2 + self.p1.lat, + ) + + @property + def height(self): + """ + The height of the bounding box in degrees. In essence, it is the + absolute value of delta_y. + """ + return abs(self.p2.lat - self.p1.lat) + + @property + def width(self): + """ + The width of the bounding box in degrees. In essence, it is the + absolute value of delta_x. + """ + return abs(self.p2.lon - self.p1.lon) + + @property + def isvertical(self): + """ + Returns True if the longitudes of the points of the bounding box are + the same, implying a vertical or north/south oriented bbox or segment. + """ + return self.p1.lon == self.p2.lon + + @property + def slope(self): + """ + Returns the dy/dx of the segment formed by the bounding box points. + + It will return None if the bounding box segment is vertical. + """ + try: + return (self.p2.lat - self.p1.lat) / (self.p2.lon - self.p1.lon) + except: + return None + + @property + def b(self): + """ + The "y-intercept" of the bounding-box segment. If the said segement is + vertical, it will return None. + """ + try: + return self.p1.lat - self.slope * self.p1.lon + except: + return None + + @property + def n(self): + """The northern most extent (top) of the bounding box.""" + return max(self.p1.lat, self.p2.lat) + + @property + def s(self): + """The southern most extent (bottom) of the bounding box.""" + return min(self.p1.lat, self.p2.lat) + + @property + def ns(self): + """ + Tuple of the south/north (bottom and top) extents of the bounding box. + """ + return (self.s, self.n) + + @property + def e(self): + """ + Eastern (right) most extent of the bounding box. This does not account + for 180deg traversals. + """ + return max(self.p1.lon, self.p2.lon) + + @property + def w(self): + """ + Western (left) most extent of the bounding box. This does not account + for 180deg traversals. + """ + return min(self.p1.lon, self.p2.lon) + + @property + def ew(self): + """ + Tuple of the west/east (left and right) extents of the bounding box. + """ + return (self.w, self.e) + + @property + def sw(self): + """ + Coordinate of the southwest (bottom-left) point of the bounding box + (lon, lat). + """ + return (min([self.p1.lon, self.p2.lon]), min([self.p1.lat, self.p2.lat])) + + @property + def se(self): + """ + Coordinate of the southeast (bottom-right) point of the bounding box + (lon, lat). + """ + return (max([self.p1.lon, self.p2.lon]), min([self.p1.lat, self.p2.lat])) + + @property + def ne(self): + """ + Coordinate of the northeast (top-right) point of the bounding box + (lon, lat). + """ + return (max([self.p1.lon, self.p2.lon]), max([self.p1.lat, self.p2.lat])) + + @property + def nw(self): + """ + Coordinate of the northwest (top-left) point of the bounding box + (lon, lat). + """ + return (min([self.p1.lon, self.p2.lon]), max([self.p1.lat, self.p2.lat])) + +class Hurdat2GIS: + us_gulf_coast = [(-81.11, 25.138), (-81.365, 25.831), (-81.716, 25.983), (-82.715, 27.5), (-82.844, 27.846), (-82.664, 28.492), (-82.651, 28.887), (-83.279, 29.44), (-83.694, 29.926), (-84.044, 30.104), (-84.31, 30.065), (-84.383, 29.907), (-85.008, 29.607), (-85.376, 29.695), (-85.676, 30.122), (-86.454, 30.399), (-86.68, 30.403), (-87.476, 30.294), (-87.49, 30.378), (-87.622, 30.265), (-88.006, 30.231), (-88.135, 30.367), (-88.4, 30.371), (-88.692, 30.355), (-88.905, 30.415), (-89.224, 30.332), (-89.321, 30.345), (-89.443, 30.223), (-89.521, 30.193), (-89.401, 30.046), (-89.358, 29.921), (-89.354, 29.82), (-89.721, 29.619), (-89.514, 29.42), (-89.181, 29.336), (-89.016, 29.203), (-89.021, 29.143), (-89.156, 29.017), (-89.376, 28.981), (-89.443, 29.194), (-89.792, 29.333), (-90.053, 29.43), (-90.053, 29.337), (-90.118, 29.141), (-90.231, 29.103), (-90.302, 29.256), (-90.503, 29.3), (-90.678, 29.151), (-90.751, 29.131), (-91.29, 29.289), (-91.244, 29.457), (-91.565, 29.605), (-91.831, 29.486), (-92.084, 29.593), (-92.261, 29.557), (-92.688, 29.599), (-93.176, 29.779), (-93.388, 29.777), (-93.695, 29.77), (-93.826, 29.725), (-93.884, 29.81), (-93.794, 29.977), (-93.946, 29.815), (-93.89, 29.689), (-94.084, 29.673), (-94.775, 29.346), (-95.274, 28.964), (-95.853, 28.64), (-96.764, 28.153), (-97.061, 27.822), (-97.385, 27.243), (-97.351, 26.801), (-97.171, 26.159), (-97.14, 26.03), (-97.146, 25.961)] + + us_east_coast = [(-67.13, 45.138), (-66.987, 44.828), (-67.191, 44.676), (-68.057, 44.384), (-68.305, 44.257), (-69.068, 44.092), (-69.244, 43.975), (-69.526, 43.905), (-69.808, 43.775), (-70.203, 43.626), (-70.512, 43.341), (-70.642, 43.134), (-70.733, 43.07), (-70.806, 42.877), (-70.829, 42.825), (-70.604, 42.65), (-71.046, 42.331), (-70.738, 42.229), (-70.516, 41.798), (-70.021, 41.826), (-70.241, 42.091), (-70.109, 42.078), (-69.974, 41.966), (-69.949, 41.677), (-70.666, 41.527), (-70.666, 41.695), (-71.169, 41.489), (-71.234, 41.707), (-71.241, 41.492), (-71.523, 41.379), (-71.842, 41.336), (-72.925, 41.285), (-73.63, 40.992), (-73.987, 40.751), (-73.574, 40.92), (-72.625, 40.992), (-72.274, 41.153), (-71.903, 41.061), (-72.676, 40.791), (-73.229, 40.652), (-73.9, 40.571), (-74.015, 40.581), (-73.958, 40.328), (-74.08, 39.788), (-74.474, 39.343), (-74.794, 39.002), (-74.923, 38.941), (-75.413, 39.281), (-75.074, 38.775), (-75.038, 38.456), (-75.136, 38.181), (-75.226, 38.04), (-75.587, 37.559), (-75.812, 37.425), (-75.934, 37.152), (-75.966, 36.862), (-75.857, 36.551), (-75.758, 36.229), (-75.491, 35.746), (-75.456, 35.564), (-75.465, 35.449), (-75.544, 35.24), (-75.964, 35.119), (-76.504, 34.643), (-77.134, 34.708), (-77.65, 34.358), (-77.861, 34.149), (-77.928, 33.94), (-78.013, 33.912), (-78.406, 33.918), (-78.564, 33.877), (-78.92, 33.659), (-79.229, 33.185), (-79.941, 32.667), (-80.872, 32.03), (-81.258, 31.436), (-81.504, 30.731), (-81.368, 30.208), (-81.254, 29.806), (-80.889, 29.03), (-80.534, 28.479), (-80.581, 28.19), (-80.104, 27.059), (-80.048, 26.586), (-80.123, 25.83), (-80.328, 25.427), (-80.485, 25.23), (-80.737, 25.156), (-81.11, 25.138)] + + us_west_coast = [(-117.128, 32.533), (-117.137, 32.649), (-117.243, 32.664), (-117.271, 32.806), (-117.319, 33.1), (-117.467, 33.296), (-117.789, 33.538), (-118.081, 33.722), (-118.294, 33.712), (-118.41, 33.744), (-118.393, 33.858), (-118.506, 34.017), (-118.832, 34.024), (-119.236, 34.164), (-119.268, 34.257), (-119.606, 34.418), (-119.853, 34.412), (-120.053, 34.469), (-120.481, 34.472), (-120.645, 34.58), (-120.663, 34.949), (-120.634, 35.076), (-120.857, 35.21), (-121.284, 35.676), (-121.877, 36.331), (-121.919, 36.572), (-121.79, 36.732), (-121.881, 36.939), (-122.164, 36.991), (-122.395, 37.208), (-122.514, 37.772), (-123.001, 38.019), (-123.046, 38.305), (-123.701, 38.907), (-123.82, 39.368), (-123.833, 39.775), (-124.324, 40.252), (-124.372, 40.491), (-124.072, 41.46), (-124.54, 42.813), (-124.149, 43.692), (-123.929, 45.577), (-124.113, 46.863), (-124.46, 47.784), (-124.621, 47.904), (-124.71, 48.38), (-123.976, 48.168), (-122.779, 48.138), (-122.657, 48.49), (-122.789, 48.993)] + + mexico_east_coast = [(-97.146, 25.961), (-97.164, 25.755), (-97.225, 25.585), (-97.424, 25.233), (-97.668, 24.39), (-97.766, 23.306), (-97.758, 22.886), (-97.858, 22.625), (-97.763, 22.106), (-97.315, 21.564), (-97.396, 21.187), (-97.186, 20.717), (-96.456, 19.87), (-96.368, 19.567), (-96.29, 19.344), (-95.985, 19.054), (-95.913, 18.897), (-95.561, 18.719), (-95.182, 18.701), (-94.798, 18.515), (-94.546, 18.175), (-94.189, 18.195), (-93.552, 18.43), (-92.71, 18.612), (-91.974, 18.716), (-91.437, 18.89), (-90.739, 19.352), (-90.693, 19.73), (-90.492, 19.947), (-90.353, 21.009), (-88.132, 21.616), (-87.128, 21.621), (-86.824, 21.422), (-86.772, 21.151), (-86.926, 20.786), (-87.421, 20.231), (-87.435, 19.502), (-87.853, 18.269), (-88.039, 18.484), (-88.296, 18.472)] + + mexico_west_coast = [(-92.235, 14.545), (-93.734, 15.888), (-94.471, 16.187), (-95.134, 16.177), (-95.464, 15.975), (-96.511, 15.652), (-97.755, 15.967), (-98.762, 16.535), (-99.691, 16.72), (-101.002, 17.276), (-101.6, 17.652), (-101.919, 17.96), (-102.7, 18.063), (-103.442, 18.325), (-103.912, 18.828), (-104.405, 19.091), (-104.938, 19.309), (-105.669, 20.386), (-105.245, 20.634), (-105.492, 20.777), (-105.237, 21.119), (-105.209, 21.491), (-105.431, 21.618), (-105.649, 21.988), (-105.646, 22.327), (-105.792, 22.627), (-107.085, 24.016), (-107.951, 24.615), (-108.281, 25.082), (-109.385, 25.727), (-109.426, 26.033), (-109.2, 26.305), (-109.483, 26.71), (-109.755, 26.703), (-109.944, 27.079), (-110.478, 27.323), (-110.615, 27.654), (-110.53, 27.864), (-111.121, 27.967), (-111.472, 28.384), (-112.162, 29.019), (-112.278, 28.769), (-112.514, 28.848), (-112.47, 29.168), (-112.378, 29.348), (-112.415, 29.536), (-112.738, 29.985), (-112.825, 30.3), (-113.058, 30.651), (-113.119, 31.048), (-113.047, 31.179), (-113.623, 31.346), (-113.633, 31.468), (-113.948, 31.629), (-114.003, 31.525), (-114.694, 31.706), (-114.848, 31.538), (-114.882, 31.156), (-114.761, 30.959), (-114.633, 30.507), (-114.65, 30.238), (-114.373, 29.83), (-113.755, 29.367), (-113.206, 28.799), (-113.094, 28.512), (-112.871, 28.424), (-112.734, 27.826), (-112.329, 27.523), (-112.191, 27.187), (-112.004, 27.079), (-111.57, 26.708), (-111.332, 26.125), (-111.292, 25.79), (-111.034, 25.527), (-110.894, 25.144), (-110.687, 24.868), (-110.729, 24.672), (-110.659, 24.341), (-110.421, 24.183), (-110.367, 24.1), (-110.304, 24.339), (-110.023, 24.175), (-109.711, 23.804), (-109.421, 23.48), (-109.458, 23.215), (-109.728, 22.982), (-110.006, 22.894), (-110.086, 23.005), (-110.181, 23.342), (-110.363, 23.605), (-111.419, 24.329), (-111.712, 24.346), (-112.297, 24.79), (-112.07, 25.573), (-112.377, 26.214), (-112.658, 26.317), (-113.021, 26.583), (-113.156, 26.946), (-113.272, 26.791), (-113.599, 26.721), (-113.841, 26.967), (-114.445, 27.218), (-115.036, 27.842), (-114.57, 27.784), (-114.266, 27.934), (-114.048, 28.426), (-114.937, 29.352), (-115.674, 29.756), (-116.662, 31.565), (-117.128, 32.533)] + + centam_east_coast = [(-88.296, 18.472), (-88.349, 18.359), (-88.13, 18.351), (-88.085, 18.226), (-88.272, 17.61), (-88.262, 16.963), (-88.313, 16.633), (-88.562, 16.29), (-88.695, 16.248), (-88.912, 15.956), (-88.594, 15.95), (-88.131, 15.701), (-87.875, 15.879), (-87.618, 15.91), (-87.487, 15.79), (-86.907, 15.762), (-86.357, 15.783), (-85.986, 16.024), (-85.484, 15.9), (-84.974, 15.99), (-84.261, 15.823), (-83.775, 15.437), (-83.369, 15.24), (-83.291, 15.079), (-83.158, 14.993), (-83.302, 14.802), (-83.188, 14.34), (-83.412, 13.996), (-83.567, 13.32), (-83.514, 12.944), (-83.541, 12.596), (-83.511, 12.412), (-83.651, 12.287), (-83.68, 12.024), (-83.769, 11.932), (-83.705, 11.825), (-83.652, 11.642), (-83.829, 11.428), (-83.868, 11.3), (-83.832, 11.131), (-83.714, 10.934), (-83.642, 10.917), (-83.448, 10.466), (-83.125, 10.042), (-83.029, 9.991), (-82.778, 9.67), (-82.564, 9.577), (-82.371, 9.429), (-82.259, 9.43), (-82.233, 9.381), (-82.244, 9.334), (-82.363, 9.382), (-82.375, 9.337), (-82.34, 9.209), (-82.205, 9.215), (-82.188, 9.192), (-82.235, 9.142), (-82.244, 9.031), (-82.078, 8.935), (-81.78, 8.957), (-81.894, 9.14), (-81.712, 9.019), (-81.546, 8.827), (-81.204, 8.787), (-80.839, 8.887), (-80.676, 9.022), (-80.127, 9.21), (-79.978, 9.344), (-79.855, 9.378), (-79.577, 9.598), (-79.017, 9.51), (-78.932, 9.428), (-78.504, 9.406), (-78.083, 9.236), (-77.831, 9.068), (-77.697, 8.889), (-77.374, 8.658)] + + centam_west_coast = [(-77.901, 7.229), (-78.17, 7.544), (-78.422, 8.061), (-78.255, 8.139), (-78.281, 8.248), (-78.469, 8.447), (-78.514, 8.628), (-78.848, 8.842), (-79.086, 8.997), (-79.442, 9.006), (-79.687, 8.851), (-79.816, 8.639), (-79.75, 8.596), (-80.459, 8.214), (-80.458, 8.077), (-80.075, 7.667), (-80.011, 7.5), (-80.439, 7.275), (-80.846, 7.22), (-81.064, 7.9), (-81.219, 7.621), (-81.504, 7.721), (-81.728, 8.138), (-82.16, 8.195), (-82.68, 8.322), (-82.879, 8.071), (-83.123, 8.353), (-83.544, 8.446), (-83.734, 8.614), (-83.614, 8.804), (-83.737, 9.15), (-84.222, 9.463), (-84.582, 9.568), (-84.715, 9.899), (-85.115, 9.582), (-85.315, 9.811), (-85.625, 9.902), (-85.85, 10.292), (-85.663, 10.635), (-85.667, 10.745), (-85.908, 10.898), (-85.744, 11.062), (-85.961, 11.331), (-86.469, 11.738), (-86.756, 12.157), (-87.125, 12.434), (-87.46, 12.758), (-87.668, 12.904), (-87.585, 13.043), (-87.337, 12.979), (-87.489, 13.353), (-87.814, 13.399), (-87.931, 13.181), (-88.512, 13.184), (-88.867, 13.283), (-89.278, 13.478), (-89.804, 13.56), (-90.095, 13.737), (-90.562, 13.927), (-91.146, 13.926), (-91.641, 14.115), (-92.235, 14.545)] + + cuba_coast = [(-74.137, 20.232), (-74.154, 20.169), (-74.253, 20.08), (-74.635, 20.058), (-75.003, 19.929), (-75.116, 19.901), (-75.152, 20.008), (-75.219, 19.924), (-75.29, 19.893), (-75.552, 19.891), (-75.765, 19.96), (-76.158, 19.99), (-76.78, 19.94), (-76.999, 19.893), (-77.212, 19.894), (-77.715, 19.855), (-77.554, 20.082), (-77.104, 20.408), (-77.205, 20.611), (-77.997, 20.715), (-78.491, 21.054), (-78.636, 21.516), (-79.189, 21.553), (-80.231, 21.872), (-80.485, 22.087), (-80.962, 22.053), (-81.083, 22.098), (-81.185, 22.268), (-81.222, 22.143), (-81.355, 22.104), (-81.441, 22.184), (-81.816, 22.2), (-82.078, 22.388), (-81.683, 22.535), (-81.839, 22.672), (-82.738, 22.689), (-83.38, 22.223), (-83.486, 22.187), (-83.901, 22.17), (-84.031, 21.943), (-84.241, 21.898), (-84.503, 21.776), (-84.501, 21.93), (-84.838, 21.828), (-84.887, 21.857), (-84.877, 21.894), (-84.494, 22.042), (-84.326, 22.074), (-84.383, 22.256), (-84.361, 22.379), (-84.045, 22.666), (-83.258, 22.968), (-82.666, 23.044), (-82.101, 23.19), (-81.575, 23.117), (-81.364, 23.13), (-81.262, 23.157), (-81.179, 23.06), (-80.65, 23.103), (-80.55, 23.017), (-80.365, 22.943), (-80.075, 22.942), (-79.924, 22.869), (-79.82, 22.887), (-79.851, 22.827), (-79.677, 22.743), (-79.549, 22.578), (-79.276, 22.408), (-78.835, 22.391), (-78.686, 22.367), (-78.143, 22.109), (-77.865, 21.901), (-77.545, 21.775), (-77.583, 21.889), (-77.497, 21.872), (-77.3, 21.712), (-77.144, 21.644), (-77.099, 21.589), (-76.836, 21.4), (-76.726, 21.359), (-76.647, 21.285), (-76.455, 21.274), (-76.259, 21.227), (-76.074, 21.133), (-75.723, 21.111), (-75.634, 21.061), (-75.596, 20.995), (-75.663, 20.898), (-75.597, 20.838), (-75.74, 20.812), (-75.725, 20.715), (-75.643, 20.733), (-75.338, 20.702), (-75.213, 20.714), (-74.883, 20.651), (-74.662, 20.522), (-74.513, 20.385), (-74.384, 20.33), (-74.234, 20.326), (-74.167, 20.292), (-74.137, 20.232)] + + jamaica_coast = [(-76.211, 17.914), (-76.525, 17.866), (-76.853, 17.974), (-76.944, 17.849), (-77.071, 17.901), (-77.205, 17.715), (-77.464, 17.856), (-77.768, 17.877), (-78.044, 18.174), (-78.294, 18.218), (-78.34, 18.287), (-78.217, 18.448), (-77.978, 18.468), (-77.873, 18.522), (-77.354, 18.466), (-76.908, 18.39), (-76.35, 18.152), (-76.211, 17.914)] + + hispaniola_coast = [(-71.768, 18.039), (-72.06, 18.229), (-72.592, 18.187), (-72.877, 18.152), (-73.385, 18.251), (-73.747, 18.19), (-73.839, 18.058), (-73.885, 18.042), (-74.085, 18.215), (-74.419, 18.346), (-74.478, 18.45), (-74.388, 18.625), (-74.228, 18.663), (-72.739, 18.442), (-72.376, 18.574), (-72.348, 18.675), (-72.811, 19.072), (-72.703, 19.441), (-73.053, 19.611), (-73.396, 19.659), (-73.438, 19.722), (-73.401, 19.807), (-73.315, 19.855), (-72.877, 19.928), (-72.637, 19.901), (-72.22, 19.745), (-71.835, 19.697), (-71.779, 19.718), (-71.779, 19.718), (-71.735, 19.735), (-71.667, 19.849), (-71.442, 19.894), (-71.281, 19.847), (-70.954, 19.914), (-70.129, 19.636), (-69.957, 19.672), (-69.891, 19.59), (-69.739, 19.299), (-69.325, 19.328), (-69.232, 19.272), (-69.323, 19.201), (-69.624, 19.118), (-68.685, 18.905), (-68.339, 18.612), (-68.493, 18.379), (-68.687, 18.215), (-68.935, 18.408), (-69.275, 18.44), (-69.771, 18.444), (-70.018, 18.374), (-70.183, 18.252), (-70.48, 18.217), (-70.645, 18.336), (-71.07, 18.25), (-71.083, 18.128), (-71.396, 17.646), (-71.439, 17.636), (-71.658, 17.821), (-71.674, 17.954), (-71.768, 18.039)] + + puerto_rico_coast = [(-65.621, 18.242), (-65.782, 18.129), (-65.834, 18.057), (-65.971, 17.974), (-66.135, 17.949), (-66.286, 17.95), (-66.409, 17.951), (-66.511, 17.987), (-66.598, 17.978), (-66.772, 17.987), (-66.838, 17.955), (-67.013, 17.968), (-67.142, 17.967), (-67.197, 17.994), (-67.172, 18.224), (-67.264, 18.365), (-67.172, 18.436), (-67.159, 18.499), (-67.06, 18.522), (-66.813, 18.493), (-66.093, 18.469), (-65.879, 18.444), (-65.756, 18.402), (-65.629, 18.381), (-65.621, 18.242)] + + bermuda_coast = [(-64.676, 32.389), (-64.679, 32.377), (-64.704, 32.355), (-64.705, 32.338), (-64.741, 32.3), (-64.768, 32.289), (-64.795, 32.269), (-64.81, 32.265), (-64.837, 32.265), (-64.849, 32.267), (-64.86, 32.273), (-64.781, 32.288), (-64.792, 32.3), (-64.751, 32.314), (-64.697, 32.374), (-64.676, 32.389)] diff --git a/hurdat2parser/_maps.py b/hurdat2parser/_maps.py new file mode 100644 index 0000000..38f9cd5 --- /dev/null +++ b/hurdat2parser/_maps.py @@ -0,0 +1,28 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +# Map data from NaturalEarth + +_polygons = [['AW', [[(-69.899, 12.452), (-69.896, 12.423), (-69.942, 12.439), (-70.004, 12.5), (-70.066, 12.547), (-70.051, 12.597), (-70.035, 12.614), (-69.973, 12.568), (-69.912, 12.48)]]], ['AI', [[(-63.001, 18.222), (-63.16, 18.171), (-63.153, 18.2), (-63.026, 18.27), (-62.98, 18.265)]]], ['AG', [[(-61.716, 17.037), (-61.748, 16.997), (-61.86, 17.013), (-61.882, 17.063), (-61.887, 17.098), (-61.817, 17.169), (-61.739, 17.138), (-61.708, 17.105), (-61.686, 17.098), (-61.686, 17.07), (-61.695, 17.049)], [(-61.747, 17.575), (-61.762, 17.549), (-61.844, 17.596), (-61.869, 17.685), (-61.866, 17.704), (-61.852, 17.714), (-61.82, 17.697), (-61.777, 17.69), (-61.75, 17.661)]]], ['BS', [[(-73.027, 21.192), (-73.059, 21.119), (-73.165, 20.979), (-73.401, 20.944), (-73.661, 20.937), (-73.681, 20.976), (-73.687, 21.009), (-73.668, 21.062), (-73.67, 21.082), (-73.68, 21.103), (-73.585, 21.126), (-73.523, 21.191), (-73.425, 21.202), (-73.302, 21.156), (-73.235, 21.154), (-73.137, 21.205), (-73.058, 21.313), (-73.012, 21.3)], [(-72.916, 21.507), (-73.049, 21.458), (-73.063, 21.515), (-72.995, 21.562)], [(-73.041, 22.429), (-72.979, 22.415), (-72.945, 22.416), (-72.831, 22.386), (-72.763, 22.344), (-72.747, 22.327), (-72.784, 22.291), (-72.889, 22.36), (-72.981, 22.369), (-73.11, 22.368), (-73.162, 22.381), (-73.127, 22.455)], [(-74.207, 22.214), (-74.277, 22.184), (-74.261, 22.236), (-74.127, 22.323), (-74.052, 22.401), (-74.01, 22.428), (-73.995, 22.449), (-73.936, 22.478), (-73.906, 22.527), (-73.915, 22.568), (-73.976, 22.635), (-73.975, 22.682), (-73.954, 22.716), (-73.85, 22.731), (-73.877, 22.681), (-73.837, 22.538), (-73.975, 22.361), (-74.093, 22.306)], [(-74.058, 22.723), (-74.035, 22.706), (-74.099, 22.665), (-74.242, 22.715), (-74.275, 22.712), (-74.303, 22.764), (-74.314, 22.804), (-74.307, 22.84), (-74.221, 22.812), (-74.175, 22.76)], [(-74.84, 22.894), (-74.847, 22.869), (-74.973, 23.069), (-75.132, 23.117), (-75.223, 23.165), (-75.204, 23.193), (-75.141, 23.205), (-75.131, 23.268), (-75.158, 23.336), (-75.241, 23.475), (-75.288, 23.568), (-75.31, 23.59), (-75.316, 23.668), (-75.217, 23.547), (-75.175, 23.439), (-75.109, 23.333), (-75.064, 23.15), (-74.937, 23.088), (-74.846, 23.0)], [(-75.665, 23.45), (-75.706, 23.444), (-75.781, 23.471), (-75.956, 23.592), (-76.037, 23.603), (-76.01, 23.671), (-75.949, 23.647), (-75.808, 23.543), (-75.754, 23.49)], [(-74.429, 24.068), (-74.509, 23.96), (-74.551, 23.969), (-74.527, 24.105), (-74.472, 24.127), (-74.45, 24.125)], [(-77.658, 24.249), (-77.656, 24.227), (-77.755, 24.163), (-77.683, 24.118), (-77.615, 24.216), (-77.562, 24.137), (-77.532, 23.988), (-77.537, 23.962), (-77.532, 23.939), (-77.521, 23.911), (-77.519, 23.869), (-77.574, 23.739), (-77.771, 23.753), (-77.776, 23.862), (-77.806, 23.884), (-77.852, 24.04), (-77.914, 24.091), (-78.0, 24.22), (-77.95, 24.253), (-77.884, 24.242), (-77.85, 24.258), (-77.757, 24.27), (-77.701, 24.288)], [(-75.308, 24.2), (-75.302, 24.149), (-75.369, 24.159), (-75.468, 24.14), (-75.503, 24.139), (-75.481, 24.174), (-75.412, 24.221), (-75.409, 24.266), (-75.494, 24.33), (-75.593, 24.491), (-75.639, 24.529), (-75.661, 24.59), (-75.744, 24.655), (-75.727, 24.689), (-75.71, 24.698), (-75.654, 24.681), (-75.526, 24.45), (-75.518, 24.427)], [(-77.348, 25.014), (-77.46, 24.993), (-77.541, 25.014), (-77.562, 25.03), (-77.527, 25.058), (-77.451, 25.081), (-77.329, 25.083), (-77.276, 25.056), (-77.269, 25.044)], [(-77.744, 24.707), (-77.746, 24.586), (-77.735, 24.496), (-77.745, 24.463), (-77.853, 24.403), (-77.881, 24.369), (-77.983, 24.335), (-78.045, 24.287), (-78.076, 24.365), (-78.136, 24.412), (-78.146, 24.493), (-78.192, 24.466), (-78.258, 24.483), (-78.367, 24.544), (-78.435, 24.628), (-78.339, 24.642), (-78.319, 24.59), (-78.243, 24.654), (-78.26, 24.687), (-78.274, 24.692), (-78.299, 24.754), (-78.184, 24.917), (-78.159, 25.022), (-78.211, 25.191), (-78.163, 25.202), (-78.033, 25.143), (-77.975, 25.085), (-77.973, 25.005), (-77.919, 24.943), (-77.84, 24.794)], [(-76.649, 25.487), (-76.484, 25.375), (-76.344, 25.332), (-76.192, 25.191), (-76.127, 25.141), (-76.115, 25.095), (-76.141, 24.886), (-76.175, 24.76), (-76.17, 24.649), (-76.205, 24.682), (-76.241, 24.754), (-76.3, 24.796), (-76.32, 24.818), (-76.214, 24.822), (-76.204, 24.936), (-76.153, 25.026), (-76.16, 25.119), (-76.284, 25.222), (-76.369, 25.313), (-76.5, 25.342), (-76.621, 25.432), (-76.693, 25.443), (-76.781, 25.427), (-76.749, 25.481), (-76.727, 25.552), (-76.711, 25.565)], [(-78.493, 26.729), (-78.372, 26.698), (-78.307, 26.702), (-78.268, 26.723), (-78.089, 26.714), (-77.944, 26.744), (-77.922, 26.691), (-77.926, 26.663), (-78.234, 26.637), (-78.516, 26.559), (-78.671, 26.507), (-78.744, 26.501), (-78.799, 26.528), (-78.986, 26.69), (-78.936, 26.673), (-78.798, 26.582), (-78.713, 26.599), (-78.633, 26.659), (-78.621, 26.705), (-78.633, 26.726), (-78.597, 26.798)], [(-77.226, 25.904), (-77.246, 25.895), (-77.333, 25.996), (-77.403, 26.025), (-77.294, 26.096), (-77.247, 26.156), (-77.248, 26.289), (-77.221, 26.362), (-77.23, 26.425), (-77.206, 26.489), (-77.239, 26.561), (-77.33, 26.618), (-77.511, 26.846), (-77.796, 26.901), (-77.944, 26.904), (-77.863, 26.94), (-77.788, 26.936), (-77.672, 26.914), (-77.534, 26.903), (-77.449, 26.836), (-77.369, 26.748), (-77.296, 26.712), (-77.266, 26.689), (-77.269, 26.663), (-77.257, 26.639), (-77.162, 26.597), (-77.066, 26.53), (-77.038, 26.333), (-77.167, 26.24), (-77.191, 25.955)]]], ['BL', [[(-62.832, 17.876), (-62.847, 17.875), (-62.859, 17.884), (-62.869, 17.899), (-62.875, 17.914), (-62.874, 17.922), (-62.865, 17.918), (-62.8, 17.909), (-62.807, 17.898), (-62.818, 17.885)]]], ['BZ', [[(-87.853, 17.423), (-87.93, 17.283), (-87.935, 17.323), (-87.903, 17.426), (-87.859, 17.463), (-87.833, 17.501), (-87.826, 17.546), (-87.789, 17.524), (-87.798, 17.48)], [(-87.951, 17.925), (-87.998, 17.906), (-87.959, 17.964), (-87.953, 18.001), (-87.898, 18.155), (-87.859, 18.154), (-87.849, 18.14)], [(-88.349, 18.359), (-88.296, 18.344), (-88.247, 18.355), (-88.13, 18.351), (-88.085, 18.226), (-88.097, 18.122), (-88.207, 17.846), (-88.221, 17.751), (-88.272, 17.61), (-88.203, 17.517), (-88.267, 17.393), (-88.289, 17.313), (-88.294, 17.192), (-88.262, 16.963), (-88.313, 16.633), (-88.405, 16.489), (-88.461, 16.434), (-88.562, 16.29), (-88.695, 16.248), (-88.879, 16.017), (-88.912, 15.956), (-88.894, 15.891), (-88.937, 15.89), (-89.114, 15.901), (-89.233, 15.889), (-89.237, 15.894), (-89.161, 17.815), (-89.162, 17.902), (-89.134, 17.971), (-89.05, 18.0), (-88.943, 17.94), (-88.898, 17.915), (-88.857, 17.929), (-88.806, 17.966), (-88.744, 18.072), (-88.586, 18.291), (-88.523, 18.446), (-88.461, 18.477), (-88.372, 18.482), (-88.296, 18.472)]]], ['BM', [[(-64.73, 32.293), (-64.82, 32.26), (-64.845, 32.262), (-64.863, 32.274), (-64.771, 32.308), (-64.695, 32.387), (-64.668, 32.382)]]], ['BB', [[(-59.493, 13.082), (-59.522, 13.062), (-59.611, 13.102), (-59.643, 13.15), (-59.647, 13.303), (-59.592, 13.318), (-59.488, 13.197), (-59.428, 13.153)]]], ['CV', [[(-24.308, 14.856), (-24.386, 14.818), (-24.441, 14.835), (-24.492, 14.874), (-24.517, 14.931), (-24.497, 14.98), (-24.392, 15.038), (-24.329, 15.019), (-24.296, 14.93)], [(-23.182, 15.137), (-23.21, 15.133), (-23.252, 15.178), (-23.242, 15.241), (-23.247, 15.257), (-23.21, 15.324), (-23.138, 15.318), (-23.119, 15.268), (-23.116, 15.167)], [(-23.444, 15.008), (-23.505, 14.916), (-23.637, 14.923), (-23.705, 14.961), (-23.785, 15.077), (-23.783, 15.166), (-23.754, 15.244), (-23.759, 15.311), (-23.748, 15.329), (-23.707, 15.317), (-23.701, 15.272), (-23.58, 15.161), (-23.535, 15.139)], [(-22.918, 16.237), (-22.834, 16.219), (-22.803, 16.226), (-22.749, 16.222), (-22.693, 16.169), (-22.682, 16.113), (-22.71, 16.043), (-22.821, 15.986), (-22.884, 15.993), (-22.959, 16.045), (-22.916, 16.148)], [(-24.088, 16.623), (-24.046, 16.593), (-24.033, 16.572), (-24.094, 16.561), (-24.243, 16.599), (-24.283, 16.576), (-24.322, 16.493), (-24.398, 16.618), (-24.393, 16.664), (-24.377, 16.678), (-24.271, 16.645)], [(-22.888, 16.659), (-22.92, 16.608), (-22.959, 16.683), (-22.981, 16.701), (-22.991, 16.809), (-22.933, 16.841), (-22.905, 16.844), (-22.904, 16.732)], [(-24.887, 16.818), (-24.969, 16.794), (-25.02, 16.797), (-25.093, 16.833), (-25.07, 16.871), (-24.991, 16.913), (-24.936, 16.922), (-24.892, 16.846)], [(-25.17, 16.946), (-25.267, 16.926), (-25.308, 16.936), (-25.322, 17.015), (-25.342, 17.068), (-25.337, 17.091), (-25.113, 17.194), (-25.035, 17.176), (-24.98, 17.095), (-25.017, 17.049)]]], ['CR', [[(-83.642, 10.917), (-83.617, 10.877), (-83.588, 10.815), (-83.575, 10.735), (-83.448, 10.466), (-83.347, 10.315), (-83.125, 10.042), (-83.029, 9.991), (-82.866, 9.771), (-82.81, 9.735), (-82.778, 9.67), (-82.61, 9.616), (-82.564, 9.577), (-82.569, 9.558), (-82.587, 9.539), (-82.611, 9.519), (-82.644, 9.506), (-82.723, 9.546), (-82.801, 9.592), (-82.844, 9.571), (-82.86, 9.511), (-82.889, 9.481), (-82.925, 9.469), (-82.94, 9.449), (-82.943, 9.249), (-82.94, 9.06), (-82.881, 9.056), (-82.783, 8.99), (-82.741, 8.952), (-82.728, 8.916), (-82.74, 8.899), (-82.812, 8.857), (-82.882, 8.805), (-82.917, 8.74), (-82.856, 8.635), (-82.843, 8.564), (-82.845, 8.489), (-82.862, 8.454), (-82.998, 8.368), (-83.027, 8.338), (-83.023, 8.316), (-82.948, 8.257), (-82.913, 8.2), (-82.883, 8.131), (-82.879, 8.071), (-82.947, 8.182), (-83.041, 8.288), (-83.123, 8.353), (-83.13, 8.505), (-83.162, 8.588), (-83.286, 8.664), (-83.391, 8.718), (-83.47, 8.707), (-83.422, 8.619), (-83.298, 8.507), (-83.29, 8.464), (-83.292, 8.406), (-83.377, 8.415), (-83.452, 8.438), (-83.544, 8.446), (-83.605, 8.48), (-83.734, 8.614), (-83.642, 8.729), (-83.614, 8.804), (-83.616, 8.96), (-83.637, 9.035), (-83.737, 9.15), (-83.896, 9.276), (-84.118, 9.379), (-84.222, 9.463), (-84.483, 9.526), (-84.582, 9.568), (-84.659, 9.647), (-84.67, 9.703), (-84.643, 9.789), (-84.715, 9.899), (-85.025, 10.116), (-85.198, 10.195), (-85.236, 10.242), (-85.263, 10.257), (-85.237, 10.107), (-85.161, 10.017), (-84.963, 9.933), (-84.908, 9.885), (-84.886, 9.821), (-85.001, 9.699), (-85.06, 9.668), (-85.077, 9.602), (-85.115, 9.582), (-85.154, 9.62), (-85.315, 9.811), (-85.625, 9.902), (-85.681, 9.959), (-85.796, 10.133), (-85.85, 10.292), (-85.831, 10.398), (-85.703, 10.563), (-85.663, 10.635), (-85.671, 10.68), (-85.667, 10.745), (-85.715, 10.791), (-85.833, 10.85), (-85.908, 10.898), (-85.887, 10.921), (-85.752, 10.985), (-85.744, 11.043), (-85.744, 11.062), (-85.722, 11.066), (-85.703, 11.082), (-85.691, 11.097), (-85.654, 11.153), (-85.621, 11.184), (-85.584, 11.189), (-85.539, 11.166), (-85.368, 11.106), (-85.179, 11.04), (-84.909, 10.945), (-84.797, 11.006), (-84.701, 11.052), (-84.634, 11.046), (-84.489, 10.992), (-84.402, 10.974), (-84.348, 10.98), (-84.256, 10.901), (-84.205, 10.841), (-84.197, 10.802), (-84.168, 10.78), (-84.096, 10.776), (-83.919, 10.735), (-83.811, 10.743), (-83.713, 10.786), (-83.659, 10.837)]]], ['CU', [[(-82.562, 21.572), (-82.655, 21.519), (-82.853, 21.444), (-82.96, 21.441), (-83.067, 21.469), (-83.142, 21.532), (-83.184, 21.593), (-83.18, 21.623), (-83.113, 21.574), (-83.055, 21.549), (-83.007, 21.566), (-82.974, 21.592), (-83.083, 21.791), (-83.078, 21.833), (-82.991, 21.943), (-82.756, 21.91), (-82.715, 21.89), (-82.682, 21.821), (-82.629, 21.767), (-82.568, 21.622)], [(-77.669, 21.952), (-77.71, 21.921), (-77.755, 21.966), (-77.784, 21.97), (-77.823, 21.988), (-77.9, 22.037), (-77.919, 22.088), (-77.855, 22.092), (-77.774, 22.083), (-77.634, 22.054), (-77.646, 21.996)], [(-77.879, 22.128), (-77.912, 22.125), (-78.012, 22.166), (-78.042, 22.201), (-78.007, 22.248), (-77.999, 22.299), (-77.986, 22.302), (-77.97, 22.241), (-77.894, 22.215), (-77.889, 22.201), (-77.842, 22.149)], [(-78.027, 22.285), (-78.048, 22.269), (-78.102, 22.306), (-78.18, 22.322), (-78.226, 22.38), (-78.27, 22.402), (-78.274, 22.424), (-78.201, 22.438), (-78.151, 22.431), (-78.094, 22.387), (-78.062, 22.306)], [(-78.63, 22.552), (-78.493, 22.531), (-78.445, 22.544), (-78.4, 22.547), (-78.351, 22.539), (-78.284, 22.455), (-78.343, 22.445), (-78.39, 22.445), (-78.425, 22.46), (-78.548, 22.464), (-78.629, 22.488), (-78.674, 22.509), (-78.696, 22.534)], [(-79.35, 22.664), (-79.348, 22.638), (-79.523, 22.711), (-79.598, 22.788), (-79.628, 22.805), (-79.579, 22.807), (-79.382, 22.681)], [(-81.837, 23.163), (-81.575, 23.117), (-81.364, 23.13), (-81.262, 23.157), (-81.272, 23.129), (-81.179, 23.06), (-81.145, 23.055), (-81.008, 23.09), (-80.65, 23.103), (-80.613, 23.084), (-80.55, 23.017), (-80.459, 22.975), (-80.365, 22.943), (-80.266, 22.935), (-80.168, 22.949), (-80.075, 22.942), (-79.96, 22.877), (-79.924, 22.869), (-79.82, 22.887), (-79.851, 22.827), (-79.677, 22.743), (-79.549, 22.578), (-79.456, 22.51), (-79.358, 22.449), (-79.276, 22.408), (-79.183, 22.388), (-78.902, 22.396), (-78.835, 22.391), (-78.776, 22.367), (-78.719, 22.358), (-78.686, 22.367), (-78.143, 22.109), (-77.971, 21.972), (-77.865, 21.901), (-77.637, 21.797), (-77.545, 21.775), (-77.497, 21.788), (-77.507, 21.811), (-77.573, 21.868), (-77.583, 21.889), (-77.497, 21.872), (-77.342, 21.755), (-77.3, 21.712), (-77.222, 21.672), (-77.144, 21.644), (-77.181, 21.598), (-77.245, 21.594), (-77.366, 21.613), (-77.27, 21.538), (-77.253, 21.483), (-77.208, 21.479), (-77.141, 21.539), (-77.099, 21.589), (-76.928, 21.459), (-76.836, 21.4), (-76.86, 21.365), (-76.867, 21.33), (-76.765, 21.362), (-76.726, 21.359), (-76.689, 21.34), (-76.647, 21.285), (-76.552, 21.272), (-76.455, 21.274), (-76.259, 21.227), (-76.074, 21.133), (-75.899, 21.114), (-75.723, 21.111), (-75.634, 21.061), (-75.596, 20.995), (-75.639, 20.947), (-75.663, 20.898), (-75.597, 20.838), (-75.74, 20.812), (-75.76, 20.776), (-75.753, 20.736), (-75.725, 20.715), (-75.643, 20.733), (-75.525, 20.717), (-75.338, 20.702), (-75.213, 20.714), (-74.96, 20.673), (-74.883, 20.651), (-74.732, 20.573), (-74.662, 20.522), (-74.513, 20.385), (-74.384, 20.33), (-74.273, 20.317), (-74.234, 20.326), (-74.198, 20.311), (-74.167, 20.292), (-74.137, 20.232), (-74.154, 20.169), (-74.217, 20.117), (-74.253, 20.08), (-74.412, 20.075), (-74.635, 20.058), (-74.85, 20.002), (-74.955, 19.958), (-75.003, 19.929), (-75.116, 19.901), (-75.124, 19.925), (-75.122, 19.954), (-75.152, 20.008), (-75.177, 19.959), (-75.219, 19.924), (-75.29, 19.893), (-75.552, 19.891), (-75.657, 19.932), (-75.765, 19.96), (-76.158, 19.99), (-76.253, 19.987), (-76.516, 19.957), (-76.78, 19.94), (-76.89, 19.921), (-76.999, 19.893), (-77.212, 19.894), (-77.463, 19.861), (-77.715, 19.855), (-77.554, 20.082), (-77.213, 20.3), (-77.149, 20.347), (-77.104, 20.408), (-77.093, 20.453), (-77.108, 20.492), (-77.189, 20.56), (-77.205, 20.611), (-77.23, 20.644), (-77.348, 20.672), (-77.467, 20.69), (-77.593, 20.69), (-77.857, 20.714), (-77.997, 20.715), (-78.116, 20.762), (-78.314, 20.927), (-78.406, 20.974), (-78.454, 21.011), (-78.491, 21.054), (-78.537, 21.297), (-78.577, 21.414), (-78.636, 21.516), (-78.728, 21.593), (-78.823, 21.619), (-79.189, 21.553), (-79.274, 21.563), (-79.357, 21.585), (-79.91, 21.743), (-80.138, 21.829), (-80.231, 21.872), (-80.311, 21.933), (-80.393, 22.034), (-80.485, 22.123), (-80.485, 22.087), (-80.499, 22.064), (-80.962, 22.053), (-81.036, 22.074), (-81.083, 22.098), (-81.117, 22.134), (-81.141, 22.207), (-81.185, 22.268), (-81.2, 22.203), (-81.222, 22.143), (-81.284, 22.109), (-81.355, 22.104), (-81.441, 22.184), (-81.816, 22.2), (-81.849, 22.214), (-81.973, 22.291), (-82.078, 22.388), (-81.973, 22.422), (-81.757, 22.467), (-81.71, 22.497), (-81.683, 22.535), (-81.703, 22.592), (-81.746, 22.633), (-81.79, 22.657), (-81.839, 22.672), (-81.903, 22.679), (-82.738, 22.689), (-82.786, 22.658), (-82.861, 22.595), (-83.009, 22.514), (-83.107, 22.43), (-83.144, 22.386), (-83.189, 22.355), (-83.292, 22.303), (-83.38, 22.223), (-83.486, 22.187), (-83.544, 22.209), (-83.602, 22.209), (-83.643, 22.189), (-83.687, 22.18), (-83.901, 22.17), (-83.933, 22.15), (-83.963, 22.092), (-83.998, 21.98), (-84.031, 21.943), (-84.138, 21.929), (-84.241, 21.898), (-84.449, 21.792), (-84.503, 21.776), (-84.491, 21.854), (-84.501, 21.93), (-84.56, 21.933), (-84.627, 21.92), (-84.683, 21.899), (-84.786, 21.842), (-84.838, 21.828), (-84.887, 21.857), (-84.877, 21.894), (-84.533, 22.031), (-84.494, 22.042), (-84.433, 22.031), (-84.373, 22.036), (-84.326, 22.074), (-84.383, 22.256), (-84.361, 22.379), (-84.281, 22.474), (-84.122, 22.619), (-84.045, 22.666), (-83.258, 22.968), (-83.177, 22.983), (-82.666, 23.044), (-82.588, 23.065), (-82.351, 23.154), (-82.101, 23.19)]]], ['CW', [[(-68.751, 12.06), (-68.803, 12.045), (-68.995, 12.142), (-69.154, 12.298), (-69.159, 12.38), (-69.118, 12.373), (-69.077, 12.342), (-69.013, 12.231), (-68.827, 12.159)]]], ['KY', [[(-81.37, 19.349), (-81.337, 19.329), (-81.296, 19.341), (-81.285, 19.363), (-81.13, 19.347), (-81.107, 19.305), (-81.225, 19.304), (-81.277, 19.277), (-81.304, 19.272), (-81.405, 19.278), (-81.419, 19.375), (-81.391, 19.385)], [(-79.979, 19.708), (-79.989, 19.703), (-80.021, 19.707), (-80.094, 19.666), (-80.126, 19.668), (-80.116, 19.683), (-80.101, 19.696), (-80.084, 19.706), (-80.068, 19.71), (-80.016, 19.718), (-79.992, 19.719), (-79.975, 19.71)], [(-79.823, 19.712), (-79.87, 19.697), (-79.906, 19.703), (-79.824, 19.744), (-79.803, 19.758), (-79.785, 19.766), (-79.766, 19.766), (-79.742, 19.757), (-79.742, 19.751)]]], ['DM', [[(-61.282, 15.249), (-61.375, 15.227), (-61.416, 15.4), (-61.481, 15.525), (-61.47, 15.603), (-61.458, 15.633), (-61.32, 15.585), (-61.277, 15.527), (-61.251, 15.373)]]], ['DO', [[(-71.768, 18.039), (-71.764, 18.204), (-71.737, 18.271), (-71.762, 18.341), (-71.873, 18.416), (-71.94, 18.513), (-72.0, 18.598), (-71.987, 18.61), (-71.867, 18.614), (-71.824, 18.646), (-71.743, 18.733), (-71.727, 18.803), (-71.734, 18.856), (-71.786, 18.92), (-71.807, 18.987), (-71.742, 19.046), (-71.657, 19.131), (-71.645, 19.164), (-71.647, 19.196), (-71.746, 19.286), (-71.753, 19.324), (-71.707, 19.422), (-71.711, 19.487), (-71.757, 19.688), (-71.779, 19.718), (-71.735, 19.735), (-71.706, 19.795), (-71.667, 19.849), (-71.616, 19.877), (-71.558, 19.895), (-71.442, 19.894), (-71.281, 19.847), (-71.236, 19.848), (-71.082, 19.89), (-70.954, 19.914), (-70.834, 19.887), (-70.785, 19.851), (-70.686, 19.793), (-70.636, 19.776), (-70.479, 19.777), (-70.436, 19.771), (-70.305, 19.676), (-70.194, 19.638), (-70.129, 19.636), (-70.014, 19.673), (-69.957, 19.672), (-69.891, 19.59), (-69.878, 19.473), (-69.823, 19.367), (-69.739, 19.299), (-69.325, 19.328), (-69.232, 19.272), (-69.264, 19.226), (-69.323, 19.201), (-69.52, 19.212), (-69.606, 19.206), (-69.623, 19.16), (-69.624, 19.118), (-69.508, 19.108), (-69.395, 19.086), (-69.28, 19.052), (-69.163, 19.028), (-69.031, 19.013), (-68.901, 18.988), (-68.685, 18.905), (-68.445, 18.714), (-68.381, 18.671), (-68.339, 18.612), (-68.359, 18.538), (-68.445, 18.418), (-68.493, 18.379), (-68.564, 18.355), (-68.612, 18.306), (-68.659, 18.222), (-68.687, 18.215), (-68.721, 18.218), (-68.778, 18.266), (-68.82, 18.339), (-68.935, 18.408), (-69.072, 18.399), (-69.275, 18.44), (-69.397, 18.42), (-69.519, 18.416), (-69.645, 18.436), (-69.771, 18.444), (-69.896, 18.418), (-70.018, 18.374), (-70.063, 18.346), (-70.142, 18.277), (-70.183, 18.252), (-70.48, 18.217), (-70.565, 18.268), (-70.645, 18.336), (-70.759, 18.346), (-70.924, 18.292), (-71.028, 18.273), (-71.07, 18.25), (-71.082, 18.224), (-71.083, 18.128), (-71.106, 18.07), (-71.267, 17.85), (-71.358, 17.694), (-71.396, 17.646), (-71.439, 17.636), (-71.518, 17.725), (-71.569, 17.757), (-71.632, 17.774), (-71.658, 17.821), (-71.657, 17.889), (-71.674, 17.954), (-71.712, 18.005)]]], ['E', [[(-17.888, 27.81), (-17.985, 27.646), (-18.107, 27.707), (-18.136, 27.728), (-18.161, 27.761), (-18.043, 27.768), (-17.925, 27.85)], [(-15.401, 28.147), (-15.407, 28.071), (-15.383, 27.993), (-15.389, 27.875), (-15.437, 27.811), (-15.559, 27.747), (-15.656, 27.758), (-15.71, 27.784), (-15.807, 27.888), (-15.809, 27.994), (-15.721, 28.064), (-15.683, 28.154), (-15.453, 28.137), (-15.433, 28.154), (-15.415, 28.159)], [(-17.185, 28.022), (-17.225, 28.014), (-17.274, 28.038), (-17.325, 28.118), (-17.29, 28.176), (-17.259, 28.203), (-17.214, 28.199), (-17.13, 28.156), (-17.104, 28.111), (-17.101, 28.083)], [(-16.334, 28.38), (-16.418, 28.151), (-16.496, 28.062), (-16.543, 28.032), (-16.658, 28.007), (-16.795, 28.149), (-16.866, 28.293), (-16.905, 28.34), (-16.843, 28.376), (-16.752, 28.37), (-16.557, 28.4), (-16.517, 28.413), (-16.319, 28.558), (-16.124, 28.576), (-16.119, 28.528)], [(-14.197, 28.169), (-14.333, 28.056), (-14.469, 28.082), (-14.492, 28.101), (-14.356, 28.13), (-14.232, 28.216), (-14.153, 28.407), (-14.028, 28.617), (-14.003, 28.707), (-13.954, 28.741), (-13.886, 28.745), (-13.857, 28.738), (-13.827, 28.691), (-13.828, 28.585), (-13.863, 28.409), (-13.928, 28.253)], [(-17.834, 28.493), (-17.859, 28.486), (-17.882, 28.565), (-18.001, 28.758), (-17.929, 28.845), (-17.798, 28.847), (-17.745, 28.787), (-17.727, 28.724), (-17.752, 28.689), (-17.744, 28.616), (-17.758, 28.569)], [(-13.716, 28.911), (-13.784, 28.845), (-13.86, 28.869), (-13.824, 29.013), (-13.788, 29.056), (-13.65, 29.119), (-13.535, 29.144), (-13.501, 29.211), (-13.464, 29.237), (-13.423, 29.198), (-13.454, 29.151), (-13.478, 29.007), (-13.555, 28.96)]]], ['F', [[(-60.826, 14.494), (-60.837, 14.437), (-60.862, 14.426), (-60.899, 14.474), (-61.064, 14.467), (-61.089, 14.51), (-61.09, 14.53), (-61.011, 14.602), (-61.104, 14.621), (-61.141, 14.652), (-61.22, 14.804), (-61.213, 14.849), (-61.181, 14.872), (-61.127, 14.875), (-61.027, 14.826), (-60.953, 14.756), (-60.927, 14.755), (-60.919, 14.735), (-60.934, 14.686), (-60.889, 14.645), (-60.87, 14.614)], [(-61.23, 15.89), (-61.286, 15.886), (-61.311, 15.895), (-61.318, 15.955), (-61.275, 15.996), (-61.25, 16.006), (-61.212, 15.96), (-61.203, 15.921)], [(-61.59, 16.007), (-61.67, 15.962), (-61.71, 15.976), (-61.759, 16.062), (-61.794, 16.301), (-61.767, 16.34), (-61.748, 16.355), (-61.642, 16.326), (-61.597, 16.292), (-61.552, 16.271), (-61.575, 16.227), (-61.564, 16.048)], [(-61.327, 16.23), (-61.445, 16.219), (-61.522, 16.228), (-61.54, 16.3), (-61.501, 16.36), (-61.529, 16.434), (-61.511, 16.478), (-61.471, 16.507), (-61.406, 16.468), (-61.396, 16.413), (-61.355, 16.363), (-61.173, 16.256)]]], ['GD', [[(-61.716, 12.013), (-61.782, 12.008), (-61.756, 12.045), (-61.75, 12.108), (-61.715, 12.185), (-61.66, 12.237), (-61.607, 12.223), (-61.627, 12.054)]]], ['GT', [[(-89.161, 17.815), (-89.237, 15.894), (-89.233, 15.889), (-89.114, 15.901), (-88.937, 15.89), (-88.894, 15.891), (-88.84, 15.869), (-88.798, 15.863), (-88.709, 15.807), (-88.603, 15.764), (-88.536, 15.85), (-88.572, 15.901), (-88.598, 15.927), (-88.594, 15.95), (-88.228, 15.729), (-88.684, 15.36), (-88.83, 15.251), (-88.961, 15.152), (-88.976, 15.143), (-89.143, 15.072), (-89.17, 15.04), (-89.206, 14.901), (-89.222, 14.866), (-89.192, 14.789), (-89.162, 14.669), (-89.172, 14.607), (-89.287, 14.53), (-89.339, 14.461), (-89.363, 14.416), (-89.383, 14.428), (-89.419, 14.431), (-89.501, 14.414), (-89.541, 14.41), (-89.574, 14.39), (-89.577, 14.347), (-89.555, 14.277), (-89.547, 14.241), (-89.57, 14.225), (-89.671, 14.183), (-89.711, 14.141), (-89.749, 14.077), (-89.794, 14.05), (-89.84, 14.055), (-89.873, 14.046), (-89.943, 13.997), (-90.048, 13.904), (-90.105, 13.835), (-90.106, 13.783), (-90.095, 13.737), (-90.479, 13.901), (-90.607, 13.929), (-91.146, 13.926), (-91.377, 13.99), (-91.641, 14.115), (-91.819, 14.228), (-92.235, 14.545), (-92.209, 14.571), (-92.187, 14.63), (-92.16, 14.691), (-92.176, 14.761), (-92.186, 14.818), (-92.156, 14.901), (-92.159, 14.964), (-92.144, 15.002), (-92.099, 15.027), (-92.075, 15.074), (-92.204, 15.238), (-92.204, 15.275), (-92.187, 15.321), (-91.737, 16.07), (-90.522, 16.071), (-90.447, 16.073), (-90.46, 16.162), (-90.45, 16.261), (-90.417, 16.351), (-90.417, 16.391), (-90.471, 16.44), (-90.576, 16.468), (-90.634, 16.511), (-90.634, 16.565), (-90.66, 16.631), (-90.711, 16.708), (-90.816, 16.787), (-90.976, 16.868), (-91.112, 16.976), (-91.224, 17.112), (-91.319, 17.2), (-91.392, 17.236), (-91.41, 17.256), (-90.993, 17.252), (-90.989, 17.816)]]], ['HN', [[(-85.784, 16.003), (-85.484, 15.9), (-85.164, 15.918), (-85.048, 15.974), (-84.974, 15.99), (-84.646, 15.884), (-84.56, 15.802), (-84.492, 15.794), (-84.44, 15.813), (-84.426, 15.829), (-84.49, 15.847), (-84.52, 15.873), (-84.261, 15.823), (-83.775, 15.437), (-83.765, 15.405), (-83.973, 15.52), (-84.083, 15.511), (-84.111, 15.492), (-84.105, 15.43), (-84.095, 15.401), (-84.048, 15.398), (-84.013, 15.414), (-83.927, 15.394), (-83.871, 15.353), (-83.802, 15.289), (-83.76, 15.22), (-83.716, 15.219), (-83.672, 15.261), (-83.59, 15.266), (-83.536, 15.219), (-83.498, 15.222), (-83.551, 15.294), (-83.676, 15.365), (-83.646, 15.368), (-83.369, 15.24), (-83.291, 15.079), (-83.226, 15.042), (-83.158, 14.993), (-83.415, 15.008), (-83.537, 14.977), (-83.59, 14.908), (-83.635, 14.876), (-83.674, 14.884), (-83.751, 14.856), (-83.867, 14.794), (-83.972, 14.771), (-84.066, 14.786), (-84.093, 14.771), (-84.1, 14.751), (-84.114, 14.731), (-84.151, 14.72), (-84.192, 14.726), (-84.239, 14.748), (-84.264, 14.739), (-84.267, 14.698), (-84.292, 14.687), (-84.34, 14.706), (-84.394, 14.692), (-84.454, 14.644), (-84.538, 14.633), (-84.646, 14.661), (-84.73, 14.713), (-84.789, 14.79), (-84.86, 14.81), (-84.985, 14.752), (-85.037, 14.686), (-85.049, 14.645), (-85.037, 14.608), (-85.059, 14.583), (-85.117, 14.571), (-85.161, 14.525), (-85.192, 14.447), (-85.198, 14.386), (-85.179, 14.343), (-85.208, 14.312), (-85.284, 14.292), (-85.374, 14.224), (-85.477, 14.109), (-85.58, 14.028), (-85.682, 13.983), (-85.731, 13.932), (-85.728, 13.876), (-85.734, 13.859), (-85.753, 13.852), (-85.787, 13.844), (-85.984, 13.966), (-86.04, 14.05), (-86.089, 14.037), (-86.151, 13.995), (-86.238, 13.899), (-86.332, 13.77), (-86.377, 13.756), (-86.61, 13.775), (-86.734, 13.763), (-86.759, 13.746), (-86.771, 13.699), (-86.764, 13.635), (-86.73, 13.407), (-86.711, 13.313), (-86.729, 13.284), (-86.792, 13.28), (-86.874, 13.267), (-86.918, 13.224), (-86.929, 13.179), (-86.933, 13.118), (-86.959, 13.054), (-87.009, 13.008), (-87.059, 12.991), (-87.337, 12.979), (-87.333, 13.085), (-87.413, 13.127), (-87.458, 13.215), (-87.498, 13.275), (-87.485, 13.311), (-87.489, 13.353), (-87.602, 13.386), (-87.708, 13.36), (-87.769, 13.377), (-87.814, 13.399), (-87.737, 13.451), (-87.732, 13.483), (-87.756, 13.506), (-87.782, 13.521), (-87.774, 13.58), (-87.759, 13.65), (-87.715, 13.813), (-87.731, 13.841), (-87.802, 13.89), (-87.892, 13.895), (-87.991, 13.88), (-88.039, 13.905), (-88.08, 13.961), (-88.151, 13.987), (-88.276, 13.943), (-88.408, 13.875), (-88.449, 13.851), (-88.483, 13.854), (-88.498, 13.905), (-88.504, 13.964), (-88.513, 13.979), (-88.583, 14.0), (-88.666, 14.016), (-88.708, 14.032), (-88.747, 14.072), (-88.846, 14.125), (-88.868, 14.164), (-89.0, 14.253), (-89.027, 14.297), (-89.057, 14.329), (-89.121, 14.37), (-89.17, 14.36), (-89.337, 14.411), (-89.363, 14.416), (-89.339, 14.461), (-89.287, 14.53), (-89.172, 14.607), (-89.162, 14.669), (-89.192, 14.789), (-89.222, 14.866), (-89.206, 14.901), (-89.17, 15.04), (-89.143, 15.072), (-88.976, 15.143), (-88.961, 15.152), (-88.83, 15.251), (-88.684, 15.36), (-88.228, 15.729), (-88.131, 15.701), (-88.055, 15.765), (-88.01, 15.786), (-87.907, 15.863), (-87.875, 15.879), (-87.702, 15.911), (-87.618, 15.91), (-87.545, 15.832), (-87.487, 15.79), (-87.377, 15.826), (-87.286, 15.834), (-86.907, 15.762), (-86.757, 15.794), (-86.481, 15.801), (-86.357, 15.783), (-86.181, 15.885), (-86.069, 15.906), (-85.936, 15.953), (-85.954, 16.002), (-85.986, 16.024)], [(-86.42, 16.378), (-86.58, 16.3), (-86.63, 16.302), (-86.557, 16.362), (-86.438, 16.414), (-86.338, 16.439), (-86.256, 16.428)], [(-85.871, 16.462), (-85.947, 16.404), (-85.961, 16.43), (-85.924, 16.483), (-85.878, 16.514), (-85.834, 16.511), (-85.844, 16.488)]]], ['HT', [[(-72.805, 18.778), (-72.822, 18.707), (-73.078, 18.791), (-73.285, 18.897), (-73.276, 18.954), (-73.171, 18.967), (-73.069, 18.932), (-72.919, 18.861)], [(-71.954, 19.722), (-71.835, 19.697), (-71.779, 19.718), (-71.757, 19.688), (-71.711, 19.487), (-71.707, 19.422), (-71.753, 19.324), (-71.746, 19.286), (-71.647, 19.196), (-71.645, 19.164), (-71.657, 19.131), (-71.742, 19.046), (-71.807, 18.987), (-71.786, 18.92), (-71.734, 18.856), (-71.727, 18.803), (-71.743, 18.733), (-71.824, 18.646), (-71.867, 18.614), (-71.987, 18.61), (-72.0, 18.598), (-71.94, 18.513), (-71.873, 18.416), (-71.762, 18.341), (-71.737, 18.271), (-71.764, 18.204), (-71.768, 18.039), (-71.853, 18.119), (-71.946, 18.186), (-72.002, 18.212), (-72.06, 18.229), (-72.504, 18.22), (-72.553, 18.208), (-72.592, 18.187), (-72.633, 18.176), (-72.755, 18.156), (-72.877, 18.152), (-73.16, 18.206), (-73.272, 18.234), (-73.385, 18.251), (-73.515, 18.245), (-73.644, 18.229), (-73.747, 18.19), (-73.825, 18.122), (-73.839, 18.058), (-73.885, 18.042), (-73.989, 18.143), (-74.085, 18.215), (-74.195, 18.269), (-74.419, 18.346), (-74.46, 18.393), (-74.478, 18.45), (-74.388, 18.625), (-74.284, 18.657), (-74.228, 18.663), (-74.1, 18.641), (-73.976, 18.601), (-73.862, 18.575), (-73.687, 18.565), (-73.592, 18.522), (-72.917, 18.456), (-72.789, 18.435), (-72.739, 18.442), (-72.696, 18.468), (-72.66, 18.515), (-72.618, 18.551), (-72.418, 18.559), (-72.376, 18.574), (-72.347, 18.624), (-72.348, 18.675), (-72.465, 18.744), (-72.649, 18.894), (-72.811, 19.072), (-72.741, 19.131), (-72.768, 19.241), (-72.742, 19.342), (-72.703, 19.441), (-72.863, 19.526), (-73.053, 19.611), (-73.316, 19.637), (-73.396, 19.659), (-73.438, 19.722), (-73.401, 19.807), (-73.315, 19.855), (-73.218, 19.884), (-73.118, 19.904), (-72.877, 19.928), (-72.637, 19.901), (-72.43, 19.813), (-72.22, 19.745)], [(-72.664, 20.038), (-72.623, 20.014), (-72.639, 19.986), (-72.74, 20.003), (-72.844, 20.035), (-72.878, 20.027), (-72.899, 20.031), (-72.96, 20.062), (-72.907, 20.086), (-72.851, 20.094), (-72.791, 20.092)]]], ['J', [[(-77.261, 18.457), (-77.14, 18.421), (-77.014, 18.403), (-76.959, 18.402), (-76.908, 18.39), (-76.793, 18.304), (-76.701, 18.257), (-76.35, 18.152), (-76.233, 17.97), (-76.211, 17.914), (-76.301, 17.88), (-76.416, 17.868), (-76.525, 17.866), (-76.625, 17.901), (-76.669, 17.928), (-76.774, 17.94), (-76.748, 17.965), (-76.795, 17.976), (-76.853, 17.974), (-76.896, 17.904), (-76.944, 17.849), (-77.036, 17.854), (-77.071, 17.901), (-77.119, 17.88), (-77.158, 17.845), (-77.205, 17.715), (-77.28, 17.78), (-77.361, 17.834), (-77.464, 17.856), (-77.671, 17.86), (-77.768, 17.877), (-77.849, 17.988), (-77.881, 18.019), (-77.963, 18.048), (-78.044, 18.174), (-78.074, 18.191), (-78.294, 18.218), (-78.34, 18.287), (-78.326, 18.35), (-78.252, 18.426), (-78.217, 18.448), (-78.095, 18.445), (-77.978, 18.468), (-77.927, 18.501), (-77.873, 18.522), (-77.452, 18.467), (-77.354, 18.466)]]], ['KN', [[(-62.532, 17.122), (-62.582, 17.101), (-62.625, 17.13), (-62.615, 17.199), (-62.575, 17.201), (-62.534, 17.17)], [(-62.631, 17.24), (-62.656, 17.224), (-62.702, 17.286), (-62.776, 17.303), (-62.839, 17.339), (-62.84, 17.347), (-62.839, 17.365), (-62.827, 17.386), (-62.795, 17.403), (-62.714, 17.353), (-62.676, 17.291), (-62.641, 17.262)]]], ['LC', [[(-60.895, 13.822), (-60.951, 13.718), (-61.061, 13.783), (-61.073, 13.866), (-61.064, 13.916), (-60.997, 14.011), (-60.945, 14.073), (-60.908, 14.093), (-60.887, 14.011)]]], ['MF', [[(-63.011, 18.069), (-63.123, 18.069), (-63.115, 18.091), (-63.063, 18.115), (-63.025, 18.113), (-63.009, 18.104)]]], ['MX', [[(-91.684, 18.677), (-91.796, 18.654), (-91.816, 18.676), (-91.589, 18.778), (-91.55, 18.774), (-91.537, 18.76), (-91.654, 18.711)], [(-110.914, 18.741), (-110.975, 18.72), (-111.064, 18.782), (-111.04, 18.83), (-110.989, 18.863), (-110.942, 18.802)], [(-86.94, 20.303), (-86.991, 20.272), (-87.019, 20.382), (-86.978, 20.49), (-86.928, 20.552), (-86.829, 20.559), (-86.763, 20.579), (-86.755, 20.552), (-86.809, 20.468)], [(-86.714, 21.239), (-86.696, 21.191), (-86.714, 21.197), (-86.736, 21.233), (-86.753, 21.279), (-86.739, 21.28), (-86.727, 21.264)], [(-106.502, 21.611), (-106.531, 21.529), (-106.607, 21.561), (-106.634, 21.613), (-106.639, 21.698), (-106.597, 21.712), (-106.536, 21.676), (-106.524, 21.652)], [(-109.805, 24.151), (-109.827, 24.148), (-109.878, 24.201), (-109.9, 24.331), (-109.89, 24.345), (-109.794, 24.183), (-109.796, 24.164)], [(-111.699, 24.394), (-111.712, 24.346), (-112.013, 24.533), (-111.941, 24.551), (-111.857, 24.538)], [(-110.567, 25.003), (-110.539, 24.892), (-110.59, 24.908), (-110.657, 24.969), (-110.703, 25.047), (-110.699, 25.081), (-110.69, 25.088), (-110.595, 25.042)], [(-112.057, 24.546), (-112.077, 24.535), (-112.163, 24.65), (-112.175, 24.73), (-112.21, 24.763), (-112.297, 24.79), (-112.222, 24.951), (-112.159, 25.286), (-112.132, 25.224), (-112.198, 24.885), (-112.195, 24.841), (-112.164, 24.8), (-112.13, 24.73), (-112.126, 24.654), (-112.067, 24.584)], [(-111.1, 26.021), (-111.088, 25.985), (-111.094, 25.974), (-111.135, 25.999), (-111.204, 25.85), (-111.225, 25.836), (-111.183, 26.041), (-111.139, 26.07), (-111.091, 26.076)], [(-115.171, 28.069), (-115.184, 28.037), (-115.353, 28.104), (-115.26, 28.221), (-115.274, 28.343), (-115.234, 28.368), (-115.197, 28.328), (-115.149, 28.172)], [(-118.243, 28.942), (-118.285, 28.904), (-118.4, 29.112), (-118.401, 29.163), (-118.368, 29.188), (-118.312, 29.183), (-118.312, 29.131), (-118.266, 29.086), (-118.247, 29.043)], [(-112.203, 29.005), (-112.278, 28.769), (-112.355, 28.773), (-112.514, 28.848), (-112.531, 28.894), (-112.47, 29.168), (-112.424, 29.204), (-112.285, 29.24), (-112.263, 29.207), (-112.249, 29.126)], [(-113.156, 29.052), (-113.163, 29.035), (-113.265, 29.097), (-113.496, 29.308), (-113.581, 29.413), (-113.594, 29.463), (-113.587, 29.573), (-113.508, 29.56), (-113.416, 29.486), (-113.376, 29.417), (-113.374, 29.339), (-113.202, 29.302), (-113.178, 29.132)], [(-114.694, 31.706), (-114.727, 31.701), (-114.789, 31.747), (-114.785, 31.79), (-114.771, 31.794), (-114.709, 31.757), (-114.688, 31.724)], [(-114.836, 32.508), (-111.042, 31.324), (-108.214, 31.329), (-108.212, 31.779), (-106.453, 31.77), (-106.445, 31.768), (-106.436, 31.764), (-106.347, 31.679), (-106.256, 31.545), (-106.148, 31.451), (-106.024, 31.398), (-105.813, 31.241), (-105.514, 30.981), (-105.276, 30.807), (-105.098, 30.721), (-104.979, 30.646), (-104.918, 30.583), (-104.836, 30.448), (-104.681, 30.134), (-104.681, 29.991), (-104.622, 29.854), (-104.504, 29.678), (-104.401, 29.574), (-104.312, 29.542), (-104.216, 29.48), (-104.111, 29.386), (-103.99, 29.323), (-103.853, 29.291), (-103.664, 29.207), (-103.423, 29.071), (-103.258, 29.001), (-103.168, 28.998), (-103.09, 29.042), (-103.023, 29.132), (-102.957, 29.19), (-102.892, 29.216), (-102.866, 29.258), (-102.878, 29.315), (-102.834, 29.444), (-102.734, 29.644), (-102.615, 29.752), (-102.476, 29.769), (-102.386, 29.807), (-102.343, 29.865), (-102.269, 29.871), (-102.163, 29.825), (-101.991, 29.796), (-101.752, 29.782), (-101.612, 29.787), (-101.569, 29.809), (-101.546, 29.808), (-101.545, 29.784), (-101.509, 29.773), (-101.44, 29.777), (-101.38, 29.743), (-101.304, 29.634), (-101.039, 29.46), (-101.039, 29.46), (-101.016, 29.401), (-100.924, 29.315), (-100.755, 29.183), (-100.659, 29.069), (-100.636, 28.973), (-100.55, 28.821), (-100.399, 28.614), (-100.332, 28.503), (-100.348, 28.486), (-100.336, 28.428), (-100.296, 28.328), (-100.221, 28.243), (-100.112, 28.173), (-100.001, 28.048), (-99.89, 27.867), (-99.754, 27.73), (-99.595, 27.636), (-99.505, 27.548), (-99.484, 27.467), (-99.486, 27.398), (-99.51, 27.34), (-99.5, 27.285), (-99.455, 27.234), (-99.44, 27.17), (-99.458, 27.082), (-99.457, 27.057), (-99.456, 27.057), (-99.444, 27.037), (-99.302, 26.885), (-99.23, 26.762), (-99.172, 26.566), (-99.172, 26.564), (-99.108, 26.447), (-99.015, 26.399), (-98.873, 26.381), (-98.765, 26.34), (-98.691, 26.276), (-98.598, 26.238), (-98.486, 26.225), (-98.378, 26.182), (-98.275, 26.111), (-98.083, 26.064), (-97.801, 26.042), (-97.587, 25.984), (-97.44, 25.891), (-97.376, 25.872), (-97.358, 25.871), (-97.35, 25.885), (-97.339, 25.911), (-97.282, 25.942), (-97.146, 25.961), (-97.164, 25.755), (-97.225, 25.585), (-97.424, 25.233), (-97.507, 25.015), (-97.668, 24.39), (-97.717, 23.981), (-97.729, 23.788), (-97.743, 23.761), (-97.727, 23.732), (-97.766, 23.306), (-97.745, 22.942), (-97.758, 22.886), (-97.817, 22.776), (-97.858, 22.625), (-97.842, 22.557), (-97.842, 22.51), (-97.782, 22.279), (-97.763, 22.106), (-97.585, 21.809), (-97.485, 21.705), (-97.36, 21.615), (-97.315, 21.564), (-97.337, 21.438), (-97.388, 21.374), (-97.409, 21.273), (-97.434, 21.356), (-97.424, 21.465), (-97.385, 21.524), (-97.383, 21.567), (-97.457, 21.612), (-97.59, 21.762), (-97.754, 22.027), (-97.638, 21.604), (-97.598, 21.536), (-97.567, 21.508), (-97.515, 21.478), (-97.501, 21.432), (-97.501, 21.398), (-97.357, 21.104), (-97.195, 20.8), (-97.186, 20.717), (-97.121, 20.615), (-96.709, 20.188), (-96.456, 19.87), (-96.368, 19.567), (-96.315, 19.473), (-96.29, 19.344), (-96.124, 19.199), (-96.073, 19.106), (-95.985, 19.054), (-95.913, 18.897), (-95.778, 18.806), (-95.81, 18.804), (-95.928, 18.85), (-95.92, 18.82), (-95.821, 18.755), (-95.627, 18.691), (-95.578, 18.69), (-95.655, 18.724), (-95.72, 18.768), (-95.697, 18.775), (-95.561, 18.719), (-95.182, 18.701), (-95.015, 18.571), (-94.798, 18.515), (-94.682, 18.348), (-94.546, 18.175), (-94.46, 18.167), (-94.392, 18.166), (-94.189, 18.195), (-93.873, 18.304), (-93.764, 18.358), (-93.552, 18.43), (-93.228, 18.444), (-93.127, 18.423), (-92.885, 18.469), (-92.769, 18.524), (-92.729, 18.575), (-92.71, 18.612), (-92.485, 18.665), (-92.441, 18.675), (-92.213, 18.685), (-92.103, 18.704), (-91.974, 18.716), (-91.88, 18.638), (-91.88, 18.6), (-91.943, 18.563), (-91.914, 18.529), (-91.803, 18.471), (-91.6, 18.447), (-91.534, 18.457), (-91.44, 18.542), (-91.275, 18.624), (-91.279, 18.721), (-91.308, 18.773), (-91.356, 18.777), (-91.368, 18.806), (-91.334, 18.877), (-91.343, 18.901), (-91.446, 18.833), (-91.469, 18.833), (-91.458, 18.865), (-91.437, 18.89), (-91.136, 19.038), (-91.059, 19.098), (-90.955, 19.152), (-90.739, 19.352), (-90.693, 19.73), (-90.65, 19.796), (-90.507, 19.912), (-90.492, 19.947), (-90.482, 20.026), (-90.486, 20.224), (-90.478, 20.38), (-90.484, 20.556), (-90.458, 20.714), (-90.435, 20.758), (-90.353, 21.009), (-90.183, 21.121), (-89.888, 21.253), (-89.82, 21.275), (-88.879, 21.414), (-88.747, 21.448), (-88.585, 21.539), (-88.467, 21.569), (-88.251, 21.567), (-88.185, 21.579), (-88.172, 21.591), (-88.171, 21.604), (-88.132, 21.616), (-88.007, 21.604), (-87.774, 21.55), (-87.689, 21.536), (-87.48, 21.472), (-87.251, 21.447), (-87.218, 21.458), (-87.188, 21.477), (-87.164, 21.514), (-87.188, 21.546), (-87.211, 21.544), (-87.249, 21.527), (-87.296, 21.525), (-87.387, 21.551), (-87.369, 21.574), (-87.276, 21.572), (-87.216, 21.582), (-87.128, 21.621), (-87.035, 21.592), (-86.912, 21.463), (-86.824, 21.422), (-86.817, 21.234), (-86.804, 21.2), (-86.772, 21.151), (-86.816, 21.005), (-86.865, 20.885), (-86.926, 20.786), (-87.06, 20.631), (-87.221, 20.507), (-87.421, 20.231), (-87.467, 20.102), (-87.466, 19.999), (-87.432, 19.898), (-87.442, 19.862), (-87.466, 19.824), (-87.507, 19.827), (-87.586, 19.779), (-87.688, 19.637), (-87.69, 19.594), (-87.645, 19.554), (-87.587, 19.573), (-87.512, 19.575), (-87.469, 19.586), (-87.425, 19.583), (-87.435, 19.502), (-87.483, 19.444), (-87.513, 19.426), (-87.567, 19.416), (-87.628, 19.383), (-87.659, 19.352), (-87.656, 19.258), (-87.622, 19.25), (-87.551, 19.321), (-87.509, 19.317), (-87.501, 19.288), (-87.594, 19.046), (-87.653, 18.799), (-87.734, 18.655), (-87.762, 18.446), (-87.804, 18.357), (-87.853, 18.269), (-87.882, 18.274), (-87.96, 18.441), (-88.039, 18.484), (-88.056, 18.524), (-88.011, 18.727), (-88.032, 18.839), (-88.074, 18.834), (-88.127, 18.773), (-88.197, 18.72), (-88.195, 18.643), (-88.276, 18.515), (-88.296, 18.472), (-88.372, 18.482), (-88.461, 18.477), (-88.523, 18.446), (-88.586, 18.291), (-88.744, 18.072), (-88.806, 17.966), (-88.857, 17.929), (-88.898, 17.915), (-88.943, 17.94), (-89.05, 18.0), (-89.134, 17.971), (-89.162, 17.902), (-89.161, 17.815), (-90.989, 17.816), (-90.993, 17.252), (-91.41, 17.256), (-91.392, 17.236), (-91.319, 17.2), (-91.224, 17.112), (-91.112, 16.976), (-90.976, 16.868), (-90.816, 16.787), (-90.711, 16.708), (-90.66, 16.631), (-90.634, 16.565), (-90.634, 16.511), (-90.576, 16.468), (-90.471, 16.44), (-90.417, 16.391), (-90.417, 16.351), (-90.45, 16.261), (-90.46, 16.162), (-90.447, 16.073), (-90.522, 16.071), (-91.737, 16.07), (-92.187, 15.321), (-92.204, 15.275), (-92.204, 15.238), (-92.075, 15.074), (-92.099, 15.027), (-92.144, 15.002), (-92.159, 14.964), (-92.156, 14.901), (-92.186, 14.818), (-92.176, 14.761), (-92.16, 14.691), (-92.187, 14.63), (-92.209, 14.571), (-92.235, 14.545), (-92.265, 14.568), (-92.531, 14.84), (-92.809, 15.139), (-92.918, 15.236), (-93.024, 15.31), (-93.167, 15.448), (-93.541, 15.75), (-93.734, 15.888), (-93.916, 16.054), (-94.079, 16.145), (-94.24, 16.205), (-94.311, 16.239), (-94.374, 16.285), (-94.409, 16.287), (-94.426, 16.226), (-94.37, 16.195), (-94.303, 16.169), (-94.25, 16.168), (-94.193, 16.146), (-94.028, 16.062), (-94.001, 16.019), (-94.471, 16.187), (-94.662, 16.202), (-94.682, 16.228), (-94.587, 16.316), (-94.617, 16.348), (-94.651, 16.352), (-94.753, 16.291), (-94.791, 16.287), (-94.797, 16.327), (-94.793, 16.365), (-94.859, 16.42), (-94.9, 16.417), (-94.935, 16.379), (-95.024, 16.306), (-95.021, 16.278), (-94.846, 16.247), (-94.786, 16.229), (-94.799, 16.21), (-94.949, 16.21), (-95.134, 16.177), (-95.464, 15.975), (-95.772, 15.888), (-96.214, 15.693), (-96.409, 15.683), (-96.511, 15.652), (-96.808, 15.726), (-97.185, 15.909), (-97.755, 15.967), (-98.139, 16.206), (-98.52, 16.305), (-98.762, 16.535), (-98.908, 16.545), (-99.002, 16.581), (-99.348, 16.665), (-99.691, 16.72), (-100.025, 16.921), (-100.243, 16.984), (-100.432, 17.064), (-100.848, 17.2), (-101.002, 17.276), (-101.148, 17.393), (-101.385, 17.514), (-101.487, 17.615), (-101.6, 17.652), (-101.762, 17.842), (-101.847, 17.922), (-101.919, 17.96), (-101.996, 17.973), (-102.217, 17.957), (-102.547, 18.041), (-102.7, 18.063), (-103.019, 18.187), (-103.442, 18.325), (-103.58, 18.484), (-103.699, 18.633), (-103.912, 18.828), (-104.046, 18.912), (-104.277, 19.011), (-104.405, 19.091), (-104.603, 19.153), (-104.938, 19.309), (-105.045, 19.443), (-105.108, 19.562), (-105.286, 19.706), (-105.482, 19.976), (-105.532, 20.075), (-105.57, 20.228), (-105.616, 20.316), (-105.669, 20.386), (-105.642, 20.436), (-105.543, 20.498), (-105.377, 20.512), (-105.26, 20.579), (-105.245, 20.634), (-105.252, 20.669), (-105.327, 20.753), (-105.42, 20.775), (-105.492, 20.777), (-105.511, 20.809), (-105.456, 20.844), (-105.394, 20.926), (-105.302, 21.027), (-105.237, 21.119), (-105.225, 21.25), (-105.233, 21.38), (-105.209, 21.491), (-105.431, 21.618), (-105.457, 21.672), (-105.527, 21.818), (-105.649, 21.988), (-105.646, 22.327), (-105.792, 22.627), (-105.943, 22.777), (-106.022, 22.829), (-106.235, 23.061), (-106.402, 23.196), (-106.567, 23.449), (-106.729, 23.611), (-106.935, 23.881), (-107.085, 24.016), (-107.765, 24.472), (-107.727, 24.472), (-107.527, 24.36), (-107.494, 24.369), (-107.489, 24.424), (-107.512, 24.489), (-107.549, 24.505), (-107.602, 24.49), (-107.674, 24.504), (-107.71, 24.525), (-107.817, 24.539), (-107.951, 24.615), (-108.009, 24.694), (-108.015, 24.783), (-108.208, 24.975), (-108.281, 25.082), (-108.243, 25.074), (-108.192, 25.031), (-108.14, 25.018), (-108.08, 25.018), (-108.036, 25.035), (-108.051, 25.067), (-108.093, 25.094), (-108.374, 25.194), (-108.466, 25.265), (-108.696, 25.383), (-108.751, 25.424), (-108.787, 25.538), (-108.844, 25.543), (-108.893, 25.512), (-109.029, 25.48), (-109.063, 25.517), (-109.068, 25.552), (-108.973, 25.588), (-108.885, 25.696), (-108.887, 25.733), (-108.935, 25.69), (-109.008, 25.642), (-109.084, 25.615), (-109.196, 25.593), (-109.254, 25.609), (-109.304, 25.633), (-109.385, 25.727), (-109.426, 26.033), (-109.354, 26.138), (-109.271, 26.243), (-109.2, 26.305), (-109.159, 26.258), (-109.117, 26.253), (-109.146, 26.306), (-109.216, 26.355), (-109.241, 26.405), (-109.243, 26.45), (-109.276, 26.534), (-109.483, 26.71), (-109.676, 26.697), (-109.755, 26.703), (-109.828, 26.77), (-109.891, 26.883), (-109.922, 26.978), (-109.926, 27.029), (-109.944, 27.079), (-110.277, 27.162), (-110.377, 27.233), (-110.478, 27.323), (-110.519, 27.396), (-110.561, 27.45), (-110.593, 27.544), (-110.615, 27.654), (-110.578, 27.796), (-110.53, 27.864), (-110.759, 27.915), (-110.849, 27.918), (-110.921, 27.889), (-110.986, 27.926), (-111.121, 27.967), (-111.282, 28.115), (-111.472, 28.384), (-111.68, 28.471), (-111.747, 28.564), (-111.832, 28.648), (-111.907, 28.752), (-111.919, 28.798), (-111.941, 28.823), (-112.045, 28.896), (-112.162, 29.019), (-112.192, 29.118), (-112.223, 29.269), (-112.301, 29.323), (-112.378, 29.348), (-112.393, 29.42), (-112.389, 29.46), (-112.415, 29.536), (-112.573, 29.72), (-112.653, 29.87), (-112.697, 29.917), (-112.738, 29.985), (-112.759, 30.126), (-112.825, 30.3), (-112.952, 30.51), (-113.058, 30.651), (-113.11, 30.793), (-113.087, 30.938), (-113.105, 31.027), (-113.119, 31.048), (-113.108, 31.077), (-113.073, 31.061), (-113.043, 31.087), (-113.047, 31.179), (-113.084, 31.207), (-113.186, 31.236), (-113.231, 31.256), (-113.481, 31.294), (-113.623, 31.346), (-113.633, 31.468), (-113.7, 31.523), (-113.759, 31.558), (-113.948, 31.629), (-113.977, 31.593), (-114.003, 31.525), (-114.081, 31.51), (-114.149, 31.507), (-114.264, 31.554), (-114.549, 31.734), (-114.609, 31.762), (-114.698, 31.777), (-114.741, 31.806), (-114.934, 31.901), (-114.895, 31.851), (-114.84, 31.799), (-114.79, 31.647), (-114.848, 31.538), (-114.882, 31.156), (-114.845, 31.08), (-114.761, 30.959), (-114.703, 30.765), (-114.685, 30.621), (-114.633, 30.507), (-114.65, 30.238), (-114.63, 30.156), (-114.55, 30.022), (-114.403, 29.896), (-114.373, 29.83), (-114.179, 29.734), (-114.062, 29.61), (-113.829, 29.439), (-113.755, 29.367), (-113.545, 29.102), (-113.538, 29.023), (-113.5, 28.927), (-113.382, 28.947), (-113.329, 28.873), (-113.335, 28.839), (-113.321, 28.813), (-113.259, 28.819), (-113.206, 28.799), (-113.094, 28.512), (-113.034, 28.473), (-112.957, 28.456), (-112.871, 28.424), (-112.865, 28.351), (-112.868, 28.292), (-112.796, 28.207), (-112.808, 28.092), (-112.749, 27.995), (-112.758, 27.901), (-112.734, 27.826), (-112.553, 27.657), (-112.329, 27.523), (-112.283, 27.347), (-112.191, 27.187), (-112.098, 27.146), (-112.004, 27.079), (-112.016, 27.01), (-112.009, 26.967), (-111.883, 26.84), (-111.863, 26.679), (-111.754, 26.573), (-111.723, 26.564), (-111.699, 26.581), (-111.779, 26.687), (-111.817, 26.756), (-111.822, 26.865), (-111.795, 26.88), (-111.57, 26.708), (-111.546, 26.579), (-111.47, 26.507), (-111.465, 26.408), (-111.419, 26.35), (-111.405, 26.265), (-111.332, 26.125), (-111.33, 25.931), (-111.292, 25.79), (-111.15, 25.573), (-111.034, 25.527), (-111.014, 25.42), (-110.894, 25.144), (-110.756, 24.995), (-110.687, 24.868), (-110.677, 24.789), (-110.729, 24.672), (-110.735, 24.59), (-110.659, 24.341), (-110.547, 24.214), (-110.421, 24.183), (-110.4, 24.165), (-110.41, 24.131), (-110.367, 24.1), (-110.32, 24.139), (-110.297, 24.195), (-110.321, 24.259), (-110.325, 24.306), (-110.304, 24.339), (-110.263, 24.345), (-110.023, 24.175), (-109.983, 24.109), (-109.893, 24.033), (-109.811, 23.939), (-109.776, 23.865), (-109.711, 23.804), (-109.677, 23.662), (-109.51, 23.598), (-109.421, 23.48), (-109.415, 23.406), (-109.458, 23.215), (-109.496, 23.16), (-109.63, 23.079), (-109.728, 22.982), (-109.823, 22.922), (-109.923, 22.886), (-110.006, 22.894), (-110.086, 23.005), (-110.181, 23.342), (-110.244, 23.412), (-110.289, 23.518), (-110.363, 23.605), (-110.63, 23.737), (-110.765, 23.877), (-110.896, 23.97), (-111.036, 24.105), (-111.419, 24.329), (-111.578, 24.443), (-111.683, 24.556), (-111.75, 24.554), (-111.802, 24.543), (-111.822, 24.573), (-111.825, 24.632), (-111.848, 24.67), (-112.073, 24.84), (-112.119, 24.934), (-112.129, 25.043), (-112.078, 25.324), (-112.056, 25.488), (-112.07, 25.573), (-112.093, 25.584), (-112.115, 25.63), (-112.12, 25.766), (-112.174, 25.913), (-112.377, 26.214), (-112.526, 26.273), (-112.658, 26.317), (-113.021, 26.583), (-113.119, 26.717), (-113.143, 26.792), (-113.156, 26.946), (-113.206, 26.857), (-113.272, 26.791), (-113.426, 26.796), (-113.599, 26.721), (-113.701, 26.791), (-113.757, 26.871), (-113.841, 26.967), (-113.936, 26.985), (-113.996, 26.988), (-114.11, 27.106), (-114.202, 27.144), (-114.333, 27.158), (-114.445, 27.218), (-114.48, 27.284), (-114.498, 27.376), (-114.54, 27.431), (-114.716, 27.54), (-114.859, 27.659), (-114.994, 27.736), (-115.033, 27.799), (-115.036, 27.842), (-114.824, 27.83), (-114.57, 27.784), (-114.448, 27.797), (-114.373, 27.841), (-114.301, 27.873), (-114.289, 27.839), (-114.302, 27.776), (-114.233, 27.718), (-114.137, 27.671), (-114.069, 27.676), (-114.135, 27.727), (-114.175, 27.831), (-114.157, 27.868), (-114.158, 27.92), (-114.253, 27.908), (-114.266, 27.934), (-114.185, 28.013), (-114.093, 28.221), (-114.048, 28.426), (-114.146, 28.605), (-114.309, 28.73), (-114.664, 29.095), (-114.876, 29.282), (-114.937, 29.352), (-114.994, 29.384), (-115.166, 29.427), (-115.311, 29.532), (-115.565, 29.68), (-115.674, 29.756), (-115.749, 29.936), (-115.808, 29.96), (-115.79, 30.084), (-115.816, 30.304), (-115.858, 30.36), (-115.996, 30.414), (-116.029, 30.564), (-116.035, 30.705), (-116.062, 30.804), (-116.296, 30.971), (-116.31, 31.051), (-116.31, 31.127), (-116.333, 31.203), (-116.458, 31.361), (-116.61, 31.499), (-116.662, 31.565), (-116.668, 31.699), (-116.722, 31.735), (-116.702, 31.744), (-116.652, 31.74), (-116.624, 31.758), (-116.621, 31.851), (-116.848, 31.997), (-116.914, 32.199), (-117.035, 32.305), (-117.063, 32.344), (-117.128, 32.533), (-114.725, 32.715), (-114.788, 32.565)]]], ['MS', [[(-62.148, 16.74), (-62.154, 16.681), (-62.222, 16.7), (-62.223, 16.752), (-62.191, 16.804), (-62.176, 16.81)]]], ['NI', [[(-83.158, 14.993), (-83.185, 14.956), (-83.216, 14.932), (-83.28, 14.813), (-83.302, 14.802), (-83.306, 14.891), (-83.344, 14.902), (-83.389, 14.871), (-83.414, 14.825), (-83.375, 14.766), (-83.341, 14.765), (-83.299, 14.749), (-83.188, 14.34), (-83.212, 14.267), (-83.281, 14.154), (-83.347, 14.057), (-83.412, 13.996), (-83.494, 13.739), (-83.567, 13.32), (-83.514, 12.944), (-83.541, 12.596), (-83.518, 12.514), (-83.511, 12.412), (-83.565, 12.393), (-83.596, 12.396), (-83.627, 12.459), (-83.624, 12.515), (-83.591, 12.579), (-83.578, 12.667), (-83.593, 12.713), (-83.625, 12.613), (-83.682, 12.568), (-83.718, 12.553), (-83.754, 12.502), (-83.716, 12.407), (-83.667, 12.337), (-83.651, 12.287), (-83.669, 12.228), (-83.68, 12.024), (-83.698, 12.03), (-83.716, 12.057), (-83.767, 12.059), (-83.773, 11.977), (-83.769, 11.932), (-83.813, 11.896), (-83.829, 11.861), (-83.793, 11.836), (-83.753, 11.821), (-83.705, 11.825), (-83.664, 11.724), (-83.652, 11.642), (-83.745, 11.567), (-83.777, 11.504), (-83.829, 11.428), (-83.859, 11.354), (-83.868, 11.3), (-83.832, 11.131), (-83.768, 11.01), (-83.714, 10.934), (-83.642, 10.917), (-83.659, 10.837), (-83.713, 10.786), (-83.811, 10.743), (-83.919, 10.735), (-84.096, 10.776), (-84.168, 10.78), (-84.197, 10.802), (-84.205, 10.841), (-84.256, 10.901), (-84.348, 10.98), (-84.402, 10.974), (-84.489, 10.992), (-84.634, 11.046), (-84.701, 11.052), (-84.797, 11.006), (-84.909, 10.945), (-85.179, 11.04), (-85.368, 11.106), (-85.539, 11.166), (-85.584, 11.189), (-85.621, 11.184), (-85.654, 11.153), (-85.691, 11.097), (-85.703, 11.082), (-85.722, 11.066), (-85.744, 11.062), (-85.745, 11.089), (-85.829, 11.199), (-85.961, 11.331), (-86.469, 11.738), (-86.656, 11.982), (-86.756, 12.157), (-86.851, 12.248), (-87.125, 12.434), (-87.188, 12.508), (-87.46, 12.758), (-87.668, 12.904), (-87.67, 12.966), (-87.585, 13.043), (-87.543, 13.04), (-87.498, 12.984), (-87.424, 12.921), (-87.39, 12.921), (-87.339, 12.95), (-87.337, 12.979), (-87.059, 12.991), (-87.009, 13.008), (-86.959, 13.054), (-86.933, 13.118), (-86.929, 13.179), (-86.918, 13.224), (-86.874, 13.267), (-86.792, 13.28), (-86.729, 13.284), (-86.711, 13.313), (-86.73, 13.407), (-86.764, 13.635), (-86.771, 13.699), (-86.759, 13.746), (-86.734, 13.763), (-86.61, 13.775), (-86.377, 13.756), (-86.332, 13.77), (-86.238, 13.899), (-86.151, 13.995), (-86.089, 14.037), (-86.04, 14.05), (-85.984, 13.966), (-85.787, 13.844), (-85.753, 13.852), (-85.734, 13.859), (-85.728, 13.876), (-85.731, 13.932), (-85.682, 13.983), (-85.58, 14.028), (-85.477, 14.109), (-85.374, 14.224), (-85.284, 14.292), (-85.208, 14.312), (-85.179, 14.343), (-85.198, 14.386), (-85.192, 14.447), (-85.161, 14.525), (-85.117, 14.571), (-85.059, 14.583), (-85.037, 14.608), (-85.049, 14.645), (-85.037, 14.686), (-84.985, 14.752), (-84.86, 14.81), (-84.789, 14.79), (-84.73, 14.713), (-84.646, 14.661), (-84.538, 14.633), (-84.454, 14.644), (-84.394, 14.692), (-84.34, 14.706), (-84.292, 14.687), (-84.267, 14.698), (-84.264, 14.739), (-84.239, 14.748), (-84.192, 14.726), (-84.151, 14.72), (-84.114, 14.731), (-84.1, 14.751), (-84.093, 14.771), (-84.066, 14.786), (-83.972, 14.771), (-83.867, 14.794), (-83.751, 14.856), (-83.674, 14.884), (-83.635, 14.876), (-83.59, 14.908), (-83.537, 14.977), (-83.415, 15.008)]]], ['NL', [[(-68.206, 12.145), (-68.254, 12.032), (-68.282, 12.082), (-68.287, 12.172), (-68.307, 12.207), (-68.348, 12.228), (-68.371, 12.258), (-68.369, 12.302), (-68.219, 12.231)], [(-62.938, 17.496), (-62.962, 17.475), (-62.983, 17.477), (-62.997, 17.497), (-63.0, 17.53), (-62.979, 17.521), (-62.972, 17.516), (-62.965, 17.509)], [(-63.233, 17.623), (-63.242, 17.62), (-63.254, 17.629), (-63.252, 17.645), (-63.242, 17.652), (-63.233, 17.647), (-63.227, 17.634)]]], ['PA', [[(-81.603, 7.333), (-81.658, 7.328), (-81.77, 7.37), (-81.852, 7.453), (-81.859, 7.48), (-81.857, 7.508), (-81.812, 7.592), (-81.752, 7.622), (-81.729, 7.621), (-81.671, 7.523), (-81.71, 7.486), (-81.695, 7.425), (-81.613, 7.38)], [(-79.065, 8.254), (-79.11, 8.21), (-79.128, 8.252), (-79.096, 8.295), (-79.085, 8.296)], [(-78.898, 8.274), (-78.918, 8.232), (-78.965, 8.326), (-78.957, 8.351), (-78.961, 8.436), (-78.916, 8.458), (-78.883, 8.46), (-78.856, 8.448), (-78.839, 8.348), (-78.853, 8.302)], [(-82.233, 9.381), (-82.244, 9.334), (-82.322, 9.418), (-82.276, 9.432), (-82.259, 9.43)], [(-79.355, 9.569), (-79.212, 9.532), (-79.112, 9.537), (-79.017, 9.51), (-78.975, 9.453), (-78.932, 9.428), (-78.697, 9.435), (-78.504, 9.406), (-78.083, 9.236), (-77.831, 9.068), (-77.697, 8.889), (-77.374, 8.658), (-77.393, 8.645), (-77.448, 8.566), (-77.479, 8.498), (-77.407, 8.427), (-77.386, 8.352), (-77.346, 8.27), (-77.283, 8.187), (-77.212, 8.034), (-77.196, 7.972), (-77.216, 7.933), (-77.283, 7.908), (-77.346, 7.837), (-77.363, 7.749), (-77.351, 7.706), (-77.538, 7.566), (-77.587, 7.543), (-77.619, 7.565), (-77.659, 7.635), (-77.706, 7.691), (-77.732, 7.711), (-77.747, 7.712), (-77.762, 7.699), (-77.769, 7.668), (-77.744, 7.537), (-77.765, 7.484), (-77.828, 7.443), (-77.901, 7.229), (-77.93, 7.256), (-78.17, 7.544), (-78.378, 7.9), (-78.422, 8.061), (-78.368, 8.071), (-78.315, 8.067), (-78.287, 8.092), (-78.255, 8.139), (-78.281, 8.248), (-78.18, 8.33), (-78.142, 8.386), (-78.114, 8.38), (-78.048, 8.285), (-77.952, 8.23), (-77.834, 8.151), (-77.761, 8.133), (-77.853, 8.216), (-78.013, 8.325), (-78.057, 8.397), (-78.099, 8.497), (-78.162, 8.454), (-78.191, 8.417), (-78.223, 8.397), (-78.251, 8.421), (-78.256, 8.454), (-78.35, 8.46), (-78.374, 8.489), (-78.399, 8.506), (-78.388, 8.443), (-78.369, 8.405), (-78.379, 8.359), (-78.41, 8.355), (-78.436, 8.403), (-78.469, 8.447), (-78.514, 8.628), (-78.621, 8.714), (-78.67, 8.742), (-78.71, 8.753), (-78.77, 8.811), (-78.848, 8.842), (-78.955, 8.933), (-79.086, 8.997), (-79.247, 9.02), (-79.442, 9.006), (-79.507, 8.97), (-79.552, 8.924), (-79.572, 8.903), (-79.687, 8.851), (-79.731, 8.775), (-79.759, 8.712), (-79.816, 8.639), (-79.75, 8.596), (-80.126, 8.35), (-80.2, 8.314), (-80.369, 8.289), (-80.408, 8.262), (-80.459, 8.214), (-80.466, 8.14), (-80.458, 8.077), (-80.409, 8.029), (-80.366, 7.998), (-80.261, 7.852), (-80.075, 7.667), (-80.04, 7.6), (-80.011, 7.5), (-80.067, 7.453), (-80.111, 7.433), (-80.287, 7.426), (-80.348, 7.386), (-80.373, 7.325), (-80.439, 7.275), (-80.667, 7.226), (-80.846, 7.22), (-80.901, 7.277), (-80.915, 7.438), (-81.035, 7.711), (-81.064, 7.9), (-81.094, 7.876), (-81.158, 7.854), (-81.179, 7.808), (-81.195, 7.668), (-81.219, 7.621), (-81.268, 7.625), (-81.37, 7.675), (-81.504, 7.721), (-81.676, 8.016), (-81.694, 8.071), (-81.728, 8.138), (-81.86, 8.165), (-81.973, 8.215), (-82.097, 8.223), (-82.16, 8.195), (-82.224, 8.23), (-82.235, 8.311), (-82.365, 8.275), (-82.531, 8.287), (-82.68, 8.322), (-82.781, 8.304), (-82.866, 8.246), (-82.854, 8.1), (-82.879, 8.071), (-82.883, 8.131), (-82.913, 8.2), (-82.948, 8.257), (-83.023, 8.316), (-83.027, 8.338), (-82.998, 8.368), (-82.862, 8.454), (-82.845, 8.489), (-82.843, 8.564), (-82.856, 8.635), (-82.917, 8.74), (-82.882, 8.805), (-82.812, 8.857), (-82.74, 8.899), (-82.728, 8.916), (-82.741, 8.952), (-82.783, 8.99), (-82.881, 9.056), (-82.94, 9.06), (-82.943, 9.249), (-82.94, 9.449), (-82.925, 9.469), (-82.889, 9.481), (-82.86, 9.511), (-82.844, 9.571), (-82.801, 9.592), (-82.723, 9.546), (-82.644, 9.506), (-82.611, 9.519), (-82.587, 9.539), (-82.569, 9.558), (-82.564, 9.577), (-82.5, 9.523), (-82.371, 9.429), (-82.363, 9.382), (-82.375, 9.337), (-82.34, 9.209), (-82.272, 9.191), (-82.205, 9.215), (-82.188, 9.192), (-82.201, 9.168), (-82.235, 9.142), (-82.244, 9.031), (-82.133, 8.98), (-82.078, 8.935), (-81.894, 8.956), (-81.826, 8.944), (-81.78, 8.957), (-81.831, 9.046), (-81.9, 9.111), (-81.894, 9.14), (-81.842, 9.119), (-81.803, 9.074), (-81.712, 9.019), (-81.546, 8.827), (-81.355, 8.781), (-81.204, 8.787), (-81.063, 8.813), (-80.839, 8.887), (-80.676, 9.022), (-80.547, 9.082), (-80.127, 9.21), (-79.978, 9.344), (-79.915, 9.361), (-79.855, 9.378), (-79.723, 9.479), (-79.652, 9.558), (-79.577, 9.598)]]], ['PR', [[(-67.872, 18.06), (-67.882, 18.059), (-67.891, 18.06), (-67.895, 18.063), (-67.902, 18.072), (-67.93, 18.087), (-67.937, 18.101), (-67.931, 18.115), (-67.919, 18.121), (-67.861, 18.123), (-67.855, 18.121), (-67.844, 18.111), (-67.843, 18.104), (-67.849, 18.097), (-67.859, 18.08), (-67.863, 18.075), (-67.867, 18.071), (-67.868, 18.063)], [(-65.426, 18.106), (-65.504, 18.1), (-65.555, 18.108), (-65.572, 18.137), (-65.477, 18.165), (-65.366, 18.161), (-65.303, 18.144), (-65.295, 18.133)], [(-66.129, 18.445), (-66.098, 18.425), (-66.068, 18.428), (-66.093, 18.469), (-66.07, 18.469), (-65.879, 18.444), (-65.756, 18.402), (-65.629, 18.381), (-65.621, 18.242), (-65.718, 18.187), (-65.782, 18.129), (-65.834, 18.057), (-65.971, 17.974), (-66.135, 17.949), (-66.245, 17.947), (-66.286, 17.95), (-66.326, 17.964), (-66.409, 17.951), (-66.511, 17.987), (-66.598, 17.978), (-66.772, 17.987), (-66.838, 17.955), (-66.9, 17.948), (-66.961, 17.954), (-67.013, 17.968), (-67.142, 17.967), (-67.197, 17.994), (-67.174, 18.153), (-67.172, 18.224), (-67.204, 18.283), (-67.239, 18.321), (-67.264, 18.365), (-67.213, 18.394), (-67.172, 18.436), (-67.159, 18.499), (-67.113, 18.515), (-67.06, 18.522), (-66.813, 18.493), (-66.189, 18.476), (-66.153, 18.471)]]], ['P', [[(-17.191, 32.869), (-17.054, 32.816), (-16.929, 32.841), (-16.774, 32.774), (-16.693, 32.758), (-16.765, 32.71), (-16.837, 32.648), (-17.018, 32.663), (-17.171, 32.722), (-17.226, 32.767), (-17.241, 32.807)], [(-25.027, 36.96), (-25.032, 36.942), (-25.088, 36.949), (-25.16, 36.943), (-25.198, 36.997), (-25.164, 37.019), (-25.083, 37.024), (-25.044, 37.0)], [(-25.649, 37.841), (-25.585, 37.834), (-25.267, 37.849), (-25.182, 37.838), (-25.191, 37.764), (-25.251, 37.735), (-25.439, 37.715), (-25.734, 37.763), (-25.834, 37.826), (-25.848, 37.872), (-25.846, 37.894), (-25.784, 37.911)], [(-28.147, 38.453), (-28.065, 38.413), (-28.19, 38.404), (-28.231, 38.385), (-28.332, 38.413), (-28.454, 38.409), (-28.531, 38.463), (-28.549, 38.519), (-28.51, 38.553), (-28.402, 38.553)], [(-28.641, 38.525), (-28.744, 38.522), (-28.842, 38.598), (-28.698, 38.638), (-28.655, 38.614), (-28.624, 38.586), (-28.606, 38.551)], [(-27.778, 38.556), (-27.826, 38.544), (-28.092, 38.621), (-28.187, 38.655), (-28.311, 38.744), (-27.963, 38.636)], [(-27.075, 38.643), (-27.095, 38.634), (-27.303, 38.661), (-27.362, 38.698), (-27.386, 38.766), (-27.351, 38.789), (-27.26, 38.803), (-27.127, 38.79), (-27.042, 38.741), (-27.042, 38.679)], [(-31.137, 39.407), (-31.181, 39.359), (-31.258, 39.376), (-31.283, 39.394), (-31.261, 39.497), (-31.2, 39.521), (-31.139, 39.479)]]], ['SV', [[(-89.363, 14.416), (-89.337, 14.411), (-89.17, 14.36), (-89.121, 14.37), (-89.057, 14.329), (-89.027, 14.297), (-89.0, 14.253), (-88.868, 14.164), (-88.846, 14.125), (-88.747, 14.072), (-88.708, 14.032), (-88.666, 14.016), (-88.583, 14.0), (-88.513, 13.979), (-88.504, 13.964), (-88.498, 13.905), (-88.483, 13.854), (-88.449, 13.851), (-88.408, 13.875), (-88.276, 13.943), (-88.151, 13.987), (-88.08, 13.961), (-88.039, 13.905), (-87.991, 13.88), (-87.892, 13.895), (-87.802, 13.89), (-87.731, 13.841), (-87.715, 13.813), (-87.759, 13.65), (-87.774, 13.58), (-87.782, 13.521), (-87.756, 13.506), (-87.732, 13.483), (-87.737, 13.451), (-87.814, 13.399), (-87.838, 13.386), (-87.821, 13.285), (-87.878, 13.224), (-87.931, 13.181), (-88.023, 13.169), (-88.181, 13.164), (-88.417, 13.214), (-88.592, 13.281), (-88.686, 13.281), (-88.656, 13.259), (-88.582, 13.245), (-88.484, 13.197), (-88.512, 13.184), (-88.867, 13.283), (-89.278, 13.478), (-89.523, 13.509), (-89.804, 13.56), (-89.97, 13.683), (-90.095, 13.737), (-90.106, 13.783), (-90.105, 13.835), (-90.048, 13.904), (-89.943, 13.997), (-89.873, 14.046), (-89.84, 14.055), (-89.794, 14.05), (-89.749, 14.077), (-89.711, 14.141), (-89.671, 14.183), (-89.57, 14.225), (-89.547, 14.241), (-89.555, 14.277), (-89.577, 14.347), (-89.574, 14.39), (-89.541, 14.41), (-89.501, 14.414), (-89.419, 14.431), (-89.383, 14.428)]]], ['SX', [[(-63.123, 18.069), (-63.011, 18.069), (-63.012, 18.045), (-63.023, 18.019), (-63.09, 18.041), (-63.125, 18.064)]]], ['TC', [[(-72.333, 21.851), (-72.219, 21.796), (-72.15, 21.804), (-72.144, 21.793), (-72.182, 21.78), (-72.191, 21.77), (-72.301, 21.755), (-72.335, 21.758), (-72.342, 21.795)], [(-71.661, 21.765), (-71.665, 21.752), (-71.722, 21.79), (-71.83, 21.791), (-71.848, 21.843), (-71.806, 21.852), (-71.668, 21.833), (-71.637, 21.788)], [(-71.88, 21.84), (-71.897, 21.83), (-71.955, 21.864), (-71.964, 21.892), (-71.985, 21.893), (-72.019, 21.918), (-72.011, 21.95), (-71.932, 21.952), (-71.9, 21.863)]]], ['TT', [[(-61.012, 10.134), (-61.174, 10.078), (-61.597, 10.065), (-61.772, 10.085), (-61.906, 10.069), (-61.661, 10.192), (-61.633, 10.243), (-61.529, 10.253), (-61.499, 10.269), (-61.465, 10.539), (-61.478, 10.603), (-61.499, 10.639), (-61.541, 10.664), (-61.635, 10.699), (-61.651, 10.718), (-61.592, 10.748), (-61.465, 10.764), (-61.37, 10.797), (-61.174, 10.803), (-61.079, 10.832), (-60.918, 10.84), (-60.997, 10.716), (-61.034, 10.67), (-61.019, 10.558), (-61.038, 10.482), (-61.016, 10.386), (-60.968, 10.323), (-61.0, 10.261), (-61.004, 10.168)], [(-60.756, 11.179), (-60.811, 11.169), (-60.804, 11.208), (-60.709, 11.277), (-60.563, 11.324), (-60.525, 11.325), (-60.546, 11.264)]]], ['VC', [[(-61.334, 12.695), (-61.345, 12.695), (-61.354, 12.698), (-61.351, 12.701), (-61.34, 12.704), (-61.334, 12.71), (-61.336, 12.719), (-61.336, 12.729), (-61.327, 12.735), (-61.32, 12.735), (-61.317, 12.732), (-61.315, 12.723), (-61.32, 12.716), (-61.326, 12.71), (-61.329, 12.701)], [(-61.226, 12.995), (-61.242, 12.984), (-61.235, 12.984), (-61.242, 12.976), (-61.247, 12.984), (-61.255, 12.988), (-61.265, 12.99), (-61.277, 12.99), (-61.277, 12.997), (-61.262, 12.993), (-61.239, 12.997), (-61.239, 13.005), (-61.246, 13.013), (-61.249, 13.018), (-61.241, 13.026), (-61.213, 13.043), (-61.201, 13.053), (-61.2, 13.049), (-61.199, 13.045), (-61.198, 13.042), (-61.194, 13.038), (-61.208, 13.025)], [(-61.175, 13.158), (-61.204, 13.142), (-61.277, 13.21), (-61.268, 13.288), (-61.224, 13.331), (-61.182, 13.356), (-61.139, 13.359), (-61.124, 13.294), (-61.135, 13.203)]]], ['VE', [[(-65.213, 10.906), (-65.266, 10.884), (-65.365, 10.906), (-65.415, 10.938), (-65.383, 10.974), (-65.302, 10.974), (-65.227, 10.93)], [(-63.849, 11.131), (-63.817, 11.0), (-63.827, 10.976), (-63.918, 10.888), (-63.994, 10.881), (-64.055, 10.884), (-64.101, 10.901), (-64.161, 10.959), (-64.219, 10.942), (-64.362, 10.962), (-64.402, 10.982), (-64.349, 11.052), (-64.25, 11.08), (-64.214, 11.086), (-64.185, 11.043), (-64.113, 11.006), (-64.028, 11.002), (-64.007, 11.068), (-63.893, 11.167)]]], ['VG', [[(-64.594, 18.403), (-64.672, 18.399), (-64.695, 18.412), (-64.651, 18.443), (-64.569, 18.446), (-64.545, 18.438)], [(-64.395, 18.465), (-64.421, 18.457), (-64.438, 18.459), (-64.444, 18.473), (-64.426, 18.513), (-64.325, 18.517)], [(-64.288, 18.741), (-64.274, 18.707), (-64.282, 18.708), (-64.339, 18.731), (-64.383, 18.733), (-64.401, 18.739), (-64.411, 18.751), (-64.323, 18.753)]]], ['VI', [[(-64.766, 17.794), (-64.682, 17.75), (-64.58, 17.75), (-64.686, 17.706), (-64.889, 17.702), (-64.885, 17.772)], [(-64.66, 18.354), (-64.726, 18.328), (-64.771, 18.332), (-64.788, 18.341), (-64.752, 18.372)], [(-64.845, 18.33), (-64.92, 18.321), (-65.024, 18.368), (-64.942, 18.385), (-64.889, 18.374)]]], ['AL', [[(-88.071, 30.252), (-88.159, 30.231), (-88.29, 30.233), (-88.316, 30.24), (-88.264, 30.255), (-88.109, 30.274)], [(-87.566, 30.796), (-87.422, 30.672), (-87.408, 30.641), (-87.434, 30.546), (-87.429, 30.478), (-87.445, 30.443), (-87.48, 30.412), (-87.49, 30.378), (-87.513, 30.368), (-87.622, 30.265), (-88.006, 30.231), (-87.985, 30.254), (-87.904, 30.259), (-87.79, 30.292), (-87.813, 30.347), (-87.857, 30.407), (-87.898, 30.414), (-87.924, 30.45), (-87.923, 30.562), (-87.949, 30.627), (-88.011, 30.694), (-88.032, 30.681), (-88.078, 30.566), (-88.117, 30.415), (-88.135, 30.367), (-88.249, 30.363), (-88.35, 30.373), (-88.4, 30.371), (-88.486, 31.891), (-88.096, 34.846), (-88.089, 34.893), (-88.088, 34.909), (-88.085, 34.933), (-88.173, 34.999), (-88.191, 35.012), (-88.203, 35.024), (-88.19, 35.025), (-85.624, 35.001), (-85.227, 33.084), (-85.201, 32.956), (-85.176, 32.898), (-85.157, 32.804), (-85.015, 32.526), (-84.974, 32.409), (-84.986, 32.361), (-84.969, 32.32), (-84.922, 32.286), (-84.93, 32.247), (-84.993, 32.202), (-85.035, 32.147), (-85.065, 32.051), (-85.064, 32.051), (-85.124, 31.881), (-85.125, 31.777), (-85.067, 31.635), (-85.067, 31.635), (-85.055, 31.573), (-85.093, 31.296), (-85.067, 31.118), (-85.007, 31.002), (-87.594, 31.001), (-87.607, 30.929), (-87.601, 30.861)]]], ['AR', [[(-89.705, 36.002), (-89.709, 35.983), (-89.689, 35.944), (-89.689, 35.921), (-89.704, 35.907), (-89.738, 35.899), (-89.764, 35.889), (-89.769, 35.872), (-89.77, 35.864), (-89.768, 35.845), (-89.764, 35.828), (-89.78, 35.806), (-89.895, 35.751), (-89.944, 35.679), (-89.927, 35.592), (-89.967, 35.503), (-90.066, 35.414), (-90.108, 35.314), (-90.093, 35.204), (-90.142, 35.114), (-90.256, 35.046), (-90.294, 35.004), (-90.294, 35.001), (-90.293, 34.97), (-90.282, 34.945), (-90.32, 34.899), (-90.416, 34.852), (-90.468, 34.805), (-90.475, 34.76), (-90.497, 34.738), (-90.539, 34.728), (-90.564, 34.661), (-90.584, 34.504), (-90.635, 34.414), (-90.718, 34.392), (-90.762, 34.356), (-90.768, 34.308), (-90.817, 34.252), (-90.91, 34.189), (-90.94, 34.129), (-90.909, 34.072), (-90.915, 34.049), (-90.943, 34.03), (-91.043, 34.003), (-91.06, 33.989), (-91.07, 33.974), (-91.05, 33.945), (-91.038, 33.901), (-91.053, 33.828), (-91.077, 33.797), (-91.1, 33.767), (-91.184, 33.716), (-91.207, 33.676), (-91.17, 33.647), (-91.173, 33.617), (-91.215, 33.583), (-91.203, 33.547), (-91.193, 33.523), (-91.154, 33.5), (-91.141, 33.439), (-91.168, 33.359), (-91.163, 33.294), (-91.117, 33.241), (-91.107, 33.218), (-91.153, 33.041), (-91.15, 33.016), (-94.041, 33.012), (-94.047, 33.554), (-94.099, 33.577), (-94.192, 33.589), (-94.238, 33.581), (-94.295, 33.587), (-94.333, 33.565), (-94.358, 33.561), (-94.378, 33.566), (-94.39, 33.586), (-94.432, 33.6), (-94.484, 33.648), (-94.439, 35.387), (-94.618, 36.501), (-90.162, 36.501), (-90.118, 36.423), (-90.074, 36.372), (-90.067, 36.334), (-90.076, 36.297), (-90.149, 36.216), (-90.216, 36.178), (-90.253, 36.138), (-90.303, 36.099), (-90.381, 35.993)]]], ['AZ', [[(-109.047, 37.001), (-109.048, 31.328), (-111.042, 31.324), (-114.836, 32.508), (-114.788, 32.565), (-114.725, 32.715), (-114.721, 32.724), (-114.721, 32.724), (-114.582, 32.735), (-114.516, 32.773), (-114.478, 32.842), (-114.469, 32.912), (-114.491, 32.984), (-114.551, 33.037), (-114.648, 33.072), (-114.704, 33.17), (-114.719, 33.331), (-114.702, 33.418), (-114.651, 33.431), (-114.603, 33.47), (-114.556, 33.536), (-114.522, 33.608), (-114.499, 33.686), (-114.495, 33.785), (-114.509, 33.904), (-114.418, 34.051), (-114.329, 34.142), (-114.164, 34.253), (-114.126, 34.287), (-114.125, 34.314), (-114.125, 34.317), (-114.159, 34.355), (-114.308, 34.433), (-114.371, 34.488), (-114.377, 34.54), (-114.379, 34.541), (-114.398, 34.59), (-114.557, 34.795), (-114.611, 34.907), (-114.611, 34.991), (-114.611, 34.998), (-114.591, 35.353), (-114.649, 35.476), (-114.662, 35.545), (-114.645, 35.631), (-114.65, 35.684), (-114.677, 35.73), (-114.684, 35.814), (-114.687, 35.917), (-114.732, 35.984), (-114.741, 36.014), (-114.716, 36.085), (-114.669, 36.122), (-114.593, 36.148), (-114.505, 36.156), (-114.406, 36.148), (-114.332, 36.116), (-114.282, 36.06), (-114.232, 36.032), (-114.183, 36.03), (-114.119, 36.077), (-114.062, 36.175), (-114.043, 36.182), (-114.04, 37.004)]]], ['CA', [[(-118.35, 32.828), (-118.409, 32.819), (-118.473, 32.839), (-118.529, 32.936), (-118.59, 33.011), (-118.557, 33.033), (-118.507, 32.96), (-118.383, 32.849)], [(-119.438, 33.217), (-119.482, 33.215), (-119.544, 33.225), (-119.575, 33.278), (-119.525, 33.282), (-119.479, 33.275), (-119.442, 33.232)], [(-118.348, 33.386), (-118.297, 33.312), (-118.37, 33.321), (-118.446, 33.317), (-118.469, 33.357), (-118.492, 33.413), (-118.507, 33.427), (-118.559, 33.432), (-118.563, 33.437), (-118.569, 33.464), (-118.555, 33.477), (-118.392, 33.415)], [(-120.044, 33.919), (-120.114, 33.905), (-120.167, 33.918), (-120.252, 34.014), (-120.072, 34.027), (-119.994, 33.985), (-119.984, 33.973)], [(-120.307, 34.025), (-120.36, 34.022), (-120.442, 34.033), (-120.413, 34.056), (-120.368, 34.073), (-120.353, 34.061)], [(-119.882, 34.08), (-119.679, 34.028), (-119.569, 34.053), (-119.549, 34.028), (-119.562, 34.007), (-119.81, 33.968), (-119.886, 33.995), (-119.892, 34.032), (-119.918, 34.068)], [(-124.228, 42.001), (-120.001, 42.001), (-120.0, 39.0), (-118.126, 37.692), (-117.21, 37.003), (-116.406, 36.392), (-114.611, 34.991), (-114.611, 34.907), (-114.557, 34.795), (-114.398, 34.59), (-114.379, 34.541), (-114.377, 34.54), (-114.371, 34.488), (-114.308, 34.433), (-114.159, 34.355), (-114.125, 34.317), (-114.125, 34.314), (-114.126, 34.287), (-114.164, 34.253), (-114.329, 34.142), (-114.418, 34.051), (-114.509, 33.904), (-114.495, 33.785), (-114.499, 33.686), (-114.522, 33.608), (-114.556, 33.536), (-114.603, 33.47), (-114.651, 33.431), (-114.702, 33.418), (-114.719, 33.331), (-114.704, 33.17), (-114.648, 33.072), (-114.551, 33.037), (-114.491, 32.984), (-114.469, 32.912), (-114.478, 32.842), (-114.516, 32.773), (-114.582, 32.735), (-114.721, 32.724), (-114.721, 32.724), (-114.725, 32.715), (-117.128, 32.533), (-117.13, 32.54), (-117.137, 32.649), (-117.184, 32.688), (-117.243, 32.664), (-117.271, 32.806), (-117.256, 32.873), (-117.263, 32.939), (-117.319, 33.1), (-117.467, 33.295), (-117.789, 33.538), (-117.952, 33.62), (-118.081, 33.722), (-118.162, 33.751), (-118.264, 33.759), (-118.294, 33.712), (-118.41, 33.744), (-118.393, 33.858), (-118.506, 34.017), (-118.599, 34.035), (-118.832, 34.024), (-119.144, 34.112), (-119.236, 34.164), (-119.268, 34.257), (-119.414, 34.339), (-119.606, 34.418), (-119.713, 34.4), (-119.853, 34.412), (-120.053, 34.469), (-120.17, 34.476), (-120.396, 34.46), (-120.481, 34.472), (-120.56, 34.544), (-120.645, 34.58), (-120.627, 34.669), (-120.638, 34.749), (-120.625, 34.812), (-120.663, 34.949), (-120.634, 35.076), (-120.659, 35.122), (-120.707, 35.158), (-120.857, 35.21), (-120.885, 35.275), (-120.86, 35.365), (-120.9, 35.425), (-121.023, 35.481), (-121.138, 35.607), (-121.284, 35.676), (-121.344, 35.792), (-121.434, 35.864), (-121.465, 35.927), (-121.664, 36.154), (-121.877, 36.331), (-121.91, 36.433), (-121.919, 36.572), (-121.835, 36.657), (-121.79, 36.732), (-121.795, 36.801), (-121.807, 36.851), (-121.881, 36.939), (-122.164, 36.991), (-122.395, 37.208), (-122.408, 37.373), (-122.499, 37.543), (-122.5, 37.653), (-122.514, 37.772), (-122.446, 37.798), (-122.384, 37.789), (-122.39, 37.741), (-122.37, 37.656), (-122.298, 37.592), (-122.229, 37.564), (-122.166, 37.502), (-122.119, 37.483), (-122.071, 37.478), (-122.097, 37.518), (-122.124, 37.544), (-122.158, 37.626), (-122.222, 37.732), (-122.296, 37.79), (-122.333, 37.897), (-122.365, 37.921), (-122.385, 37.961), (-122.314, 38.007), (-122.217, 38.041), (-122.087, 38.05), (-121.717, 38.034), (-121.638, 38.061), (-121.573, 38.052), (-121.525, 38.056), (-121.626, 38.084), (-121.682, 38.075), (-121.749, 38.08), (-121.881, 38.075), (-121.934, 38.087), (-121.993, 38.12), (-122.032, 38.124), (-122.154, 38.066), (-122.208, 38.073), (-122.337, 38.136), (-122.393, 38.145), (-122.484, 38.109), (-122.495, 37.954), (-122.467, 37.838), (-122.521, 37.826), (-122.584, 37.874), (-122.681, 37.902), (-122.76, 37.946), (-122.873, 38.026), (-122.932, 38.055), (-122.999, 37.989), (-123.001, 38.019), (-122.968, 38.097), (-122.978, 38.227), (-122.877, 38.123), (-122.908, 38.197), (-122.987, 38.277), (-123.046, 38.305), (-123.121, 38.449), (-123.29, 38.536), (-123.425, 38.676), (-123.701, 38.907), (-123.72, 39.111), (-123.82, 39.368), (-123.778, 39.515), (-123.784, 39.619), (-123.833, 39.776), (-123.884, 39.861), (-124.109, 40.095), (-124.324, 40.252), (-124.357, 40.371), (-124.372, 40.491), (-124.325, 40.598), (-124.284, 40.711), (-124.254, 40.74), (-124.242, 40.728), (-124.251, 40.704), (-124.22, 40.696), (-124.208, 40.746), (-124.19, 40.772), (-124.222, 40.775), (-124.219, 40.791), (-124.2, 40.822), (-124.133, 40.97), (-124.14, 41.156), (-124.069, 41.384), (-124.072, 41.46), (-124.118, 41.622), (-124.163, 41.719), (-124.245, 41.788), (-124.209, 41.889), (-124.212, 41.985)]]], ['CO', [[(-102.024, 40.001), (-102.013, 37.001), (-103.001, 37.001), (-109.047, 37.001), (-109.046, 41.001), (-104.022, 41.001), (-102.025, 41.001)]]], ['CT', [[(-71.801, 42.012), (-71.796, 41.52), (-71.805, 41.417), (-71.83, 41.393), (-71.842, 41.336), (-71.93, 41.341), (-72.074, 41.326), (-72.265, 41.292), (-72.371, 41.312), (-72.479, 41.276), (-72.847, 41.266), (-72.925, 41.285), (-73.024, 41.216), (-73.182, 41.176), (-73.583, 41.022), (-73.63, 40.992), (-73.682, 41.055), (-73.723, 41.105), (-73.642, 41.143), (-73.58, 41.173), (-73.522, 41.201), (-73.484, 41.219), (-73.514, 41.257), (-73.545, 41.296), (-73.481, 42.056), (-72.808, 42.034), (-72.806, 42.008), (-72.763, 42.011), (-72.758, 42.034), (-71.802, 42.023)]]], ['DC', [[(-77.03, 38.889), (-77.053, 38.915), (-77.102, 38.936), (-77.122, 38.944), (-77.042, 39.012), (-76.989, 38.952), (-76.931, 38.888), (-77.02, 38.807)]]], ['DE', [[(-75.421, 39.815), (-75.464, 39.781), (-75.502, 39.717), (-75.588, 39.641), (-75.582, 39.589), (-75.567, 39.553), (-75.574, 39.477), (-75.52, 39.403), (-75.413, 39.281), (-75.392, 39.093), (-75.31, 38.967), (-75.185, 38.819), (-75.089, 38.778), (-75.084, 38.723), (-75.128, 38.632), (-75.187, 38.591), (-75.111, 38.599), (-75.073, 38.579), (-75.036, 38.503), (-75.038, 38.456), (-75.145, 38.455), (-75.366, 38.455), (-75.588, 38.455), (-75.689, 38.455), (-75.691, 38.455), (-75.693, 38.455), (-75.696, 38.455), (-75.698, 38.455), (-75.7, 38.455), (-75.702, 38.455), (-75.705, 38.455), (-75.707, 38.455), (-75.717, 38.613), (-75.726, 38.772), (-75.736, 38.93), (-75.746, 39.089), (-75.756, 39.247), (-75.765, 39.406), (-75.775, 39.564), (-75.785, 39.722), (-75.709, 39.803), (-75.677, 39.827), (-75.635, 39.839), (-75.51, 39.843)]]], ['FL', [[(-81.784, 24.545), (-81.809, 24.542), (-81.811, 24.558), (-81.768, 24.577), (-81.739, 24.575), (-81.74, 24.555)], [(-81.567, 24.6), (-81.632, 24.59), (-81.579, 24.629), (-81.562, 24.689), (-81.532, 24.642), (-81.532, 24.614)], [(-81.335, 24.65), (-81.365, 24.63), (-81.379, 24.636), (-81.379, 24.666), (-81.422, 24.733), (-81.42, 24.75), (-81.322, 24.685), (-81.32, 24.668)], [(-81.044, 24.717), (-81.09, 24.693), (-81.137, 24.711), (-81.085, 24.734), (-80.93, 24.759), (-80.989, 24.728)], [(-80.829, 24.804), (-80.848, 24.804), (-80.839, 24.818), (-80.799, 24.846), (-80.785, 24.835), (-80.787, 24.821)], [(-80.638, 24.903), (-80.665, 24.898), (-80.626, 24.941), (-80.615, 24.938)], [(-80.382, 25.142), (-80.581, 24.954), (-80.559, 25.001), (-80.481, 25.102), (-80.456, 25.149), (-80.404, 25.179), (-80.355, 25.234), (-80.351, 25.297), (-80.28, 25.341), (-80.257, 25.348)], [(-82.037, 26.454), (-82.073, 26.428), (-82.145, 26.447), (-82.184, 26.481), (-82.201, 26.548), (-82.139, 26.477), (-82.116, 26.461)], [(-82.084, 26.552), (-82.085, 26.494), (-82.136, 26.592), (-82.169, 26.701), (-82.121, 26.666)], [(-80.187, 27.278), (-80.171, 27.205), (-80.262, 27.376), (-80.376, 27.643), (-80.437, 27.851), (-80.396, 27.795), (-80.356, 27.679)], [(-84.908, 29.643), (-85.008, 29.607), (-85.117, 29.633), (-85.049, 29.638), (-85.001, 29.627), (-84.877, 29.679), (-84.812, 29.718), (-84.737, 29.732)], [(-84.884, 30.721), (-82.24, 30.566), (-82.239, 30.533), (-82.213, 30.481), (-82.206, 30.422), (-82.194, 30.393), (-82.163, 30.376), (-82.112, 30.371), (-82.062, 30.405), (-82.03, 30.478), (-82.022, 30.56), (-82.041, 30.653), (-82.038, 30.732), (-82.013, 30.778), (-81.983, 30.789), (-81.957, 30.814), (-81.936, 30.82), (-81.88, 30.806), (-81.673, 30.74), (-81.504, 30.731), (-81.457, 30.641), (-81.386, 30.27), (-81.337, 30.141), (-81.25, 29.794), (-81.105, 29.457), (-80.9, 29.05), (-80.564, 28.556), (-80.524, 28.486), (-80.568, 28.426), (-80.581, 28.365), (-80.585, 28.272), (-80.573, 28.181), (-80.533, 28.07), (-80.457, 27.901), (-80.5, 27.934), (-80.61, 28.178), (-80.623, 28.32), (-80.607, 28.523), (-80.633, 28.518), (-80.654, 28.452), (-80.665, 28.375), (-80.693, 28.345), (-80.732, 28.463), (-80.729, 28.516), (-80.688, 28.579), (-80.7, 28.601), (-80.766, 28.633), (-80.78, 28.683), (-80.771, 28.732), (-80.809, 28.759), (-80.838, 28.758), (-80.818, 28.636), (-80.787, 28.561), (-80.749, 28.381), (-80.686, 28.272), (-80.65, 28.181), (-80.226, 27.207), (-80.126, 27.083), (-80.089, 26.994), (-80.05, 26.808), (-80.041, 26.569), (-80.111, 26.132), (-80.126, 25.834), (-80.136, 25.843), (-80.143, 25.874), (-80.159, 25.878), (-80.219, 25.742), (-80.301, 25.619), (-80.328, 25.427), (-80.367, 25.331), (-80.485, 25.23), (-80.558, 25.232), (-80.737, 25.156), (-80.862, 25.176), (-81.012, 25.133), (-81.11, 25.138), (-81.167, 25.229), (-81.159, 25.269), (-81.136, 25.31), (-81.098, 25.319), (-80.965, 25.224), (-80.94, 25.264), (-80.98, 25.312), (-81.057, 25.338), (-81.113, 25.367), (-81.227, 25.583), (-81.345, 25.732), (-81.365, 25.831), (-81.568, 25.892), (-81.716, 25.983), (-81.811, 26.146), (-81.867, 26.435), (-81.931, 26.467), (-81.959, 26.49), (-81.896, 26.597), (-81.829, 26.687), (-81.882, 26.665), (-81.921, 26.631), (-81.97, 26.552), (-82.006, 26.54), (-82.04, 26.552), (-82.078, 26.704), (-82.067, 26.892), (-82.013, 26.962), (-82.096, 26.963), (-82.181, 26.937), (-82.169, 26.874), (-82.181, 26.84), (-82.243, 26.849), (-82.29, 26.871), (-82.354, 26.936), (-82.441, 27.06), (-82.62, 27.401), (-82.655, 27.449), (-82.715, 27.5), (-82.687, 27.515), (-82.636, 27.525), (-82.521, 27.678), (-82.431, 27.771), (-82.401, 27.835), (-82.406, 27.863), (-82.446, 27.903), (-82.498, 27.868), (-82.521, 27.878), (-82.58, 27.958), (-82.636, 27.981), (-82.675, 27.964), (-82.634, 27.898), (-82.597, 27.873), (-82.611, 27.777), (-82.626, 27.746), (-82.661, 27.718), (-82.715, 27.733), (-82.743, 27.709), (-82.775, 27.734), (-82.808, 27.777), (-82.844, 27.846), (-82.749, 28.237), (-82.661, 28.486), (-82.651, 28.77), (-82.644, 28.812), (-82.651, 28.887), (-82.769, 29.052), (-83.29, 29.452), (-83.694, 29.926), (-84.044, 30.104), (-84.31, 30.065), (-84.356, 30.029), (-84.375, 29.982), (-84.359, 29.929), (-84.383, 29.907), (-84.454, 29.91), (-84.55, 29.898), (-84.801, 29.773), (-84.889, 29.778), (-84.969, 29.745), (-85.029, 29.721), (-85.186, 29.708), (-85.319, 29.68), (-85.376, 29.695), (-85.414, 29.768), (-85.414, 29.842), (-85.383, 29.785), (-85.336, 29.74), (-85.315, 29.758), (-85.307, 29.798), (-85.354, 29.876), (-85.504, 29.976), (-85.676, 30.122), (-85.623, 30.117), (-85.61, 30.148), (-85.663, 30.189), (-85.641, 30.237), (-85.604, 30.287), (-85.676, 30.279), (-85.741, 30.244), (-85.743, 30.201), (-85.756, 30.167), (-85.791, 30.172), (-85.856, 30.214), (-86.175, 30.333), (-86.454, 30.399), (-86.24, 30.429), (-86.124, 30.406), (-86.138, 30.442), (-86.166, 30.464), (-86.257, 30.493), (-86.374, 30.482), (-86.448, 30.496), (-86.523, 30.467), (-86.606, 30.425), (-86.68, 30.403), (-86.968, 30.372), (-87.201, 30.339), (-87.164, 30.374), (-87.124, 30.397), (-86.986, 30.431), (-86.965, 30.502), (-86.998, 30.57), (-87.034, 30.554), (-87.072, 30.5), (-87.119, 30.539), (-87.171, 30.539), (-87.185, 30.454), (-87.251, 30.397), (-87.281, 30.339), (-87.476, 30.294), (-87.501, 30.309), (-87.444, 30.364), (-87.448, 30.394), (-87.49, 30.378), (-87.48, 30.412), (-87.445, 30.443), (-87.429, 30.478), (-87.434, 30.546), (-87.408, 30.641), (-87.422, 30.672), (-87.566, 30.796), (-87.601, 30.861), (-87.607, 30.929), (-87.594, 31.001), (-85.007, 31.002), (-84.966, 30.923), (-84.887, 30.759)]]], ['GA', [[(-81.419, 30.971), (-81.463, 30.728), (-81.483, 30.814), (-81.485, 30.898), (-81.451, 30.947)], [(-83.121, 35.001), (-83.17, 34.933), (-83.317, 34.806), (-83.356, 34.708), (-83.167, 34.6), (-83.166, 34.599), (-83.053, 34.511), (-82.976, 34.476), (-82.897, 34.466), (-82.848, 34.437), (-82.819, 34.366), (-82.819, 34.366), (-82.589, 34.017), (-82.589, 34.018), (-82.352, 33.838), (-82.257, 33.749), (-82.208, 33.664), (-82.006, 33.523), (-81.936, 33.447), (-81.933, 33.39), (-81.909, 33.349), (-81.864, 33.325), (-81.821, 33.274), (-81.78, 33.195), (-81.699, 33.127), (-81.578, 33.069), (-81.49, 32.936), (-81.434, 32.728), (-81.377, 32.607), (-81.29, 32.557), (-81.172, 32.38), (-81.133, 32.275), (-81.135, 32.182), (-81.075, 32.11), (-80.872, 32.03), (-80.923, 31.945), (-81.046, 31.892), (-81.083, 31.894), (-81.113, 31.879), (-81.096, 31.841), (-81.065, 31.813), (-81.066, 31.788), (-81.098, 31.753), (-81.162, 31.744), (-81.198, 31.704), (-81.187, 31.667), (-81.166, 31.646), (-81.17, 31.61), (-81.242, 31.574), (-81.259, 31.539), (-81.223, 31.528), (-81.196, 31.539), (-81.175, 31.531), (-81.219, 31.472), (-81.258, 31.436), (-81.295, 31.371), (-81.381, 31.353), (-81.378, 31.332), (-81.329, 31.314), (-81.288, 31.264), (-81.365, 31.172), (-81.413, 31.179), (-81.442, 31.2), (-81.46, 31.127), (-81.453, 31.088), (-81.471, 31.009), (-81.501, 30.914), (-81.52, 30.875), (-81.516, 30.802), (-81.504, 30.731), (-81.673, 30.74), (-81.88, 30.806), (-81.936, 30.82), (-81.957, 30.814), (-81.983, 30.789), (-82.013, 30.778), (-82.038, 30.732), (-82.041, 30.653), (-82.022, 30.56), (-82.03, 30.478), (-82.062, 30.405), (-82.112, 30.371), (-82.163, 30.376), (-82.194, 30.393), (-82.206, 30.422), (-82.213, 30.481), (-82.239, 30.533), (-82.24, 30.566), (-84.884, 30.721), (-84.887, 30.759), (-84.966, 30.923), (-85.007, 31.002), (-85.067, 31.118), (-85.093, 31.296), (-85.055, 31.573), (-85.067, 31.635), (-85.067, 31.635), (-85.125, 31.777), (-85.124, 31.881), (-85.064, 32.051), (-85.065, 32.051), (-85.035, 32.147), (-84.993, 32.202), (-84.93, 32.247), (-84.922, 32.286), (-84.969, 32.32), (-84.986, 32.361), (-84.974, 32.409), (-85.015, 32.526), (-85.157, 32.804), (-85.176, 32.898), (-85.201, 32.956), (-85.227, 33.084), (-85.624, 35.001), (-84.325, 34.988), (-84.022, 34.991), (-83.72, 34.995), (-83.417, 34.998), (-83.115, 35.001)]]], ['HI', [[(-155.581, 19.012), (-155.626, 18.964), (-155.681, 18.968), (-155.881, 19.071), (-155.906, 19.126), (-155.891, 19.383), (-155.966, 19.591), (-156.049, 19.75), (-155.988, 19.832), (-155.909, 19.895), (-155.82, 20.014), (-155.893, 20.167), (-155.874, 20.26), (-155.832, 20.276), (-155.622, 20.163), (-155.199, 19.994), (-155.086, 19.876), (-155.066, 19.748), (-154.989, 19.732), (-154.953, 19.645), (-154.841, 19.568), (-154.804, 19.524), (-154.85, 19.454), (-155.053, 19.319), (-155.31, 19.26), (-155.535, 19.109)], [(-156.85, 20.773), (-156.909, 20.744), (-156.973, 20.758), (-156.988, 20.826), (-157.051, 20.912), (-156.942, 20.93), (-156.881, 20.905), (-156.848, 20.878), (-156.809, 20.831)], [(-156.487, 20.933), (-156.461, 20.915), (-156.354, 20.941), (-156.278, 20.951), (-156.148, 20.885), (-156.104, 20.84), (-156.019, 20.792), (-155.99, 20.757), (-156.014, 20.715), (-156.107, 20.645), (-156.235, 20.629), (-156.31, 20.599), (-156.409, 20.605), (-156.438, 20.618), (-156.449, 20.706), (-156.48, 20.801), (-156.544, 20.79), (-156.615, 20.822), (-156.69, 20.901), (-156.698, 20.949), (-156.657, 21.025), (-156.585, 21.034), (-156.532, 20.993)], [(-157.214, 21.215), (-157.002, 21.188), (-156.952, 21.2), (-156.917, 21.177), (-156.742, 21.164), (-156.712, 21.155), (-156.748, 21.104), (-156.86, 21.056), (-157.021, 21.098), (-157.29, 21.113), (-157.279, 21.152), (-157.254, 21.181), (-157.25, 21.23)], [(-157.799, 21.457), (-157.765, 21.451), (-157.721, 21.458), (-157.706, 21.378), (-157.654, 21.334), (-157.635, 21.308), (-157.691, 21.28), (-157.799, 21.269), (-157.849, 21.291), (-157.902, 21.341), (-157.958, 21.327), (-157.968, 21.367), (-157.978, 21.378), (-158.017, 21.368), (-157.981, 21.316), (-158.079, 21.312), (-158.11, 21.319), (-158.138, 21.377), (-158.239, 21.489), (-158.239, 21.533), (-158.273, 21.585), (-158.123, 21.6), (-158.02, 21.692), (-157.962, 21.701), (-157.851, 21.553), (-157.854, 21.512), (-157.83, 21.471)], [(-160.18, 21.841), (-160.2, 21.797), (-160.235, 21.804), (-160.243, 21.843), (-160.221, 21.897), (-160.164, 21.944), (-160.101, 22.015), (-160.049, 22.005), (-160.077, 21.958), (-160.08, 21.907), (-160.153, 21.879)], [(-159.373, 21.932), (-159.461, 21.876), (-159.512, 21.9), (-159.609, 21.91), (-159.646, 21.952), (-159.748, 21.99), (-159.789, 22.042), (-159.727, 22.14), (-159.579, 22.223), (-159.352, 22.22), (-159.305, 22.154), (-159.301, 22.105), (-159.33, 22.051), (-159.344, 21.974)], [(-177.371, 28.201), (-177.39, 28.196), (-177.389, 28.209), (-177.371, 28.221), (-177.354, 28.217), (-177.362, 28.207)]]], ['IA', [[(-90.651, 42.513), (-90.59, 42.445), (-90.485, 42.383), (-90.425, 42.326), (-90.41, 42.272), (-90.347, 42.215), (-90.233, 42.154), (-90.168, 42.1), (-90.149, 42.054), (-90.152, 41.982), (-90.177, 41.884), (-90.218, 41.813), (-90.276, 41.77), (-90.319, 41.71), (-90.348, 41.632), (-90.437, 41.56), (-90.587, 41.495), (-90.754, 41.45), (-90.939, 41.426), (-91.048, 41.369), (-91.082, 41.28), (-91.067, 41.206), (-91.001, 41.146), (-90.964, 41.083), (-90.954, 41.016), (-91.0, 40.905), (-91.102, 40.75), (-91.215, 40.65), (-91.339, 40.604), (-91.394, 40.537), (-91.381, 40.448), (-91.391, 40.397), (-91.442, 40.379), (-91.53, 40.432), (-91.545, 40.469), (-91.617, 40.507), (-91.627, 40.531), (-91.682, 40.552), (-91.732, 40.625), (-95.765, 40.602), (-95.826, 40.676), (-95.859, 40.745), (-95.838, 40.778), (-95.834, 40.889), (-95.847, 41.08), (-95.871, 41.188), (-95.907, 41.212), (-95.911, 41.245), (-95.884, 41.288), (-95.892, 41.316), (-95.936, 41.331), (-95.95, 41.367), (-95.933, 41.425), (-95.944, 41.461), (-95.982, 41.474), (-95.997, 41.494), (-95.991, 41.52), (-96.011, 41.538), (-96.059, 41.546), (-96.078, 41.611), (-96.069, 41.734), (-96.087, 41.821), (-96.131, 41.872), (-96.154, 41.92), (-96.154, 41.965), (-96.201, 42.036), (-96.295, 42.133), (-96.356, 42.26), (-96.384, 42.418), (-96.451, 42.506), (-96.481, 42.511), (-96.506, 42.594), (-96.534, 42.63), (-96.539, 42.659), (-96.622, 42.73), (-96.627, 42.757), (-96.616, 42.791), (-96.563, 42.859), (-96.513, 42.969), (-96.502, 43.043), (-96.463, 43.099), (-96.461, 43.13), (-96.468, 43.17), (-96.49, 43.206), (-96.555, 43.232), (-96.563, 43.243), (-96.57, 43.283), (-96.543, 43.309), (-96.535, 43.338), (-96.542, 43.373), (-96.581, 43.435), (-96.599, 43.498), (-96.454, 43.501), (-96.128, 43.501), (-91.245, 43.502), (-91.238, 43.44), (-91.219, 43.395), (-91.178, 43.359), (-91.117, 43.331), (-91.107, 43.278), (-91.148, 43.2), (-91.161, 43.102), (-91.148, 42.986), (-91.118, 42.882), (-91.07, 42.789), (-90.96, 42.72), (-90.789, 42.677), (-90.688, 42.61), (-90.657, 42.521)]]], ['ID', [[(-111.051, 44.499), (-111.05, 42.001), (-114.043, 42.001), (-117.017, 42.001), (-117.02, 43.808), (-117.02, 43.813), (-116.958, 43.964), (-116.944, 44.038), (-116.961, 44.079), (-116.95, 44.119), (-116.911, 44.157), (-116.912, 44.199), (-116.953, 44.245), (-117.029, 44.276), (-117.14, 44.29), (-117.197, 44.344), (-117.202, 44.436), (-117.119, 44.578), (-116.949, 44.77), (-116.856, 44.906), (-116.84, 44.985), (-116.737, 45.169), (-116.549, 45.457), (-116.477, 45.641), (-116.521, 45.722), (-116.617, 45.799), (-116.765, 45.873), (-116.869, 45.958), (-116.896, 46.002), (-116.93, 46.056), (-116.948, 46.124), (-116.922, 46.164), (-116.943, 46.232), (-117.01, 46.33), (-117.039, 46.397), (-117.032, 46.42), (-117.025, 46.429), (-117.039, 48.993), (-116.048, 48.993), (-116.049, 48.005), (-115.941, 47.904), (-115.862, 47.842), (-115.811, 47.776), (-115.734, 47.706), (-115.718, 47.681), (-115.691, 47.607), (-115.711, 47.553), (-115.67, 47.498), (-115.677, 47.471), (-115.708, 47.457), (-115.714, 47.452), (-115.713, 47.447), (-115.702, 47.438), (-115.593, 47.385), (-115.486, 47.312), (-115.349, 47.261), (-115.307, 47.231), (-115.127, 47.085), (-115.034, 46.991), (-114.936, 46.923), (-114.887, 46.845), (-114.786, 46.777), (-114.761, 46.742), (-114.754, 46.735), (-114.74, 46.734), (-114.678, 46.75), (-114.662, 46.746), (-114.631, 46.719), (-114.624, 46.678), (-114.602, 46.66), (-114.563, 46.65), (-114.519, 46.648), (-114.381, 46.668), (-114.351, 46.668), (-114.337, 46.659), (-114.33, 46.638), (-114.332, 46.601), (-114.346, 46.551), (-114.387, 46.5), (-114.38, 46.453), (-114.413, 46.344), (-114.444, 46.271), (-114.447, 46.199), (-114.485, 46.158), (-114.464, 46.11), (-114.478, 46.036), (-114.465, 46.016), (-114.416, 45.982), (-114.397, 45.891), (-114.405, 45.874), (-114.493, 45.839), (-114.523, 45.815), (-114.534, 45.782), (-114.496, 45.686), (-114.533, 45.633), (-114.537, 45.587), (-114.529, 45.576), (-114.448, 45.551), (-114.351, 45.497), (-114.319, 45.486), (-114.298, 45.488), (-114.256, 45.506), (-114.21, 45.542), (-114.117, 45.579), (-114.006, 45.658), (-114.001, 45.681), (-113.992, 45.693), (-113.978, 45.692), (-113.943, 45.682), (-113.873, 45.634), (-113.813, 45.607), (-113.802, 45.601), (-113.797, 45.588), (-113.8, 45.54), (-113.766, 45.503), (-113.756, 45.441), (-113.722, 45.379), (-113.697, 45.305), (-113.607, 45.209), (-113.557, 45.14), (-113.504, 45.109), (-113.471, 45.073), (-113.447, 45.029), (-113.438, 44.994), (-113.469, 44.93), (-113.461, 44.904), (-113.432, 44.874), (-113.339, 44.808), (-113.32, 44.803), (-113.234, 44.81), (-113.187, 44.799), (-113.141, 44.765), (-113.093, 44.715), (-113.063, 44.665), (-113.054, 44.605), (-113.006, 44.539), (-113.0, 44.48), (-112.97, 44.454), (-112.91, 44.419), (-112.854, 44.398), (-112.831, 44.397), (-112.816, 44.406), (-112.81, 44.438), (-112.787, 44.463), (-112.716, 44.498), (-112.648, 44.497), (-112.393, 44.468), (-112.375, 44.47), (-112.364, 44.48), (-112.32, 44.533), (-112.285, 44.554), (-112.231, 44.561), (-112.074, 44.548), (-111.892, 44.555), (-111.797, 44.54), (-111.659, 44.56), (-111.5, 44.545), (-111.479, 44.554), (-111.475, 44.565), (-111.489, 44.585), (-111.491, 44.624), (-111.459, 44.671), (-111.448, 44.711), (-111.416, 44.734), (-111.373, 44.746), (-111.337, 44.745), (-111.304, 44.723), (-111.265, 44.688), (-111.198, 44.591), (-111.161, 44.556), (-111.117, 44.525)]]], ['IL', [[(-87.812, 42.497), (-87.812, 42.341), (-87.797, 42.211), (-87.767, 42.154), (-87.733, 42.112), (-87.695, 42.084), (-87.651, 42.0), (-87.602, 41.859), (-87.557, 41.766), (-87.521, 41.728), (-87.533, 39.379), (-87.533, 39.375), (-87.579, 39.344), (-87.611, 39.291), (-87.603, 39.234), (-87.615, 39.193), (-87.647, 39.169), (-87.632, 39.107), (-87.568, 39.007), (-87.53, 38.909), (-87.518, 38.812), (-87.529, 38.742), (-87.584, 38.679), (-87.636, 38.543), (-87.681, 38.488), (-87.735, 38.47), (-87.784, 38.419), (-87.827, 38.336), (-87.873, 38.295), (-87.921, 38.298), (-87.957, 38.282), (-87.98, 38.249), (-87.977, 38.214), (-87.949, 38.178), (-87.958, 38.144), (-88.006, 38.113), (-88.005, 38.098), (-87.99, 38.089), (-87.996, 38.074), (-88.026, 38.06), (-88.045, 38.013), (-88.042, 37.937), (-88.059, 37.898), (-88.091, 37.897), (-88.095, 37.876), (-88.042, 37.789), (-88.073, 37.771), (-88.129, 37.7), (-88.14, 37.621), (-88.108, 37.534), (-88.191, 37.465), (-88.389, 37.411), (-88.495, 37.364), (-88.507, 37.324), (-88.493, 37.262), (-88.453, 37.178), (-88.446, 37.12), (-88.472, 37.088), (-88.614, 37.11), (-88.873, 37.186), (-89.046, 37.183), (-89.135, 37.102), (-89.165, 37.042), (-89.154, 36.992), (-89.225, 37.053), (-89.272, 37.08), (-89.281, 37.078), (-89.292, 37.071), (-89.296, 37.052), (-89.293, 37.038), (-89.286, 37.023), (-89.29, 37.013), (-89.301, 37.012), (-89.352, 37.036), (-89.414, 37.102), (-89.487, 37.213), (-89.503, 37.301), (-89.462, 37.366), (-89.462, 37.434), (-89.503, 37.506), (-89.523, 37.576), (-89.523, 37.645), (-89.623, 37.747), (-89.823, 37.884), (-89.97, 37.969), (-90.064, 38.001), (-90.174, 38.069), (-90.299, 38.174), (-90.366, 38.254), (-90.374, 38.31), (-90.317, 38.458), (-90.151, 38.781), (-90.132, 38.819), (-90.127, 38.833), (-90.134, 38.847), (-90.15, 38.86), (-90.22, 38.898), (-90.354, 38.93), (-90.478, 38.948), (-90.577, 38.91), (-90.664, 38.987), (-90.737, 39.182), (-90.919, 39.387), (-91.21, 39.603), (-91.379, 39.749), (-91.426, 39.827), (-91.467, 39.943), (-91.502, 40.098), (-91.5, 40.226), (-91.442, 40.379), (-91.391, 40.397), (-91.381, 40.448), (-91.394, 40.537), (-91.339, 40.604), (-91.215, 40.65), (-91.102, 40.75), (-91.0, 40.905), (-90.954, 41.016), (-90.964, 41.083), (-91.001, 41.146), (-91.067, 41.206), (-91.082, 41.28), (-91.048, 41.369), (-90.939, 41.426), (-90.754, 41.45), (-90.587, 41.495), (-90.437, 41.56), (-90.348, 41.632), (-90.319, 41.71), (-90.276, 41.77), (-90.218, 41.813), (-90.177, 41.884), (-90.152, 41.982), (-90.149, 42.054), (-90.168, 42.1), (-90.233, 42.154), (-90.347, 42.215), (-90.41, 42.272), (-90.425, 42.326), (-90.485, 42.383), (-90.59, 42.445), (-90.651, 42.513)]]], ['IN', [[(-84.796, 41.701), (-84.822, 39.092), (-84.837, 39.083), (-84.861, 39.04), (-84.835, 38.996), (-84.837, 38.961), (-84.864, 38.933), (-84.854, 38.913), (-84.807, 38.9), (-84.79, 38.868), (-84.801, 38.819), (-84.901, 38.77), (-85.094, 38.714), (-85.136, 38.697), (-85.17, 38.69), (-85.186, 38.694), (-85.186, 38.694), (-85.211, 38.704), (-85.247, 38.727), (-85.307, 38.737), (-85.405, 38.73), (-85.445, 38.683), (-85.425, 38.597), (-85.459, 38.53), (-85.546, 38.484), (-85.609, 38.423), (-85.646, 38.347), (-85.706, 38.301), (-85.788, 38.285), (-85.855, 38.215), (-85.906, 38.091), (-85.961, 38.014), (-86.021, 37.984), (-86.103, 37.992), (-86.208, 38.037), (-86.268, 38.083), (-86.284, 38.13), (-86.315, 38.164), (-86.343, 38.179), (-86.361, 38.179), (-86.363, 38.172), (-86.355, 38.159), (-86.365, 38.145), (-86.43, 38.14), (-86.457, 38.12), (-86.448, 38.086), (-86.463, 38.062), (-86.5, 38.048), (-86.52, 38.015), (-86.522, 37.964), (-86.549, 37.917), (-86.599, 37.875), (-86.673, 37.889), (-86.77, 37.96), (-86.869, 37.976), (-86.969, 37.938), (-87.044, 37.886), (-87.094, 37.821), (-87.141, 37.805), (-87.209, 37.855), (-87.372, 37.923), (-87.457, 37.938), (-87.518, 37.922), (-87.561, 37.929), (-87.576, 37.948), (-87.587, 37.956), (-87.599, 37.946), (-87.601, 37.887), (-87.615, 37.849), (-87.643, 37.833), (-87.665, 37.846), (-87.679, 37.886), (-87.714, 37.9), (-87.77, 37.885), (-87.825, 37.891), (-87.874, 37.916), (-87.892, 37.913), (-87.906, 37.902), (-87.902, 37.855), (-87.912, 37.818), (-87.938, 37.794), (-87.975, 37.788), (-88.022, 37.8), (-88.042, 37.789), (-88.095, 37.876), (-88.091, 37.897), (-88.059, 37.898), (-88.042, 37.937), (-88.045, 38.013), (-88.026, 38.06), (-87.996, 38.074), (-87.99, 38.089), (-88.005, 38.098), (-88.006, 38.113), (-87.958, 38.144), (-87.949, 38.178), (-87.977, 38.214), (-87.98, 38.249), (-87.957, 38.282), (-87.921, 38.298), (-87.873, 38.295), (-87.827, 38.336), (-87.784, 38.419), (-87.735, 38.47), (-87.681, 38.488), (-87.636, 38.543), (-87.584, 38.679), (-87.529, 38.742), (-87.518, 38.812), (-87.53, 38.909), (-87.568, 39.007), (-87.632, 39.107), (-87.647, 39.169), (-87.615, 39.193), (-87.603, 39.234), (-87.611, 39.291), (-87.579, 39.344), (-87.533, 39.375), (-87.533, 39.379), (-87.521, 41.728), (-87.515, 41.721), (-87.477, 41.695), (-87.447, 41.681), (-87.425, 41.679), (-87.412, 41.656), (-87.356, 41.643), (-87.253, 41.638), (-87.159, 41.646), (-87.073, 41.669), (-86.863, 41.761), (-84.796, 41.76)]]], ['KS', [[(-94.618, 37.001), (-102.013, 37.001), (-102.024, 40.001), (-95.347, 40.001), (-95.116, 39.872), (-95.056, 39.871), (-94.984, 39.891), (-94.93, 39.861), (-94.893, 39.782), (-94.899, 39.741), (-94.946, 39.739), (-95.005, 39.692), (-95.075, 39.597), (-95.058, 39.509), (-94.953, 39.426), (-94.882, 39.343), (-94.847, 39.259), (-94.778, 39.194), (-94.622, 39.124), (-94.625, 39.086)]]], ['KY', [[(-89.487, 36.503), (-89.557, 36.501), (-89.56, 36.513), (-89.555, 36.541), (-89.55, 36.553), (-89.536, 36.555), (-89.52, 36.555), (-89.497, 36.529)], [(-84.661, 39.094), (-84.595, 39.086), (-84.509, 39.103), (-84.43, 39.091), (-84.358, 39.05), (-84.29, 38.975), (-84.227, 38.865), (-84.113, 38.798), (-83.948, 38.774), (-83.828, 38.731), (-83.752, 38.669), (-83.69, 38.65), (-83.616, 38.683), (-83.538, 38.7), (-83.461, 38.68), (-83.357, 38.627), (-83.203, 38.639), (-83.0, 38.714), (-82.88, 38.71), (-82.845, 38.628), (-82.758, 38.541), (-82.621, 38.451), (-82.613, 38.448), (-82.589, 38.42), (-82.578, 38.272), (-82.585, 38.243), (-82.62, 38.182), (-82.618, 38.15), (-82.589, 38.1), (-82.482, 37.984), (-82.472, 37.938), (-82.43, 37.894), (-82.394, 37.828), (-82.28, 37.687), (-82.103, 37.571), (-81.965, 37.54), (-82.343, 37.297), (-82.517, 37.209), (-82.682, 37.138), (-82.695, 37.126), (-82.732, 37.048), (-82.832, 36.979), (-82.895, 36.906), (-83.044, 36.846), (-83.15, 36.762), (-83.417, 36.681), (-83.566, 36.653), (-83.668, 36.605), (-83.675, 36.603), (-83.683, 36.6), (-83.691, 36.598), (-83.699, 36.596), (-83.707, 36.594), (-83.715, 36.591), (-83.723, 36.589), (-83.73, 36.587), (-86.508, 36.665), (-87.839, 36.644), (-87.869, 36.675), (-87.956, 36.682), (-88.091, 36.693), (-88.096, 36.693), (-88.057, 36.59), (-88.056, 36.501), (-88.059, 36.5), (-89.45, 36.5), (-89.397, 36.588), (-89.351, 36.611), (-89.331, 36.616), (-89.28, 36.6), (-89.256, 36.594), (-89.203, 36.626), (-89.156, 36.716), (-89.13, 36.811), (-89.122, 36.912), (-89.154, 36.992), (-89.165, 37.042), (-89.135, 37.102), (-89.046, 37.183), (-88.873, 37.186), (-88.614, 37.11), (-88.472, 37.088), (-88.446, 37.12), (-88.453, 37.178), (-88.493, 37.262), (-88.507, 37.324), (-88.495, 37.364), (-88.389, 37.411), (-88.191, 37.465), (-88.108, 37.534), (-88.14, 37.621), (-88.129, 37.7), (-88.073, 37.771), (-88.042, 37.789), (-88.022, 37.8), (-87.975, 37.788), (-87.938, 37.794), (-87.912, 37.818), (-87.902, 37.855), (-87.906, 37.902), (-87.892, 37.913), (-87.874, 37.916), (-87.825, 37.891), (-87.77, 37.885), (-87.714, 37.9), (-87.679, 37.886), (-87.665, 37.846), (-87.643, 37.833), (-87.615, 37.849), (-87.601, 37.887), (-87.599, 37.946), (-87.587, 37.956), (-87.576, 37.948), (-87.561, 37.929), (-87.518, 37.922), (-87.457, 37.938), (-87.372, 37.923), (-87.209, 37.855), (-87.141, 37.805), (-87.094, 37.821), (-87.044, 37.886), (-86.969, 37.938), (-86.869, 37.976), (-86.77, 37.96), (-86.673, 37.889), (-86.599, 37.875), (-86.549, 37.917), (-86.522, 37.964), (-86.52, 38.015), (-86.5, 38.048), (-86.463, 38.062), (-86.448, 38.086), (-86.457, 38.12), (-86.43, 38.14), (-86.365, 38.145), (-86.355, 38.159), (-86.363, 38.172), (-86.361, 38.179), (-86.343, 38.179), (-86.315, 38.164), (-86.284, 38.13), (-86.268, 38.083), (-86.208, 38.037), (-86.103, 37.992), (-86.021, 37.984), (-85.961, 38.014), (-85.906, 38.091), (-85.855, 38.215), (-85.788, 38.285), (-85.706, 38.301), (-85.646, 38.347), (-85.609, 38.423), (-85.546, 38.484), (-85.459, 38.53), (-85.425, 38.597), (-85.445, 38.683), (-85.405, 38.73), (-85.307, 38.737), (-85.247, 38.727), (-85.211, 38.704), (-85.186, 38.694), (-85.186, 38.694), (-85.17, 38.69), (-85.136, 38.697), (-85.094, 38.714), (-84.901, 38.77), (-84.801, 38.819), (-84.79, 38.868), (-84.807, 38.9), (-84.854, 38.913), (-84.864, 38.933), (-84.837, 38.961), (-84.835, 38.996), (-84.861, 39.04), (-84.837, 39.083), (-84.822, 39.092), (-84.766, 39.125), (-84.707, 39.129)]]], ['LA', [[(-91.794, 29.501), (-91.831, 29.486), (-91.996, 29.573), (-92.007, 29.61), (-91.925, 29.644), (-91.875, 29.641), (-91.797, 29.597), (-91.768, 29.585), (-91.754, 29.567), (-91.762, 29.539)], [(-88.889, 29.713), (-88.944, 29.66), (-88.941, 29.68), (-88.901, 29.733), (-88.873, 29.753)], [(-88.827, 29.808), (-88.856, 29.776), (-88.828, 29.928), (-88.867, 30.057), (-88.826, 30.0), (-88.813, 29.933)], [(-89.224, 30.084), (-89.22, 30.038), (-89.269, 30.061), (-89.342, 30.063), (-89.31, 30.079), (-89.288, 30.094), (-89.276, 30.111), (-89.185, 30.169), (-89.211, 30.126)], [(-91.656, 31.002), (-89.735, 31.001), (-89.765, 30.886), (-89.835, 30.731), (-89.838, 30.69), (-89.82, 30.64), (-89.82, 30.611), (-89.794, 30.569), (-89.737, 30.527), (-89.686, 30.463), (-89.641, 30.349), (-89.629, 30.296), (-89.592, 30.223), (-89.572, 30.209), (-89.545, 30.201), (-89.521, 30.193), (-89.588, 30.166), (-89.954, 30.269), (-90.045, 30.351), (-90.126, 30.369), (-90.225, 30.379), (-90.332, 30.278), (-90.413, 30.14), (-90.285, 30.065), (-90.175, 30.029), (-89.994, 30.059), (-89.894, 30.126), (-89.812, 30.124), (-89.773, 30.137), (-89.737, 30.172), (-89.668, 30.145), (-89.665, 30.117), (-89.715, 30.078), (-89.777, 30.046), (-89.815, 30.007), (-89.744, 29.93), (-89.632, 29.904), (-89.59, 29.915), (-89.563, 30.002), (-89.494, 30.058), (-89.401, 30.046), (-89.414, 30.011), (-89.401, 29.978), (-89.358, 29.921), (-89.363, 29.84), (-89.354, 29.82), (-89.455, 29.784), (-89.531, 29.772), (-89.591, 29.725), (-89.559, 29.698), (-89.621, 29.674), (-89.662, 29.684), (-89.683, 29.675), (-89.689, 29.646), (-89.721, 29.619), (-89.675, 29.539), (-89.58, 29.486), (-89.514, 29.42), (-89.246, 29.333), (-89.181, 29.336), (-89.117, 29.248), (-89.065, 29.218), (-89.016, 29.203), (-89.021, 29.143), (-89.11, 29.099), (-89.133, 29.046), (-89.156, 29.017), (-89.195, 29.054), (-89.236, 29.081), (-89.331, 28.999), (-89.376, 28.981), (-89.354, 29.07), (-89.389, 29.105), (-89.443, 29.194), (-89.522, 29.249), (-89.577, 29.268), (-89.62, 29.302), (-89.672, 29.317), (-89.717, 29.313), (-89.792, 29.333), (-89.797, 29.381), (-89.818, 29.416), (-89.877, 29.458), (-90.159, 29.537), (-90.161, 29.504), (-90.141, 29.48), (-90.101, 29.463), (-90.052, 29.431), (-90.053, 29.337), (-90.074, 29.297), (-90.083, 29.24), (-90.101, 29.182), (-90.136, 29.136), (-90.213, 29.105), (-90.247, 29.131), (-90.302, 29.256), (-90.379, 29.295), (-90.503, 29.3), (-90.586, 29.272), (-90.678, 29.151), (-90.751, 29.131), (-91.003, 29.194), (-91.29, 29.289), (-91.283, 29.321), (-91.237, 29.331), (-91.151, 29.318), (-91.155, 29.351), (-91.244, 29.457), (-91.26, 29.505), (-91.249, 29.564), (-91.278, 29.563), (-91.331, 29.514), (-91.514, 29.555), (-91.565, 29.605), (-91.672, 29.746), (-91.824, 29.751), (-91.893, 29.836), (-92.017, 29.8), (-92.08, 29.761), (-92.135, 29.699), (-92.114, 29.668), (-92.059, 29.617), (-92.084, 29.593), (-92.261, 29.557), (-92.671, 29.597), (-92.791, 29.635), (-92.952, 29.714), (-93.176, 29.779), (-93.283, 29.789), (-93.388, 29.777), (-93.695, 29.77), (-93.766, 29.753), (-93.826, 29.725), (-93.866, 29.756), (-93.884, 29.81), (-93.848, 29.819), (-93.809, 29.851), (-93.773, 29.914), (-93.769, 29.952), (-93.794, 29.977), (-93.727, 30.077), (-93.711, 30.113), (-93.721, 30.283), (-93.75, 30.345), (-93.747, 30.38), (-93.715, 30.473), (-93.72, 30.558), (-93.665, 30.661), (-93.625, 30.714), (-93.579, 30.824), (-93.569, 30.895), (-93.549, 30.948), (-93.563, 31.005), (-93.531, 31.046), (-93.551, 31.104), (-93.558, 31.18), (-93.597, 31.21), (-93.666, 31.323), (-93.664, 31.372), (-93.736, 31.478), (-93.738, 31.514), (-93.807, 31.569), (-93.821, 31.604), (-93.827, 31.75), (-93.846, 31.793), (-93.905, 31.877), (-94.043, 31.999), (-94.041, 33.012), (-91.15, 33.016), (-91.144, 32.967), (-91.096, 32.938), (-91.093, 32.885), (-91.136, 32.809), (-91.136, 32.756), (-91.092, 32.726), (-91.094, 32.694), (-91.142, 32.661), (-91.15, 32.625), (-91.116, 32.586), (-91.101, 32.541), (-91.104, 32.49), (-91.059, 32.424), (-90.99, 32.381), (-90.945, 32.331), (-90.94, 32.303), (-90.938, 32.277), (-90.948, 32.24), (-91.005, 32.186), (-91.048, 32.146), (-91.075, 32.131), (-91.089, 32.104), (-91.093, 32.046), (-91.157, 31.971), (-91.286, 31.884), (-91.373, 31.774), (-91.415, 31.64), (-91.459, 31.555), (-91.506, 31.519), (-91.529, 31.449), (-91.529, 31.345), (-91.559, 31.288), (-91.618, 31.277), (-91.631, 31.218), (-91.596, 31.11), (-91.611, 31.065), (-91.653, 31.03)]]], ['MA', [[(-69.978, 41.266), (-70.055, 41.249), (-70.233, 41.286), (-70.087, 41.318), (-70.063, 41.328), (-70.044, 41.374), (-70.041, 41.397), (-69.986, 41.299)], [(-70.51, 41.376), (-70.785, 41.327), (-70.829, 41.359), (-70.76, 41.374), (-70.674, 41.449), (-70.616, 41.457), (-70.525, 41.415)], [(-70.781, 42.721), (-70.736, 42.669), (-70.697, 42.665), (-70.655, 42.674), (-70.624, 42.672), (-70.604, 42.65), (-70.613, 42.623), (-70.661, 42.617), (-70.752, 42.57), (-70.831, 42.553), (-70.871, 42.497), (-70.93, 42.432), (-71.046, 42.331), (-70.997, 42.3), (-70.818, 42.265), (-70.738, 42.229), (-70.618, 42.04), (-70.645, 42.022), (-70.656, 41.987), (-70.549, 41.939), (-70.515, 41.803), (-70.427, 41.757), (-70.295, 41.729), (-70.135, 41.77), (-70.001, 41.826), (-70.006, 41.872), (-70.09, 41.98), (-70.11, 42.03), (-70.173, 42.063), (-70.196, 42.035), (-70.237, 42.071), (-70.241, 42.091), (-70.203, 42.101), (-70.16, 42.097), (-70.109, 42.078), (-69.978, 41.961), (-69.942, 41.808), (-69.934, 41.71), (-69.949, 41.677), (-69.987, 41.684), (-70.06, 41.677), (-70.405, 41.627), (-70.481, 41.582), (-70.657, 41.534), (-70.668, 41.558), (-70.655, 41.608), (-70.666, 41.71), (-70.701, 41.715), (-70.974, 41.549), (-71.08, 41.538), (-71.169, 41.489), (-71.188, 41.516), (-71.204, 41.641), (-71.149, 41.746), (-71.178, 41.744), (-71.234, 41.707), (-71.268, 41.751), (-71.305, 41.775), (-71.341, 41.798), (-71.339, 41.835), (-71.338, 41.891), (-71.379, 41.902), (-71.384, 41.972), (-71.387, 42.017), (-71.801, 42.012), (-71.802, 42.023), (-72.758, 42.034), (-72.763, 42.011), (-72.806, 42.008), (-72.808, 42.034), (-73.481, 42.056), (-73.507, 42.08), (-73.253, 42.752), (-72.467, 42.73), (-71.33, 42.702), (-71.242, 42.73), (-71.139, 42.808), (-71.076, 42.825), (-70.974, 42.872), (-70.923, 42.882), (-70.806, 42.877), (-70.829, 42.825), (-70.8, 42.774)]]], ['MD', [[(-75.226, 38.04), (-75.252, 38.037), (-75.226, 38.072), (-75.137, 38.24), (-75.098, 38.298), (-75.136, 38.181), (-75.203, 38.072)], [(-75.785, 39.722), (-75.775, 39.564), (-75.765, 39.406), (-75.756, 39.247), (-75.746, 39.089), (-75.736, 38.93), (-75.726, 38.772), (-75.717, 38.613), (-75.707, 38.455), (-75.705, 38.455), (-75.702, 38.455), (-75.7, 38.455), (-75.698, 38.455), (-75.696, 38.455), (-75.693, 38.455), (-75.691, 38.455), (-75.689, 38.455), (-75.588, 38.455), (-75.366, 38.455), (-75.145, 38.455), (-75.038, 38.456), (-75.039, 38.426), (-75.051, 38.383), (-75.074, 38.366), (-75.073, 38.41), (-75.09, 38.425), (-75.117, 38.406), (-75.134, 38.384), (-75.141, 38.298), (-75.16, 38.255), (-75.225, 38.242), (-75.292, 38.129), (-75.354, 38.065), (-75.376, 38.025), (-75.469, 38.015), (-75.62, 37.999), (-75.659, 37.954), (-75.735, 37.974), (-75.851, 37.972), (-75.829, 38.033), (-75.795, 38.087), (-75.856, 38.14), (-75.891, 38.147), (-75.928, 38.169), (-75.885, 38.214), (-75.864, 38.261), (-75.877, 38.319), (-75.859, 38.362), (-75.889, 38.356), (-75.937, 38.31), (-75.967, 38.291), (-75.986, 38.332), (-76.007, 38.323), (-76.02, 38.295), (-76.051, 38.28), (-76.116, 38.318), (-76.212, 38.361), (-76.265, 38.436), (-76.295, 38.495), (-76.264, 38.6), (-76.198, 38.619), (-76.113, 38.602), (-76.001, 38.602), (-76.017, 38.625), (-76.057, 38.621), (-76.175, 38.707), (-76.213, 38.758), (-76.278, 38.772), (-76.308, 38.723), (-76.341, 38.71), (-76.3, 38.818), (-76.247, 38.823), (-76.168, 38.853), (-76.191, 38.916), (-76.241, 38.943), (-76.331, 38.909), (-76.33, 38.953), (-76.313, 39.009), (-76.245, 39.009), (-76.186, 38.991), (-76.135, 39.082), (-76.133, 39.123), (-76.217, 39.064), (-76.236, 39.192), (-76.153, 39.315), (-76.074, 39.369), (-75.976, 39.367), (-75.876, 39.376), (-75.939, 39.399), (-76.003, 39.411), (-75.955, 39.46), (-75.913, 39.468), (-75.873, 39.511), (-75.97, 39.505), (-75.959, 39.585), (-76.006, 39.569), (-76.063, 39.561), (-76.085, 39.527), (-76.081, 39.47), (-76.097, 39.433), (-76.141, 39.403), (-76.216, 39.38), (-76.223, 39.42), (-76.248, 39.439), (-76.257, 39.352), (-76.276, 39.323), (-76.331, 39.404), (-76.347, 39.388), (-76.345, 39.365), (-76.359, 39.325), (-76.406, 39.304), (-76.403, 39.253), (-76.421, 39.225), (-76.57, 39.269), (-76.574, 39.254), (-76.489, 39.159), (-76.428, 39.126), (-76.42, 39.074), (-76.473, 39.031), (-76.546, 39.068), (-76.559, 39.065), (-76.519, 39.001), (-76.494, 38.945), (-76.52, 38.898), (-76.516, 38.841), (-76.521, 38.788), (-76.537, 38.743), (-76.501, 38.532), (-76.459, 38.475), (-76.416, 38.42), (-76.394, 38.369), (-76.439, 38.362), (-76.51, 38.404), (-76.572, 38.436), (-76.647, 38.539), (-76.659, 38.58), (-76.677, 38.612), (-76.669, 38.538), (-76.642, 38.454), (-76.409, 38.268), (-76.366, 38.197), (-76.333, 38.141), (-76.341, 38.087), (-76.402, 38.125), (-76.454, 38.174), (-76.594, 38.228), (-76.769, 38.263), (-76.868, 38.39), (-76.868, 38.337), (-76.89, 38.292), (-76.95, 38.347), (-76.988, 38.394), (-77.001, 38.445), (-77.077, 38.442), (-77.156, 38.397), (-77.233, 38.408), (-77.242, 38.495), (-77.221, 38.541), (-77.135, 38.65), (-77.054, 38.706), (-77.018, 38.778), (-77.03, 38.889), (-77.02, 38.807), (-76.931, 38.888), (-76.989, 38.952), (-77.042, 39.012), (-77.122, 38.944), (-77.19, 38.969), (-77.301, 39.053), (-77.481, 39.113), (-77.506, 39.143), (-77.503, 39.175), (-77.479, 39.221), (-77.534, 39.266), (-77.669, 39.31), (-77.727, 39.346), (-77.739, 39.354), (-77.745, 39.4), (-77.762, 39.429), (-77.792, 39.442), (-77.797, 39.461), (-77.78, 39.488), (-77.798, 39.517), (-77.853, 39.548), (-77.872, 39.576), (-77.855, 39.6), (-77.883, 39.611), (-77.956, 39.609), (-78.027, 39.631), (-78.098, 39.678), (-78.181, 39.686), (-78.325, 39.639), (-78.407, 39.628), (-78.443, 39.601), (-78.46, 39.556), (-78.496, 39.533), (-78.575, 39.533), (-78.587, 39.534), (-78.678, 39.55), (-78.742, 39.578), (-78.753, 39.59), (-78.746, 39.614), (-78.758, 39.625), (-78.778, 39.627), (-78.796, 39.613), (-78.815, 39.57), (-78.971, 39.454), (-79.047, 39.477), (-79.075, 39.476), (-79.294, 39.312), (-79.36, 39.285), (-79.488, 39.211), (-79.485, 39.339), (-79.483, 39.467), (-79.48, 39.595), (-79.478, 39.723)]]], ['ME', [[(-68.623, 44.196), (-68.661, 44.176), (-68.702, 44.183), (-68.703, 44.232), (-68.691, 44.249), (-68.677, 44.256), (-68.656, 44.242)], [(-68.187, 44.332), (-68.245, 44.313), (-68.309, 44.322), (-68.308, 44.269), (-68.315, 44.25), (-68.386, 44.277), (-68.412, 44.294), (-68.409, 44.364), (-68.347, 44.43), (-68.299, 44.457), (-68.238, 44.438), (-68.191, 44.364)], [(-68.937, 47.211), (-68.887, 47.203), (-68.829, 47.203), (-68.669, 47.253), (-68.48, 47.286), (-68.377, 47.316), (-68.358, 47.345), (-68.311, 47.354), (-68.235, 47.346), (-68.097, 47.275), (-67.935, 47.168), (-67.807, 47.083), (-67.803, 46.936), (-67.8, 46.78), (-67.798, 46.616), (-67.796, 46.498), (-67.793, 46.337), (-67.79, 46.209), (-67.786, 46.042), (-67.785, 45.953), (-67.767, 45.927), (-67.778, 45.892), (-67.782, 45.874), (-67.781, 45.86), (-67.774, 45.843), (-67.775, 45.818), (-67.792, 45.796), (-67.8, 45.77), (-67.801, 45.756), (-67.863, 45.74), (-67.779, 45.67), (-67.625, 45.602), (-67.512, 45.589), (-67.449, 45.607), (-67.45, 45.608), (-67.433, 45.603), (-67.414, 45.566), (-67.424, 45.53), (-67.455, 45.514), (-67.488, 45.501), (-67.494, 45.474), (-67.477, 45.446), (-67.454, 45.421), (-67.428, 45.378), (-67.439, 45.34), (-67.462, 45.309), (-67.473, 45.276), (-67.453, 45.248), (-67.4, 45.21), (-67.367, 45.174), (-67.315, 45.154), (-67.291, 45.168), (-67.271, 45.187), (-67.25, 45.201), (-67.213, 45.193), (-67.171, 45.182), (-67.125, 45.169), (-67.13, 45.139), (-67.102, 45.088), (-67.08, 44.989), (-67.114, 44.944), (-67.107, 44.885), (-67.014, 44.868), (-66.991, 44.85), (-66.987, 44.828), (-67.191, 44.676), (-67.364, 44.697), (-67.458, 44.657), (-67.556, 44.645), (-67.599, 44.577), (-67.653, 44.562), (-67.727, 44.566), (-67.79, 44.586), (-67.839, 44.576), (-67.907, 44.454), (-67.963, 44.464), (-67.985, 44.42), (-68.014, 44.401), (-68.057, 44.384), (-68.094, 44.439), (-68.117, 44.491), (-68.152, 44.502), (-68.198, 44.515), (-68.246, 44.515), (-68.277, 44.507), (-68.317, 44.474), (-68.374, 44.445), (-68.417, 44.469), (-68.451, 44.508), (-68.479, 44.446), (-68.521, 44.38), (-68.514, 44.304), (-68.533, 44.259), (-68.572, 44.271), (-68.612, 44.311), (-68.723, 44.342), (-68.812, 44.339), (-68.794, 44.382), (-68.71, 44.443), (-68.736, 44.454), (-68.777, 44.446), (-68.795, 44.454), (-68.766, 44.51), (-68.763, 44.571), (-68.8, 44.549), (-68.847, 44.485), (-68.961, 44.434), (-68.956, 44.348), (-69.064, 44.172), (-69.068, 44.098), (-69.137, 44.038), (-69.226, 43.986), (-69.345, 44.001), (-69.435, 43.956), (-69.481, 43.905), (-69.521, 43.897), (-69.542, 43.963), (-69.557, 43.983), (-69.59, 43.887), (-69.624, 43.881), (-69.637, 43.949), (-69.653, 43.994), (-69.699, 43.955), (-69.73, 43.852), (-69.762, 43.861), (-69.772, 43.899), (-69.795, 43.911), (-69.803, 43.867), (-69.792, 43.805), (-69.808, 43.772), (-69.84, 43.79), (-69.873, 43.82), (-69.926, 43.797), (-69.974, 43.788), (-69.975, 43.818), (-69.965, 43.855), (-70.062, 43.835), (-70.179, 43.766), (-70.269, 43.672), (-70.238, 43.656), (-70.203, 43.626), (-70.36, 43.48), (-70.521, 43.349), (-70.642, 43.134), (-70.691, 43.109), (-70.733, 43.07), (-70.813, 43.164), (-70.829, 43.239), (-70.92, 43.328), (-70.956, 43.389), (-70.968, 43.458), (-70.962, 43.532), (-71.085, 45.294), (-71.06, 45.309), (-71.0, 45.337), (-70.96, 45.333), (-70.926, 45.291), (-70.898, 45.262), (-70.865, 45.271), (-70.837, 45.311), (-70.838, 45.366), (-70.799, 45.405), (-70.753, 45.411), (-70.711, 45.409), (-70.69, 45.428), (-70.692, 45.455), (-70.707, 45.499), (-70.702, 45.551), (-70.596, 45.644), (-70.467, 45.707), (-70.421, 45.738), (-70.408, 45.802), (-70.333, 45.868), (-70.296, 45.906), (-70.287, 45.939), (-70.306, 45.98), (-70.305, 46.057), (-70.279, 46.15), (-70.248, 46.251), (-70.18, 46.342), (-70.067, 46.441), (-70.038, 46.571), (-70.008, 46.709), (-69.872, 46.843), (-69.718, 46.995), (-69.63, 47.081), (-69.471, 47.239), (-69.359, 47.351), (-69.302, 47.402), (-69.243, 47.463), (-69.146, 47.445), (-69.05, 47.427), (-69.064, 47.338), (-69.054, 47.295), (-69.049, 47.274), (-69.003, 47.236)]]], ['MI', [[(-85.976, 45.102), (-85.988, 45.088), (-86.016, 45.089), (-86.038, 45.103), (-86.06, 45.147), (-86.052, 45.156), (-85.998, 45.15), (-85.98, 45.132)], [(-85.552, 45.603), (-85.586, 45.598), (-85.612, 45.609), (-85.608, 45.656), (-85.573, 45.738), (-85.539, 45.775), (-85.492, 45.76), (-85.501, 45.75), (-85.492, 45.663), (-85.509, 45.624)], [(-84.691, 45.774), (-84.563, 45.712), (-84.441, 45.676), (-84.326, 45.666), (-84.242, 45.644), (-84.189, 45.611), (-84.151, 45.574), (-84.128, 45.532), (-84.073, 45.509), (-83.986, 45.504), (-83.918, 45.486), (-83.869, 45.456), (-83.594, 45.379), (-83.479, 45.339), (-83.415, 45.299), (-83.397, 45.274), (-83.403, 45.248), (-83.396, 45.221), (-83.349, 45.169), (-83.331, 45.164), (-83.32, 45.139), (-83.316, 45.093), (-83.302, 45.062), (-83.279, 45.047), (-83.293, 45.04), (-83.378, 45.067), (-83.426, 45.059), (-83.448, 45.025), (-83.452, 44.992), (-83.436, 44.961), (-83.328, 44.869), (-83.3, 44.785), (-83.294, 44.683), (-83.308, 44.644), (-83.319, 44.556), (-83.328, 44.421), (-83.331, 44.375), (-83.366, 44.33), (-83.463, 44.265), (-83.464, 44.277), (-83.487, 44.281), (-83.513, 44.271), (-83.548, 44.215), (-83.577, 44.113), (-83.614, 44.058), (-83.657, 44.05), (-83.683, 44.035), (-83.692, 44.014), (-83.738, 44.001), (-83.821, 43.993), (-83.879, 43.963), (-83.922, 43.875), (-83.92, 43.834), (-83.94, 43.782), (-83.938, 43.738), (-83.916, 43.701), (-83.848, 43.664), (-83.735, 43.627), (-83.668, 43.621), (-83.622, 43.636), (-83.573, 43.697), (-83.526, 43.721), (-83.469, 43.731), (-83.447, 43.758), (-83.353, 43.879), (-83.353, 43.906), (-83.388, 43.917), (-83.383, 43.924), (-83.338, 43.929), (-83.299, 43.945), (-83.267, 43.973), (-83.209, 43.994), (-83.069, 44.025), (-82.995, 44.061), (-82.947, 44.067), (-82.878, 44.048), (-82.788, 44.004), (-82.716, 43.939), (-82.663, 43.854), (-82.597, 43.634), (-82.516, 43.28), (-82.461, 43.081), (-82.432, 43.039), (-82.417, 43.017), (-82.417, 43.017), (-82.417, 43.017), (-82.488, 42.74), (-82.545, 42.625), (-82.645, 42.558), (-82.639, 42.574), (-82.63, 42.595), (-82.633, 42.661), (-82.65, 42.687), (-82.687, 42.697), (-82.733, 42.69), (-82.787, 42.665), (-82.804, 42.639), (-82.784, 42.613), (-82.796, 42.589), (-82.841, 42.568), (-82.87, 42.519), (-82.883, 42.442), (-82.902, 42.394), (-82.926, 42.375), (-83.017, 42.347), (-83.063, 42.323), (-83.105, 42.286), (-83.142, 42.228), (-83.175, 42.146), (-83.188, 42.083), (-83.177, 42.049), (-83.205, 42.027), (-83.256, 41.986), (-83.265, 41.971), (-83.262, 41.946), (-83.273, 41.935), (-83.297, 41.935), (-83.316, 41.923), (-83.362, 41.88), (-83.441, 41.766), (-83.454, 41.746), (-83.464, 41.739), (-84.796, 41.701), (-84.796, 41.76), (-86.863, 41.761), (-86.798, 41.789), (-86.692, 41.853), (-86.632, 41.911), (-86.575, 41.988), (-86.52, 42.082), (-86.407, 42.224), (-86.352, 42.309), (-86.3, 42.418), (-86.26, 42.531), (-86.233, 42.65), (-86.22, 42.773), (-86.222, 42.9), (-86.248, 43.029), (-86.301, 43.158), (-86.329, 43.224), (-86.34, 43.242), (-86.435, 43.407), (-86.542, 43.637), (-86.541, 43.657), (-86.441, 43.794), (-86.438, 43.813), (-86.449, 43.924), (-86.47, 43.98), (-86.521, 44.055), (-86.519, 44.074), (-86.415, 44.169), (-86.353, 44.242), (-86.296, 44.331), (-86.259, 44.434), (-86.242, 44.551), (-86.243, 44.63), (-86.261, 44.669), (-86.259, 44.699), (-86.237, 44.72), (-86.126, 44.748), (-86.088, 44.794), (-86.08, 44.876), (-86.058, 44.916), (-86.02, 44.916), (-85.985, 44.933), (-85.953, 44.967), (-85.91, 44.976), (-85.858, 44.962), (-85.784, 45.012), (-85.689, 45.128), (-85.617, 45.193), (-85.566, 45.207), (-85.556, 45.196), (-85.588, 45.161), (-85.597, 45.123), (-85.585, 45.082), (-85.596, 45.042), (-85.619, 44.987), (-85.605, 44.97), (-85.645, 44.882), (-85.647, 44.837), (-85.623, 44.804), (-85.593, 44.816), (-85.559, 44.873), (-85.549, 44.903), (-85.563, 44.907), (-85.558, 44.931), (-85.534, 44.976), (-85.513, 44.997), (-85.494, 44.994), (-85.489, 44.97), (-85.497, 44.924), (-85.551, 44.815), (-85.561, 44.781), (-85.549, 44.772), (-85.485, 44.84), (-85.43, 44.949), (-85.389, 45.033), (-85.382, 45.078), (-85.394, 45.196), (-85.391, 45.244), (-85.376, 45.277), (-85.319, 45.314), (-85.223, 45.356), (-85.127, 45.378), (-85.033, 45.381), (-84.967, 45.393), (-84.93, 45.413), (-84.943, 45.429), (-85.006, 45.44), (-85.055, 45.467), (-85.088, 45.507), (-85.099, 45.553), (-85.088, 45.605), (-85.047, 45.656), (-84.977, 45.707), (-84.955, 45.743), (-84.981, 45.767), (-84.952, 45.775), (-84.866, 45.769), (-84.806, 45.775), (-84.772, 45.795)], [(-84.557, 45.82), (-84.429, 45.807), (-84.417, 45.814), (-84.38, 45.788), (-84.375, 45.765), (-84.39, 45.747), (-84.412, 45.736), (-84.441, 45.734), (-84.487, 45.754), (-84.563, 45.804)], [(-83.503, 46.013), (-83.494, 45.991), (-83.518, 45.958), (-83.588, 45.941), (-83.731, 45.943), (-83.823, 45.956), (-83.866, 45.979), (-83.875, 45.991), (-83.871, 46.017), (-83.851, 46.019), (-83.82, 46.005), (-83.775, 46.011), (-83.715, 46.038), (-83.683, 46.057), (-83.68, 46.07), (-83.699, 46.096), (-83.684, 46.106), (-83.608, 46.097), (-83.58, 46.08), (-83.529, 46.024)], [(-84.121, 46.246), (-84.135, 46.24), (-84.185, 46.279), (-84.196, 46.303), (-84.188, 46.323), (-84.169, 46.324), (-84.137, 46.306), (-84.12, 46.285), (-84.116, 46.261)], [(-84.133, 46.362), (-84.133, 46.341), (-84.163, 46.346), (-84.189, 46.36), (-84.209, 46.384), (-84.235, 46.445), (-84.274, 46.487), (-84.216, 46.536), (-84.18, 46.542), (-84.142, 46.531), (-84.137, 46.503), (-84.165, 46.457), (-84.164, 46.41)], [(-88.463, 46.814), (-88.449, 46.802), (-88.427, 46.814), (-88.4, 46.841), (-88.39, 46.857), (-88.383, 46.874), (-88.216, 46.952), (-88.184, 46.955), (-88.129, 46.935), (-87.877, 46.908), (-87.778, 46.888), (-87.673, 46.844), (-87.638, 46.827), (-87.509, 46.683), (-87.451, 46.627), (-87.415, 46.612), (-87.394, 46.59), (-87.378, 46.54), (-87.358, 46.524), (-87.171, 46.514), (-87.086, 46.523), (-87.034, 46.543), (-86.977, 46.53), (-86.914, 46.483), (-86.851, 46.47), (-86.79, 46.491), (-86.733, 46.49), (-86.679, 46.468), (-86.654, 46.452), (-86.638, 46.453), (-86.531, 46.524), (-86.403, 46.588), (-86.231, 46.656), (-86.132, 46.687), (-86.105, 46.679), (-85.947, 46.702), (-85.804, 46.704), (-85.616, 46.691), (-85.442, 46.707), (-85.281, 46.752), (-85.138, 46.778), (-85.015, 46.783), (-84.968, 46.771), (-84.998, 46.74), (-85.015, 46.686), (-85.017, 46.611), (-85.027, 46.563), (-85.046, 46.543), (-85.049, 46.524), (-85.034, 46.506), (-84.914, 46.494), (-84.851, 46.469), (-84.779, 46.468), (-84.697, 46.491), (-84.635, 46.482), (-84.592, 46.443), (-84.528, 46.436), (-84.467, 46.464), (-84.424, 46.491), (-84.387, 46.502), (-84.358, 46.505), (-84.327, 46.491), (-84.307, 46.469), (-84.255, 46.408), (-84.229, 46.366), (-84.213, 46.304), (-84.202, 46.283), (-84.204, 46.247), (-84.238, 46.222), (-84.248, 46.203), (-84.227, 46.184), (-84.109, 46.178), (-84.055, 46.159), (-84.035, 46.137), (-84.048, 46.114), (-84.041, 46.088), (-84.012, 46.061), (-83.917, 46.021), (-83.894, 46.001), (-83.901, 45.981), (-83.929, 45.968), (-83.979, 45.962), (-84.341, 46.0), (-84.447, 46.006), (-84.463, 45.992), (-84.473, 45.99), (-84.49, 45.994), (-84.521, 45.995), (-84.537, 46.004), (-84.55, 46.029), (-84.581, 46.046), (-84.632, 46.053), (-84.675, 46.033), (-84.725, 45.958), (-84.717, 45.944), (-84.725, 45.895), (-84.713, 45.882), (-84.713, 45.871), (-84.727, 45.861), (-84.757, 45.863), (-84.802, 45.874), (-84.972, 45.989), (-85.101, 46.046), (-85.26, 46.088), (-85.386, 46.109), (-85.479, 46.108), (-85.555, 46.078), (-85.615, 46.02), (-85.708, 45.988), (-85.834, 45.98), (-85.903, 45.964), (-85.914, 45.941), (-85.959, 45.941), (-86.04, 45.963), (-86.123, 45.969), (-86.209, 45.959), (-86.272, 45.937), (-86.338, 45.866), (-86.351, 45.831), (-86.4, 45.801), (-86.527, 45.753), (-86.534, 45.736), (-86.601, 45.682), (-86.622, 45.652), (-86.622, 45.623), (-86.644, 45.625), (-86.69, 45.657), (-86.691, 45.701), (-86.65, 45.757), (-86.612, 45.784), (-86.58, 45.782), (-86.559, 45.806), (-86.552, 45.857), (-86.563, 45.883), (-86.627, 45.873), (-86.661, 45.852), (-86.703, 45.848), (-86.754, 45.859), (-86.799, 45.832), (-86.837, 45.765), (-86.884, 45.721), (-86.938, 45.7), (-86.974, 45.723), (-86.993, 45.79), (-86.993, 45.842), (-86.971, 45.905), (-86.982, 45.917), (-87.005, 45.897), (-87.039, 45.845), (-87.085, 45.73), (-87.114, 45.692), (-87.154, 45.677), (-87.216, 45.607), (-87.302, 45.484), (-87.399, 45.365), (-87.506, 45.249), (-87.571, 45.187), (-87.593, 45.178), (-87.602, 45.157), (-87.606, 45.109), (-87.654, 45.122), (-87.694, 45.161), (-87.719, 45.201), (-87.721, 45.243), (-87.663, 45.345), (-87.658, 45.362), (-87.664, 45.371), (-87.696, 45.383), (-87.769, 45.364), (-87.842, 45.361), (-87.865, 45.368), (-87.875, 45.385), (-87.874, 45.413), (-87.859, 45.445), (-87.815, 45.506), (-87.815, 45.563), (-87.795, 45.596), (-87.814, 45.657), (-87.809, 45.686), (-87.84, 45.718), (-87.923, 45.76), (-88.116, 45.816), (-88.096, 45.878), (-88.104, 45.905), (-88.152, 45.945), (-88.355, 45.992), (-88.493, 46.014), (-88.63, 46.014), (-88.727, 46.031), (-88.837, 46.037), (-88.908, 46.065), (-88.978, 46.093), (-89.049, 46.121), (-89.119, 46.149), (-89.244, 46.173), (-89.369, 46.197), (-89.494, 46.221), (-89.619, 46.245), (-89.744, 46.269), (-89.869, 46.294), (-89.994, 46.318), (-90.119, 46.342), (-90.147, 46.384), (-90.174, 46.426), (-90.202, 46.468), (-90.23, 46.51), (-90.288, 46.527), (-90.318, 46.537), (-90.341, 46.558), (-90.392, 46.549), (-90.413, 46.585), (-90.408, 46.593), (-90.341, 46.602), (-90.154, 46.654), (-89.993, 46.718), (-89.861, 46.793), (-89.695, 46.839), (-89.497, 46.855), (-89.355, 46.882), (-89.269, 46.918), (-89.155, 46.989), (-89.09, 47.009), (-89.009, 47.016), (-88.948, 47.043), (-88.907, 47.091), (-88.83, 47.146), (-88.716, 47.207), (-88.65, 47.232), (-88.634, 47.22), (-88.628, 47.199), (-88.633, 47.167), (-88.604, 47.141), (-88.543, 47.122), (-88.515, 47.096), (-88.521, 47.063), (-88.504, 47.035), (-88.466, 47.013), (-88.456, 46.963), (-88.474, 46.886), (-88.476, 46.837)], [(-88.222, 47.211), (-88.24, 47.178), (-88.237, 47.159), (-88.358, 47.073), (-88.402, 47.019), (-88.439, 47.011), (-88.469, 47.048), (-88.468, 47.077), (-88.438, 47.1), (-88.409, 47.131), (-88.405, 47.175), (-88.417, 47.191), (-88.454, 47.152), (-88.433, 47.143), (-88.427, 47.137), (-88.434, 47.122), (-88.574, 47.143), (-88.616, 47.174), (-88.609, 47.217), (-88.562, 47.272), (-88.394, 47.389), (-88.32, 47.421), (-88.11, 47.473), (-87.994, 47.484), (-87.878, 47.484), (-87.793, 47.467), (-87.741, 47.434), (-87.79, 47.411), (-88.021, 47.392), (-88.027, 47.386), (-87.983, 47.368), (-87.975, 47.355), (-88.016, 47.321)], [(-88.955, 47.926), (-88.96, 47.909), (-88.924, 47.905), (-88.93, 47.896), (-88.97, 47.881), (-89.082, 47.851), (-89.157, 47.841), (-89.195, 47.852), (-89.199, 47.872), (-89.169, 47.902), (-89.169, 47.917), (-89.2, 47.917), (-89.193, 47.929), (-89.147, 47.953), (-88.756, 48.104), (-88.588, 48.158), (-88.499, 48.176), (-88.485, 48.167), (-88.581, 48.111), (-88.597, 48.087), (-88.593, 48.072), (-88.625, 48.042), (-88.911, 47.936)]]], ['MN', [[(-89.578, 48.002), (-89.605, 47.992), (-89.634, 47.994), (-89.672, 47.979), (-89.72, 47.947), (-89.829, 47.901), (-90.0, 47.841), (-90.197, 47.786), (-90.597, 47.688), (-90.847, 47.585), (-90.957, 47.524), (-91.386, 47.215), (-91.645, 47.05), (-92.065, 46.819), (-92.104, 46.789), (-92.107, 46.762), (-92.125, 46.763), (-92.195, 46.707), (-92.224, 46.671), (-92.292, 46.661), (-92.292, 46.517), (-92.292, 46.373), (-92.292, 46.228), (-92.293, 46.084), (-92.325, 46.07), (-92.367, 46.036), (-92.425, 46.028), (-92.694, 45.909), (-92.738, 45.875), (-92.786, 45.796), (-92.875, 45.706), (-92.897, 45.659), (-92.892, 45.595), (-92.757, 45.543), (-92.707, 45.494), (-92.683, 45.433), (-92.686, 45.381), (-92.754, 45.278), (-92.766, 45.236), (-92.759, 45.111), (-92.793, 45.071), (-92.765, 44.969), (-92.763, 44.934), (-92.785, 44.823), (-92.799, 44.79), (-92.773, 44.732), (-92.77, 44.726), (-92.644, 44.645), (-92.537, 44.601), (-92.442, 44.587), (-92.367, 44.552), (-92.313, 44.498), (-92.24, 44.462), (-92.149, 44.445), (-92.055, 44.4), (-91.912, 44.289), (-91.841, 44.194), (-91.716, 44.126), (-91.515, 44.054), (-91.383, 43.991), (-91.32, 43.936), (-91.278, 43.797), (-91.245, 43.502), (-96.128, 43.501), (-96.454, 43.501), (-96.454, 45.297), (-96.53, 45.372), (-96.696, 45.432), (-96.738, 45.468), (-96.815, 45.557), (-96.845, 45.596), (-96.851, 45.626), (-96.814, 45.659), (-96.663, 45.756), (-96.615, 45.8), (-96.591, 45.843), (-96.556, 45.943), (-96.57, 46.019), (-96.561, 46.138), (-96.592, 46.228), (-96.599, 46.272), (-96.617, 46.327), (-96.731, 46.473), (-96.758, 46.59), (-96.787, 46.648), (-96.796, 46.797), (-96.793, 46.839), (-96.77, 46.92), (-96.818, 46.974), (-96.825, 47.019), (-96.848, 47.373), (-96.863, 47.424), (-96.859, 47.588), (-96.946, 47.762), (-96.988, 47.82), (-97.009, 47.892), (-97.007, 47.926), (-97.079, 48.043), (-97.126, 48.173), (-97.122, 48.286), (-97.137, 48.371), (-97.131, 48.437), (-97.144, 48.537), (-97.129, 48.593), (-97.128, 48.681), (-97.226, 48.993), (-97.103, 48.993), (-96.677, 48.993), (-96.251, 48.993), (-95.824, 48.993), (-95.398, 48.993), (-95.162, 48.992), (-95.158, 49.203), (-95.155, 49.37), (-94.939, 49.349), (-94.875, 49.319), (-94.854, 49.305), (-94.86, 49.259), (-94.843, 49.119), (-94.803, 49.003), (-94.713, 48.863), (-94.713, 48.863), (-94.705, 48.809), (-94.675, 48.774), (-94.621, 48.743), (-94.414, 48.704), (-94.055, 48.659), (-93.852, 48.607), (-93.804, 48.549), (-93.708, 48.525), (-93.564, 48.537), (-93.464, 48.561), (-93.378, 48.617), (-93.258, 48.629), (-93.155, 48.625), (-93.052, 48.62), (-92.996, 48.612), (-92.837, 48.568), (-92.733, 48.532), (-92.583, 48.465), (-92.501, 48.435), (-92.461, 48.366), (-92.415, 48.277), (-92.348, 48.277), (-92.299, 48.329), (-92.172, 48.338), (-92.005, 48.302), (-91.858, 48.198), (-91.647, 48.105), (-91.518, 48.058), (-91.387, 48.059), (-91.221, 48.105), (-91.043, 48.194), (-90.916, 48.209), (-90.84, 48.201), (-90.797, 48.131), (-90.744, 48.105), (-90.607, 48.113), (-90.32, 48.099), (-90.092, 48.118), (-90.04, 48.078), (-89.994, 48.015), (-89.901, 47.995), (-89.775, 48.015)]]], ['MO', [[(-91.442, 40.379), (-91.5, 40.226), (-91.502, 40.098), (-91.467, 39.943), (-91.426, 39.827), (-91.379, 39.749), (-91.21, 39.603), (-90.919, 39.387), (-90.737, 39.182), (-90.664, 38.987), (-90.577, 38.91), (-90.478, 38.948), (-90.354, 38.93), (-90.22, 38.898), (-90.15, 38.86), (-90.134, 38.847), (-90.127, 38.833), (-90.132, 38.819), (-90.151, 38.781), (-90.317, 38.458), (-90.374, 38.31), (-90.366, 38.254), (-90.299, 38.174), (-90.174, 38.069), (-90.064, 38.001), (-89.97, 37.969), (-89.823, 37.884), (-89.623, 37.747), (-89.523, 37.645), (-89.523, 37.576), (-89.503, 37.506), (-89.462, 37.434), (-89.462, 37.366), (-89.503, 37.301), (-89.487, 37.213), (-89.414, 37.102), (-89.352, 37.036), (-89.301, 37.012), (-89.29, 37.013), (-89.286, 37.023), (-89.293, 37.038), (-89.296, 37.052), (-89.292, 37.071), (-89.281, 37.078), (-89.272, 37.08), (-89.225, 37.053), (-89.154, 36.992), (-89.122, 36.912), (-89.13, 36.811), (-89.156, 36.716), (-89.203, 36.626), (-89.256, 36.594), (-89.28, 36.6), (-89.331, 36.616), (-89.351, 36.611), (-89.397, 36.588), (-89.45, 36.5), (-89.452, 36.498), (-89.471, 36.489), (-89.485, 36.498), (-89.487, 36.503), (-89.497, 36.529), (-89.52, 36.555), (-89.536, 36.555), (-89.55, 36.553), (-89.555, 36.541), (-89.56, 36.513), (-89.557, 36.501), (-89.541, 36.427), (-89.555, 36.373), (-89.604, 36.352), (-89.612, 36.322), (-89.584, 36.288), (-89.584, 36.272), (-89.595, 36.259), (-89.628, 36.255), (-89.654, 36.248), (-89.675, 36.221), (-89.634, 36.168), (-89.642, 36.105), (-89.698, 36.03), (-89.705, 36.002), (-90.381, 35.993), (-90.303, 36.099), (-90.253, 36.138), (-90.216, 36.178), (-90.149, 36.216), (-90.076, 36.297), (-90.067, 36.334), (-90.074, 36.372), (-90.118, 36.423), (-90.162, 36.501), (-94.618, 36.501), (-94.618, 37.001), (-94.625, 39.086), (-94.622, 39.124), (-94.778, 39.194), (-94.847, 39.259), (-94.882, 39.343), (-94.953, 39.426), (-95.058, 39.509), (-95.075, 39.597), (-95.005, 39.692), (-94.946, 39.739), (-94.899, 39.741), (-94.893, 39.782), (-94.93, 39.861), (-94.984, 39.891), (-95.056, 39.871), (-95.116, 39.872), (-95.347, 40.001), (-95.362, 40.01), (-95.434, 40.096), (-95.464, 40.198), (-95.521, 40.265), (-95.607, 40.295), (-95.662, 40.363), (-95.685, 40.466), (-95.74, 40.571), (-95.765, 40.602), (-91.732, 40.625), (-91.682, 40.552), (-91.627, 40.531), (-91.617, 40.507), (-91.545, 40.469), (-91.53, 40.432)]]], ['MS', [[(-88.558, 30.216), (-88.571, 30.205), (-88.659, 30.226), (-88.713, 30.245), (-88.723, 30.264), (-88.574, 30.229)], [(-88.486, 31.891), (-88.4, 30.371), (-88.692, 30.355), (-88.82, 30.406), (-88.873, 30.416), (-88.905, 30.415), (-89.054, 30.368), (-89.224, 30.332), (-89.264, 30.344), (-89.321, 30.345), (-89.443, 30.223), (-89.521, 30.193), (-89.545, 30.201), (-89.572, 30.209), (-89.592, 30.223), (-89.629, 30.296), (-89.641, 30.349), (-89.686, 30.463), (-89.737, 30.527), (-89.794, 30.569), (-89.82, 30.611), (-89.82, 30.64), (-89.838, 30.69), (-89.835, 30.731), (-89.765, 30.886), (-89.735, 31.001), (-91.656, 31.002), (-91.653, 31.03), (-91.611, 31.065), (-91.596, 31.11), (-91.631, 31.218), (-91.618, 31.277), (-91.559, 31.288), (-91.529, 31.345), (-91.529, 31.449), (-91.506, 31.519), (-91.459, 31.555), (-91.415, 31.64), (-91.373, 31.774), (-91.286, 31.884), (-91.157, 31.971), (-91.093, 32.046), (-91.089, 32.104), (-91.075, 32.131), (-91.048, 32.146), (-91.005, 32.186), (-90.948, 32.24), (-90.938, 32.277), (-90.94, 32.303), (-90.945, 32.331), (-90.99, 32.381), (-91.059, 32.424), (-91.104, 32.49), (-91.101, 32.541), (-91.116, 32.586), (-91.15, 32.625), (-91.142, 32.661), (-91.094, 32.694), (-91.092, 32.726), (-91.136, 32.756), (-91.136, 32.809), (-91.093, 32.885), (-91.096, 32.938), (-91.144, 32.967), (-91.15, 33.016), (-91.153, 33.041), (-91.107, 33.218), (-91.117, 33.241), (-91.163, 33.294), (-91.168, 33.359), (-91.141, 33.439), (-91.154, 33.5), (-91.193, 33.523), (-91.203, 33.547), (-91.215, 33.583), (-91.173, 33.617), (-91.17, 33.647), (-91.207, 33.676), (-91.184, 33.716), (-91.1, 33.767), (-91.077, 33.797), (-91.053, 33.828), (-91.038, 33.901), (-91.05, 33.945), (-91.07, 33.974), (-91.06, 33.989), (-91.043, 34.003), (-90.943, 34.03), (-90.915, 34.049), (-90.909, 34.072), (-90.94, 34.129), (-90.91, 34.189), (-90.817, 34.252), (-90.768, 34.308), (-90.762, 34.356), (-90.718, 34.392), (-90.635, 34.414), (-90.584, 34.504), (-90.564, 34.661), (-90.539, 34.728), (-90.497, 34.738), (-90.475, 34.76), (-90.468, 34.805), (-90.416, 34.852), (-90.32, 34.899), (-90.282, 34.945), (-90.293, 34.97), (-90.294, 35.001), (-88.173, 34.999), (-88.085, 34.933), (-88.088, 34.909), (-88.089, 34.893), (-88.096, 34.846)]]], ['MT', [[(-104.034, 48.993), (-104.005, 45.013), (-104.005, 45.01), (-104.005, 45.007), (-104.005, 45.004), (-104.005, 45.001), (-104.037, 45.001), (-111.051, 45.001), (-111.051, 44.499), (-111.117, 44.525), (-111.161, 44.556), (-111.198, 44.591), (-111.265, 44.688), (-111.304, 44.723), (-111.337, 44.745), (-111.373, 44.746), (-111.416, 44.734), (-111.448, 44.711), (-111.459, 44.671), (-111.491, 44.624), (-111.489, 44.585), (-111.475, 44.565), (-111.479, 44.554), (-111.5, 44.545), (-111.659, 44.56), (-111.797, 44.54), (-111.892, 44.555), (-112.074, 44.548), (-112.231, 44.561), (-112.285, 44.554), (-112.32, 44.533), (-112.364, 44.48), (-112.375, 44.47), (-112.393, 44.468), (-112.648, 44.497), (-112.716, 44.498), (-112.787, 44.463), (-112.81, 44.438), (-112.816, 44.406), (-112.831, 44.397), (-112.854, 44.398), (-112.91, 44.419), (-112.97, 44.454), (-113.0, 44.48), (-113.006, 44.539), (-113.054, 44.605), (-113.063, 44.665), (-113.093, 44.715), (-113.141, 44.765), (-113.187, 44.799), (-113.234, 44.81), (-113.32, 44.803), (-113.339, 44.808), (-113.432, 44.874), (-113.461, 44.904), (-113.469, 44.93), (-113.438, 44.994), (-113.447, 45.029), (-113.471, 45.073), (-113.504, 45.109), (-113.557, 45.14), (-113.607, 45.209), (-113.697, 45.305), (-113.722, 45.379), (-113.756, 45.441), (-113.766, 45.503), (-113.8, 45.54), (-113.797, 45.588), (-113.802, 45.601), (-113.813, 45.607), (-113.873, 45.634), (-113.943, 45.682), (-113.978, 45.692), (-113.992, 45.693), (-114.001, 45.681), (-114.006, 45.658), (-114.117, 45.579), (-114.21, 45.542), (-114.256, 45.506), (-114.298, 45.488), (-114.319, 45.486), (-114.351, 45.497), (-114.448, 45.551), (-114.529, 45.576), (-114.537, 45.587), (-114.533, 45.633), (-114.496, 45.686), (-114.534, 45.782), (-114.523, 45.815), (-114.493, 45.839), (-114.405, 45.874), (-114.397, 45.891), (-114.416, 45.982), (-114.465, 46.016), (-114.478, 46.036), (-114.464, 46.11), (-114.485, 46.158), (-114.447, 46.199), (-114.444, 46.271), (-114.413, 46.344), (-114.38, 46.453), (-114.387, 46.5), (-114.346, 46.551), (-114.332, 46.601), (-114.33, 46.638), (-114.337, 46.659), (-114.351, 46.668), (-114.381, 46.668), (-114.519, 46.648), (-114.563, 46.65), (-114.602, 46.66), (-114.624, 46.678), (-114.631, 46.719), (-114.662, 46.746), (-114.678, 46.75), (-114.74, 46.734), (-114.754, 46.735), (-114.761, 46.742), (-114.786, 46.777), (-114.887, 46.845), (-114.936, 46.923), (-115.034, 46.991), (-115.127, 47.085), (-115.307, 47.231), (-115.349, 47.261), (-115.486, 47.312), (-115.593, 47.385), (-115.702, 47.438), (-115.713, 47.447), (-115.714, 47.452), (-115.708, 47.457), (-115.677, 47.471), (-115.67, 47.498), (-115.711, 47.553), (-115.691, 47.607), (-115.718, 47.681), (-115.734, 47.706), (-115.811, 47.776), (-115.862, 47.842), (-115.941, 47.904), (-116.049, 48.005), (-116.048, 48.993)]]], ['NC', [[(-76.546, 34.655), (-76.568, 34.653), (-76.608, 34.664), (-76.662, 34.685), (-76.674, 34.7), (-76.622, 34.695)], [(-76.504, 34.643), (-76.529, 34.632), (-76.437, 34.756), (-76.256, 34.915), (-76.207, 34.939), (-76.358, 34.804)], [(-75.782, 35.19), (-75.964, 35.119), (-75.984, 35.123), (-75.865, 35.174)], [(-75.544, 35.24), (-75.678, 35.213), (-75.69, 35.222), (-75.536, 35.279), (-75.488, 35.48), (-75.481, 35.572), (-75.504, 35.735), (-75.504, 35.769), (-75.478, 35.716), (-75.456, 35.564), (-75.465, 35.449), (-75.509, 35.28)], [(-75.636, 35.856), (-75.651, 35.836), (-75.717, 35.946), (-75.649, 35.91), (-75.637, 35.881)], [(-75.559, 35.879), (-75.534, 35.819), (-75.58, 35.872), (-75.728, 36.104), (-75.81, 36.271), (-75.889, 36.551), (-75.857, 36.551), (-75.758, 36.229)], [(-75.925, 36.383), (-75.867, 36.268), (-75.82, 36.113), (-75.883, 36.176), (-75.95, 36.209), (-76.055, 36.235), (-76.148, 36.279), (-76.141, 36.215), (-76.15, 36.146), (-76.222, 36.167), (-76.271, 36.19), (-76.227, 36.116), (-76.321, 36.138), (-76.384, 36.134), (-76.424, 36.068), (-76.479, 36.028), (-76.559, 36.015), (-76.679, 36.075), (-76.718, 36.148), (-76.734, 36.229), (-76.74, 36.133), (-76.719, 36.034), (-76.726, 35.958), (-76.611, 35.944), (-76.504, 35.956), (-76.358, 35.953), (-76.264, 35.967), (-76.207, 35.991), (-76.07, 35.97), (-76.06, 35.879), (-76.076, 35.788), (-76.084, 35.691), (-76.046, 35.691), (-76.001, 35.722), (-75.979, 35.896), (-75.854, 35.96), (-75.812, 35.956), (-75.772, 35.9), (-75.759, 35.843), (-75.745, 35.765), (-75.774, 35.647), (-75.966, 35.508), (-76.104, 35.38), (-76.174, 35.354), (-76.275, 35.369), (-76.39, 35.401), (-76.447, 35.408), (-76.489, 35.397), (-76.516, 35.436), (-76.532, 35.508), (-76.577, 35.532), (-76.611, 35.53), (-76.634, 35.453), (-76.741, 35.431), (-76.887, 35.463), (-77.04, 35.527), (-76.974, 35.458), (-76.595, 35.33), (-76.553, 35.306), (-76.513, 35.27), (-76.566, 35.215), (-76.608, 35.153), (-76.613, 35.104), (-76.628, 35.073), (-76.779, 34.99), (-76.861, 35.005), (-77.07, 35.155), (-76.975, 35.025), (-76.899, 34.97), (-76.745, 34.941), (-76.457, 34.989), (-76.362, 34.937), (-76.44, 34.843), (-76.517, 34.777), (-76.618, 34.77), (-76.707, 34.752), (-76.733, 34.707), (-76.797, 34.704), (-76.896, 34.701), (-77.049, 34.697), (-77.134, 34.708), (-77.252, 34.616), (-77.296, 34.603), (-77.358, 34.62), (-77.384, 34.694), (-77.412, 34.731), (-77.413, 34.592), (-77.402, 34.555), (-77.38, 34.527), (-77.518, 34.451), (-77.65, 34.358), (-77.697, 34.332), (-77.751, 34.285), (-77.861, 34.149), (-77.888, 34.05), (-77.928, 33.94), (-77.933, 33.989), (-77.926, 34.073), (-77.953, 34.169), (-77.971, 33.993), (-78.013, 33.912), (-78.406, 33.918), (-78.564, 33.877), (-79.654, 34.797), (-80.784, 34.829), (-80.789, 34.907), (-80.793, 34.963), (-80.882, 35.058), (-80.934, 35.114), (-81.045, 35.066), (-81.051, 35.089), (-81.047, 35.131), (-81.057, 35.146), (-81.087, 35.156), (-82.356, 35.202), (-82.393, 35.211), (-82.464, 35.178), (-82.651, 35.128), (-82.744, 35.084), (-82.778, 35.087), (-82.937, 35.044), (-83.097, 35.002), (-83.115, 35.001), (-83.417, 34.998), (-83.72, 34.995), (-84.022, 34.991), (-84.325, 34.988), (-84.287, 35.201), (-84.261, 35.25), (-84.232, 35.261), (-84.129, 35.261), (-84.062, 35.286), (-84.004, 35.414), (-83.871, 35.515), (-83.812, 35.54), (-83.723, 35.56), (-83.511, 35.584), (-83.284, 35.682), (-83.12, 35.775), (-82.99, 35.8), (-82.949, 35.835), (-82.92, 35.879), (-82.902, 35.939), (-82.888, 35.952), (-82.813, 35.947), (-82.756, 36.0), (-82.7, 36.03), (-82.645, 36.047), (-82.611, 36.047), (-82.598, 36.032), (-82.589, 35.987), (-82.577, 35.972), (-82.553, 35.971), (-82.521, 35.981), (-82.478, 36.01), (-82.368, 36.1), (-82.295, 36.134), (-82.182, 36.154), (-82.101, 36.107), (-82.051, 36.123), (-81.908, 36.306), (-81.851, 36.34), (-81.808, 36.353), (-81.734, 36.355), (-81.733, 36.406), (-81.708, 36.482), (-81.704, 36.534), (-81.659, 36.611), (-81.642, 36.595), (-75.966, 36.551), (-75.993, 36.474), (-75.978, 36.429)]]], ['ND', [[(-96.556, 45.943), (-104.011, 45.943), (-104.034, 48.993), (-97.226, 48.993), (-97.128, 48.681), (-97.129, 48.593), (-97.144, 48.537), (-97.131, 48.437), (-97.137, 48.371), (-97.122, 48.286), (-97.126, 48.173), (-97.079, 48.043), (-97.007, 47.926), (-97.009, 47.892), (-96.988, 47.82), (-96.946, 47.762), (-96.859, 47.588), (-96.863, 47.424), (-96.848, 47.373), (-96.825, 47.019), (-96.818, 46.974), (-96.77, 46.92), (-96.793, 46.839), (-96.796, 46.797), (-96.787, 46.648), (-96.758, 46.59), (-96.731, 46.473), (-96.617, 46.327), (-96.599, 46.272), (-96.592, 46.228), (-96.561, 46.138), (-96.57, 46.019)]]], ['NE', [[(-96.481, 42.511), (-96.451, 42.506), (-96.384, 42.418), (-96.356, 42.26), (-96.295, 42.133), (-96.201, 42.036), (-96.154, 41.965), (-96.154, 41.92), (-96.131, 41.872), (-96.087, 41.821), (-96.069, 41.734), (-96.078, 41.611), (-96.059, 41.546), (-96.011, 41.538), (-95.991, 41.52), (-95.997, 41.494), (-95.982, 41.474), (-95.944, 41.461), (-95.933, 41.425), (-95.95, 41.367), (-95.936, 41.331), (-95.892, 41.316), (-95.884, 41.288), (-95.911, 41.245), (-95.907, 41.212), (-95.871, 41.188), (-95.847, 41.08), (-95.834, 40.889), (-95.838, 40.778), (-95.859, 40.745), (-95.826, 40.676), (-95.765, 40.602), (-95.74, 40.571), (-95.685, 40.466), (-95.662, 40.363), (-95.607, 40.295), (-95.521, 40.265), (-95.464, 40.198), (-95.434, 40.096), (-95.362, 40.01), (-95.347, 40.001), (-102.024, 40.001), (-102.025, 41.001), (-104.022, 41.001), (-104.029, 43.001), (-98.442, 43.001), (-98.143, 42.852), (-97.965, 42.806), (-97.881, 42.85), (-97.698, 42.875), (-97.417, 42.881), (-97.239, 42.861), (-97.164, 42.813), (-97.02, 42.76), (-96.805, 42.701), (-96.676, 42.638), (-96.633, 42.569), (-96.558, 42.525)]]], ['NH', [[(-70.733, 43.07), (-70.778, 42.941), (-70.806, 42.877), (-70.923, 42.882), (-70.974, 42.872), (-71.076, 42.825), (-71.139, 42.808), (-71.242, 42.73), (-71.33, 42.702), (-72.467, 42.73), (-72.484, 42.766), (-72.54, 42.83), (-72.553, 42.856), (-72.55, 42.887), (-72.519, 42.967), (-72.496, 42.992), (-72.474, 43.039), (-72.438, 43.225), (-72.407, 43.332), (-72.385, 43.529), (-72.362, 43.587), (-72.338, 43.622), (-72.297, 43.715), (-72.222, 43.791), (-72.174, 43.884), (-72.115, 43.965), (-72.106, 44.013), (-72.062, 44.116), (-72.031, 44.301), (-72.002, 44.329), (-71.868, 44.355), (-71.826, 44.374), (-71.683, 44.45), (-71.638, 44.482), (-71.609, 44.514), (-71.588, 44.565), (-71.571, 44.579), (-71.568, 44.608), (-71.618, 44.728), (-71.621, 44.772), (-71.51, 44.908), (-71.533, 44.988), (-71.518, 45.008), (-71.419, 45.2), (-71.327, 45.29), (-71.202, 45.26), (-71.135, 45.263), (-71.085, 45.294), (-70.962, 43.532), (-70.968, 43.458), (-70.956, 43.389), (-70.92, 43.328), (-70.829, 43.239), (-70.813, 43.164)]]], ['NJ', [[(-74.133, 39.681), (-74.251, 39.529), (-74.253, 39.558), (-74.107, 39.746)], [(-74.242, 40.456), (-74.05, 40.43), (-73.998, 40.452), (-73.972, 40.4), (-73.958, 40.328), (-73.972, 40.251), (-74.004, 40.171), (-74.028, 40.073), (-74.049, 39.923), (-74.08, 39.788), (-74.084, 39.829), (-74.065, 39.993), (-74.096, 39.976), (-74.118, 39.938), (-74.176, 39.727), (-74.257, 39.614), (-74.331, 39.536), (-74.407, 39.549), (-74.39, 39.487), (-74.411, 39.455), (-74.429, 39.387), (-74.474, 39.343), (-74.517, 39.347), (-74.579, 39.316), (-74.603, 39.293), (-74.605, 39.248), (-74.646, 39.208), (-74.794, 39.002), (-74.923, 38.941), (-74.954, 38.95), (-74.92, 39.047), (-74.897, 39.145), (-74.975, 39.188), (-75.05, 39.211), (-75.136, 39.208), (-75.231, 39.284), (-75.353, 39.34), (-75.524, 39.49), (-75.519, 39.532), (-75.524, 39.602), (-75.472, 39.712), (-75.422, 39.79), (-75.353, 39.83), (-75.154, 39.87), (-75.104, 39.932), (-75.074, 39.983), (-75.024, 40.017), (-74.909, 40.08), (-74.735, 40.155), (-74.976, 40.406), (-75.034, 40.42), (-75.097, 40.543), (-75.171, 40.577), (-75.189, 40.596), (-75.192, 40.69), (-75.186, 40.744), (-75.175, 40.776), (-75.112, 40.802), (-75.076, 40.856), (-75.075, 40.884), (-75.123, 40.972), (-75.123, 40.999), (-75.032, 41.052), (-74.912, 41.155), (-74.841, 41.269), (-74.812, 41.302), (-74.778, 41.325), (-74.699, 41.357), (-73.91, 40.992), (-73.927, 40.914), (-74.026, 40.756), (-74.067, 40.72), (-74.116, 40.687), (-74.153, 40.673), (-74.187, 40.648), (-74.227, 40.608), (-74.264, 40.529)]]], ['NM', [[(-103.0, 36.501), (-103.042, 36.501), (-103.066, 32.003), (-106.662, 32.001), (-106.668, 32.001), (-106.566, 31.82), (-106.566, 31.82), (-106.445, 31.768), (-106.453, 31.77), (-108.212, 31.779), (-108.214, 31.329), (-109.048, 31.328), (-109.047, 37.001), (-103.001, 37.001)]]], ['NV', [[(-114.04, 37.004), (-114.043, 36.182), (-114.062, 36.175), (-114.119, 36.077), (-114.183, 36.03), (-114.232, 36.032), (-114.282, 36.06), (-114.332, 36.116), (-114.406, 36.148), (-114.505, 36.156), (-114.593, 36.148), (-114.669, 36.122), (-114.716, 36.085), (-114.741, 36.014), (-114.732, 35.984), (-114.687, 35.917), (-114.684, 35.814), (-114.677, 35.73), (-114.65, 35.684), (-114.645, 35.631), (-114.662, 35.545), (-114.649, 35.476), (-114.591, 35.353), (-114.611, 34.998), (-114.611, 34.991), (-116.406, 36.392), (-117.21, 37.003), (-118.126, 37.692), (-120.0, 39.0), (-120.001, 42.001), (-117.017, 42.001), (-114.043, 42.001)]]], ['NY', [[(-74.188, 40.523), (-74.236, 40.519), (-74.188, 40.615), (-74.1, 40.658), (-74.069, 40.649), (-74.067, 40.615), (-74.08, 40.586), (-74.139, 40.542)], [(-72.51, 40.986), (-72.581, 40.921), (-72.517, 40.915), (-72.461, 40.934), (-72.409, 40.972), (-72.287, 41.024), (-72.184, 41.047), (-72.151, 41.051), (-72.102, 41.015), (-72.004, 41.044), (-71.903, 41.061), (-72.339, 40.894), (-72.428, 40.875), (-72.556, 40.826), (-72.676, 40.791), (-72.763, 40.778), (-73.194, 40.654), (-73.229, 40.652), (-73.266, 40.664), (-73.621, 40.6), (-73.767, 40.593), (-73.9, 40.571), (-73.801, 40.622), (-73.799, 40.641), (-73.823, 40.656), (-73.875, 40.652), (-73.929, 40.599), (-74.015, 40.581), (-74.032, 40.639), (-74.003, 40.683), (-73.965, 40.725), (-73.879, 40.792), (-73.757, 40.834), (-73.695, 40.87), (-73.652, 40.838), (-73.643, 40.881), (-73.61, 40.906), (-73.574, 40.92), (-73.487, 40.92), (-73.441, 40.927), (-73.407, 40.941), (-73.373, 40.944), (-73.278, 40.924), (-73.186, 40.93), (-73.111, 40.957), (-73.034, 40.966), (-72.829, 40.972), (-72.625, 40.992), (-72.544, 41.027), (-72.373, 41.126), (-72.274, 41.153), (-72.427, 41.039)], [(-78.93, 43.022), (-78.961, 42.988), (-78.99, 42.992), (-79.012, 43.003), (-79.019, 43.024), (-79.014, 43.052), (-78.988, 43.064), (-78.916, 43.053), (-78.914, 43.042)], [(-76.262, 43.99), (-76.277, 43.987), (-76.275, 44.009), (-76.26, 44.022), (-76.231, 44.029), (-76.231, 44.018)], [(-76.111, 44.277), (-76.143, 44.269), (-76.15, 44.281), (-76.145, 44.292), (-76.119, 44.306), (-76.075, 44.306), (-76.081, 44.295)], [(-73.352, 45.005), (-73.345, 44.939), (-73.366, 44.86), (-73.349, 44.775), (-73.372, 44.597), (-73.31, 44.46), (-73.325, 44.368), (-73.321, 44.269), (-73.332, 44.245), (-73.381, 44.187), (-73.41, 44.131), (-73.426, 44.075), (-73.425, 44.038), (-73.383, 43.876), (-73.375, 43.804), (-73.376, 43.762), (-73.413, 43.628), (-73.416, 43.59), (-73.405, 43.579), (-73.391, 43.579), (-73.349, 43.62), (-73.33, 43.627), (-73.306, 43.616), (-73.247, 43.553), (-73.267, 42.865), (-73.28, 42.813), (-73.253, 42.752), (-73.507, 42.08), (-73.481, 42.056), (-73.545, 41.296), (-73.514, 41.257), (-73.484, 41.219), (-73.522, 41.201), (-73.58, 41.173), (-73.642, 41.143), (-73.723, 41.105), (-73.682, 41.055), (-73.63, 40.992), (-73.671, 40.966), (-73.779, 40.878), (-73.851, 40.831), (-73.911, 40.816), (-73.947, 40.777), (-73.987, 40.751), (-73.949, 40.839), (-73.907, 40.912), (-73.872, 41.055), (-73.882, 41.171), (-73.925, 41.218), (-73.97, 41.25), (-73.918, 41.136), (-73.909, 40.996), (-73.91, 40.992), (-74.699, 41.357), (-74.72, 41.395), (-74.757, 41.424), (-74.935, 41.474), (-74.981, 41.508), (-75.023, 41.553), (-75.051, 41.608), (-75.066, 41.667), (-75.067, 41.713), (-75.054, 41.765), (-75.095, 41.799), (-75.096, 41.832), (-75.122, 41.853), (-75.239, 41.892), (-75.274, 41.947), (-75.351, 41.998), (-79.763, 42.001), (-79.763, 42.27), (-79.763, 42.276), (-79.704, 42.3), (-79.512, 42.391), (-79.416, 42.457), (-79.315, 42.512), (-79.209, 42.555), (-79.125, 42.611), (-79.063, 42.68), (-78.994, 42.731), (-78.918, 42.764), (-78.878, 42.799), (-78.872, 42.836), (-78.886, 42.886), (-78.92, 42.948), (-78.924, 42.998), (-78.9, 43.033), (-78.895, 43.058), (-78.908, 43.07), (-79.066, 43.106), (-79.066, 43.106), (-79.059, 43.278), (-79.061, 43.283), (-79.053, 43.285), (-78.689, 43.361), (-78.457, 43.388), (-78.175, 43.395), (-77.838, 43.357), (-77.707, 43.323), (-77.625, 43.279), (-77.529, 43.267), (-77.421, 43.288), (-77.271, 43.295), (-77.079, 43.288), (-76.976, 43.277), (-76.963, 43.264), (-76.95, 43.268), (-76.937, 43.29), (-76.885, 43.314), (-76.741, 43.35), (-76.722, 43.343), (-76.693, 43.361), (-76.653, 43.405), (-76.58, 43.454), (-76.473, 43.507), (-76.376, 43.535), (-76.29, 43.537), (-76.232, 43.55), (-76.203, 43.575), (-76.194, 43.596), (-76.205, 43.614), (-76.2, 43.635), (-76.195, 43.645), (-76.199, 43.653), (-76.21, 43.67), (-76.218, 43.758), (-76.235, 43.799), (-76.258, 43.829), (-76.288, 43.849), (-76.285, 43.869), (-76.233, 43.895), (-76.236, 43.871), (-76.223, 43.864), (-76.198, 43.874), (-76.143, 43.927), (-76.136, 43.947), (-76.099, 43.967), (-76.071, 43.998), (-76.102, 44.003), (-76.175, 43.994), (-76.192, 44.003), (-76.154, 44.045), (-76.161, 44.069), (-76.173, 44.079), (-76.198, 44.083), (-76.281, 44.046), (-76.306, 44.043), (-76.31, 44.063), (-76.352, 44.106), (-76.238, 44.183), (-75.832, 44.397), (-75.791, 44.43), (-75.776, 44.459), (-75.787, 44.484), (-75.798, 44.491), (-75.792, 44.497), (-75.401, 44.772), (-75.179, 44.899), (-74.996, 44.97), (-74.857, 45.004), (-74.762, 44.999), (-74.709, 45.004), (-74.663, 45.004), (-74.43, 45.004), (-74.014, 45.005), (-73.598, 45.005)]]], ['OH', [[(-80.519, 40.647), (-80.638, 40.603), (-80.659, 40.563), (-80.623, 40.512), (-80.604, 40.445), (-80.602, 40.364), (-80.668, 40.185), (-80.804, 39.909), (-80.872, 39.736), (-80.874, 39.664), (-80.963, 39.571), (-81.139, 39.456), (-81.263, 39.387), (-81.333, 39.363), (-81.392, 39.365), (-81.44, 39.393), (-81.493, 39.374), (-81.552, 39.308), (-81.606, 39.274), (-81.657, 39.272), (-81.701, 39.229), (-81.737, 39.147), (-81.771, 39.099), (-81.803, 39.086), (-81.805, 39.044), (-81.778, 38.973), (-81.78, 38.947), (-81.795, 38.946), (-81.809, 38.95), (-81.844, 38.934), (-81.882, 38.894), (-81.897, 38.894), (-81.907, 38.9), (-81.919, 38.952), (-81.95, 38.989), (-82.001, 39.011), (-82.072, 38.963), (-82.163, 38.845), (-82.204, 38.768), (-82.188, 38.715), (-82.18, 38.638), (-82.202, 38.606), (-82.252, 38.594), (-82.291, 38.552), (-82.318, 38.48), (-82.387, 38.434), (-82.498, 38.415), (-82.613, 38.448), (-82.621, 38.451), (-82.758, 38.541), (-82.845, 38.628), (-82.88, 38.71), (-83.0, 38.714), (-83.203, 38.639), (-83.357, 38.627), (-83.461, 38.68), (-83.538, 38.7), (-83.616, 38.683), (-83.69, 38.65), (-83.752, 38.669), (-83.828, 38.731), (-83.948, 38.774), (-84.113, 38.798), (-84.227, 38.865), (-84.29, 38.975), (-84.358, 39.05), (-84.43, 39.091), (-84.509, 39.103), (-84.595, 39.086), (-84.661, 39.094), (-84.707, 39.129), (-84.766, 39.125), (-84.822, 39.092), (-84.796, 41.701), (-83.464, 41.739), (-83.454, 41.746), (-83.456, 41.742), (-83.443, 41.725), (-83.352, 41.714), (-83.291, 41.693), (-83.243, 41.662), (-83.069, 41.601), (-83.016, 41.563), (-82.963, 41.542), (-82.911, 41.538), (-82.875, 41.55), (-82.856, 41.578), (-82.831, 41.58), (-82.801, 41.556), (-82.703, 41.529), (-82.7, 41.521), (-82.971, 41.476), (-83.027, 41.455), (-82.96, 41.44), (-82.891, 41.443), (-82.822, 41.465), (-82.743, 41.464), (-82.673, 41.454), (-82.651, 41.462), (-82.643, 41.467), (-82.524, 41.407), (-82.48, 41.398), (-82.434, 41.405), (-82.387, 41.427), (-82.282, 41.457), (-82.121, 41.493), (-81.966, 41.508), (-81.817, 41.501), (-81.723, 41.511), (-81.637, 41.548), (-81.447, 41.671), (-81.229, 41.77), (-80.869, 41.893), (-80.52, 41.99)]]], ['OK', [[(-94.618, 36.501), (-94.439, 35.387), (-94.484, 33.648), (-94.709, 33.699), (-94.766, 33.732), (-94.869, 33.768), (-94.962, 33.843), (-95.146, 33.937), (-95.216, 33.959), (-95.238, 33.956), (-95.276, 33.911), (-95.374, 33.874), (-95.427, 33.873), (-95.523, 33.887), (-95.542, 33.898), (-95.556, 33.926), (-95.594, 33.945), (-95.623, 33.93), (-95.763, 33.891), (-95.784, 33.865), (-95.863, 33.863), (-95.942, 33.883), (-96.139, 33.822), (-96.207, 33.774), (-96.279, 33.758), (-96.315, 33.711), (-96.337, 33.718), (-96.411, 33.775), (-96.487, 33.792), (-96.592, 33.849), (-96.595, 33.899), (-96.606, 33.906), (-96.625, 33.911), (-96.649, 33.906), (-96.694, 33.864), (-96.72, 33.853), (-96.746, 33.854), (-96.848, 33.883), (-96.89, 33.935), (-96.911, 33.95), (-96.934, 33.953), (-96.978, 33.938), (-97.002, 33.882), (-97.022, 33.867), (-97.064, 33.857), (-97.061, 33.828), (-97.099, 33.75), (-97.119, 33.735), (-97.145, 33.738), (-97.172, 33.757), (-97.192, 33.785), (-97.201, 33.808), (-97.186, 33.87), (-97.195, 33.891), (-97.215, 33.897), (-97.265, 33.868), (-97.308, 33.869), (-97.364, 33.84), (-97.398, 33.831), (-97.43, 33.839), (-97.482, 33.886), (-97.571, 33.916), (-97.606, 33.972), (-97.622, 33.988), (-97.641, 33.992), (-97.66, 33.99), (-97.692, 33.972), (-97.795, 33.899), (-97.842, 33.876), (-97.883, 33.871), (-97.922, 33.878), (-97.946, 33.897), (-97.951, 33.971), (-97.974, 33.994), (-98.069, 34.04), (-98.09, 34.084), (-98.099, 34.145), (-98.214, 34.135), (-98.356, 34.142), (-98.42, 34.088), (-98.454, 34.078), (-98.494, 34.089), (-98.608, 34.161), (-98.73, 34.147), (-98.799, 34.155), (-98.969, 34.209), (-99.102, 34.213), (-99.158, 34.223), (-99.187, 34.235), (-99.2, 34.318), (-99.253, 34.388), (-99.27, 34.407), (-99.36, 34.456), (-99.375, 34.458), (-99.385, 34.447), (-99.405, 34.392), (-99.432, 34.389), (-99.536, 34.405), (-99.632, 34.388), (-99.686, 34.416), (-99.867, 34.543), (-99.941, 34.576), (-99.999, 34.587), (-100.002, 36.501), (-103.0, 36.501), (-103.001, 37.001), (-102.013, 37.001), (-94.618, 37.001)]]], ['OR', [[(-123.221, 46.154), (-123.121, 46.179), (-123.042, 46.16), (-122.942, 46.115), (-122.843, 45.978), (-122.746, 45.75), (-122.726, 45.674), (-122.65, 45.627), (-122.561, 45.625), (-122.203, 45.591), (-122.15, 45.594), (-122.15, 45.594), (-122.085, 45.603), (-121.882, 45.689), (-121.663, 45.718), (-121.402, 45.712), (-121.243, 45.687), (-121.184, 45.644), (-121.045, 45.639), (-120.716, 45.69), (-120.351, 45.725), (-120.156, 45.762), (-119.934, 45.838), (-119.429, 45.934), (-119.177, 45.945), (-119.05, 45.981), (-119.02, 46.0), (-119.002, 46.001), (-118.737, 46.001), (-118.472, 46.001), (-118.206, 46.001), (-117.941, 46.002), (-117.675, 46.002), (-117.41, 46.002), (-117.144, 46.002), (-116.896, 46.002), (-116.869, 45.958), (-116.765, 45.873), (-116.617, 45.799), (-116.521, 45.722), (-116.477, 45.641), (-116.549, 45.457), (-116.737, 45.169), (-116.84, 44.985), (-116.856, 44.906), (-116.949, 44.77), (-117.119, 44.578), (-117.202, 44.436), (-117.197, 44.344), (-117.14, 44.29), (-117.029, 44.276), (-116.953, 44.245), (-116.912, 44.199), (-116.911, 44.157), (-116.95, 44.119), (-116.961, 44.079), (-116.944, 44.038), (-116.958, 43.964), (-117.02, 43.813), (-117.02, 43.808), (-117.017, 42.001), (-120.001, 42.001), (-124.228, 42.001), (-124.355, 42.123), (-124.41, 42.304), (-124.421, 42.381), (-124.406, 42.584), (-124.444, 42.67), (-124.54, 42.813), (-124.499, 42.937), (-124.454, 43.012), (-124.347, 43.342), (-124.321, 43.368), (-124.275, 43.367), (-124.197, 43.423), (-124.233, 43.436), (-124.288, 43.41), (-124.239, 43.54), (-124.184, 43.652), (-124.149, 43.692), (-124.131, 44.056), (-124.099, 44.334), (-124.047, 44.426), (-124.065, 44.52), (-124.045, 44.648), (-124.059, 44.778), (-123.949, 45.401), (-123.963, 45.476), (-123.929, 45.577), (-123.961, 45.843), (-123.947, 46.141), (-123.975, 46.178), (-123.989, 46.219), (-123.963, 46.225), (-123.912, 46.182), (-123.674, 46.183), (-123.522, 46.223), (-123.466, 46.209), (-123.402, 46.155), (-123.322, 46.144)]]], ['PA', [[(-74.699, 41.357), (-74.778, 41.325), (-74.812, 41.302), (-74.841, 41.269), (-74.912, 41.155), (-75.032, 41.052), (-75.123, 40.999), (-75.123, 40.972), (-75.075, 40.884), (-75.076, 40.856), (-75.112, 40.802), (-75.175, 40.776), (-75.186, 40.744), (-75.192, 40.69), (-75.189, 40.596), (-75.171, 40.577), (-75.097, 40.543), (-75.034, 40.42), (-74.976, 40.406), (-74.735, 40.155), (-74.909, 40.08), (-75.024, 40.017), (-75.074, 39.983), (-75.173, 39.895), (-75.321, 39.865), (-75.401, 39.832), (-75.421, 39.815), (-75.51, 39.843), (-75.635, 39.839), (-75.677, 39.827), (-75.709, 39.803), (-75.785, 39.722), (-79.478, 39.723), (-80.519, 39.723), (-80.519, 40.647), (-80.52, 41.99), (-80.334, 42.041), (-80.252, 42.075), (-80.168, 42.109), (-80.125, 42.128), (-80.076, 42.146), (-79.763, 42.276), (-79.763, 42.27), (-79.763, 42.001), (-75.351, 41.998), (-75.274, 41.947), (-75.239, 41.892), (-75.122, 41.853), (-75.096, 41.832), (-75.095, 41.799), (-75.054, 41.765), (-75.067, 41.713), (-75.066, 41.667), (-75.051, 41.608), (-75.023, 41.553), (-74.981, 41.508), (-74.935, 41.474), (-74.757, 41.424), (-74.72, 41.395)]]], ['RI', [[(-71.365, 41.485), (-71.393, 41.467), (-71.403, 41.515), (-71.384, 41.571), (-71.364, 41.572), (-71.354, 41.542)], [(-71.241, 41.492), (-71.291, 41.465), (-71.346, 41.469), (-71.318, 41.506), (-71.307, 41.56), (-71.28, 41.62), (-71.264, 41.638), (-71.232, 41.654)], [(-71.341, 41.798), (-71.305, 41.775), (-71.268, 41.751), (-71.234, 41.707), (-71.271, 41.681), (-71.311, 41.72), (-71.331, 41.762), (-71.359, 41.786), (-71.39, 41.795), (-71.364, 41.703), (-71.427, 41.633), (-71.444, 41.454), (-71.523, 41.379), (-71.769, 41.331), (-71.842, 41.336), (-71.83, 41.393), (-71.805, 41.417), (-71.796, 41.52), (-71.801, 42.012), (-71.387, 42.017), (-71.384, 41.972), (-71.379, 41.902), (-71.338, 41.891), (-71.339, 41.835)]]], ['SC', [[(-78.564, 33.877), (-78.578, 33.873), (-78.841, 33.724), (-78.92, 33.659), (-79.138, 33.406), (-79.194, 33.244), (-79.238, 33.312), (-79.227, 33.363), (-79.226, 33.405), (-79.281, 33.315), (-79.229, 33.185), (-79.276, 33.135), (-79.42, 33.043), (-79.499, 33.027), (-79.587, 33.001), (-79.615, 32.909), (-79.735, 32.825), (-79.805, 32.787), (-79.933, 32.81), (-79.894, 32.729), (-79.941, 32.667), (-80.022, 32.62), (-80.123, 32.589), (-80.18, 32.593), (-80.23, 32.577), (-80.268, 32.537), (-80.363, 32.501), (-80.461, 32.521), (-80.572, 32.534), (-80.634, 32.512), (-80.53, 32.475), (-80.474, 32.423), (-80.486, 32.352), (-80.514, 32.324), (-80.579, 32.287), (-80.608, 32.293), (-80.626, 32.326), (-80.647, 32.396), (-80.678, 32.381), (-80.683, 32.349), (-80.709, 32.337), (-80.803, 32.448), (-80.798, 32.363), (-80.765, 32.298), (-80.734, 32.265), (-80.702, 32.246), (-80.694, 32.216), (-80.758, 32.142), (-80.791, 32.126), (-80.849, 32.114), (-80.882, 32.069), (-80.872, 32.03), (-81.075, 32.11), (-81.135, 32.182), (-81.133, 32.275), (-81.172, 32.38), (-81.29, 32.557), (-81.377, 32.607), (-81.434, 32.728), (-81.49, 32.936), (-81.578, 33.069), (-81.699, 33.127), (-81.78, 33.195), (-81.821, 33.274), (-81.864, 33.325), (-81.909, 33.349), (-81.933, 33.39), (-81.936, 33.447), (-82.006, 33.523), (-82.208, 33.664), (-82.257, 33.749), (-82.352, 33.838), (-82.589, 34.018), (-82.589, 34.017), (-82.819, 34.366), (-82.819, 34.366), (-82.848, 34.437), (-82.897, 34.466), (-82.976, 34.476), (-83.053, 34.511), (-83.166, 34.599), (-83.167, 34.6), (-83.356, 34.708), (-83.317, 34.806), (-83.17, 34.933), (-83.121, 35.001), (-83.115, 35.001), (-83.097, 35.002), (-82.937, 35.044), (-82.778, 35.087), (-82.744, 35.084), (-82.651, 35.128), (-82.464, 35.178), (-82.393, 35.211), (-82.356, 35.202), (-81.087, 35.156), (-81.057, 35.146), (-81.047, 35.131), (-81.051, 35.089), (-81.045, 35.066), (-80.934, 35.114), (-80.882, 35.058), (-80.793, 34.963), (-80.789, 34.907), (-80.784, 34.829), (-79.654, 34.797)]]], ['SD', [[(-96.556, 45.943), (-96.591, 45.843), (-96.615, 45.8), (-96.663, 45.756), (-96.814, 45.659), (-96.851, 45.626), (-96.845, 45.596), (-96.815, 45.557), (-96.738, 45.468), (-96.696, 45.432), (-96.53, 45.372), (-96.454, 45.297), (-96.454, 43.501), (-96.599, 43.498), (-96.581, 43.435), (-96.542, 43.373), (-96.535, 43.338), (-96.543, 43.309), (-96.57, 43.283), (-96.563, 43.243), (-96.555, 43.232), (-96.49, 43.206), (-96.468, 43.17), (-96.461, 43.13), (-96.463, 43.099), (-96.502, 43.043), (-96.513, 42.969), (-96.563, 42.859), (-96.616, 42.791), (-96.627, 42.757), (-96.622, 42.73), (-96.539, 42.659), (-96.534, 42.63), (-96.506, 42.594), (-96.481, 42.511), (-96.558, 42.525), (-96.633, 42.569), (-96.676, 42.638), (-96.805, 42.701), (-97.02, 42.76), (-97.164, 42.813), (-97.239, 42.861), (-97.417, 42.881), (-97.698, 42.875), (-97.881, 42.85), (-97.965, 42.806), (-98.143, 42.852), (-98.442, 43.001), (-104.029, 43.001), (-104.037, 45.001), (-104.005, 45.001), (-104.005, 45.013), (-104.011, 45.943)]]], ['TN', [[(-83.668, 36.605), (-81.953, 36.598), (-81.905, 36.619), (-81.801, 36.615), (-81.659, 36.611), (-81.704, 36.534), (-81.708, 36.482), (-81.733, 36.406), (-81.734, 36.355), (-81.808, 36.353), (-81.851, 36.34), (-81.908, 36.306), (-82.051, 36.123), (-82.101, 36.107), (-82.182, 36.154), (-82.295, 36.134), (-82.368, 36.1), (-82.478, 36.01), (-82.521, 35.981), (-82.553, 35.971), (-82.577, 35.972), (-82.589, 35.987), (-82.598, 36.032), (-82.611, 36.047), (-82.645, 36.047), (-82.7, 36.03), (-82.756, 36.0), (-82.813, 35.947), (-82.888, 35.952), (-82.902, 35.939), (-82.92, 35.879), (-82.949, 35.835), (-82.99, 35.8), (-83.12, 35.775), (-83.284, 35.682), (-83.511, 35.584), (-83.723, 35.56), (-83.812, 35.54), (-83.871, 35.515), (-84.004, 35.414), (-84.062, 35.286), (-84.129, 35.261), (-84.232, 35.261), (-84.261, 35.25), (-84.287, 35.201), (-84.325, 34.988), (-85.624, 35.001), (-88.19, 35.025), (-88.203, 35.024), (-88.191, 35.012), (-88.173, 34.999), (-90.294, 35.001), (-90.294, 35.004), (-90.256, 35.046), (-90.142, 35.114), (-90.093, 35.204), (-90.108, 35.314), (-90.066, 35.414), (-89.967, 35.503), (-89.927, 35.592), (-89.944, 35.679), (-89.895, 35.751), (-89.78, 35.806), (-89.764, 35.828), (-89.768, 35.845), (-89.77, 35.864), (-89.769, 35.872), (-89.764, 35.889), (-89.738, 35.899), (-89.704, 35.907), (-89.689, 35.921), (-89.689, 35.944), (-89.709, 35.983), (-89.705, 36.002), (-89.698, 36.03), (-89.642, 36.105), (-89.634, 36.168), (-89.675, 36.221), (-89.654, 36.248), (-89.628, 36.255), (-89.595, 36.259), (-89.584, 36.272), (-89.584, 36.288), (-89.612, 36.322), (-89.604, 36.352), (-89.555, 36.373), (-89.541, 36.427), (-89.557, 36.501), (-89.487, 36.503), (-89.485, 36.498), (-89.471, 36.489), (-89.452, 36.498), (-89.45, 36.5), (-88.059, 36.5), (-88.056, 36.501), (-88.057, 36.59), (-88.096, 36.693), (-88.091, 36.693), (-87.956, 36.682), (-87.869, 36.675), (-87.839, 36.644), (-86.508, 36.665), (-83.73, 36.587), (-83.723, 36.589), (-83.715, 36.591), (-83.707, 36.594), (-83.699, 36.596), (-83.691, 36.598), (-83.683, 36.6), (-83.675, 36.603)]]], ['TX', [[(-97.171, 26.159), (-97.185, 26.113), (-97.267, 26.33), (-97.402, 26.821), (-97.407, 27.1), (-97.386, 27.197), (-97.351, 26.801), (-97.202, 26.3)], [(-97.354, 27.3), (-97.385, 27.243), (-97.376, 27.328), (-97.295, 27.523), (-97.13, 27.779), (-97.061, 27.822), (-97.251, 27.541)], [(-97.014, 27.902), (-97.036, 27.899), (-96.988, 27.981), (-96.979, 28.014), (-96.899, 28.117), (-96.857, 28.133), (-96.84, 28.089), (-96.921, 28.016)], [(-96.764, 28.153), (-96.801, 28.148), (-96.756, 28.202), (-96.682, 28.23), (-96.519, 28.333), (-96.453, 28.341), (-96.419, 28.376), (-96.404, 28.382), (-96.413, 28.338), (-96.544, 28.276)], [(-95.04, 29.146), (-95.09, 29.136), (-94.872, 29.29), (-94.826, 29.341), (-94.768, 29.339), (-94.865, 29.253)], [(-103.0, 36.501), (-100.002, 36.501), (-99.999, 34.587), (-99.941, 34.576), (-99.867, 34.543), (-99.686, 34.416), (-99.632, 34.388), (-99.536, 34.405), (-99.432, 34.389), (-99.405, 34.392), (-99.385, 34.447), (-99.375, 34.458), (-99.36, 34.456), (-99.27, 34.407), (-99.253, 34.388), (-99.2, 34.318), (-99.187, 34.235), (-99.158, 34.223), (-99.102, 34.213), (-98.969, 34.209), (-98.799, 34.155), (-98.73, 34.147), (-98.608, 34.161), (-98.494, 34.089), (-98.454, 34.078), (-98.42, 34.088), (-98.356, 34.142), (-98.214, 34.135), (-98.099, 34.145), (-98.09, 34.084), (-98.069, 34.04), (-97.974, 33.994), (-97.951, 33.971), (-97.946, 33.897), (-97.922, 33.878), (-97.883, 33.871), (-97.842, 33.876), (-97.795, 33.899), (-97.692, 33.972), (-97.66, 33.99), (-97.641, 33.992), (-97.622, 33.988), (-97.606, 33.972), (-97.571, 33.916), (-97.482, 33.886), (-97.43, 33.839), (-97.398, 33.831), (-97.364, 33.84), (-97.308, 33.869), (-97.265, 33.868), (-97.215, 33.897), (-97.195, 33.891), (-97.186, 33.87), (-97.201, 33.808), (-97.192, 33.785), (-97.172, 33.757), (-97.145, 33.738), (-97.119, 33.735), (-97.099, 33.75), (-97.061, 33.828), (-97.064, 33.857), (-97.022, 33.867), (-97.002, 33.882), (-96.978, 33.938), (-96.934, 33.953), (-96.911, 33.95), (-96.89, 33.935), (-96.848, 33.883), (-96.746, 33.854), (-96.72, 33.853), (-96.694, 33.864), (-96.649, 33.906), (-96.625, 33.911), (-96.606, 33.906), (-96.595, 33.899), (-96.592, 33.849), (-96.487, 33.792), (-96.411, 33.775), (-96.337, 33.718), (-96.315, 33.711), (-96.279, 33.758), (-96.207, 33.774), (-96.139, 33.822), (-95.942, 33.883), (-95.863, 33.863), (-95.784, 33.865), (-95.763, 33.891), (-95.623, 33.93), (-95.594, 33.945), (-95.556, 33.926), (-95.542, 33.898), (-95.523, 33.887), (-95.427, 33.873), (-95.374, 33.874), (-95.276, 33.911), (-95.238, 33.956), (-95.216, 33.959), (-95.146, 33.937), (-94.962, 33.843), (-94.869, 33.768), (-94.766, 33.732), (-94.709, 33.699), (-94.484, 33.648), (-94.432, 33.6), (-94.39, 33.586), (-94.378, 33.566), (-94.358, 33.561), (-94.333, 33.565), (-94.295, 33.587), (-94.238, 33.581), (-94.192, 33.589), (-94.099, 33.577), (-94.047, 33.554), (-94.041, 33.012), (-94.043, 31.999), (-93.905, 31.877), (-93.846, 31.793), (-93.827, 31.75), (-93.821, 31.604), (-93.807, 31.569), (-93.738, 31.514), (-93.736, 31.478), (-93.664, 31.372), (-93.666, 31.323), (-93.597, 31.21), (-93.558, 31.18), (-93.551, 31.104), (-93.531, 31.046), (-93.563, 31.005), (-93.549, 30.948), (-93.569, 30.895), (-93.579, 30.824), (-93.625, 30.714), (-93.665, 30.661), (-93.72, 30.558), (-93.715, 30.473), (-93.747, 30.38), (-93.75, 30.345), (-93.721, 30.283), (-93.711, 30.113), (-93.727, 30.077), (-93.794, 29.977), (-93.841, 29.98), (-93.946, 29.815), (-93.886, 29.723), (-93.89, 29.689), (-94.1, 29.67), (-94.574, 29.485), (-94.76, 29.384), (-94.75, 29.418), (-94.526, 29.548), (-94.605, 29.568), (-94.733, 29.535), (-94.778, 29.548), (-94.724, 29.655), (-94.742, 29.75), (-94.832, 29.753), (-94.89, 29.677), (-94.93, 29.68), (-94.982, 29.713), (-95.023, 29.702), (-94.993, 29.531), (-94.936, 29.46), (-94.888, 29.371), (-95.018, 29.259), (-95.139, 29.168), (-95.152, 29.079), (-95.274, 28.964), (-95.388, 28.898), (-95.656, 28.745), (-95.732, 28.712), (-95.853, 28.64), (-96.02, 28.587), (-96.181, 28.502), (-96.235, 28.489), (-96.132, 28.561), (-96.011, 28.632), (-96.115, 28.622), (-96.275, 28.655), (-96.373, 28.657), (-96.374, 28.631), (-96.449, 28.594), (-96.526, 28.648), (-96.56, 28.684), (-96.576, 28.716), (-96.609, 28.723), (-96.64, 28.709), (-96.525, 28.489), (-96.475, 28.479), (-96.421, 28.457), (-96.489, 28.406), (-96.562, 28.367), (-96.676, 28.341), (-96.774, 28.422), (-96.795, 28.321), (-96.807, 28.22), (-96.84, 28.194), (-96.892, 28.158), (-96.92, 28.185), (-96.933, 28.224), (-96.967, 28.19), (-97.015, 28.163), (-97.096, 28.158), (-97.156, 28.144), (-97.155, 28.103), (-97.141, 28.061), (-97.034, 28.094), (-97.073, 27.986), (-97.171, 27.88), (-97.252, 27.854), (-97.374, 27.87), (-97.404, 27.859), (-97.432, 27.837), (-97.289, 27.671), (-97.38, 27.419), (-97.439, 27.328), (-97.48, 27.317), (-97.524, 27.314), (-97.682, 27.395), (-97.768, 27.457), (-97.692, 27.287), (-97.485, 27.237), (-97.475, 27.173), (-97.476, 27.118), (-97.517, 27.053), (-97.555, 26.967), (-97.526, 26.908), (-97.494, 26.76), (-97.466, 26.692), (-97.435, 26.486), (-97.402, 26.397), (-97.214, 26.068), (-97.15, 26.065), (-97.14, 26.03), (-97.146, 25.961), (-97.282, 25.942), (-97.339, 25.911), (-97.35, 25.885), (-97.358, 25.871), (-97.376, 25.872), (-97.44, 25.891), (-97.587, 25.984), (-97.801, 26.042), (-98.083, 26.064), (-98.275, 26.111), (-98.378, 26.182), (-98.486, 26.225), (-98.598, 26.238), (-98.691, 26.276), (-98.765, 26.34), (-98.873, 26.381), (-99.015, 26.399), (-99.108, 26.447), (-99.172, 26.564), (-99.172, 26.566), (-99.23, 26.762), (-99.302, 26.885), (-99.444, 27.037), (-99.457, 27.057), (-99.457, 27.057), (-99.458, 27.082), (-99.44, 27.17), (-99.455, 27.234), (-99.5, 27.286), (-99.51, 27.34), (-99.486, 27.398), (-99.484, 27.467), (-99.505, 27.548), (-99.595, 27.636), (-99.754, 27.73), (-99.89, 27.867), (-100.001, 28.048), (-100.112, 28.173), (-100.221, 28.243), (-100.296, 28.328), (-100.336, 28.428), (-100.348, 28.486), (-100.332, 28.503), (-100.399, 28.614), (-100.55, 28.821), (-100.636, 28.973), (-100.659, 29.069), (-100.755, 29.183), (-100.924, 29.315), (-101.016, 29.401), (-101.039, 29.46), (-101.039, 29.46), (-101.304, 29.634), (-101.38, 29.743), (-101.44, 29.777), (-101.509, 29.773), (-101.545, 29.784), (-101.546, 29.808), (-101.569, 29.809), (-101.612, 29.787), (-101.752, 29.782), (-101.991, 29.796), (-102.163, 29.825), (-102.269, 29.871), (-102.343, 29.865), (-102.386, 29.807), (-102.476, 29.769), (-102.615, 29.752), (-102.734, 29.644), (-102.834, 29.444), (-102.878, 29.315), (-102.866, 29.258), (-102.892, 29.216), (-102.957, 29.19), (-103.023, 29.132), (-103.09, 29.042), (-103.168, 28.998), (-103.258, 29.001), (-103.423, 29.071), (-103.664, 29.207), (-103.853, 29.291), (-103.99, 29.323), (-104.111, 29.386), (-104.216, 29.48), (-104.312, 29.542), (-104.401, 29.574), (-104.504, 29.678), (-104.622, 29.854), (-104.681, 29.991), (-104.681, 30.134), (-104.836, 30.448), (-104.918, 30.583), (-104.979, 30.646), (-105.098, 30.721), (-105.276, 30.807), (-105.514, 30.981), (-105.813, 31.241), (-106.024, 31.398), (-106.148, 31.451), (-106.256, 31.545), (-106.347, 31.679), (-106.436, 31.764), (-106.445, 31.768), (-106.566, 31.82), (-106.566, 31.82), (-106.668, 32.001), (-106.662, 32.001), (-103.066, 32.003), (-103.042, 36.501)]]], ['UT', [[(-111.05, 42.001), (-111.05, 41.001), (-109.046, 41.001), (-109.047, 37.001), (-114.04, 37.004), (-114.043, 42.001)]]], ['VA', [[(-75.854, 37.297), (-75.934, 37.152), (-75.985, 37.212), (-75.997, 37.264), (-75.975, 37.398), (-75.888, 37.619), (-75.792, 37.756), (-75.719, 37.821), (-75.659, 37.954), (-75.62, 37.999), (-75.469, 38.015), (-75.376, 38.025), (-75.596, 37.631), (-75.587, 37.559), (-75.632, 37.535), (-75.699, 37.516), (-75.767, 37.473), (-75.812, 37.425)], [(-75.333, 37.888), (-75.379, 37.872), (-75.252, 38.037), (-75.226, 38.04), (-75.226, 38.04)], [(-78.322, 39.452), (-77.836, 39.145), (-77.792, 39.227), (-77.727, 39.346), (-77.669, 39.31), (-77.534, 39.266), (-77.479, 39.221), (-77.503, 39.175), (-77.506, 39.143), (-77.481, 39.113), (-77.301, 39.053), (-77.19, 38.969), (-77.122, 38.944), (-77.102, 38.936), (-77.053, 38.915), (-77.03, 38.889), (-77.046, 38.776), (-77.092, 38.72), (-77.165, 38.677), (-77.26, 38.6), (-77.284, 38.529), (-77.314, 38.397), (-77.273, 38.352), (-77.232, 38.34), (-77.11, 38.37), (-77.047, 38.357), (-76.906, 38.197), (-76.645, 38.134), (-76.55, 38.095), (-76.472, 38.011), (-76.355, 37.963), (-76.264, 37.894), (-76.262, 37.848), (-76.293, 37.794), (-76.306, 37.722), (-76.344, 37.676), (-76.437, 37.67), (-76.492, 37.682), (-76.793, 37.938), (-76.829, 37.962), (-76.94, 38.095), (-77.071, 38.167), (-77.111, 38.166), (-76.925, 38.033), (-76.849, 37.94), (-76.715, 37.81), (-76.62, 37.755), (-76.549, 37.669), (-76.484, 37.629), (-76.306, 37.572), (-76.368, 37.53), (-76.269, 37.495), (-76.254, 37.431), (-76.263, 37.357), (-76.401, 37.386), (-76.405, 37.332), (-76.393, 37.3), (-76.454, 37.274), (-76.538, 37.309), (-76.758, 37.505), (-76.756, 37.479), (-76.738, 37.449), (-76.611, 37.323), (-76.497, 37.247), (-76.401, 37.213), (-76.327, 37.149), (-76.301, 37.111), (-76.283, 37.053), (-76.338, 37.013), (-76.401, 36.991), (-76.462, 37.031), (-76.507, 37.072), (-76.602, 37.143), (-76.631, 37.222), (-76.704, 37.218), (-77.007, 37.318), (-77.251, 37.329), (-77.227, 37.309), (-77.196, 37.296), (-77.002, 37.271), (-76.925, 37.225), (-76.765, 37.184), (-76.672, 37.173), (-76.634, 37.047), (-76.505, 36.961), (-76.488, 36.897), (-76.4, 36.89), (-76.244, 36.953), (-76.144, 36.931), (-75.999, 36.913), (-75.966, 36.862), (-75.942, 36.766), (-75.89, 36.657), (-75.857, 36.551), (-75.889, 36.551), (-75.966, 36.551), (-81.642, 36.595), (-81.659, 36.611), (-81.801, 36.615), (-81.905, 36.619), (-81.953, 36.598), (-83.668, 36.605), (-83.566, 36.653), (-83.417, 36.681), (-83.15, 36.762), (-83.044, 36.846), (-82.895, 36.906), (-82.832, 36.979), (-82.732, 37.048), (-82.695, 37.126), (-82.682, 37.138), (-82.517, 37.209), (-82.343, 37.297), (-81.965, 37.54), (-81.958, 37.508), (-81.971, 37.473), (-81.939, 37.433), (-81.913, 37.369), (-81.876, 37.33), (-81.829, 37.299), (-81.752, 37.271), (-81.661, 37.222), (-81.589, 37.208), (-81.565, 37.21), (-81.486, 37.257), (-81.419, 37.282), (-81.35, 37.334), (-81.227, 37.263), (-81.178, 37.263), (-81.057, 37.294), (-80.944, 37.302), (-80.915, 37.311), (-80.873, 37.341), (-80.872, 37.399), (-80.862, 37.415), (-80.843, 37.422), (-80.821, 37.423), (-80.77, 37.402), (-80.72, 37.401), (-80.507, 37.469), (-80.491, 37.464), (-80.465, 37.433), (-80.371, 37.473), (-80.316, 37.51), (-80.292, 37.566), (-80.246, 37.621), (-80.255, 37.645), (-80.285, 37.677), (-80.246, 37.751), (-80.188, 37.824), (-79.972, 38.046), (-79.903, 38.181), (-79.813, 38.267), (-79.783, 38.336), (-79.715, 38.404), (-79.669, 38.544), (-79.64, 38.572), (-79.598, 38.577), (-79.555, 38.559), (-79.525, 38.533), (-79.505, 38.491), (-79.396, 38.454), (-79.304, 38.45), (-79.24, 38.477), (-79.203, 38.526), (-79.153, 38.618), (-79.104, 38.673), (-79.073, 38.742), (-79.041, 38.79), (-78.992, 38.82), (-78.869, 38.818), (-78.805, 38.86), (-78.757, 38.908), (-78.727, 38.924), (-78.693, 38.922), (-78.581, 38.999), (-78.435, 39.161), (-78.404, 39.263), (-78.366, 39.336), (-78.351, 39.411)]]], ['VT', [[(-72.467, 42.73), (-73.253, 42.752), (-73.28, 42.813), (-73.267, 42.865), (-73.247, 43.553), (-73.306, 43.616), (-73.33, 43.627), (-73.349, 43.62), (-73.391, 43.579), (-73.405, 43.579), (-73.416, 43.59), (-73.413, 43.628), (-73.376, 43.762), (-73.375, 43.804), (-73.383, 43.876), (-73.425, 44.038), (-73.426, 44.075), (-73.41, 44.131), (-73.381, 44.187), (-73.332, 44.245), (-73.321, 44.269), (-73.325, 44.368), (-73.31, 44.46), (-73.372, 44.597), (-73.349, 44.775), (-73.366, 44.86), (-73.345, 44.939), (-73.352, 45.005), (-73.182, 45.006), (-72.766, 45.006), (-72.35, 45.007), (-71.934, 45.007), (-71.518, 45.008), (-71.533, 44.988), (-71.51, 44.908), (-71.621, 44.772), (-71.618, 44.728), (-71.568, 44.608), (-71.571, 44.579), (-71.588, 44.565), (-71.609, 44.514), (-71.638, 44.482), (-71.683, 44.45), (-71.826, 44.374), (-71.868, 44.355), (-72.002, 44.329), (-72.031, 44.301), (-72.062, 44.116), (-72.106, 44.013), (-72.115, 43.965), (-72.174, 43.884), (-72.222, 43.791), (-72.297, 43.715), (-72.338, 43.622), (-72.362, 43.587), (-72.385, 43.529), (-72.407, 43.332), (-72.438, 43.225), (-72.474, 43.039), (-72.496, 42.992), (-72.519, 42.967), (-72.55, 42.887), (-72.553, 42.856), (-72.54, 42.83), (-72.484, 42.766)]]], ['WA', [[(-122.853, 47.205), (-122.863, 47.185), (-122.877, 47.186), (-122.908, 47.226), (-122.912, 47.254), (-122.885, 47.275), (-122.849, 47.216)], [(-122.394, 47.395), (-122.399, 47.373), (-122.437, 47.355), (-122.457, 47.359), (-122.458, 47.386), (-122.469, 47.39), (-122.51, 47.358), (-122.507, 47.422), (-122.486, 47.489), (-122.469, 47.49), (-122.442, 47.446)], [(-122.497, 47.595), (-122.503, 47.575), (-122.558, 47.598), (-122.576, 47.619), (-122.574, 47.667), (-122.56, 47.698), (-122.55, 47.704), (-122.517, 47.691), (-122.508, 47.683)], [(-122.573, 48.157), (-122.524, 48.025), (-122.503, 48.08), (-122.367, 47.985), (-122.367, 47.939), (-122.383, 47.923), (-122.411, 47.918), (-122.438, 47.931), (-122.462, 47.964), (-122.492, 47.981), (-122.558, 47.992), (-122.591, 48.03), (-122.603, 48.055), (-122.606, 48.129), (-122.623, 48.151), (-122.657, 48.156), (-122.69, 48.174), (-122.742, 48.225), (-122.749, 48.239), (-122.725, 48.281), (-122.669, 48.351), (-122.629, 48.384), (-122.604, 48.381), (-122.572, 48.36), (-122.536, 48.321), (-122.542, 48.294), (-122.692, 48.241), (-122.697, 48.229), (-122.624, 48.214), (-122.598, 48.2)], [(-122.821, 48.431), (-122.837, 48.422), (-122.89, 48.435), (-122.922, 48.457), (-122.932, 48.485), (-122.912, 48.538), (-122.886, 48.552), (-122.869, 48.549), (-122.862, 48.502), (-122.815, 48.452)], [(-123.013, 48.501), (-122.987, 48.468), (-123.094, 48.489), (-123.14, 48.508), (-123.153, 48.526), (-123.17, 48.587), (-123.162, 48.606), (-123.114, 48.613), (-123.024, 48.538)], [(-122.782, 48.673), (-122.769, 48.651), (-122.809, 48.63), (-122.838, 48.627), (-122.883, 48.661), (-122.903, 48.665), (-122.887, 48.612), (-122.893, 48.594), (-122.986, 48.627), (-123.003, 48.652), (-122.977, 48.679), (-122.918, 48.707), (-122.898, 48.71)], [(-123.049, 48.993), (-123.063, 48.978), (-123.077, 48.98), (-123.086, 48.993)], [(-117.039, 48.993), (-117.025, 46.429), (-117.032, 46.42), (-117.039, 46.397), (-117.01, 46.33), (-116.943, 46.232), (-116.922, 46.164), (-116.948, 46.124), (-116.93, 46.056), (-116.896, 46.002), (-117.144, 46.002), (-117.41, 46.002), (-117.675, 46.002), (-117.941, 46.002), (-118.206, 46.001), (-118.472, 46.001), (-118.737, 46.001), (-119.002, 46.001), (-119.02, 46.0), (-119.05, 45.981), (-119.177, 45.945), (-119.429, 45.934), (-119.934, 45.838), (-120.156, 45.762), (-120.351, 45.725), (-120.716, 45.69), (-121.045, 45.639), (-121.184, 45.644), (-121.243, 45.687), (-121.402, 45.712), (-121.663, 45.718), (-121.882, 45.689), (-122.085, 45.603), (-122.15, 45.594), (-122.15, 45.594), (-122.203, 45.591), (-122.561, 45.625), (-122.65, 45.627), (-122.726, 45.674), (-122.746, 45.75), (-122.843, 45.978), (-122.942, 46.115), (-123.042, 46.16), (-123.121, 46.179), (-123.221, 46.154), (-123.251, 46.167), (-123.299, 46.171), (-123.405, 46.221), (-123.465, 46.271), (-123.65, 46.268), (-123.688, 46.3), (-123.896, 46.268), (-123.96, 46.301), (-124.073, 46.279), (-124.045, 46.373), (-124.05, 46.491), (-124.044, 46.605), (-124.016, 46.521), (-123.946, 46.433), (-123.912, 46.533), (-123.889, 46.66), (-123.958, 46.709), (-124.072, 46.745), (-124.113, 46.863), (-123.843, 46.963), (-123.986, 46.984), (-124.042, 47.03), (-124.112, 47.035), (-124.117, 47.0), (-124.139, 46.955), (-124.164, 47.015), (-124.171, 47.087), (-124.199, 47.209), (-124.309, 47.405), (-124.376, 47.659), (-124.46, 47.784), (-124.621, 47.904), (-124.663, 47.974), (-124.702, 48.152), (-124.68, 48.286), (-124.71, 48.38), (-124.633, 48.375), (-124.429, 48.301), (-124.176, 48.242), (-124.099, 48.2), (-123.976, 48.168), (-123.294, 48.12), (-123.25, 48.124), (-123.162, 48.155), (-123.124, 48.151), (-123.024, 48.082), (-122.974, 48.073), (-122.909, 48.077), (-122.861, 48.09), (-122.779, 48.138), (-122.768, 48.12), (-122.769, 48.076), (-122.74, 48.013), (-122.679, 47.932), (-122.657, 47.881), (-122.778, 47.738), (-122.802, 47.735), (-122.805, 47.784), (-122.821, 47.793), (-123.051, 47.552), (-123.131, 47.438), (-123.139, 47.386), (-123.136, 47.356), (-123.104, 47.348), (-123.031, 47.36), (-122.922, 47.408), (-122.917, 47.418), (-123.018, 47.401), (-123.067, 47.4), (-123.06, 47.454), (-123.049, 47.479), (-122.982, 47.559), (-122.913, 47.607), (-122.814, 47.659), (-122.757, 47.701), (-122.718, 47.762), (-122.608, 47.835), (-122.588, 47.856), (-122.593, 47.916), (-122.586, 47.928), (-122.533, 47.92), (-122.511, 47.816), (-122.524, 47.769), (-122.618, 47.713), (-122.63, 47.693), (-122.614, 47.616), (-122.628, 47.608), (-122.664, 47.617), (-122.675, 47.612), (-122.586, 47.528), (-122.557, 47.463), (-122.554, 47.405), (-122.578, 47.293), (-122.604, 47.275), (-122.649, 47.281), (-122.708, 47.316), (-122.721, 47.305), (-122.768, 47.218), (-122.783, 47.226), (-122.813, 47.329), (-122.828, 47.337), (-122.92, 47.29), (-122.956, 47.245), (-122.988, 47.173), (-123.028, 47.139), (-122.914, 47.131), (-122.812, 47.146), (-122.73, 47.112), (-122.702, 47.111), (-122.627, 47.144), (-122.604, 47.167), (-122.542, 47.276), (-122.511, 47.295), (-122.465, 47.296), (-122.42, 47.312), (-122.354, 47.372), (-122.351, 47.395), (-122.375, 47.528), (-122.368, 47.604), (-122.381, 47.628), (-122.411, 47.653), (-122.407, 47.677), (-122.384, 47.716), (-122.382, 47.752), (-122.402, 47.784), (-122.393, 47.821), (-122.33, 47.899), (-122.318, 47.933), (-122.242, 48.011), (-122.261, 48.042), (-122.317, 48.08), (-122.353, 48.114), (-122.389, 48.166), (-122.416, 48.184), (-122.425, 48.176), (-122.387, 48.09), (-122.395, 48.084), (-122.494, 48.13), (-122.517, 48.16), (-122.529, 48.199), (-122.52, 48.229), (-122.467, 48.259), (-122.403, 48.269), (-122.409, 48.294), (-122.488, 48.374), (-122.542, 48.411), (-122.583, 48.429), (-122.638, 48.433), (-122.662, 48.446), (-122.669, 48.465), (-122.657, 48.49), (-122.628, 48.498), (-122.543, 48.488), (-122.497, 48.506), (-122.501, 48.538), (-122.515, 48.555), (-122.513, 48.669), (-122.545, 48.762), (-122.562, 48.778), (-122.58, 48.78), (-122.599, 48.767), (-122.653, 48.764), (-122.686, 48.794), (-122.722, 48.853), (-122.789, 48.993)]]], ['WI', [[(-86.992, 45.241), (-87.01, 45.228), (-87.042, 45.237), (-87.054, 45.218), (-87.047, 45.172), (-87.057, 45.151), (-87.084, 45.154), (-87.086, 45.145), (-87.062, 45.125), (-87.059, 45.102), (-87.078, 45.078), (-87.096, 45.067), (-87.114, 45.068), (-87.141, 45.041), (-87.179, 44.983), (-87.191, 44.95), (-87.179, 44.941), (-87.188, 44.922), (-87.28, 44.835), (-87.316, 44.827), (-87.355, 44.839), (-87.382, 44.864), (-87.398, 44.903), (-87.403, 44.933), (-87.396, 44.954), (-87.316, 45.031), (-87.279, 45.081), (-87.259, 45.138), (-87.221, 45.174), (-87.166, 45.19), (-87.122, 45.225), (-87.088, 45.279), (-87.049, 45.303), (-87.005, 45.296), (-86.986, 45.275)], [(-86.862, 45.352), (-86.892, 45.342), (-86.947, 45.346), (-86.967, 45.368), (-86.938, 45.426), (-86.926, 45.415), (-86.878, 45.414), (-86.862, 45.409), (-86.857, 45.394)], [(-90.711, 46.783), (-90.768, 46.77), (-90.792, 46.772), (-90.782, 46.791), (-90.752, 46.814), (-90.619, 46.87), (-90.596, 46.869), (-90.589, 46.855), (-90.653, 46.828), (-90.678, 46.813), (-90.68, 46.798)], [(-90.547, 46.919), (-90.58, 46.914), (-90.652, 46.922), (-90.65, 46.937), (-90.576, 46.957), (-90.543, 46.963), (-90.535, 46.954)], [(-90.788, 46.868), (-90.84, 46.81), (-90.865, 46.761), (-90.864, 46.721), (-90.886, 46.677), (-90.944, 46.619), (-90.923, 46.603), (-90.77, 46.645), (-90.748, 46.662), (-90.745, 46.672), (-90.754, 46.684), (-90.737, 46.689), (-90.617, 46.631), (-90.536, 46.599), (-90.469, 46.584), (-90.408, 46.593), (-90.413, 46.585), (-90.392, 46.549), (-90.341, 46.558), (-90.318, 46.537), (-90.288, 46.527), (-90.23, 46.51), (-90.202, 46.468), (-90.174, 46.426), (-90.147, 46.384), (-90.119, 46.342), (-89.994, 46.318), (-89.869, 46.294), (-89.744, 46.269), (-89.619, 46.245), (-89.494, 46.221), (-89.369, 46.197), (-89.244, 46.173), (-89.119, 46.149), (-89.049, 46.121), (-88.978, 46.093), (-88.908, 46.065), (-88.837, 46.037), (-88.727, 46.031), (-88.63, 46.014), (-88.493, 46.014), (-88.355, 45.992), (-88.152, 45.945), (-88.104, 45.905), (-88.096, 45.878), (-88.116, 45.816), (-87.923, 45.76), (-87.84, 45.718), (-87.809, 45.686), (-87.814, 45.657), (-87.795, 45.596), (-87.815, 45.563), (-87.815, 45.506), (-87.859, 45.445), (-87.874, 45.413), (-87.875, 45.385), (-87.865, 45.368), (-87.842, 45.361), (-87.769, 45.364), (-87.696, 45.383), (-87.664, 45.371), (-87.658, 45.362), (-87.663, 45.345), (-87.721, 45.243), (-87.719, 45.201), (-87.694, 45.161), (-87.654, 45.122), (-87.606, 45.109), (-87.608, 45.083), (-87.627, 45.032), (-87.683, 44.993), (-87.83, 44.942), (-87.854, 44.908), (-87.857, 44.88), (-87.952, 44.764), (-87.998, 44.692), (-88.028, 44.618), (-88.019, 44.571), (-87.969, 44.552), (-87.929, 44.559), (-87.898, 44.593), (-87.851, 44.624), (-87.788, 44.652), (-87.741, 44.692), (-87.677, 44.79), (-87.604, 44.847), (-87.566, 44.85), (-87.555, 44.849), (-87.48, 44.874), (-87.42, 44.866), (-87.383, 44.827), (-87.346, 44.801), (-87.337, 44.776), (-87.356, 44.72), (-87.391, 44.662), (-87.441, 44.601), (-87.487, 44.509), (-87.527, 44.386), (-87.536, 44.293), (-87.513, 44.23), (-87.535, 44.174), (-87.603, 44.125), (-87.658, 44.059), (-87.7, 43.977), (-87.724, 43.907), (-87.729, 43.851), (-87.723, 43.809), (-87.698, 43.752), (-87.7, 43.724), (-87.774, 43.599), (-87.801, 43.538), (-87.806, 43.49), (-87.824, 43.443), (-87.881, 43.347), (-87.898, 43.294), (-87.902, 43.245), (-87.889, 43.165), (-87.896, 43.137), (-87.893, 43.117), (-87.879, 43.103), (-87.879, 43.078), (-87.893, 43.041), (-87.888, 43.012), (-87.862, 42.992), (-87.846, 42.953), (-87.838, 42.896), (-87.819, 42.848), (-87.787, 42.809), (-87.781, 42.753), (-87.802, 42.68), (-87.812, 42.543), (-87.812, 42.497), (-90.651, 42.513), (-90.657, 42.521), (-90.688, 42.61), (-90.789, 42.677), (-90.96, 42.72), (-91.07, 42.789), (-91.118, 42.882), (-91.148, 42.986), (-91.161, 43.102), (-91.148, 43.2), (-91.107, 43.278), (-91.117, 43.331), (-91.178, 43.359), (-91.219, 43.395), (-91.238, 43.44), (-91.245, 43.502), (-91.278, 43.797), (-91.32, 43.936), (-91.383, 43.991), (-91.515, 44.054), (-91.716, 44.126), (-91.841, 44.194), (-91.912, 44.289), (-92.055, 44.4), (-92.149, 44.445), (-92.24, 44.462), (-92.313, 44.498), (-92.367, 44.552), (-92.442, 44.587), (-92.537, 44.601), (-92.644, 44.645), (-92.77, 44.726), (-92.773, 44.732), (-92.799, 44.79), (-92.785, 44.823), (-92.763, 44.934), (-92.765, 44.969), (-92.793, 45.071), (-92.759, 45.111), (-92.766, 45.236), (-92.754, 45.278), (-92.686, 45.381), (-92.683, 45.433), (-92.707, 45.494), (-92.757, 45.543), (-92.892, 45.595), (-92.897, 45.659), (-92.875, 45.706), (-92.786, 45.796), (-92.738, 45.875), (-92.694, 45.909), (-92.425, 46.028), (-92.367, 46.036), (-92.325, 46.07), (-92.293, 46.084), (-92.292, 46.228), (-92.292, 46.373), (-92.292, 46.517), (-92.292, 46.661), (-92.224, 46.671), (-92.195, 46.707), (-92.125, 46.763), (-92.107, 46.762), (-92.107, 46.762), (-92.073, 46.736), (-91.987, 46.699), (-91.921, 46.694), (-91.836, 46.702), (-91.499, 46.766), (-91.357, 46.811), (-91.218, 46.886), (-91.203, 46.888), (-91.145, 46.874), (-91.127, 46.868), (-90.946, 46.954), (-90.887, 46.965), (-90.84, 46.962), (-90.782, 46.929), (-90.768, 46.908)], [(-90.708, 46.927), (-90.723, 46.92), (-90.761, 46.937), (-90.766, 46.951), (-90.756, 46.965), (-90.738, 46.962), (-90.713, 46.941)], [(-90.427, 47.026), (-90.459, 47.01), (-90.472, 47.018), (-90.464, 47.048), (-90.447, 47.066), (-90.422, 47.071), (-90.41, 47.064), (-90.41, 47.044)]]], ['WV', [[(-79.478, 39.723), (-79.48, 39.595), (-79.483, 39.467), (-79.485, 39.339), (-79.488, 39.211), (-79.36, 39.285), (-79.294, 39.312), (-79.075, 39.476), (-79.047, 39.477), (-78.971, 39.454), (-78.815, 39.57), (-78.796, 39.613), (-78.778, 39.627), (-78.758, 39.625), (-78.746, 39.614), (-78.753, 39.59), (-78.742, 39.578), (-78.678, 39.55), (-78.587, 39.534), (-78.575, 39.533), (-78.496, 39.533), (-78.46, 39.556), (-78.443, 39.601), (-78.407, 39.628), (-78.325, 39.639), (-78.181, 39.686), (-78.098, 39.678), (-78.027, 39.631), (-77.956, 39.609), (-77.883, 39.611), (-77.855, 39.6), (-77.872, 39.576), (-77.853, 39.548), (-77.798, 39.517), (-77.78, 39.488), (-77.797, 39.461), (-77.792, 39.442), (-77.762, 39.429), (-77.745, 39.4), (-77.739, 39.354), (-77.727, 39.346), (-77.792, 39.227), (-77.836, 39.145), (-78.322, 39.452), (-78.351, 39.411), (-78.366, 39.336), (-78.404, 39.263), (-78.435, 39.161), (-78.581, 38.999), (-78.693, 38.922), (-78.727, 38.924), (-78.757, 38.908), (-78.805, 38.86), (-78.869, 38.818), (-78.992, 38.82), (-79.041, 38.79), (-79.073, 38.742), (-79.104, 38.673), (-79.153, 38.618), (-79.203, 38.526), (-79.24, 38.477), (-79.304, 38.45), (-79.396, 38.454), (-79.505, 38.491), (-79.525, 38.533), (-79.555, 38.559), (-79.598, 38.577), (-79.64, 38.572), (-79.669, 38.544), (-79.715, 38.404), (-79.783, 38.336), (-79.813, 38.267), (-79.903, 38.181), (-79.972, 38.046), (-80.188, 37.824), (-80.246, 37.751), (-80.285, 37.677), (-80.255, 37.645), (-80.246, 37.621), (-80.292, 37.566), (-80.316, 37.51), (-80.371, 37.473), (-80.465, 37.433), (-80.491, 37.464), (-80.507, 37.469), (-80.72, 37.401), (-80.77, 37.402), (-80.821, 37.423), (-80.843, 37.422), (-80.862, 37.415), (-80.872, 37.399), (-80.873, 37.341), (-80.915, 37.311), (-80.944, 37.302), (-81.057, 37.294), (-81.178, 37.263), (-81.227, 37.263), (-81.35, 37.334), (-81.419, 37.282), (-81.486, 37.257), (-81.565, 37.21), (-81.589, 37.208), (-81.661, 37.222), (-81.752, 37.271), (-81.829, 37.299), (-81.876, 37.33), (-81.913, 37.369), (-81.939, 37.433), (-81.971, 37.473), (-81.958, 37.508), (-81.965, 37.54), (-82.103, 37.571), (-82.28, 37.687), (-82.394, 37.828), (-82.43, 37.894), (-82.472, 37.938), (-82.482, 37.984), (-82.589, 38.1), (-82.618, 38.15), (-82.62, 38.182), (-82.585, 38.243), (-82.578, 38.272), (-82.589, 38.42), (-82.613, 38.448), (-82.498, 38.415), (-82.387, 38.434), (-82.318, 38.48), (-82.291, 38.552), (-82.252, 38.594), (-82.202, 38.606), (-82.18, 38.638), (-82.188, 38.715), (-82.204, 38.768), (-82.163, 38.845), (-82.072, 38.963), (-82.001, 39.011), (-81.95, 38.989), (-81.919, 38.952), (-81.907, 38.9), (-81.897, 38.894), (-81.882, 38.894), (-81.844, 38.934), (-81.809, 38.95), (-81.795, 38.946), (-81.78, 38.947), (-81.778, 38.973), (-81.805, 39.044), (-81.803, 39.086), (-81.771, 39.099), (-81.737, 39.147), (-81.701, 39.229), (-81.657, 39.272), (-81.606, 39.274), (-81.552, 39.308), (-81.493, 39.374), (-81.44, 39.393), (-81.392, 39.365), (-81.333, 39.363), (-81.263, 39.387), (-81.139, 39.456), (-80.963, 39.571), (-80.874, 39.664), (-80.872, 39.736), (-80.804, 39.909), (-80.668, 40.185), (-80.602, 40.364), (-80.604, 40.445), (-80.623, 40.512), (-80.659, 40.563), (-80.638, 40.603), (-80.519, 40.647), (-80.519, 39.723)]]], ['WY', [[(-104.029, 43.001), (-104.022, 41.001), (-109.046, 41.001), (-111.05, 41.001), (-111.05, 42.001), (-111.051, 44.499), (-111.051, 45.001), (-104.037, 45.001)]]], ['PE', [[(-63.811, 46.469), (-63.784, 46.455), (-63.737, 46.48), (-63.681, 46.562), (-63.534, 46.541), (-63.456, 46.504), (-63.413, 46.512), (-63.369, 46.508), (-63.286, 46.46), (-63.129, 46.422), (-62.964, 46.428), (-62.712, 46.45), (-62.682, 46.459), (-62.423, 46.478), (-62.164, 46.487), (-62.074, 46.466), (-62.041, 46.446), (-62.024, 46.422), (-62.172, 46.355), (-62.32, 46.278), (-62.526, 46.203), (-62.552, 46.166), (-62.539, 46.098), (-62.543, 46.029), (-62.503, 46.023), (-62.478, 46.0), (-62.531, 45.977), (-62.743, 45.967), (-62.805, 45.973), (-62.878, 46.001), (-62.904, 46.068), (-62.995, 46.058), (-63.022, 46.067), (-62.895, 46.124), (-62.953, 46.195), (-63.015, 46.19), (-63.056, 46.224), (-63.053, 46.27), (-62.995, 46.292), (-62.978, 46.316), (-63.057, 46.295), (-63.117, 46.253), (-63.195, 46.237), (-63.271, 46.2), (-63.153, 46.188), (-63.214, 46.16), (-63.277, 46.153), (-63.569, 46.209), (-63.641, 46.23), (-63.732, 46.289), (-63.801, 46.367), (-63.763, 46.37), (-63.751, 46.384), (-63.759, 46.398), (-63.861, 46.408), (-64.02, 46.405), (-64.111, 46.425), (-64.107, 46.562), (-64.136, 46.6), (-64.236, 46.631), (-64.388, 46.641), (-64.403, 46.692), (-64.355, 46.769), (-64.28, 46.836), (-64.223, 46.901), (-64.157, 46.955), (-63.994, 47.062), (-63.997, 46.982), (-63.981, 46.913), (-64.088, 46.775), (-63.903, 46.639), (-63.879, 46.609), (-63.864, 46.572), (-63.876, 46.539), (-63.906, 46.509), (-63.834, 46.494)]]], ['FJ', [[(180.0, -16.067), (180.0, -16.555), (179.364, -16.801), (178.725, -17.012), (178.597, -16.639), (179.097, -16.434), (179.414, -16.379)], [(178.126, -17.505), (178.374, -17.34), (178.718, -17.628), (178.553, -18.151), (177.933, -18.288), (177.381, -18.164), (177.285, -17.725), (177.671, -17.381)], [(-179.793, -16.021), (-179.917, -16.502), (-180.0, -16.555), (-180.0, -16.067)]]], ['TZ', [[(34.073, -1.06), (37.699, -3.097), (37.767, -3.677), (39.202, -4.677), (38.741, -5.909), (38.8, -6.476), (39.44, -6.84), (39.47, -7.1), (39.195, -7.704), (39.252, -8.008), (39.187, -8.486), (39.536, -9.112), (39.95, -10.098), (40.317, -10.317), (40.317, -10.317), (39.521, -10.897), (38.428, -11.285), (37.828, -11.269), (37.471, -11.569), (36.775, -11.595), (36.514, -11.721), (35.312, -11.439), (34.933, -11.48), (34.937, -11.463), (34.608, -11.081), (34.524, -10.03), (33.996, -9.495), (33.939, -9.691), (33.74, -9.417), (32.759, -9.231), (32.192, -8.93), (31.556, -8.762), (31.158, -8.595), (31.107, -8.564), (30.604, -7.542), (30.528, -6.923), (29.722, -6.244), (29.951, -5.861), (29.758, -5.467), (29.792, -5.041), (29.6, -4.896), (29.648, -4.465), (29.754, -4.452), (30.116, -4.09), (30.506, -3.569), (30.752, -3.359), (30.743, -3.034), (30.528, -2.808), (30.47, -2.414), (30.47, -2.414), (30.758, -2.287), (30.816, -1.699), (30.419, -1.135), (30.77, -1.015), (31.866, -1.027), (31.866, -1.027), (31.866, -1.027), (31.836, -1.629), (31.648, -2.329), (31.927, -2.715), (32.373, -2.49), (32.952, -2.43), (33.077, -2.547), (33.647, -2.301), (33.252, -1.958), (33.579, -1.506), (34.073, -1.06)]]], ['WS', [[(-8.666, 27.656), (-8.665, 27.589), (-8.684, 27.396), (-8.687, 25.881), (-11.969, 25.933), (-11.937, 23.375), (-12.874, 23.285), (-13.119, 22.771), (-12.929, 21.327), (-16.845, 21.333), (-17.063, 21.0), (-17.02, 21.422), (-17.003, 21.421), (-14.751, 21.501), (-14.631, 21.861), (-14.221, 22.31), (-13.891, 23.691), (-12.501, 24.77), (-12.031, 26.031), (-11.718, 26.104), (-11.393, 26.883), (-10.551, 26.991), (-10.189, 26.861), (-9.735, 26.861), (-9.413, 27.088), (-8.795, 27.121), (-8.818, 27.656), (-8.818, 27.656)]]], ['US', [[(-166.468, 60.384), (-165.674, 60.294), (-165.579, 59.91), (-166.193, 59.754), (-166.848, 59.941), (-167.455, 60.213)], [(-153.229, 57.969), (-152.565, 57.901), (-152.141, 57.591), (-153.006, 57.116), (-154.005, 56.735), (-154.516, 56.993), (-154.671, 57.461), (-153.763, 57.817)], [(-140.986, 69.712), (-140.986, 69.712), (-140.993, 66.0), (-140.998, 60.306), (-140.013, 60.277), (-139.039, 60.0), (-138.341, 59.562), (-137.452, 58.905), (-136.48, 59.464), (-135.476, 59.788), (-134.945, 59.271), (-134.271, 58.861), (-133.356, 58.41), (-132.73, 57.693), (-131.708, 56.552), (-130.008, 55.916), (-129.98, 55.285), (-130.536, 54.803), (-130.536, 54.803), (-130.536, 54.803), (-131.086, 55.179), (-131.967, 55.498), (-132.25, 56.37), (-133.539, 57.179), (-134.078, 58.123), (-135.038, 58.188), (-136.628, 58.212), (-137.8, 58.5), (-139.868, 59.538), (-140.825, 59.728), (-142.574, 60.084), (-143.959, 59.999), (-145.926, 60.459), (-147.114, 60.885), (-148.224, 60.673), (-148.018, 59.978), (-148.571, 59.914), (-149.728, 59.706), (-150.608, 59.368), (-151.716, 59.156), (-151.859, 59.745), (-151.41, 60.726), (-150.347, 61.034), (-150.621, 61.284), (-151.896, 60.727), (-152.578, 60.062), (-154.019, 59.35), (-153.288, 58.865), (-154.232, 58.146), (-155.307, 57.728), (-156.308, 57.423), (-156.556, 56.98), (-158.117, 56.464), (-158.433, 55.994), (-159.603, 55.567), (-160.29, 55.644), (-161.223, 55.365), (-162.238, 55.024), (-163.069, 54.69), (-164.786, 54.404), (-164.942, 54.572), (-163.848, 55.039), (-162.87, 55.348), (-161.804, 55.895), (-160.564, 56.008), (-160.071, 56.418), (-158.684, 57.017), (-158.461, 57.217), (-157.723, 57.57), (-157.55, 58.328), (-157.042, 58.919), (-158.195, 58.616), (-158.517, 58.788), (-159.059, 58.424), (-159.712, 58.931), (-159.981, 58.573), (-160.355, 59.071), (-161.355, 58.671), (-161.969, 58.672), (-162.055, 59.267), (-161.874, 59.634), (-162.518, 59.99), (-163.818, 59.798), (-164.662, 60.267), (-165.346, 60.507), (-165.351, 61.074), (-166.121, 61.5), (-165.734, 62.075), (-164.919, 62.633), (-164.563, 63.146), (-163.753, 63.219), (-163.067, 63.059), (-162.261, 63.542), (-161.534, 63.456), (-160.773, 63.766), (-160.958, 64.223), (-161.518, 64.403), (-160.778, 64.789), (-161.392, 64.777), (-162.453, 64.559), (-162.758, 64.339), (-163.546, 64.559), (-164.961, 64.447), (-166.425, 64.687), (-166.845, 65.089), (-168.111, 65.67), (-166.705, 66.088), (-164.475, 66.577), (-163.653, 66.577), (-163.789, 66.077), (-161.678, 66.116), (-162.49, 66.736), (-163.72, 67.116), (-164.431, 67.616), (-165.39, 68.043), (-166.764, 68.359), (-166.205, 68.883), (-164.431, 68.916), (-163.169, 69.371), (-162.931, 69.858), (-161.909, 70.333), (-160.935, 70.448), (-159.039, 70.892), (-158.12, 70.825), (-156.581, 71.358), (-155.068, 71.148), (-154.344, 70.696), (-153.9, 70.89), (-152.21, 70.83), (-152.27, 70.6), (-150.74, 70.43), (-149.72, 70.53), (-147.613, 70.214), (-145.69, 70.12), (-144.92, 69.99), (-143.589, 70.153), (-142.073, 69.852), (-140.986, 69.712)], [(-171.732, 63.783), (-171.114, 63.592), (-170.491, 63.695), (-169.683, 63.431), (-168.689, 63.298), (-168.772, 63.189), (-169.529, 62.977), (-170.291, 63.194), (-170.671, 63.376), (-171.553, 63.318), (-171.791, 63.406)]]], ['KZ', [[(87.36, 49.215), (86.599, 48.549), (85.768, 48.456), (85.72, 47.453), (85.164, 47.001), (83.18, 47.33), (82.459, 45.54), (81.947, 45.317), (79.966, 44.918), (80.866, 43.18), (80.18, 42.92), (80.26, 42.35), (79.644, 42.497), (79.142, 42.856), (77.658, 42.961), (76.0, 42.988), (75.637, 42.878), (74.213, 43.298), (73.645, 43.091), (73.49, 42.501), (71.845, 42.845), (71.186, 42.704), (70.962, 42.266), (70.389, 42.081), (69.07, 41.384), (68.632, 40.669), (68.26, 40.662), (67.986, 41.136), (66.714, 41.168), (66.511, 41.988), (66.023, 41.995), (66.098, 42.998), (64.901, 43.728), (63.186, 43.65), (62.013, 43.504), (61.058, 44.406), (60.24, 44.784), (58.69, 45.5), (58.503, 45.587), (55.929, 44.996), (55.968, 41.309), (55.455, 41.26), (54.755, 42.044), (54.079, 42.324), (52.944, 42.116), (52.502, 41.783), (52.446, 42.027), (52.692, 42.444), (52.501, 42.792), (51.342, 43.133), (50.891, 44.031), (50.339, 44.284), (50.306, 44.61), (51.279, 44.515), (51.317, 45.246), (52.167, 45.408), (53.041, 45.259), (53.221, 46.235), (53.043, 46.853), (52.042, 46.805), (51.192, 47.049), (50.034, 46.609), (49.101, 46.399), (48.593, 46.561), (48.695, 47.076), (48.057, 47.744), (47.315, 47.716), (46.466, 48.394), (47.044, 49.152), (46.752, 49.356), (47.549, 50.455), (48.578, 49.875), (48.702, 50.605), (50.767, 51.693), (52.329, 51.719), (54.533, 51.026), (55.717, 50.622), (56.778, 51.044), (58.363, 51.064), (59.642, 50.545), (59.933, 50.842), (61.337, 50.799), (61.588, 51.273), (59.968, 51.96), (60.927, 52.448), (60.74, 52.72), (61.7, 52.98), (60.978, 53.665), (61.437, 54.006), (65.179, 54.354), (65.667, 54.601), (68.169, 54.97), (69.068, 55.385), (70.865, 55.17), (71.18, 54.133), (72.224, 54.377), (73.509, 54.036), (73.426, 53.49), (74.385, 53.547), (76.891, 54.491), (76.525, 54.177), (77.801, 53.404), (80.036, 50.865), (80.568, 51.388), (81.946, 50.812), (83.383, 51.069), (83.935, 50.889), (84.416, 50.311), (85.116, 50.117), (85.541, 49.693), (86.829, 49.827)]]], ['UZ', [[(55.968, 41.309), (55.929, 44.996), (58.503, 45.587), (58.69, 45.5), (60.24, 44.784), (61.058, 44.406), (62.013, 43.504), (63.186, 43.65), (64.901, 43.728), (66.098, 42.998), (66.023, 41.995), (66.511, 41.988), (66.714, 41.168), (67.986, 41.136), (68.26, 40.662), (68.632, 40.669), (69.07, 41.384), (70.389, 42.081), (70.962, 42.266), (71.259, 42.168), (70.42, 41.52), (71.158, 41.144), (71.87, 41.393), (73.055, 40.866), (71.775, 40.146), (71.014, 40.244), (70.601, 40.219), (70.458, 40.496), (70.667, 40.96), (69.329, 40.728), (69.012, 40.086), (68.536, 39.533), (67.701, 39.58), (67.442, 39.14), (68.176, 38.902), (68.392, 38.157), (67.83, 37.145), (67.076, 37.356), (66.519, 37.363), (66.546, 37.975), (65.216, 38.403), (64.17, 38.892), (63.518, 39.363), (62.374, 40.054), (61.883, 41.085), (61.547, 41.266), (60.466, 41.22), (60.083, 41.425), (59.976, 42.223), (58.629, 42.752), (57.787, 42.171), (56.932, 41.826), (57.096, 41.322)]]], ['PG', [[(141.0, -2.6), (142.735, -3.289), (144.584, -3.861), (145.273, -4.374), (145.83, -4.876), (145.982, -5.466), (147.648, -6.084), (147.891, -6.614), (146.971, -6.722), (147.192, -7.388), (148.085, -8.044), (148.734, -9.105), (149.307, -9.071), (149.267, -9.514), (150.039, -9.684), (149.739, -9.873), (150.802, -10.294), (150.691, -10.583), (150.028, -10.652), (149.782, -10.393), (148.923, -10.281), (147.913, -10.13), (147.135, -9.492), (146.568, -8.943), (146.048, -8.067), (144.744, -7.63), (143.897, -7.915), (143.286, -8.245), (143.414, -8.983), (142.628, -9.327), (142.068, -9.16), (141.034, -9.118), (141.017, -5.859)], [(152.64, -3.66), (153.02, -3.98), (153.14, -4.5), (152.827, -4.766), (152.639, -4.176), (152.406, -3.79), (151.953, -3.462), (151.384, -3.035), (150.662, -2.741), (150.94, -2.5), (151.48, -2.78), (151.82, -3.0), (152.24, -3.24)], [(151.301, -5.841), (150.754, -6.084), (150.241, -6.318), (149.71, -6.317), (148.89, -6.026), (148.319, -5.747), (148.402, -5.438), (149.298, -5.584), (149.846, -5.506), (149.996, -5.026), (150.14, -5.001), (150.237, -5.532), (150.807, -5.456), (151.09, -5.114), (151.648, -4.757), (151.538, -4.168), (152.137, -4.149), (152.339, -4.313), (152.319, -4.868), (151.983, -5.478), (151.459, -5.56)], [(154.76, -5.34), (155.063, -5.567), (155.548, -6.201), (156.02, -6.54), (155.88, -6.82), (155.6, -6.92), (155.167, -6.536), (154.729, -5.901), (154.514, -5.139), (154.653, -5.042)]]], ['INDO', [[(141.0, -2.6), (141.017, -5.859), (141.034, -9.118), (140.143, -8.297), (139.128, -8.096), (138.881, -8.381), (137.614, -8.412), (138.039, -7.598), (138.669, -7.32), (138.408, -6.233), (137.928, -5.393), (135.989, -4.547), (135.165, -4.463), (133.663, -3.539), (133.368, -4.025), (132.984, -4.113), (132.757, -3.746), (132.754, -3.312), (131.99, -2.821), (133.067, -2.46), (133.78, -2.48), (133.696, -2.215), (132.232, -2.213), (131.836, -1.617), (130.943, -1.433), (130.52, -0.938), (131.868, -0.695), (132.38, -0.37), (133.986, -0.78), (134.143, -1.152), (134.423, -2.769), (135.458, -3.368), (136.293, -2.307), (137.441, -1.704), (138.33, -1.703), (139.185, -2.051), (139.927, -2.409)], [(124.969, -8.893), (125.07, -9.09), (125.089, -9.393), (124.436, -10.14), (123.58, -10.36), (123.46, -10.24), (123.55, -9.9), (123.98, -9.29)], [(134.21, -6.895), (134.113, -6.142), (134.29, -5.783), (134.5, -5.445), (134.727, -5.738), (134.725, -6.214)], [(117.882, 4.138), (117.313, 3.234), (118.048, 2.288), (117.876, 1.828), (118.997, 0.902), (117.812, 0.784), (117.478, 0.102), (117.522, -0.804), (116.56, -1.488), (116.534, -2.484), (116.148, -4.013), (116.001, -3.657), (114.865, -4.107), (114.469, -3.496), (113.756, -3.439), (113.257, -3.119), (112.068, -3.478), (111.703, -2.994), (111.048, -3.049), (110.224, -2.934), (110.071, -1.593), (109.572, -1.315), (109.092, -0.46), (108.953, 0.415), (109.069, 1.342), (109.663, 2.006), (109.83, 1.338), (110.514, 0.773), (111.159, 0.976), (111.798, 0.904), (112.38, 1.41), (112.86, 1.498), (113.806, 1.218), (114.621, 1.431), (115.134, 2.821), (115.519, 3.169), (115.866, 4.307), (117.015, 4.306)], [(129.371, -2.802), (130.471, -3.094), (130.835, -3.858), (129.991, -3.446), (129.155, -3.363), (128.591, -3.429), (127.899, -3.393), (128.136, -2.844)], [(126.875, -3.791), (126.184, -3.607), (125.989, -3.177), (127.001, -3.129), (127.249, -3.459)], [(127.932, 2.175), (128.004, 1.629), (128.595, 1.541), (128.688, 1.132), (128.636, 0.258), (128.12, 0.356), (127.968, -0.252), (128.38, -0.78), (128.1, -0.9), (127.696, -0.267), (127.399, 1.012), (127.601, 1.811)], [(122.928, 0.875), (124.078, 0.917), (125.066, 1.643), (125.241, 1.42), (124.437, 0.428), (123.686, 0.236), (122.723, 0.431), (121.057, 0.381), (120.183, 0.237), (120.041, -0.52), (120.936, -1.409), (121.476, -0.956), (123.341, -0.616), (123.258, -1.076), (122.823, -0.931), (122.389, -1.517), (121.508, -1.904), (122.455, -3.186), (122.272, -3.53), (123.171, -4.684), (123.162, -5.341), (122.629, -5.635), (122.236, -5.283), (122.72, -4.464), (121.738, -4.851), (121.489, -4.575), (121.619, -4.188), (120.898, -3.602), (120.972, -2.628), (120.305, -2.932), (120.39, -4.098), (120.431, -5.528), (119.797, -5.673), (119.367, -5.38), (119.654, -4.459), (119.499, -3.494), (119.078, -3.487), (118.768, -2.802), (119.181, -2.147), (119.323, -1.353), (119.826, 0.154), (120.036, 0.566), (120.886, 1.309), (121.667, 1.014)], [(120.295, -10.259), (118.968, -9.558), (119.9, -9.361), (120.426, -9.666), (120.776, -9.97), (120.716, -10.24)], [(121.342, -8.537), (122.007, -8.461), (122.904, -8.094), (122.757, -8.65), (121.254, -8.934), (119.924, -8.81), (119.921, -8.445), (120.715, -8.237)], [(118.261, -8.362), (118.878, -8.281), (119.127, -8.706), (117.97, -8.907), (117.278, -9.041), (116.74, -9.033), (117.084, -8.457), (117.632, -8.449), (117.9, -8.096)], [(108.487, -6.422), (108.623, -6.778), (110.539, -6.877), (110.76, -6.465), (112.615, -6.946), (112.979, -7.594), (114.479, -7.777), (115.706, -8.371), (114.565, -8.752), (113.465, -8.349), (112.56, -8.376), (111.522, -8.302), (110.586, -8.123), (109.428, -7.741), (108.694, -7.642), (108.278, -7.767), (106.454, -7.355), (106.281, -6.925), (105.365, -6.851), (106.052, -5.896), (107.265, -5.955), (108.072, -6.346)], [(104.37, -1.085), (104.539, -1.782), (104.888, -2.34), (105.622, -2.429), (106.109, -3.062), (105.857, -4.306), (105.818, -5.852), (104.71, -5.873), (103.868, -5.037), (102.584, -4.22), (102.156, -3.614), (101.399, -2.8), (100.903, -2.05), (100.142, -0.65), (99.264, 0.183), (98.97, 1.043), (98.601, 1.824), (97.7, 2.453), (97.177, 3.309), (96.424, 3.869), (95.381, 4.971), (95.293, 5.48), (95.937, 5.44), (97.485, 5.246), (98.369, 4.268), (99.143, 3.59), (99.694, 3.174), (100.641, 2.099), (101.658, 2.084), (102.498, 1.399), (103.077, 0.561), (103.838, 0.105), (103.438, -0.712), (104.011, -1.059)]]], ['AR', [[(-68.634, -52.636), (-68.25, -53.1), (-67.75, -53.85), (-66.45, -54.45), (-65.05, -54.7), (-65.5, -55.2), (-66.45, -55.25), (-66.96, -54.897), (-67.562, -54.87), (-68.633, -54.87)], [(-57.625, -30.216), (-57.875, -31.017), (-58.142, -32.045), (-58.133, -33.041), (-58.35, -33.263), (-58.427, -33.909), (-58.495, -34.431), (-57.226, -35.288), (-57.362, -35.977), (-56.737, -36.413), (-56.788, -36.902), (-57.749, -38.184), (-59.232, -38.72), (-61.237, -38.928), (-62.336, -38.828), (-62.126, -39.424), (-62.331, -40.173), (-62.146, -40.677), (-62.746, -41.029), (-63.77, -41.167), (-64.732, -40.803), (-65.118, -41.064), (-64.979, -42.058), (-64.303, -42.359), (-63.756, -42.044), (-63.458, -42.563), (-64.379, -42.874), (-65.182, -43.495), (-65.329, -44.501), (-65.565, -45.037), (-66.51, -45.04), (-67.294, -45.552), (-67.581, -46.302), (-66.597, -47.034), (-65.641, -47.236), (-65.985, -48.133), (-67.166, -48.697), (-67.816, -49.87), (-68.729, -50.264), (-69.139, -50.733), (-68.816, -51.771), (-68.15, -52.35), (-68.572, -52.299), (-69.498, -52.143), (-71.915, -52.009), (-72.329, -51.426), (-72.31, -50.677), (-72.976, -50.741), (-73.328, -50.379), (-73.415, -49.318), (-72.648, -48.879), (-72.331, -48.244), (-72.447, -47.739), (-71.917, -46.885), (-71.552, -45.561), (-71.659, -44.974), (-71.223, -44.784), (-71.33, -44.408), (-71.794, -44.207), (-71.464, -43.788), (-71.915, -43.409), (-72.149, -42.255), (-71.747, -42.051), (-71.916, -40.832), (-71.681, -39.808), (-71.414, -38.916), (-70.815, -38.553), (-71.119, -37.577), (-71.122, -36.658), (-70.365, -36.005), (-70.388, -35.17), (-69.817, -34.194), (-69.815, -33.274), (-70.074, -33.091), (-70.535, -31.365), (-69.919, -30.336), (-70.014, -29.368), (-69.656, -28.459), (-69.001, -27.521), (-68.296, -26.899), (-68.595, -26.507), (-68.386, -26.185), (-68.418, -24.519), (-67.328, -24.025), (-66.985, -22.986), (-67.107, -22.736), (-66.273, -21.832), (-64.965, -22.076), (-64.377, -22.798), (-63.987, -21.994), (-62.846, -22.035), (-62.685, -22.249), (-60.847, -23.881), (-60.029, -24.033), (-58.807, -24.771), (-57.777, -25.162), (-57.634, -25.604), (-58.618, -27.124), (-57.61, -27.396), (-56.487, -27.548), (-55.696, -27.388), (-54.789, -26.622), (-54.625, -25.739), (-54.13, -25.548), (-53.628, -26.125), (-53.649, -26.923), (-54.491, -27.475), (-55.162, -27.882), (-56.291, -28.853)]]], ['CL', [[(-68.634, -52.636), (-68.633, -54.87), (-67.562, -54.87), (-66.96, -54.897), (-67.291, -55.301), (-68.149, -55.612), (-68.64, -55.58), (-69.232, -55.499), (-69.958, -55.198), (-71.006, -55.054), (-72.264, -54.495), (-73.285, -53.958), (-74.663, -52.837), (-73.838, -53.047), (-72.434, -53.715), (-71.108, -54.074), (-70.592, -53.616), (-70.267, -52.931), (-69.346, -52.518)], [(-69.59, -17.58), (-69.1, -18.26), (-68.967, -18.982), (-68.442, -19.405), (-68.757, -20.373), (-68.22, -21.494), (-67.828, -22.873), (-67.107, -22.736), (-66.985, -22.986), (-67.328, -24.025), (-68.418, -24.519), (-68.386, -26.185), (-68.595, -26.507), (-68.296, -26.899), (-69.001, -27.521), (-69.656, -28.459), (-70.014, -29.368), (-69.919, -30.336), (-70.535, -31.365), (-70.074, -33.091), (-69.815, -33.274), (-69.817, -34.194), (-70.388, -35.17), (-70.365, -36.005), (-71.122, -36.658), (-71.119, -37.577), (-70.815, -38.553), (-71.414, -38.916), (-71.681, -39.808), (-71.916, -40.832), (-71.747, -42.051), (-72.149, -42.255), (-71.915, -43.409), (-71.464, -43.788), (-71.794, -44.207), (-71.33, -44.408), (-71.223, -44.784), (-71.659, -44.974), (-71.552, -45.561), (-71.917, -46.885), (-72.447, -47.739), (-72.331, -48.244), (-72.648, -48.879), (-73.415, -49.318), (-73.328, -50.379), (-72.976, -50.741), (-72.31, -50.677), (-72.329, -51.426), (-71.915, -52.009), (-69.498, -52.143), (-68.572, -52.299), (-69.461, -52.292), (-69.943, -52.538), (-70.845, -52.899), (-71.006, -53.833), (-71.43, -53.856), (-72.558, -53.531), (-73.703, -52.835), (-73.703, -52.835), (-74.947, -52.263), (-75.26, -51.629), (-74.977, -51.043), (-75.48, -50.378), (-75.608, -48.674), (-75.183, -47.712), (-74.127, -46.939), (-75.644, -46.648), (-74.692, -45.764), (-74.352, -44.103), (-73.24, -44.455), (-72.718, -42.383), (-73.389, -42.118), (-73.701, -43.366), (-74.332, -43.225), (-74.018, -41.795), (-73.677, -39.942), (-73.218, -39.259), (-73.506, -38.283), (-73.588, -37.156), (-73.167, -37.124), (-72.553, -35.509), (-71.862, -33.909), (-71.438, -32.419), (-71.669, -30.921), (-71.37, -30.096), (-71.49, -28.861), (-70.905, -27.64), (-70.725, -25.706), (-70.404, -23.629), (-70.091, -21.393), (-70.164, -19.756), (-70.373, -18.348), (-69.858, -18.093)]]], ['DRC', [[(30.522, -8.284), (30.346, -8.238), (29.003, -8.407), (28.735, -8.527), (28.45, -9.165), (28.674, -9.606), (28.496, -10.79), (28.372, -11.794), (28.642, -11.972), (29.342, -12.361), (29.616, -12.179), (29.7, -13.257), (28.934, -13.249), (28.524, -12.699), (28.155, -12.272), (27.389, -12.133), (27.164, -11.609), (26.553, -11.924), (25.752, -11.785), (25.418, -11.331), (24.783, -11.239), (24.315, -11.263), (24.257, -10.952), (23.912, -10.927), (23.457, -10.868), (22.837, -11.018), (22.403, -10.993), (22.155, -11.085), (22.209, -9.895), (21.875, -9.524), (21.802, -8.909), (21.949, -8.306), (21.746, -7.92), (21.728, -7.291), (20.515, -7.3), (20.602, -6.939), (20.092, -6.943), (20.038, -7.116), (19.418, -7.155), (19.167, -7.738), (19.017, -7.988), (18.464, -7.847), (18.134, -7.988), (17.473, -8.069), (17.09, -7.546), (16.86, -7.222), (16.573, -6.623), (16.327, -5.877), (13.376, -5.864), (13.025, -5.984), (12.735, -5.966), (12.322, -6.1), (12.182, -5.79), (12.437, -5.684), (12.468, -5.248), (12.632, -4.991), (12.996, -4.781), (13.258, -4.883), (13.6, -4.5), (14.145, -4.51), (14.209, -4.793), (14.583, -4.97), (15.171, -4.344), (15.754, -3.855), (16.006, -3.535), (15.973, -2.712), (16.407, -1.741), (16.865, -1.226), (17.524, -0.744), (17.639, -0.425), (17.664, -0.058), (17.827, 0.289), (17.774, 0.856), (17.899, 1.742), (18.094, 2.366), (18.394, 2.9), (18.453, 3.504), (18.543, 4.202), (18.932, 4.71), (19.468, 5.032), (20.291, 4.692), (20.928, 4.323), (21.659, 4.224), (22.405, 4.029), (22.704, 4.633), (22.841, 4.71), (23.297, 4.61), (24.411, 5.109), (24.805, 4.897), (25.129, 4.927), (25.279, 5.17), (25.65, 5.256), (26.403, 5.151), (27.044, 5.128), (27.374, 5.234), (27.98, 4.408), (28.429, 4.287), (28.697, 4.455), (29.159, 4.389), (29.716, 4.601), (29.953, 4.174), (30.834, 3.509), (30.834, 3.509), (30.773, 2.34), (31.174, 2.204), (30.853, 1.849), (30.469, 1.584), (30.086, 1.062), (29.876, 0.597), (29.82, -0.205), (29.588, -0.587), (29.579, -1.341), (29.292, -1.62), (29.255, -2.215), (29.117, -2.292), (29.025, -2.839), (29.276, -3.294), (29.286, -3.467), (29.281, -3.455), (29.102, -5.054), (29.372, -5.616), (29.193, -6.038), (29.537, -6.754), (30.147, -7.299), (30.277, -7.848), (30.567, -8.115)]]], ['SO', [[(41.585, -1.683), (40.993, -0.858), (40.981, 2.785), (41.855, 3.919), (42.129, 4.234), (42.77, 4.253), (43.661, 4.958), (44.964, 5.002), (47.789, 8.003), (48.487, 8.838), (48.938, 9.452), (48.938, 9.973), (48.938, 10.982), (48.942, 11.394), (48.948, 11.411), (49.268, 11.43), (49.729, 11.579), (50.259, 11.68), (50.732, 12.022), (51.111, 12.025), (51.134, 11.748), (51.042, 11.167), (51.045, 10.641), (50.834, 10.28), (50.552, 9.199), (50.071, 8.082), (49.453, 6.805), (48.595, 5.339), (47.741, 4.219), (46.565, 2.855), (45.564, 2.046), (44.068, 1.053), (43.136, 0.292), (42.042, -0.919), (41.811, -1.446)]]], ['KE', [[(39.202, -4.677), (37.767, -3.677), (37.699, -3.097), (34.073, -1.06), (34.136, -0.319), (33.894, 0.06), (33.894, 0.11), (34.18, 0.515), (34.672, 1.177), (35.036, 1.906), (34.596, 3.054), (34.479, 3.556), (34.005, 4.25), (34.62, 4.847), (35.298, 5.506), (35.817, 5.338), (35.817, 4.777), (36.159, 4.448), (36.855, 4.448), (38.121, 3.599), (38.437, 3.589), (38.671, 3.616), (38.893, 3.501), (39.559, 3.422), (39.855, 3.839), (40.768, 4.257), (41.172, 3.919), (41.855, 3.919), (40.981, 2.785), (40.993, -0.858), (41.585, -1.683), (40.885, -2.083), (40.638, -2.5), (40.263, -2.573), (40.121, -3.278), (39.8, -3.681), (39.605, -4.347)]]], ['SD', [[(23.887, 8.62), (23.806, 8.666), (23.459, 8.954), (23.395, 9.265), (23.557, 9.681), (23.554, 10.089), (22.978, 10.714), (22.864, 11.142), (22.876, 11.385), (22.509, 11.679), (22.498, 12.26), (22.288, 12.646), (21.937, 12.588), (22.038, 12.955), (22.297, 13.372), (22.183, 13.786), (22.512, 14.093), (22.304, 14.327), (22.568, 14.944), (23.025, 15.681), (23.887, 15.611), (23.838, 19.58), (23.85, 20.0), (25.0, 20.003), (25.0, 22.0), (29.02, 22.0), (32.9, 22.0), (36.866, 22.0), (37.189, 21.019), (36.969, 20.837), (37.115, 19.808), (37.482, 18.614), (37.863, 18.368), (38.41, 17.998), (37.904, 17.428), (37.167, 17.263), (36.853, 16.957), (36.754, 16.292), (36.323, 14.822), (36.43, 14.422), (36.27, 13.563), (35.864, 12.578), (35.26, 12.083), (34.832, 11.319), (34.731, 10.91), (34.257, 10.63), (33.962, 9.584), (33.963, 9.464), (33.825, 9.484), (33.842, 9.982), (33.722, 10.325), (33.207, 10.72), (33.087, 11.441), (33.207, 12.179), (32.743, 12.248), (32.675, 12.025), (32.074, 11.973), (32.314, 11.681), (32.4, 11.081), (31.851, 10.531), (31.353, 9.81), (30.838, 9.707), (29.997, 10.291), (29.619, 10.085), (29.516, 9.793), (29.001, 9.604), (28.967, 9.398), (27.971, 9.398), (27.834, 9.604), (27.113, 9.639), (26.752, 9.467), (26.477, 9.553), (25.962, 10.136), (25.791, 10.411), (25.07, 10.274), (24.795, 9.81), (24.537, 8.918), (24.194, 8.729)]]], ['TD', [[(23.838, 19.58), (23.887, 15.611), (23.025, 15.681), (22.568, 14.944), (22.304, 14.327), (22.512, 14.093), (22.183, 13.786), (22.297, 13.372), (22.038, 12.955), (21.937, 12.588), (22.288, 12.646), (22.498, 12.26), (22.509, 11.679), (22.876, 11.385), (22.864, 11.142), (22.231, 10.972), (21.724, 10.567), (21.001, 9.476), (20.06, 9.013), (19.094, 9.075), (18.812, 8.983), (18.911, 8.631), (18.39, 8.281), (17.965, 7.891), (16.706, 7.508), (16.456, 7.735), (16.291, 7.754), (16.106, 7.497), (15.279, 7.422), (15.436, 7.693), (15.121, 8.382), (14.98, 8.796), (14.544, 8.966), (13.954, 9.549), (14.171, 10.021), (14.627, 9.921), (14.909, 9.992), (15.468, 9.982), (14.924, 10.891), (14.96, 11.556), (14.893, 12.219), (14.496, 12.859), (14.596, 13.33), (13.954, 13.353), (13.957, 13.997), (13.54, 14.367), (13.972, 15.684), (15.248, 16.627), (15.3, 17.928), (15.686, 19.957), (15.903, 20.388), (15.487, 20.73), (15.471, 21.048), (15.097, 21.309), (14.851, 22.863), (15.861, 23.41)]]], ['RUS', [[(178.725, 71.099), (180.0, 71.516), (180.0, 70.832), (178.903, 70.781)], [(49.101, 46.399), (48.645, 45.806), (47.676, 45.641), (46.682, 44.609), (47.591, 43.66), (47.493, 42.987), (48.584, 41.809), (48.584, 41.809), (47.987, 41.406), (47.816, 41.151), (47.373, 41.22), (46.686, 41.827), (46.405, 41.861), (45.776, 42.092), (45.47, 42.503), (44.538, 42.712), (43.931, 42.555), (43.756, 42.741), (42.394, 43.22), (40.922, 43.382), (40.077, 43.553), (39.955, 43.435), (38.68, 44.28), (37.539, 44.657), (36.675, 45.245), (37.403, 45.405), (38.233, 46.241), (37.674, 46.637), (39.148, 47.045), (39.121, 47.263), (38.224, 47.102), (38.255, 47.546), (38.771, 47.826), (39.738, 47.899), (39.896, 48.232), (39.675, 48.784), (40.081, 49.307), (40.069, 49.601), (38.595, 49.926), (38.011, 49.916), (37.393, 50.384), (36.626, 50.226), (35.356, 50.577), (35.378, 50.774), (35.022, 51.208), (34.225, 51.256), (34.142, 51.566), (34.392, 51.769), (33.753, 52.335), (32.716, 52.238), (32.412, 52.289), (32.159, 52.061), (31.786, 52.102), (31.786, 52.102), (31.54, 52.742), (31.305, 53.074), (31.498, 53.167), (32.305, 53.133), (32.694, 53.351), (32.406, 53.618), (31.731, 53.794), (31.791, 53.975), (31.384, 54.157), (30.758, 54.812), (30.972, 55.082), (30.874, 55.551), (29.896, 55.789), (29.372, 55.67), (29.23, 55.918), (28.177, 56.169), (27.855, 56.759), (27.77, 57.244), (27.288, 57.475), (27.717, 57.792), (27.42, 58.725), (28.132, 59.301), (27.981, 59.475), (27.981, 59.475), (29.118, 60.028), (28.07, 60.504), (28.07, 60.504), (30.211, 61.78), (31.14, 62.358), (31.516, 62.868), (30.036, 63.553), (30.445, 64.204), (29.544, 64.949), (30.218, 65.806), (29.055, 66.944), (29.977, 67.698), (28.446, 68.365), (28.592, 69.065), (29.4, 69.157), (31.101, 69.558), (31.101, 69.558), (32.133, 69.906), (33.775, 69.301), (36.514, 69.063), (40.292, 67.932), (41.06, 67.457), (41.126, 66.792), (40.016, 66.266), (38.383, 66.0), (33.919, 66.76), (33.184, 66.633), (34.815, 65.9), (34.879, 65.436), (34.944, 64.414), (36.231, 64.109), (37.013, 63.85), (37.142, 64.335), (36.54, 64.764), (37.176, 65.143), (39.593, 64.521), (40.436, 64.764), (39.763, 65.497), (42.093, 66.476), (43.016, 66.419), (43.95, 66.069), (44.532, 66.756), (43.698, 67.352), (44.188, 67.951), (43.453, 68.571), (46.25, 68.25), (46.821, 67.69), (45.555, 67.567), (45.562, 67.01), (46.349, 66.668), (47.894, 66.885), (48.139, 67.522), (50.228, 67.999), (53.717, 68.857), (54.472, 68.808), (53.486, 68.201), (54.726, 68.097), (55.443, 68.439), (57.317, 68.466), (58.802, 68.881), (59.941, 68.278), (61.078, 68.941), (60.03, 69.52), (60.55, 69.85), (63.504, 69.547), (64.888, 69.235), (68.512, 68.092), (69.181, 68.616), (68.164, 69.144), (68.135, 69.356), (66.93, 69.455), (67.26, 69.929), (66.725, 70.709), (66.695, 71.029), (68.54, 71.934), (69.196, 72.843), (69.94, 73.04), (72.588, 72.776), (72.796, 72.22), (71.848, 71.409), (72.47, 71.09), (72.792, 70.391), (72.565, 69.021), (73.668, 68.408), (73.239, 67.74), (71.28, 66.32), (72.423, 66.173), (72.821, 66.533), (73.921, 66.789), (74.187, 67.284), (75.052, 67.76), (74.469, 68.329), (74.936, 68.989), (73.842, 69.071), (73.602, 69.628), (74.4, 70.632), (73.101, 71.447), (74.891, 72.121), (74.659, 72.832), (75.158, 72.855), (75.684, 72.301), (75.289, 71.336), (76.359, 71.153), (75.903, 71.874), (77.577, 72.267), (79.652, 72.32), (81.5, 71.75), (80.611, 72.583), (80.511, 73.648), (82.25, 73.85), (84.655, 73.806), (86.822, 73.937), (86.01, 74.46), (87.167, 75.116), (88.316, 75.144), (90.26, 75.64), (92.901, 75.773), (93.234, 76.047), (95.86, 76.14), (96.678, 75.915), (98.923, 76.447), (100.76, 76.43), (101.035, 76.862), (101.991, 77.288), (104.352, 77.698), (106.067, 77.374), (104.705, 77.127), (106.97, 76.974), (107.24, 76.48), (108.154, 76.723), (111.077, 76.71), (113.332, 76.222), (114.134, 75.848), (113.885, 75.328), (112.779, 75.032), (110.151, 74.477), (109.4, 74.18), (110.64, 74.04), (112.119, 73.788), (113.02, 73.977), (113.53, 73.335), (113.969, 73.595), (115.568, 73.753), (118.776, 73.588), (119.02, 73.12), (123.201, 72.971), (123.258, 73.735), (125.38, 73.56), (126.976, 73.565), (128.591, 73.039), (129.052, 72.399), (128.46, 71.98), (129.716, 71.193), (131.289, 70.787), (132.254, 71.836), (133.858, 71.386), (135.562, 71.655), (137.498, 71.348), (138.234, 71.628), (139.87, 71.488), (139.148, 72.416), (140.468, 72.849), (149.5, 72.2), (150.351, 71.606), (152.969, 70.842), (157.007, 71.031), (158.998, 70.867), (159.83, 70.453), (159.709, 69.722), (160.941, 69.437), (162.279, 69.642), (164.052, 69.668), (165.94, 69.472), (167.836, 69.583), (169.578, 68.694), (170.817, 69.014), (170.008, 69.653), (170.453, 70.097), (173.644, 69.817), (175.724, 69.877), (178.6, 69.4), (180.0, 68.964), (180.0, 64.98), (179.993, 64.974), (178.707, 64.535), (177.411, 64.608), (178.313, 64.076), (178.908, 63.252), (179.37, 62.983), (179.486, 62.569), (179.228, 62.304), (177.364, 62.522), (174.569, 61.769), (173.68, 61.653), (172.15, 60.95), (170.698, 60.336), (170.331, 59.882), (168.9, 60.574), (166.295, 59.789), (165.84, 60.16), (164.877, 59.732), (163.539, 59.869), (163.217, 59.211), (162.017, 58.243), (162.053, 57.839), (163.192, 57.615), (163.058, 56.159), (162.13, 56.122), (161.701, 55.286), (162.117, 54.855), (160.369, 54.344), (160.022, 53.203), (158.531, 52.959), (158.231, 51.943), (156.79, 51.011), (156.42, 51.7), (155.992, 53.159), (155.434, 55.381), (155.914, 56.768), (156.758, 57.365), (156.81, 57.832), (158.364, 58.056), (160.151, 59.315), (161.872, 60.343), (163.67, 61.141), (164.474, 62.551), (163.258, 62.466), (162.658, 61.642), (160.121, 60.544), (159.302, 61.774), (156.721, 61.434), (154.218, 59.758), (155.044, 59.145), (152.812, 58.884), (151.266, 58.781), (151.338, 59.504), (149.784, 59.656), (148.545, 59.164), (145.487, 59.336), (142.198, 59.04), (138.958, 57.088), (135.126, 54.73), (136.702, 54.604), (137.193, 53.977), (138.165, 53.755), (138.805, 54.255), (139.902, 54.19), (141.345, 53.09), (141.379, 52.239), (140.597, 51.24), (140.513, 50.046), (140.062, 48.447), (138.555, 47.0), (138.22, 46.308), (136.862, 45.144), (135.515, 43.989), (134.869, 43.398), (133.537, 42.811), (132.906, 42.798), (132.278, 43.285), (130.936, 42.553), (130.78, 42.22), (130.78, 42.22), (130.78, 42.22), (130.78, 42.22), (130.64, 42.395), (130.64, 42.395), (130.634, 42.903), (131.145, 42.93), (131.289, 44.112), (131.025, 44.968), (131.883, 45.321), (133.097, 45.144), (133.77, 46.117), (134.112, 47.212), (134.501, 47.578), (135.026, 48.478), (133.374, 48.183), (132.507, 47.789), (130.987, 47.79), (130.582, 48.73), (129.398, 49.441), (127.657, 49.76), (127.287, 50.74), (126.939, 51.354), (126.564, 51.784), (125.946, 52.793), (125.068, 53.161), (123.571, 53.459), (122.246, 53.432), (121.003, 53.251), (120.177, 52.754), (120.726, 52.516), (120.738, 51.964), (120.182, 51.644), (119.279, 50.583), (119.288, 50.143), (117.879, 49.511), (116.679, 49.889), (115.486, 49.805), (114.962, 50.14), (114.362, 50.248), (112.898, 49.544), (111.581, 49.378), (110.662, 49.13), (109.402, 49.293), (108.475, 49.283), (107.868, 49.794), (106.889, 50.274), (105.887, 50.406), (104.622, 50.275), (103.677, 50.09), (102.256, 50.511), (102.065, 51.26), (100.889, 51.517), (99.982, 51.634), (98.861, 52.047), (97.826, 51.011), (98.232, 50.422), (97.26, 49.726), (95.814, 49.977), (94.816, 50.013), (94.148, 50.481), (93.104, 50.495), (92.235, 50.802), (90.714, 50.332), (88.806, 49.471), (87.751, 49.297), (87.36, 49.215), (86.829, 49.827), (85.541, 49.693), (85.116, 50.117), (84.416, 50.311), (83.935, 50.889), (83.383, 51.069), (81.946, 50.812), (80.568, 51.388), (80.036, 50.865), (77.801, 53.404), (76.525, 54.177), (76.891, 54.491), (74.385, 53.547), (73.426, 53.49), (73.509, 54.036), (72.224, 54.377), (71.18, 54.133), (70.865, 55.17), (69.068, 55.385), (68.169, 54.97), (65.667, 54.601), (65.179, 54.354), (61.437, 54.006), (60.978, 53.665), (61.7, 52.98), (60.74, 52.72), (60.927, 52.448), (59.968, 51.96), (61.588, 51.273), (61.337, 50.799), (59.933, 50.842), (59.642, 50.545), (58.363, 51.064), (56.778, 51.044), (55.717, 50.622), (54.533, 51.026), (52.329, 51.719), (50.767, 51.693), (48.702, 50.605), (48.578, 49.875), (47.549, 50.455), (46.752, 49.356), (47.044, 49.152), (46.466, 48.394), (47.315, 47.716), (48.057, 47.744), (48.695, 47.076), (48.593, 46.561)], [(93.778, 81.025), (95.941, 81.25), (97.884, 80.747), (100.187, 79.78), (99.94, 78.881), (97.758, 78.756), (94.973, 79.045), (93.313, 79.427), (92.545, 80.144), (91.181, 80.341)], [(102.838, 79.281), (105.372, 78.713), (105.075, 78.307), (99.438, 77.921), (101.265, 79.234), (102.086, 79.346)], [(138.831, 76.137), (141.472, 76.093), (145.086, 75.563), (144.3, 74.82), (140.614, 74.848), (138.955, 74.611), (136.974, 75.262), (137.512, 75.949)], [(148.222, 75.346), (150.732, 75.084), (149.576, 74.689), (147.977, 74.778), (146.119, 75.173), (146.358, 75.497)], [(139.863, 73.37), (140.812, 73.765), (142.062, 73.858), (143.483, 73.475), (143.604, 73.212), (142.088, 73.205), (140.038, 73.317)], [(44.847, 80.59), (46.799, 80.772), (48.318, 80.784), (48.523, 80.515), (49.097, 80.754), (50.04, 80.919), (51.523, 80.7), (51.136, 80.547), (49.794, 80.415), (48.894, 80.34), (48.755, 80.175), (47.586, 80.01), (46.503, 80.247), (47.072, 80.559)], [(22.731, 54.328), (20.892, 54.313), (19.661, 54.426), (19.888, 54.866), (21.268, 55.19), (22.316, 55.015), (22.758, 54.857), (22.651, 54.583)], [(53.508, 73.75), (55.902, 74.627), (55.632, 75.081), (57.869, 75.609), (61.17, 76.252), (64.498, 76.439), (66.211, 76.81), (68.157, 76.94), (68.852, 76.545), (68.181, 76.234), (64.637, 75.738), (61.584, 75.261), (58.477, 74.309), (56.987, 73.333), (55.419, 72.371), (55.623, 71.541), (57.536, 70.72), (56.945, 70.633), (53.677, 70.763), (53.412, 71.207), (51.602, 71.475), (51.456, 72.015), (52.478, 72.229), (52.444, 72.775), (54.428, 73.628)], [(142.915, 53.705), (143.261, 52.741), (143.235, 51.757), (143.648, 50.748), (144.654, 48.976), (143.174, 49.307), (142.559, 47.862), (143.533, 46.837), (143.505, 46.138), (142.748, 46.741), (142.092, 45.967), (141.907, 46.806), (142.018, 47.78), (141.904, 48.859), (142.136, 49.615), (142.18, 50.952), (141.594, 51.935), (141.683, 53.302), (142.607, 53.762), (142.21, 54.225), (142.655, 54.366)], [(-174.928, 67.206), (-175.014, 66.584), (-174.34, 66.336), (-174.572, 67.062), (-171.857, 66.913), (-169.9, 65.977), (-170.891, 65.541), (-172.53, 65.438), (-172.555, 64.461), (-172.955, 64.253), (-173.892, 64.283), (-174.654, 64.631), (-175.984, 64.923), (-176.207, 65.357), (-177.223, 65.52), (-178.36, 65.391), (-178.903, 65.74), (-178.686, 66.112), (-179.884, 65.875), (-179.433, 65.404), (-180.0, 64.98), (-180.0, 68.964), (-177.55, 68.2)], [(-178.694, 70.893), (-180.0, 70.832), (-180.0, 71.516), (-179.872, 71.558), (-179.024, 71.556), (-177.578, 71.269), (-177.664, 71.133)], [(33.436, 45.972), (33.699, 46.22), (34.41, 46.005), (34.732, 45.966), (34.862, 45.768), (35.013, 45.738), (35.021, 45.651), (35.51, 45.41), (36.53, 45.47), (36.335, 45.113), (35.24, 44.94), (33.883, 44.361), (33.326, 44.565), (33.547, 45.035), (32.454, 45.327), (32.631, 45.519), (33.588, 45.852)]]], ['FK', [[(-61.2, -51.85), (-60.0, -51.25), (-59.15, -51.5), (-58.55, -51.1), (-57.75, -51.55), (-58.05, -51.9), (-59.4, -52.2), (-59.85, -51.85), (-60.7, -52.3)]]], ['N', [[(15.143, 79.674), (15.523, 80.016), (16.991, 80.051), (18.252, 79.702), (21.544, 78.956), (19.027, 78.563), (18.472, 77.827), (17.594, 77.638), (17.118, 76.809), (15.913, 76.77), (13.763, 77.38), (14.67, 77.736), (13.171, 78.025), (11.222, 78.869), (10.445, 79.652), (13.171, 80.01), (13.719, 79.66)], [(31.101, 69.558), (29.4, 69.157), (28.592, 69.065), (29.016, 69.766), (27.732, 70.164), (26.18, 69.825), (25.689, 69.092), (24.736, 68.65), (23.662, 68.891), (22.356, 68.842), (21.245, 69.37), (20.646, 69.106), (20.025, 69.065), (19.879, 68.407), (17.994, 68.567), (17.729, 68.011), (16.769, 68.014), (16.109, 67.302), (15.108, 66.194), (13.556, 64.787), (13.92, 64.445), (13.572, 64.049), (12.58, 64.066), (11.931, 63.128), (11.992, 61.8), (12.631, 61.294), (12.3, 60.118), (11.468, 59.432), (11.027, 58.856), (10.357, 59.47), (8.382, 58.313), (7.049, 58.079), (5.666, 58.588), (5.308, 59.663), (4.992, 61.971), (5.913, 62.614), (8.553, 63.454), (10.528, 64.486), (12.358, 65.88), (14.761, 67.811), (16.436, 68.563), (19.184, 69.817), (21.378, 70.255), (23.024, 70.202), (24.547, 71.03), (26.37, 70.986), (28.166, 71.185), (31.293, 70.454), (30.005, 70.186)], [(27.408, 80.056), (25.925, 79.518), (23.024, 79.4), (20.075, 79.567), (19.897, 79.842), (18.462, 79.86), (17.368, 80.319), (20.456, 80.598), (21.908, 80.358), (22.919, 80.657), (25.448, 80.407)], [(24.724, 77.854), (22.49, 77.445), (20.726, 77.677), (21.416, 77.935), (20.812, 78.255), (22.884, 78.455), (23.281, 78.08)]]], ['GL', [[(-46.764, 82.628), (-43.406, 83.225), (-39.898, 83.18), (-38.622, 83.549), (-35.088, 83.645), (-27.1, 83.52), (-20.845, 82.727), (-22.692, 82.342), (-26.518, 82.298), (-31.9, 82.2), (-31.396, 82.022), (-27.857, 82.132), (-24.844, 81.787), (-22.903, 82.093), (-22.072, 81.734), (-23.17, 81.153), (-20.624, 81.525), (-15.768, 81.912), (-12.77, 81.719), (-12.209, 81.292), (-16.285, 80.58), (-16.85, 80.35), (-20.046, 80.177), (-17.73, 80.129), (-18.9, 79.4), (-19.705, 78.751), (-19.674, 77.639), (-18.473, 76.986), (-20.035, 76.944), (-21.679, 76.628), (-19.834, 76.098), (-19.599, 75.248), (-20.668, 75.156), (-19.373, 74.296), (-21.594, 74.224), (-20.435, 73.817), (-20.762, 73.464), (-22.172, 73.31), (-23.566, 73.307), (-22.313, 72.629), (-22.3, 72.184), (-24.278, 72.598), (-24.793, 72.33), (-23.443, 72.08), (-22.133, 71.469), (-21.754, 70.664), (-23.536, 70.471), (-24.307, 70.856), (-25.543, 71.431), (-25.201, 70.752), (-26.363, 70.226), (-23.727, 70.184), (-22.349, 70.129), (-25.029, 69.259), (-27.747, 68.47), (-30.674, 68.125), (-31.777, 68.121), (-32.811, 67.735), (-34.202, 66.68), (-36.353, 65.979), (-37.044, 65.938), (-38.375, 65.692), (-39.812, 65.458), (-40.669, 64.84), (-40.683, 64.139), (-41.189, 63.482), (-42.819, 62.682), (-42.417, 61.901), (-42.866, 61.074), (-43.378, 60.098), (-44.788, 60.037), (-46.264, 60.853), (-48.263, 60.858), (-49.233, 61.407), (-49.9, 62.383), (-51.633, 63.627), (-52.14, 64.278), (-52.277, 65.177), (-53.662, 66.1), (-53.302, 66.837), (-53.969, 67.189), (-52.98, 68.358), (-51.475, 68.73), (-51.08, 69.148), (-50.871, 69.929), (-52.014, 69.575), (-52.558, 69.426), (-53.456, 69.284), (-54.683, 69.61), (-54.75, 70.289), (-54.359, 70.821), (-53.431, 70.836), (-51.39, 70.57), (-53.109, 71.205), (-54.004, 71.547), (-55.0, 71.407), (-55.835, 71.654), (-54.718, 72.586), (-55.326, 72.959), (-56.12, 73.65), (-57.324, 74.71), (-58.597, 75.099), (-58.585, 75.517), (-61.269, 76.102), (-63.392, 76.175), (-66.064, 76.135), (-68.504, 76.061), (-69.665, 76.38), (-71.403, 77.009), (-68.777, 77.323), (-66.764, 77.376), (-71.043, 77.636), (-73.297, 78.044), (-73.159, 78.433), (-69.373, 78.914), (-65.711, 79.394), (-65.324, 79.758), (-68.023, 80.117), (-67.151, 80.516), (-63.689, 81.214), (-62.234, 81.321), (-62.651, 81.77), (-60.282, 82.034), (-57.207, 82.191), (-54.134, 82.2), (-53.043, 81.888), (-50.391, 82.439), (-48.004, 82.065), (-46.6, 81.986), (-44.523, 81.661), (-46.901, 82.2)]]], ['TF', [[(68.935, -48.625), (69.58, -48.94), (70.525, -49.065), (70.56, -49.255), (70.28, -49.71), (68.745, -49.775), (68.72, -49.242), (68.868, -48.83)]]], ['TL', [[(124.969, -8.893), (125.086, -8.657), (125.947, -8.432), (126.645, -8.398), (126.957, -8.273), (127.336, -8.397), (126.968, -8.668), (125.926, -9.106), (125.089, -9.393), (125.07, -9.09)]]], ['ZA', [[(16.345, -28.577), (16.824, -28.082), (17.219, -28.356), (17.387, -28.784), (17.836, -28.856), (18.465, -29.045), (19.002, -28.972), (19.895, -28.461), (19.896, -24.768), (20.166, -24.918), (20.759, -25.868), (20.666, -26.477), (20.89, -26.829), (21.606, -26.727), (22.106, -26.28), (22.58, -25.979), (22.824, -25.5), (23.312, -25.269), (23.734, -25.39), (24.211, -25.67), (25.025, -25.72), (25.665, -25.487), (25.766, -25.175), (25.942, -24.696), (26.486, -24.616), (26.786, -24.241), (27.119, -23.574), (28.017, -22.828), (29.432, -22.091), (29.839, -22.102), (30.323, -22.272), (30.66, -22.152), (31.191, -22.252), (31.67, -23.659), (31.931, -24.369), (31.752, -25.484), (31.838, -25.843), (31.333, -25.66), (31.044, -25.731), (30.95, -26.023), (30.677, -26.398), (30.686, -26.744), (31.283, -27.286), (31.868, -27.178), (32.072, -26.734), (32.83, -26.742), (32.58, -27.47), (32.462, -28.301), (32.203, -28.752), (31.521, -29.257), (31.326, -29.402), (30.902, -29.91), (30.623, -30.424), (30.056, -31.14), (28.926, -32.172), (28.22, -32.772), (27.465, -33.227), (26.419, -33.615), (25.91, -33.667), (25.781, -33.945), (25.173, -33.797), (24.678, -33.987), (23.594, -33.794), (22.988, -33.916), (22.574, -33.864), (21.543, -34.259), (20.689, -34.417), (20.071, -34.795), (19.616, -34.819), (19.193, -34.463), (18.855, -34.444), (18.425, -33.998), (18.377, -34.137), (18.244, -33.868), (18.25, -33.281), (17.925, -32.611), (18.248, -32.429), (18.222, -31.662), (17.567, -30.726), (17.064, -29.879), (17.063, -29.876)], [(28.978, -28.956), (28.542, -28.648), (28.074, -28.851), (27.533, -29.243), (26.999, -29.876), (27.749, -30.645), (28.107, -30.546), (28.291, -30.226), (28.848, -30.07), (29.018, -29.744), (29.325, -29.257)]]], ['LS', [[(28.978, -28.956), (29.325, -29.257), (29.018, -29.744), (28.848, -30.07), (28.291, -30.226), (28.107, -30.546), (27.749, -30.645), (26.999, -29.876), (27.533, -29.243), (28.074, -28.851), (28.542, -28.648)]]], ['UY', [[(-57.625, -30.216), (-56.976, -30.11), (-55.973, -30.883), (-55.602, -30.854), (-54.572, -31.495), (-53.788, -32.047), (-53.21, -32.728), (-53.651, -33.202), (-53.374, -33.768), (-53.806, -34.397), (-54.936, -34.953), (-55.674, -34.753), (-56.215, -34.86), (-57.14, -34.43), (-57.818, -34.463), (-58.427, -33.909), (-58.35, -33.263), (-58.133, -33.041), (-58.142, -32.045), (-57.875, -31.017)]]], ['BR', [[(-53.374, -33.768), (-53.651, -33.202), (-53.21, -32.728), (-53.788, -32.047), (-54.572, -31.495), (-55.602, -30.854), (-55.973, -30.883), (-56.976, -30.11), (-57.625, -30.216), (-56.291, -28.853), (-55.162, -27.882), (-54.491, -27.475), (-53.649, -26.923), (-53.628, -26.125), (-54.13, -25.548), (-54.625, -25.739), (-54.429, -25.162), (-54.293, -24.571), (-54.293, -24.021), (-54.653, -23.84), (-55.028, -24.001), (-55.401, -23.957), (-55.518, -23.572), (-55.611, -22.656), (-55.798, -22.357), (-56.473, -22.086), (-56.882, -22.282), (-57.937, -22.09), (-57.871, -20.733), (-58.166, -20.177), (-57.854, -19.97), (-57.95, -19.4), (-57.676, -18.962), (-57.498, -18.174), (-57.735, -17.552), (-58.281, -17.272), (-58.388, -16.877), (-58.241, -16.3), (-60.158, -16.258), (-60.543, -15.094), (-60.251, -15.077), (-60.264, -14.646), (-60.459, -14.354), (-60.503, -13.776), (-61.084, -13.479), (-61.713, -13.489), (-62.127, -13.199), (-62.803, -13.001), (-63.196, -12.627), (-64.316, -12.462), (-65.402, -11.566), (-65.322, -10.896), (-65.445, -10.511), (-65.338, -9.762), (-66.647, -9.931), (-67.174, -10.307), (-68.048, -10.712), (-68.271, -11.015), (-68.786, -11.036), (-69.53, -10.952), (-70.094, -11.124), (-70.549, -11.009), (-70.482, -9.49), (-71.302, -10.079), (-72.185, -10.054), (-72.563, -9.52), (-73.227, -9.462), (-73.015, -9.033), (-73.571, -8.424), (-73.987, -7.524), (-73.723, -7.341), (-73.724, -6.919), (-73.12, -6.63), (-73.22, -6.089), (-72.965, -5.741), (-72.892, -5.275), (-71.748, -4.594), (-70.929, -4.402), (-70.795, -4.251), (-69.894, -4.298), (-69.444, -1.556), (-69.42, -1.123), (-69.577, -0.55), (-70.021, -0.185), (-70.016, 0.541), (-69.452, 0.706), (-69.252, 0.603), (-69.219, 0.986), (-69.805, 1.089), (-69.817, 1.715), (-67.869, 1.692), (-67.538, 2.037), (-67.26, 1.72), (-67.065, 1.13), (-66.876, 1.253), (-66.326, 0.724), (-65.548, 0.789), (-65.355, 1.095), (-64.611, 1.329), (-64.199, 1.493), (-64.083, 1.916), (-63.369, 2.201), (-63.423, 2.411), (-64.27, 2.497), (-64.409, 3.127), (-64.368, 3.797), (-64.816, 4.056), (-64.629, 4.148), (-63.888, 4.021), (-63.093, 3.771), (-62.805, 4.007), (-62.085, 4.162), (-60.967, 4.536), (-60.601, 4.918), (-60.734, 5.2), (-60.214, 5.244), (-59.981, 5.014), (-60.111, 4.575), (-59.767, 4.424), (-59.538, 3.959), (-59.815, 3.606), (-59.975, 2.755), (-59.719, 2.25), (-59.646, 1.787), (-59.031, 1.318), (-58.54, 1.268), (-58.429, 1.464), (-58.113, 1.507), (-57.661, 1.683), (-57.336, 1.949), (-56.783, 1.864), (-56.539, 1.9), (-55.996, 1.818), (-55.906, 2.022), (-56.073, 2.221), (-55.973, 2.51), (-55.57, 2.422), (-55.098, 2.524), (-54.525, 2.312), (-54.088, 2.106), (-53.779, 2.377), (-53.555, 2.335), (-53.418, 2.053), (-52.94, 2.125), (-52.556, 2.505), (-52.249, 3.241), (-51.658, 4.156), (-51.317, 4.203), (-51.07, 3.65), (-50.509, 1.902), (-49.974, 1.736), (-49.947, 1.046), (-50.699, 0.223), (-50.388, -0.078), (-48.621, -0.235), (-48.584, -1.238), (-47.825, -0.582), (-46.567, -0.941), (-44.906, -1.552), (-44.418, -2.138), (-44.582, -2.691), (-43.419, -2.383), (-41.473, -2.912), (-39.979, -2.873), (-38.5, -3.701), (-37.223, -4.821), (-36.453, -5.109), (-35.598, -5.15), (-35.235, -5.465), (-34.896, -6.738), (-34.73, -7.343), (-35.128, -8.996), (-35.637, -9.649), (-37.047, -11.041), (-37.684, -12.171), (-38.424, -13.038), (-38.674, -13.058), (-38.953, -13.793), (-38.882, -15.667), (-39.161, -17.208), (-39.267, -17.868), (-39.584, -18.262), (-39.761, -19.599), (-40.775, -20.905), (-40.945, -21.937), (-41.754, -22.371), (-41.988, -22.97), (-43.075, -22.968), (-44.648, -23.352), (-45.352, -23.797), (-46.472, -24.089), (-47.649, -24.885), (-48.495, -25.877), (-48.641, -26.624), (-48.475, -27.176), (-48.662, -28.186), (-48.888, -28.674), (-49.587, -29.224), (-50.697, -30.984), (-51.576, -31.778), (-52.256, -32.245), (-52.712, -33.197)]]], ['BO', [[(-69.53, -10.952), (-68.786, -11.036), (-68.271, -11.015), (-68.048, -10.712), (-67.174, -10.307), (-66.647, -9.931), (-65.338, -9.762), (-65.445, -10.511), (-65.322, -10.896), (-65.402, -11.566), (-64.316, -12.462), (-63.196, -12.627), (-62.803, -13.001), (-62.127, -13.199), (-61.713, -13.489), (-61.084, -13.479), (-60.503, -13.776), (-60.459, -14.354), (-60.264, -14.646), (-60.251, -15.077), (-60.543, -15.094), (-60.158, -16.258), (-58.241, -16.3), (-58.388, -16.877), (-58.281, -17.272), (-57.735, -17.552), (-57.498, -18.174), (-57.676, -18.962), (-57.95, -19.4), (-57.854, -19.97), (-58.166, -20.177), (-58.183, -19.868), (-59.115, -19.357), (-60.044, -19.343), (-61.786, -19.634), (-62.266, -20.514), (-62.291, -21.052), (-62.685, -22.249), (-62.846, -22.035), (-63.987, -21.994), (-64.377, -22.798), (-64.965, -22.076), (-66.273, -21.832), (-67.107, -22.736), (-67.828, -22.873), (-68.22, -21.494), (-68.757, -20.373), (-68.442, -19.405), (-68.967, -18.982), (-69.1, -18.26), (-69.59, -17.58), (-68.96, -16.501), (-69.39, -15.66), (-69.16, -15.324), (-69.34, -14.953), (-68.949, -14.454), (-68.929, -13.603), (-68.88, -12.9), (-68.665, -12.561)]]], ['PE', [[(-69.894, -4.298), (-70.795, -4.251), (-70.929, -4.402), (-71.748, -4.594), (-72.892, -5.275), (-72.965, -5.741), (-73.22, -6.089), (-73.12, -6.63), (-73.724, -6.919), (-73.723, -7.341), (-73.987, -7.524), (-73.571, -8.424), (-73.015, -9.033), (-73.227, -9.462), (-72.563, -9.52), (-72.185, -10.054), (-71.302, -10.079), (-70.482, -9.49), (-70.549, -11.009), (-70.094, -11.124), (-69.53, -10.952), (-68.665, -12.561), (-68.88, -12.9), (-68.929, -13.603), (-68.949, -14.454), (-69.34, -14.953), (-69.16, -15.324), (-69.39, -15.66), (-68.96, -16.501), (-69.59, -17.58), (-69.858, -18.093), (-70.373, -18.348), (-71.375, -17.774), (-71.462, -17.363), (-73.445, -16.359), (-75.238, -15.266), (-76.009, -14.649), (-76.423, -13.823), (-76.259, -13.535), (-77.106, -12.223), (-78.092, -10.378), (-79.037, -8.387), (-79.446, -7.931), (-79.761, -7.194), (-80.537, -6.542), (-81.25, -6.137), (-80.926, -5.691), (-81.411, -4.737), (-81.1, -4.036), (-80.303, -3.405), (-80.184, -3.821), (-80.469, -4.059), (-80.442, -4.426), (-80.029, -4.346), (-79.625, -4.454), (-79.205, -4.959), (-78.64, -4.548), (-78.451, -3.873), (-77.838, -3.003), (-76.635, -2.609), (-75.545, -1.562), (-75.234, -0.911), (-75.373, -0.152), (-75.107, -0.057), (-74.442, -0.531), (-74.122, -1.003), (-73.66, -1.26), (-73.07, -2.309), (-72.326, -2.434), (-71.775, -2.17), (-71.414, -2.343), (-70.813, -2.257), (-70.048, -2.725), (-70.693, -3.743), (-70.394, -3.767)]]], ['CO', [[(-66.876, 1.253), (-67.065, 1.13), (-67.26, 1.72), (-67.538, 2.037), (-67.869, 1.692), (-69.817, 1.715), (-69.805, 1.089), (-69.219, 0.986), (-69.252, 0.603), (-69.452, 0.706), (-70.016, 0.541), (-70.021, -0.185), (-69.577, -0.55), (-69.42, -1.123), (-69.444, -1.556), (-69.894, -4.298), (-70.394, -3.767), (-70.693, -3.743), (-70.048, -2.725), (-70.813, -2.257), (-71.414, -2.343), (-71.775, -2.17), (-72.326, -2.434), (-73.07, -2.309), (-73.66, -1.26), (-74.122, -1.003), (-74.442, -0.531), (-75.107, -0.057), (-75.373, -0.152), (-75.801, 0.085), (-76.292, 0.416), (-76.576, 0.257), (-77.425, 0.396), (-77.669, 0.826), (-77.855, 0.81), (-78.855, 1.381), (-78.991, 1.691), (-78.618, 1.766), (-78.662, 2.267), (-78.428, 2.63), (-77.932, 2.697), (-77.51, 3.325), (-77.128, 3.85), (-77.496, 4.088), (-77.308, 4.668), (-77.533, 5.583), (-77.319, 5.845), (-77.477, 6.691), (-77.901, 7.229), (-77.828, 7.443), (-77.765, 7.484), (-77.744, 7.537), (-77.769, 7.668), (-77.762, 7.699), (-77.747, 7.712), (-77.732, 7.711), (-77.706, 7.691), (-77.659, 7.635), (-77.619, 7.565), (-77.587, 7.543), (-77.538, 7.566), (-77.351, 7.706), (-77.363, 7.749), (-77.346, 7.837), (-77.283, 7.908), (-77.216, 7.933), (-77.196, 7.972), (-77.212, 8.034), (-77.283, 8.187), (-77.346, 8.27), (-77.386, 8.352), (-77.407, 8.427), (-77.479, 8.498), (-77.448, 8.566), (-77.393, 8.645), (-77.374, 8.658), (-76.837, 8.639), (-76.086, 9.337), (-75.675, 9.443), (-75.665, 9.774), (-75.48, 10.619), (-74.907, 11.083), (-74.277, 11.102), (-74.197, 11.31), (-73.415, 11.227), (-72.628, 11.732), (-72.238, 11.956), (-71.754, 12.437), (-71.4, 12.376), (-71.137, 12.113), (-71.332, 11.776), (-71.974, 11.609), (-72.228, 11.109), (-72.615, 10.822), (-72.905, 10.45), (-73.028, 9.737), (-73.305, 9.152), (-72.789, 9.085), (-72.66, 8.625), (-72.44, 8.405), (-72.361, 8.003), (-72.48, 7.633), (-72.444, 7.424), (-72.198, 7.34), (-71.96, 6.992), (-70.674, 7.088), (-70.093, 6.96), (-69.389, 6.1), (-68.985, 6.207), (-68.265, 6.153), (-67.695, 6.267), (-67.341, 6.095), (-67.522, 5.557), (-67.745, 5.221), (-67.823, 4.504), (-67.622, 3.839), (-67.338, 3.542), (-67.303, 3.318), (-67.81, 2.821), (-67.447, 2.6), (-67.181, 2.251)]]], ['VE', [[(-60.734, 5.2), (-60.601, 4.918), (-60.967, 4.536), (-62.085, 4.162), (-62.805, 4.007), (-63.093, 3.771), (-63.888, 4.021), (-64.629, 4.148), (-64.816, 4.056), (-64.368, 3.797), (-64.409, 3.127), (-64.27, 2.497), (-63.423, 2.411), (-63.369, 2.201), (-64.083, 1.916), (-64.199, 1.493), (-64.611, 1.329), (-65.355, 1.095), (-65.548, 0.789), (-66.326, 0.724), (-66.876, 1.253), (-67.181, 2.251), (-67.447, 2.6), (-67.81, 2.821), (-67.303, 3.318), (-67.338, 3.542), (-67.622, 3.839), (-67.823, 4.504), (-67.745, 5.221), (-67.522, 5.557), (-67.341, 6.095), (-67.695, 6.267), (-68.265, 6.153), (-68.985, 6.207), (-69.389, 6.1), (-70.093, 6.96), (-70.674, 7.088), (-71.96, 6.992), (-72.198, 7.34), (-72.444, 7.424), (-72.48, 7.633), (-72.361, 8.003), (-72.44, 8.405), (-72.66, 8.625), (-72.789, 9.085), (-73.305, 9.152), (-73.028, 9.737), (-72.905, 10.45), (-72.615, 10.822), (-72.228, 11.109), (-71.974, 11.609), (-71.332, 11.776), (-71.36, 11.54), (-71.947, 11.423), (-71.621, 10.969), (-71.633, 10.446), (-72.074, 9.866), (-71.696, 9.072), (-71.265, 9.137), (-71.04, 9.86), (-71.35, 10.212), (-71.401, 10.969), (-70.155, 11.375), (-70.294, 11.847), (-69.943, 12.162), (-69.584, 11.46), (-68.883, 11.443), (-68.233, 10.886), (-68.194, 10.555), (-67.296, 10.546), (-66.228, 10.649), (-65.655, 10.201), (-64.89, 10.077), (-64.329, 10.39), (-64.318, 10.641), (-63.079, 10.702), (-61.881, 10.716), (-62.73, 10.42), (-62.389, 9.948), (-61.589, 9.873), (-60.831, 9.381), (-60.671, 8.58), (-60.15, 8.603), (-59.758, 8.367), (-60.551, 7.78), (-60.638, 7.415), (-60.296, 7.044), (-60.544, 6.857), (-61.159, 6.696), (-61.139, 6.234), (-61.41, 5.959)]]], ['GY', [[(-56.539, 1.9), (-56.783, 1.864), (-57.336, 1.949), (-57.661, 1.683), (-58.113, 1.507), (-58.429, 1.464), (-58.54, 1.268), (-59.031, 1.318), (-59.646, 1.787), (-59.719, 2.25), (-59.975, 2.755), (-59.815, 3.606), (-59.538, 3.959), (-59.767, 4.424), (-60.111, 4.575), (-59.981, 5.014), (-60.214, 5.244), (-60.734, 5.2), (-61.41, 5.959), (-61.139, 6.234), (-61.159, 6.696), (-60.544, 6.857), (-60.296, 7.044), (-60.638, 7.415), (-60.551, 7.78), (-59.758, 8.367), (-59.102, 7.999), (-58.483, 7.348), (-58.455, 6.833), (-58.078, 6.809), (-57.542, 6.321), (-57.147, 5.973), (-57.307, 5.074), (-57.914, 4.813), (-57.86, 4.577), (-58.045, 4.061), (-57.602, 3.335), (-57.281, 3.333), (-57.15, 2.769)]]], ['SR', [[(-54.525, 2.312), (-55.098, 2.524), (-55.57, 2.422), (-55.973, 2.51), (-56.073, 2.221), (-55.906, 2.022), (-55.996, 1.818), (-56.539, 1.9), (-57.15, 2.769), (-57.281, 3.333), (-57.602, 3.335), (-58.045, 4.061), (-57.86, 4.577), (-57.914, 4.813), (-57.307, 5.074), (-57.147, 5.973), (-55.949, 5.773), (-55.842, 5.953), (-55.033, 6.025), (-53.958, 5.757), (-54.479, 4.897), (-54.4, 4.213), (-54.007, 3.62), (-54.182, 3.19), (-54.27, 2.732)]]], ['F', [[(-51.658, 4.156), (-52.249, 3.241), (-52.556, 2.505), (-52.94, 2.125), (-53.418, 2.053), (-53.555, 2.335), (-53.779, 2.377), (-54.088, 2.106), (-54.525, 2.312), (-54.27, 2.732), (-54.182, 3.19), (-54.007, 3.62), (-54.4, 4.213), (-54.479, 4.897), (-53.958, 5.757), (-53.618, 5.647), (-52.882, 5.41), (-51.823, 4.566)], [(6.186, 49.464), (6.658, 49.202), (8.099, 49.018), (7.594, 48.333), (7.467, 47.621), (7.192, 47.45), (6.737, 47.542), (6.769, 47.288), (6.037, 46.726), (6.023, 46.273), (6.5, 46.43), (6.844, 45.991), (6.802, 45.709), (7.097, 45.333), (6.75, 45.029), (7.008, 44.255), (7.55, 44.128), (7.435, 43.694), (6.529, 43.129), (4.557, 43.4), (3.1, 43.075), (2.986, 42.473), (1.827, 42.343), (0.702, 42.796), (0.338, 42.58), (-1.503, 43.034), (-1.901, 43.423), (-1.384, 44.023), (-1.194, 46.015), (-2.226, 47.064), (-2.963, 47.57), (-4.492, 47.955), (-4.592, 48.684), (-3.296, 48.902), (-1.617, 48.644), (-1.933, 49.776), (-0.989, 49.347), (1.339, 50.127), (1.639, 50.947), (2.514, 51.149), (2.658, 50.797), (3.123, 50.78), (3.588, 50.379), (4.286, 49.907), (4.799, 49.985), (5.674, 49.529), (5.898, 49.443)], [(8.746, 42.628), (9.39, 43.01), (9.56, 42.152), (9.23, 41.38), (8.776, 41.584), (8.544, 42.257)]]], ['EC', [[(-75.373, -0.152), (-75.234, -0.911), (-75.545, -1.562), (-76.635, -2.609), (-77.838, -3.003), (-78.451, -3.873), (-78.64, -4.548), (-79.205, -4.959), (-79.625, -4.454), (-80.029, -4.346), (-80.442, -4.426), (-80.469, -4.059), (-80.184, -3.821), (-80.303, -3.405), (-79.77, -2.658), (-79.987, -2.221), (-80.369, -2.685), (-80.968, -2.247), (-80.765, -1.965), (-80.934, -1.057), (-80.583, -0.907), (-80.399, -0.284), (-80.021, 0.36), (-80.091, 0.768), (-79.543, 0.983), (-78.855, 1.381), (-77.855, 0.81), (-77.669, 0.826), (-77.425, 0.396), (-76.576, 0.257), (-76.292, 0.416), (-75.801, 0.085)]]], ['ZW', [[(31.191, -22.252), (30.66, -22.152), (30.323, -22.272), (29.839, -22.102), (29.432, -22.091), (28.795, -21.639), (28.021, -21.486), (27.727, -20.852), (27.725, -20.499), (27.297, -20.392), (26.165, -19.293), (25.85, -18.714), (25.649, -18.536), (25.264, -17.737), (26.382, -17.846), (26.707, -17.961), (27.044, -17.938), (27.598, -17.291), (28.468, -16.468), (28.826, -16.39), (28.947, -16.043), (29.517, -15.645), (30.274, -15.508), (30.339, -15.881), (31.173, -15.861), (31.636, -16.072), (31.852, -16.319), (32.328, -16.392), (32.848, -16.713), (32.85, -17.979), (32.655, -18.672), (32.612, -19.419), (32.773, -19.716), (32.66, -20.304), (32.509, -20.395), (32.245, -21.116)]]], ['BW', [[(29.432, -22.091), (28.017, -22.828), (27.119, -23.574), (26.786, -24.241), (26.486, -24.616), (25.942, -24.696), (25.766, -25.175), (25.665, -25.487), (25.025, -25.72), (24.211, -25.67), (23.734, -25.39), (23.312, -25.269), (22.824, -25.5), (22.58, -25.979), (22.106, -26.28), (21.606, -26.727), (20.89, -26.829), (20.666, -26.477), (20.759, -25.868), (20.166, -24.918), (19.896, -24.768), (19.895, -21.849), (20.881, -21.814), (20.911, -18.252), (21.655, -18.219), (23.197, -17.869), (23.579, -18.281), (24.217, -17.889), (24.521, -17.887), (25.084, -17.662), (25.264, -17.737), (25.649, -18.536), (25.85, -18.714), (26.165, -19.293), (27.297, -20.392), (27.725, -20.499), (27.727, -20.852), (28.021, -21.486), (28.795, -21.639)]]], ['NA', [[(19.896, -24.768), (19.895, -28.461), (19.002, -28.972), (18.465, -29.045), (17.836, -28.856), (17.387, -28.784), (17.219, -28.356), (16.824, -28.082), (16.345, -28.577), (15.602, -27.821), (15.21, -27.091), (14.99, -26.117), (14.743, -25.393), (14.408, -23.853), (14.386, -22.657), (14.258, -22.111), (13.869, -21.699), (13.352, -20.873), (12.827, -19.673), (12.609, -19.045), (11.795, -18.069), (11.734, -17.302), (12.215, -17.112), (12.814, -16.941), (13.462, -16.971), (14.059, -17.423), (14.21, -17.353), (18.263, -17.31), (18.956, -17.789), (21.377, -17.931), (23.215, -17.523), (24.034, -17.296), (24.682, -17.353), (25.077, -17.579), (25.084, -17.662), (24.521, -17.887), (24.217, -17.889), (23.579, -18.281), (23.197, -17.869), (21.655, -18.219), (20.911, -18.252), (20.881, -21.814), (19.895, -21.849)]]], ['SN', [[(-16.714, 13.595), (-17.126, 14.374), (-17.625, 14.73), (-17.185, 14.919), (-16.701, 15.622), (-16.463, 16.135), (-16.121, 16.456), (-15.624, 16.369), (-15.136, 16.587), (-14.577, 16.598), (-14.1, 16.304), (-13.436, 16.039), (-12.831, 15.304), (-12.171, 14.617), (-12.125, 13.995), (-11.928, 13.422), (-11.553, 13.141), (-11.468, 12.755), (-11.514, 12.443), (-11.658, 12.387), (-12.204, 12.466), (-12.279, 12.354), (-12.499, 12.332), (-13.218, 12.576), (-13.7, 12.586), (-15.548, 12.628), (-15.817, 12.516), (-16.148, 12.548), (-16.677, 12.385), (-16.842, 13.151), (-15.931, 13.13), (-15.691, 13.27), (-15.512, 13.279), (-15.141, 13.51), (-14.712, 13.298), (-14.278, 13.281), (-13.845, 13.505), (-14.047, 13.794), (-14.377, 13.626), (-14.687, 13.63), (-15.082, 13.876), (-15.399, 13.86), (-15.625, 13.624)]]], ['ML', [[(-11.514, 12.443), (-11.468, 12.755), (-11.553, 13.141), (-11.928, 13.422), (-12.125, 13.995), (-12.171, 14.617), (-11.834, 14.799), (-11.666, 15.388), (-11.349, 15.411), (-10.651, 15.133), (-10.087, 15.33), (-9.7, 15.264), (-9.55, 15.486), (-5.538, 15.502), (-5.315, 16.202), (-5.489, 16.325), (-5.971, 20.641), (-6.454, 24.957), (-4.923, 24.975), (1.823, 20.611), (2.061, 20.142), (2.684, 19.856), (3.147, 19.694), (3.158, 19.057), (4.267, 19.155), (4.27, 16.852), (3.723, 16.184), (3.638, 15.568), (2.75, 15.41), (1.386, 15.324), (1.016, 14.968), (0.375, 14.929), (-0.266, 14.924), (-0.516, 15.116), (-1.066, 14.974), (-2.001, 14.559), (-2.192, 14.246), (-2.968, 13.798), (-3.104, 13.541), (-3.523, 13.338), (-4.006, 13.472), (-4.28, 13.228), (-4.427, 12.543), (-5.221, 11.714), (-5.198, 11.375), (-5.471, 10.951), (-5.404, 10.371), (-5.817, 10.223), (-6.05, 10.096), (-6.205, 10.524), (-6.494, 10.411), (-6.666, 10.431), (-6.851, 10.139), (-7.623, 10.147), (-7.9, 10.297), (-8.03, 10.207), (-8.335, 10.495), (-8.282, 10.793), (-8.407, 10.909), (-8.62, 10.811), (-8.581, 11.136), (-8.376, 11.394), (-8.786, 11.813), (-8.905, 12.088), (-9.127, 12.308), (-9.328, 12.334), (-9.568, 12.194), (-9.891, 12.06), (-10.165, 11.844), (-10.593, 11.924), (-10.871, 12.178), (-11.037, 12.211), (-11.298, 12.078), (-11.456, 12.077)]]], ['MR', [[(-17.063, 21.0), (-16.845, 21.333), (-12.929, 21.327), (-13.119, 22.771), (-12.874, 23.285), (-11.937, 23.375), (-11.969, 25.933), (-8.687, 25.881), (-8.684, 27.396), (-4.923, 24.975), (-6.454, 24.957), (-5.971, 20.641), (-5.489, 16.325), (-5.315, 16.202), (-5.538, 15.502), (-9.55, 15.486), (-9.7, 15.264), (-10.087, 15.33), (-10.651, 15.133), (-11.349, 15.411), (-11.666, 15.388), (-11.834, 14.799), (-12.171, 14.617), (-12.831, 15.304), (-13.436, 16.039), (-14.1, 16.304), (-14.577, 16.598), (-15.136, 16.587), (-15.624, 16.369), (-16.121, 16.456), (-16.463, 16.135), (-16.55, 16.674), (-16.271, 17.167), (-16.146, 18.108), (-16.257, 19.097), (-16.378, 19.594), (-16.278, 20.093), (-16.536, 20.568)]]], ['BJ', [[(2.692, 6.259), (1.865, 6.142), (1.619, 6.832), (1.664, 9.129), (1.463, 9.335), (1.425, 9.825), (1.078, 10.176), (0.772, 10.471), (0.9, 10.997), (1.243, 11.111), (1.447, 11.548), (1.936, 11.641), (2.154, 11.94), (2.49, 12.233), (2.849, 12.236), (3.611, 11.66), (3.572, 11.328), (3.797, 10.735), (3.6, 10.332), (3.705, 10.063), (3.22, 9.444), (2.912, 9.138), (2.724, 8.507), (2.749, 7.871)]]], ['NE', [[(14.851, 22.863), (15.097, 21.309), (15.471, 21.048), (15.487, 20.73), (15.903, 20.388), (15.686, 19.957), (15.3, 17.928), (15.248, 16.627), (13.972, 15.684), (13.54, 14.367), (13.957, 13.997), (13.954, 13.353), (14.596, 13.33), (14.496, 12.859), (14.214, 12.802), (14.181, 12.484), (13.995, 12.462), (13.319, 13.556), (13.084, 13.596), (12.302, 13.037), (11.528, 13.329), (10.99, 13.387), (10.701, 13.247), (10.115, 13.277), (9.525, 12.851), (9.015, 12.827), (7.805, 13.344), (7.331, 13.098), (6.82, 13.115), (6.445, 13.493), (5.443, 13.866), (4.368, 13.747), (4.108, 13.531), (3.967, 12.956), (3.681, 12.553), (3.611, 11.66), (2.849, 12.236), (2.49, 12.233), (2.154, 11.94), (2.177, 12.625), (1.024, 12.852), (0.993, 13.336), (0.43, 13.989), (0.296, 14.444), (0.375, 14.929), (1.016, 14.968), (1.386, 15.324), (2.75, 15.41), (3.638, 15.568), (3.723, 16.184), (4.27, 16.852), (4.267, 19.155), (5.678, 19.601), (8.573, 21.566), (12.0, 23.472), (13.581, 23.041), (14.144, 22.491)]]], ['NG', [[(2.692, 6.259), (2.749, 7.871), (2.724, 8.507), (2.912, 9.138), (3.22, 9.444), (3.705, 10.063), (3.6, 10.332), (3.797, 10.735), (3.572, 11.328), (3.611, 11.66), (3.681, 12.553), (3.967, 12.956), (4.108, 13.531), (4.368, 13.747), (5.443, 13.866), (6.445, 13.493), (6.82, 13.115), (7.331, 13.098), (7.805, 13.344), (9.015, 12.827), (9.525, 12.851), (10.115, 13.277), (10.701, 13.247), (10.99, 13.387), (11.528, 13.329), (12.302, 13.037), (13.084, 13.596), (13.319, 13.556), (13.995, 12.462), (14.181, 12.484), (14.577, 12.085), (14.468, 11.905), (14.415, 11.572), (13.573, 10.799), (13.309, 10.16), (13.168, 9.641), (12.955, 9.418), (12.754, 8.718), (12.219, 8.306), (12.064, 7.8), (11.839, 7.397), (11.746, 6.981), (11.059, 6.644), (10.497, 7.055), (10.118, 7.039), (9.523, 6.453), (9.233, 6.444), (8.758, 5.48), (8.5, 4.772), (7.462, 4.412), (7.083, 4.465), (6.698, 4.241), (5.898, 4.262), (5.363, 4.888), (5.034, 5.612), (4.326, 6.271), (3.574, 6.258)]]], ['CM', [[(14.496, 12.859), (14.893, 12.219), (14.96, 11.556), (14.924, 10.891), (15.468, 9.982), (14.909, 9.992), (14.627, 9.921), (14.171, 10.021), (13.954, 9.549), (14.544, 8.966), (14.98, 8.796), (15.121, 8.382), (15.436, 7.693), (15.279, 7.422), (14.777, 6.408), (14.537, 6.227), (14.459, 5.452), (14.559, 5.031), (14.478, 4.733), (14.951, 4.21), (15.036, 3.851), (15.405, 3.335), (15.863, 3.014), (15.907, 2.557), (16.013, 2.268), (15.941, 1.728), (15.146, 1.964), (14.338, 2.228), (13.076, 2.267), (12.951, 2.322), (12.359, 2.193), (11.752, 2.327), (11.276, 2.261), (9.649, 2.284), (9.795, 3.073), (9.404, 3.735), (8.948, 3.904), (8.745, 4.352), (8.489, 4.496), (8.5, 4.772), (8.758, 5.48), (9.233, 6.444), (9.523, 6.453), (10.118, 7.039), (10.497, 7.055), (11.059, 6.644), (11.746, 6.981), (11.839, 7.397), (12.064, 7.8), (12.219, 8.306), (12.754, 8.718), (12.955, 9.418), (13.168, 9.641), (13.309, 10.16), (13.573, 10.799), (14.415, 11.572), (14.468, 11.905), (14.577, 12.085), (14.181, 12.484), (14.214, 12.802)]]], ['TG', [[(0.9, 10.997), (0.772, 10.471), (1.078, 10.176), (1.425, 9.825), (1.463, 9.335), (1.664, 9.129), (1.619, 6.832), (1.865, 6.142), (1.06, 5.929), (0.837, 6.28), (0.57, 6.914), (0.491, 7.412), (0.712, 8.312), (0.461, 8.677), (0.366, 9.465), (0.368, 10.191), (-0.05, 10.707), (0.024, 11.019)]]], ['GH', [[(0.024, 11.019), (-0.05, 10.707), (0.368, 10.191), (0.366, 9.465), (0.461, 8.677), (0.712, 8.312), (0.491, 7.412), (0.57, 6.914), (0.837, 6.28), (1.06, 5.929), (-0.508, 5.343), (-1.064, 5.001), (-1.965, 4.71), (-2.856, 4.994), (-2.811, 5.389), (-3.244, 6.25), (-2.984, 7.38), (-2.562, 8.22), (-2.827, 9.642), (-2.964, 10.395), (-2.94, 10.963), (-1.203, 11.01), (-0.762, 10.937), (-0.439, 11.098)]]], ['CI', [[(-8.03, 10.207), (-7.9, 10.297), (-7.623, 10.147), (-6.851, 10.139), (-6.666, 10.431), (-6.494, 10.411), (-6.205, 10.524), (-6.05, 10.096), (-5.817, 10.223), (-5.404, 10.371), (-4.955, 10.153), (-4.78, 9.822), (-4.33, 9.611), (-3.98, 9.862), (-3.512, 9.9), (-2.827, 9.642), (-2.562, 8.22), (-2.984, 7.38), (-3.244, 6.25), (-2.811, 5.389), (-2.856, 4.994), (-3.311, 4.984), (-4.009, 5.18), (-4.65, 5.168), (-5.834, 4.994), (-6.529, 4.705), (-7.519, 4.338), (-7.712, 4.365), (-7.635, 5.188), (-7.54, 5.313), (-7.57, 5.707), (-7.994, 6.126), (-8.311, 6.193), (-8.603, 6.468), (-8.385, 6.912), (-8.485, 7.395), (-8.439, 7.686), (-8.281, 7.687), (-8.222, 8.123), (-8.299, 8.316), (-8.203, 8.455), (-7.832, 8.576), (-8.079, 9.376), (-8.31, 9.79), (-8.229, 10.129)]]], ['GN', [[(-13.7, 12.586), (-13.218, 12.576), (-12.499, 12.332), (-12.279, 12.354), (-12.204, 12.466), (-11.658, 12.387), (-11.514, 12.443), (-11.456, 12.077), (-11.298, 12.078), (-11.037, 12.211), (-10.871, 12.178), (-10.593, 11.924), (-10.165, 11.844), (-9.891, 12.06), (-9.568, 12.194), (-9.328, 12.334), (-9.127, 12.308), (-8.905, 12.088), (-8.786, 11.813), (-8.376, 11.394), (-8.581, 11.136), (-8.62, 10.811), (-8.407, 10.909), (-8.282, 10.793), (-8.335, 10.495), (-8.03, 10.207), (-8.229, 10.129), (-8.31, 9.79), (-8.079, 9.376), (-7.832, 8.576), (-8.203, 8.455), (-8.299, 8.316), (-8.222, 8.123), (-8.281, 7.687), (-8.439, 7.686), (-8.722, 7.712), (-8.926, 7.309), (-9.209, 7.314), (-9.403, 7.527), (-9.337, 7.929), (-9.755, 8.541), (-10.017, 8.429), (-10.23, 8.406), (-10.505, 8.349), (-10.494, 8.716), (-10.655, 8.977), (-10.622, 9.268), (-10.839, 9.688), (-11.117, 10.046), (-11.917, 10.047), (-12.15, 9.859), (-12.426, 9.836), (-12.597, 9.62), (-12.712, 9.343), (-13.247, 8.903), (-13.685, 9.495), (-14.074, 9.886), (-14.33, 10.016), (-14.58, 10.214), (-14.693, 10.656), (-14.84, 10.877), (-15.13, 11.04), (-14.686, 11.528), (-14.382, 11.509), (-14.121, 11.677), (-13.901, 11.679), (-13.743, 11.811), (-13.828, 12.143), (-13.719, 12.247)]]], ['GW', [[(-16.677, 12.385), (-16.148, 12.548), (-15.817, 12.516), (-15.548, 12.628), (-13.7, 12.586), (-13.719, 12.247), (-13.828, 12.143), (-13.743, 11.811), (-13.901, 11.679), (-14.121, 11.677), (-14.382, 11.509), (-14.686, 11.528), (-15.13, 11.04), (-15.664, 11.458), (-16.085, 11.525), (-16.315, 11.807), (-16.309, 11.959), (-16.614, 12.171)]]], ['LR', [[(-8.439, 7.686), (-8.485, 7.395), (-8.385, 6.912), (-8.603, 6.468), (-8.311, 6.193), (-7.994, 6.126), (-7.57, 5.707), (-7.54, 5.313), (-7.635, 5.188), (-7.712, 4.365), (-7.974, 4.356), (-9.005, 4.832), (-9.913, 5.594), (-10.765, 6.141), (-11.439, 6.786), (-11.2, 7.106), (-11.147, 7.397), (-10.696, 7.939), (-10.23, 8.406), (-10.017, 8.429), (-9.755, 8.541), (-9.337, 7.929), (-9.403, 7.527), (-9.209, 7.314), (-8.926, 7.309), (-8.722, 7.712)]]], ['SL', [[(-13.247, 8.903), (-12.712, 9.343), (-12.597, 9.62), (-12.426, 9.836), (-12.15, 9.859), (-11.917, 10.047), (-11.117, 10.046), (-10.839, 9.688), (-10.622, 9.268), (-10.655, 8.977), (-10.494, 8.716), (-10.505, 8.349), (-10.23, 8.406), (-10.696, 7.939), (-11.147, 7.397), (-11.2, 7.106), (-11.439, 6.786), (-11.708, 6.86), (-12.428, 7.263), (-12.949, 7.799), (-13.124, 8.164)]]], ['BF', [[(-5.404, 10.371), (-5.471, 10.951), (-5.198, 11.375), (-5.221, 11.714), (-4.427, 12.543), (-4.28, 13.228), (-4.006, 13.472), (-3.523, 13.338), (-3.104, 13.541), (-2.968, 13.798), (-2.192, 14.246), (-2.001, 14.559), (-1.066, 14.974), (-0.516, 15.116), (-0.266, 14.924), (0.375, 14.929), (0.296, 14.444), (0.43, 13.989), (0.993, 13.336), (1.024, 12.852), (2.177, 12.625), (2.154, 11.94), (1.936, 11.641), (1.447, 11.548), (1.243, 11.111), (0.9, 10.997), (0.024, 11.019), (-0.439, 11.098), (-0.762, 10.937), (-1.203, 11.01), (-2.94, 10.963), (-2.964, 10.395), (-2.827, 9.642), (-3.512, 9.9), (-3.98, 9.862), (-4.33, 9.611), (-4.78, 9.822), (-4.955, 10.153)]]], ['CF', [[(27.374, 5.234), (27.044, 5.128), (26.403, 5.151), (25.65, 5.256), (25.279, 5.17), (25.129, 4.927), (24.805, 4.897), (24.411, 5.109), (23.297, 4.61), (22.841, 4.71), (22.704, 4.633), (22.405, 4.029), (21.659, 4.224), (20.928, 4.323), (20.291, 4.692), (19.468, 5.032), (18.932, 4.71), (18.543, 4.202), (18.453, 3.504), (17.81, 3.56), (17.133, 3.728), (16.537, 3.198), (16.013, 2.268), (15.907, 2.557), (15.863, 3.014), (15.405, 3.335), (15.036, 3.851), (14.951, 4.21), (14.478, 4.733), (14.559, 5.031), (14.459, 5.452), (14.537, 6.227), (14.777, 6.408), (15.279, 7.422), (16.106, 7.497), (16.291, 7.754), (16.456, 7.735), (16.706, 7.508), (17.965, 7.891), (18.39, 8.281), (18.911, 8.631), (18.812, 8.983), (19.094, 9.075), (20.06, 9.013), (21.001, 9.476), (21.724, 10.567), (22.231, 10.972), (22.864, 11.142), (22.978, 10.714), (23.554, 10.089), (23.557, 9.681), (23.395, 9.265), (23.459, 8.954), (23.806, 8.666), (23.887, 8.62), (24.567, 8.229), (25.115, 7.825), (25.124, 7.5), (25.797, 6.979), (26.213, 6.547), (26.466, 5.947), (27.213, 5.551)]]], ['CG', [[(18.453, 3.504), (18.394, 2.9), (18.094, 2.366), (17.899, 1.742), (17.774, 0.856), (17.827, 0.289), (17.664, -0.058), (17.639, -0.425), (17.524, -0.744), (16.865, -1.226), (16.407, -1.741), (15.973, -2.712), (16.006, -3.535), (15.754, -3.855), (15.171, -4.344), (14.583, -4.97), (14.209, -4.793), (14.145, -4.51), (13.6, -4.5), (13.258, -4.883), (12.996, -4.781), (12.621, -4.438), (12.319, -4.606), (11.915, -5.038), (11.094, -3.979), (11.855, -3.427), (11.478, -2.766), (11.821, -2.514), (12.496, -2.392), (12.575, -1.949), (13.11, -2.429), (13.992, -2.471), (14.299, -1.998), (14.425, -1.333), (14.316, -0.553), (13.843, 0.039), (14.276, 1.197), (14.027, 1.396), (13.283, 1.314), (13.003, 1.831), (13.076, 2.267), (14.338, 2.228), (15.146, 1.964), (15.941, 1.728), (16.013, 2.268), (16.537, 3.198), (17.133, 3.728), (17.81, 3.56)]]], ['GA', [[(11.276, 2.261), (11.752, 2.327), (12.359, 2.193), (12.951, 2.322), (13.076, 2.267), (13.003, 1.831), (13.283, 1.314), (14.027, 1.396), (14.276, 1.197), (13.843, 0.039), (14.316, -0.553), (14.425, -1.333), (14.299, -1.998), (13.992, -2.471), (13.11, -2.429), (12.575, -1.949), (12.496, -2.392), (11.821, -2.514), (11.478, -2.766), (11.855, -3.427), (11.094, -3.979), (10.066, -2.969), (9.405, -2.144), (8.798, -1.111), (8.83, -0.779), (9.048, -0.459), (9.291, 0.269), (9.493, 1.01), (9.83, 1.068), (11.285, 1.058)]]], ['GQ', [[(9.649, 2.284), (11.276, 2.261), (11.285, 1.058), (9.83, 1.068), (9.493, 1.01), (9.306, 1.161)]]], ['ZM', [[(31.107, -8.564), (31.158, -8.595), (31.556, -8.762), (32.192, -8.93), (32.759, -9.231), (33.231, -9.677), (33.486, -10.526), (33.315, -10.797), (33.114, -11.607), (33.306, -12.436), (32.992, -12.784), (32.688, -13.713), (33.214, -13.972), (30.179, -14.796), (30.274, -15.508), (29.517, -15.645), (28.947, -16.043), (28.826, -16.39), (28.468, -16.468), (27.598, -17.291), (27.044, -17.938), (26.707, -17.961), (26.382, -17.846), (25.264, -17.737), (25.084, -17.662), (25.077, -17.579), (24.682, -17.353), (24.034, -17.296), (23.215, -17.523), (22.562, -16.898), (21.888, -16.08), (21.934, -12.898), (24.016, -12.911), (23.931, -12.566), (24.08, -12.191), (23.904, -11.722), (24.018, -11.237), (23.912, -10.927), (24.257, -10.952), (24.315, -11.263), (24.783, -11.239), (25.418, -11.331), (25.752, -11.785), (26.553, -11.924), (27.164, -11.609), (27.389, -12.133), (28.155, -12.272), (28.524, -12.699), (28.934, -13.249), (29.7, -13.257), (29.616, -12.179), (29.342, -12.361), (28.642, -11.972), (28.372, -11.794), (28.496, -10.79), (28.674, -9.606), (28.45, -9.165), (28.735, -8.527), (29.003, -8.407), (30.346, -8.238), (30.522, -8.284), (30.464, -8.498), (30.806, -8.578), (31.022, -8.787), (31.189, -8.73)]]], ['MW', [[(32.759, -9.231), (33.74, -9.417), (33.939, -9.691), (33.907, -9.802), (34.26, -10.448), (34.323, -11.653), (34.033, -12.209), (34.33, -12.945), (34.321, -13.379), (34.551, -13.672), (34.547, -14.048), (34.707, -14.262), (34.881, -14.012), (35.236, -14.401), (35.26, -14.277), (35.056, -13.743), (34.868, -13.701), (34.849, -13.568), (34.907, -13.565), (35.268, -13.888), (35.687, -14.611), (35.772, -15.897), (35.339, -16.107), (35.034, -16.801), (34.381, -16.184), (34.307, -15.479), (34.518, -15.014), (34.46, -14.613), (34.065, -14.36), (33.79, -14.452), (33.214, -13.972), (32.688, -13.713), (32.992, -12.784), (33.306, -12.436), (33.114, -11.607), (33.315, -10.797), (33.486, -10.526), (33.231, -9.677)]]], ['MZ', [[(34.933, -11.48), (35.312, -11.439), (36.514, -11.721), (36.775, -11.595), (37.471, -11.569), (37.828, -11.269), (38.428, -11.285), (39.521, -10.897), (40.317, -10.317), (40.317, -10.317), (40.317, -10.317), (40.478, -10.765), (40.437, -11.762), (40.561, -12.639), (40.6, -14.202), (40.775, -14.692), (40.477, -15.406), (40.089, -16.101), (39.453, -16.721), (38.538, -17.101), (37.411, -17.586), (36.281, -18.66), (35.896, -18.842), (35.198, -19.553), (34.786, -19.784), (34.702, -20.497), (35.176, -21.254), (35.373, -21.841), (35.386, -22.14), (35.563, -22.09), (35.534, -23.071), (35.372, -23.535), (35.607, -23.707), (35.459, -24.123), (35.041, -24.478), (34.216, -24.816), (33.013, -25.358), (32.575, -25.727), (32.66, -26.149), (32.916, -26.216), (32.83, -26.742), (32.072, -26.734), (31.986, -26.292), (31.838, -25.843), (31.752, -25.484), (31.931, -24.369), (31.67, -23.659), (31.191, -22.252), (32.245, -21.116), (32.509, -20.395), (32.66, -20.304), (32.773, -19.716), (32.612, -19.419), (32.655, -18.672), (32.85, -17.979), (32.848, -16.713), (32.328, -16.392), (31.852, -16.319), (31.636, -16.072), (31.173, -15.861), (30.339, -15.881), (30.274, -15.508), (30.179, -14.796), (33.214, -13.972), (33.79, -14.452), (34.065, -14.36), (34.46, -14.613), (34.518, -15.014), (34.307, -15.479), (34.381, -16.184), (35.034, -16.801), (35.339, -16.107), (35.772, -15.897), (35.687, -14.611), (35.268, -13.888), (34.907, -13.565), (34.849, -13.568), (34.694, -12.422)]]], ['ES', [[(32.072, -26.734), (31.868, -27.178), (31.283, -27.286), (30.686, -26.744), (30.677, -26.398), (30.95, -26.023), (31.044, -25.731), (31.333, -25.66), (31.838, -25.843), (31.986, -26.292)]]], ['AO', [[(12.996, -4.781), (12.632, -4.991), (12.468, -5.248), (12.437, -5.684), (12.182, -5.79), (11.915, -5.038), (12.319, -4.606), (12.621, -4.438)], [(12.322, -6.1), (12.735, -5.966), (13.025, -5.984), (13.376, -5.864), (16.327, -5.877), (16.573, -6.623), (16.86, -7.222), (17.09, -7.546), (17.473, -8.069), (18.134, -7.988), (18.464, -7.847), (19.017, -7.988), (19.167, -7.738), (19.418, -7.155), (20.038, -7.116), (20.092, -6.943), (20.602, -6.939), (20.515, -7.3), (21.728, -7.291), (21.746, -7.92), (21.949, -8.306), (21.802, -8.909), (21.875, -9.524), (22.209, -9.895), (22.155, -11.085), (22.403, -10.993), (22.837, -11.018), (23.457, -10.868), (23.912, -10.927), (24.018, -11.237), (23.904, -11.722), (24.08, -12.191), (23.931, -12.566), (24.016, -12.911), (21.934, -12.898), (21.888, -16.08), (22.562, -16.898), (23.215, -17.523), (21.377, -17.931), (18.956, -17.789), (18.263, -17.31), (14.21, -17.353), (14.059, -17.423), (13.462, -16.971), (12.814, -16.941), (12.215, -17.112), (11.734, -17.302), (11.64, -16.673), (11.779, -15.794), (12.124, -14.878), (12.176, -14.449), (12.5, -13.548), (12.738, -13.138), (13.313, -12.484), (13.634, -12.039), (13.739, -11.298), (13.686, -10.731), (13.387, -10.374), (13.121, -9.767), (12.875, -9.167), (12.929, -8.959), (13.236, -8.563), (12.933, -7.597), (12.728, -6.927), (12.227, -6.294)]]], ['BI', [[(30.47, -2.414), (30.528, -2.808), (30.743, -3.034), (30.752, -3.359), (30.506, -3.569), (30.116, -4.09), (29.754, -4.452), (29.648, -4.465), (29.653, -4.42), (29.286, -3.467), (29.276, -3.294), (29.025, -2.839), (29.632, -2.918), (29.938, -2.348)]]], ['IS', [[(35.72, 32.709), (35.546, 32.394), (35.184, 32.533), (34.975, 31.867), (35.226, 31.754), (34.971, 31.617), (34.927, 31.353), (35.398, 31.489), (35.421, 31.1), (34.923, 29.501), (34.823, 29.761), (34.265, 31.219), (34.265, 31.219), (34.265, 31.219), (34.556, 31.549), (34.488, 31.606), (34.753, 32.073), (34.955, 32.827), (35.098, 33.081), (35.126, 33.091), (35.461, 33.089), (35.553, 33.264), (35.821, 33.277), (35.836, 32.868), (35.701, 32.716)]]], ['LB', [[(35.821, 33.277), (35.553, 33.264), (35.461, 33.089), (35.126, 33.091), (35.482, 33.905), (35.98, 34.61), (35.998, 34.645), (36.448, 34.594), (36.612, 34.202), (36.066, 33.825)]]], ['MG', [[(49.544, -12.47), (49.809, -12.895), (50.057, -13.556), (50.217, -14.759), (50.477, -15.227), (50.377, -15.706), (50.2, -16.0), (49.861, -15.414), (49.673, -15.71), (49.863, -16.451), (49.775, -16.875), (49.499, -17.106), (49.436, -17.953), (49.042, -19.119), (48.549, -20.497), (47.931, -22.392), (47.548, -23.782), (47.096, -24.942), (46.282, -25.178), (45.41, -25.601), (44.834, -25.346), (44.04, -24.988), (43.764, -24.461), (43.698, -23.574), (43.346, -22.777), (43.254, -22.057), (43.433, -21.336), (43.894, -21.163), (43.896, -20.83), (44.374, -20.072), (44.464, -19.435), (44.232, -18.962), (44.043, -18.331), (43.963, -17.41), (44.312, -16.85), (44.447, -16.216), (44.945, -16.179), (45.503, -15.974), (45.873, -15.793), (46.312, -15.78), (46.882, -15.21), (47.705, -14.594), (48.005, -14.091), (47.869, -13.664), (48.294, -13.784), (48.845, -13.089), (48.864, -12.488), (49.195, -12.041)]]], ['PAL', [[(35.398, 31.489), (34.927, 31.353), (34.971, 31.617), (35.226, 31.754), (34.975, 31.867), (35.184, 32.533), (35.546, 32.394), (35.545, 31.783)]]], ['GM', [[(-16.714, 13.595), (-15.625, 13.624), (-15.399, 13.86), (-15.082, 13.876), (-14.687, 13.63), (-14.377, 13.626), (-14.047, 13.794), (-13.845, 13.505), (-14.278, 13.281), (-14.712, 13.298), (-15.141, 13.51), (-15.512, 13.279), (-15.691, 13.27), (-15.931, 13.13), (-16.842, 13.151)]]], ['TN', [[(9.482, 30.308), (9.056, 32.103), (8.439, 32.506), (8.43, 32.748), (7.613, 33.344), (7.524, 34.097), (8.141, 34.655), (8.376, 35.48), (8.218, 36.433), (8.421, 36.946), (9.51, 37.35), (10.21, 37.23), (10.181, 36.724), (11.029, 37.092), (11.1, 36.9), (10.6, 36.41), (10.593, 35.947), (10.94, 35.699), (10.808, 34.834), (10.15, 34.331), (10.34, 33.786), (10.857, 33.769), (11.109, 33.293), (11.489, 33.137), (11.432, 32.369), (10.945, 32.082), (10.637, 31.761), (9.95, 31.376), (10.057, 30.962), (9.97, 30.539)]]], ['DZ', [[(-8.684, 27.396), (-8.665, 27.589), (-8.666, 27.656), (-8.674, 28.841), (-7.059, 29.579), (-6.061, 29.732), (-5.242, 30.0), (-4.86, 30.501), (-3.69, 30.897), (-3.647, 31.637), (-3.069, 31.724), (-2.617, 32.094), (-1.308, 32.263), (-1.125, 32.652), (-1.388, 32.864), (-1.733, 33.92), (-1.793, 34.528), (-2.17, 35.168), (-1.209, 35.715), (-0.127, 35.889), (0.504, 36.301), (1.467, 36.606), (3.162, 36.784), (4.816, 36.865), (5.32, 36.717), (6.262, 37.111), (7.33, 37.118), (7.737, 36.886), (8.421, 36.946), (8.218, 36.433), (8.376, 35.48), (8.141, 34.655), (7.524, 34.097), (7.613, 33.344), (8.43, 32.748), (8.439, 32.506), (9.056, 32.103), (9.482, 30.308), (9.806, 29.425), (9.86, 28.96), (9.684, 28.144), (9.756, 27.688), (9.629, 27.141), (9.716, 26.512), (9.319, 26.094), (9.911, 25.365), (9.948, 24.937), (10.304, 24.379), (10.771, 24.563), (11.561, 24.098), (12.0, 23.472), (8.573, 21.566), (5.678, 19.601), (4.267, 19.155), (3.158, 19.057), (3.147, 19.694), (2.684, 19.856), (2.061, 20.142), (1.823, 20.611), (-4.923, 24.975)]]], ['J', [[(35.546, 32.394), (35.72, 32.709), (36.834, 32.313), (38.792, 33.379), (39.195, 32.161), (39.005, 32.01), (37.002, 31.508), (37.999, 30.509), (37.668, 30.339), (37.504, 30.004), (36.741, 29.865), (36.501, 29.505), (36.069, 29.197), (34.956, 29.357), (34.923, 29.501), (35.421, 31.1), (35.398, 31.489), (35.545, 31.783)]]], ['AE', [[(51.58, 24.245), (51.757, 24.294), (51.794, 24.02), (52.577, 24.177), (53.404, 24.151), (54.008, 24.122), (54.693, 24.798), (55.439, 25.439), (56.071, 26.055), (56.261, 25.715), (56.397, 24.925), (55.886, 24.921), (55.804, 24.27), (55.981, 24.131), (55.529, 23.934), (55.526, 23.525), (55.234, 23.111), (55.208, 22.708), (55.007, 22.497), (52.001, 23.001), (51.618, 24.014)]]], ['QA', [[(50.81, 24.755), (50.744, 25.482), (51.013, 26.007), (51.286, 26.115), (51.589, 25.801), (51.607, 25.216), (51.39, 24.627), (51.112, 24.556)]]], ['KW', [[(47.975, 29.976), (48.183, 29.534), (48.094, 29.306), (48.416, 28.552), (47.709, 28.526), (47.46, 29.003), (46.569, 29.099), (47.303, 30.059)]]], ['IRQ', [[(39.195, 32.161), (38.792, 33.379), (41.006, 34.419), (41.384, 35.628), (41.29, 36.359), (41.837, 36.606), (42.35, 37.23), (42.779, 37.385), (43.942, 37.256), (44.293, 37.002), (44.773, 37.17), (45.421, 35.978), (46.076, 35.677), (46.152, 35.093), (45.648, 34.748), (45.417, 33.968), (46.109, 33.017), (47.335, 32.469), (47.849, 31.709), (47.685, 30.985), (48.005, 30.985), (48.015, 30.452), (48.568, 29.927), (47.975, 29.976), (47.303, 30.059), (46.569, 29.099), (44.709, 29.179), (41.89, 31.19), (40.4, 31.89)]]], ['OM', [[(55.208, 22.708), (55.234, 23.111), (55.526, 23.525), (55.529, 23.934), (55.981, 24.131), (55.804, 24.27), (55.886, 24.921), (56.397, 24.925), (56.845, 24.242), (57.403, 23.879), (58.137, 23.748), (58.729, 23.566), (59.181, 22.992), (59.45, 22.66), (59.808, 22.534), (59.806, 22.311), (59.442, 21.715), (59.282, 21.434), (58.861, 21.114), (58.488, 20.429), (58.034, 20.481), (57.826, 20.243), (57.666, 19.736), (57.789, 19.068), (57.694, 18.945), (57.234, 18.948), (56.61, 18.574), (56.512, 18.087), (56.284, 17.876), (55.661, 17.884), (55.27, 17.632), (55.275, 17.228), (54.791, 16.951), (54.239, 17.045), (53.571, 16.708), (53.109, 16.651), (52.782, 17.35), (52.0, 19.0), (55.0, 20.0), (55.667, 22.0)], [(56.261, 25.715), (56.071, 26.055), (56.362, 26.396), (56.486, 26.309), (56.391, 25.896)]]], ['VU', [[(167.217, -15.892), (167.845, -16.466), (167.515, -16.598), (167.18, -16.16)], [(166.793, -15.669), (166.65, -15.393), (166.629, -14.626), (167.108, -14.934), (167.27, -15.74), (167.001, -15.615)]]], ['KH', [[(102.585, 12.187), (102.348, 13.394), (102.988, 14.226), (104.281, 14.417), (105.219, 14.273), (106.044, 13.881), (106.496, 14.571), (107.383, 14.202), (107.615, 13.536), (107.491, 12.337), (105.811, 11.568), (106.25, 10.962), (105.2, 10.889), (104.334, 10.487), (103.497, 10.633), (103.091, 11.154)]]], ['TH', [[(105.219, 14.273), (104.281, 14.417), (102.988, 14.226), (102.348, 13.394), (102.585, 12.187), (101.687, 12.646), (100.832, 12.627), (100.978, 13.413), (100.098, 13.407), (100.019, 12.307), (99.479, 10.846), (99.154, 9.963), (99.222, 9.239), (99.874, 9.208), (100.28, 8.295), (100.459, 7.43), (101.017, 6.857), (101.623, 6.741), (102.141, 6.222), (101.814, 5.811), (101.154, 5.691), (101.076, 6.205), (100.26, 6.643), (100.086, 6.464), (99.691, 6.848), (99.52, 7.343), (98.988, 7.908), (98.504, 8.382), (98.34, 7.795), (98.15, 8.35), (98.259, 8.974), (98.554, 9.933), (99.038, 10.961), (99.587, 11.893), (99.196, 12.805), (99.212, 13.269), (99.098, 13.828), (98.431, 14.622), (98.192, 15.124), (98.537, 15.308), (98.903, 16.178), (98.494, 16.838), (97.859, 17.568), (97.376, 18.445), (97.798, 18.627), (98.254, 19.708), (98.96, 19.753), (99.543, 20.187), (100.116, 20.418), (100.549, 20.109), (100.606, 19.508), (101.282, 19.463), (101.036, 18.409), (101.06, 17.512), (102.114, 18.109), (102.413, 17.933), (102.999, 17.962), (103.2, 18.31), (103.956, 18.241), (104.717, 17.429), (104.779, 16.442), (105.589, 15.57), (105.544, 14.724)]]], ['LA', [[(107.383, 14.202), (106.496, 14.571), (106.044, 13.881), (105.219, 14.273), (105.544, 14.724), (105.589, 15.57), (104.779, 16.442), (104.717, 17.429), (103.956, 18.241), (103.2, 18.31), (102.999, 17.962), (102.413, 17.933), (102.114, 18.109), (101.06, 17.512), (101.036, 18.409), (101.282, 19.463), (100.606, 19.508), (100.549, 20.109), (100.116, 20.418), (100.329, 20.786), (101.18, 21.437), (101.27, 21.202), (101.803, 21.174), (101.652, 22.318), (102.17, 22.465), (102.755, 21.675), (103.204, 20.767), (104.435, 20.759), (104.823, 19.887), (104.183, 19.625), (103.897, 19.265), (105.095, 18.667), (105.926, 17.485), (106.556, 16.604), (107.313, 15.909), (107.565, 15.202)]]], ['MM', [[(100.116, 20.418), (99.543, 20.187), (98.96, 19.753), (98.254, 19.708), (97.798, 18.627), (97.376, 18.445), (97.859, 17.568), (98.494, 16.838), (98.903, 16.178), (98.537, 15.308), (98.192, 15.124), (98.431, 14.622), (99.098, 13.828), (99.212, 13.269), (99.196, 12.805), (99.587, 11.893), (99.038, 10.961), (98.554, 9.933), (98.457, 10.675), (98.765, 11.441), (98.428, 12.033), (98.51, 13.122), (98.104, 13.64), (97.778, 14.837), (97.597, 16.101), (97.165, 16.929), (96.506, 16.427), (95.369, 15.714), (94.808, 15.803), (94.189, 16.038), (94.533, 17.277), (94.325, 18.214), (93.541, 19.366), (93.663, 19.727), (93.078, 19.855), (92.369, 20.671), (92.303, 21.475), (92.652, 21.324), (92.673, 22.041), (93.166, 22.278), (93.06, 22.703), (93.286, 23.044), (93.325, 24.079), (94.107, 23.851), (94.553, 24.675), (94.603, 25.162), (95.155, 26.001), (95.125, 26.574), (96.419, 27.265), (97.134, 27.084), (97.052, 27.699), (97.403, 27.883), (97.327, 28.262), (97.912, 28.336), (98.246, 27.747), (98.683, 27.509), (98.712, 26.744), (98.672, 25.919), (97.725, 25.084), (97.605, 23.897), (98.66, 24.063), (98.899, 23.143), (99.532, 22.949), (99.241, 22.118), (99.983, 21.743), (100.417, 21.559), (101.15, 21.85), (101.18, 21.437), (100.329, 20.786)]]], ['VN', [[(104.334, 10.487), (105.2, 10.889), (106.25, 10.962), (105.811, 11.568), (107.491, 12.337), (107.615, 13.536), (107.383, 14.202), (107.565, 15.202), (107.313, 15.909), (106.556, 16.604), (105.926, 17.485), (105.095, 18.667), (103.897, 19.265), (104.183, 19.625), (104.823, 19.887), (104.435, 20.759), (103.204, 20.767), (102.755, 21.675), (102.17, 22.465), (102.707, 22.709), (103.505, 22.704), (104.477, 22.819), (105.329, 23.352), (105.811, 22.977), (106.725, 22.794), (106.567, 22.218), (107.043, 21.812), (108.05, 21.552), (106.715, 20.697), (105.882, 19.752), (105.662, 19.058), (106.427, 18.004), (107.362, 16.697), (108.269, 16.08), (108.877, 15.277), (109.335, 13.426), (109.2, 11.667), (108.366, 11.008), (107.221, 10.364), (106.405, 9.531), (105.158, 8.6), (104.795, 9.241), (105.076, 9.918)]]], ['KP', [[(130.78, 42.22), (130.78, 42.22), (130.78, 42.22)], [(130.64, 42.395), (130.64, 42.395), (130.78, 42.22), (130.4, 42.28), (129.966, 41.941), (129.667, 41.601), (129.705, 40.883), (129.188, 40.662), (129.01, 40.485), (128.633, 40.19), (127.967, 40.025), (127.533, 39.757), (127.502, 39.324), (127.385, 39.213), (127.783, 39.051), (128.35, 38.612), (128.206, 38.37), (127.78, 38.305), (127.073, 38.256), (126.684, 37.805), (126.237, 37.84), (126.175, 37.75), (125.689, 37.94), (125.568, 37.752), (125.275, 37.669), (125.24, 37.857), (124.981, 37.949), (124.712, 38.108), (124.986, 38.548), (125.222, 38.666), (125.133, 38.849), (125.387, 39.388), (125.321, 39.551), (124.737, 39.66), (124.266, 39.928), (125.08, 40.57), (126.182, 41.107), (126.869, 41.817), (127.344, 41.503), (128.208, 41.467), (128.052, 41.994), (129.597, 42.425), (129.994, 42.985)]]], ['KR', [[(126.175, 37.75), (126.237, 37.84), (126.684, 37.805), (127.073, 38.256), (127.78, 38.305), (128.206, 38.37), (128.35, 38.612), (129.213, 37.432), (129.46, 36.784), (129.468, 35.632), (129.091, 35.082), (128.186, 34.89), (127.387, 34.476), (126.486, 34.39), (126.374, 34.935), (126.559, 35.685), (126.117, 36.725), (126.86, 36.894)]]], ['MN', [[(87.751, 49.297), (88.806, 49.471), (90.714, 50.332), (92.235, 50.802), (93.104, 50.495), (94.148, 50.481), (94.816, 50.013), (95.814, 49.977), (97.26, 49.726), (98.232, 50.422), (97.826, 51.011), (98.861, 52.047), (99.982, 51.634), (100.889, 51.517), (102.065, 51.26), (102.256, 50.511), (103.677, 50.09), (104.622, 50.275), (105.887, 50.406), (106.889, 50.274), (107.868, 49.794), (108.475, 49.283), (109.402, 49.293), (110.662, 49.13), (111.581, 49.378), (112.898, 49.544), (114.362, 50.248), (114.962, 50.14), (115.486, 49.805), (116.679, 49.889), (116.192, 49.135), (115.485, 48.135), (115.743, 47.727), (116.309, 47.853), (117.296, 47.698), (118.064, 48.067), (118.867, 47.747), (119.773, 47.048), (119.663, 46.693), (118.874, 46.805), (117.422, 46.673), (116.718, 46.388), (115.985, 45.727), (114.46, 45.34), (113.464, 44.809), (112.436, 45.012), (111.873, 45.102), (111.348, 44.457), (111.668, 44.073), (111.83, 43.743), (111.13, 43.407), (110.412, 42.871), (109.244, 42.519), (107.745, 42.482), (106.129, 42.134), (104.965, 41.597), (104.522, 41.908), (103.312, 41.907), (101.833, 42.515), (100.846, 42.664), (99.516, 42.525), (97.452, 42.749), (96.349, 42.726), (95.762, 43.319), (95.307, 44.241), (94.689, 44.352), (93.481, 44.975), (92.134, 45.115), (90.946, 45.286), (90.586, 45.72), (90.971, 46.888), (90.281, 47.694), (88.854, 48.069), (88.014, 48.599)]]], ['IND', [[(97.327, 28.262), (97.403, 27.883), (97.052, 27.699), (97.134, 27.084), (96.419, 27.265), (95.125, 26.574), (95.155, 26.001), (94.603, 25.162), (94.553, 24.675), (94.107, 23.851), (93.325, 24.079), (93.286, 23.044), (93.06, 22.703), (93.166, 22.278), (92.673, 22.041), (92.146, 23.627), (91.87, 23.624), (91.706, 22.985), (91.159, 23.504), (91.468, 24.073), (91.915, 24.13), (92.376, 24.977), (91.8, 25.147), (90.872, 25.133), (89.921, 25.27), (89.832, 25.965), (89.355, 26.014), (88.563, 26.447), (88.21, 25.768), (88.932, 25.239), (88.306, 24.866), (88.084, 24.502), (88.7, 24.234), (88.53, 23.631), (88.876, 22.879), (89.032, 22.056), (88.889, 21.691), (88.208, 21.703), (86.976, 21.496), (87.033, 20.743), (86.499, 20.152), (85.06, 19.479), (83.941, 18.302), (83.189, 17.671), (82.193, 17.017), (82.191, 16.557), (81.693, 16.31), (80.792, 15.952), (80.325, 15.899), (80.025, 15.136), (80.233, 13.836), (80.286, 13.006), (79.863, 12.056), (79.858, 10.357), (79.341, 10.309), (78.885, 9.546), (79.19, 9.217), (78.278, 8.933), (77.941, 8.253), (77.54, 7.966), (76.593, 8.899), (76.13, 10.3), (75.746, 11.308), (75.396, 11.781), (74.865, 12.742), (74.617, 13.993), (74.444, 14.617), (73.534, 15.991), (73.12, 17.929), (72.821, 19.208), (72.824, 20.42), (72.631, 21.356), (71.175, 20.757), (70.47, 20.877), (69.164, 22.089), (69.645, 22.451), (69.35, 22.843), (68.177, 23.692), (68.843, 24.359), (71.043, 24.357), (70.845, 25.215), (70.283, 25.722), (70.169, 26.492), (69.514, 26.941), (70.616, 27.989), (71.778, 27.913), (72.824, 28.962), (73.451, 29.976), (74.421, 30.98), (74.406, 31.693), (75.259, 32.271), (74.452, 32.765), (74.104, 33.441), (73.75, 34.318), (74.24, 34.749), (75.757, 34.505), (76.872, 34.654), (77.837, 35.494), (78.912, 34.322), (78.811, 33.506), (79.209, 32.994), (79.176, 32.484), (78.458, 32.618), (78.739, 31.516), (79.721, 30.883), (81.111, 30.183), (80.477, 29.73), (80.088, 28.794), (81.057, 28.416), (82.0, 27.925), (83.304, 27.365), (84.675, 27.235), (85.252, 26.726), (86.024, 26.631), (87.227, 26.398), (88.06, 26.415), (88.175, 26.81), (88.043, 27.446), (88.12, 27.877), (88.73, 28.087), (88.814, 27.299), (88.836, 27.099), (89.745, 26.719), (90.373, 26.876), (91.218, 26.809), (92.033, 26.838), (92.104, 27.453), (91.697, 27.772), (92.503, 27.897), (93.413, 28.641), (94.566, 29.277), (95.405, 29.032), (96.118, 29.453), (96.587, 28.831), (96.249, 28.411)]]], ['BD', [[(92.673, 22.041), (92.652, 21.324), (92.303, 21.475), (92.369, 20.671), (92.083, 21.192), (92.025, 21.702), (91.835, 22.183), (91.417, 22.765), (90.496, 22.805), (90.587, 22.393), (90.273, 21.836), (89.847, 22.039), (89.702, 21.857), (89.419, 21.966), (89.032, 22.056), (88.876, 22.879), (88.53, 23.631), (88.7, 24.234), (88.084, 24.502), (88.306, 24.866), (88.932, 25.239), (88.21, 25.768), (88.563, 26.447), (89.355, 26.014), (89.832, 25.965), (89.921, 25.27), (90.872, 25.133), (91.8, 25.147), (92.376, 24.977), (91.915, 24.13), (91.468, 24.073), (91.159, 23.504), (91.706, 22.985), (91.87, 23.624), (92.146, 23.627)]]], ['BT', [[(91.697, 27.772), (92.104, 27.453), (92.033, 26.838), (91.218, 26.809), (90.373, 26.876), (89.745, 26.719), (88.836, 27.099), (88.814, 27.299), (89.476, 28.043), (90.016, 28.296), (90.731, 28.065), (91.259, 28.041)]]], ['NP', [[(88.12, 27.877), (88.043, 27.446), (88.175, 26.81), (88.06, 26.415), (87.227, 26.398), (86.024, 26.631), (85.252, 26.726), (84.675, 27.235), (83.304, 27.365), (82.0, 27.925), (81.057, 28.416), (80.088, 28.794), (80.477, 29.73), (81.111, 30.183), (81.526, 30.423), (82.328, 30.115), (83.337, 29.464), (83.899, 29.32), (84.235, 28.84), (85.012, 28.643), (85.823, 28.204), (86.955, 27.974)]]], ['PK', [[(77.837, 35.494), (76.872, 34.654), (75.757, 34.505), (74.24, 34.749), (73.75, 34.318), (74.104, 33.441), (74.452, 32.765), (75.259, 32.271), (74.406, 31.693), (74.421, 30.98), (73.451, 29.976), (72.824, 28.962), (71.778, 27.913), (70.616, 27.989), (69.514, 26.941), (70.169, 26.492), (70.283, 25.722), (70.845, 25.215), (71.043, 24.357), (68.843, 24.359), (68.177, 23.692), (67.444, 23.945), (67.145, 24.664), (66.373, 25.425), (64.53, 25.237), (62.906, 25.218), (61.497, 25.078), (61.874, 26.24), (63.317, 26.757), (63.234, 27.217), (62.755, 27.379), (62.728, 28.26), (61.772, 28.699), (61.369, 29.303), (60.874, 29.829), (62.55, 29.319), (63.55, 29.468), (64.148, 29.341), (64.35, 29.56), (65.047, 29.472), (66.346, 29.888), (66.381, 30.739), (66.939, 31.305), (67.683, 31.303), (67.793, 31.583), (68.557, 31.713), (68.927, 31.62), (69.318, 31.901), (69.263, 32.502), (69.687, 33.105), (70.324, 33.359), (69.931, 34.02), (70.882, 33.989), (71.157, 34.349), (71.115, 34.733), (71.613, 35.153), (71.499, 35.651), (71.262, 36.074), (71.846, 36.51), (72.92, 36.72), (74.068, 36.836), (74.576, 37.021), (75.158, 37.133), (75.897, 36.667), (76.193, 35.898)]]], ['AF', [[(66.519, 37.363), (67.076, 37.356), (67.83, 37.145), (68.136, 37.023), (68.859, 37.344), (69.196, 37.151), (69.519, 37.609), (70.117, 37.588), (70.271, 37.735), (70.376, 38.138), (70.807, 38.486), (71.348, 38.259), (71.239, 37.953), (71.542, 37.906), (71.449, 37.066), (71.845, 36.738), (72.193, 36.948), (72.637, 37.048), (73.26, 37.495), (73.949, 37.422), (74.98, 37.42), (75.158, 37.133), (74.576, 37.021), (74.068, 36.836), (72.92, 36.72), (71.846, 36.51), (71.262, 36.074), (71.499, 35.651), (71.613, 35.153), (71.115, 34.733), (71.157, 34.349), (70.882, 33.989), (69.931, 34.02), (70.324, 33.359), (69.687, 33.105), (69.263, 32.502), (69.318, 31.901), (68.927, 31.62), (68.557, 31.713), (67.793, 31.583), (67.683, 31.303), (66.939, 31.305), (66.381, 30.739), (66.346, 29.888), (65.047, 29.472), (64.35, 29.56), (64.148, 29.341), (63.55, 29.468), (62.55, 29.319), (60.874, 29.829), (61.781, 30.736), (61.699, 31.38), (60.942, 31.548), (60.864, 32.183), (60.536, 32.981), (60.964, 33.529), (60.528, 33.676), (60.803, 34.404), (61.211, 35.65), (62.231, 35.271), (62.985, 35.404), (63.194, 35.857), (63.983, 36.008), (64.546, 36.312), (64.746, 37.112), (65.589, 37.305), (65.746, 37.661), (66.217, 37.394)]]], ['TJ', [[(67.83, 37.145), (68.392, 38.157), (68.176, 38.902), (67.442, 39.14), (67.701, 39.58), (68.536, 39.533), (69.012, 40.086), (69.329, 40.728), (70.667, 40.96), (70.458, 40.496), (70.601, 40.219), (71.014, 40.244), (70.648, 39.936), (69.56, 40.103), (69.465, 39.527), (70.549, 39.604), (71.785, 39.279), (73.675, 39.431), (73.929, 38.506), (74.258, 38.607), (74.865, 38.379), (74.83, 37.99), (74.98, 37.42), (73.949, 37.422), (73.26, 37.495), (72.637, 37.048), (72.193, 36.948), (71.845, 36.738), (71.449, 37.066), (71.542, 37.906), (71.239, 37.953), (71.348, 38.259), (70.807, 38.486), (70.376, 38.138), (70.271, 37.735), (70.117, 37.588), (69.519, 37.609), (69.196, 37.151), (68.859, 37.344), (68.136, 37.023)]]], ['KG', [[(70.962, 42.266), (71.186, 42.704), (71.845, 42.845), (73.49, 42.501), (73.645, 43.091), (74.213, 43.298), (75.637, 42.878), (76.0, 42.988), (77.658, 42.961), (79.142, 42.856), (79.644, 42.497), (80.26, 42.35), (80.119, 42.124), (78.544, 41.582), (78.187, 41.185), (76.904, 41.066), (76.526, 40.428), (75.468, 40.562), (74.777, 40.366), (73.822, 39.894), (73.96, 39.66), (73.675, 39.431), (71.785, 39.279), (70.549, 39.604), (69.465, 39.527), (69.56, 40.103), (70.648, 39.936), (71.014, 40.244), (71.775, 40.146), (73.055, 40.866), (71.87, 41.393), (71.158, 41.144), (70.42, 41.52), (71.259, 42.168)]]], ['TM', [[(52.502, 41.783), (52.944, 42.116), (54.079, 42.324), (54.755, 42.044), (55.455, 41.26), (55.968, 41.309), (57.096, 41.322), (56.932, 41.826), (57.787, 42.171), (58.629, 42.752), (59.976, 42.223), (60.083, 41.425), (60.466, 41.22), (61.547, 41.266), (61.883, 41.085), (62.374, 40.054), (63.518, 39.363), (64.17, 38.892), (65.216, 38.403), (66.546, 37.975), (66.519, 37.363), (66.217, 37.394), (65.746, 37.661), (65.589, 37.305), (64.746, 37.112), (64.546, 36.312), (63.983, 36.008), (63.194, 35.857), (62.985, 35.404), (62.231, 35.271), (61.211, 35.65), (61.123, 36.492), (60.378, 36.527), (59.235, 37.413), (58.436, 37.522), (57.33, 38.029), (56.619, 38.121), (56.18, 37.935), (55.512, 37.964), (54.8, 37.392), (53.922, 37.199), (53.736, 37.906), (53.881, 38.952), (53.101, 39.291), (53.358, 39.975), (52.694, 40.034), (52.915, 40.877), (53.858, 40.631), (54.737, 40.951), (54.008, 41.551), (53.722, 42.123), (52.917, 41.868), (52.815, 41.135)]]], ['IRN', [[(48.568, 29.927), (48.015, 30.452), (48.005, 30.985), (47.685, 30.985), (47.849, 31.709), (47.335, 32.469), (46.109, 33.017), (45.417, 33.968), (45.648, 34.748), (46.152, 35.093), (46.076, 35.677), (45.421, 35.978), (44.773, 37.17), (44.773, 37.17), (44.226, 37.972), (44.421, 38.281), (44.109, 39.428), (44.794, 39.713), (44.953, 39.336), (45.458, 38.874), (46.144, 38.741), (46.506, 38.771), (47.685, 39.508), (48.06, 39.582), (48.356, 39.289), (48.011, 38.794), (48.634, 38.27), (48.883, 38.32), (49.2, 37.583), (50.148, 37.375), (50.842, 36.873), (52.264, 36.7), (53.826, 36.965), (53.922, 37.199), (54.8, 37.392), (55.512, 37.964), (56.18, 37.935), (56.619, 38.121), (57.33, 38.029), (58.436, 37.522), (59.235, 37.413), (60.378, 36.527), (61.123, 36.492), (61.211, 35.65), (60.803, 34.404), (60.528, 33.676), (60.964, 33.529), (60.536, 32.981), (60.864, 32.183), (60.942, 31.548), (61.699, 31.38), (61.781, 30.736), (60.874, 29.829), (61.369, 29.303), (61.772, 28.699), (62.728, 28.26), (62.755, 27.379), (63.234, 27.217), (63.317, 26.757), (61.874, 26.24), (61.497, 25.078), (59.616, 25.38), (58.526, 25.61), (57.397, 25.74), (56.971, 26.966), (56.492, 27.143), (55.724, 26.965), (54.715, 26.481), (53.493, 26.812), (52.484, 27.581), (51.521, 27.866), (50.853, 28.815), (50.115, 30.148), (49.577, 29.986), (48.941, 30.317)]]], ['SYR', [[(35.72, 32.709), (35.701, 32.716), (35.836, 32.868), (35.821, 33.277), (36.066, 33.825), (36.612, 34.202), (36.448, 34.594), (35.998, 34.645), (35.905, 35.41), (36.15, 35.822), (36.418, 36.041), (36.685, 36.26), (36.739, 36.818), (37.067, 36.623), (38.168, 36.901), (38.7, 36.713), (39.523, 36.716), (40.673, 37.091), (41.212, 37.074), (42.35, 37.23), (41.837, 36.606), (41.29, 36.359), (41.384, 35.628), (41.006, 34.419), (38.792, 33.379), (36.834, 32.313)]]], ['ARM', [[(46.506, 38.771), (46.144, 38.741), (45.735, 39.32), (45.74, 39.474), (45.298, 39.472), (45.002, 39.74), (44.794, 39.713), (44.4, 40.005), (43.656, 40.254), (43.753, 40.74), (43.583, 41.092), (44.972, 41.248), (45.179, 40.985), (45.56, 40.812), (45.359, 40.562), (45.892, 40.218), (45.61, 39.9), (46.035, 39.628), (46.483, 39.464)]]], ['S', [[(11.027, 58.856), (11.468, 59.432), (12.3, 60.118), (12.631, 61.294), (11.992, 61.8), (11.931, 63.128), (12.58, 64.066), (13.572, 64.049), (13.92, 64.445), (13.556, 64.787), (15.108, 66.194), (16.109, 67.302), (16.769, 68.014), (17.729, 68.011), (17.994, 68.567), (19.879, 68.407), (20.025, 69.065), (20.646, 69.106), (21.979, 68.617), (23.539, 67.936), (23.566, 66.396), (23.903, 66.007), (22.183, 65.724), (21.214, 65.026), (21.37, 64.414), (19.779, 63.61), (17.848, 62.749), (17.12, 61.341), (17.831, 60.637), (18.788, 60.082), (17.869, 58.954), (16.829, 58.72), (16.448, 57.041), (15.88, 56.104), (14.667, 56.201), (14.101, 55.408), (12.943, 55.362), (12.625, 56.307), (11.788, 57.442)]]], ['BY', [[(28.177, 56.169), (29.23, 55.918), (29.372, 55.67), (29.896, 55.789), (30.874, 55.551), (30.972, 55.082), (30.758, 54.812), (31.384, 54.157), (31.791, 53.975), (31.731, 53.794), (32.406, 53.618), (32.694, 53.351), (32.305, 53.133), (31.498, 53.167), (31.305, 53.074), (31.54, 52.742), (31.786, 52.102), (31.786, 52.102), (30.928, 52.042), (30.619, 51.823), (30.555, 51.32), (30.157, 51.416), (29.255, 51.368), (28.993, 51.602), (28.618, 51.428), (28.242, 51.572), (27.454, 51.592), (26.338, 51.832), (25.328, 51.911), (24.553, 51.888), (24.005, 51.617), (23.527, 51.578), (23.508, 52.024), (23.199, 52.487), (23.799, 52.691), (23.805, 53.09), (23.528, 53.47), (23.484, 53.912), (24.451, 53.906), (25.536, 54.282), (25.768, 54.847), (26.588, 55.167), (26.494, 55.615), (27.102, 55.783)]]], ['UA', [[(31.786, 52.102), (32.159, 52.061), (32.412, 52.289), (32.716, 52.238), (33.753, 52.335), (34.392, 51.769), (34.142, 51.566), (34.225, 51.256), (35.022, 51.208), (35.378, 50.774), (35.356, 50.577), (36.626, 50.226), (37.393, 50.384), (38.011, 49.916), (38.595, 49.926), (40.069, 49.601), (40.081, 49.307), (39.675, 48.784), (39.896, 48.232), (39.738, 47.899), (38.771, 47.826), (38.255, 47.546), (38.224, 47.102), (37.425, 47.022), (36.76, 46.699), (35.824, 46.646), (34.962, 46.273), (35.013, 45.738), (34.862, 45.768), (34.732, 45.966), (34.41, 46.005), (33.699, 46.22), (33.436, 45.972), (33.299, 46.081), (31.744, 46.333), (31.675, 46.706), (30.749, 46.583), (30.378, 46.032), (29.603, 45.293), (29.15, 45.465), (28.68, 45.304), (28.234, 45.488), (28.485, 45.597), (28.66, 45.94), (28.934, 46.259), (28.863, 46.438), (29.072, 46.518), (29.171, 46.379), (29.76, 46.35), (30.025, 46.424), (29.838, 46.525), (29.909, 46.674), (29.56, 46.929), (29.415, 47.347), (29.051, 47.51), (29.123, 47.849), (28.671, 48.118), (28.26, 48.156), (27.523, 48.467), (26.858, 48.368), (26.619, 48.221), (26.197, 48.221), (25.946, 47.987), (25.208, 47.891), (24.866, 47.738), (24.402, 47.982), (23.761, 47.986), (23.142, 48.096), (22.711, 47.882), (22.641, 48.15), (22.086, 48.422), (22.281, 48.825), (22.558, 49.086), (22.776, 49.027), (22.518, 49.477), (23.427, 50.309), (23.923, 50.425), (24.03, 50.705), (23.527, 51.578), (24.005, 51.617), (24.553, 51.888), (25.328, 51.911), (26.338, 51.832), (27.454, 51.592), (28.242, 51.572), (28.618, 51.428), (28.993, 51.602), (29.255, 51.368), (30.157, 51.416), (30.555, 51.32), (30.619, 51.823), (30.928, 52.042)]]], ['PL', [[(23.484, 53.912), (23.528, 53.47), (23.805, 53.09), (23.799, 52.691), (23.199, 52.487), (23.508, 52.024), (23.527, 51.578), (24.03, 50.705), (23.923, 50.425), (23.427, 50.309), (22.518, 49.477), (22.776, 49.027), (22.558, 49.086), (21.608, 49.47), (20.888, 49.329), (20.416, 49.431), (19.825, 49.217), (19.321, 49.572), (18.91, 49.436), (18.853, 49.496), (18.393, 49.989), (17.649, 50.049), (17.555, 50.362), (16.869, 50.474), (16.719, 50.216), (16.176, 50.423), (16.239, 50.698), (15.491, 50.785), (15.017, 51.107), (14.607, 51.745), (14.685, 52.09), (14.438, 52.625), (14.075, 52.981), (14.353, 53.248), (14.12, 53.757), (14.803, 54.051), (16.363, 54.513), (17.623, 54.852), (18.621, 54.683), (18.696, 54.439), (19.661, 54.426), (20.892, 54.313), (22.731, 54.328), (23.244, 54.221)]]], ['A', [[(16.98, 48.123), (16.904, 47.715), (16.341, 47.713), (16.534, 47.496), (16.202, 46.852), (16.012, 46.684), (15.137, 46.659), (14.632, 46.432), (13.806, 46.509), (12.376, 46.768), (12.153, 47.115), (11.165, 46.942), (11.049, 46.751), (10.443, 46.894), (9.932, 46.921), (9.48, 47.103), (9.633, 47.348), (9.594, 47.525), (9.896, 47.58), (10.402, 47.302), (10.545, 47.566), (11.426, 47.524), (12.141, 47.703), (12.621, 47.672), (12.933, 47.468), (13.026, 47.638), (12.884, 48.289), (13.243, 48.416), (13.596, 48.877), (14.339, 48.555), (14.901, 48.964), (15.253, 49.039), (16.03, 48.734), (16.499, 48.786), (16.96, 48.597), (16.88, 48.47)]]], ['HU', [[(22.086, 48.422), (22.641, 48.15), (22.711, 47.882), (22.1, 47.672), (21.627, 46.994), (21.022, 46.316), (20.22, 46.127), (19.596, 46.172), (18.83, 45.909), (18.83, 45.909), (18.456, 45.759), (17.63, 45.952), (16.883, 46.381), (16.565, 46.504), (16.371, 46.841), (16.202, 46.852), (16.534, 47.496), (16.341, 47.713), (16.904, 47.715), (16.98, 48.123), (17.488, 47.867), (17.857, 47.758), (18.697, 47.881), (18.777, 48.082), (19.174, 48.111), (19.661, 48.267), (19.769, 48.203), (20.239, 48.328), (20.474, 48.563), (20.801, 48.624), (21.872, 48.32)]]], ['MD', [[(26.619, 48.221), (26.858, 48.368), (27.523, 48.467), (28.26, 48.156), (28.671, 48.118), (29.123, 47.849), (29.051, 47.51), (29.415, 47.347), (29.56, 46.929), (29.909, 46.674), (29.838, 46.525), (30.025, 46.424), (29.76, 46.35), (29.171, 46.379), (29.072, 46.518), (28.863, 46.438), (28.934, 46.259), (28.66, 45.94), (28.485, 45.597), (28.234, 45.488), (28.054, 45.945), (28.16, 46.372), (28.128, 46.81), (27.551, 47.405), (27.234, 47.827), (26.924, 48.123)]]], ['RO', [[(28.234, 45.488), (28.68, 45.304), (29.15, 45.465), (29.603, 45.293), (29.627, 45.035), (29.142, 44.82), (28.838, 44.914), (28.558, 43.707), (27.97, 43.812), (27.242, 44.176), (26.065, 43.943), (25.569, 43.688), (24.101, 43.741), (23.332, 43.897), (22.945, 43.824), (22.657, 44.235), (22.474, 44.409), (22.706, 44.578), (22.459, 44.703), (22.145, 44.478), (21.562, 44.769), (21.484, 45.181), (20.874, 45.416), (20.762, 45.735), (20.22, 46.127), (21.022, 46.316), (21.627, 46.994), (22.1, 47.672), (22.711, 47.882), (23.142, 48.096), (23.761, 47.986), (24.402, 47.982), (24.866, 47.738), (25.208, 47.891), (25.946, 47.987), (26.197, 48.221), (26.619, 48.221), (26.924, 48.123), (27.234, 47.827), (27.551, 47.405), (28.128, 46.81), (28.16, 46.372), (28.054, 45.945)]]], ['LT', [[(26.494, 55.615), (26.588, 55.167), (25.768, 54.847), (25.536, 54.282), (24.451, 53.906), (23.484, 53.912), (23.244, 54.221), (22.731, 54.328), (22.651, 54.583), (22.758, 54.857), (22.316, 55.015), (21.268, 55.19), (21.056, 56.031), (22.201, 56.338), (23.878, 56.274), (24.861, 56.373), (25.001, 56.165), (25.533, 56.1)]]], ['LV', [[(27.288, 57.475), (27.77, 57.244), (27.855, 56.759), (28.177, 56.169), (27.102, 55.783), (26.494, 55.615), (25.533, 56.1), (25.001, 56.165), (24.861, 56.373), (23.878, 56.274), (22.201, 56.338), (21.056, 56.031), (21.09, 56.784), (21.582, 57.412), (22.524, 57.753), (23.318, 57.006), (24.121, 57.026), (24.313, 57.793), (25.165, 57.97), (25.603, 57.848), (26.464, 57.476)]]], ['EST', [[(27.981, 59.475), (27.981, 59.475), (28.132, 59.301), (27.42, 58.725), (27.717, 57.792), (27.288, 57.475), (26.464, 57.476), (25.603, 57.848), (25.165, 57.97), (24.313, 57.793), (24.429, 58.383), (24.061, 58.257), (23.427, 58.613), (23.34, 59.187), (24.604, 59.466), (25.864, 59.611), (26.949, 59.446), (27.981, 59.475)]]], ['D', [[(14.12, 53.757), (14.353, 53.248), (14.075, 52.981), (14.438, 52.625), (14.685, 52.09), (14.607, 51.745), (15.017, 51.107), (14.571, 51.002), (14.307, 51.117), (14.056, 50.927), (13.338, 50.733), (12.967, 50.484), (12.24, 50.266), (12.415, 49.969), (12.521, 49.547), (13.031, 49.307), (13.596, 48.877), (13.243, 48.416), (12.884, 48.289), (13.026, 47.638), (12.933, 47.468), (12.621, 47.672), (12.141, 47.703), (11.426, 47.524), (10.545, 47.566), (10.402, 47.302), (9.896, 47.58), (9.594, 47.525), (8.523, 47.831), (8.317, 47.614), (7.467, 47.621), (7.594, 48.333), (8.099, 49.018), (6.658, 49.202), (6.186, 49.464), (6.243, 49.902), (6.043, 50.128), (6.157, 50.804), (5.989, 51.852), (6.589, 51.852), (6.843, 52.228), (7.092, 53.144), (6.905, 53.482), (7.1, 53.694), (7.936, 53.748), (8.122, 53.528), (8.801, 54.021), (8.572, 54.396), (8.526, 54.963), (9.282, 54.831), (9.922, 54.983), (9.94, 54.597), (10.95, 54.364), (10.939, 54.009), (11.956, 54.196), (12.518, 54.47), (13.647, 54.076)]]], ['BG', [[(22.657, 44.235), (22.945, 43.824), (23.332, 43.897), (24.101, 43.741), (25.569, 43.688), (26.065, 43.943), (27.242, 44.176), (27.97, 43.812), (28.558, 43.707), (28.039, 43.293), (27.674, 42.578), (27.997, 42.007), (27.136, 42.141), (26.117, 41.827), (26.106, 41.329), (25.197, 41.234), (24.493, 41.584), (23.692, 41.309), (22.952, 41.338), (22.881, 41.999), (22.381, 42.32), (22.545, 42.461), (22.437, 42.58), (22.605, 42.899), (22.986, 43.211), (22.5, 43.643), (22.41, 44.008)]]], ['GR', [[(26.29, 35.3), (26.165, 35.005), (24.725, 34.92), (24.735, 35.085), (23.515, 35.28), (23.7, 35.705), (24.247, 35.368), (25.025, 35.425), (25.769, 35.354), (25.745, 35.18)], [(22.952, 41.338), (23.692, 41.309), (24.493, 41.584), (25.197, 41.234), (26.106, 41.329), (26.117, 41.827), (26.604, 41.562), (26.295, 40.936), (26.057, 40.824), (25.448, 40.853), (24.926, 40.947), (23.715, 40.687), (24.408, 40.125), (23.9, 39.962), (23.343, 39.961), (22.814, 40.476), (22.626, 40.257), (22.85, 39.659), (23.35, 39.19), (22.973, 38.971), (23.53, 38.51), (24.025, 38.22), (24.04, 37.655), (23.115, 37.92), (23.41, 37.41), (22.775, 37.305), (23.154, 36.423), (22.49, 36.41), (21.67, 36.845), (21.295, 37.645), (21.12, 38.31), (20.73, 38.77), (20.218, 39.34), (20.15, 39.625), (20.615, 40.11), (20.675, 40.435), (21.0, 40.58), (21.02, 40.843), (21.674, 40.931), (22.055, 41.15), (22.597, 41.13), (22.762, 41.305)]]], ['TR', [[(44.773, 37.17), (44.293, 37.002), (43.942, 37.256), (42.779, 37.385), (42.35, 37.23), (41.212, 37.074), (40.673, 37.091), (39.523, 36.716), (38.7, 36.713), (38.168, 36.901), (37.067, 36.623), (36.739, 36.818), (36.685, 36.26), (36.418, 36.041), (36.15, 35.822), (35.782, 36.275), (36.161, 36.651), (35.551, 36.565), (34.715, 36.796), (34.027, 36.22), (32.509, 36.108), (31.7, 36.644), (30.622, 36.678), (30.391, 36.263), (29.7, 36.144), (28.733, 36.677), (27.641, 36.659), (27.049, 37.653), (26.318, 38.208), (26.805, 38.986), (26.171, 39.464), (27.28, 40.42), (28.82, 40.46), (29.24, 41.22), (31.146, 41.088), (32.348, 41.736), (33.513, 42.019), (35.168, 42.04), (36.913, 41.335), (38.348, 40.949), (39.513, 41.103), (40.373, 41.014), (41.554, 41.536), (42.62, 41.583), (43.583, 41.092), (43.753, 40.74), (43.656, 40.254), (44.4, 40.005), (44.794, 39.713), (44.109, 39.428), (44.421, 38.281), (44.226, 37.972), (44.773, 37.17)], [(26.117, 41.827), (27.136, 42.141), (27.997, 42.007), (28.116, 41.623), (28.988, 41.3), (28.806, 41.055), (27.619, 41.0), (27.192, 40.691), (26.358, 40.152), (26.043, 40.618), (26.057, 40.824), (26.295, 40.936), (26.604, 41.562)]]], ['AL', [[(21.02, 40.843), (21.0, 40.58), (20.675, 40.435), (20.615, 40.11), (20.15, 39.625), (19.98, 39.695), (19.96, 39.915), (19.406, 40.251), (19.319, 40.727), (19.404, 41.41), (19.54, 41.72), (19.372, 41.878), (19.372, 41.878), (19.304, 42.196), (19.738, 42.688), (19.802, 42.5), (20.071, 42.589), (20.284, 42.32), (20.523, 42.218), (20.59, 41.855), (20.59, 41.855), (20.463, 41.515), (20.605, 41.086)]]], ['HR', [[(16.565, 46.504), (16.883, 46.381), (17.63, 45.952), (18.456, 45.759), (18.83, 45.909), (19.073, 45.522), (19.39, 45.237), (19.005, 44.86), (18.553, 45.082), (17.862, 45.068), (17.002, 45.234), (16.535, 45.212), (16.318, 45.004), (15.959, 45.234), (15.75, 44.819), (16.24, 44.351), (16.456, 44.041), (16.916, 43.668), (17.297, 43.446), (17.675, 43.029), (18.56, 42.65), (18.45, 42.48), (18.45, 42.48), (17.51, 42.85), (16.93, 43.21), (16.015, 43.507), (15.174, 44.243), (15.376, 44.318), (14.92, 44.738), (14.902, 45.076), (14.259, 45.234), (13.952, 44.802), (13.657, 45.137), (13.679, 45.484), (13.715, 45.5), (14.412, 45.466), (14.595, 45.635), (14.935, 45.472), (15.328, 45.452), (15.324, 45.732), (15.672, 45.834), (15.769, 46.238)]]], ['CH', [[(9.594, 47.525), (9.633, 47.348), (9.48, 47.103), (9.932, 46.921), (10.443, 46.894), (10.363, 46.484), (9.923, 46.315), (9.183, 46.44), (8.966, 46.037), (8.49, 46.005), (8.317, 46.164), (7.756, 45.824), (7.274, 45.777), (6.844, 45.991), (6.5, 46.43), (6.023, 46.273), (6.037, 46.726), (6.769, 47.288), (6.737, 47.542), (7.192, 47.45), (7.467, 47.621), (8.317, 47.614), (8.523, 47.831)]]], ['L', [[(6.043, 50.128), (6.243, 49.902), (6.186, 49.464), (5.898, 49.443), (5.674, 49.529), (5.782, 50.09)]]], ['B', [[(6.157, 50.804), (6.043, 50.128), (5.782, 50.09), (5.674, 49.529), (4.799, 49.985), (4.286, 49.907), (3.588, 50.379), (3.123, 50.78), (2.658, 50.797), (2.514, 51.149), (3.315, 51.346), (3.315, 51.346), (3.315, 51.346), (4.047, 51.267), (4.974, 51.475), (5.607, 51.037)]]], ['NL', [[(6.905, 53.482), (7.092, 53.144), (6.843, 52.228), (6.589, 51.852), (5.989, 51.852), (6.157, 50.804), (5.607, 51.037), (4.974, 51.475), (4.047, 51.267), (3.315, 51.346), (3.315, 51.346), (3.83, 51.621), (4.706, 53.092), (6.074, 53.51)]]], ['P', [[(-9.035, 41.881), (-8.672, 42.135), (-8.264, 42.28), (-8.013, 41.791), (-7.423, 41.792), (-7.251, 41.918), (-6.669, 41.883), (-6.389, 41.382), (-6.851, 41.111), (-6.864, 40.331), (-7.026, 40.185), (-7.067, 39.712), (-7.499, 39.63), (-7.098, 39.03), (-7.374, 38.373), (-7.029, 38.076), (-7.167, 37.804), (-7.537, 37.429), (-7.454, 37.098), (-7.856, 36.838), (-8.383, 36.979), (-8.899, 36.869), (-8.746, 37.651), (-8.84, 38.266), (-9.287, 38.358), (-9.527, 38.737), (-9.447, 39.392), (-9.048, 39.755), (-8.977, 40.159), (-8.769, 40.761), (-8.791, 41.184), (-8.991, 41.543)]]], ['E', [[(-7.454, 37.098), (-7.537, 37.429), (-7.167, 37.804), (-7.029, 38.076), (-7.374, 38.373), (-7.098, 39.03), (-7.499, 39.63), (-7.067, 39.712), (-7.026, 40.185), (-6.864, 40.331), (-6.851, 41.111), (-6.389, 41.382), (-6.669, 41.883), (-7.251, 41.918), (-7.423, 41.792), (-8.013, 41.791), (-8.264, 42.28), (-8.672, 42.135), (-9.035, 41.881), (-8.984, 42.593), (-9.393, 43.027), (-7.978, 43.748), (-6.754, 43.568), (-5.412, 43.574), (-4.348, 43.403), (-3.518, 43.456), (-1.901, 43.423), (-1.503, 43.034), (0.338, 42.58), (0.702, 42.796), (1.827, 42.343), (2.986, 42.473), (3.039, 41.892), (2.092, 41.226), (0.811, 41.015), (0.721, 40.678), (0.107, 40.124), (-0.279, 39.31), (0.111, 38.739), (-0.467, 38.292), (-0.683, 37.642), (-1.438, 37.443), (-2.146, 36.674), (-3.416, 36.659), (-4.369, 36.678), (-4.995, 36.325), (-5.377, 35.947), (-5.866, 36.03), (-6.237, 36.368), (-6.52, 36.943)]]], ['IRL', [[(-6.198, 53.868), (-6.033, 53.153), (-6.789, 52.26), (-8.562, 51.669), (-9.977, 51.82), (-9.166, 52.865), (-9.689, 53.881), (-8.328, 54.665), (-7.572, 55.132), (-7.366, 54.596), (-7.572, 54.06), (-6.954, 54.074)]]], ['NC', [[(165.78, -21.08), (166.6, -21.7), (167.12, -22.16), (166.74, -22.4), (166.19, -22.13), (165.474, -21.68), (164.83, -21.15), (164.168, -20.445), (164.03, -20.106), (164.46, -20.12), (165.02, -20.46), (165.46, -20.8)]]], ['SB', [[(162.119, -10.483), (162.399, -10.826), (161.7, -10.82), (161.32, -10.205), (161.917, -10.447)], [(161.68, -9.6), (161.529, -9.784), (160.788, -8.918), (160.58, -8.32), (160.92, -8.32), (161.28, -9.12)], [(160.852, -9.873), (160.463, -9.895), (159.849, -9.794), (159.64, -9.64), (159.703, -9.243), (160.363, -9.4), (160.689, -9.61)], [(159.64, -8.02), (159.875, -8.337), (159.917, -8.538), (159.134, -8.114), (158.586, -7.755), (158.211, -7.422), (158.36, -7.32), (158.82, -7.56)], [(157.14, -7.022), (157.538, -7.348), (157.339, -7.405), (156.902, -7.177), (156.491, -6.766), (156.543, -6.599)]]], ['NZ', [[(176.886, -40.066), (176.508, -40.605), (176.012, -41.29), (175.24, -41.688), (175.068, -41.426), (174.651, -41.282), (175.228, -40.459), (174.9, -39.909), (173.824, -39.509), (173.852, -39.147), (174.575, -38.798), (174.743, -38.028), (174.697, -37.381), (174.292, -36.711), (174.319, -36.535), (173.841, -36.122), (173.054, -35.237), (172.636, -34.529), (173.007, -34.451), (173.551, -35.006), (174.329, -35.265), (174.612, -36.156), (175.337, -37.209), (175.358, -36.526), (175.809, -36.799), (175.958, -37.555), (176.763, -37.881), (177.439, -37.961), (178.01, -37.58), (178.517, -37.695), (178.275, -38.583), (177.97, -39.166), (177.207, -39.146), (176.94, -39.45), (177.033, -39.88)], [(169.668, -43.555), (170.525, -43.032), (171.125, -42.513), (171.57, -41.767), (171.949, -41.514), (172.097, -40.956), (172.799, -40.494), (173.02, -40.919), (173.247, -41.332), (173.958, -40.927), (174.248, -41.349), (174.249, -41.77), (173.876, -42.233), (173.223, -42.97), (172.711, -43.372), (173.08, -43.853), (172.309, -43.866), (171.453, -44.243), (171.185, -44.897), (170.617, -45.909), (169.831, -46.356), (169.332, -46.641), (168.411, -46.62), (167.764, -46.29), (166.677, -46.22), (166.509, -45.853), (167.046, -45.111), (168.304, -44.124), (168.949, -43.936)]]], ['AU', [[(147.689, -40.808), (148.289, -40.875), (148.36, -42.062), (148.017, -42.407), (147.914, -43.212), (147.565, -42.938), (146.87, -43.635), (146.663, -43.581), (146.048, -43.55), (145.432, -42.694), (145.295, -42.034), (144.718, -41.163), (144.744, -40.704), (145.398, -40.793), (146.364, -41.138), (146.909, -41.001)], [(126.149, -32.216), (125.089, -32.729), (124.222, -32.959), (124.029, -33.484), (123.66, -33.89), (122.811, -33.914), (122.183, -34.003), (121.299, -33.821), (120.58, -33.93), (119.894, -33.976), (119.299, -34.509), (119.007, -34.464), (118.506, -34.747), (118.025, -35.065), (117.296, -35.025), (116.625, -35.025), (115.564, -34.386), (115.027, -34.197), (115.049, -33.623), (115.545, -33.487), (115.715, -33.26), (115.679, -32.9), (115.802, -32.205), (115.69, -31.612), (115.161, -30.602), (114.997, -30.031), (115.04, -29.461), (114.642, -28.81), (114.616, -28.516), (114.174, -28.118), (114.049, -27.335), (113.477, -26.543), (113.339, -26.117), (113.778, -26.549), (113.441, -25.621), (113.937, -25.911), (114.233, -26.298), (114.216, -25.786), (113.721, -24.999), (113.625, -24.684), (113.394, -24.385), (113.502, -23.806), (113.707, -23.56), (113.843, -23.06), (113.737, -22.475), (114.15, -21.756), (114.225, -22.517), (114.648, -21.83), (115.46, -21.495), (115.947, -21.069), (116.712, -20.702), (117.166, -20.624), (117.442, -20.747), (118.23, -20.374), (118.836, -20.263), (118.988, -20.044), (119.252, -19.953), (119.805, -19.977), (120.856, -19.684), (121.4, -19.24), (121.655, -18.705), (122.242, -18.198), (122.287, -17.799), (122.313, -17.255), (123.013, -16.405), (123.434, -17.269), (123.859, -17.069), (123.503, -16.597), (123.817, -16.111), (124.258, -16.328), (124.38, -15.567), (124.926, -15.075), (125.167, -14.68), (125.67, -14.51), (125.686, -14.231), (126.125, -14.347), (126.143, -14.096), (126.583, -13.953), (127.066, -13.818), (127.805, -14.277), (128.36, -14.869), (128.986, -14.876), (129.621, -14.97), (129.41, -14.421), (129.889, -13.619), (130.339, -13.357), (130.184, -13.108), (130.618, -12.536), (131.223, -12.184), (131.735, -12.302), (132.575, -12.114), (132.557, -11.603), (131.825, -11.274), (132.357, -11.129), (133.02, -11.376), (133.551, -11.787), (134.393, -12.042), (134.679, -11.941), (135.298, -12.249), (135.883, -11.962), (136.258, -12.049), (136.492, -11.857), (136.952, -12.352), (136.685, -12.887), (136.305, -13.291), (135.962, -13.325), (136.078, -13.724), (135.784, -14.224), (135.429, -14.715), (135.5, -14.998), (136.295, -15.55), (137.065, -15.871), (137.58, -16.215), (138.303, -16.808), (138.585, -16.807), (139.109, -17.063), (139.261, -17.372), (140.215, -17.711), (140.875, -17.369), (141.071, -16.832), (141.274, -16.389), (141.398, -15.841), (141.702, -15.045), (141.563, -14.561), (141.636, -14.27), (141.52, -13.698), (141.651, -12.945), (141.843, -12.742), (141.687, -12.408), (141.929, -11.877), (142.118, -11.328), (142.144, -11.043), (142.515, -10.668), (142.797, -11.157), (142.867, -11.785), (143.116, -11.906), (143.159, -12.326), (143.522, -12.834), (143.597, -13.4), (143.562, -13.764), (143.922, -14.548), (144.564, -14.171), (144.895, -14.594), (145.375, -14.985), (145.272, -15.428), (145.485, -16.286), (145.637, -16.785), (145.889, -16.907), (146.16, -17.762), (146.064, -18.28), (146.387, -18.958), (147.471, -19.481), (148.178, -19.956), (148.848, -20.391), (148.717, -20.633), (149.289, -21.261), (149.678, -22.343), (150.077, -22.123), (150.483, -22.556), (150.727, -22.402), (150.9, -23.462), (151.609, -24.076), (152.074, -24.458), (152.855, -25.268), (153.136, -26.071), (153.162, -26.641), (153.093, -27.26), (153.569, -28.11), (153.512, -28.995), (153.339, -29.458), (153.069, -30.35), (153.09, -30.924), (152.892, -31.64), (152.45, -32.55), (151.709, -33.041), (151.344, -33.816), (151.011, -34.31), (150.714, -35.173), (150.328, -35.672), (150.075, -36.42), (149.946, -37.109), (149.997, -37.425), (149.424, -37.773), (148.305, -37.809), (147.382, -38.219), (146.922, -38.607), (146.318, -39.036), (145.49, -38.594), (144.877, -38.417), (145.032, -37.896), (144.486, -38.085), (143.61, -38.809), (142.745, -38.538), (142.178, -38.38), (141.607, -38.309), (140.639, -38.019), (139.992, -37.403), (139.807, -36.644), (139.574, -36.138), (139.083, -35.733), (138.121, -35.612), (138.449, -35.127), (138.208, -34.385), (137.719, -35.077), (136.829, -35.261), (137.352, -34.707), (137.504, -34.13), (137.89, -33.64), (137.81, -32.9), (136.997, -33.753), (136.372, -34.095), (135.989, -34.89), (135.208, -34.479), (135.239, -33.948), (134.613, -33.223), (134.086, -32.848), (134.274, -32.617), (132.991, -32.011), (132.288, -31.983), (131.326, -31.496), (129.536, -31.59), (128.241, -31.948), (127.103, -32.282)]]], ['LK', [[(81.788, 7.523), (81.637, 6.482), (81.218, 6.197), (80.348, 5.968), (79.872, 6.763), (79.695, 8.201), (80.148, 9.824), (80.839, 9.268), (81.304, 8.564)]]], ['CN', [[(109.475, 18.198), (108.655, 18.508), (108.626, 19.368), (109.119, 19.821), (110.212, 20.101), (110.787, 20.078), (111.01, 19.696), (110.571, 19.256), (110.339, 18.678)], [(80.26, 42.35), (80.18, 42.92), (80.866, 43.18), (79.966, 44.918), (81.947, 45.317), (82.459, 45.54), (83.18, 47.33), (85.164, 47.001), (85.72, 47.453), (85.768, 48.456), (86.599, 48.549), (87.36, 49.215), (87.751, 49.297), (88.014, 48.599), (88.854, 48.069), (90.281, 47.694), (90.971, 46.888), (90.586, 45.72), (90.946, 45.286), (92.134, 45.115), (93.481, 44.975), (94.689, 44.352), (95.307, 44.241), (95.762, 43.319), (96.349, 42.726), (97.452, 42.749), (99.516, 42.525), (100.846, 42.664), (101.833, 42.515), (103.312, 41.907), (104.522, 41.908), (104.965, 41.597), (106.129, 42.134), (107.745, 42.482), (109.244, 42.519), (110.412, 42.871), (111.13, 43.407), (111.83, 43.743), (111.668, 44.073), (111.348, 44.457), (111.873, 45.102), (112.436, 45.012), (113.464, 44.809), (114.46, 45.34), (115.985, 45.727), (116.718, 46.388), (117.422, 46.673), (118.874, 46.805), (119.663, 46.693), (119.773, 47.048), (118.867, 47.747), (118.064, 48.067), (117.296, 47.698), (116.309, 47.853), (115.743, 47.727), (115.485, 48.135), (116.192, 49.135), (116.679, 49.889), (117.879, 49.511), (119.288, 50.143), (119.279, 50.583), (120.182, 51.644), (120.738, 51.964), (120.726, 52.516), (120.177, 52.754), (121.003, 53.251), (122.246, 53.432), (123.571, 53.459), (125.068, 53.161), (125.946, 52.793), (126.564, 51.784), (126.939, 51.354), (127.287, 50.74), (127.657, 49.76), (129.398, 49.441), (130.582, 48.73), (130.987, 47.79), (132.507, 47.789), (133.374, 48.183), (135.026, 48.478), (134.501, 47.578), (134.112, 47.212), (133.77, 46.117), (133.097, 45.144), (131.883, 45.321), (131.025, 44.968), (131.289, 44.112), (131.145, 42.93), (130.634, 42.903), (130.64, 42.395), (129.994, 42.985), (129.597, 42.425), (128.052, 41.994), (128.208, 41.467), (127.344, 41.503), (126.869, 41.817), (126.182, 41.107), (125.08, 40.57), (124.266, 39.928), (122.868, 39.638), (122.131, 39.17), (121.055, 38.897), (121.586, 39.361), (121.377, 39.75), (122.169, 40.422), (121.64, 40.946), (120.769, 40.593), (119.64, 39.898), (119.023, 39.252), (118.043, 39.204), (117.533, 38.738), (118.06, 38.061), (118.878, 37.897), (118.912, 37.448), (119.703, 37.156), (120.823, 37.87), (121.711, 37.481), (122.358, 37.454), (122.52, 36.931), (121.104, 36.651), (120.637, 36.111), (119.665, 35.61), (119.151, 34.91), (120.228, 34.36), (120.62, 33.377), (121.229, 32.46), (121.908, 31.692), (121.892, 30.949), (121.264, 30.676), (121.504, 30.143), (122.092, 29.833), (121.938, 29.018), (121.684, 28.226), (121.126, 28.136), (120.395, 27.053), (119.585, 25.741), (118.657, 24.547), (117.282, 23.625), (115.891, 22.783), (114.764, 22.668), (114.153, 22.224), (113.807, 22.548), (113.241, 22.051), (111.844, 21.55), (110.785, 21.397), (110.444, 20.341), (109.89, 20.282), (109.628, 21.008), (109.864, 21.395), (108.523, 21.715), (108.05, 21.552), (107.043, 21.812), (106.567, 22.218), (106.725, 22.794), (105.811, 22.977), (105.329, 23.352), (104.477, 22.819), (103.505, 22.704), (102.707, 22.709), (102.17, 22.465), (101.652, 22.318), (101.803, 21.174), (101.27, 21.202), (101.18, 21.437), (101.15, 21.85), (100.417, 21.559), (99.983, 21.743), (99.241, 22.118), (99.532, 22.949), (98.899, 23.143), (98.66, 24.063), (97.605, 23.897), (97.725, 25.084), (98.672, 25.919), (98.712, 26.744), (98.683, 27.509), (98.246, 27.747), (97.912, 28.336), (97.327, 28.262), (96.249, 28.411), (96.587, 28.831), (96.118, 29.453), (95.405, 29.032), (94.566, 29.277), (93.413, 28.641), (92.503, 27.897), (91.697, 27.772), (91.259, 28.041), (90.731, 28.065), (90.016, 28.296), (89.476, 28.043), (88.814, 27.299), (88.73, 28.087), (88.12, 27.877), (86.955, 27.974), (85.823, 28.204), (85.012, 28.643), (84.235, 28.84), (83.899, 29.32), (83.337, 29.464), (82.328, 30.115), (81.526, 30.423), (81.111, 30.183), (79.721, 30.883), (78.739, 31.516), (78.458, 32.618), (79.176, 32.484), (79.209, 32.994), (78.811, 33.506), (78.912, 34.322), (77.837, 35.494), (76.193, 35.898), (75.897, 36.667), (75.158, 37.133), (74.98, 37.42), (74.83, 37.99), (74.865, 38.379), (74.258, 38.607), (73.929, 38.506), (73.675, 39.431), (73.96, 39.66), (73.822, 39.894), (74.777, 40.366), (75.468, 40.562), (76.526, 40.428), (76.904, 41.066), (78.187, 41.185), (78.544, 41.582), (80.119, 42.124)]]], ['TW', [[(121.778, 24.394), (121.176, 22.791), (120.747, 21.971), (120.22, 22.815), (120.106, 23.556), (120.695, 24.538), (121.495, 25.295), (121.951, 24.998)]]], ['I', [[(10.443, 46.894), (11.049, 46.751), (11.165, 46.942), (12.153, 47.115), (12.376, 46.768), (13.806, 46.509), (13.698, 46.017), (13.938, 45.591), (13.142, 45.737), (12.329, 45.382), (12.384, 44.885), (12.261, 44.6), (12.589, 44.091), (13.527, 43.588), (14.03, 42.761), (15.143, 41.955), (15.926, 41.961), (16.17, 41.74), (15.889, 41.541), (16.785, 41.18), (17.519, 40.877), (18.377, 40.356), (18.48, 40.169), (18.293, 39.811), (17.738, 40.278), (16.87, 40.442), (16.449, 39.795), (17.171, 39.425), (17.053, 38.903), (16.635, 38.844), (16.101, 37.986), (15.684, 37.909), (15.688, 38.215), (15.892, 38.751), (16.109, 38.965), (15.719, 39.544), (15.414, 40.048), (14.998, 40.173), (14.703, 40.605), (14.061, 40.786), (13.628, 41.188), (12.888, 41.253), (12.107, 41.705), (11.192, 42.355), (10.512, 42.931), (10.2, 43.92), (9.702, 44.036), (8.889, 44.366), (8.429, 44.231), (7.851, 43.767), (7.435, 43.694), (7.55, 44.128), (7.008, 44.255), (6.75, 45.029), (7.097, 45.333), (6.802, 45.709), (6.844, 45.991), (7.274, 45.777), (7.756, 45.824), (8.317, 46.164), (8.49, 46.005), (8.966, 46.037), (9.183, 46.44), (9.923, 46.315), (10.363, 46.484)], [(14.761, 38.144), (15.52, 38.231), (15.16, 37.444), (15.31, 37.134), (15.1, 36.62), (14.335, 36.997), (13.827, 37.105), (12.431, 37.613), (12.571, 38.126), (13.741, 38.035)], [(8.71, 40.9), (9.21, 41.21), (9.81, 40.5), (9.67, 39.177), (9.215, 39.24), (8.807, 38.907), (8.428, 39.172), (8.388, 40.378), (8.16, 40.95)]]], ['DK', [[(9.922, 54.983), (9.282, 54.831), (8.526, 54.963), (8.12, 55.518), (8.09, 56.54), (8.257, 56.81), (8.543, 57.11), (9.424, 57.172), (9.776, 57.448), (10.58, 57.73), (10.546, 57.216), (10.25, 56.89), (10.37, 56.61), (10.912, 56.459), (10.668, 56.081), (10.37, 56.19), (9.65, 55.47)], [(12.371, 56.111), (12.69, 55.61), (12.09, 54.8), (11.044, 55.365), (10.904, 55.78)]]], ['GB', [[(-6.198, 53.868), (-6.954, 54.074), (-7.572, 54.06), (-7.366, 54.596), (-7.572, 55.132), (-6.734, 55.173), (-5.662, 54.555)], [(-3.094, 53.405), (-3.092, 53.404), (-2.945, 53.985), (-3.615, 54.601), (-3.63, 54.615), (-4.844, 54.791), (-5.083, 55.062), (-4.719, 55.508), (-5.048, 55.784), (-5.586, 55.311), (-5.645, 56.275), (-6.15, 56.785), (-5.787, 57.819), (-5.01, 58.63), (-4.211, 58.551), (-3.005, 58.635), (-4.074, 57.553), (-3.055, 57.69), (-1.959, 57.685), (-2.22, 56.87), (-3.119, 55.974), (-2.085, 55.91), (-2.006, 55.805), (-1.115, 54.625), (-0.43, 54.464), (0.185, 53.325), (0.47, 52.93), (1.682, 52.74), (1.56, 52.1), (1.051, 51.807), (1.45, 51.289), (0.55, 50.766), (-0.788, 50.775), (-2.49, 50.5), (-2.956, 50.697), (-3.617, 50.228), (-4.543, 50.342), (-5.245, 49.96), (-5.777, 50.16), (-4.31, 51.21), (-3.415, 51.426), (-3.423, 51.427), (-4.984, 51.593), (-5.267, 51.991), (-4.222, 52.301), (-4.77, 52.84), (-4.58, 53.495)]]], ['IS', [[(-14.509, 66.456), (-14.74, 65.809), (-13.61, 65.127), (-14.91, 64.364), (-17.794, 63.679), (-18.656, 63.496), (-19.973, 63.644), (-22.763, 63.96), (-21.778, 64.402), (-23.955, 64.891), (-22.184, 65.085), (-22.227, 65.379), (-24.326, 65.611), (-23.651, 66.263), (-22.135, 66.41), (-20.576, 65.732), (-19.057, 66.277), (-17.799, 65.994), (-16.168, 66.527)]]], ['AZ', [[(46.405, 41.861), (46.686, 41.827), (47.373, 41.22), (47.816, 41.151), (47.987, 41.406), (48.584, 41.809), (49.11, 41.282), (49.619, 40.573), (50.085, 40.526), (50.393, 40.257), (49.569, 40.176), (49.395, 39.399), (49.223, 39.049), (48.857, 38.815), (48.883, 38.32), (48.634, 38.27), (48.011, 38.794), (48.356, 39.289), (48.06, 39.582), (47.685, 39.508), (46.506, 38.771), (46.483, 39.464), (46.035, 39.628), (45.61, 39.9), (45.892, 40.218), (45.359, 40.562), (45.56, 40.812), (45.179, 40.985), (44.972, 41.248), (45.217, 41.411), (45.963, 41.124), (46.502, 41.064), (46.638, 41.182), (46.145, 41.723)], [(46.144, 38.741), (45.458, 38.874), (44.953, 39.336), (44.794, 39.713), (45.002, 39.74), (45.298, 39.472), (45.74, 39.474), (45.735, 39.32)]]], ['GE', [[(39.955, 43.435), (40.077, 43.553), (40.922, 43.382), (42.394, 43.22), (43.756, 42.741), (43.931, 42.555), (44.538, 42.712), (45.47, 42.503), (45.776, 42.092), (46.405, 41.861), (46.145, 41.723), (46.638, 41.182), (46.502, 41.064), (45.963, 41.124), (45.217, 41.411), (44.972, 41.248), (43.583, 41.092), (42.62, 41.583), (41.554, 41.536), (41.703, 41.963), (41.453, 42.645), (40.875, 43.014), (40.321, 43.129)]]], ['PH', [[(120.834, 12.704), (120.323, 13.466), (121.18, 13.43), (121.527, 13.07), (121.262, 12.206)], [(122.586, 9.981), (122.837, 10.261), (122.947, 10.882), (123.499, 10.941), (123.338, 10.267), (124.078, 11.233), (123.982, 10.279), (123.623, 9.95), (123.31, 9.318), (122.996, 9.022), (122.38, 9.713)], [(126.377, 8.415), (126.479, 7.75), (126.537, 7.189), (126.197, 6.274), (125.831, 7.294), (125.364, 6.786), (125.683, 6.05), (125.397, 5.581), (124.22, 6.161), (123.939, 6.885), (124.244, 7.361), (123.61, 7.834), (123.296, 7.419), (122.826, 7.457), (122.085, 6.899), (121.92, 7.192), (122.312, 8.035), (122.942, 8.316), (123.488, 8.693), (123.841, 8.24), (124.601, 8.514), (124.765, 8.96), (125.471, 8.987), (125.412, 9.76), (126.223, 9.286), (126.307, 8.782)], [(118.505, 9.316), (117.174, 8.367), (117.664, 9.067), (118.387, 9.684), (118.987, 10.376), (119.511, 11.37), (119.69, 10.554), (119.029, 10.004)], [(122.337, 18.225), (122.174, 17.81), (122.516, 17.094), (122.252, 16.262), (121.663, 15.931), (121.505, 15.125), (121.729, 14.328), (122.259, 14.218), (122.701, 14.337), (123.95, 13.782), (123.855, 13.238), (124.181, 12.998), (124.077, 12.537), (123.298, 13.028), (122.929, 13.553), (122.671, 13.186), (122.035, 13.784), (121.126, 13.637), (120.629, 13.858), (120.679, 14.271), (120.992, 14.525), (120.693, 14.757), (120.564, 14.396), (120.07, 14.971), (119.921, 15.406), (119.884, 16.364), (120.286, 16.035), (120.39, 17.599), (120.716, 18.505), (121.321, 18.504), (121.938, 18.219), (122.246, 18.479)], [(122.038, 11.416), (121.884, 11.892), (122.484, 11.582), (123.12, 11.584), (123.101, 11.166), (122.638, 10.741), (122.003, 10.441), (121.967, 10.906)], [(125.503, 12.163), (125.783, 11.046), (125.012, 11.311), (125.033, 10.976), (125.277, 10.359), (124.802, 10.135), (124.76, 10.838), (124.459, 10.89), (124.303, 11.495), (124.891, 11.416), (124.878, 11.794), (124.267, 12.558), (125.227, 12.536)]]], ['MY', [[(100.086, 6.464), (100.26, 6.643), (101.076, 6.205), (101.154, 5.691), (101.814, 5.811), (102.141, 6.222), (102.371, 6.128), (102.962, 5.524), (103.381, 4.855), (103.439, 4.182), (103.332, 3.727), (103.429, 3.383), (103.502, 2.791), (103.855, 2.515), (104.248, 1.631), (104.229, 1.293), (103.52, 1.226), (102.574, 1.967), (101.391, 2.761), (101.274, 3.27), (100.695, 3.939), (100.557, 4.767), (100.197, 5.312), (100.306, 6.041)], [(117.882, 4.138), (117.015, 4.306), (115.866, 4.307), (115.519, 3.169), (115.134, 2.821), (114.621, 1.431), (113.806, 1.218), (112.86, 1.498), (112.38, 1.41), (111.798, 0.904), (111.159, 0.976), (110.514, 0.773), (109.83, 1.338), (109.663, 2.006), (110.396, 1.664), (111.169, 1.851), (111.37, 2.697), (111.797, 2.886), (112.996, 3.102), (113.713, 3.894), (114.204, 4.526), (114.66, 4.008), (114.87, 4.348), (115.347, 4.317), (115.406, 4.955), (115.451, 5.448), (116.221, 6.143), (116.725, 6.925), (117.13, 6.928), (117.643, 6.422), (117.689, 5.987), (118.348, 5.709), (119.182, 5.408), (119.111, 5.016), (118.44, 4.967), (118.618, 4.478)]]], ['BN', [[(115.451, 5.448), (115.406, 4.955), (115.347, 4.317), (114.87, 4.348), (114.66, 4.008), (114.204, 4.526), (114.6, 4.9)]]], ['SLO', [[(13.806, 46.509), (14.632, 46.432), (15.137, 46.659), (16.012, 46.684), (16.202, 46.852), (16.371, 46.841), (16.565, 46.504), (15.769, 46.238), (15.672, 45.834), (15.324, 45.732), (15.328, 45.452), (14.935, 45.472), (14.595, 45.635), (14.412, 45.466), (13.715, 45.5), (13.938, 45.591), (13.698, 46.017)]]], ['FIN', [[(28.592, 69.065), (28.446, 68.365), (29.977, 67.698), (29.055, 66.944), (30.218, 65.806), (29.544, 64.949), (30.445, 64.204), (30.036, 63.553), (31.516, 62.868), (31.14, 62.358), (30.211, 61.78), (28.07, 60.504), (28.07, 60.504), (28.07, 60.504), (26.255, 60.424), (24.497, 60.057), (22.87, 59.846), (22.291, 60.392), (21.322, 60.72), (21.545, 61.705), (21.059, 62.607), (21.536, 63.19), (22.443, 63.818), (24.731, 64.902), (25.398, 65.111), (25.294, 65.534), (23.903, 66.007), (23.566, 66.396), (23.539, 67.936), (21.979, 68.617), (20.646, 69.106), (21.245, 69.37), (22.356, 68.842), (23.662, 68.891), (24.736, 68.65), (25.689, 69.092), (26.18, 69.825), (27.732, 70.164), (29.016, 69.766)]]], ['SK', [[(22.558, 49.086), (22.281, 48.825), (22.086, 48.422), (21.872, 48.32), (20.801, 48.624), (20.474, 48.563), (20.239, 48.328), (19.769, 48.203), (19.661, 48.267), (19.174, 48.111), (18.777, 48.082), (18.697, 47.881), (17.857, 47.758), (17.488, 47.867), (16.98, 48.123), (16.88, 48.47), (16.96, 48.597), (17.102, 48.817), (17.545, 48.8), (17.886, 48.903), (17.914, 48.996), (18.105, 49.044), (18.17, 49.272), (18.4, 49.315), (18.555, 49.495), (18.853, 49.496), (18.91, 49.436), (19.321, 49.572), (19.825, 49.217), (20.416, 49.431), (20.888, 49.329), (21.608, 49.47)]]], ['CZ', [[(15.017, 51.107), (15.491, 50.785), (16.239, 50.698), (16.176, 50.423), (16.719, 50.216), (16.869, 50.474), (17.555, 50.362), (17.649, 50.049), (18.393, 49.989), (18.853, 49.496), (18.555, 49.495), (18.4, 49.315), (18.17, 49.272), (18.105, 49.044), (17.914, 48.996), (17.886, 48.903), (17.545, 48.8), (17.102, 48.817), (16.96, 48.597), (16.499, 48.786), (16.03, 48.734), (15.253, 49.039), (14.901, 48.964), (14.339, 48.555), (13.596, 48.877), (13.031, 49.307), (12.521, 49.547), (12.415, 49.969), (12.24, 50.266), (12.967, 50.484), (13.338, 50.733), (14.056, 50.927), (14.307, 51.117), (14.571, 51.002)]]], ['ER', [[(36.43, 14.422), (36.323, 14.822), (36.754, 16.292), (36.853, 16.957), (37.167, 17.263), (37.904, 17.428), (38.41, 17.998), (38.991, 16.841), (39.266, 15.923), (39.814, 15.436), (41.179, 14.491), (41.735, 13.921), (42.277, 13.344), (42.59, 13.0), (43.081, 12.7), (42.78, 12.455), (42.352, 12.542), (42.01, 12.866), (41.599, 13.452), (41.155, 13.773), (40.897, 14.119), (40.026, 14.52), (39.341, 14.532), (39.099, 14.741), (38.513, 14.505), (37.906, 14.959), (37.594, 14.213)]]], ['J', [[(141.885, 39.181), (140.959, 38.174), (140.976, 37.142), (140.6, 36.344), (140.774, 35.843), (140.253, 35.138), (138.976, 34.668), (137.218, 34.606), (135.793, 33.465), (135.121, 33.849), (135.079, 34.597), (133.34, 34.376), (132.157, 33.905), (130.986, 33.886), (132.0, 33.15), (131.333, 31.45), (130.686, 31.03), (130.202, 31.418), (130.448, 32.319), (129.815, 32.61), (129.408, 33.296), (130.354, 33.604), (130.878, 34.233), (131.884, 34.75), (132.618, 35.433), (134.608, 35.732), (135.678, 35.527), (136.724, 37.305), (137.391, 36.827), (138.858, 37.827), (139.426, 38.216), (140.055, 39.439), (139.883, 40.563), (140.306, 41.195), (141.369, 41.379), (141.914, 39.992)], [(144.613, 43.961), (145.321, 44.385), (145.543, 43.262), (144.06, 42.988), (143.184, 41.995), (141.611, 42.679), (141.067, 41.585), (139.955, 41.57), (139.818, 42.564), (140.312, 43.333), (141.381, 43.389), (141.672, 44.772), (141.968, 45.551), (143.143, 44.51), (143.91, 44.174)], [(132.371, 33.464), (132.924, 34.06), (133.493, 33.945), (133.904, 34.365), (134.638, 34.149), (134.766, 33.806), (134.203, 33.201), (133.793, 33.522), (133.28, 33.29), (133.015, 32.705), (132.363, 32.989)]]], ['PY', [[(-58.166, -20.177), (-57.871, -20.733), (-57.937, -22.09), (-56.882, -22.282), (-56.473, -22.086), (-55.798, -22.357), (-55.611, -22.656), (-55.518, -23.572), (-55.401, -23.957), (-55.028, -24.001), (-54.653, -23.84), (-54.293, -24.021), (-54.293, -24.571), (-54.429, -25.162), (-54.625, -25.739), (-54.789, -26.622), (-55.696, -27.388), (-56.487, -27.548), (-57.61, -27.396), (-58.618, -27.124), (-57.634, -25.604), (-57.777, -25.162), (-58.807, -24.771), (-60.029, -24.033), (-60.847, -23.881), (-62.685, -22.249), (-62.291, -21.052), (-62.266, -20.514), (-61.786, -19.634), (-60.044, -19.343), (-59.115, -19.357), (-58.183, -19.868)]]], ['YE', [[(52.0, 19.0), (52.782, 17.35), (53.109, 16.651), (52.385, 16.382), (52.192, 15.938), (52.168, 15.597), (51.173, 15.175), (49.575, 14.709), (48.679, 14.003), (48.239, 13.948), (47.939, 14.007), (47.354, 13.592), (46.717, 13.4), (45.878, 13.348), (45.625, 13.291), (45.406, 13.027), (45.144, 12.954), (44.99, 12.7), (44.495, 12.722), (44.175, 12.586), (43.483, 12.637), (43.223, 13.221), (43.251, 13.768), (43.088, 14.063), (42.892, 14.802), (42.605, 15.213), (42.805, 15.262), (42.702, 15.719), (42.824, 15.912), (42.779, 16.348), (43.218, 16.667), (43.116, 17.088), (43.381, 17.58), (43.792, 17.32), (44.063, 17.41), (45.217, 17.433), (45.4, 17.333), (46.367, 17.233), (46.75, 17.283), (47.0, 16.95), (47.467, 17.117), (48.183, 18.167), (49.117, 18.617)]]], ['SA', [[(34.956, 29.357), (36.069, 29.197), (36.501, 29.505), (36.741, 29.865), (37.504, 30.004), (37.668, 30.339), (37.999, 30.509), (37.002, 31.508), (39.005, 32.01), (39.195, 32.161), (40.4, 31.89), (41.89, 31.19), (44.709, 29.179), (46.569, 29.099), (47.46, 29.003), (47.709, 28.526), (48.416, 28.552), (48.808, 27.69), (49.3, 27.461), (49.471, 27.11), (50.152, 26.69), (50.213, 26.277), (50.113, 25.944), (50.24, 25.608), (50.527, 25.328), (50.661, 25.0), (50.81, 24.755), (51.112, 24.556), (51.39, 24.627), (51.58, 24.245), (51.618, 24.014), (52.001, 23.001), (55.007, 22.497), (55.208, 22.708), (55.667, 22.0), (55.0, 20.0), (52.0, 19.0), (49.117, 18.617), (48.183, 18.167), (47.467, 17.117), (47.0, 16.95), (46.75, 17.283), (46.367, 17.233), (45.4, 17.333), (45.217, 17.433), (44.063, 17.41), (43.792, 17.32), (43.381, 17.58), (43.116, 17.088), (43.218, 16.667), (42.779, 16.348), (42.65, 16.775), (42.348, 17.076), (42.271, 17.475), (41.754, 17.833), (41.221, 18.672), (40.939, 19.486), (40.248, 20.175), (39.802, 20.339), (39.139, 21.292), (39.024, 21.987), (39.066, 22.58), (38.493, 23.688), (38.024, 24.079), (37.484, 24.285), (37.155, 24.858), (37.209, 25.085), (36.932, 25.603), (36.64, 25.826), (36.249, 26.57), (35.64, 27.377), (35.13, 28.063), (34.632, 28.059), (34.788, 28.607), (34.832, 28.957)]]], ['AQ', [[(-48.661, -78.047), (-48.151, -78.047), (-46.663, -77.831), (-45.155, -78.047), (-43.921, -78.478), (-43.49, -79.086), (-43.372, -79.517), (-43.333, -80.026), (-44.881, -80.34), (-46.506, -80.594), (-48.386, -80.829), (-50.482, -81.025), (-52.852, -80.967), (-54.164, -80.634), (-53.988, -80.222), (-51.853, -79.948), (-50.991, -79.615), (-50.365, -79.183), (-49.914, -78.811), (-49.307, -78.459), (-48.661, -78.047)], [(-66.29, -80.256), (-64.038, -80.295), (-61.883, -80.393), (-61.139, -79.981), (-60.61, -79.629), (-59.572, -80.04), (-59.866, -80.55), (-60.16, -81.0), (-62.255, -80.863), (-64.488, -80.922), (-65.742, -80.589), (-65.742, -80.55)], [(-73.916, -71.269), (-73.916, -71.269), (-73.23, -71.152), (-72.075, -71.191), (-71.781, -70.681), (-71.722, -70.309), (-71.742, -69.506), (-71.174, -69.035), (-70.253, -68.879), (-69.724, -69.251), (-69.489, -69.623), (-69.059, -70.074), (-68.726, -70.505), (-68.451, -70.956), (-68.334, -71.406), (-68.51, -71.798), (-68.784, -72.171), (-69.959, -72.308), (-71.076, -72.504), (-72.388, -72.484), (-71.898, -72.092), (-73.074, -72.229), (-74.19, -72.367), (-74.954, -72.073), (-75.013, -71.661)], [(-102.331, -71.894), (-102.331, -71.894), (-101.704, -71.718), (-100.431, -71.855), (-98.982, -71.933), (-97.885, -72.071), (-96.788, -71.953), (-96.2, -72.521), (-96.984, -72.443), (-98.198, -72.482), (-99.432, -72.443), (-100.783, -72.502), (-101.802, -72.306)], [(-122.622, -73.658), (-122.622, -73.658), (-122.406, -73.325), (-121.212, -73.501), (-119.919, -73.658), (-118.724, -73.481), (-119.292, -73.834), (-120.232, -74.089), (-121.623, -74.01)], [(-127.283, -73.462), (-127.283, -73.462), (-126.558, -73.246), (-125.56, -73.481), (-124.032, -73.873), (-124.619, -73.834), (-125.912, -73.736)], [(-163.713, -78.596), (-163.713, -78.596), (-163.106, -78.223), (-161.245, -78.38), (-160.246, -78.694), (-159.482, -79.046), (-159.208, -79.497), (-161.128, -79.634), (-162.44, -79.281), (-163.027, -78.929), (-163.067, -78.87)], [(180.0, -84.713), (180.0, -90.0), (-180.0, -90.0), (-180.0, -84.713), (-179.942, -84.721), (-179.059, -84.139), (-177.257, -84.453), (-177.141, -84.418), (-176.085, -84.099), (-175.947, -84.11), (-175.83, -84.118), (-174.383, -84.534), (-173.117, -84.118), (-172.889, -84.061), (-169.951, -83.885), (-169.0, -84.118), (-168.53, -84.237), (-167.022, -84.57), (-164.182, -84.825), (-161.93, -85.139), (-158.071, -85.374), (-155.192, -85.1), (-150.942, -85.296), (-148.533, -85.609), (-145.889, -85.315), (-143.108, -85.041), (-142.892, -84.57), (-146.829, -84.531), (-150.061, -84.296), (-150.903, -83.904), (-153.586, -83.689), (-153.41, -83.238), (-153.038, -82.827), (-152.666, -82.454), (-152.862, -82.043), (-154.526, -81.768), (-155.29, -81.416), (-156.837, -81.102), (-154.409, -81.161), (-152.098, -81.004), (-150.648, -81.337), (-148.866, -81.043), (-147.221, -80.671), (-146.418, -80.338), (-146.77, -79.926), (-148.063, -79.652), (-149.532, -79.358), (-151.588, -79.299), (-153.39, -79.162), (-155.329, -79.064), (-155.976, -78.692), (-157.268, -78.378), (-158.052, -78.026), (-158.365, -76.889), (-157.875, -76.987), (-156.975, -77.301), (-155.329, -77.203), (-153.743, -77.066), (-152.92, -77.497), (-151.334, -77.399), (-150.002, -77.183), (-148.748, -76.909), (-147.612, -76.576), (-146.104, -76.478), (-146.144, -76.105), (-146.496, -75.733), (-146.202, -75.38), (-144.91, -75.204), (-144.322, -75.537), (-142.794, -75.341), (-141.639, -75.086), (-140.209, -75.067), (-138.858, -74.969), (-137.506, -74.734), (-136.429, -74.518), (-135.215, -74.303), (-134.431, -74.361), (-133.746, -74.44), (-132.257, -74.303), (-130.925, -74.479), (-129.554, -74.459), (-128.242, -74.322), (-126.891, -74.42), (-125.402, -74.518), (-124.011, -74.479), (-122.562, -74.499), (-121.074, -74.518), (-119.703, -74.479), (-118.684, -74.185), (-117.47, -74.028), (-116.216, -74.244), (-115.022, -74.068), (-113.944, -73.715), (-113.298, -74.028), (-112.945, -74.381), (-112.299, -74.714), (-111.261, -74.42), (-110.066, -74.793), (-108.715, -74.91), (-107.559, -75.184), (-106.149, -75.126), (-104.876, -74.949), (-103.368, -74.988), (-102.017, -75.126), (-100.646, -75.302), (-100.117, -74.871), (-100.763, -74.538), (-101.253, -74.185), (-102.545, -74.107), (-103.113, -73.734), (-103.329, -73.362), (-103.681, -72.618), (-102.917, -72.755), (-101.605, -72.813), (-100.313, -72.755), (-99.137, -72.911), (-98.119, -73.205), (-97.688, -73.558), (-96.337, -73.617), (-95.044, -73.48), (-93.673, -73.284), (-92.439, -73.166), (-91.421, -73.401), (-90.089, -73.323), (-89.227, -72.559), (-88.424, -73.009), (-87.268, -73.186), (-86.015, -73.088), (-85.192, -73.48), (-83.88, -73.519), (-82.666, -73.636), (-81.471, -73.852), (-80.687, -73.48), (-80.296, -73.127), (-79.297, -73.519), (-77.926, -73.421), (-76.907, -73.636), (-76.222, -73.97), (-74.89, -73.872), (-73.852, -73.656), (-72.834, -73.401), (-71.619, -73.264), (-70.209, -73.147), (-68.936, -73.009), (-67.957, -72.794), (-67.369, -72.48), (-67.134, -72.049), (-67.252, -71.638), (-67.565, -71.246), (-67.917, -70.854), (-68.231, -70.462), (-68.485, -70.109), (-68.544, -69.717), (-68.446, -69.326), (-67.976, -68.953), (-67.585, -68.542), (-67.428, -68.15), (-67.624, -67.719), (-67.741, -67.327), (-67.252, -66.876), (-66.703, -66.582), (-66.057, -66.21), (-65.371, -65.896), (-64.568, -65.603), (-64.177, -65.171), (-63.628, -64.897), (-63.001, -64.642), (-62.042, -64.584), (-61.415, -64.27), (-60.71, -64.074), (-59.887, -63.957), (-59.163, -63.702), (-58.595, -63.388), (-57.811, -63.271), (-57.224, -63.525), (-57.596, -63.859), (-58.614, -64.152), (-59.045, -64.368), (-59.789, -64.211), (-60.612, -64.309), (-61.297, -64.544), (-62.022, -64.799), (-62.512, -65.093), (-62.649, -65.485), (-62.59, -65.857), (-62.12, -66.19), (-62.806, -66.426), (-63.746, -66.504), (-64.294, -66.837), (-64.882, -67.15), (-65.508, -67.582), (-65.665, -67.954), (-65.313, -68.365), (-64.784, -68.679), (-63.961, -68.914), (-63.197, -69.228), (-62.786, -69.619), (-62.571, -69.992), (-62.277, -70.384), (-61.807, -70.717), (-61.513, -71.089), (-61.376, -72.01), (-61.082, -72.382), (-61.004, -72.774), (-60.69, -73.166), (-60.827, -73.695), (-61.376, -74.107), (-61.963, -74.44), (-63.295, -74.577), (-63.746, -74.93), (-64.353, -75.263), (-65.861, -75.635), (-67.193, -75.792), (-68.446, -76.007), (-69.798, -76.223), (-70.601, -76.634), (-72.207, -76.674), (-73.97, -76.634), (-75.556, -76.713), (-77.24, -76.713), (-76.927, -77.105), (-75.399, -77.281), (-74.283, -77.555), (-73.656, -77.908), (-74.773, -78.222), (-76.496, -78.124), (-77.926, -78.378), (-77.985, -78.79), (-78.024, -79.182), (-76.849, -79.515), (-76.633, -79.887), (-75.36, -80.26), (-73.245, -80.416), (-71.443, -80.691), (-70.013, -81.004), (-68.192, -81.318), (-65.704, -81.474), (-63.256, -81.749), (-61.552, -82.043), (-59.691, -82.376), (-58.712, -82.846), (-58.222, -83.218), (-57.008, -82.866), (-55.363, -82.572), (-53.62, -82.258), (-51.544, -82.004), (-49.761, -81.729), (-47.274, -81.71), (-44.826, -81.847), (-42.808, -82.082), (-42.162, -81.651), (-40.771, -81.357), (-38.245, -81.337), (-36.267, -81.122), (-34.386, -80.906), (-32.31, -80.769), (-30.097, -80.593), (-28.55, -80.338), (-29.255, -79.985), (-29.686, -79.633), (-29.686, -79.26), (-31.625, -79.299), (-33.681, -79.456), (-35.64, -79.456), (-35.914, -79.084), (-35.777, -78.339), (-35.327, -78.124), (-33.897, -77.889), (-32.212, -77.653), (-30.998, -77.36), (-29.784, -77.066), (-28.883, -76.674), (-27.512, -76.497), (-26.16, -76.36), (-25.475, -76.282), (-23.928, -76.243), (-22.459, -76.105), (-21.225, -75.909), (-20.01, -75.674), (-18.914, -75.439), (-17.523, -75.126), (-16.642, -74.793), (-15.701, -74.499), (-15.408, -74.107), (-16.465, -73.872), (-16.113, -73.46), (-15.447, -73.147), (-14.409, -72.951), (-13.312, -72.715), (-12.294, -72.402), (-11.51, -72.01), (-11.02, -71.54), (-10.296, -71.265), (-9.101, -71.324), (-8.611, -71.657), (-7.417, -71.697), (-7.377, -71.324), (-6.868, -70.932), (-5.791, -71.03), (-5.536, -71.403), (-4.342, -71.461), (-3.049, -71.285), (-1.795, -71.167), (-0.659, -71.226), (-0.229, -71.638), (0.868, -71.305), (1.887, -71.128), (3.023, -70.991), (4.139, -70.854), (5.158, -70.619), (6.274, -70.462), (7.136, -70.247), (7.743, -69.894), (8.487, -70.149), (9.525, -70.011), (10.25, -70.482), (10.818, -70.834), (11.954, -70.638), (12.404, -70.247), (13.423, -69.972), (14.735, -70.031), (15.127, -70.403), (15.949, -70.031), (17.027, -69.913), (18.202, -69.874), (19.259, -69.894), (20.376, -70.011), (21.453, -70.07), (21.923, -70.403), (22.569, -70.697), (23.666, -70.521), (24.841, -70.482), (25.977, -70.482), (27.094, -70.462), (28.093, -70.325), (29.15, -70.207), (30.032, -69.933), (30.972, -69.757), (31.99, -69.659), (32.754, -69.384), (33.302, -68.836), (33.87, -68.503), (34.908, -68.659), (35.3, -69.012), (36.162, -69.247), (37.2, -69.169), (37.905, -69.521), (38.649, -69.776), (39.668, -69.541), (40.02, -69.11), (40.921, -68.934), (41.959, -68.601), (42.939, -68.463), (44.114, -68.267), (44.897, -68.052), (45.72, -67.817), (46.503, -67.601), (47.443, -67.719), (48.344, -67.366), (48.991, -67.092), (49.931, -67.111), (50.753, -66.876), (50.949, -66.523), (51.792, -66.249), (52.614, -66.053), (53.613, -65.896), (54.534, -65.818), (55.415, -65.877), (56.355, -65.975), (57.158, -66.249), (57.256, -66.68), (58.137, -67.013), (58.745, -67.288), (59.939, -67.405), (60.605, -67.68), (61.428, -67.954), (62.387, -68.013), (63.19, -67.817), (64.052, -67.405), (64.992, -67.621), (65.972, -67.738), (66.912, -67.856), (67.891, -67.934), (68.89, -67.934), (69.713, -68.973), (69.673, -69.228), (69.556, -69.678), (68.596, -69.933), (67.813, -70.305), (67.95, -70.697), (69.066, -70.678), (68.929, -71.069), (68.42, -71.442), (67.95, -71.853), (68.714, -72.167), (69.869, -72.265), (71.025, -72.088), (71.573, -71.697), (71.906, -71.324), (72.455, -71.011), (73.081, -70.717), (73.336, -70.364), (73.865, -69.874), (74.492, -69.776), (75.628, -69.737), (76.626, -69.619), (77.645, -69.463), (78.135, -69.071), (78.428, -68.698), (79.114, -68.326), (80.093, -68.072), (80.935, -67.876), (81.484, -67.542), (82.052, -67.366), (82.776, -67.209), (83.775, -67.307), (84.676, -67.209), (85.656, -67.092), (86.752, -67.15), (87.477, -66.876), (87.986, -66.21), (88.358, -66.484), (88.828, -66.955), (89.671, -67.15), (90.63, -67.229), (91.59, -67.111), (92.609, -67.19), (93.549, -67.209), (94.175, -67.111), (95.018, -67.17), (95.781, -67.386), (96.682, -67.249), (97.76, -67.249), (98.68, -67.111), (99.718, -67.249), (100.384, -66.915), (100.893, -66.582), (101.579, -66.308), (102.832, -65.563), (103.479, -65.7), (104.243, -65.975), (104.908, -66.328), (106.182, -66.935), (107.161, -66.955), (108.081, -66.955), (109.159, -66.837), (110.236, -66.7), (111.058, -66.426), (111.744, -66.132), (112.86, -66.092), (113.605, -65.877), (114.388, -66.073), (114.897, -66.386), (115.602, -66.7), (116.699, -66.661), (117.385, -66.915), (118.579, -67.17), (119.833, -67.268), (120.871, -67.19), (121.654, -66.876), (122.32, -66.563), (123.221, -66.484), (124.122, -66.621), (125.16, -66.719), (126.1, -66.563), (127.001, -66.563), (127.883, -66.661), (128.803, -66.759), (129.704, -66.582), (130.781, -66.426), (131.8, -66.386), (132.936, -66.386), (133.856, -66.288), (134.757, -66.21), (135.032, -65.72), (135.071, -65.309), (135.697, -65.583), (135.874, -66.034), (136.207, -66.445), (136.618, -66.778), (137.46, -66.955), (138.596, -66.896), (139.908, -66.876), (140.809, -66.817), (142.122, -66.817), (143.062, -66.798), (144.374, -66.837), (145.49, -66.915), (146.196, -67.229), (146.0, -67.601), (146.646, -67.895), (147.723, -68.13), (148.84, -68.385), (150.132, -68.561), (151.484, -68.718), (152.502, -68.875), (153.638, -68.895), (154.285, -68.561), (155.166, -68.836), (155.93, -69.149), (156.811, -69.384), (158.026, -69.482), (159.181, -69.6), (159.671, -69.992), (160.807, -70.227), (161.57, -70.58), (162.687, -70.736), (163.842, -70.717), (164.92, -70.776), (166.114, -70.756), (167.309, -70.834), (168.426, -70.971), (169.464, -71.207), (170.502, -71.403), (171.207, -71.697), (171.089, -72.088), (170.56, -72.441), (170.11, -72.892), (169.757, -73.245), (169.287, -73.656), (167.975, -73.813), (167.387, -74.165), (166.095, -74.381), (165.644, -74.773), (164.959, -75.145), (164.234, -75.459), (163.823, -75.87), (163.568, -76.243), (163.47, -76.693), (163.49, -77.066), (164.058, -77.457), (164.273, -77.83), (164.743, -78.183), (166.604, -78.32), (166.996, -78.751), (165.194, -78.907), (163.666, -79.123), (161.766, -79.162), (160.924, -79.73), (160.748, -80.201), (160.317, -80.573), (159.788, -80.945), (161.12, -81.279), (161.629, -81.69), (162.491, -82.062), (163.705, -82.395), (165.096, -82.709), (166.604, -83.022), (168.896, -83.336), (169.405, -83.826), (172.284, -84.041), (172.477, -84.118), (173.224, -84.414), (175.986, -84.159), (178.277, -84.473)]]], ['CN', [[(32.732, 35.14), (32.802, 35.146), (32.947, 35.387), (33.667, 35.373), (34.576, 35.672), (33.901, 35.246), (33.974, 35.059), (33.866, 35.094), (33.675, 35.018), (33.526, 35.039), (33.476, 35.0), (33.456, 35.101), (33.384, 35.163), (33.191, 35.173), (32.92, 35.088)]]], ['CY', [[(32.732, 35.14), (32.92, 35.088), (33.191, 35.173), (33.384, 35.163), (33.456, 35.101), (33.476, 35.0), (33.526, 35.039), (33.675, 35.018), (33.866, 35.094), (33.974, 35.059), (34.005, 34.978), (32.98, 34.572), (32.49, 34.702), (32.257, 35.103)]]], ['MA', [[(-2.17, 35.168), (-1.793, 34.528), (-1.733, 33.92), (-1.388, 32.864), (-1.125, 32.652), (-1.308, 32.263), (-2.617, 32.094), (-3.069, 31.724), (-3.647, 31.637), (-3.69, 30.897), (-4.86, 30.501), (-5.242, 30.0), (-6.061, 29.732), (-7.059, 29.579), (-8.674, 28.841), (-8.666, 27.656), (-8.818, 27.656), (-8.818, 27.656), (-8.795, 27.121), (-9.413, 27.088), (-9.735, 26.861), (-10.189, 26.861), (-10.551, 26.991), (-11.393, 26.883), (-11.718, 26.104), (-12.031, 26.031), (-12.501, 24.77), (-13.891, 23.691), (-14.221, 22.31), (-14.631, 21.861), (-14.751, 21.501), (-17.003, 21.421), (-17.02, 21.422), (-16.973, 21.886), (-16.589, 22.158), (-16.262, 22.679), (-16.326, 23.018), (-15.983, 23.723), (-15.426, 24.359), (-15.089, 24.52), (-14.825, 25.104), (-14.801, 25.636), (-14.44, 26.254), (-13.774, 26.619), (-13.14, 27.64), (-13.122, 27.654), (-12.619, 28.038), (-11.689, 28.149), (-10.901, 28.832), (-10.4, 29.099), (-9.565, 29.934), (-9.815, 31.178), (-9.435, 32.038), (-9.301, 32.565), (-8.657, 33.24), (-7.654, 33.697), (-6.913, 34.11), (-6.244, 35.146), (-5.93, 35.76), (-5.194, 35.755), (-4.591, 35.331), (-3.64, 35.4), (-2.604, 35.179)]]], ['EG', [[(36.866, 22.0), (32.9, 22.0), (29.02, 22.0), (25.0, 22.0), (25.0, 29.239), (24.7, 30.044), (24.958, 30.662), (24.803, 31.089), (25.165, 31.569), (26.495, 31.586), (27.458, 31.321), (28.45, 31.026), (28.914, 30.87), (29.683, 31.187), (30.095, 31.473), (30.977, 31.556), (31.688, 31.43), (31.96, 30.934), (32.192, 31.26), (32.994, 31.024), (33.773, 30.967), (34.265, 31.219), (34.265, 31.219), (34.823, 29.761), (34.923, 29.501), (34.642, 29.099), (34.427, 28.344), (34.155, 27.823), (33.921, 27.649), (33.588, 27.971), (33.137, 28.418), (32.423, 29.851), (32.32, 29.76), (32.735, 28.705), (33.349, 27.7), (34.105, 26.142), (34.474, 25.599), (34.795, 25.034), (35.692, 23.927), (35.494, 23.752), (35.526, 23.102), (36.691, 22.205)]]], ['LY', [[(25.0, 22.0), (25.0, 20.003), (23.85, 20.0), (23.838, 19.58), (15.861, 23.41), (14.851, 22.863), (14.144, 22.491), (13.581, 23.041), (12.0, 23.472), (11.561, 24.098), (10.771, 24.563), (10.304, 24.379), (9.948, 24.937), (9.911, 25.365), (9.319, 26.094), (9.716, 26.512), (9.629, 27.141), (9.756, 27.688), (9.684, 28.144), (9.86, 28.96), (9.806, 29.425), (9.482, 30.308), (9.97, 30.539), (10.057, 30.962), (9.95, 31.376), (10.637, 31.761), (10.945, 32.082), (11.432, 32.369), (11.489, 33.137), (12.663, 32.793), (13.083, 32.879), (13.919, 32.712), (15.246, 32.265), (15.714, 31.376), (16.612, 31.182), (18.021, 30.764), (19.086, 30.266), (19.574, 30.526), (20.053, 30.986), (19.82, 31.752), (20.134, 32.238), (20.855, 32.707), (21.543, 32.843), (22.896, 32.639), (23.237, 32.191), (23.609, 32.187), (23.927, 32.017), (24.921, 31.899), (25.165, 31.569), (24.803, 31.089), (24.958, 30.662), (24.7, 30.044), (25.0, 29.239)]]], ['ET', [[(47.789, 8.003), (44.964, 5.002), (43.661, 4.958), (42.77, 4.253), (42.129, 4.234), (41.855, 3.919), (41.172, 3.919), (40.768, 4.257), (39.855, 3.839), (39.559, 3.422), (38.893, 3.501), (38.671, 3.616), (38.437, 3.589), (38.121, 3.599), (36.855, 4.448), (36.159, 4.448), (35.817, 4.777), (35.817, 5.338), (35.298, 5.506), (34.707, 6.594), (34.25, 6.826), (34.075, 7.226), (33.568, 7.713), (32.954, 7.785), (33.295, 8.355), (33.825, 8.379), (33.975, 8.685), (33.963, 9.464), (33.962, 9.584), (34.257, 10.63), (34.731, 10.91), (34.832, 11.319), (35.26, 12.083), (35.864, 12.578), (36.27, 13.563), (36.43, 14.422), (37.594, 14.213), (37.906, 14.959), (38.513, 14.505), (39.099, 14.741), (39.341, 14.532), (40.026, 14.52), (40.897, 14.119), (41.155, 13.773), (41.599, 13.452), (42.01, 12.866), (42.352, 12.542), (42.0, 12.1), (41.662, 11.631), (41.74, 11.355), (41.756, 11.051), (42.314, 11.034), (42.555, 11.105), (42.777, 10.927), (42.559, 10.573), (42.928, 10.022), (43.297, 9.54), (43.679, 9.184), (46.948, 7.997)]]], ['DJ', [[(42.352, 12.542), (42.78, 12.455), (43.081, 12.7), (43.318, 12.39), (43.286, 11.975), (42.716, 11.736), (43.145, 11.462), (42.777, 10.927), (42.555, 11.105), (42.314, 11.034), (41.756, 11.051), (41.74, 11.355), (41.662, 11.631), (42.0, 12.1)]]], ['SL', [[(48.948, 11.411), (48.942, 11.394), (48.938, 10.982), (48.938, 9.973), (48.938, 9.452), (48.487, 8.838), (47.789, 8.003), (46.948, 7.997), (43.679, 9.184), (43.297, 9.54), (42.928, 10.022), (42.559, 10.573), (42.777, 10.927), (43.145, 11.462), (43.471, 11.278), (43.667, 10.864), (44.118, 10.446), (44.614, 10.442), (45.557, 10.698), (46.645, 10.817), (47.526, 11.127), (48.022, 11.193), (48.379, 11.375), (48.948, 11.411)]]], ['UG', [[(31.866, -1.027), (31.866, -1.027), (30.77, -1.015), (30.419, -1.135), (29.822, -1.443), (29.579, -1.341), (29.588, -0.587), (29.82, -0.205), (29.876, 0.597), (30.086, 1.062), (30.469, 1.584), (30.853, 1.849), (31.174, 2.204), (30.773, 2.34), (30.834, 3.509), (30.834, 3.509), (31.246, 3.782), (31.881, 3.558), (32.686, 3.792), (33.39, 3.79), (34.005, 4.25), (34.479, 3.556), (34.596, 3.054), (35.036, 1.906), (34.672, 1.177), (34.18, 0.515), (33.894, 0.11), (33.894, 0.06), (33.85, 0.128), (33.332, 0.325), (32.906, 0.087), (32.273, -0.056), (31.815, -0.64)]]], ['RW', [[(30.419, -1.135), (30.816, -1.699), (30.758, -2.287), (30.47, -2.414), (30.47, -2.414), (29.938, -2.348), (29.632, -2.918), (29.025, -2.839), (29.117, -2.292), (29.255, -2.215), (29.292, -1.62), (29.579, -1.341), (29.822, -1.443)]]], ['BiH', [[(18.56, 42.65), (17.675, 43.029), (17.297, 43.446), (16.916, 43.668), (16.456, 44.041), (16.24, 44.351), (15.75, 44.819), (15.959, 45.234), (16.318, 45.004), (16.535, 45.212), (17.002, 45.234), (17.862, 45.068), (18.553, 45.082), (19.005, 44.86), (19.005, 44.86), (19.368, 44.863), (19.118, 44.423), (19.6, 44.038), (19.454, 43.568), (19.219, 43.524), (19.032, 43.433), (18.706, 43.2)]]], ['NM', [[(22.381, 42.32), (22.881, 41.999), (22.952, 41.338), (22.762, 41.305), (22.597, 41.13), (22.055, 41.15), (21.674, 40.931), (21.02, 40.843), (20.605, 41.086), (20.463, 41.515), (20.59, 41.855), (20.59, 41.855), (20.717, 41.847), (20.762, 42.052), (21.353, 42.207), (21.577, 42.245), (21.917, 42.304)]]], ['RS', [[(18.83, 45.909), (18.83, 45.909), (19.596, 46.172), (20.22, 46.127), (20.762, 45.735), (20.874, 45.416), (21.484, 45.181), (21.562, 44.769), (22.145, 44.478), (22.459, 44.703), (22.706, 44.578), (22.474, 44.409), (22.657, 44.235), (22.41, 44.008), (22.5, 43.643), (22.986, 43.211), (22.605, 42.899), (22.437, 42.58), (22.545, 42.461), (22.381, 42.32), (21.917, 42.304), (21.577, 42.245), (21.543, 42.32), (21.663, 42.439), (21.775, 42.683), (21.633, 42.677), (21.439, 42.863), (21.274, 42.91), (21.143, 43.069), (20.957, 43.131), (20.814, 43.272), (20.635, 43.217), (20.497, 42.885), (20.258, 42.813), (20.34, 42.899), (19.959, 43.106), (19.63, 43.214), (19.484, 43.352), (19.219, 43.524), (19.454, 43.568), (19.6, 44.038), (19.118, 44.423), (19.368, 44.863), (19.005, 44.86), (19.005, 44.86), (19.39, 45.237), (19.073, 45.522)]]], ['ME', [[(20.071, 42.589), (19.802, 42.5), (19.738, 42.688), (19.304, 42.196), (19.372, 41.878), (19.162, 41.955), (18.882, 42.282), (18.45, 42.48), (18.56, 42.65), (18.706, 43.2), (19.032, 43.433), (19.219, 43.524), (19.484, 43.352), (19.63, 43.214), (19.959, 43.106), (20.34, 42.899), (20.258, 42.813)]]], ['KO', [[(20.59, 41.855), (20.523, 42.218), (20.284, 42.32), (20.071, 42.589), (20.258, 42.813), (20.497, 42.885), (20.635, 43.217), (20.814, 43.272), (20.957, 43.131), (21.143, 43.069), (21.274, 42.91), (21.439, 42.863), (21.633, 42.677), (21.775, 42.683), (21.663, 42.439), (21.543, 42.32), (21.577, 42.245), (21.353, 42.207), (20.762, 42.052), (20.717, 41.847)]]], ['SS', [[(30.834, 3.509), (29.953, 4.174), (29.716, 4.601), (29.159, 4.389), (28.697, 4.455), (28.429, 4.287), (27.98, 4.408), (27.374, 5.234), (27.213, 5.551), (26.466, 5.947), (26.213, 6.547), (25.797, 6.979), (25.124, 7.5), (25.115, 7.825), (24.567, 8.229), (23.887, 8.62), (24.194, 8.729), (24.537, 8.918), (24.795, 9.81), (25.07, 10.274), (25.791, 10.411), (25.962, 10.136), (26.477, 9.553), (26.752, 9.467), (27.113, 9.639), (27.834, 9.604), (27.971, 9.398), (28.967, 9.398), (29.001, 9.604), (29.516, 9.793), (29.619, 10.085), (29.997, 10.291), (30.838, 9.707), (31.353, 9.81), (31.851, 10.531), (32.4, 11.081), (32.314, 11.681), (32.074, 11.973), (32.675, 12.025), (32.743, 12.248), (33.207, 12.179), (33.087, 11.441), (33.207, 10.72), (33.722, 10.325), (33.842, 9.982), (33.825, 9.484), (33.963, 9.464), (33.975, 8.685), (33.825, 8.379), (33.295, 8.355), (32.954, 7.785), (33.568, 7.713), (34.075, 7.226), (34.25, 6.826), (34.707, 6.594), (35.298, 5.506), (34.62, 4.847), (34.005, 4.25), (33.39, 3.79), (32.686, 3.792), (31.881, 3.558), (31.246, 3.782)]]], [None, [[(-76.809, 44.14), (-76.799, 44.155), (-76.761, 44.172), (-76.643, 44.199), (-76.64, 44.181), (-76.688, 44.138), (-76.731, 44.127), (-76.787, 44.13)]]], [None, [[(-76.485, 44.128), (-76.474, 44.141), (-76.477, 44.153), (-76.492, 44.162), (-76.483, 44.179), (-76.451, 44.202), (-76.43, 44.227), (-76.329, 44.239), (-76.227, 44.254), (-76.237, 44.233), (-76.33, 44.208), (-76.353, 44.176), (-76.365, 44.156), (-76.423, 44.122), (-76.469, 44.125)]]], [None, [[(-83.48, 45.907), (-83.392, 45.988), (-82.821, 45.977), (-82.295, 45.973), (-81.939, 45.979), (-81.675, 45.896), (-81.593, 45.792), (-81.727, 45.5), (-81.788, 45.466), (-81.881, 45.535), (-82.029, 45.566), (-83.332, 45.88)]]], ['NL', [[(-54.276, 47.407), (-54.326, 47.408), (-54.32, 47.439), (-54.259, 47.498), (-54.227, 47.54), (-54.226, 47.566), (-54.215, 47.585), (-54.168, 47.607), (-54.128, 47.647), (-54.148, 47.573), (-54.227, 47.441)], [(-54.709, 49.531), (-54.744, 49.508), (-54.786, 49.496), (-54.819, 49.514), (-54.864, 49.576), (-54.855, 49.597), (-54.813, 49.599), (-54.789, 49.591), (-54.783, 49.572), (-54.764, 49.562), (-54.733, 49.562), (-54.619, 49.622), (-54.559, 49.631), (-54.538, 49.62), (-54.554, 49.589)], [(-54.02, 49.679), (-53.981, 49.662), (-54.238, 49.592), (-54.269, 49.587), (-54.286, 49.595), (-54.289, 49.661), (-54.278, 49.711), (-54.259, 49.719), (-54.199, 49.689), (-54.138, 49.751), (-54.094, 49.744)], [(-55.57, 50.709), (-55.601, 50.709), (-55.629, 50.721), (-55.634, 50.74), (-55.605, 50.781), (-55.527, 50.801), (-55.469, 50.796), (-55.473, 50.776), (-55.504, 50.742), (-55.536, 50.72)], [(-55.532, 51.437), (-55.583, 51.389), (-55.631, 51.373), (-55.731, 51.359), (-55.941, 51.343), (-56.031, 51.328), (-56.044, 51.262), (-56.031, 51.227), (-56.0, 51.199), (-55.961, 51.191), (-55.874, 51.208), (-55.841, 51.205), (-55.815, 51.191), (-55.795, 51.166), (-55.785, 51.131), (-55.785, 51.087), (-55.8, 51.033), (-55.871, 50.907), (-55.962, 50.838), (-56.078, 50.781), (-56.107, 50.759), (-56.121, 50.734), (-56.136, 50.651), (-56.196, 50.585), (-56.382, 50.417), (-56.454, 50.38), (-56.455, 50.35), (-56.484, 50.271), (-56.539, 50.207), (-56.694, 50.06), (-56.732, 50.008), (-56.75, 49.967), (-56.747, 49.908), (-56.754, 49.883), (-56.79, 49.834), (-56.839, 49.788), (-56.849, 49.765), (-56.829, 49.725), (-56.809, 49.71), (-56.807, 49.673), (-56.822, 49.613), (-56.757, 49.652), (-56.611, 49.788), (-56.501, 49.87), (-56.428, 49.897), (-56.376, 49.934), (-56.322, 50.014), (-56.247, 50.09), (-56.179, 50.115), (-56.148, 50.1), (-56.122, 50.063), (-56.127, 50.015), (-56.164, 49.957), (-56.161, 49.94), (-56.075, 49.983), (-55.927, 50.018), (-55.873, 50.013), (-55.765, 49.96), (-55.674, 49.967), (-55.53, 49.997), (-55.503, 49.983), (-55.527, 49.937), (-55.584, 49.892), (-55.718, 49.829), (-56.04, 49.705), (-56.14, 49.619), (-56.121, 49.622), (-56.052, 49.658), (-55.978, 49.678), (-55.902, 49.681), (-55.87, 49.67), (-55.882, 49.646), (-55.892, 49.58), (-56.087, 49.452), (-56.041, 49.457), (-55.815, 49.515), (-55.678, 49.435), (-55.49, 49.463), (-55.376, 49.49), (-55.379, 49.473), (-55.355, 49.438), (-55.355, 49.381), (-55.344, 49.373), (-55.29, 49.392), (-55.28, 49.413), (-55.283, 49.514), (-55.266, 49.524), (-55.23, 49.508), (-55.207, 49.482), (-55.2, 49.409), (-55.225, 49.335), (-55.259, 49.267), (-55.343, 49.168), (-55.332, 49.126), (-55.353, 49.079), (-55.335, 49.078), (-55.252, 49.121), (-55.247, 49.139), (-55.254, 49.18), (-55.245, 49.2), (-55.176, 49.244), (-55.063, 49.297), (-55.026, 49.305), (-55.01, 49.293), (-55.016, 49.26), (-54.983, 49.268), (-54.911, 49.316), (-54.844, 49.345), (-54.782, 49.355), (-54.718, 49.389), (-54.651, 49.445), (-54.579, 49.491), (-54.502, 49.527), (-54.469, 49.53), (-54.481, 49.469), (-54.465, 49.401), (-54.463, 49.342), (-54.448, 49.329), (-54.389, 49.392), (-54.356, 49.415), (-54.317, 49.424), (-54.271, 49.419), (-53.958, 49.442), (-53.862, 49.426), (-53.755, 49.385), (-53.619, 49.322), (-53.57, 49.264), (-53.56, 49.192), (-53.573, 49.141), (-53.671, 49.078), (-53.758, 49.035), (-53.809, 48.993), (-53.825, 48.951), (-53.845, 48.925), (-53.903, 48.889), (-54.161, 48.788), (-54.1, 48.785), (-53.951, 48.807), (-53.853, 48.811), (-53.848, 48.797), (-53.887, 48.768), (-53.962, 48.739), (-53.97, 48.725), (-53.966, 48.707), (-53.886, 48.685), (-53.784, 48.695), (-53.698, 48.68), (-53.706, 48.656), (-53.775, 48.576), (-53.795, 48.526), (-53.886, 48.485), (-54.068, 48.419), (-54.114, 48.394), (-54.104, 48.388), (-53.937, 48.437), (-53.853, 48.449), (-53.799, 48.449), (-53.739, 48.496), (-53.644, 48.511), (-53.552, 48.482), (-53.411, 48.562), (-53.361, 48.573), (-53.275, 48.563), (-53.22, 48.578), (-53.127, 48.633), (-53.057, 48.659), (-53.043, 48.657), (-53.028, 48.635), (-53.021, 48.572), (-53.037, 48.516), (-53.06, 48.48), (-53.136, 48.402), (-53.182, 48.374), (-53.225, 48.364), (-53.301, 48.368), (-53.334, 48.356), (-53.406, 48.294), (-53.531, 48.232), (-53.61, 48.208), (-53.56, 48.174), (-53.542, 48.108), (-53.569, 48.088), (-53.704, 48.068), (-53.71, 48.057), (-53.758, 48.042), (-53.87, 48.02), (-53.794, 48.01), (-53.653, 48.026), (-53.638, 48.015), (-53.658, 47.969), (-53.695, 47.921), (-53.862, 47.799), (-53.864, 47.787), (-53.838, 47.727), (-53.805, 47.682), (-53.765, 47.65), (-53.672, 47.648), (-53.604, 47.662), (-53.504, 47.744), (-53.283, 47.998), (-53.085, 48.068), (-52.921, 48.147), (-52.883, 48.131), (-52.866, 48.113), (-52.872, 48.094), (-52.955, 48.029), (-52.998, 47.976), (-53.111, 47.812), (-53.154, 47.735), (-53.176, 47.653), (-53.17, 47.512), (-53.158, 47.488), (-53.122, 47.455), (-53.057, 47.483), (-52.945, 47.553), (-52.873, 47.619), (-52.817, 47.728), (-52.782, 47.769), (-52.745, 47.769), (-52.711, 47.745), (-52.703, 47.693), (-52.672, 47.622), (-52.654, 47.549), (-52.669, 47.47), (-52.684, 47.426), (-52.912, 47.103), (-52.888, 47.046), (-52.882, 47.011), (-52.889, 46.974), (-52.962, 46.819), (-53.032, 46.723), (-53.07, 46.681), (-53.115, 46.656), (-53.167, 46.647), (-53.214, 46.661), (-53.255, 46.698), (-53.291, 46.717), (-53.323, 46.718), (-53.382, 46.711), (-53.536, 46.633), (-53.568, 46.628), (-53.59, 46.639), (-53.616, 46.68), (-53.595, 46.888), (-53.581, 46.957), (-53.612, 47.01), (-53.58, 47.099), (-53.578, 47.133), (-53.597, 47.146), (-53.636, 47.138), (-53.695, 47.093), (-53.774, 47.012), (-53.86, 46.939), (-54.01, 46.84), (-54.076, 46.82), (-54.102, 46.825), (-54.133, 46.839), (-54.174, 46.88), (-54.173, 46.917), (-54.155, 46.967), (-54.093, 47.086), (-53.97, 47.262), (-53.869, 47.387), (-53.85, 47.44), (-53.878, 47.464), (-53.901, 47.509), (-53.94, 47.645), (-53.989, 47.756), (-54.047, 47.806), (-54.192, 47.86), (-54.218, 47.847), (-54.234, 47.772), (-54.405, 47.556), (-54.435, 47.462), (-54.456, 47.428), (-54.488, 47.404), (-54.563, 47.375), (-54.542, 47.425), (-54.463, 47.536), (-54.474, 47.547), (-54.574, 47.458), (-54.651, 47.408), (-54.745, 47.395), (-54.802, 47.399), (-54.857, 47.385), (-55.09, 47.174), (-55.099, 47.104), (-55.14, 47.046), (-55.255, 46.942), (-55.316, 46.906), (-55.401, 46.899), (-55.479, 46.917), (-55.531, 46.914), (-55.652, 46.881), (-55.789, 46.867), (-55.845, 46.874), (-55.881, 46.887), (-55.95, 46.928), (-55.958, 46.956), (-55.955, 46.973), (-55.919, 47.017), (-55.838, 47.072), (-55.772, 47.092), (-55.61, 47.12), (-55.492, 47.161), (-55.401, 47.221), (-55.361, 47.259), (-55.191, 47.449), (-54.976, 47.516), (-54.87, 47.571), (-54.795, 47.64), (-54.785, 47.665), (-54.891, 47.629), (-54.946, 47.621), (-55.035, 47.634), (-55.075, 47.658), (-55.197, 47.65), (-55.366, 47.661), (-55.391, 47.643), (-55.413, 47.55), (-55.435, 47.501), (-55.461, 47.485), (-55.499, 47.475), (-55.576, 47.465), (-55.775, 47.498), (-55.811, 47.516), (-55.862, 47.53), (-56.081, 47.5), (-56.127, 47.503), (-56.084, 47.524), (-55.867, 47.592), (-55.844, 47.788), (-55.858, 47.819), (-55.918, 47.792), (-56.02, 47.764), (-56.09, 47.772), (-56.121, 47.789), (-56.151, 47.775), (-56.221, 47.671), (-56.263, 47.658), (-56.326, 47.655), (-56.46, 47.617), (-56.722, 47.592), (-56.774, 47.565), (-56.952, 47.574), (-57.473, 47.631), (-57.66, 47.625), (-57.884, 47.66), (-57.926, 47.675), (-58.239, 47.669), (-58.333, 47.677), (-58.327, 47.72), (-58.337, 47.731), (-58.428, 47.683), (-58.509, 47.653), (-58.613, 47.626), (-58.941, 47.58), (-59.117, 47.571), (-59.219, 47.603), (-59.26, 47.634), (-59.321, 47.737), (-59.362, 47.866), (-59.362, 47.889), (-59.341, 47.934), (-59.272, 47.996), (-58.961, 48.159), (-58.711, 48.325), (-58.605, 48.411), (-58.503, 48.442), (-58.336, 48.514), (-58.33, 48.522), (-58.492, 48.513), (-58.606, 48.533), (-58.723, 48.541), (-58.944, 48.522), (-59.167, 48.522), (-59.168, 48.558), (-59.063, 48.628), (-58.842, 48.746), (-58.819, 48.747), (-58.887, 48.692), (-58.906, 48.65), (-58.877, 48.623), (-58.843, 48.605), (-58.716, 48.598), (-58.687, 48.622), (-58.642, 48.749), (-58.546, 48.897), (-58.494, 49.003), (-58.404, 49.084), (-58.359, 49.097), (-58.319, 49.081), (-58.186, 49.062), (-58.05, 48.988), (-58.006, 48.981), (-57.991, 48.988), (-58.041, 49.01), (-58.082, 49.045), (-58.099, 49.077), (-58.049, 49.18), (-57.991, 49.209), (-57.98, 49.23), (-58.097, 49.23), (-58.191, 49.259), (-58.219, 49.305), (-58.213, 49.387), (-58.183, 49.435), (-58.107, 49.5), (-58.016, 49.543), (-57.961, 49.532), (-57.856, 49.474), (-57.791, 49.49), (-57.799, 49.509), (-57.897, 49.6), (-57.929, 49.668), (-57.926, 49.701), (-57.713, 50.025), (-57.608, 50.199), (-57.466, 50.464), (-57.433, 50.506), (-57.36, 50.584), (-57.331, 50.605), (-57.237, 50.605), (-57.18, 50.615), (-57.264, 50.649), (-57.294, 50.673), (-57.298, 50.699), (-57.275, 50.725), (-57.242, 50.745), (-57.132, 50.787), (-57.053, 50.857), (-57.006, 50.94), (-57.013, 50.968), (-57.037, 50.996), (-57.036, 51.011), (-56.976, 51.028), (-56.825, 51.126), (-56.805, 51.144), (-56.75, 51.275), (-56.682, 51.333), (-56.619, 51.362), (-56.518, 51.399), (-56.207, 51.489), (-56.026, 51.568), (-55.902, 51.564), (-55.866, 51.508), (-55.69, 51.471), (-55.66, 51.511), (-55.701, 51.559), (-55.666, 51.579), (-55.522, 51.596), (-55.496, 51.59), (-55.453, 51.562), (-55.459, 51.537)], [(-55.409, 51.889), (-55.42, 51.9), (-55.4, 51.938), (-55.346, 51.983), (-55.274, 51.995), (-55.294, 51.93), (-55.361, 51.89)], [(-60.983, 56.015), (-61.137, 56.033), (-61.191, 56.048), (-61.196, 56.064), (-61.188, 56.089), (-61.158, 56.118), (-61.087, 56.141), (-61.049, 56.129), (-60.966, 56.099), (-60.955, 56.08), (-60.994, 56.039)], [(-61.66, 57.525), (-61.637, 57.416), (-61.795, 57.422), (-61.975, 57.495), (-62.011, 57.548), (-62.007, 57.558), (-61.983, 57.567), (-61.938, 57.554), (-61.893, 57.573), (-61.848, 57.579), (-61.744, 57.555)], [(-64.733, 59.998), (-64.559, 60.043), (-64.408, 60.065), (-64.284, 60.064), (-64.183, 59.973), (-64.169, 59.847), (-64.226, 59.741), (-64.151, 59.794), (-64.056, 59.823), (-63.979, 59.754), (-63.97, 59.698), (-63.929, 59.645), (-63.841, 59.574), (-63.75, 59.513), (-63.85, 59.448), (-63.971, 59.409), (-63.945, 59.38), (-63.781, 59.349), (-63.759, 59.319), (-63.776, 59.277), (-63.752, 59.277), (-63.638, 59.341), (-63.54, 59.333), (-63.415, 59.194), (-63.506, 59.115), (-63.646, 59.079), (-63.756, 59.063), (-63.91, 59.066), (-63.971, 59.054), (-63.941, 59.027), (-63.794, 59.027), (-63.568, 59.047), (-63.399, 59.08), (-63.326, 59.082), (-63.248, 59.068), (-63.222, 59.057), (-63.304, 59.034), (-63.31, 59.026), (-63.279, 59.003), (-63.216, 58.928), (-63.222, 58.911), (-63.282, 58.867), (-63.185, 58.858), (-63.05, 58.878), (-63.008, 58.855), (-62.926, 58.765), (-62.874, 58.672), (-63.102, 58.546), (-63.219, 58.52), (-63.39, 58.453), (-63.438, 58.399), (-63.537, 58.33), (-63.474, 58.331), (-63.296, 58.441), (-63.21, 58.467), (-63.145, 58.46), (-63.12, 58.442), (-63.132, 58.411), (-63.076, 58.415), (-62.837, 58.479), (-62.737, 58.492), (-62.608, 58.496), (-62.594, 58.474), (-62.674, 58.319), (-62.812, 58.2), (-63.063, 58.127), (-63.152, 58.084), (-63.262, 58.015), (-63.22, 58.002), (-62.981, 58.093), (-62.818, 58.129), (-62.588, 58.158), (-62.486, 58.154), (-62.306, 57.972), (-62.202, 57.955), (-62.117, 57.964), (-61.959, 57.912), (-61.899, 57.861), (-61.914, 57.825), (-61.968, 57.803), (-61.995, 57.769), (-61.931, 57.669), (-61.968, 57.612), (-62.084, 57.562), (-62.167, 57.537), (-62.254, 57.529), (-62.339, 57.485), (-62.377, 57.478), (-62.496, 57.489), (-62.455, 57.462), (-62.396, 57.448), (-62.303, 57.441), (-62.194, 57.455), (-62.088, 57.453), (-61.921, 57.421), (-61.851, 57.381), (-61.85, 57.37), (-61.886, 57.348), (-61.939, 57.274), (-61.977, 57.248), (-61.945, 57.228), (-61.861, 57.198), (-61.798, 57.186), (-61.716, 57.196), (-61.629, 57.183), (-61.334, 57.011), (-61.346, 56.922), (-61.39, 56.853), (-61.373, 56.776), (-61.372, 56.681), (-61.532, 56.655), (-62.062, 56.699), (-62.366, 56.767), (-62.382, 56.788), (-62.296, 56.833), (-62.372, 56.836), (-62.46, 56.818), (-62.497, 56.802), (-62.396, 56.73), (-62.116, 56.667), (-61.992, 56.591), (-61.855, 56.584), (-61.813, 56.571), (-61.738, 56.526), (-61.76, 56.511), (-61.899, 56.505), (-62.01, 56.454), (-61.94, 56.424), (-61.692, 56.397), (-61.515, 56.39), (-61.425, 56.361), (-61.499, 56.328), (-61.707, 56.289), (-61.713, 56.231), (-61.559, 56.208), (-61.421, 56.222), (-61.365, 56.216), (-61.324, 56.076), (-61.301, 56.047), (-61.449, 56.022), (-61.45, 55.996), (-61.351, 55.974), (-61.188, 55.955), (-61.134, 55.93), (-61.123, 55.889), (-61.089, 55.866), (-60.996, 55.862), (-60.893, 55.914), (-60.832, 55.958), (-60.743, 55.941), (-60.737, 55.887), (-60.631, 55.825), (-60.593, 55.815), (-60.562, 55.727), (-60.476, 55.805), (-60.413, 55.789), (-60.341, 55.785), (-60.365, 55.709), (-60.408, 55.65), (-60.352, 55.612), (-60.308, 55.557), (-60.192, 55.481), (-60.224, 55.444), (-60.361, 55.366), (-60.433, 55.243), (-60.45, 55.2), (-60.521, 55.129), (-60.617, 55.06), (-60.557, 55.067), (-60.341, 55.194), (-60.213, 55.236), (-59.93, 55.259), (-59.862, 55.295), (-59.759, 55.31), (-59.695, 55.269), (-59.689, 55.196), (-59.605, 55.173), (-59.518, 55.197), (-59.438, 55.176), (-59.486, 55.13), (-59.742, 54.943), (-59.816, 54.867), (-59.838, 54.814), (-59.75, 54.887), (-59.429, 55.056), (-59.394, 55.081), (-59.324, 55.153), (-59.26, 55.2), (-59.086, 55.183), (-58.997, 55.149), (-58.956, 55.055), (-58.886, 54.952), (-58.78, 54.838), (-58.5, 54.783), (-58.398, 54.774), (-58.223, 54.813), (-58.195, 54.866), (-58.058, 54.882), (-57.962, 54.876), (-57.929, 54.773), (-57.827, 54.719), (-57.725, 54.674), (-57.627, 54.65), (-57.483, 54.64), (-57.405, 54.591), (-57.404, 54.57), (-57.485, 54.518), (-57.563, 54.44), (-57.699, 54.387), (-57.889, 54.384), (-58.151, 54.35), (-58.162, 54.32), (-58.22, 54.286), (-58.359, 54.253), (-58.435, 54.228), (-58.558, 54.103), (-58.633, 54.05), (-58.719, 54.039), (-58.841, 54.045), (-58.92, 54.033), (-58.978, 54.01), (-59.013, 53.976), (-59.039, 53.964), (-59.201, 53.929), (-59.497, 53.834), (-59.653, 53.831), (-59.749, 53.842), (-59.823, 53.834), (-59.873, 53.808), (-60.014, 53.762), (-60.057, 53.733), (-60.081, 53.701), (-60.101, 53.634), (-60.117, 53.61), (-60.145, 53.596), (-60.263, 53.61), (-60.395, 53.653), (-60.37, 53.607), (-60.16, 53.53), (-60.1, 53.487), (-60.157, 53.45), (-60.29, 53.391), (-60.306, 53.36), (-60.251, 53.344), (-60.273, 53.317), (-60.346, 53.289), (-60.338, 53.277), (-60.329, 53.266), (-60.148, 53.307), (-59.987, 53.393), (-59.882, 53.48), (-59.829, 53.505), (-59.621, 53.537), (-59.498, 53.575), (-59.322, 53.644), (-59.129, 53.744), (-58.92, 53.875), (-58.652, 53.978), (-58.327, 54.052), (-58.088, 54.09), (-57.936, 54.091), (-57.928, 54.104), (-58.065, 54.127), (-58.177, 54.131), (-58.317, 54.114), (-58.361, 54.154), (-58.356, 54.172), (-58.31, 54.202), (-58.192, 54.228), (-57.615, 54.191), (-57.416, 54.163), (-57.199, 53.924), (-57.149, 53.848), (-57.135, 53.792), (-57.157, 53.757), (-57.244, 53.715), (-57.489, 53.633), (-57.524, 53.611), (-57.527, 53.6), (-57.42, 53.583), (-57.386, 53.561), (-57.332, 53.469), (-57.221, 53.529), (-57.012, 53.673), (-56.841, 53.739), (-56.697, 53.758), (-56.524, 53.766), (-56.465, 53.765), (-56.444, 53.718), (-56.354, 53.624), (-56.27, 53.6), (-56.11, 53.588), (-55.966, 53.471), (-55.911, 53.391), (-55.859, 53.344), (-55.863, 53.312), (-55.855, 53.286), (-55.817, 53.246), (-55.798, 53.212), (-55.808, 53.135), (-55.892, 53.0), (-55.83, 52.878), (-55.858, 52.823), (-55.873, 52.736), (-55.819, 52.677), (-55.803, 52.643), (-55.848, 52.623), (-56.167, 52.575), (-56.292, 52.574), (-56.325, 52.545), (-56.228, 52.536), (-56.053, 52.537), (-55.84, 52.508), (-55.746, 52.475), (-55.706, 52.428), (-55.716, 52.391), (-55.777, 52.364), (-55.897, 52.37), (-56.012, 52.394), (-56.005, 52.37), (-55.834, 52.31), (-55.783, 52.28), (-55.691, 52.242), (-55.673, 52.19), (-55.695, 52.138), (-56.018, 51.929), (-56.283, 51.797), (-56.549, 51.681), (-56.976, 51.458), (-57.018, 51.447), (-57.096, 51.443), (-57.1, 51.443), (-57.299, 51.478), (-57.462, 51.469), (-57.77, 51.426), (-57.854, 51.4), (-58.023, 51.322), (-58.089, 51.311), (-58.27, 51.295), (-58.442, 51.306), (-58.51, 51.295), (-58.593, 51.257), (-58.615, 51.237), (-58.638, 51.172), (-59.055, 50.879), (-59.165, 50.78), (-59.378, 50.675), (-59.612, 50.492), (-59.815, 50.418), (-59.886, 50.316), (-60.08, 50.255), (-60.438, 50.239), (-60.608, 50.221), (-60.807, 50.25), (-60.956, 50.205), (-61.181, 50.192), (-61.29, 50.202), (-61.725, 50.104), (-61.835, 50.197), (-61.92, 50.233), (-62.165, 50.239), (-62.362, 50.277), (-62.541, 50.285), (-62.715, 50.302), (-62.83, 50.301), (-62.95, 50.291), (-63.136, 50.294), (-63.239, 50.243), (-63.587, 50.258), (-63.734, 50.305), (-63.854, 50.314), (-64.016, 50.304), (-64.17, 50.269), (-64.509, 50.309), (-64.868, 50.275), (-65.181, 50.298), (-65.269, 50.32), (-65.762, 50.259), (-65.955, 50.294), (-66.126, 50.201), (-66.242, 50.22), (-66.369, 50.207), (-66.411, 50.224), (-66.496, 50.212), (-66.55, 50.161), (-66.622, 50.155), (-66.741, 50.066), (-66.941, 49.994), (-67.234, 49.602), (-67.262, 49.451), (-67.372, 49.348), (-67.469, 49.335), (-67.549, 49.332), (-68.056, 49.257), (-68.282, 49.197), (-68.221, 49.15), (-68.295, 49.114), (-68.414, 49.1), (-68.544, 49.056), (-68.628, 49.007), (-68.669, 48.94), (-68.929, 48.829), (-69.231, 48.574), (-69.375, 48.386), (-69.55, 48.251), (-69.674, 48.199), (-69.762, 48.191), (-69.852, 48.207), (-70.001, 48.271), (-70.111, 48.278), (-70.384, 48.367), (-71.018, 48.456), (-70.923, 48.422), (-70.839, 48.367), (-70.671, 48.353), (-70.501, 48.354), (-70.145, 48.244), (-69.971, 48.206), (-69.866, 48.172), (-69.775, 48.098), (-69.84, 47.953), (-69.906, 47.832), (-69.994, 47.74), (-70.3, 47.503), (-70.448, 47.423), (-70.706, 47.14), (-70.973, 47.007), (-71.116, 46.925), (-71.268, 46.796), (-71.625, 46.698), (-71.757, 46.674), (-71.88, 46.687), (-72.028, 46.607), (-72.205, 46.559), (-72.257, 46.485), (-72.68, 46.287), (-72.843, 46.262), (-72.981, 46.21), (-73.022, 46.12), (-73.145, 46.066), (-73.284, 45.9), (-73.477, 45.738), (-73.712, 45.711), (-73.798, 45.655), (-73.897, 45.564), (-74.038, 45.502), (-74.315, 45.531), (-74.248, 45.493), (-74.0, 45.433), (-73.974, 45.345), (-74.098, 45.324), (-74.358, 45.206), (-74.709, 45.004), (-74.762, 44.999), (-74.857, 45.004), (-74.996, 44.97), (-75.179, 44.899), (-75.401, 44.772), (-75.792, 44.497), (-75.798, 44.491), (-75.805, 44.495), (-75.831, 44.49), (-75.942, 44.411), (-76.057, 44.367), (-76.341, 44.295), (-76.408, 44.262), (-76.49, 44.244), (-76.589, 44.238), (-76.688, 44.218), (-76.787, 44.182), (-76.863, 44.1), (-76.87, 43.965), (-76.879, 43.943), (-76.934, 43.93), (-77.054, 43.883), (-77.151, 43.866), (-77.208, 43.876), (-77.421, 43.954), (-77.503, 43.963), (-77.554, 43.99), (-77.605, 44.039), (-78.451, 43.903), (-79.156, 43.757), (-79.461, 43.639), (-79.76, 43.297), (-79.362, 43.202), (-79.061, 43.283), (-79.059, 43.278), (-79.066, 43.106), (-79.073, 43.093), (-79.043, 43.064), (-79.035, 43.044), (-79.04, 43.021), (-79.011, 42.991), (-78.947, 42.952), (-78.922, 42.924), (-78.936, 42.907), (-79.057, 42.862), (-79.122, 42.858), (-79.176, 42.873), (-79.386, 42.881), (-79.661, 42.851), (-79.699, 42.862), (-79.923, 42.822), (-80.22, 42.774), (-80.365, 42.683), (-80.446, 42.604), (-80.062, 42.554), (-80.473, 42.574), (-81.039, 42.662), (-81.404, 42.63), (-81.809, 42.368), (-81.841, 42.295), (-81.867, 42.258), (-81.887, 42.257), (-81.938, 42.269), (-82.044, 42.257), (-82.16, 42.223), (-82.311, 42.158), (-82.412, 42.103), (-82.462, 42.058), (-82.49, 42.005), (-82.496, 41.944), (-82.512, 41.932), (-82.567, 42.0), (-82.604, 42.025), (-82.645, 42.037), (-82.69, 42.036), (-82.834, 41.997), (-82.937, 42.006), (-83.108, 42.071), (-83.117, 42.12), (-83.105, 42.215), (-83.076, 42.275), (-83.047, 42.297), (-82.971, 42.327), (-82.867, 42.335), (-82.59, 42.315), (-82.516, 42.322), (-82.462, 42.339), (-82.428, 42.367), (-82.414, 42.411), (-82.418, 42.472), (-82.432, 42.498), (-82.453, 42.495), (-82.613, 42.525), (-82.634, 42.542), (-82.645, 42.558), (-82.545, 42.625), (-82.488, 42.74), (-82.417, 43.017), (-81.783, 43.311), (-81.7, 43.59), (-81.753, 44.065), (-81.276, 44.62), (-81.697, 45.251), (-81.296, 45.249), (-81.282, 45.124), (-80.898, 44.632), (-80.65, 44.721), (-80.085, 44.494), (-79.763, 44.825), (-80.411, 45.59), (-80.737, 45.904), (-81.631, 46.098), (-82.442, 46.2), (-83.203, 46.21), (-83.738, 46.289), (-83.93, 46.092), (-84.097, 46.288), (-84.092, 46.361), (-84.087, 46.507), (-84.165, 46.563), (-84.236, 46.557), (-84.344, 46.531), (-84.501, 46.483), (-84.569, 46.577), (-84.438, 46.723), (-84.54, 46.697), (-84.561, 46.73), (-84.553, 46.806), (-84.528, 46.834), (-84.382, 46.853), (-84.385, 46.906), (-84.488, 46.944), (-84.6, 46.918), (-84.775, 47.004), (-84.594, 47.32), (-84.998, 47.595), (-84.855, 47.95), (-85.615, 47.941), (-86.022, 48.119), (-86.321, 48.577), (-86.56, 48.711), (-87.249, 48.735), (-88.138, 48.683), (-88.233, 48.597), (-88.539, 48.443), (-88.933, 48.335), (-88.775, 48.583), (-89.201, 48.451), (-89.221, 48.311), (-89.345, 48.121), (-89.578, 48.002), (-89.775, 48.015), (-89.901, 47.995), (-89.994, 48.015), (-90.04, 48.078), (-90.092, 48.118), (-90.32, 48.099), (-90.607, 48.113), (-90.744, 48.105), (-90.797, 48.131), (-90.84, 48.201), (-90.916, 48.209), (-91.043, 48.194), (-91.221, 48.105), (-91.387, 48.059), (-91.518, 48.058), (-91.647, 48.105), (-91.858, 48.198), (-92.005, 48.302), (-92.172, 48.338), (-92.299, 48.329), (-92.348, 48.277), (-92.415, 48.277), (-92.501, 48.435), (-92.733, 48.532), (-92.996, 48.612), (-93.258, 48.629), (-93.378, 48.617), (-93.464, 48.561), (-93.564, 48.537), (-93.708, 48.525), (-93.804, 48.549), (-93.852, 48.607), (-94.055, 48.659), (-94.414, 48.704), (-94.621, 48.743), (-94.675, 48.774), (-94.705, 48.809), (-94.713, 48.863), (-94.803, 49.003), (-94.843, 49.119), (-94.86, 49.259), (-94.854, 49.305), (-94.875, 49.319), (-94.939, 49.349), (-95.155, 49.37), (-95.162, 48.992), (-97.226, 48.993), (-104.034, 48.993), (-116.048, 48.993), (-117.039, 48.993), (-122.789, 48.993), (-122.974, 49.003), (-124.91, 49.985), (-125.625, 50.417), (-127.436, 50.831), (-127.993, 51.716), (-127.85, 52.33), (-129.13, 52.755), (-129.305, 53.562), (-130.515, 54.288), (-130.536, 54.803), (-130.536, 54.803), (-129.98, 55.285), (-130.008, 55.916), (-131.708, 56.552), (-132.73, 57.693), (-133.356, 58.41), (-134.271, 58.861), (-134.945, 59.271), (-135.476, 59.788), (-136.48, 59.464), (-137.452, 58.905), (-138.341, 59.562), (-139.039, 60.0), (-140.013, 60.277), (-140.998, 60.306), (-140.993, 66.0), (-140.986, 69.712), (-140.986, 69.712), (-139.121, 69.471), (-137.546, 68.99), (-136.504, 68.898), (-135.626, 69.315), (-134.415, 69.627), (-132.929, 69.505), (-131.431, 69.945), (-129.795, 70.194), (-129.108, 69.779), (-128.362, 70.013), (-128.138, 70.484), (-127.447, 70.377), (-125.756, 69.481), (-124.425, 70.158), (-124.29, 69.4), (-123.061, 69.564), (-122.683, 69.856), (-121.472, 69.798), (-119.943, 69.378), (-117.603, 69.011), (-116.226, 68.842), (-115.247, 68.906), (-113.898, 68.399), (-115.305, 67.903), (-113.497, 67.688), (-110.798, 67.806), (-109.946, 67.981), (-108.88, 67.381), (-107.792, 67.887), (-108.813, 68.312), (-108.167, 68.654), (-106.95, 68.7), (-106.15, 68.8), (-105.343, 68.561), (-104.338, 68.018), (-103.221, 68.098), (-101.454, 67.647), (-99.902, 67.806), (-98.443, 67.782), (-98.559, 68.404), (-97.669, 68.579), (-96.12, 68.239), (-96.126, 67.293), (-95.489, 68.091), (-94.685, 68.064), (-94.233, 69.069), (-95.304, 69.686), (-96.471, 70.09), (-96.391, 71.195), (-95.209, 71.921), (-93.89, 71.76), (-92.878, 71.319), (-91.52, 70.191), (-92.407, 69.7), (-90.547, 69.498), (-90.552, 68.475), (-89.215, 69.259), (-88.02, 68.615), (-88.317, 67.873), (-87.35, 67.199), (-86.306, 67.921), (-85.577, 68.785), (-85.522, 69.882), (-84.101, 69.805), (-82.623, 69.658), (-81.28, 69.162), (-81.22, 68.666), (-81.964, 68.133), (-81.259, 67.597), (-81.387, 67.111), (-83.345, 66.412), (-84.735, 66.257), (-85.769, 66.558), (-86.068, 66.056), (-87.031, 65.213), (-87.323, 64.776), (-88.483, 64.099), (-89.914, 64.033), (-90.704, 63.61), (-90.77, 62.96), (-91.933, 62.835), (-93.157, 62.025), (-94.242, 60.899), (-94.629, 60.11), (-94.685, 58.949), (-93.215, 58.782), (-92.765, 57.846), (-92.297, 57.087), (-90.898, 57.285), (-89.04, 56.852), (-88.04, 56.472), (-87.324, 55.999), (-86.071, 55.724), (-85.012, 55.303), (-83.361, 55.245), (-82.273, 55.148), (-82.436, 54.282), (-82.125, 53.277), (-81.401, 52.158), (-79.913, 51.208), (-79.143, 51.534), (-78.602, 52.562), (-79.124, 54.141), (-79.83, 54.668), (-78.229, 55.136), (-77.096, 55.837), (-76.541, 56.534), (-76.623, 57.203), (-77.302, 58.052), (-78.517, 58.805), (-77.337, 59.853), (-77.773, 60.758), (-78.107, 62.32), (-77.411, 62.551), (-75.696, 62.278), (-74.668, 62.181), (-73.84, 62.444), (-72.909, 62.105), (-71.677, 61.525), (-71.374, 61.137), (-69.59, 61.061), (-69.62, 60.221), (-69.288, 58.957), (-68.375, 58.801), (-67.65, 58.212), (-66.202, 58.767), (-65.245, 59.871), (-64.784, 60.195), (-64.789, 60.196), (-64.847, 60.238), (-64.847, 60.251), (-64.816, 60.267), (-64.614, 60.306), (-64.499, 60.268), (-64.436, 60.228), (-64.42, 60.171), (-64.528, 60.095), (-64.713, 60.037), (-64.768, 60.012)], [(-81.877, 62.905), (-81.898, 62.711), (-83.069, 62.159), (-83.775, 62.182), (-83.994, 62.453), (-83.25, 62.914)], [(-80.834, 73.693), (-80.353, 73.76), (-78.064, 73.652), (-76.34, 73.103), (-76.251, 72.826), (-77.314, 72.856), (-78.392, 72.877), (-79.486, 72.742), (-79.776, 72.803), (-80.876, 73.333)], [(-79.52, 62.364), (-79.266, 62.159), (-79.658, 61.633), (-80.1, 61.718), (-80.362, 62.016), (-80.315, 62.086), (-79.929, 62.386)], [(-95.609, 74.667), (-96.821, 74.928), (-96.289, 75.378), (-94.851, 75.647), (-93.978, 75.296), (-93.613, 74.98), (-94.157, 74.592)], [(-96.17, 77.555), (-96.436, 77.835), (-94.423, 77.82), (-93.721, 77.634), (-93.84, 77.52), (-94.296, 77.491)], [(-95.83, 78.057), (-97.31, 77.851), (-98.124, 78.083), (-98.553, 78.458), (-98.632, 78.872), (-97.337, 78.832), (-96.754, 78.766), (-95.559, 78.418)], [(-92.422, 74.838), (-92.768, 75.387), (-92.89, 75.883), (-93.894, 76.319), (-95.962, 76.441), (-97.121, 76.751), (-96.745, 77.161), (-94.684, 77.098), (-93.574, 76.776), (-91.605, 76.779), (-90.742, 76.45), (-90.97, 76.074), (-89.822, 75.848), (-89.187, 75.61), (-87.838, 75.566), (-86.379, 75.482), (-84.79, 75.699), (-82.753, 75.784), (-81.129, 75.714), (-80.058, 75.337), (-79.834, 74.923), (-80.458, 74.657), (-81.949, 74.442), (-83.229, 74.564), (-86.097, 74.41), (-88.15, 74.392), (-89.765, 74.516)], [(-110.187, 77.697), (-112.051, 77.409), (-113.534, 77.732), (-112.725, 78.051), (-111.264, 78.153), (-109.854, 77.996)], [(-110.881, 78.407), (-112.542, 78.408), (-112.526, 78.551), (-111.5, 78.85), (-110.964, 78.804), (-109.663, 78.602)], [(-81.642, 64.455), (-81.553, 63.98), (-80.817, 64.057), (-80.103, 63.726), (-80.991, 63.411), (-82.547, 63.652), (-83.109, 64.102), (-84.1, 63.57), (-85.523, 63.052), (-85.867, 63.637), (-87.222, 63.541), (-86.353, 64.036), (-86.225, 64.823), (-85.884, 65.739), (-85.161, 65.657), (-84.976, 65.218), (-84.464, 65.372), (-83.883, 65.11), (-82.788, 64.767)], [(-75.606, 72.244), (-74.229, 71.767), (-74.099, 71.331), (-72.242, 71.557), (-71.2, 70.92), (-68.786, 70.525), (-67.915, 70.122), (-66.969, 69.186), (-68.805, 68.72), (-66.45, 68.067), (-64.862, 67.848), (-63.425, 66.928), (-61.852, 66.862), (-62.163, 66.16), (-63.918, 64.999), (-65.149, 65.426), (-66.721, 66.388), (-68.015, 66.263), (-68.141, 65.69), (-67.09, 65.108), (-65.732, 64.648), (-65.32, 64.383), (-64.669, 63.393), (-65.014, 62.674), (-66.275, 62.945), (-68.783, 63.746), (-67.37, 62.884), (-66.328, 62.28), (-66.166, 61.931), (-68.877, 62.33), (-71.023, 62.911), (-72.235, 63.398), (-71.886, 63.68), (-73.378, 64.194), (-74.834, 64.679), (-74.819, 64.389), (-77.71, 64.23), (-78.556, 64.573), (-77.897, 65.309), (-76.018, 65.327), (-73.96, 65.455), (-74.294, 65.812), (-73.945, 66.311), (-72.651, 67.285), (-72.926, 67.727), (-73.312, 68.069), (-74.843, 68.555), (-76.869, 68.895), (-76.229, 69.148), (-77.287, 69.77), (-78.169, 69.826), (-78.957, 70.167), (-79.492, 69.872), (-81.305, 69.743), (-84.945, 69.967), (-87.06, 70.26), (-88.682, 70.411), (-89.513, 70.762), (-88.468, 71.218), (-89.888, 71.223), (-90.205, 72.235), (-89.437, 73.129), (-88.408, 73.538), (-85.826, 73.804), (-86.562, 73.157), (-85.774, 72.534), (-84.85, 73.34), (-82.316, 73.751), (-80.6, 72.717), (-80.749, 72.062), (-78.771, 72.352), (-77.825, 72.75)], [(-90.51, 73.857), (-92.004, 72.966), (-93.196, 72.772), (-94.269, 72.025), (-95.41, 72.062), (-96.034, 72.94), (-96.018, 73.437), (-95.496, 73.862), (-94.504, 74.135), (-92.42, 74.1)], [(-121.158, 76.865), (-119.104, 77.512), (-117.57, 77.498), (-116.199, 77.645), (-116.336, 76.877), (-117.106, 76.53), (-118.04, 76.481), (-119.899, 76.053), (-121.5, 75.9), (-122.855, 76.117), (-122.855, 76.117)], [(-132.049, 52.985), (-131.179, 52.18), (-131.578, 52.182), (-132.18, 52.64), (-132.55, 53.1), (-133.055, 53.411), (-133.24, 53.851), (-133.18, 54.17), (-132.71, 54.04), (-131.75, 54.12)], [(-100.825, 78.8), (-100.06, 78.325), (-99.671, 77.908), (-101.304, 78.019), (-102.95, 78.343), (-105.176, 78.38), (-104.21, 78.677), (-105.42, 78.918), (-105.492, 79.302), (-103.529, 79.165)], [(-125.655, 48.825), (-125.955, 49.18), (-126.85, 49.53), (-127.03, 49.815), (-128.059, 49.995), (-128.445, 50.539), (-128.358, 50.771), (-127.309, 50.553), (-126.695, 50.401), (-125.755, 50.295), (-125.415, 49.95), (-124.921, 49.475), (-123.923, 49.062), (-123.51, 48.51), (-124.013, 48.371)], [(-117.556, 74.186), (-116.584, 73.896), (-115.511, 73.475), (-116.768, 73.223), (-119.22, 72.52), (-120.46, 71.82), (-120.46, 71.384), (-123.092, 70.902), (-123.62, 71.34), (-125.929, 71.869), (-125.5, 72.292), (-124.807, 73.023), (-123.94, 73.68), (-124.918, 74.293), (-121.538, 74.449), (-120.11, 74.241)], [(-105.881, 75.969), (-105.705, 75.48), (-106.313, 75.005), (-109.7, 74.85), (-112.223, 74.417), (-113.744, 74.394), (-113.871, 74.72), (-111.794, 75.162), (-116.312, 75.043), (-117.71, 75.222), (-116.346, 76.199), (-115.405, 76.479), (-112.591, 76.141), (-110.814, 75.549), (-109.067, 75.473), (-110.497, 76.43), (-109.581, 76.794), (-108.549, 76.678), (-108.211, 76.202), (-107.819, 75.846), (-106.929, 76.013)], [(-104.775, 71.698), (-104.465, 70.993), (-102.785, 70.498), (-100.981, 70.024), (-101.089, 69.584), (-102.731, 69.504), (-102.093, 69.12), (-102.43, 68.753), (-104.24, 68.91), (-105.96, 69.18), (-107.123, 69.119), (-109.0, 68.78), (-111.534, 68.63), (-113.313, 68.536), (-113.855, 69.007), (-115.22, 69.28), (-116.108, 69.168), (-117.34, 69.96), (-116.675, 70.067), (-115.131, 70.237), (-113.721, 70.192), (-112.416, 70.366), (-114.35, 70.6), (-116.487, 70.52), (-117.905, 70.541), (-118.432, 70.909), (-116.113, 71.309), (-117.656, 71.295), (-119.402, 71.559), (-118.563, 72.308), (-117.866, 72.706), (-115.189, 73.315), (-114.167, 73.121), (-114.666, 72.653), (-112.441, 72.955), (-111.05, 72.45), (-109.92, 72.961), (-109.007, 72.633), (-108.188, 71.651), (-107.686, 72.065), (-108.396, 73.09), (-107.516, 73.236), (-106.523, 73.076), (-105.402, 72.673)], [(-100.356, 73.844), (-99.164, 73.633), (-97.38, 73.76), (-97.12, 73.47), (-98.054, 72.991), (-96.54, 72.56), (-96.72, 71.66), (-98.36, 71.273), (-99.323, 71.356), (-100.015, 71.738), (-102.5, 72.51), (-102.48, 72.83), (-100.438, 72.706), (-101.54, 73.36)], [(-104.5, 73.42), (-105.38, 72.76), (-106.94, 73.46), (-106.6, 73.6), (-105.26, 73.64)], [(-97.704, 75.743), (-98.16, 75.0), (-99.809, 74.897), (-100.884, 75.057), (-100.863, 75.641), (-102.502, 75.564), (-102.566, 76.337), (-101.49, 76.305), (-99.983, 76.646), (-98.577, 76.589), (-98.5, 76.72), (-97.736, 76.257)], [(-94.298, 80.977), (-94.735, 81.206), (-92.41, 81.257), (-91.133, 80.723), (-89.45, 80.509), (-87.81, 80.32), (-87.02, 79.66), (-85.814, 79.337), (-87.188, 79.039), (-89.035, 78.287), (-90.804, 78.215), (-92.877, 78.343), (-93.951, 78.751), (-93.936, 79.114), (-93.145, 79.38), (-94.974, 79.372), (-96.076, 79.705), (-96.71, 80.158), (-96.016, 80.602), (-95.323, 80.907)], [(-88.932, 82.118), (-86.97, 82.28), (-85.5, 82.652), (-84.26, 82.6), (-83.18, 82.32), (-82.42, 82.86), (-81.1, 83.02), (-79.307, 83.131), (-76.25, 83.172), (-75.719, 83.064), (-72.832, 83.233), (-70.666, 83.17), (-68.5, 83.106), (-65.827, 83.028), (-63.68, 82.9), (-61.85, 82.629), (-61.894, 82.362), (-64.334, 81.928), (-66.753, 81.725), (-67.658, 81.501), (-65.48, 81.507), (-67.84, 80.9), (-69.47, 80.617), (-71.18, 79.8), (-73.243, 79.634), (-73.88, 79.43), (-76.908, 79.323), (-75.529, 79.198), (-76.22, 79.019), (-75.393, 78.526), (-76.344, 78.183), (-77.889, 77.9), (-78.363, 77.509), (-79.76, 77.21), (-79.62, 76.983), (-77.911, 77.022), (-77.889, 76.778), (-80.561, 76.178), (-83.174, 76.454), (-86.112, 76.299), (-87.6, 76.42), (-89.491, 76.472), (-89.616, 76.952), (-87.767, 77.178), (-88.26, 77.9), (-87.65, 77.97), (-84.976, 77.539), (-86.34, 78.18), (-87.962, 78.372), (-87.152, 78.759), (-85.379, 78.997), (-85.095, 79.345), (-86.507, 79.736), (-86.932, 80.251), (-84.198, 80.208), (-83.409, 80.1), (-81.848, 80.464), (-84.1, 80.58), (-87.599, 80.516), (-89.367, 80.856), (-90.2, 81.26), (-91.368, 81.553), (-91.587, 81.894), (-90.1, 82.085)], [(-76.987, 67.099), (-77.236, 67.588), (-76.812, 68.149), (-75.895, 68.287), (-75.115, 68.01), (-75.103, 67.582), (-75.216, 67.444), (-75.866, 67.149)], [(-96.27, 68.757), (-97.617, 69.06), (-98.432, 68.951), (-99.797, 69.4), (-98.917, 69.71), (-98.218, 70.144), (-97.157, 69.86), (-96.557, 69.68), (-96.257, 69.49), (-95.648, 69.108)]]], ['NS', [[(-59.922, 43.904), (-60.038, 43.907), (-60.114, 43.939), (-60.117, 43.953), (-59.936, 43.94), (-59.866, 43.947), (-59.727, 44.003), (-59.788, 43.94)], [(-66.324, 44.257), (-66.312, 44.292), (-66.25, 44.379), (-66.21, 44.392), (-66.274, 44.292)], [(-61.003, 45.482), (-61.013, 45.496), (-61.076, 45.537), (-61.082, 45.558), (-61.026, 45.577), (-60.912, 45.567), (-60.953, 45.516), (-60.962, 45.49)], [(-63.703, 45.858), (-63.568, 45.878), (-63.509, 45.875), (-63.358, 45.811), (-63.316, 45.78), (-63.293, 45.752), (-63.217, 45.758), (-63.108, 45.782), (-62.911, 45.776), (-62.701, 45.741), (-62.718, 45.686), (-62.75, 45.648), (-62.586, 45.661), (-62.483, 45.622), (-62.447, 45.641), (-62.422, 45.665), (-62.218, 45.731), (-61.956, 45.868), (-61.924, 45.851), (-61.912, 45.799), (-61.877, 45.714), (-61.777, 45.656), (-61.657, 45.642), (-61.492, 45.687), (-61.428, 45.648), (-61.351, 45.574), (-61.277, 45.476), (-61.282, 45.441), (-61.376, 45.411), (-61.461, 45.367), (-61.107, 45.349), (-61.071, 45.33), (-61.032, 45.292), (-61.068, 45.253), (-61.101, 45.233), (-61.165, 45.256), (-61.284, 45.235), (-61.387, 45.185), (-61.498, 45.157), (-61.569, 45.154), (-61.647, 45.131), (-61.719, 45.094), (-61.794, 45.084), (-62.027, 44.994), (-62.265, 44.936), (-62.514, 44.844), (-62.768, 44.785), (-63.032, 44.715), (-63.089, 44.709), (-63.156, 44.711), (-63.306, 44.643), (-63.381, 44.652), (-63.457, 44.64), (-63.544, 44.655), (-63.604, 44.683), (-63.558, 44.611), (-63.545, 44.544), (-63.568, 44.514), (-63.61, 44.48), (-63.761, 44.486), (-63.821, 44.511), (-63.891, 44.546), (-63.924, 44.604), (-64.0, 44.645), (-64.045, 44.588), (-64.045, 44.545), (-64.101, 44.487), (-64.167, 44.587), (-64.286, 44.55), (-64.339, 44.445), (-64.312, 44.415), (-64.276, 44.334), (-64.335, 44.292), (-64.378, 44.304), (-64.469, 44.185), (-64.578, 44.142), (-64.692, 44.021), (-64.826, 43.929), (-64.862, 43.868), (-65.087, 43.727), (-65.172, 43.731), (-65.235, 43.727), (-65.33, 43.668), (-65.344, 43.55), (-65.386, 43.565), (-65.429, 43.561), (-65.45, 43.524), (-65.482, 43.518), (-65.564, 43.553), (-65.662, 43.534), (-65.738, 43.561), (-65.835, 43.734), (-65.887, 43.795), (-65.978, 43.815), (-66.002, 43.778), (-66.038, 43.742), (-66.126, 43.814), (-66.193, 44.08), (-66.193, 44.144), (-66.1, 44.367), (-65.868, 44.569), (-65.942, 44.576), (-66.146, 44.436), (-66.125, 44.47), (-66.091, 44.505), (-66.022, 44.562), (-65.917, 44.615), (-65.778, 44.646), (-65.682, 44.651), (-65.616, 44.68), (-65.52, 44.733), (-65.502, 44.76), (-65.587, 44.729), (-65.728, 44.697), (-65.692, 44.738), (-65.657, 44.76), (-64.903, 45.121), (-64.751, 45.18), (-64.449, 45.256), (-64.407, 45.306), (-64.448, 45.337), (-64.331, 45.309), (-64.34, 45.268), (-64.359, 45.238), (-64.366, 45.187), (-64.354, 45.138), (-64.235, 45.114), (-64.136, 45.023), (-64.183, 45.147), (-64.093, 45.217), (-63.748, 45.311), (-63.46, 45.321), (-63.368, 45.365), (-63.614, 45.394), (-63.906, 45.378), (-64.087, 45.411), (-64.336, 45.39), (-64.6, 45.41), (-64.681, 45.383), (-64.747, 45.324), (-64.832, 45.35), (-64.873, 45.355), (-64.913, 45.375), (-64.827, 45.476), (-64.56, 45.625), (-64.397, 45.756), (-64.351, 45.783), (-64.315, 45.836), (-64.404, 45.827), (-64.482, 45.806), (-64.536, 45.867), (-64.633, 45.947), (-64.642, 45.913), (-64.594, 45.814), (-64.779, 45.638), (-64.898, 45.626), (-65.057, 45.544), (-65.282, 45.473), (-65.545, 45.337), (-65.884, 45.223), (-65.956, 45.222), (-66.11, 45.317), (-66.067, 45.359), (-66.027, 45.418), (-66.065, 45.401), (-66.09, 45.376), (-66.183, 45.335), (-66.107, 45.257), (-66.144, 45.228), (-66.252, 45.189), (-66.352, 45.133), (-66.44, 45.096), (-66.511, 45.143), (-66.707, 45.083), (-66.872, 45.067), (-66.908, 45.098), (-66.919, 45.146), (-66.977, 45.157), (-67.084, 45.144), (-67.125, 45.169), (-67.171, 45.182), (-67.213, 45.193), (-67.25, 45.201), (-67.271, 45.187), (-67.291, 45.168), (-67.315, 45.154), (-67.367, 45.174), (-67.4, 45.21), (-67.453, 45.248), (-67.473, 45.276), (-67.462, 45.309), (-67.439, 45.34), (-67.428, 45.378), (-67.454, 45.421), (-67.477, 45.446), (-67.494, 45.474), (-67.488, 45.501), (-67.455, 45.514), (-67.424, 45.53), (-67.414, 45.566), (-67.433, 45.603), (-67.45, 45.608), (-67.461, 45.642), (-67.48, 45.683), (-67.533, 45.643), (-67.6, 45.637), (-67.708, 45.692), (-67.787, 45.759), (-67.801, 45.756), (-67.8, 45.77), (-67.792, 45.796), (-67.775, 45.818), (-67.774, 45.843), (-67.781, 45.86), (-67.782, 45.874), (-67.778, 45.892), (-67.767, 45.927), (-67.785, 45.953), (-67.807, 47.083), (-68.235, 47.346), (-68.311, 47.354), (-68.358, 47.345), (-68.377, 47.316), (-68.48, 47.286), (-68.669, 47.253), (-68.829, 47.203), (-68.887, 47.203), (-68.937, 47.211), (-69.003, 47.236), (-69.049, 47.274), (-69.054, 47.295), (-69.064, 47.338), (-69.05, 47.427), (-69.146, 47.445), (-69.243, 47.463), (-69.302, 47.402), (-69.359, 47.351), (-69.471, 47.239), (-70.008, 46.709), (-70.067, 46.441), (-70.18, 46.342), (-70.248, 46.251), (-70.279, 46.15), (-70.305, 46.057), (-70.306, 45.98), (-70.287, 45.939), (-70.296, 45.906), (-70.333, 45.868), (-70.408, 45.802), (-70.421, 45.738), (-70.467, 45.707), (-70.596, 45.644), (-70.702, 45.551), (-70.707, 45.499), (-70.692, 45.455), (-70.69, 45.428), (-70.711, 45.409), (-70.753, 45.411), (-70.799, 45.405), (-70.838, 45.366), (-70.837, 45.311), (-70.865, 45.271), (-70.898, 45.262), (-70.926, 45.291), (-70.96, 45.333), (-71.0, 45.337), (-71.06, 45.309), (-71.085, 45.294), (-71.135, 45.263), (-71.202, 45.26), (-71.327, 45.29), (-71.419, 45.2), (-71.518, 45.008), (-73.352, 45.005), (-74.663, 45.004), (-74.709, 45.004), (-74.566, 45.042), (-74.269, 45.188), (-74.05, 45.241), (-73.765, 45.395), (-73.558, 45.425), (-73.519, 45.459), (-73.484, 45.587), (-73.465, 45.632), (-73.369, 45.758), (-73.253, 45.864), (-73.16, 46.01), (-72.99, 46.104), (-72.733, 46.182), (-72.496, 46.353), (-72.366, 46.405), (-72.24, 46.442), (-72.187, 46.512), (-72.109, 46.551), (-71.901, 46.632), (-71.671, 46.654), (-71.439, 46.721), (-71.261, 46.756), (-71.152, 46.819), (-70.993, 46.852), (-70.519, 47.033), (-70.388, 47.117), (-70.218, 47.29), (-70.07, 47.378), (-70.017, 47.471), (-69.802, 47.623), (-69.581, 47.824), (-69.471, 47.967), (-69.306, 48.047), (-68.987, 48.275), (-68.816, 48.366), (-68.746, 48.376), (-68.552, 48.457), (-68.432, 48.542), (-68.238, 48.626), (-67.889, 48.731), (-67.561, 48.856), (-67.117, 48.964), (-66.598, 49.126), (-66.178, 49.213), (-65.883, 49.226), (-65.523, 49.266), (-65.396, 49.262), (-64.836, 49.192), (-64.568, 49.105), (-64.262, 48.922), (-64.216, 48.874), (-64.209, 48.806), (-64.371, 48.839), (-64.514, 48.841), (-64.415, 48.804), (-64.246, 48.691), (-64.254, 48.55), (-64.349, 48.423), (-64.633, 48.361), (-64.706, 48.311), (-64.764, 48.228), (-64.822, 48.196), (-64.96, 48.16), (-65.036, 48.106), (-65.259, 48.021), (-65.36, 48.011), (-65.476, 48.031), (-65.755, 48.112), (-65.927, 48.189), (-66.013, 48.147), (-66.083, 48.103), (-66.249, 48.117), (-66.324, 48.098), (-66.449, 48.12), (-66.704, 48.022), (-66.632, 48.011), (-66.429, 48.067), (-66.36, 48.061), (-66.21, 47.989), (-65.849, 47.911), (-65.756, 47.86), (-65.666, 47.696), (-65.607, 47.67), (-65.484, 47.687), (-65.344, 47.768), (-65.228, 47.811), (-65.002, 47.847), (-65.046, 47.793), (-64.874, 47.797), (-64.703, 47.725), (-64.766, 47.673), (-64.852, 47.57), (-64.912, 47.369), (-65.086, 47.234), (-65.319, 47.101), (-65.26, 47.069), (-65.192, 47.05), (-65.042, 47.089), (-64.942, 47.086), (-64.831, 47.061), (-64.866, 46.958), (-64.906, 46.888), (-64.883, 46.823), (-64.817, 46.699), (-64.726, 46.671), (-64.69, 46.512), (-64.641, 46.426), (-64.648, 46.356), (-64.557, 46.311), (-64.542, 46.24), (-64.212, 46.22), (-64.145, 46.193), (-63.916, 46.166), (-63.873, 46.146), (-63.832, 46.107), (-64.056, 46.021), (-64.031, 46.013), (-63.875, 45.959)], [(-61.071, 45.937), (-60.937, 45.986), (-60.865, 45.983), (-60.868, 45.949), (-60.984, 45.911), (-61.038, 45.882), (-60.971, 45.856), (-60.972, 45.838), (-61.052, 45.795), (-61.092, 45.748), (-61.059, 45.703), (-60.93, 45.748), (-60.878, 45.748), (-60.806, 45.738), (-60.738, 45.751), (-60.699, 45.773), (-60.472, 45.947), (-60.461, 45.969), (-60.705, 45.933), (-60.733, 45.957), (-60.573, 46.061), (-60.586, 46.117), (-60.505, 46.204), (-60.431, 46.256), (-60.377, 46.285), (-60.298, 46.311), (-60.244, 46.27), (-60.226, 46.196), (-60.092, 46.206), (-59.961, 46.191), (-59.865, 46.16), (-59.85, 46.141), (-59.849, 46.113), (-59.881, 46.062), (-59.934, 46.019), (-59.828, 45.965), (-59.842, 45.942), (-60.016, 45.88), (-60.114, 45.819), (-60.205, 45.743), (-60.386, 45.655), (-60.673, 45.591), (-60.764, 45.591), (-60.872, 45.611), (-60.979, 45.606), (-61.084, 45.582), (-61.186, 45.585), (-61.236, 45.572), (-61.284, 45.574), (-61.323, 45.599), (-61.408, 45.669), (-61.45, 45.716), (-61.495, 45.941), (-61.481, 46.06), (-61.409, 46.17), (-61.302, 46.244), (-61.241, 46.303), (-60.982, 46.65), (-60.932, 46.729), (-60.87, 46.797), (-60.76, 46.863), (-60.617, 46.976), (-60.571, 46.999), (-60.489, 47.01), (-60.408, 47.004), (-60.431, 46.963), (-60.425, 46.923), (-60.332, 46.768), (-60.333, 46.737), (-60.384, 46.613), (-60.482, 46.414), (-60.508, 46.303), (-60.495, 46.27), (-60.534, 46.215), (-60.577, 46.172), (-60.745, 46.093), (-60.831, 46.074), (-60.912, 46.045), (-61.105, 45.945)], [(-73.858, 45.574), (-73.725, 45.672), (-73.572, 45.694), (-73.695, 45.585), (-73.816, 45.565)], [(-73.775, 45.468), (-73.92, 45.442), (-73.961, 45.441), (-73.853, 45.516), (-73.687, 45.561), (-73.522, 45.701), (-73.476, 45.705), (-73.539, 45.546), (-73.552, 45.49), (-73.567, 45.469), (-73.644, 45.449)], [(-71.095, 46.9), (-70.971, 46.961), (-70.88, 46.996), (-70.826, 46.995), (-70.913, 46.92), (-71.026, 46.873), (-71.117, 46.865)], [(-61.815, 47.268), (-61.773, 47.26), (-61.834, 47.223), (-61.951, 47.219), (-62.008, 47.234), (-61.925, 47.425), (-61.827, 47.469), (-61.628, 47.594), (-61.548, 47.632), (-61.474, 47.647), (-61.396, 47.638), (-61.476, 47.564), (-61.582, 47.56), (-61.684, 47.499), (-61.751, 47.431), (-61.831, 47.392), (-61.887, 47.345), (-61.914, 47.285), (-61.879, 47.266)], [(-62.553, 49.141), (-62.8, 49.171), (-63.042, 49.225), (-63.566, 49.399), (-63.626, 49.46), (-63.676, 49.534), (-63.777, 49.602), (-63.885, 49.658), (-64.44, 49.828), (-64.485, 49.887), (-64.373, 49.926), (-64.244, 49.944), (-64.131, 49.942), (-63.76, 49.875), (-63.292, 49.817), (-63.089, 49.773), (-62.859, 49.705), (-62.633, 49.624), (-62.133, 49.407), (-62.043, 49.39), (-61.817, 49.284), (-61.736, 49.204), (-61.696, 49.139), (-61.746, 49.106), (-61.801, 49.094), (-62.22, 49.079)], [(-66.845, 44.764), (-66.802, 44.805), (-66.745, 44.791), (-66.753, 44.71), (-66.762, 44.682), (-66.897, 44.629)], [(-64.621, 47.752), (-64.665, 47.748), (-64.685, 47.754), (-64.66, 47.794), (-64.663, 47.863), (-64.591, 47.872), (-64.565, 47.866), (-64.509, 47.887), (-64.534, 47.814)], [(-64.541, 47.985), (-64.52, 48.005), (-64.5, 48.014), (-64.481, 48.007), (-64.476, 47.959), (-64.591, 47.907)]]], ['PM', [[(-56.151, 46.762), (-56.172, 46.753), (-56.243, 46.767), (-56.209, 46.798), (-56.185, 46.807), (-56.153, 46.811), (-56.137, 46.802), (-56.139, 46.779)], [(-56.267, 46.838), (-56.354, 46.795), (-56.385, 46.819), (-56.377, 46.848), (-56.333, 46.916), (-56.334, 46.936), (-56.387, 47.068), (-56.378, 47.09), (-56.365, 47.099), (-56.287, 47.071), (-56.278, 47.035), (-56.315, 46.954), (-56.29, 46.9), (-56.255, 46.861)]]]] +_lakes = [['Lake Okeechobee', [[(-80.629, 26.887), (-80.668, 26.826), (-80.711, 26.742), (-80.743, 26.697), (-80.784, 26.691), (-80.827, 26.707), (-80.858, 26.723), (-80.896, 26.752), (-80.932, 26.81), (-80.979, 26.856), (-81.027, 26.876), (-81.071, 26.917), (-81.081, 26.956), (-81.055, 26.991), (-80.997, 27.033), (-80.942, 27.077), (-80.87, 27.147), (-80.803, 27.182), (-80.759, 27.182), (-80.711, 27.133), (-80.69, 27.11), (-80.671, 27.087), (-80.654, 27.054), (-80.639, 27.008), (-80.621, 26.949), (-80.629, 26.887), (-80.629, 26.887), (-80.629, 26.887)]]], ['Great Salt Lake', [[(-111.974, 41.002), (-111.974, 41.002), (-111.974, 41.002), (-111.951, 40.968), (-111.961, 40.942), (-112.053, 40.902), (-112.097, 40.881), (-112.19, 40.769), (-112.267, 40.74), (-112.332, 40.699), (-112.37, 40.701), (-112.394, 40.757), (-112.436, 40.816), (-112.446, 40.875), (-112.478, 40.943), (-112.493, 40.938), (-112.508, 40.919), (-112.522, 40.878), (-112.546, 40.839), (-112.58, 40.849), (-112.632, 40.927), (-112.69, 40.98), (-112.728, 41.019), (-112.751, 41.059), (-112.768, 41.114), (-112.788, 41.174), (-112.814, 41.224), (-112.846, 41.261), (-112.881, 41.289), (-112.918, 41.328), (-112.961, 41.377), (-112.985, 41.427), (-112.997, 41.489), (-112.998, 41.534), (-112.995, 41.56), (-112.997, 41.576), (-113.007, 41.582), (-113.014, 41.597), (-112.999, 41.612), (-112.966, 41.614), (-112.909, 41.637), (-112.844, 41.657), (-112.8, 41.667), (-112.77, 41.666), (-112.742, 41.659), (-112.719, 41.637), (-112.707, 41.603), (-112.734, 41.563), (-112.738, 41.537), (-112.708, 41.496), (-112.666, 41.466), (-112.604, 41.431), (-112.554, 41.43), (-112.527, 41.421), (-112.512, 41.381), (-112.489, 41.309), (-112.458, 41.247), (-112.437, 41.219), (-112.422, 41.217), (-112.406, 41.217), (-112.39, 41.223), (-112.377, 41.232), (-112.366, 41.248), (-112.381, 41.324), (-112.388, 41.385), (-112.402, 41.432), (-112.39, 41.447), (-112.374, 41.457), (-112.33, 41.443), (-112.29, 41.41), (-112.243, 41.393), (-112.171, 41.397), (-112.092, 41.408), (-112.064, 41.4), (-112.063, 41.388), (-112.076, 41.347), (-112.114, 41.336), (-112.179, 41.342), (-112.241, 41.345), (-112.27, 41.332), (-112.287, 41.317), (-112.304, 41.283), (-112.284, 41.268), (-112.243, 41.222), (-112.212, 41.192), (-112.181, 41.163), (-112.152, 41.134), (-112.083, 41.065)], [(-112.171, 40.875), (-112.171, 40.875), (-112.171, 40.875), (-112.156, 40.956), (-112.198, 41.056), (-112.236, 41.069), (-112.263, 41.058), (-112.252, 41.02), (-112.25, 40.964), (-112.216, 40.924)]]], [None, [[(-90.425, 30.274), (-90.467, 30.198), (-90.537, 30.179), (-90.574, 30.197), (-90.58, 30.235), (-90.557, 30.284), (-90.493, 30.348), (-90.433, 30.326), (-90.425, 30.274), (-90.425, 30.274)]]], ['Lake George', [[(-81.684, 29.368), (-81.684, 29.368), (-81.684, 29.368), (-81.684, 29.368), (-81.683, 29.505), (-81.64, 29.414), (-81.54, 29.287), (-81.529, 29.224), (-81.595, 29.198), (-81.64, 29.258), (-81.663, 29.314)]]]] \ No newline at end of file diff --git a/hurdat2parser/_reports.py b/hurdat2parser/_reports.py new file mode 100644 index 0000000..6169e0b --- /dev/null +++ b/hurdat2parser/_reports.py @@ -0,0 +1,1710 @@ +""" +hurdat2parser 2.3.0.1, Copyright (c) 2024, Kyle S. Gentry + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +import operator +import json +import statistics +import math +import os +import re +import csv +import itertools +import collections +import sys +import copy + +import shapefile + +import geojson + +from . import _calculations +from . import _gis +from . import _maps + +import matplotlib +import matplotlib.style as mplstyle +import matplotlib.pyplot as plt +import matplotlib.ticker as _ticker +import matplotlib.dates as _dates +import matplotlib.figure as _figure +import matplotlib.patches as _patches + +CSV_VARS = [ + ('TC Qty', 'tracks'), + # ('Trk Dist', 'track_distance'), + ('Landfalls (Acc.)', 'landfalls'), + ('TC Trk Dist', 'track_distance_TC'), + ('TC Landfall', 'landfall_TC'), + ('TS', 'TSreach'), + ('TS Landfall', 'landfall_TS'), + ('ACE', 'ACE'), + ('TS Trk Dist', 'track_distance_TS'), + ('TS-Excl', 'TSonly'), + ('HU', 'HUreach'), + ('HU Landfall', 'landfall_HU'), + ('HDP', 'HDP'), + ('HU Trk Dist', 'track_distance_HU'), + ('HU-1and2', 'HUonly'), + ('MHU', 'MHUreach'), + ('MHU Landfall', 'landfall_MHU'), + ('MHDP', 'MHDP'), + ('MHU Trk Dist', 'track_distance_MHU'), + ('Cat 4 and 5 Qty', 'cat45reach'), + ('Cat 5 Qty', 'cat5reach'), +] + +CSV_CLIMO_VARS = [('Climatology', "era")] + CSV_VARS + +CSV_SEASON_VARS = [ + ('Year', 'year'), + ('Duration (days)', 'duration'), + ('Start Ordinal', 'start_ordinal'), + ('End Ordinal', 'end_ordinal'), +] + CSV_VARS + +CSV_TC_VARS = [ + ('Year', 'year'), + ('ATCF Num', 'atcf_num'), + ('ATCF Id', 'atcfid'), + ('Name', 'name'), + ('Duration (days) as TC', 'duration_TC'), + ('Start Ordinal', 'start_ordinal'), + ('End Ordinal', 'end_ordinal'), + ('Min MSLP', 'minmslp'), + ('Max Wind', 'maxwind'), + ('Highest Status Reached', 'status_highest'), +] + [ + VAR for VAR in CSV_VARS[1:] + if "only" not in VAR[-1] + and "reach" not in VAR[-1] +] + +Era = collections.namedtuple( + "Era", + [attr for desc, attr in CSV_CLIMO_VARS] +) + +class ClimateEra(object): + """Used to house information from the .multi_season_info method.""" + def __init__(self, **kw): + self.__dict__.update(**kw) + +# class Ellipsoid: # Uncomment for lambda release +class Ellipsoid(_patches.Ellipse): + """ + An extended matplotlib.patches.Ellipse class. + + This is used to form wind-extent ellipses in the .track_map + method. + """ + @property + def slice_ne(self): + return list(self.get_verts()[ + len(self.get_verts()) // 4: (len(self.get_verts()) // 4) * 2 + 1 + ]) + [list(self.get_center())] + # return list(self.get_verts()[6:13]) + [list(self.get_center())] + @property + def slice_se(self): + return list(self.get_verts()[ + 0 : len(self.get_verts()) // 4 + 1 + ]) + [list(self.get_center())] + # return list(self.get_verts()[:7]) + [list(self.get_center())] + @property + def slice_sw(self): + return list(self.get_verts()[ + len(self.get_verts()) // 4 * 3 : + ]) + [list(self.get_center())] + # return list(self.get_verts()[-7:]) + [list(self.get_center())] + @property + def slice_nw(self): + return list(self.get_verts()[ + len(self.get_verts()) // 4 * 2: (len(self.get_verts()) // 4) * 3 + 1 + ]) + [list(self.get_center())] + # return list(self.get_verts()[12:19]) + [list(self.get_center())] + +class Hurdat2Reports: + + def from_map(self, landfall_assist=True, digits=3, **kw): + """ + Returns a list of clicked-coordinates from a mpl-interactive map where + the coordinates are tuples in (longitude, latitude) format. Initialized + map extents are relative to the atlantic or east/central pacific basins. + + This method is designed to be a companion to the + .crosses method. If the list is passed to the + aforementioned method, it will be tested against a cyclone's track. + This can be useful to narrow down crossings over certain bearings and + landfalls across a coordinate polyline of interest. + + Controls (also displayed on the interactive map): + ------------------------------------------------- + Alt + LeftClick -> Add a point to the path + Alt + RightClick -> Remove previous point from the path + Alt + C -> Erase/Clear Path (start over) + Q (mpl-defined shortcut) -> close the screen but return the coordinates + + N: toggle landfall_assist and any drawn arrows + + arrows: Zoom + + arrows: Pan + + Default Arguments: + ------------------ + landfall_assist (True): This is an aid to assist you in drawing a + path in the proper direction if testing for landfall or + direction-dependent barrier crossing using the + .crosses method. If True, semi-transparent + arrows will be placed on the map to show from what direction + intersection would be tested for. A convenience kb shortcut + (L) has been included to toggle the display of the arrows + digits (3): The number of decimal places (precision) that the + returned coordinates will have. + + Keyword Arguments + ----------------- + backend (None): what mpl backend to request using + """ + if kw.get("backend"): + matplotlib.use(kw.get("backend")) + + plt.ion() + + def add_point(x,y): + nonlocal clicked_coords + nonlocal point + nonlocal _arrows + + try: + point.remove() + except Exception as e: + # print(e) + pass + + clicked_coords.append( + ( + float(x), + float(y) + ) + ) + point = plt.scatter( + x, y, + s = matplotlib.rcParams['lines.markersize'] ** 1.5, + facecolor = "black", + ) + # draw arrow dependent upon landfall_assist + try: + segment = _gis.BoundingBox( + _gis.Coordinate(*clicked_coords[-2]), + _gis.Coordinate(*clicked_coords[-1]), + ) + rotated = segment.rotate(-90) + + arrow_maxlen = 10 + _dx = rotated.delta_x + _dy = rotated.delta_y + # modify if arrow is not user friendly + if rotated.length > arrow_maxlen: + _dx = rotated.delta_hypot(arrow_maxlen).delta_x + _dy = rotated.delta_hypot(arrow_maxlen).delta_y + _width = min( + rotated.length * 0.2, + 1.5 + ) + _arrows.append( + ax.arrow( + rotated.p1.x, + rotated.p1.y, + _dx, + _dy, + width = _width, + head_width = _width * 2.5, + head_length = _width * 1.5, + length_includes_head = True, + # headwidth=segment.length * 0.9 * 19/8, + facecolor=(1,0,0,0.3), + edgecolor=(1,1,1,0), + visible = landfall_assist + ) + ) + except Exception as e: + pass + + def remove_point(): + nonlocal clicked_coords + nonlocal point + nonlocal _arrows + + try: + point.remove() + except Exception as e: + # print(e) + pass + + if len(clicked_coords) > 0: + del clicked_coords[-1] + try: + point = plt.scatter( + *clicked_coords[-1], + s = matplotlib.rcParams['lines.markersize'] ** 1.5, + facecolor = "black", + ) + _arrows.pop().remove() + except Exception as e: + pass + + def onclick(event): + nonlocal point + nonlocal line + nonlocal _arrows + nonlocal clicked_coords + + if str(event.key).lower() == "alt": + # Add a point/segment (alt + left click) + if event.button.value == 1: + add_point( + round(event.xdata, digits), + round(event.ydata, digits) + ) + # remove point/segment (alt + right click) + if event.button.value == 3: + remove_point() + + # combine all clicked coordinates into one + if len(clicked_coords) >= 1: + try: + line[-1].remove() + except: + pass + line = plt.plot( + [x for x,y in clicked_coords], + [y for x,y in clicked_coords], + color = "red", + ) + + def onpress(event): + nonlocal point + nonlocal line + nonlocal _arrows + nonlocal landfall_assist + nonlocal clicked_coords + # print(event.__dict__) + + try: + # add home view if not already appended + if len(fig.canvas.toolbar._nav_stack) == 0: + fig.canvas.toolbar.push_current() + except: + pass + + if str(event.key).lower() == "alt+c": + try: + line[-1].remove() + point.remove() + clicked_coords = [] + for arw in _arrows: + arw.remove() + _arrows = [] + except: + pass + + # ylim (south, north) + # xlim (west, east) + + # aspect ratio >= 1 -> x <= y + # aspect ratio < 1 -> x > y + ar = abs(operator.sub(*ax.get_ylim()) / operator.sub(*ax.get_xlim())) + + # toggle landfall assist + if event.key.lower() == "n": + landfall_assist = not landfall_assist + lfall_text.set_text( + "Landfall Assist (key: N): {}".format( + "ON" if landfall_assist else + "OFF" + ) + ) + # toggle visibility of the arrows + for arrow in _arrows: + arrow.set_visible(landfall_assist) + + # Zoom in (shift + up or right) + if event.key.lower() in [ + "shift+" + arrow for arrow in ("up","right") + ]: + min_span = 4 + # ensure valid zoom in to avoid folding + new_xlim = ( + ax.get_xlim()[0] + 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] - 3 * (ar if ar >= 1 else 1) + ) + new_ylim = ( + ax.get_ylim()[0] + 3 * (ar if ar < 1 else 1), + ax.get_ylim()[1] - 3 * (ar if ar < 1 else 1) + ) + # only zoom in if no folding will occur (west extent > east extent) + # and if the zoom-in won't be too much + if operator.le(*new_xlim) and operator.le(*new_ylim) \ + and abs(operator.sub(*new_xlim)) > min_span \ + and abs(operator.sub(*new_ylim)) > min_span: + ax.set_xlim( + ax.get_xlim()[0] + 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] - 3 * (ar if ar >= 1 else 1), + ) + ax.set_ylim( + ax.get_ylim()[0] + 3 * (ar if ar < 1 else 1), + ax.get_ylim()[1] - 3 * (ar if ar < 1 else 1), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + # if it would zoom in too much, but the extents wouldn't fold, + # zoom in, but do so at a minimum + elif operator.le(*new_xlim) and operator.le(*new_ylim): + ax.set_xlim( + statistics.mean(new_xlim) - 2, + statistics.mean(new_xlim) + 2, + ) + ax.set_ylim( + statistics.mean(new_ylim) - 2, + statistics.mean(new_ylim) + 2, + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + # Zoom out (shift + up or right) + if event.key.lower() in [ + "shift+" + arrow for arrow in ("down","left") + ]: + ax.set_xlim( + ax.get_xlim()[0] - 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] + 3 * (ar if ar >= 1 else 1), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + + # pan (ctrl+arrows) + if event.key.lower() in [ + "ctrl+" + arrow for arrow in ("up","down","left","right") + ]: + everybody_move = min( + abs(operator.sub(*ax.get_ylim())) / 5, + abs(operator.sub(*ax.get_xlim())) / 5, + ) + ax.set_xlim( + ax.get_xlim()[0] + ( + everybody_move if "right" in event.key else + everybody_move * -1 if "left" in event.key else + 0 + ), + ax.get_xlim()[1] + ( + everybody_move if "right" in event.key else + everybody_move * -1 if "left" in event.key else + 0 + ), + ) + ax.set_ylim( + ax.get_ylim()[0] + ( + everybody_move if "up" in event.key else + everybody_move * -1 if "down" in event.key else + 0 + ), + ax.get_ylim()[1] + ( + everybody_move if "up" in event.key else + everybody_move * -1 if "down" in event.key else + 0 + ), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except Exception as e: + pass + + point = None + line = None + _arrows = [] + clicked_coords = [] + # matplotlib.use("TkAgg") + matplotlib.rcParams['path.simplify_threshold'] = 1 + + fig = plt.figure( + num = "Path Selector", + figsize = ( + matplotlib.rcParams["figure.figsize"][0], + matplotlib.rcParams["figure.figsize"][0] + ), + layout = "constrained", + ) + cid = fig.canvas.mpl_connect("button_press_event", onclick) + fig.canvas.mpl_connect("key_press_event", onpress) + plt.ion() + figman = plt.get_current_fig_manager() + figman.set_window_title(fig._label) + + figtitle = fig.suptitle( + "\n".join([ + "Path Selector", + "Alt+: Add point to the path", + "Alt+: Remove previous point from the path", + "Alt+C: Erase/Clear Path", + "Q: Finish / Return path", + ]), + fontsize = "small", + linespacing = 0.8, + ) + + ax = plt.axes( + facecolor = "lightblue", + aspect="equal", + adjustable="datalim", # aspect: equal and adj: datalim allows 1:1 in data-coordinates! + ) + + # Set the axis labels + ax.set_ylabel("Latitude") + ax.set_xlabel("Longitude") + ax.yaxis.set_major_locator(_ticker.MultipleLocator(5)) + ax.yaxis.set_minor_locator(_ticker.MultipleLocator(1)) + ax.xaxis.set_major_locator(_ticker.MultipleLocator(5)) + ax.xaxis.set_minor_locator(_ticker.MultipleLocator(1)) + ax.grid(True, color=(0.3, 0.3, 0.3)) + ax.grid(True, which="minor", color=(0.6, 0.6, 0.6), linestyle=":") + + # Draw Map + + for postal, geo in _maps._polygons: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = "lightseagreen", + edgecolor = "black", + linewidth = 0.5, + ) + for lake, geo in _maps._lakes: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = "lightblue", + edgecolor = "black", + linewidth = 0.3, + ) + + # Equator + # ax.plot([-180,180], [0,0], color="red") + + # pacific basins + if "EP" in self.basin_abbr() or "CP" in self.basin_abbr(): + ax.set_xlim(-160, -80) + # atlantic + else: + ax.set_xlim(-100, -40) + ax.set_ylim(0, 60) + # ax.set_box_aspect(1) + # ax.set_ylim( + # 42.5 - 85 * 3/4 / 2, + # 42.5 + 85 * 3/4 / 2, + # ) + mplstyle.use("fast") + + # KB Shortcuts + plt.figtext( + 0.995, + 0.01, + "\n".join([ + " + arrows: Zoom-in", + " + arrows: Pan", + ]), + color = (0,0,0,0.6), + ha = "right", + fontsize = "x-small", + ) + + # landfall assist toggle + lfall_text = plt.figtext( + 0.005, + 0.01, + "Landfall Assist (N): {}".format( + "ON" if landfall_assist else + "OFF" + ), + color = (0,0,0,0.6), + fontsize = "small", + ) + + # Map credits + plt.text( + 0.995, + 0.01, + "Map Data: Made with Natural Earth", + ha = "right", + fontsize = "x-small", + bbox = dict( + boxstyle = "Square, pad=0.1", + # edgecolor = (1,1,1,0), + facecolor = (1,1,1,0.6), + linewidth = 0, + ), + transform = ax.transAxes, + ) + + plt.show(block=True) + + return clicked_coords + + def multi_season_info(self, year1=None, year2=None): + """Grab a chunk of multi-season data and report on that climate era. + This method can be viewed as a climatological era info method. + + Default Arguments: + year1 (None): The start year + year2 (None): The end year + """ + + year1 = self.record_range[0] if year1 is None \ + or year1 < self.record_range[0] else year1 + year2 = self.record_range[1] if year2 is None \ + or year2 > self.record_range[1] else year2 + # --------------------- + + yrrange = range(year1, year2+1) + clmt = ClimateEra( + era = (year1, year2), + tracks = sum(self.season[s].tracks for s in yrrange), + landfalls = sum(self.season[s].landfalls for s in yrrange), + landfall_TC = sum(self.season[s].landfall_TC for s in yrrange), + landfall_TD = sum(self.season[s].landfall_TD for s in yrrange), + landfall_TS = sum(self.season[s].landfall_TS for s in yrrange), + landfall_HU = sum(self.season[s].landfall_HU for s in yrrange), + landfall_MHU = sum(self.season[s].landfall_MHU for s in yrrange), + TSreach = sum(self.season[s].TSreach for s in yrrange), + TSonly = sum(self.season[s].TSonly for s in yrrange), + HUreach = sum(self.season[s].HUreach for s in yrrange), + HUonly = sum(self.season[s].HUonly for s in yrrange), + MHUreach = sum(self.season[s].MHUreach for s in yrrange), + cat45reach = sum(self.season[s].cat45reach for s in yrrange), + cat5reach = sum(self.season[s].cat5reach for s in yrrange), + track_distance = sum(self.season[s].track_distance for s in yrrange), + track_distance_TC = sum(self.season[s].track_distance_TC for s in yrrange), + track_distance_TS = sum(self.season[s].track_distance_TS for s in yrrange), + track_distance_HU = sum(self.season[s].track_distance_HU for s in yrrange), + track_distance_MHU = sum(self.season[s].track_distance_MHU for s in yrrange), + ACE = sum(self.season[s].ACE for s in yrrange), + HDP = sum(self.season[s].HDP for s in yrrange), + MHDP = sum(self.season[s].MHDP for s in yrrange) + ) + + # Print Report + totalyrs = year2 - year1 + 1 + print("") + print(" --------------------------------------------------------") + print(" Tropical Cyclone Season Stats, for {} to {}".format(year1, year2)) + print(" --------------------------------------------------------") + print(" {:^56}".format( + "* Distances in nmi; * Energy Indices in 10**(-4) kt^2" + )) + print(" --------------------------------------------------------") + print(" Avg Track Qty (Total): {}/yr ({})".format( + round(clmt.tracks / totalyrs,1), + clmt.tracks + )) + print(" Avg TC Track Distance (Total): {}/yr ({})".format( + round(clmt.track_distance_TC / totalyrs,1), + round(clmt.track_distance_TC,1) + )) + print(" Avg TS Qty (Total): {}/yr ({})".format( + round(clmt.TSreach / totalyrs,1), + clmt.TSreach + )) + print(" -- Avg TS Track Distance (Total): {}/yr ({})".format( + round(clmt.track_distance_TS / totalyrs,1), + round(clmt.track_distance_TS,1) + )) + print(" -- Avg ACE (Total): {}/yr ({})".format( + round(clmt.ACE * 10**(-4) / totalyrs,1), + round(clmt.ACE * 10**(-4),1) + )) + print(" Avg HU Qty (Total): {}/yr ({})".format( + round(clmt.HUreach / totalyrs,1), + clmt.HUreach + )) + print(" -- Avg HU Track Distance (Total): {}/yr ({})".format( + round(clmt.track_distance_HU / totalyrs,1), + round(clmt.track_distance_HU,1) + )) + print(" -- Avg HDP (Total): {}/yr ({})".format( + round(clmt.HDP * 10**(-4) / totalyrs,1), + round(clmt.HDP * 10**(-4),1) + )) + print(" Avg MHU Qty (Total): {}/yr ({})".format( + round(clmt.MHUreach / totalyrs,1), + clmt.MHUreach + )) + print(" Avg Cat-4 and Cat-5 Qty (Total): {}/yr ({})".format( + round(clmt.cat45reach / totalyrs,1), + clmt.cat45reach + )) + print(" Avg Cat-5 Qty (Total): {}/yr ({})".format( + round(clmt.cat5reach / totalyrs,1), + clmt.cat5reach + )) + print(" -- Avg MHU Track Distance (Total): {}/yr ({})".format( + round(clmt.track_distance_MHU / totalyrs,1), + round(clmt.track_distance_MHU,1) + )) + print(" -- Avg MHDP (Total): {}/yr ({})".format( + round(clmt.MHDP * 10**(-4) / totalyrs,1), + round(clmt.MHDP * 10**(-4),1) + )) + print(" Avg Landfalling System Qty (Total): {}/yr ({})".format( + round(clmt.landfall_TC / totalyrs,1), + clmt.landfall_TC + )) + print("") + + def output_climo(self, climo_len=30): + """Output a csv of stats from all climatological eras from the record + of specifiable era-spans. Temporal separations of 1-year increments + will be used. + + Default Arguments: + climo_len (30): The length of time in years each climate era will + be assessed. + """ + + ofn = "{}_HURDAT2_{}-yr_climatology.csv".format( + "".join(self.basin_abbr()), + climo_len + ) + + if os.path.exists(ofn): + choice = input( + "* A file named '{}' already exists.".format(ofn) \ + + "Continue? (y/n): " + ) + if choice.lower()[0] != "y": return None + print("** PLEASE WAIT; THIS MAY TAKE A MOMENT **") + + year1, year2 = self.record_range + climo = {} + for yr1, yr2 in [ + (y, y+climo_len-1) \ + for y in range(year1, year2+1) \ + if year1 <= y <= year2 \ + and year1 <= y+climo_len-1 <= year2 + ]: + climo[yr1, yr2] = Era( + *( + [(yr1, yr2)] + [ + sum(getattr(self.season[s], attr) + for s in range(yr1, yr2+1)) + for desc, attr in CSV_CLIMO_VARS[1:] + ] + ) + ) + + with open(ofn, "w", newline="") as w: + out = csv.writer(w) + out.writerow([desc for desc, attr in CSV_CLIMO_VARS]) + for clmt in climo.values(): + out.writerow( + ["{}-{}".format(*clmt.era)] \ + + [getattr(clmt, attr) for desc, attr in CSV_CLIMO_VARS[1:]] + ) + + def output_seasons_csv(self): + """Output a csv of season-based stats from the record. In general, this + method really only has need to be called once. The primary exception to + this suggestion would only occur upon official annual release of the + HURDAT2 record. + """ + ofn = "{}_HURDAT2_seasons_summary.csv".format( + "".join(self.basin_abbr()) + ) + with open(ofn, "w", newline="") as w: + out = csv.writer(w) + out.writerow([desc for desc, attr in CSV_SEASON_VARS]) + for y in self.season.values(): + out.writerow( + [getattr(y, attr) for desc, attr in CSV_SEASON_VARS] + ) + + def output_storms_csv(self): + """Output a csv of individual storm-based stats from the record. In + general, this method really only has need to be called once. The + primary exception to this suggestion would only occur upon official + annual release of the HURDAT2 record. + """ + ofn = "{}_HURDAT2_storms_summary.csv".format( + "".join(self.basin_abbr()) + ) + with open(ofn, "w", newline="") as w: + out = csv.writer(w) + out.writerow([desc for desc, attr in CSV_TC_VARS]) + for tc in self.tc.values(): + out.writerow( + [getattr(tc, attr) for desc, attr in CSV_TC_VARS] + ) + + def climograph(self, attr, climatology=30, increment=5, **kw): + """Returns a basic climatological graph. + + Args: + attr: the attribute wanted to graph + + Default Keyword Arguments: + climatology (30): the length in years that a climatology should be + assessed. + increment (5): The temporal frequency of assessment of a + climatology (in years). + + Keyword Arguments: + year1: the start year for assessment + year2: the end year for assessment + """ + _w, _h = _figure.figaspect(kw.get("aspect_ratio", 3/5)) + fig = plt.figure( + figsize = (_w, _h), + layout = "tight", + ) + plt.get_current_fig_manager().set_window_title( + "{} {} Climatological Tendency, {}".format( + attr, + "{}yr / {}yr incremented".format( + climatology, + increment + ), + self.basin() + ) + ) + fig.suptitle( + "{} {} Climatological Tendency\n{}".format( + attr, + "{}yr / {}yr Incremented".format( + climatology, + increment + ), + self.basin() + ) + ) + ax = plt.axes( + xlabel = "Climate Era", + ylabel = attr + ) + ax.plot( + [ + "{}-{}".format(y, y+climatology-1) \ + for y in range( + kw.get("year1", self.record_range[0]), + kw.get("year2", self.record_range[1]) + 1 - climatology, + ) if (y+climatology-1) % increment == 0 + ], + [ + sum( + getattr(self.season[s], attr) \ + for s in range( + y, + y+climatology + ) + ) for y in range( + kw.get("year1", self.record_range[0]), + kw.get("year2", self.record_range[1]) + 1 - climatology, + ) if (y+climatology-1) % increment == 0 + ] + ) + + ax.xaxis.set_tick_params( + rotation = 90 + ) + plt.grid(True) + plt.show(block=False) + +class SeasonReports: + + def output_shp(self): + """Uses the shapefile module to output a GIS-compatible shapefile of + the tracks of all storms documented during a particular season. It is + output to the current directory. + """ + ofn = "{}_{}_tracks".format( + self.year, + "".join(self._hd2.basin_abbr()) + ) + with shapefile.Writer(ofn,shapeType=3) as gis: + gis.field("ATCFID","C","8") + gis.field("NAME","C","10") + gis.field("START","C","16") + gis.field("END","C","16") + gis.field("MAXWIND","N","3") + gis.field("MINMSLP","N","4") + gis.field("ACE (x10^4)","N","12",3) + gis.field("HDP (x10^4)","N","12",3) + gis.field("MHDP (x10^4)","N","12",3) + gis.field("TRK_DIST_NMI","N","22",1) + gis.field("TRK_DIST_TC_NMI","N","22",1) + gis.field("TRK_DIST_TS_NMI","N","22",1) + gis.field("TRK_DIST_HU_NMI","N","22",1) + gis.field("TRK_DIST_MHU_NMI","N","22",1) + for trop in self.tc: + gis.record( + self.tc[trop].atcfid, + self.tc[trop].name, + self.tc[trop].entry[0].entrytime.isoformat(), + self.tc[trop].entry[-1].entrytime.isoformat(), + self.tc[trop].maxwind, + self.tc[trop].minmslp if self.tc[trop].minmslp != None else 9999, + self.tc[trop].ACE * math.pow(10,-4), + self.tc[trop].HDP * math.pow(10,-4), + self.tc[trop].MHDP * math.pow(10,-4), + self.tc[trop].track_distance, + self.tc[trop].track_distance_TC, + self.tc[trop].track_distance_TS, + self.tc[trop].track_distance_HU, + self.tc[trop].track_distance_MHU + ) + entiretrack = [self.tc[trop].entry[trk].location_reversed for trk in range(len(self.tc[trop].entry))] + gis.line([entiretrack]) + + def output_shp_segmented(self): + """Uses the shapefile module to output a GIS-compatible shapefile of + individual segments (as separate geometries) of each system from the + season. Use this if you'd like the idea of coloring the tracks by + saffir-simpson strength controlled by the segments. + """ + ofn = "{}_{}_tracks_segmented".format( + self.year, + "".join(self._hd2.basin_abbr()) + ) + c = itertools.count(0) + with shapefile.Writer(ofn,shapeType=3) as gis: + gis.field("ID","N","3") + gis.field("ATCFID","C","8") + gis.field("ENTRY_INDEX","N") + gis.field("NAME","C","10") + gis.field("ENTRY_TIME","C","16") + gis.field("NEXT_ENTRY_TIME","C","16") + gis.field("LAT","N",decimal=1) + gis.field("LON","N",decimal=1) + gis.field("NEXT_ENTRY_LAT","N",decimal=1) + gis.field("NEXT_ENTRY_LON","N",decimal=1) + gis.field("STATUS","C","3") + gis.field("PEAK_WIND","N","3") + gis.field("MIN_MSLP","N","4") + for TC in [t[1] for t in self.tc.items()]: + for track in range(len(TC.entry)): + gis.record( + next(c), + TC.atcfid, + track, + TC.name, + TC.entry[track].entrytime.isoformat(), + TC.entry[track+1].entrytime.isoformat() if track != len(TC.entry)-1 else None, + TC.entry[track].location[0], + TC.entry[track].location[1], + TC.entry[track+1].location[0] if track != len(TC.entry)-1 else None, + TC.entry[track+1].location[1] if track != len(TC.entry)-1 else None, + TC.entry[track].status, + TC.entry[track].wind if TC.entry[track].wind > 0 else "", + TC.entry[track].mslp if TC.entry[track].mslp != None else "" + ) + if track != len(TC.entry)-1: + gis.line([[TC.entry[track].location_reversed,TC.entry[track+1].location_reversed]]) + else: + gis.null() + + def output_geojson(self, INDENT=2): + """Uses the geojson module to output a GIS-compatible geojson of the + tracks of all storms documented during a particular season. It is + output to the current directory. + + Default Argument: + INDENT = 2; used to provide indention to the output. Though it + makes the output prettier and easier to read, it increases the + file size. + """ + ofn = "{}_{}_tracks.geojson".format( + self.year, + "".join(self._hd2.basin_abbr()) + ) + # Ensure indention is an int + INDENT = int(INDENT) + + feats = [] + stormnum = itertools.count(1) + for TC in [tc[1] for tc in self.tc.items()]: + ls = geojson.LineString([(trk.lon,trk.lat) for trk in TC.entry]) + prp = { + "ID": next(stormnum), + "ATCFID": TC.atcfid, + "NAME": TC.name, + "START": TC.entry[0].entrytime.isoformat(), + "END": TC.entry[-1].entrytime.isoformat(), + "MAXWIND": TC.maxwind, + "MINMSLP": TC.minmslp, + "ACE (x10^4)": round(TC.ACE * math.pow(10,-4), 3), + "HDP (x10^4)": round(TC.HDP * math.pow(10,-4), 3), + "MHDP (x10^4)": round(TC.MHDP * math.pow(10,-4), 3), + "TRK_DIST_NMI": round(TC.track_distance, 1), + "TRK_DIST_TC_NMI": round(TC.track_distance_TC, 1), + "TRK_DIST_TS_NMI": round(TC.track_distance_TS, 1), + "TRK_DIST_HU_NMI": round(TC.track_distance_HU, 1), + "TRK_DIST_MHU_NMI": round(TC.track_distance_MHU, 1) + } + feats.append(geojson.Feature(geometry=ls, properties=prp)) + gjs = geojson.FeatureCollection(feats) + with open(ofn,"w") as w: + w.write(geojson.dumps(gjs, indent=INDENT)) + + def output_geojson_segmented(self, INDENT=2): + """Uses the geojson module to output a GIS-compatible geojson of + individual segments (as separate geometries) of each system from the + season. Use this if you'd like the idea of coloring the tracks by + saffir-simpson strength controlled by the segments. + + Default Argument: + INDENT = 2; used to provide indention to the output. Though it + makes the output prettier and easier to read, it increases the + file size. + """ + ofn = "{}_{}_tracks_segmented.geojson".format( + self.year, + "".join(self._hd2.basin_abbr()) + ) + + # Ensure indention is an int + INDENT = int(INDENT) + + feats = [] + for TC in [tc[1] for tc in self.tc.items()]: + for trk in range(len(TC.entry)): + ls = geojson.LineString([ + (TC.entry[trk].lon,TC.entry[trk].lat), + (TC.entry[trk+1].lon,TC.entry[trk+1].lat), + ]) if trk != len(TC.entry)-1 else geojson.LineString([]) + prp = { + "ENTRY_ID": trk, + "ATCFID": TC.atcfid, + "NAME": TC.name, + "ENTRY_TIME": TC.entry[trk].entrytime.isoformat(), + "LAT": TC.entry[trk].lat, + "LON": TC.entry[trk].lon, + "STATUS": TC.entry[trk].status, + "PEAK_WIND": TC.entry[trk].wind if TC.entry[trk].wind > 0 else None, + "MSLP": TC.entry[trk].mslp + } + feats.append(geojson.Feature(geometry=ls, properties=prp)) + gjs = geojson.FeatureCollection(feats) + with open(ofn,"w") as w: + w.write(geojson.dumps(gjs, indent=INDENT)) + +class TropicalCycloneReports: + + def output_shp(self): + """Uses the shapefile module to output a shapefile of the Tropical + Cyclone/System. + """ + ofn = "{}_{}_tracks".format(self.atcfid,self.name) + with shapefile.Writer(ofn,shapeType=3) as gis: + gis.field("ENTRY_INDEX","N","3") + gis.field("ATCFID","C","8") + gis.field("NAME","C","10") + gis.field("ENTRY_TIME","C","16") + gis.field("LAT","N",decimal=1) + gis.field("LON","N",decimal=1) + gis.field("STATUS","C","3") + gis.field("PEAK_WIND","N","3") + gis.field("MIN_MSLP","N","4") + for track in range(len(self.entry)): + gis.record( + track, + self.atcfid, + self.name, + self.entry[track].entrytime.isoformat(), + self.entry[track].lat, + self.entry[track].lon, + self.entry[track].status, + self.entry[track].wind if self.entry[track].wind > 0 else None, + self.entry[track].mslp) + if track != len(self.entry)-1: + gis.line([[self.entry[track].location_reversed,self.entry[track+1].location_reversed]]) + else: gis.null() + + def output_geojson(self, INDENT=2, feature_type="line"): + """Uses the geojson module to output a geojson file of the tropical + cyclone. + + Default Arguments: + INDENT = 2; used to provide indention to the output. Though it + makes the output prettier and easier to read, it increases the + file size. + feature_type = "line"; determines the type of feature used in + compiling the geoJSON file. "line" (default) indicates a + geoJSON ``LineString`` while "point" indicates a geoJSON + ``Point``. + """ + if feature_type.lower() not in ["point", "line"]: + raise TypeError("param feature_type must be either 'point' or 'line'.") + + ofn = "{}_{}_tracks_{}.geojson".format(self.atcfid, self.name, feature_type) + + # Ensure indention is an int + INDENT = int(INDENT) + + feats = [] + for trk in range(len(self.entry)): + # Point feature + if feature_type.lower() == "point": + ls = geojson.Point( + (self.entry[trk].lon, self.entry[trk].lat) + ) + # Polyline Feature + elif feature_type.lower() == "line": + ls = geojson.LineString([ + (self.entry[trk].lon,self.entry[trk].lat), + (self.entry[trk+1].lon,self.entry[trk+1].lat), + ]) if trk != len(self.entry)-1 else geojson.LineString([]) + prp = { + "ENTRY_ID": trk, + "ATCFID": self.atcfid, + "NAME": self.name, + "ENTRY_TIME": self.entry[trk].entrytime.isoformat(), + "LAT": self.entry[trk].lat, + "LON": self.entry[trk].lon, + "STATUS": self.entry[trk].status, + "PEAK_WIND": self.entry[trk].wind if self.entry[trk].wind > 0 else None, + "MSLP": self.entry[trk].mslp + } + feats.append(geojson.Feature(geometry=ls, properties=prp)) + gjs = geojson.FeatureCollection(feats) + with open(ofn,"w") as w: + w.write(geojson.dumps(gjs, indent=INDENT)) + + def track_map(self, **kw): + """Return a map of the tropical-cyclone's track via matplotlib + (referred further as "mpl"). Each track will be color-coded based on + associated wind-speed and storm-status. Colors are controlled by + saffir-simpson scale equivalent winds. When a system is not a + designated tropical cyclone, its track will be represented as a dotted + (rather than solid) line. + + Keyboard Shortcuts + ------------------ + Zoom: + arrows + Pan: + arrows + Toggle Legend: N + + * Clicking on a track segment will reveal basic information about the + that sources the segment. Clicking on an empty part of + the map will remove the label + + * Map feature coordinate data from Natural Earth (naturalearthdata.com) + + Accepted Keyword Arguments: + ----------------------------------- + block (True): bool that applies to the "block" kw of the mpl pyplot + show method. The default value of True reflects the same of mpl. + A value of False allows one to display multiple track-map + instances at a time. + width (None): the desired figure width in inches (will be further + altered if using non-default dpi) + height (None): the desired figure height in inches (will be further + altered if using non-default dpi) + dpi (None): affects the dpi of the figure. Generally speaking, a + smaller dpi -> smaller figure. larger dpi -> larger figure If + , the matplotlib default (100) is used. + ocean (mpl-compatible color): the requested color for the + ocean (the background); defaults to 'lightblue'. + land (mpl-compatible color): the requested color for land- + masses; defaults to 'lightseagreen'. + padding (2): how much extra space (in degrees) to place on the + focused system track. The larger this value the more map + (zoomed out) the display will be. Negative values work too. + labels (bool): toggle for temporal labels for entries; defaults to + True. + linewidth (float): the line-width of the track; defaults to 1.5. + markersize (float): the entry-marker size; defaults to 3. + legend (bool): whether or not you want to display a legend (default + is True). + draggable (False): do you want the displayed legend to be + interactive? + extents (bool): if True, and the data is available for a cyclone, + tropical storm, 50kt, and hurricane-force wind-extents will be + plotted. This defaults to False. + saveonly (False): if True, the method will silently save an image + without generating a visible plot + backend (None): what mpl backend to request using + """ + + # matplotlib.rcParams['path.simplify_threshold'] = 1 + + if kw.get("backend"): + matplotlib.use(kw.get("backend")) + + fig = plt.figure( + num = "{} - {} Tracks".format( + self.atcfid, + self.name + ), + figsize = ( + matplotlib.rcParams["figure.figsize"][0] + if not kw.get("width") else kw.get("width"), + matplotlib.rcParams["figure.figsize"][1] + if not kw.get("height") else kw.get("height"), + ), + + layout = "constrained", + dpi = kw.get("dpi", matplotlib.rcParams["figure.dpi"]) + ) + plt.ion() + + # declared outside of the inner function on purpose; + # will represent mpl Artist text that gives info on TCRecordEntry + entryinfo = None + def canvas_click(event): + # The purpose of this is to capture and process pick events when + # in zoom or pan mode otherwise, I wouldn't need it. + nonlocal entryinfo + + if event.inaxes: + try: + entryinfo.remove() + except Exception as e: + pass + # left click + if event.button.value == 1: + ax.pick(event) + + def show_entry_info(event): + nonlocal entryinfo + if hasattr(event, "artist") and hasattr(event.artist, "tcentry"): + try: + entryinfo.remove() + except Exception as e: + pass + entryinfo = plt.figtext( + 0.005, + 0.01, + "{:%Y-%m-%d %H:%MZ} - {}; {}kts; {}".format( + event.artist.tcentry.entrytime, + event.artist.tcentry.status, + event.artist.tcentry.wind, + "{}mb".format(event.artist.tcentry.mslp) + if event.artist.tcentry.mslp is not None + else "N/A", + ), + fontsize = "small", + fontweight = "bold", + color = "blue", + ha="left", + ) + + def kb_zoom_pan(event): + # kb shortcuts for panning and zooming + + try: + # add home view if not already appended + if len(fig.canvas.toolbar._nav_stack) == 0: + fig.canvas.toolbar.push_current() + except: + pass + + ar = abs(operator.sub(*ax.get_ylim()) / operator.sub(*ax.get_xlim())) + + if event.key.lower() == "n": + legend.set_visible( + not legend.get_visible() + ) + + # Zoom in (shift + up or right) + if event.key in [ + "shift+" + arrow for arrow in ("up","right") + ]: + min_span = 4 + # ensure valid zoom in to avoid folding + new_xlim = ( + ax.get_xlim()[0] + 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] - 3 * (ar if ar >= 1 else 1) + ) + new_ylim = ( + ax.get_ylim()[0] + 3 * (ar if ar < 1 else 1), + ax.get_ylim()[1] - 3 * (ar if ar < 1 else 1) + ) + # only zoom in if no folding will occur (west extent > east extent) + # and if the zoom-in won't be too much + if operator.le(*new_xlim) and operator.le(*new_ylim) \ + and abs(operator.sub(*new_xlim)) > min_span \ + and abs(operator.sub(*new_ylim)) > min_span: + ax.set_xlim( + ax.get_xlim()[0] + 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] - 3 * (ar if ar >= 1 else 1), + ) + ax.set_ylim( + ax.get_ylim()[0] + 3 * (ar if ar < 1 else 1), + ax.get_ylim()[1] - 3 * (ar if ar < 1 else 1), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + # if it would zoom in too much, but the extents wouldn't fold, + # zoom in, but do so at a minimum + elif operator.le(*new_xlim) and operator.le(*new_ylim): + ax.set_xlim( + statistics.mean(new_xlim) - 2, + statistics.mean(new_xlim) + 2, + ) + ax.set_ylim( + statistics.mean(new_ylim) - 2, + statistics.mean(new_ylim) + 2, + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + # Zoom out (shift + up or right) + if event.key in [ + "shift+" + arrow for arrow in ("down","left") + ]: + ax.set_xlim( + ax.get_xlim()[0] - 3 * (ar if ar >= 1 else 1), + ax.get_xlim()[1] + 3 * (ar if ar >= 1 else 1), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except: + pass + + # pan (ctrl+arrows) + if event.key in [ + "ctrl+" + arrow for arrow in ("up","down","left","right") + ]: + everybody_move = min( + abs(operator.sub(*ax.get_ylim())) / 5, + abs(operator.sub(*ax.get_xlim())) / 5, + ) + ax.set_xlim( + ax.get_xlim()[0] + ( + everybody_move if "right" in event.key else + everybody_move * -1 if "left" in event.key else + 0 + ), + ax.get_xlim()[1] + ( + everybody_move if "right" in event.key else + everybody_move * -1 if "left" in event.key else + 0 + ), + ) + ax.set_ylim( + ax.get_ylim()[0] + ( + everybody_move if "up" in event.key else + everybody_move * -1 if "down" in event.key else + 0 + ), + ax.get_ylim()[1] + ( + everybody_move if "up" in event.key else + everybody_move * -1 if "down" in event.key else + 0 + ), + ) + # Record the new view in the navigation stack (so home/back/forward will work) + try: + fig.canvas.toolbar.push_current() + except Exception as e: + pass + # plt.ioff() + + fig.canvas.mpl_connect("button_release_event", canvas_click) + fig.canvas.mpl_connect("pick_event", show_entry_info) + fig.canvas.mpl_connect("key_release_event", kb_zoom_pan) + + figman = plt.get_current_fig_manager() + figman.set_window_title(fig._label) + + fig.suptitle("Tracks for {} - {}".format( + "{} {} ({})".format( + self.status_highest, + self.name.title(), + self.atcfid + ) if self.name != "UNNAMED" else \ + "{} - {}".format( + self.atcfid, + self.status_highest + ), + "{:%b %d}-{:{MD2}}, {}".format( + self.entry[0].time, + self.entry[-1].time, + self.entry[0].time.year, + MD2 = "%d" \ + if self.entry[0].time.month == self.entry[-1].time.month \ + else "%b %d" + ) if self.entry[0].time.year == self.entry[-1].time.year else \ + "{:%Y-%m-%d} - {:%Y-%m-%d}".format( + self.entry[0].time, + self.entry[-1].time + ) + )) + + + # this is used in code below + rc = matplotlib.rcParams + + ax = plt.axes( + facecolor = kw.get("ocean", "lightblue"), + aspect="equal", + adjustable="datalim", # aspect: equal and adj: datalim allows 1:1 in data-coordinates! + ) + # self._hd2.fig = fig + + # Set the axis labels + ax.set_ylabel("Latitude") + ax.set_xlabel("Longitude") + ax.yaxis.set_major_locator(_ticker.MultipleLocator(5)) + ax.yaxis.set_minor_locator(_ticker.MultipleLocator(1)) + ax.xaxis.set_major_locator(_ticker.MultipleLocator(5)) + ax.xaxis.set_minor_locator(_ticker.MultipleLocator(1)) + labelrot = 0 # initialization for label rotation + + #Legend Objects list + legend_objects = [] + + for indx, entry in enumerate(self.entry): + # for angle comparison and label angle determination + if entry.previous_entry is not None: + prev_entry_angle = math.degrees( + math.atan2( + entry.lat - entry.previous_entry.lat, + entry.lon - entry.previous_entry.lon + ) + ) + prev_entry_angle += 360 if prev_entry_angle < 0 else 0 + else: + prev_entry_angle = None + + # if entry != self.entry[-1]: + if entry.next_entry is not None: + # q1 0 th 90 + # q2 90 th 180 + # q3 -179.999 <= th <= -90 + # q4 -90 th 0 + entry_angle = math.degrees( + math.atan2( + entry.next_entry.lat - entry.lat, + entry.next_entry.lon - entry.lon + ) + ) + entry_angle += 360 if entry_angle < 0 else 0 + + if prev_entry_angle is not None: + avg_entry_angle = statistics.mean([entry_angle, prev_entry_angle]) + else: + avg_entry_angle = None + + # labelrot = 45 if 135 <= entry_angle <= 190 else \ + # -45 if 190 < entry_angle <= 270 else \ + # (entry_angle - 90 + (360 if entry_angle - 90 < 0 else 0)) + # labelrot = 45 if 90 <= entry_angle < 135 else \ + # entry_angle - 80 if 135 <= entry_angle <= 190 else \ + # -45 if 190 < entry_angle <= 270 else \ + # (entry_angle - 90 + (360 if entry_angle - 90 < 0 else 0)) + labelrot = avg_entry_angle - 90 + ( + 360 if avg_entry_angle -90 < 0 else 0 + ) if avg_entry_angle is not None else \ + 45 if 90 <= entry_angle < 135 else \ + entry_angle - 80 if 135 <= entry_angle <= 190 else \ + -45 if 190 < entry_angle <= 270 else \ + (entry_angle - 90 + (360 if entry_angle - 90 < 0 else 0)) + + halign = "left" if labelrot <= 270 else "right" + if halign == "left" and labelrot > 120: + labelrot -= 180 + # print( + # "{:%Y-%m-%d %Hz}".format(entry.time), + # round(prev_entry_angle,1) if prev_entry_angle is not None else None, + # round(entry_angle,1), + # round(avg_entry_angle,1) if avg_entry_angle is not None else None, + # round(labelrot,1), + # halign + # ) + # offset ? = - 180 + (360 if entry.lon - 180 < -180 else 0) + # offset ? = 360 if entry.lon < 0 else 0 + line2dobj_list = ax.plot( + [ + entry.lon, + entry.next_entry.lon + ], + [entry.lat, entry.next_entry.lat], + color = "#FF38A5" if entry.saffir_simpson == 5 else + "purple" if entry.saffir_simpson == 4 else + "red" if entry.saffir_simpson == 3 else + "orange" if entry.saffir_simpson == 2 else + "yellow" if entry.saffir_simpson == 1 else + "green" if entry.saffir_simpson == 0 else + "black", + marker = ".", + markersize = kw.get("markersize", 3), + markeredgecolor = "black", + markerfacecolor = "black", + linestyle = "-" if entry.status in ["HU", "TS", "TD"] + else (0, (3,1,1,1)) if entry.status in ["SS", "SD"] + else ":", + linewidth = kw.get("linewidth", rc["lines.linewidth"]) + if kw.get("extents", False) else + kw.get("linewidth", rc["lines.linewidth"]) + 1 + if entry.is_TC and entry.saffir_simpson >= 3 else + kw.get("linewidth", rc["lines.linewidth"]) + if entry.is_TC and entry.saffir_simpson >= 0 else + kw.get("linewidth", rc["lines.linewidth"]) - 0.25, + label = "Category {}".format(entry.saffir_simpson) + if entry.status == "HU" + else entry._status_desc if entry.is_TC + else "Post/Potential Tropical Cyclone" + ) + # 'mouseover' stuff + point = line2dobj_list[0] + point.tcentry = entry + point.set_picker(True) + point.set_pickradius(5) + # line2dobj_list[0].mouseover = True + # line2dobj_list[0].format_cursor_data("TESTING"); + # print(line2dobj_list[0].get_cursor_data(None)) + + # Add a label to the legend if one doesn't exist already + if point.get_label() not in [ + pt.get_label() for pt in legend_objects + ]: + point.order_value = entry.saffir_simpson \ + if point.tcentry.is_TC else -2 + + legend_objects.append(point) + + if kw.get("labels", True): + if entry.record_identifier == "L": + ax.annotate( + " L ", + (entry.lon, entry.lat), + fontsize = 10, + fontweight = "bold", + rotation = labelrot, + rotation_mode = "anchor", + horizontalalignment = halign, + verticalalignment = "center_baseline", + clip_on = True, + ) + # labels for each point will show if extents are not shown + # or if they are, 00Z entry-indication will be shown + # or if it is a landfall entry + if kw.get("extents", False) is False \ + or entry.hour == 0 \ + or entry.record_identifier == "L": + ax.annotate( + " {}{:{YMD}{HM}Z} ".format( + " " if entry.record_identifier == "L" else "", + entry.time, + YMD = "%m-%d " + if (entry.hour, entry.minute) == (0,0) + else "", + HM = "%H%M" if entry.minute != 0 else "%H" + ), + (entry.lon, entry.lat), + fontsize = 7 + if (entry.hour, entry.minute) == (0,0) + or entry.record_identifier == "L" + else 6, + color = "black" + if (entry.hour, entry.minute) == (0,0) + or entry.record_identifier == "L" + else (0.3,0.3,0.3), + rotation = labelrot, + rotation_mode = "anchor", + horizontalalignment = halign, + verticalalignment = "center_baseline", + clip_on = True, + ) + + # Reorder legend labels now as it currently is only categories + legend_objects = sorted( + legend_objects, + key=lambda l: l.order_value + ) + + ax.grid(True, color=(0.3, 0.3, 0.3)) + ax.grid(True, which="minor", color=(0.6, 0.6, 0.6), linestyle=":") + + # set focus to the TC entries + # This setting is persistent + ax.set_xlim([ + min(en.lon for en in self.tc_entries) - kw.get("padding", 2), + max(en.lon for en in self.tc_entries) + kw.get("padding", 2), + ]) + ax.set_ylim([ + min(en.lat for en in self.tc_entries) - kw.get("padding", 2), + max(en.lat for en in self.tc_entries) + kw.get("padding", 2), + ]) + + # Draw Map + for postal, geo in _maps._polygons: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = kw.get("land", "lightseagreen"), + # edgecolor = "black", + linewidth = 0.5, + zorder = 1, + ) + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = (0,0,0,0), + edgecolor = "black", + linewidth = 0.5, + zorder = 1.1, + ) + for lake, geo in _maps._lakes: + for polygon in geo: + ax.fill( + [lon for lon, lat in polygon], + [lat for lon, lat in polygon], + color = kw.get("ocean", "lightblue"), + edgecolor = "black", + linewidth = 0.3, + ) + + # TESTING + if kw.get("extents", False): + for extent, extcolor, extlabel in [ + ("ts", "green", "TS-Force"), + ("ts50", "limegreen", "50kt"), + ("hu", "gold", "Hurricane-Force") + ]: + # legend + if kw.get("legend", True): + legend_color_block = _patches.Rectangle( + (0,0), + 1, + 1, + facecolor = extcolor, + edgecolor = "black", + label = extlabel, + alpha = 0.8 if extent != "ts" else 0.6, + ) + legend_objects.append(legend_color_block) + + for en in self.entry: + for quad in ["NE", "SE", "SW", "NW"]: + if getattr(en, "{}{}".format(extent,quad)) not in [0, None]: + h = _calculations.distance_from_coordinates( + en.lat, + en.lon, + getattr(en, "{}{}".format(extent,quad)), + quad[-1] + ) + z = _calculations.distance_from_coordinates( + en.lat, + en.lon, + getattr(en, "{}{}".format(extent,quad)), + quad[0] + ) + + ell = Ellipsoid( + (en.lon, en.lat), + abs(h[1] - en.location[1]), + abs(z[0] - en.location[0]), + ) + + ax.fill( + [x for x,y in getattr(ell, "slice_{}".format(quad.lower()))], + [y for x,y in getattr(ell, "slice_{}".format(quad.lower()))], + color = extcolor, + linewidth = 0.5, + # edgecolor = "black" if extcolor != "green" else None, + edgecolor = None, + picker = False, + alpha = 0.8 if extent != "ts" else 0.6, + ) + + # Legend + legend = plt.legend( + legend_objects, + [line2dobj.get_label() for line2dobj in legend_objects], + loc = "upper right", + ) + legend.set_visible(kw.get("legend", True)) + legend.set_draggable( + bool(kw.get("draggable")) + ) + + # Map credits + plt.text( + 0.995, + 0.01, + "Map Data: Made with Natural Earth", + ha = "right", + fontsize = "x-small", + bbox = dict( + boxstyle = "Square, pad=0.1", + # edgecolor = (1,1,1,0), + facecolor = (1,1,1,0.6), + linewidth = 0, + ), + transform = ax.transAxes, + ) + + mplstyle.use("fast") + + # Save the figure only + if kw.get("saveonly", False): + # ax.set_adjustable("box") + plt.savefig( + "{}_{}_tracks".format( + self.atcfid, + self.name, + ), + dpi=kw.get("dpi", matplotlib.rcParams["figure.dpi"]) + ) + # This is necessary to "flush" to presence of figures as "savefig" does not + # Other wise, subsequent calls would bring up the figure that was saved (but + # not originally shown). + orig_backend = matplotlib.rcParams["backend"] + matplotlib.use("Agg") # so the plt.show() command won't show anything + plt.show() # this will flush the figure + matplotlib.use(orig_backend) # change back to original backend + # See the figure (the default) + else: + plt.show( + block = kw.get("block", True) + ) + # Turn back on xscale / yscale kb keys if not using jupyter notebook + # if kw.get("backend") != "nbAgg": + # matplotlib.rcParams['keymap.yscale'] = orig_keymap_yscale + # matplotlib.rcParams['keymap.xscale'] = orig_keymap_xscale