max_stars_repo_path
stringlengths 3
269
| max_stars_repo_name
stringlengths 4
119
| max_stars_count
int64 0
191k
| id
stringlengths 1
7
| content
stringlengths 6
1.05M
| score
float64 0.23
5.13
| int_score
int64 0
5
|
|---|---|---|---|---|---|---|
src/uwrov_cams/scripts/usb_cam.py
|
uwrov/nautilus_pi
| 0
|
12775051
|
#!/usr/bin/env python3
import rospy
import os
from sensor_msgs.msg import CompressedImage
import numpy as np
import cv2
def streaming(msg, rate, stream, image_pub):
while not rospy.is_shutdown():
_, frame = stream.read()
msg.header.stamp = rospy.Time.now()
msg.format = 'jpeg'
msg.data = np.array(cv2.imencode('.jpeg', frame)[1]).tostring()
image_pub.publish(msg)
rate.sleep()
if __name__ == '__main__':
src = 0 # 'http://[Pi IP]:8081/'
stream = cv2.VideoCapture(src)
hn = os.environ.get('HOSTNAME')
hn = 'pi' if hn is None else hn
image_pub = rospy.Publisher(f'/nautilus/{hn}/usbcam', CompressedImage, queue_size=1)
rospy.init_node('compress_stream')
rate = rospy.Rate(24)
msg = CompressedImage()
streaming(msg, rate, stream, image_pub)
| 2.828125
| 3
|
leetcode-63.py
|
comst007/myLeetCode
| 0
|
12775052
|
class Solution:
def dfs(self,row_cnt:int, col_cnt:int, i:int, j:int, obs_arr:list, solve_dict:dict):
if (i, j) in solve_dict:
return solve_dict[(i,j)]
right_cnt = 0
down_cnt = 0
#right
if i + 1 < row_cnt and not obs_arr[i + 1][j]:
if (i + 1, j) in solve_dict:
right_cnt = solve_dict[(i + 1, j)]
else:
right_cnt = self.dfs(row_cnt, col_cnt,i + 1, j,obs_arr,solve_dict)
#left
if j + 1 < col_cnt and not obs_arr[i][j + 1]:
if (i, j + 1) in solve_dict:
down_cnt = solve_dict[(i, j + 1)]
else:
down_cnt = self.dfs(row_cnt, col_cnt, i, j + 1,obs_arr, solve_dict)
res = right_cnt + down_cnt
solve_dict[(i, j)] = res
return res
def uniquePathsWithObstacles(self, obstacleGrid: list) -> int:
row = len(obstacleGrid)
if not row:
return 0
col = len(obstacleGrid[0])
if not col:
return 0
if obstacleGrid[row - 1][col - 1]:
return 0
if obstacleGrid[0][0]:
return 0
res = self.dfs(row,col,0,0,obstacleGrid, {(row-1, col - 1):1})
return res
t1 = [
[0,0,0],
[0,1,0],
[0,0,0]
]
sl = Solution()
res = sl.uniquePathsWithObstacles(t1)
print(res)
| 3.046875
| 3
|
mkdocs_typer/_exceptions.py
|
bruce-szalwinski/mkdocs-typer
| 10
|
12775053
|
class MkDocsTyperException(Exception):
"""
Generic exception class for mkdocs-typer errors.
"""
| 1.5625
| 2
|
AutomatedTesting/Gem/PythonTests/physics/C4044460_Material_StaticFriction.py
|
aaarsene/o3de
| 1
|
12775054
|
<gh_stars>1-10
"""
Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
SPDX-License-Identifier: Apache-2.0 OR MIT
"""
# Test case ID : C4044460
# Test Case Title : Verify the functionality of static friction
# fmt: off
class Tests():
enter_game_mode = ("Entered game mode", "Failed to enter game mode")
find_ramp = ("Ramp entity found", "Ramp entity not found")
find_box_zero = ("Box entity 'zero' found", "Box entity 'zero' not found")
find_box_low = ("Box entity 'low' found", "Box entity 'low' not found")
find_box_mid = ("Box entity 'mid' found", "Box entity 'mid' not found")
find_box_high = ("Box entity 'high' found", "Box entity 'high' not found")
box_at_rest_zero = ("Box 'zero' began test motionless", "Box 'zero' did not begin test motionless")
box_at_rest_low = ("Box 'low' began test motionless", "Box 'low' did not begin test motionless")
box_at_rest_mid = ("Box 'mid' began test motionless", "Box 'mid' did not begin test motionless")
box_at_rest_high = ("Box 'high' began test motionless", "Box 'high' did not begin test motionless")
box_was_pushed_zero = ("Box 'zero' moved", "Box 'zero' did not move before timeout")
box_was_pushed_low = ("Box 'low' moved", "Box 'low' did not move before timeout")
box_was_pushed_mid = ("Box 'mid' moved", "Box 'mid' did not move before timeout")
box_was_pushed_high = ("Box 'high' moved", "Box 'high' did not move before timeout")
force_impulse_ordered = ("Boxes with greater static friction required greater impulses", "Boxes with greater static friction did not require greater impulses")
exit_game_mode = ("Exited game mode", "Couldn't exit game mode")
# fmt: on
def C4044460_Material_StaticFriction():
"""
Summary:
Runs an automated test to ensure that greater static friction coefficient settings on a physX material results in
rigidbodys (with that material) requiring a greater force in order to be set into motion
Level Description:
Four boxes sit on a horizontal 'ramp'. The boxes are identical, save for their physX material.
A new material library was created with 4 materials and their static friction coefficient:
zero_static_friction: 0.00
low_static_friction: 0.50
mid_static_friction: 1.00
high_static_friction: 1.50
Each material is identical otherwise
Each box is assigned its corresponding friction material, the ramp is assigned low_static_friction
The COM of the boxes is placed on the plane (0, 0, -0.5), so as to remove any torque moments and resulting rotations
Expected Behavior:
For each box, this script will apply a force impulse in the world X direction (starting at magnitude 0.0).
Every frame, it checks if the box moved:
If it didn't, we increase the magnitude slightly and try again
If it did, the box retains the magnitude required to move it, and we move to the next box.
Boxes with greater static friction coefficients should require greater forces in order to set them in motion.
Test Steps:
1) Open level
2) Enter game mode
3) Find the ramp
For each box:
4) Find the box
5) Ensure the box is stationary
6) Push the box until it moves
7) Assert that greater coefficients result in greater required force impulses
8) Exit game mode
9) Close the editor
Note:
- This test file must be called from the Open 3D Engine Editor command terminal
- Any passed and failed tests are written to the Editor.log file.
Parsing the file or running a log_monitor are required to observe the test results.
:return: None
"""
import os
import sys
import ImportPathHelper as imports
imports.init()
from editor_python_test_tools.utils import Report
from editor_python_test_tools.utils import TestHelper as helper
import azlmbr
import azlmbr.legacy.general as general
import azlmbr.bus as bus
import azlmbr.math as lymath
FORCE_IMPULSE_INCREMENT = 0.005 # How much we increase the force every frame
MIN_MOVE_DISTANCE = 0.02 # Distance magnitude that a box must travel in order to be considered moved
STATIONARY_TOLERANCE = 0.0001 # Boxes must have velocities under this magnitude in order to be stationary
TIMEOUT = 10
class Box:
def __init__(self, name, valid_test, stationary_test, moved_test):
self.name = name
self.id = general.find_game_entity(name)
self.start_position = self.get_position()
self.force_impulse = 0.0
self.valid_test = valid_test
self.stationary_test = stationary_test
self.moved_test = moved_test
def is_stationary(self):
velocity = azlmbr.physics.RigidBodyRequestBus(bus.Event, "GetLinearVelocity", self.id)
return vector_close_to_zero(velocity, STATIONARY_TOLERANCE)
def get_position(self):
return azlmbr.components.TransformBus(bus.Event, "GetWorldTranslation", self.id)
def vector_close_to_zero(vector, tolerance):
return abs(vector.x) <= tolerance and abs(vector.y) <= tolerance and abs(vector.z) <= tolerance
def push(box):
delta = box.start_position.Subtract(box.get_position())
if vector_close_to_zero(delta, MIN_MOVE_DISTANCE):
box.force_impulse += FORCE_IMPULSE_INCREMENT
impulse_vector = lymath.Vector3(box.force_impulse, 0.0, 0.0)
azlmbr.physics.RigidBodyRequestBus(bus.Event, "ApplyLinearImpulse", box.id, impulse_vector)
return False
else:
Report.info("Box {} required force was {:.3f}".format(box.name, box.force_impulse))
return True
helper.init_idle()
# 1) Open level
helper.open_level("Physics", "C4044460_Material_StaticFriction")
# 2) Enter game mode
helper.enter_game_mode(Tests.enter_game_mode)
# fmt: off
# Set up our boxes
box_zero = Box(
name = "Zero",
valid_test = Tests.find_box_zero,
stationary_test = Tests.box_at_rest_zero,
moved_test = Tests.box_was_pushed_zero
)
box_low = Box(
name = "Low",
valid_test = Tests.find_box_low,
stationary_test = Tests.box_at_rest_low,
moved_test = Tests.box_was_pushed_low
)
box_mid = Box(
name = "Mid",
valid_test = Tests.find_box_mid,
stationary_test = Tests.box_at_rest_mid,
moved_test = Tests.box_was_pushed_mid
)
box_high = Box(
name = "High",
valid_test = Tests.find_box_high,
stationary_test = Tests.box_at_rest_high,
moved_test = Tests.box_was_pushed_high
)
all_boxes = (box_zero, box_low, box_mid, box_high)
# fmt: on
# 3) Find the ramp
ramp_id = general.find_game_entity("Ramp")
Report.critical_result(Tests.find_ramp, ramp_id.IsValid())
for box in all_boxes:
Report.info("********Pushing Box {}********".format(box.name))
# 4) Find the box
Report.critical_result(box.valid_test, box.id.IsValid())
# 5) Ensure the box is stationary
Report.result(box.stationary_test, box.is_stationary())
# 6) Push the box until it moves
Report.critical_result(box.moved_test, helper.wait_for_condition(lambda: push(box), TIMEOUT))
# 7) Assert that greater coefficients result in greater required force impulses
ordered_impulses = box_high.force_impulse > box_mid.force_impulse > box_low.force_impulse > box_zero.force_impulse
Report.result(Tests.force_impulse_ordered, ordered_impulses)
# 8) Exit game mode
helper.exit_game_mode(Tests.exit_game_mode)
if __name__ == "__main__":
import ImportPathHelper as imports
imports.init()
from editor_python_test_tools.utils import Report
Report.start_test(C4044460_Material_StaticFriction)
| 2.03125
| 2
|
login/apps/user/serializers.py
|
LHW6688/login
| 1
|
12775055
|
# -*- coding: utf-8 -*-
'''
PROJECT_NAME：login
FILE:serializers
USERNAME: 李宏伟
DATE:2020/1/15
TIME:上午10:13
PRODUCT_NAME:PyCharm
'''
import re
from rest_framework import serializers
from .models import User
class CreateUserSerializer(serializers.ModelSerializer):
"""
创建用户序列化器
"""
password2 = serializers.CharField(label="确认密码", write_only=True)
allow = serializers.CharField(label="同意协议", write_only=True)
class Meta:
model = User
fields = ('id', 'username', 'password', 'password2', 'mobile', 'allow',)
extra_kwargs = {
"username": {
"min_length": 5,
"max_length": 20,
"error_messages": {
"min_length": "仅允许5-20个字符的用户名",
"max_length": "仅允许5-20个字符的用户名",
}
},
"password": {
"write_only": True,
"min_length": 8,
"max_length": 20,
"error_messages": {
"min_length": "仅允许8-20个字符的密码",
"max_length": "仅允许8-20个字符的密码",
}
}
}
def validate_mobile(self, value):
"""验证手机号码"""
if not re.match(r"1[1-9]\d{9}", value):
raise serializers.ValidationError("手机号码格式错误")
return value
def validate_allow(self, value):
if value != 'true':
raise serializers.ValidationError('请同意用户协议')
return value
def validate(self, attrs):
# 判断两次密码
if attrs['password'] != attrs['password2']:
raise serializers.ValidationError('两次密码不一致')
return attrs
def create(self, validate_data):
"""创建用户"""
# 移除数据库模型中不存在的属性
del validate_data['password2']
del validate_data['allow']
user = super(CreateUserSerializer, self).create(validate_data)
# 调用Django的认证系统加密密码
user.set_password(validate_data["password"])
user.save()
# 生成token
from rest_framework_jwt.settings import api_settings
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
user.token = token
return user
| 2.609375
| 3
|
mmdetection2.11-ShipRSImageNet/configs/ShipRSImageNet/_base_/datasets/ShipRSImageNet_Level2_detection.py
|
zzndream/ShipRSImageNet
| 7
|
12775056
|
<reponame>zzndream/ShipRSImageNet
dataset_type = 'ShipRSImageNet_Level2'
# data_root = 'data/Ship_ImageNet/'
data_root = './data/ShipRSImageNet/'
CLASSES = ('Other Ship', 'Other Warship', 'Submarine', 'Aircraft Carrier', 'Cruiser', 'Destroyer',
'Frigate', 'Patrol', 'Landing', 'Commander', 'Auxiliary Ships', 'Other Merchant',
'Container Ship', 'RoRo', 'Cargo', 'Barge', 'Tugboat', 'Ferry', 'Yacht',
'Sailboat', 'Fishing Vessel', 'Oil Tanker', 'Hovercraft', 'Motorboat', 'Dock',)
img_norm_cfg = dict(
mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
train_pipeline = [
dict(type='LoadImageFromFile'),
dict(type='LoadAnnotations', with_bbox=True),
dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
dict(type='RandomFlip', flip_ratio=0.5),
dict(type='Normalize', **img_norm_cfg),
dict(type='Pad', size_divisor=32),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
test_pipeline = [
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(1333, 800),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(type='Normalize', **img_norm_cfg),
dict(type='Pad', size_divisor=32),
dict(type='ImageToTensor', keys=['img']),
dict(type='Collect', keys=['img']),
])
]
data = dict(
samples_per_gpu=8,
workers_per_gpu=2,
train=dict(
type=dataset_type,
classes=CLASSES,
ann_file=data_root + 'COCO_Format/ShipRSImageNet_bbox_train_level_2.json',
img_prefix=data_root + 'VOC_Format/JPEGImages/',
pipeline=train_pipeline),
val=dict(
type=dataset_type,
classes=CLASSES,
ann_file=data_root + 'COCO_Format/ShipRSImageNet_bbox_val_level_2.json',
img_prefix=data_root + 'VOC_Format/JPEGImages/',
pipeline=test_pipeline),
test=dict(
type=dataset_type,
classes=CLASSES,
ann_file=data_root + 'COCO_Format/ShipRSImageNet_bbox_val_level_2.json',
img_prefix=data_root + 'VOC_Format/JPEGImages/',
pipeline=test_pipeline))
evaluation = dict(interval=10, metric='bbox')
| 1.757813
| 2
|
pages/MainPage.py
|
yadavdeepa365/HUDL_PYTHON
| 0
|
12775057
|
<reponame>yadavdeepa365/HUDL_PYTHON
from selenium.webdriver.common.keys import Keys
from pages.BasePage import BasePage
from pages.LoginPage import LoginPage
#from pages.MainPage import MainPage
from utils.locators import *
# Page objects are written in this module.
# Depends on this Main page functionality we can have more functions for new classes, Currently I have only included below 2 functions for the test purpose
class MainPage(BasePage):
def __init__(self, driver):
self.locator = MainPageLocators
super().__init__(driver) # Python3 version
def check_page_loaded(self):
return True if self.find_element(*self.locator.MAINCONTENT) else False
def click_sign_in_button(self):
self.find_element(*self.locator.LOGIN_BUTTON).click()
return LoginPage(self.driver)
| 2.578125
| 3
|
models/imagenet/arch/tests/test_utils_fuse_utils.py
|
a1004123217/pytorch-mobile
| 0
|
12775058
|
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
import unittest
import numpy as np
import torch
import mobile_cv.arch.fbnet_v2.basic_blocks as bb
import mobile_cv.arch.fbnet_v2.fbnet_builder as fbnet_builder
import mobile_cv.arch.utils.fuse_utils as fuse_utils
def run_and_compare(model_before, model_after, input_size):
inputs = torch.zeros(input_size, requires_grad=False)
output_before = model_before(inputs)
output_after = model_after(inputs)
np.testing.assert_allclose(
output_before.detach(), output_after.detach(), rtol=0, atol=1e-4
)
def _build_model(arch_def, dim_in):
arch_def = fbnet_builder.unify_arch_def(arch_def, ["blocks"])
torch.manual_seed(0)
builder = fbnet_builder.FBNetBuilder(1.0)
model = builder.build_blocks(arch_def["blocks"], dim_in=dim_in)
model.eval()
return model
def _find_modules(model, module_to_check):
for x in model.modules():
if isinstance(x, module_to_check):
return True
return False
class TestUtilsFuseUtils(unittest.TestCase):
def test_fuse_convbnrelu(self):
cbr = bb.ConvBNRelu(
3, 6, kernel_size=3, padding=1, bn_args="bn", relu_args="relu"
).eval()
fused = fuse_utils.fuse_convbnrelu(cbr, inplace=False)
self.assertTrue(_find_modules(cbr, torch.nn.BatchNorm2d))
self.assertFalse(_find_modules(fused, torch.nn.BatchNorm2d))
input_size = [2, 3, 7, 7]
run_and_compare(cbr, fused, input_size)
def test_fuse_convbnrelu_inplace(self):
cbr = bb.ConvBNRelu(
3, 6, kernel_size=3, padding=1, bn_args="bn", relu_args="relu"
).eval()
fused = fuse_utils.fuse_convbnrelu(cbr, inplace=True)
self.assertFalse(_find_modules(cbr, torch.nn.BatchNorm2d))
self.assertFalse(_find_modules(fused, torch.nn.BatchNorm2d))
input_size = [2, 3, 7, 7]
run_and_compare(cbr, fused, input_size)
def test_fuse_model(self):
e6 = {"expansion": 6}
dw_skip_bnrelu = {"dw_skip_bnrelu": True}
bn_args = {"bn_args": {"name": "bn", "momentum": 0.003}}
arch_def = {
"blocks": [
# [c, s, n, ...]
# stage 0
[("conv_k3", 4, 2, 1, bn_args)],
# stage 1
[
("ir_k3", 8, 2, 2, e6, dw_skip_bnrelu, bn_args),
("ir_k5_sehsig", 8, 1, 1, e6, bn_args),
],
]
}
model = _build_model(arch_def, dim_in=3)
fused_model = fuse_utils.fuse_model(model, inplace=False)
print(model)
print(fused_model)
self.assertTrue(_find_modules(model, torch.nn.BatchNorm2d))
self.assertFalse(_find_modules(fused_model, torch.nn.BatchNorm2d))
input_size = [2, 3, 8, 8]
run_and_compare(model, fused_model, input_size)
def test_fuse_model_inplace(self):
e6 = {"expansion": 6}
dw_skip_bnrelu = {"dw_skip_bnrelu": True}
bn_args = {"bn_args": {"name": "bn", "momentum": 0.003}}
arch_def = {
"blocks": [
# [c, s, n, ...]
# stage 0
[("conv_k3", 4, 2, 1, bn_args)],
# stage 1
[
("ir_k3", 8, 2, 2, e6, dw_skip_bnrelu, bn_args),
("ir_k5_sehsig", 8, 1, 1, e6, bn_args),
],
]
}
model = _build_model(arch_def, dim_in=3)
fused_model = fuse_utils.fuse_model(model, inplace=True)
print(model)
print(fused_model)
self.assertFalse(_find_modules(model, torch.nn.BatchNorm2d))
self.assertFalse(_find_modules(fused_model, torch.nn.BatchNorm2d))
input_size = [2, 3, 8, 8]
run_and_compare(model, fused_model, input_size)
def test_fuse_model_swish(self):
e6 = {"expansion": 6}
dw_skip_bnrelu = {"dw_skip_bnrelu": True}
bn_args = {"bn_args": {"name": "bn", "momentum": 0.003}}
arch_def = {
"blocks": [
# [c, s, n, ...]
# stage 0
[("conv_k3", 4, 2, 1, bn_args, {"relu_args": "swish"})],
# stage 1
[
("ir_k3", 8, 2, 2, e6, dw_skip_bnrelu, bn_args),
("ir_k5_sehsig", 8, 1, 1, e6, bn_args),
],
]
}
model = _build_model(arch_def, dim_in=3)
fused_model = fuse_utils.fuse_model(model, inplace=False)
print(model)
print(fused_model)
self.assertTrue(_find_modules(model, torch.nn.BatchNorm2d))
self.assertFalse(_find_modules(fused_model, torch.nn.BatchNorm2d))
self.assertTrue(_find_modules(fused_model, bb.Swish))
input_size = [2, 3, 8, 8]
run_and_compare(model, fused_model, input_size)
| 2.21875
| 2
|
django/BankAccount/BankAccount/settings_prod.py
|
akrysmalski/BankAccount
| 0
|
12775059
|
<reponame>akrysmalski/BankAccount
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SECRET_KEY = os.environ['DJANGO_SECRET']
DEBUG = False
ALLOWED_HOSTS = ['localhost', '127.0.0.1']
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
X_FRAME_OPTIONS = 'DENY'
CSRF_COOKIE_SECURE = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SECURE_BROWSER_XSS_FILTER = True
SESSION_COOKIE_SECURE = True
SECURE_SSL_REDIRECT = True
SECURE_HSTS_SECONDS = 60
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'file': {
'level': 'INFO',
'class': 'logging.FileHandler',
'filename': '/var/log/django/django.log'
}
},
'loggers': {
'django': {
'handlers': ['file'],
'level': 'INFO',
'propagate': True
}
}
}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'bank_account',
'USER': 'bank_account',
'PASSWORD': os.environ['DB_PASSWORD'],
'HOST': 'postgresql',
'PORT': '5432'
}
}
STATIC_ROOT = '/var/lib/django/static'
MEDIA_ROOT = '/var/lib/django/media'
| 1.929688
| 2
|
saved_models/Nb3d/nb_oxide_analysis.py
|
cassberk/xps_peakfit
| 1
|
12775060
|
<filename>saved_models/Nb3d/nb_oxide_analysis.py
import numpy as np
import matplotlib.pyplot as plt
from copy import deepcopy as dc
import lmfit as lm
import XPyS
import XPyS.config as cfg
"""
Series of funcitons for analyzing thicknesses of the different oxides for NbOxides
"""
def transfer_func(depth,depth_bins,EAL,angle):
trans = np.ones([4,depth_bins])
# trans = np.ones(depth_bins)
# iter = 0
# for angle in np.arange(0,70,10):
for thick in range(depth_bins):
trans[:,thick] = np.exp( -(depth/depth_bins) /(EAL*np.cos(angle*(np.pi/180))))**thick
# iter+=1
return trans
# def oxide_concentration(x,Nb2O5_T,NbO_T,NbO2_T):
def oxide_concentration(x,pars):
parsval = pars.valuesdict()
NbO_T = parsval['NbO_T']
NbO2_T = parsval['NbO2_T']
Nb2O5_T = parsval['Nb2O5_T']
ox_c = np.ones([4,len(x)])
"""Nb2O5"""
ox_c[0,:] = 0.46*(np.ones(len(x))- np.heaviside(x - Nb2O5_T,1 ))
"""NbO2"""
ox_c[1,:] = 0.51*(np.heaviside(x - Nb2O5_T,1) - np.heaviside(x-(Nb2O5_T + NbO2_T),1))
"""NbO"""
# ox_c[2,:] = np.heaviside(x-(thickness - NbO_T),1)
ox_c[2,:] = 0.73*(np.heaviside(x - (Nb2O5_T + NbO2_T),1) - np.heaviside(x-(Nb2O5_T + NbO2_T + NbO_T),1) )
"""Nb"""
ox_c[3,:] = np.heaviside(x-(Nb2O5_T + NbO2_T + NbO_T),1)
return ox_c
def thickness_residual(pars,x,data,error,transfer,EAL,obj_fun = 'Chi', split=False):
# parsval = pars.valuesdict()
# NbO_T = parsval['NbO_T']
# NbO2_T = parsval['NbO2_T']
# Nb2O5_T = parsval['Nb2O5_T']
# calc_c = np.sum(transfer_func(thickness,len(x),EAL,0) * oxide_concentration(x,thickness,NbO_T,NbO2_T),axis = 1)/\
# np.sum(transfer_func(thickness,len(x),EAL,0)*oxide_concentration(x,thickness,NbO_T,NbO2_T) )
# calc_c = np.sum(transfer_func(np.max(x),len(x),EAL,0) * oxide_concentration(x,pars),axis = 1)/\
# np.sum(transfer_func(np.max(x),len(x),EAL,0)*oxide_concentration(x,pars ))
calc_c = np.sum(transfer * oxide_concentration(x,pars),axis = 1)/\
np.sum(transfer*oxide_concentration(x,pars ))
err_adj = np.empty(len(error.keys()))
err_adj[0] = error['Nb2O5_52_']
err_adj[1] = error['NbO2_52_']
err_adj[2] = error['NbO_52_']
err_adj[3] = error['Nb_52_']
err_adj = np.where(np.isnan(err_adj), 1, err_adj)
if split==True:
return calc_c
if obj_fun == 'Chi' :
return (calc_c - data)/err_adj
if obj_fun =='S':
return calc_c - data
# return calc_c - data
def calc_oxide_thickness(sample,oxides=None,substrate=None,S_oxide=None,S_substrate=None,\
EAL=None,pars=None, fitting_alg = 'powell',obj_fun = 'S',specific_points = None,colors = None,fit_flag = True,\
plotflag = True):
if pars is None:
pars = lm.Parameters()
pars.add('NbO_T',value = 1,min = 0,vary = 1)
pars.add('NbO2_T',value = 1,min = 0, vary = 1)
pars.add('Nb2O5_T',value = 4,min = 0, vary = 1)
if oxides is None:
oxides = ['NbO_52_','NbO2_52_','Nb2O5_52_']
if substrate is None:
substrate = 'Nb_52_'
if S_oxide is None:
S_oxide = 10583
if S_substrate is None:
S_substrate = 22917
if EAL is None:
EAL = 1.7
if specific_points == None:
# if hasattr(sample,'fit_results_idx'):
pts = [j for j,x in enumerate(sample.fit_results) if x]
# else:
# pts = [j for j,x in enumerate(sample.params_full) if x]
else:
pts = dc(specific_points)
print(pts)
"""Fit the thicknesses of NbOxides"""
if fit_flag ==True:
# areas = np.empty([len(sample.pairlist),len(pts)])
sample.fit_component = {key: np.empty(len(pts)) for key in [sample.pairlist[i][0] for i in range(len(sample.pairlist))]}
sample.oxide_thickness = {key: np.empty(len(pts)) for key in oxides}
sample.oxide_thickness_err = {key: np.empty(len(pts)) for key in oxides}
sample.thickness =np.empty(len(pts))
oxide_thick_fit_result = [[] for i in range(len(pts))]
iter=0
for k in enumerate(pts):
for pairs in sample.pairlist:
# if hasattr(sample,'fit_results_idx'):
sample.fit_component[pairs[0]][k[0]] = sum( [sample.fit_results[k[1]].params[pairs[i] + 'amplitude'].value for i in range(len(pairs))] )
# else:
# sample.fit_component[pairs[0]][k[0]] = sum( [sample.params_full[k[1]][pairs[i] + 'amplitude'].value for i in range(len(pairs))] )
sample.thickness[k[0]] = np.mean( EAL*np.log( 1 + S_substrate*sum([sample.fit_component[ox][k[0]] for ox in oxides])/(S_oxide*sample.fit_component[substrate][k[0]]) ) )
ex_c = np.empty(4)
ex_c[0] = sample.fit_component['Nb2O5_52_'][k[0]]
ex_c[1] = sample.fit_component['NbO2_52_'][k[0]]
ex_c[2] = sample.fit_component['NbO_52_'][k[0]]
ex_c[3] = sample.fit_component['Nb_52_'][k[0]]
ex_c = ex_c/np.sum(ex_c)
x = np.linspace(0,10,10001)
# if hasattr(sample,'fit_results_idx'):
err = {key[0]: sample.fit_results[k[0]].params[key[0] + 'amplitude'].stderr for key in sample.pairlist}
# else:
# err = {key[0]: sample.params_full[k[0]][key[0] + 'amplitude'].stderr for key in sample.pairlist}
tran = transfer_func(np.max(x),len(x),EAL,0)
fitter = lm.Minimizer(thickness_residual, pars,fcn_args=(x,),fcn_kws={'data': ex_c,'error':err,\
'transfer': tran, 'EAL':EAL,'obj_fun':obj_fun})
result = fitter.minimize(method = fitting_alg)
# sample.oxide_thick_fit_result[k[0]] = dc(result)
sample.oxide_thickness['Nb2O5_52_'][k[0]] = result.params['Nb2O5_T'].value
sample.oxide_thickness['NbO2_52_'][k[0]] = result.params['NbO2_T'].value
sample.oxide_thickness['NbO_52_'][k[0]] = result.params['NbO_T'].value
sample.oxide_thickness_err['Nb2O5_52_'][k[0]] = result.params['Nb2O5_T'].stderr
sample.oxide_thickness_err['NbO2_52_'][k[0]] = result.params['NbO2_T'].stderr
sample.oxide_thickness_err['NbO_52_'][k[0]] = result.params['NbO_T'].stderr
# print(result.params['Nb2O5_T'].value)
# print(result.params['Nb2O5_T'].stderr)
"""Plot the calculated thicknesses"""
if plotflag:
if colors is None:
hue = cfg.element_color
else:
hue = colors
width = 0.8
fig, ax = plt.subplots(figsize=(15,10))
p = [[] for i in range(len(oxides))]
fit_legend = [cfg.element_text[element] for element in oxides]
comps_so_far = []
for ox in enumerate(oxides):
bottom_iter = sum([sample.oxide_thickness[i] for i in comps_so_far])
p[ox[0]] = ax.bar(np.arange(0,len(pts)),sample.oxide_thickness[ox[1]],width, bottom = bottom_iter, \
yerr = sample.oxide_thickness_err[ox[1]], color = hue[ox[1]],capsize = 5)
comps_so_far.append(ox[1])
ax.set_xticks(np.arange(0,len(pts)))
if hasattr(sample,'positions'):
ax.set_xticklabels(sample.positions,rotation = 90)
ax.tick_params(labelsize = 40)
ax.set_ylabel('Thickness (nm)',fontsize=40);
plt.legend(p,fit_legend,bbox_to_anchor=(0.9, 0.6, 0.0, 0.5),fontsize=20)
plt.grid()
plt.tight_layout()
return fig, ax
| 2.25
| 2
|
scripts/2021-10-10_extract_data_montecarlo.py
|
wendong-wang/spinning_rafts_sim2
| 0
|
12775061
|
<gh_stars>0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 28 14:52:17 2020
@author: vimal
"""
"""
This is for the Monte Carlo simulation of the configuration of many rafts
The maximum characters per line is set to be 120.
"""
# import glob
import os
import sys
import shelve
import platform
import datetime
import cv2 as cv
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import progressbar
# from scipy.integrate import RK45
# from scipy.integrate import solve_ivp
# from scipy.spatial import Voronoi as scipyVoronoi
# import scipy.io
from scipy.spatial import distance as scipy_distance
parallel_mode = 0
if platform.node() == 'NOTESIT43' and platform.system() == 'Windows':
projectDir = "D:\\simulationFolder\\spinning_rafts_sim2"
elif platform.node() == 'NOTESIT71' and platform.system() == 'Linux':
projectDir = r'/media/wwang/shared/spinning_rafts_simulation/spinning_rafts_sim2'
else:
projectDir = os.getcwd()
if projectDir != os.getcwd():
os.chdir(projectDir)
if parallel_mode == 1:
import functions_spinning_rafts as fsr
else:
import scripts.functions_spinning_rafts as fsr
scriptDir = os.path.join(projectDir, "scripts")
# capSym6Dir = os.path.join(projectDir, '2019-05-13_capillaryForceCalculations-sym6')
# capSym4Dir = os.path.join(projectDir, '2019-03-29_capillaryForceCalculations')
dataDir = os.path.join(projectDir, 'data')
if not os.path.isdir(dataDir):
os.mkdir('data')
#%%
os.chdir(dataDir)
resultFoldersFull = next(os.walk(dataDir))[1]
resultFoldersFull.sort()
resultFolders = resultFoldersFull[266:-2].copy()
#%%
arenaSize = 1.5e4 # unit: micron
R = raftRadius = 1.5e2 # unit: micron
numFrames_last = 10000
binSize_NDist = 0.5 # unit: radius
binStart_NDist = 2 # unit: radius
binEnd_NDist = 50 # unit: radius
binEdgesNeighborDistances = list(np.arange(binStart_NDist, binEnd_NDist, binSize_NDist)) + [100]
binSize_NAngles = 10 # unit: deg
binStart_NAngles = 0 # unit: deg
binEnd_NAngles = 360 # unit: deg
binEdgesNeighborAngles = list(np.arange(binStart_NAngles, binEnd_NAngles, binSize_NAngles)) + [360]
binSize_ODist = 0.5 # unit: radius
binStart_ODist = 2 # unit: radius
binEnd_ODist = 80 # unit: radius
binEdgesOrbitingDistances = list(np.arange(binStart_ODist, binEnd_ODist, binSize_ODist)) + [100]
binSize_XY = 2 # unit: radius
binEdgesX = list(np.arange(0, arenaSize/R + binSize_XY, binSize_XY))
binEdgesY = list(np.arange(0, arenaSize/R + binSize_XY, binSize_XY))
summaryDataFrameColNames = ['date', 'time', 'spinspeed', 'Numofsteps', 'lastframe', 'Max|psi6|FrameNum', 'Max_|psi6|', 'Last_|psi6|', 'Last_psi6_avg',
'Min_KLD_X', 'Min_KLD_Y', 'Min_KLD_NDist', 'Min_KLD_ODist', 'NumAcceptedProb', 'XYorODist', '|psi6|_avg', '|psi6|_std', ' psi6_avg', 'psi6_std']
dfSummary = pd.DataFrame(columns = summaryDataFrameColNames)
Mod_psi6 = np.zeros((len(resultFolders), numFrames_last)) # len(resultFolders) = number of simulations for each spinspeed or target distribution # num of frames to analyze = 10000. change this if needded.
psi6_avg = np.zeros((len(resultFolders), numFrames_last)) # this is the average norm and the one above i the norm average.
for index, resultFolderID in progressbar.progressbar(enumerate(range(len(resultFolders)))):
parts = resultFolders[resultFolderID].split('_')
os.chdir(resultFolders[resultFolderID])
numOfRafts = int(parts[2][:-5])
spinSpeed = int(parts[4][:2])
numOfSteps = int(parts[3][10:])
lastFrame = int(parts[7][9:])
date = parts[0]
time = parts[1]
XYorODist = parts[8]
shelfToRead = shelve.open('simulation_{}Rafts_{}rps'.format(numOfRafts, spinSpeed), flag='r')
listOfVariablesInShelfToRead = list(shelfToRead.keys())
for key in shelfToRead:
globals()[key] = shelfToRead[key]
shelfToRead.close()
#store distributions in csv file
count_NDist_all = np.zeros((len(binEdgesNeighborDistances[:-1]), 4)) # bin edges, frame with highest psi6, last frame, experimental distribution
count_X_all = np.zeros((len(binEdgesX[:-1]), 4)) # bin edges, frame with highest psi6, last frame, experimental distribution
count_Y_all = np.zeros((len(binEdgesY[:-1]), 4)) # bin edges, frame with highest psi6, last frame, experimental distribution
count_ODist_all = np.zeros((len(binEdgesOrbitingDistances[:-1]), 4)) # bin edges, frame with highest psi6, last frame, experimental distribution
Frame_max = hexaticOrderParameterModuliiAvgs.argmax()
Mod_psi6_max = hexaticOrderParameterModuliiAvgs.max()
Mod_psi6_last = hexaticOrderParameterModuliiAvgs[-2]
psi6_avg_last = hexaticOrderParameterAvgNorms[-2]
Mod_psi6[index,:] = hexaticOrderParameterModuliiAvgs[-numFrames_last:]
psi6_avg[index,:] = hexaticOrderParameterAvgNorms[-numFrames_last:]
count_NDist_all[:,0] = binEdgesNeighborDistances[:-1]
count_NDist_all[:,1] = count_NDist[:,Frame_max]
count_NDist_all[:,2] = count_NDist[:,-2]
count_NDist_all[:,3] = target['count_NDist']
count_X_all[:,0] = binEdgesX[:-1]
count_X_all[:,1] = count_X[:,Frame_max]
count_X_all[:,2] = count_X[:,-2]
count_X_all[:,3] = target['count_X']
count_Y_all[:,0] = binEdgesY[:-1]
count_Y_all[:,1] = count_Y[:,Frame_max]
count_Y_all[:,2] = count_Y[:,-2]
count_Y_all[:,3] = target['count_Y']
count_ODist_all[:,0] = binEdgesOrbitingDistances[:-1]
count_ODist_all[:,1] = count_ODist[:,Frame_max]
count_ODist_all[:,2] = count_ODist[:,-2]
count_ODist_all[:,3] = target['count_ODist']
count_accepted, _ = np.histogram(np.asarray(acceptedBasedOnProbs), bins=25)
dfSummary.loc[resultFolderID, 'date'] = date
dfSummary.loc[resultFolderID, 'time'] = time
dfSummary.loc[resultFolderID, 'spinspeed'] = spinSpeed
dfSummary.loc[resultFolderID, 'Numofsteps'] = numOfSteps
dfSummary.loc[resultFolderID, 'lastframe'] = lastFrame
dfSummary.loc[resultFolderID, 'Max|psi6|FrameNum'] = Frame_max
dfSummary.loc[resultFolderID, 'Max_|psi6|'] = Mod_psi6_max
dfSummary.loc[resultFolderID, 'Last_|psi6|'] = Mod_psi6_last
dfSummary.loc[resultFolderID, 'Last_psi6_avg'] = psi6_avg_last
dfSummary.loc[resultFolderID, 'Min_KLD_X'] = klDiv_X.min()
dfSummary.loc[resultFolderID, 'Min_KLD_Y'] = klDiv_Y.min()
dfSummary.loc[resultFolderID, 'Min_KLD_NDist'] = klDiv_NDist.min()
dfSummary.loc[resultFolderID, 'Min_KLD_ODist'] = klDiv_ODist.min()
dfSummary.loc[resultFolderID, 'NumAcceptedProb'] = count_accepted.sum()
dfSummary.loc[resultFolderID, 'XYorODist'] = XYorODist
np.savetxt("NDist_hist_" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) + "_totalAcceptedProbability" + str(count_accepted.sum()), count_NDist_all, delimiter=",")
np.savetxt("X_hist_" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) + "_totalAcceptedProbability" + str(count_accepted.sum()), count_X_all, delimiter=",")
np.savetxt("Y_hist_" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) + "_totalAcceptedProbability" + str(count_accepted.sum()), count_Y_all, delimiter=",")
np.savetxt("ODist_hist_" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) + "_totalAcceptedProbability" + str(count_accepted.sum()), count_ODist_all, delimiter=",")
np.savetxt("Mod_psi6" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) +
"_totalAcceptedProbability" + str(count_accepted.sum()), Mod_psi6, delimiter=",")
np.savetxt("psi6_avg" + str(numOfRafts) + "Rafts_" + str(spinSpeed) + "rps_" + "LastFrame" + str(ifLastFrameCount) +
"_totalAcceptedProbability" + str(count_accepted.sum()), psi6_avg, delimiter=",")
os.chdir(dataDir)
Mod_psi6_avg = Mod_psi6.mean()
Mod_psi6_std = Mod_psi6.std()
psi6_avg_avg = psi6_avg.mean()
psi6_avg_std =psi6_avg.std()
dfSummary.loc[resultFolderID, '|psi6|_avg'] = Mod_psi6_avg
dfSummary.loc[resultFolderID, '|psi6|_std'] = Mod_psi6_std
dfSummary.loc[resultFolderID, ' psi6_avg'] = psi6_avg_avg
dfSummary.loc[resultFolderID, 'psi6_std'] = psi6_avg_std
dfSummaryConverted = dfSummary.infer_objects()
dfSummarySorted = dfSummaryConverted.sort_values(by = ['spinspeed', 'date'], ascending = [True, False])
dfSummarySorted.to_csv('MonteCarlo' + '_summary.csv', index = False, columns = summaryDataFrameColNames )
| 2.09375
| 2
|
popupcad_gazebo/__init__.py
|
popupcad/popupcad
| 19
|
12775062
|
<filename>popupcad_gazebo/__init__.py
# -*- coding: utf-8 -*-
"""
Written by <NAME> and CONTRIBUTORS
Email: danaukes<at>asu.edu.
Please see LICENSE for full license.
"""
from . import gazebo_controller
#import external modules
import PIL
import array
import lxml
import multiprocessing
import pygazebo
import trollius
import collada
import stl
from . import enhanced_grid
from . import gradient
from . import image
from . import perlin_noise
def initialize(program):
projectactions =[]
projectactions.append({'text': 'Run Simulation', 'kwargs': {'triggered': lambda:gazebo_controller.export(program)}})
projectactions.append({'text': 'Export DAE', 'kwargs': {'triggered': lambda:export_dae(program)}})
projectactions.append({'text': 'Export STL', 'kwargs': {'triggered': lambda:export_stl(program)}})
program.editor.addMenu(projectactions, name='Gazebo')
def export_dae(program):
editor = program.editor
ii, jj = editor.operationeditor.currentIndeces2()[0]
output = editor.design.operations[ii].output[jj]
output.generic_laminate().toDAE()
def export_stl(program):
editor = program.editor
ii, jj = editor.operationeditor.currentIndeces2()[0]
output = editor.design.operations[ii].output[jj]
output.generic_laminate().toSTL()
| 2.125
| 2
|
Code/nebulae/nebulae.py
|
DaveSeidel/QB_Nebulae_V2
| 40
|
12775063
|
# Main Nebulae Source File
import sys
import os
from subprocess import Popen
import ctcsound
import controlhandler as ch
import conductor
import ui
import fileloader
import time
import logger
import neb_globals
cfg_path = "/home/alarm/QB_Nebulae_V2/Code/config/"
debug = False
debug_controls = False
class Nebulae(object):
def __init__(self):
if neb_globals.remount_fs is False:
print("Nebulae is operating in \"Read/Write\" mode.")
print("Filesystem will not be remounted during operation.")
os.system("/home/alarm/QB_Nebulae_V2/Code/scripts/mountfs.sh rw")
print "Nebulae Initializing"
self.instr_cfg = cfg_path + "bootinstr.txt"
self.orc_handle = conductor.Conductor() # Initialize Audio File Tables and Csound Score/Orchestra
#self.currentInstr = "a_granularlooper"
self.c = None
self.pt = None
self.ui = None
self.c_handle = None
self.led_process = None
self.log = logger.NebLogger()
# Check the config file for last instr
if os.path.isfile(self.instr_cfg) and os.path.getsize(self.instr_cfg) > 0:
# Get bank/instr from factory
with open(self.instr_cfg, 'rb') as f:
print "Reading bootinstr.txt"
for line in f:
templist = line.strip().split(',')
if templist[0] == 'bank':
self.new_bank = templist[1]
elif templist[0] == 'instr':
self.new_instr = templist[1]
else:
self.new_bank = 'factory'
self.new_instr = 'a_granularlooper'
self.currentInstr = self.new_instr
# Check if file exists, else reset to default instr
factory_path = "/home/alarm/QB_Nebulae_V2/Code/instr/"
user_path = "/home/alarm/instr/"
pd_path = "/home/alarm/pd/"
if self.new_bank == 'factory':
path = factory_path + self.new_instr + '.instr'
elif self.new_bank == 'user':
path = user_path + self.new_instr + '.instr'
elif self.new_bank == 'puredata':
path = pd_path + self.new_instr + '.pd'
else:
print "bank not recocgnized."
print self.new_bank
path = 'factory'
if os.path.isfile(path) == False:
# set to default instr
self.new_bank = 'factory'
self.new_instr = 'a_granularlooper'
self.first_run = True
self.last_debug_print = time.time()
def start(self, instr, instr_bank):
print "Nebulae Starting"
if self.currentInstr != self.new_instr:
reset_settings_flag = True
else:
reset_settings_flag = False
self.currentInstr = instr
if self.c is None:
self.c = ctcsound.Csound()
self.log.spill_basic_info()
floader = fileloader.FileLoader()
floader.reload()
self.orc_handle.generate_orc(instr, instr_bank)
configData = self.orc_handle.getConfigDict()
self.c.setOption("-iadc:hw:0,0")
self.c.setOption("-odac:hw:0,0") # Set option for Csound
if configData.has_key("-B"):
self.c.setOption("-B"+str(configData.get("-B")[0]))
else:
self.c.setOption("-B512") # Liberal Buffer
if configData.has_key("-b"):
self.c.setOption("-b"+str(configData.get("-b")[0]))
self.c.setOption("--realtime")
self.c.setOption("-+rtaudio=alsa") # Set option for Csound
if debug is True:
self.c.setOption("-m7")
else:
self.c.setOption("-m0") # Set option for Csound
self.c.setOption("-d")
self.c.compileOrc(self.orc_handle.curOrc) # Compile Orchestra from String
self.c.readScore(self.orc_handle.curSco) # Read in Score generated from notes
self.c.start() # Start Csound
self.c_handle = ch.ControlHandler(self.c, self.orc_handle.numFiles(), configData, self.new_instr, bank=self.new_bank) # Create handler for all csound comm.
self.loadUI()
self.pt = ctcsound.CsoundPerformanceThread(self.c.csound()) # Create CsoundPerformanceThread
self.c_handle.setCsoundPerformanceThread(self.pt)
self.pt.play() # Begin Performing the Score in the perforamnce thread
self.c_handle.updateAll() # Update all values to ensure their at their initial state.
if reset_settings_flag == True:
print("Changing Instr File -- Resetting Secondary Settings")
self.c_handle.restoreAltToDefault()
def run(self):
new_instr = None
request = False
if self.first_run == False:
self.c_handle.restoreAltToDefault()
while (self.pt.status() == 0): # Run a loop to poll for messages, and handle the UI.
self.ui.update()
self.c_handle.updateAll()
if debug_controls == True:
if time.time() - self.last_debug_print > 0.25:
self.last_debug_print = time.time()
self.c_handle.printAllControls()
request = self.ui.getReloadRequest()
if request == True:
self.cleanup()
if request == True:
self.first_run = False
print "Received Reload Request from UI"
print "index of new instr is: " + str(self.c_handle.instr_sel_idx)
self.new_instr = self.ui.getNewInstr()
print "new instr: " + self.new_instr
self.new_bank = self.c_handle.getInstrSelBank()
print "new bank: " + self.new_bank
self.c.cleanup()
self.ui.reload_flag = False # Clear Reload Flag
print "Reloading " + self.new_instr + " from " + self.new_bank
# Store bank/instr to config
self.writeBootInstr()
# Get bank/instr from factory
if self.new_bank == "puredata":
self.start_puredata(self.new_instr)
self.run_puredata()
else:
self.c.reset()
self.start(self.new_instr, self.new_bank)
self.run()
else:
print "Run Loop Ending."
self.cleanup()
print "Goodbye!"
sys.exit()
def cleanup(self):
print "Cleaning Up"
self.pt.stop()
self.pt.join()
def writeBootInstr(self):
try:
if neb_globals.remount_fs is True:
os.system("sh /home/alarm/QB_Nebulae_V2/Code/scripts/mountfs.sh rw")
with open(self.instr_cfg, 'w') as f:
bankstr = 'bank,'+self.new_bank
instrstr = 'instr,'+self.new_instr
f.write(bankstr + '\n')
f.write(instrstr + '\n')
for line in f:
templist = line.strip().split(',')
if templist[0] == 'bank':
self.new_bank = templist[1]
elif templist[0] == 'instr':
self.new_instr = templist[1]
if neb_globals.remount_fs is True:
os.system("sh /home/alarm/QB_Nebulae_V2/Code/scripts/mountfs.sh ro")
except:
"Could not write config file."
def start_puredata(self, patch):
self.log.spill_basic_info()
if self.c is not None:
self.c.cleanup()
self.c = None
self.c_handle = None
self.currentInstr = patch
self.newInstr = patch
floader = fileloader.FileLoader()
floader.reload()
self.orc_handle.refreshFileHandler()
fullPath = "/home/alarm/pd/" + patch + ".pd"
#cmd = "pd -rt -nogui -verbose -audiobuf 5".split()
if debug == False:
cmd = "pd -rt -callback -nogui -audiobuf 5".split()
else:
cmd = "pd -rt -callback -nogui -verbose -audiobuf 5".split()
cmd.append(fullPath)
self.pt = Popen(cmd)
print 'sleeping'
time.sleep(2)
self.c_handle = ch.ControlHandler(None, self.orc_handle.numFiles(), None, self.new_instr, bank="puredata")
self.c_handle.setCsoundPerformanceThread(None)
self.c_handle.enterPureDataMode()
self.loadUI()
def run_puredata(self):
new_instr = None
request = False
self.c_handle.enterPureDataMode()
while(request != True):
self.c_handle.updateAll()
if debug_controls == True:
self.c_handle.printAllControls()
self.ui.update()
request = self.ui.getReloadRequest()
if request == True:
print "Received Reload Request from UI"
print "index of new instr is: " + str(self.c_handle.instr_sel_idx)
self.new_instr = self.ui.getNewInstr()
self.new_bank = self.c_handle.getInstrSelBank()
self.ui.reload_flag = False # Clear Reload Flag
print "Reloading " + self.new_instr + " from " + self.new_bank
self.cleanup_puredata()
# Store bank/instr to config
self.writeBootInstr()
if self.new_bank == "puredata":
self.start_puredata(self.new_instr)
self.run_puredata()
else:
self.start(self.new_instr, self.new_bank)
self.run()
else:
print "Run Loop Ending."
self.cleanup_puredata()
print "Goodbye!"
sys.exit()
def cleanup_puredata(self):
self.pt.terminate()
self.pt.kill()
def loadUI(self):
print "Killing LED program"
cmd = "sudo pkill -1 -f /home/alarm/QB_Nebulae_V2/Code/nebulae/bootleds.py"
os.system(cmd)
if self.ui is None:
self.ui = ui.UserInterface(self.c_handle) # Create User Interface
else:
self.ui.controlhandler = self.c_handle
self.ui.clearAllLEDs()
self.c_handle.setInstrSelBank(self.new_bank)
self.ui.setCurrentInstr(self.new_instr)
def launch_bootled(self):
cmd = "sudo pkill -1 -f /home/alarm/QB_Nebulae_V2/Code/nebulae/bootleds.py"
os.system(cmd)
print "Launching LED program"
fullCmd = "python2 /home/alarm/QB_Nebulae_V2/Code/nebulae/bootleds.py loading"
self.led_process = Popen(fullCmd, shell=True)
print 'led process created: ' + str(self.led_process)
### NEBULAE ###
app = Nebulae()
if app.new_bank == "puredata":
app.start_puredata(app.new_instr)
app.run_puredata()
else:
app.start(app.new_instr, app.new_bank)
app.run()
| 2.171875
| 2
|
tests/test_magic.py
|
liranbg/nuclio-jupyter
| 62
|
12775064
|
# Copyright 2018 Iguazio
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from contextlib import redirect_stdout
from io import StringIO
from os import path
from conftest import here
from nuclio import magic
def test_print_handler_code():
fname = path.join(here, "handler.ipynb")
io = StringIO()
with redirect_stdout(io):
magic.print_handler_code(fname)
assert 'def handler' in io.getvalue()
def test_export():
line = path.join(here, "handler.ipynb")
line = line.replace("\\", "/") # handle windows
config, code = magic.build(line, None, return_dir=True)
assert config.get('spec'), 'export failed, config={}'.format(config)
| 1.867188
| 2
|
code/ch20/20.1.1. 1284.minFlips.py
|
leetcode-pp/leetcode-pp1
| 22
|
12775065
|
class Solution:
def minFlips(self, mat: List[List[int]]) -> int:
# 放到 flip 函数外面可以减少计算
mapper = {"0": "1", "1": "0"}
def flip(state: List[str], i: int) -> None:
state[i] = mapper[state[i]]
if i % n != 0:
state[i - 1] = mapper[state[i - 1]]
if i % n < n - 1:
state[i + 1] = mapper[state[i + 1]]
if i >= n:
state[i - n] = mapper[state[i - n]]
if i < (m - 1) * n:
state[i + n] = mapper[state[i + n]]
m = len(mat)
n = len(mat[0])
target = "0" * (m * n)
cur = "".join(str(cell) for row in mat for cell in row)
queue = [cur]
visited = set()
steps = 0
while len(queue) > 0:
for _ in range(len(queue)):
cur = queue.pop(0)
if cur == target:
return steps
if cur in visited:
continue
visited.add(cur)
for i in range(len(cur)):
s = list(cur)
flip(s, i)
queue.append("".join(s))
steps += 1
return -1
| 3.109375
| 3
|
agsconfig/services/parcel_fabric_server_extension.py
|
DavidWhittingham/agsconfig
| 1
|
12775066
|
<filename>agsconfig/services/parcel_fabric_server_extension.py
"""This module contains the ParcelFabricServer extension class"""
# Python 2/3 compatibility
# pylint: disable=wildcard-import,unused-wildcard-import,wrong-import-order,wrong-import-position
from __future__ import (absolute_import, division, print_function, unicode_literals)
from future.builtins.disabled import *
from future.builtins import *
from future.standard_library import install_aliases
install_aliases()
# pylint: enable=wildcard-import,unused-wildcard-import,wrong-import-order,wrong-import-position
from .extension_base import ExtensionBase
from .._enum import StrEnum as Enum
class ParcelFabricServerExtension(ExtensionBase):
""" ParcelFabricServer extension properties for ArcGIS services """
class Capability(Enum):
assign_features_to_record = "AssignFeaturesToRecord"
build = "Build"
change_parcel_type = "ChangeParcelType"
clip = "Clip"
copy_lines_to_parcel_type = "CopyLinesToParcelType"
create_seeds = "CreateSeeds"
delete_parcels = "DeleteParcels"
duplicate_parcels = "DuplicateParcels"
merge = "Merge"
update_parcel_history = "UpdateParcelHistory"
def __init__(self, editor):
super().__init__(editor, "ParcelFabricServer")
| 1.726563
| 2
|
setup.py
|
RockefellerArchiveCenter/rac_es
| 0
|
12775067
|
from setuptools import find_packages, setup
with open("README.md", "r") as fh:
long_description = fh.read()
setup(
name='rac_es',
version='0.17.4',
description="Helpers for Rockefeller Archive Center's Elasticsearch implementation.",
long_description=long_description,
long_description_content_type="text/markdown",
url='http://github.com/RockefellerArchiveCenter/rac_es',
author='Rockefeller Archive Center',
author_email='<EMAIL>',
license='MIT',
packages=find_packages(),
install_requires=[
'elasticsearch',
'elasticsearch_dsl',
],
test_suite='nose.collector',
tests_require=['nose', 'coverage'],
zip_safe=False)
| 1.304688
| 1
|
xcube/util/types.py
|
bcdev/xcube
| 0
|
12775068
|
# The MIT License (MIT)
# Copyright (c) 2022 by the xcube development team and contributors
#
# 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.
from typing import Optional, Tuple, Type, TypeVar, Union
from xcube.util.assertions import assert_true
T = TypeVar('T')
ItemType = Union[Type[T], Tuple[Type[T], ...]]
Pair = Tuple[T, T]
ScalarOrPair = Union[T, Pair]
def normalize_scalar_or_pair(
value: ScalarOrPair[T],
*,
item_type: Optional[ItemType[T]] = None,
name: Optional[str] = None
) -> Pair:
try:
assert_true(len(value) <= 2,
message=f"{name or 'Value'} must be a scalar or pair of "
f"{item_type or 'scalars'}, was '{value}'")
x, y = value
except TypeError:
x, y = value, value
if item_type is not None:
assert_true(isinstance(x, item_type) and isinstance(y, item_type),
message=f"{name or 'Value'} must be a scalar or pair of "
f"{item_type}, was '{value}'")
return x, y
| 2.21875
| 2
|
cronman/base.py
|
ryancheley/django-cronman
| 17
|
12775069
|
# -*- coding: utf-8 -*-
# vi:si:et:sw=4:sts=4:ts=4
from __future__ import unicode_literals
import logging
import platform
from cronman.monitor import Cronitor, Sentry, Slack
from cronman.utils import bool_param, config, ensure_dir, format_exception
logger = logging.getLogger("cronman.command")
class BaseCronObject(object):
"""Common base class for CronRemoteManager, CronScheduler, CronSpawner,
CronWorker.
"""
def __init__(self, **kwargs):
self.data_dir = kwargs.get("data_dir", config("CRONMAN_DATA_DIR"))
self.debug = kwargs.get("debug", bool_param(config("CRONMAN_DEBUG")))
self.cronitor = Cronitor()
self.sentry = Sentry()
self.slack = Slack()
ensure_dir(self.data_dir)
self.logger = kwargs.get("logger", logger)
def warning(self, exception, silent=False):
"""Handles exception as warning"""
message = format_exception(exception)
if not silent:
self.logger.warning(message)
system_name = platform.node()
self.slack.post(
"[{host}] {message}".format(host=system_name, message=message)
)
return message + "\n" # to be printed on stdout
| 2.09375
| 2
|
app/models/vehicle.py
|
MTES-MCT/mobilic-api
| 0
|
12775070
|
<gh_stars>0
import graphene
from app import db
from app.helpers.db import DateTimeStoredAsUTC
from app.helpers.graphene_types import BaseSQLAlchemyObjectType
from app.models.base import BaseModel
class Vehicle(BaseModel):
registration_number = db.Column(db.TEXT, nullable=False)
alias = db.Column(db.TEXT, nullable=True)
company_id = db.Column(
db.Integer, db.ForeignKey("company.id"), index=True, nullable=False
)
company = db.relationship("Company", backref="vehicles")
submitter_id = db.Column(
db.Integer, db.ForeignKey("user.id"), index=False, nullable=False
)
submitter = db.relationship("User")
terminated_at = db.Column(DateTimeStoredAsUTC, nullable=True)
__table_args__ = (
db.UniqueConstraint(
"company_id",
"registration_number",
name="unique_registration_numbers_among_company",
),
)
@property
def name(self):
return self.alias or self.registration_number
@property
def is_terminated(self):
return self.terminated_at is not None
class VehicleOutput(BaseSQLAlchemyObjectType):
class Meta:
model = Vehicle
name = graphene.Field(graphene.String)
| 2.296875
| 2
|
tests/data/thirdParty/Four/csnFour.py
|
xplanes/CSnake
| 4
|
12775071
|
# Csnake project configuration
import csnCilab
from csnAll import three
four = csnCilab.CilabModuleProject("Four", "third party")
four.pathsManager.useFilePath = "%s/Four/UseFour.cmake" % four.GetBuildFolder()
four.pathsManager.configFilePath = "%s/Four/FourConfig.cmake" % four.GetBuildFolder()
four.AddProjects([three])
| 1.46875
| 1
|
Chapter14/data_preprocessing.py
|
andriitugai/Learning-Python-data-structures
| 202
|
12775072
|
import numpy as np
import pandas
from sklearn.preprocessing import MinMaxScaler, StandardScaler, Binarizer
#handle the missing values
data = pandas.DataFrame([
[4., 45., 984.],
[np.NAN, np.NAN, 5.],
[94., 23., 55.],
])
#print original data
print(data)
#fill the missing values with the constant 0.1
print(data.fillna(0.1))
#fill the missing values with the mean
print(data.fillna(data.mean()))
#Data normalization
data1 = pandas.DataFrame([[ 58., 1., 43.],
[ 10., 200., 65.],
[ 20. , 75. , 7.]])
#scaling with min-max scaler
scaled_values = MinMaxScaler(feature_range=(0,1))
results = scaled_values.fit(data1).transform(data1)
print(results)
#scaling with the standard scaling
stand_scalar = StandardScaler().fit(data1)
results = stand_scalar.transform(data1)
print(results)
#normalization using binarization
results = Binarizer(50.0).fit(data1).transform(data1)
print(results)
| 3.359375
| 3
|
sentinel_backend/sentinel_backend/repository/MentionRepository.py
|
szymanskir/Sentinel
| 0
|
12775073
|
<reponame>szymanskir/Sentinel
import pandas as pd
from datetime import datetime
from sentinel_common.db_models import MentionDb, MentionDateIndex
from typing import List
from . import KeywordRepository
_KEYWORD_REPOSITORY = KeywordRepository()
class MentionRepository:
def get_mentions(
self, user: str, since: datetime, until: datetime, keywords: List[str]
):
if keywords is None or len(keywords) == 0:
keywords = _KEYWORD_REPOSITORY.get_by_user(user)
queries = [
MentionDateIndex.query(keyword, MentionDb.origin_date.between(since, until))
for keyword in keywords
]
mentions = []
for keyword in queries:
for m in keyword:
mentions.append(map_mention_to_dto(m))
return pd.DataFrame.from_records(mentions)
def map_mention_to_dto(m: MentionDb) -> dict:
return {
"author": m.author,
"origin_date": m.origin_date,
"keyword": m.keyword,
"id": m.id,
"download_date": m.download_date,
"text": m.text,
"url": m.url,
"source": m.source,
"sentiment_score": m.sentiment_score,
"metadata": m.metadata,
}
| 2.765625
| 3
|
socks.py
|
lik78/Gravy-Reloaded
| 2
|
12775074
|
"""SocksiPy - Python SOCKS module.
Version 1.00
Copyright 2006 Dan-Haim. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of Dan Haim nor the names of his contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY <NAME> "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL <NAME> OR HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.
This module provides a standard socket-like interface for Python
for tunneling connections through SOCKS proxies.
"""
import socket
import struct
PROXY_TYPE_SOCKS4 = 1
PROXY_TYPE_SOCKS5 = 2
PROXY_TYPE_HTTP = 3
_defaultproxy = None
_orgsocket = socket.socket
class ProxyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class GeneralProxyError(ProxyError):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class Socks5AuthError(ProxyError):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class Socks5Error(ProxyError):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class Socks4Error(ProxyError):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class HTTPError(ProxyError):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
_generalerrors = ('success', 'invalid data', 'not connected', 'not available', 'bad proxy type', 'bad input')
_socks5errors = ('succeeded', 'general SOCKS server failure', 'connection not allowed by ruleset', 'Network unreachable', 'Host unreachable', 'Connection refused', 'TTL expired', 'Command not supported', 'Address type not supported', 'Unknown error')
_socks5autherrors = ('succeeded', 'authentication is required', 'all offered authentication methods were rejected', 'unknown username or invalid password', 'unknown error')
_socks4errors = ('request granted', 'request rejected or failed', 'request rejected because SOCKS server cannot connect to identd on the client', 'request rejected because the client program and identd report different user-ids', 'unknown error')
def setdefaultproxy(proxytype = None, addr = None, port = None, rdns = True, username = None, password = None):
"""setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
Sets a default proxy which all further socksocket objects will use,
unless explicitly changed.
"""
global _defaultproxy
_defaultproxy = (proxytype,
addr,
port,
rdns,
username,
password)
class socksocket(socket.socket):
"""socksocket([family[, type[, proto]]]) -> socket object
Open a SOCKS enabled socket. The parameters are the same as
those of the standard socket init. In order for SOCKS to work,
you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
"""
def __init__(self, family = socket.AF_INET, type = socket.SOCK_STREAM, proto = 0, _sock = None):
_orgsocket.__init__(self, family, type, proto, _sock)
if _defaultproxy != None:
self.__proxy = _defaultproxy
else:
self.__proxy = (None, None, None, None, None, None)
self.__proxysockname = None
self.__proxypeername = None
return
def __recvall(self, bytes):
"""__recvall(bytes) -> data
Receive EXACTLY the number of bytes requested from the socket.
Blocks until the required number of bytes have been received.
"""
data = ''
while len(data) < bytes:
data = data + self.recv(bytes - len(data))
return data
def setproxy(self, proxytype = None, addr = None, port = None, rdns = True, username = None, password = <PASSWORD>):
"""setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
Sets the proxy to be used.
proxytype - The type of the proxy to be used. Three types
are supported: PROXY_TYPE_SOCKS4 (including socks4a),
PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
addr - The address of the server (IP or DNS).
port - The port of the server. Defaults to 1080 for SOCKS
servers and 8080 for HTTP proxy servers.
rdns - Should DNS queries be preformed on the remote side
(rather than the local side). The default is True.
Note: This has no effect with SOCKS4 servers.
username - Username to authenticate with to the server.
The default is no authentication.
password - Password to authenticate with to the server.
Only relevant when username is also provided.
"""
self.__proxy = (proxytype,
addr,
port,
rdns,
username,
password)
def __negotiatesocks5(self, destaddr, destport):
"""__negotiatesocks5(self,destaddr,destport)
Negotiates a connection through a SOCKS5 server.
"""
if self.__proxy[4] != None and self.__proxy[5] != None:
self.sendall('\x05\x02\x00\x02')
else:
self.sendall('\x05\x01\x00')
chosenauth = self.__recvall(2)
if chosenauth[0] != '\x05':
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if chosenauth[1] == '\x00':
pass
elif chosenauth[1] == '\x02':
self.sendall('\x01' + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.proxy[5])) + self.__proxy[5])
authstat = self.__recvall(2)
if authstat[0] != '\x01':
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if authstat[1] != '\x00':
self.close()
raise Socks5AuthError, (3, _socks5autherrors[3])
else:
self.close()
if chosenauth[1] == '\xff':
raise Socks5AuthError((2, _socks5autherrors[2]))
else:
raise GeneralProxyError((1, _generalerrors[1]))
req = '\x05\x01\x00'
try:
ipaddr = socket.inet_aton(destaddr)
req = req + '\x01' + ipaddr
except socket.error:
if self.__proxy[3] == True:
ipaddr = None
req = req + '\x03' + chr(len(destaddr)) + destaddr
else:
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
req = req + '\x01' + ipaddr
req = req + struct.pack('>H', destport)
self.sendall(req)
resp = self.__recvall(4)
if resp[0] != '\x05':
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
elif resp[1] != '\x00':
self.close()
if ord(resp[1]) <= 8:
raise Socks5Error(ord(resp[1]), _generalerrors[ord(resp[1])])
else:
raise Socks5Error(9, _generalerrors[9])
elif resp[3] == '\x01':
boundaddr = self.__recvall(4)
elif resp[3] == '\x03':
resp = resp + self.recv(1)
boundaddr = self.__recvall(resp[4])
else:
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
boundport = struct.unpack('>H', self.__recvall(2))[0]
self.__proxysockname = (boundaddr, boundport)
if ipaddr != None:
self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
else:
self.__proxypeername = (destaddr, destport)
return
def getproxysockname(self):
"""getsockname() -> address info
Returns the bound IP address and port number at the proxy.
"""
return self.__proxysockname
def getproxypeername(self):
"""getproxypeername() -> address info
Returns the IP and port number of the proxy.
"""
return _orgsocket.getpeername(self)
def getpeername(self):
"""getpeername() -> address info
Returns the IP address and port number of the destination
machine (note: getproxypeername returns the proxy)
"""
return self.__proxypeername
def __negotiatesocks4(self, destaddr, destport):
"""__negotiatesocks4(self,destaddr,destport)
Negotiates a connection through a SOCKS4 server.
"""
rmtrslv = False
try:
ipaddr = socket.inet_aton(destaddr)
except socket.error:
if self.__proxy[3] == True:
ipaddr = '\x00\x00\x00\x01'
rmtrslv = True
else:
ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
req = '\x04\x01' + struct.pack('>H', destport) + ipaddr
if self.__proxy[4] != None:
req = req + self.__proxy[4]
req = req + '\x00'
if rmtrslv == True:
req = req + destaddr + '\x00'
self.sendall(req)
resp = self.__recvall(8)
if resp[0] != '\x00':
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if resp[1] != 'Z':
self.close()
if ord(resp[1]) in (91, 92, 93):
self.close()
raise Socks4Error((ord(resp[1]), _socks4errors[ord(resp[1]) - 90]))
else:
raise Socks4Error((94, _socks4errors[4]))
self.__proxysockname = (socket.inet_ntoa(resp[4:]), struct.unpack('>H', resp[2:4])[0])
if rmtrslv != None:
self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
else:
self.__proxypeername = (destaddr, destport)
return
def __negotiatehttp(self, destaddr, destport):
"""__negotiatehttp(self,destaddr,destport)
Negotiates a connection through an HTTP server.
"""
if self.__proxy[3] == False:
addr = socket.gethostbyname(destaddr)
else:
addr = destaddr
self.sendall('CONNECT ' + addr + ':' + str(destport) + ' HTTP/1.1\r\n' + 'Host: ' + destaddr + '\r\n\r\n')
resp = self.recv(1)
while resp.find('\r\n\r\n') == -1:
resp = resp + self.recv(1)
statusline = resp.splitlines()[0].split(' ', 2)
if statusline[0] not in ('HTTP/1.0', 'HTTP/1.1'):
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
try:
statuscode = int(statusline[1])
except ValueError:
self.close()
raise GeneralProxyError((1, _generalerrors[1]))
if statuscode != 200:
self.close()
raise HTTPError((statuscode, statusline[2]))
self.__proxysockname = ('0.0.0.0', 0)
self.__proxypeername = (addr, destport)
def connect(self, destpair):
"""connect(self,despair)
Connects to the specified destination through a proxy.
destpar - A tuple of the IP/DNS address and the port number.
(identical to socket's connect).
To select the proxy server use setproxy().
"""
if type(destpair) in (list, tuple) == False or len(destpair) < 2 or type(destpair[0]) != str or type(destpair[1]) != int:
raise GeneralProxyError((5, _generalerrors[5]))
if self.__proxy[0] == PROXY_TYPE_SOCKS5:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 1080
_orgsocket.connect(self, (self.__proxy[1], portnum))
self.__negotiatesocks5(destpair[0], destpair[1])
elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 1080
_orgsocket.connect(self, (self.__proxy[1], portnum))
self.__negotiatesocks4(destpair[0], destpair[1])
elif self.__proxy[0] == PROXY_TYPE_HTTP:
if self.__proxy[2] != None:
portnum = self.__proxy[2]
else:
portnum = 8080
_orgsocket.connect(self, (self.__proxy[1], portnum))
self.__negotiatehttp(destpair[0], destpair[1])
elif self.__proxy[0] == None:
_orgsocket.connect(self, (destpair[0], destpair[1]))
else:
raise GeneralProxyError((4, _generalerrors[4]))
return
| 1.921875
| 2
|
iron/utilities/explode_bam.py
|
jason-weirather/Au-public
| 4
|
12775075
|
<reponame>jason-weirather/Au-public
#!/usr/bin/python
import sys, argparse, re, os
from subprocess import Popen, PIPE
from SamBasics import is_header
from multiprocessing import cpu_count, Pool
def main():
parser = argparse.ArgumentParser(description="Break a bam into evenly sized chunks",formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input',help="name bam file")
parser.add_argument('output_base',help="output base name myout will go to myout.1.bam")
parser.add_argument('-k',type=int,required=True,help="Number per chunk")
parser.add_argument('--threads',type=int,default=cpu_count(),help="Number of threads")
parser.add_argument('--name',action='store_true',help="pre-sorted by query name keep queries together")
parser.add_argument('-F',help="Add an input flag filter if you are reading from a bam file")
args = parser.parse_args()
# read header first
header = []
cmd = "samtools view -H "+args.input
p = Popen(cmd.split(),stdout=PIPE,bufsize=1)
inf = p.stdout
for line in inf:
header.append(line)
p.communicate()
inf = None
cmd = "samtools view "+args.input
if args.F:
cmd += " -F "+args.F
p = Popen(cmd.split(),stdout=PIPE,bufsize=1)
rex = re.compile('^(\S+)')
buffersize = args.k
buffer = []
prev_name = None
i = 0
poo = Pool(processes=max(1,args.threads-2))
while True:
line = p.stdout.readline()
if not line: break
if args.name:
m = rex.match(line)
if prev_name and m.group(1) != prev_name and len(buffer) >= buffersize:
i+= 1
poo.apply_async(do_output,args=(buffer[:],header,i,args.output_base))
buffer = []
prev_name = m.group(1)
else:
if len(buffer) >= buffersize:
i+=1
poo.apply_async(do_output,args=(buffer[:],header,i,args.output_base))
buffer = []
buffer.append(line)
# Deal with remainder
if len(buffer) > 0:
i+=1
poo.apply_async(do_output,args=(buffer[:],header,i,args.output_base))
buffer = []
poo.close()
poo.join()
print i
def do_output(buffer,header,i,output_base):
of = open(output_base+'.'+str(i)+'.bam','w')
cmd = 'samtools view - -Sb'
p = Popen(cmd.split(),stdin=PIPE,stdout=of)
for e in header:
p.stdin.write(e)
for e in buffer:
p.stdin.write(e)
p.communicate()
of.close()
return
if __name__=="__main__":
main()
| 2.421875
| 2
|
pytorch-version/train.py
|
bzantium/EA-LSTM
| 16
|
12775076
|
<gh_stars>10-100
import math
import torch
import torch.nn as nn
import torch.optim as optim
from utils import make_cuda
from sklearn.metrics import mean_squared_error, mean_absolute_error
def train(args, model, data_loader, initial=False):
MSELoss = nn.MSELoss(reduction='mean')
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
model.train()
num_epochs = args.initial_epochs if initial else args.num_epochs
for epoch in range(num_epochs):
loss = 0
for step, (features, targets) in enumerate(data_loader):
features = make_cuda(features)
targets = make_cuda(targets)
optimizer.zero_grad()
preds = model(features)
mse_loss = MSELoss(preds, targets)
loss += mse_loss.item()
mse_loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
optimizer.step()
# print step info
if (step + 1) % args.log_step == 0:
print("Epoch [%.3d/%.3d] Step [%.3d/%.3d]: MSE_loss=%.4f, RMSE_loss=%.4f"
% (epoch + 1,
num_epochs,
step + 1,
len(data_loader),
loss / args.log_step,
math.sqrt(loss / args.log_step)))
loss = 0
return model
def evaluate(args, model, scaler, data_loader):
model.eval()
model.lstm.flatten_parameters()
all_preds = []
all_targets = []
for features, targets in data_loader:
features = make_cuda(features)
with torch.no_grad():
preds = model(features)
all_preds.append(preds)
all_targets.append(targets)
all_preds = scaler.inverse_transform(torch.cat(all_preds, dim=0).cpu().numpy().reshape(-1, 1))
all_targets = scaler.inverse_transform(torch.cat(all_targets, dim=0).cpu().numpy().reshape(-1, 1))
mse = mean_squared_error(all_targets, all_preds)
rmse = math.sqrt(mse)
mae = mean_absolute_error(all_targets, all_preds)
print("RMSE = %.4f, MAE = %.4f\n" % (rmse, mae))
return rmse, mae
| 2.234375
| 2
|
nydus/db/backends/redis.py
|
jusbrasil/nydus
| 0
|
12775077
|
<reponame>jusbrasil/nydus
"""
nydus.db.backends.redis
~~~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2011-2012 DISQUS.
:license: Apache License 2.0, see LICENSE for more details.
"""
from __future__ import absolute_import
from redis import Redis as RedisClient, StrictRedis
from redis import ConnectionError, InvalidResponse
from nydus.db.backends import BaseConnection, BasePipeline
from nydus.compat import izip
class RedisPipeline(BasePipeline):
def __init__(self, connection):
self.pending = []
self.connection = connection
self.pipe = connection.pipeline()
def add(self, command):
name, args, kwargs = command.get_command()
self.pending.append(command)
# ensure the command is executed in the pipeline
getattr(self.pipe, name)(*args, **kwargs)
def execute(self):
return dict(izip(self.pending, self.pipe.execute()))
class Redis(BaseConnection):
# Exceptions that can be retried by this backend
retryable_exceptions = frozenset([ConnectionError, InvalidResponse])
supports_pipelines = True
def __init__(self, num, host='localhost', port=6379, db=0, timeout=None,
password=<PASSWORD>, unix_socket_path=None, identifier=None,
strict=True):
self.host = host
self.port = port
self.db = db
self.unix_socket_path = unix_socket_path
self.timeout = timeout
self.strict = strict
self.__identifier = identifier
self.__password = password
super(Redis, self).__init__(num)
@property
def identifier(self):
if self.__identifier is not None:
return self.__identifier
mapping = vars(self)
mapping['klass'] = self.__class__.__name__
return "redis://%(host)s:%(port)s/%(db)s" % mapping
def connect(self):
if self.strict:
cls = StrictRedis
else:
cls = RedisClient
return cls(
host=self.host, port=self.port, db=self.db,
socket_timeout=self.timeout, password=self.__password,
unix_socket_path=self.unix_socket_path)
def disconnect(self):
self.connection.disconnect()
def get_pipeline(self, *args, **kwargs):
return RedisPipeline(self)
| 2.28125
| 2
|
pybda/bda_03a_ave.py
|
OxfordSKA/bda
| 2
|
12775078
|
"""BDA with custom BDA code."""
import os
import sys
import subprocess
if __name__ == "__main__":
if len(sys.argv) - 1 < 1:
print 'Usage:'
print (' $ python bda/bda_03a_ave.py '
'<simulation dir>')
sys.exit(1)
sim_dir = sys.argv[-1]
if not os.path.isdir(sim_dir):
print 'ERROR: simulation directory not found!'
sys.exit(1)
# -------------------------------------------------------------------------
idt_max = 50
max_fact = 1.002 # Maximum amplitude loss factor.
fov_radius = 0.9 # Field of view radius for max_fact
# -------------------------------------------------------------------------
cmd = 'src/bda'
ms = os.path.join(sim_dir, 'vis', 'model.ms')
subprocess.call([cmd, ms,
'%.5f' % max_fact,
'%.3f' % fov_radius,
'%i' % idt_max])
print ''
print '*' * 60
print '*' * 60
print '*' * 60
print ''
cmd = 'src/bda_2'
ms = os.path.join(sim_dir, 'vis', 'corrupted.ms')
subprocess.call([cmd, ms,
'%.5f' % max_fact,
'%.3f' % fov_radius,
'%i' % idt_max])
| 2.09375
| 2
|
scripts/integration_fail_file.py
|
Hrovatin/scib
| 11
|
12775079
|
from snakemake.io import load_configfile
from pathlib import Path
if __name__=='__main__':
import argparse
parser = argparse.ArgumentParser(description='Create an empty output file for failed integration runs')
parser.add_argument('-c', '--config', help='Snakemake config file', required=True)
parser.add_argument('-t', '--task', required=True)
parser.add_argument('-m', '--method', required=True)
parser.add_argument("-v", '--hvgs', help='pre-processed by HVG filtering', action='store_true')
parser.add_argument('-s', '--scale', action='store_true', help='pre-processed by scaling')
args = parser.parse_args()
config = args.config
task = args.task
hvgs = args.hvgs
scale = args.scale
method = args.method
# Load config file
params = load_configfile(config)
# Check inputs
if method not in params['METHODS']:
raise ValueError(f'{method} is not a valid method.\n'
f'Please choose one of: {list(params["METHODS"].keys())}')
if task not in params['DATA_SCENARIOS']:
raise ValueError(f'{task} is not a valid integration task.\n'
f'Please choose one of: {list(params["DATA_SCENARIOS"].keys())}')
# Get path values
folder = params['ROOT']
t_folder = task
s_folder = 'scaled' if scale else 'unscaled'
h_folder = 'hvg' if hvgs else 'full_feature'
r_folder = 'R/' if 'R' in params['METHODS'][method] else ''
filename = method+'.h5ad'
folder_path = '/'.join([folder,task,'integration',s_folder,h_folder])+'/'+r_folder
full_path = folder_path+filename
if 'R' in params['METHODS'][method]:
filename_r = method+'.RDS'
full_path_r = folder_path+filename_r
Path(full_path_r).touch()
Path(full_path_r+".benchmark").touch()
#print(full_path)
Path(full_path).touch()
Path(full_path+".benchmark").touch()
| 2.296875
| 2
|
mongo/data_generator/models/models.py
|
svvladimir-ru/ugc_sprint_1
| 0
|
12775080
|
from uuid import UUID, uuid4
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, Field
class BaseCollection(BaseModel):
id: Optional[UUID] = Field(alias='_id', default=uuid4())
created_at: Optional[datetime] = datetime.now()
collection: Optional[str]
def __init__(self, collection: str = None, **kwargs):
super().__init__(**kwargs)
self.id = uuid4()
self.created_at = datetime.now()
if collection:
self.collection = collection
class Likes(BaseCollection):
user_id: UUID
content_id: UUID
value: int
collection = "likes"
class Reviews(BaseCollection):
user_id: UUID
movie_id: UUID
text: str
collection = "reviews"
class Bookmarks(BaseCollection):
movie_id: UUID
user_id: UUID
collection = "bookmarks"
| 2.859375
| 3
|
src/m6_your_turtles.py
|
kaysm/01-IntroductionToPython
| 0
|
12775081
|
"""
Your chance to explore Loops and Turtles!
Authors: <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>, their colleagues, and <NAME>.
"""
########################################################################
# DONE: 1.
# On Line 5 above, replace PUT_YOUR_NAME_HERE with your own name.
########################################################################
########################################################################
# DONE: 2.
# You should have RUN the m5e_loopy_turtles module and READ its code.
# (Do so now if you have not already done so.)
#
# Below this comment, add ANY CODE THAT YOU WANT, as long as:
# 1. You construct at least 2 rg.SimpleTurtle objects.
# 2. Each rg.SimpleTurtle object draws something
# (by moving, using its rg.Pen). ANYTHING is fine!
# 3. Each rg.SimpleTurtle moves inside a LOOP.
#
# Be creative! Strive for way-cool pictures! Abstract pictures rule!
#
# If you make syntax (notational) errors, no worries -- get help
# fixing them at either this session OR at the NEXT session.
#
# Don't forget to COMMIT-and-PUSH when you are done with this module.
#
########################################################################
import rosegraphics as rg
window = rg.TurtleWindow()
window.tracer(100)
blueboi = rg.SimpleTurtle('square')
blueboi.pen = rg.Pen('blue', 3)
blueboi.speed = 200
for k in range(500):
blueboi.left(92)
blueboi.forward(k)
redboi = rg.SimpleTurtle('square')
redboi.pen = rg.Pen('red', 3)
redboi.speed = 200
for k in range(500):
redboi.right(92)
redboi.forward(k)
greenboi = rg.SimpleTurtle('square')
greenboi.pen = rg.Pen('green', 3)
greenboi.speed = 200
greenboi.backward(10)
for k in range(500):
greenboi.backward(k)
greenboi.right(2)
greenboi.forward(k)
window.close_on_mouse_click()
| 3.703125
| 4
|
canvas/core/model/statements.py
|
robinsax/canvas
| 4
|
12775082
|
# coding: utf-8
'''
Top-level statement objects.
'''
from .ast import deproxy, nodeify
from .joins import Join
# TODO: Constructor docs.
class Statement:
'''The top-level AST node type, which must facilitate value collection.'''
def write(self):
'''Return an SQL, value list tuple of this statement's serialization'''
raise NotImplementedError()
class CreateStatement(Statement):
'''A lazy SQL `CREATE` statement.'''
def __init__(self, target):
self.target = deproxy(target)
def write(self):
return ' '.join((
'CREATE', self.target.object_type, 'IF NOT EXISTS',
self.target.describe()
)), tuple()
class SelectStatement(Statement):
'''An SQL `SELECT` statement.'''
def __init__(self, target, condition=True, modifiers=tuple(), distinct=False):
self.target, self.condition = deproxy(target), nodeify(condition)
self.modifiers = modifiers
self.distinct = distinct
def write(self):
name_policy = self.target.name_column if isinstance(self.target, Join) else None
values = list()
selection = '*'
if not isinstance(self.target, Join):
selection = self.target.serialize_selection()
sql = ' '.join((
'SELECT', selection,
'FROM', self.target.serialize_source(values),
'WHERE', nodeify(self.condition).serialize(values, name_policy=name_policy),
*(modifier.serialize(values) for modifier in self.modifiers)
))
return sql, values
class InsertStatement(Statement):
'''An SQL `INSERT` statement.'''
def __init__(self, target, values):
'''
::target The target object reference.
::values A list of value, object-reference-esq tuples.
'''
self.target = deproxy(target)
self.values = [(nodeify(value[0]), value[1]) for value in values]
def write(self):
values = list()
sql = ' '.join((
'INSERT INTO', self.target.serialize(values), '(',
', '.join(value[1].name for value in self.values),
') VALUES (',
', '.join(value[0].serialize(values) for value in self.values),
') RETURNING ', self.target.primary_key.serialize()
))
return sql, values
class DeleteStatement(Statement):
'''An SQL 'DELETE FROM' statement.'''
def __init__(self, host, condition, cascade):
self.host, self.condition = deproxy(host), condition
self.cascade = cascade
# TODO: Handle cascade options.
def write(self):
values = list()
sql = ' '.join((
'DELETE FROM', self.host.serialize(values),
'WHERE', self.condition.serialize(values)
))
return sql, values
class UpdateStatement(Statement):
'''An SQL 'UPDATE' statement.'''
def __init__(self, target, assignments, condition):
self.target, self.condition = deproxy(target), nodeify(condition)
self.assignments = (
(deproxy(target), nodeify(value)) for target, value in assignments
)
def write(self):
values, assignment_expressions = list(), list()
for target, value in self.assignments:
assignment_expressions.append(
' = '.join((target.name, value.serialize(values)))
)
sql = ' '.join((
'UPDATE', self.target.serialize(),
'SET', ', '.join(assignment_expressions),
'WHERE', self.condition.serialize(values)
))
return sql, values
| 2.546875
| 3
|
mmtbx/conformation_dependent_library/cdl_database.py
|
rimmartin/cctbx_project
| 0
|
12775083
|
from __future__ import division
version = "CDL v1.2"
cdl_database = {
"Gly_nonxpro" : {
(-180, -180) : ['B', 14, 120.86, 1.62, -1, -1, 110.42, 1.49, -1, -1, 121.63, 0.95, 114.72, 1.32, 123.61, 1.16, 1.327, 0.0115, 1.4508, 0.0113, -1, -1, 1.5117, 0.0124, 1.2356, 0.0123],
(-180, -170) : ['B', 7, 120.56, 1.42, -1, -1, 110.8, 1.41, -1, -1, 121.38, 1.05, 114.98, 1.64, 123.62, 1.15, 1.3269, 0.0101, 1.4489, 0.0121, -1, -1, 1.5118, 0.0114, 1.233, 0.0125],
(-180, -160) : ['B', 7, 120.51, 1.22, -1, -1, 111.08, 1.62, -1, -1, 121.08, 1.12, 115.31, 1.79, 123.58, 1.13, 1.326, 0.0105, 1.4483, 0.0135, -1, -1, 1.5101, 0.012, 1.2324, 0.0113],
(-180, -150) : ['I', 1379, 121.41, 1.96, -1, -1, 113.18, 2.37, -1, -1, 120.57, 1.74, 116.69, 2.04, 122.7, 1.3, 1.3305, 0.0146, 1.4492, 0.0145, -1, -1, 1.5143, 0.0141, 1.2347, 0.0135],
(-180, 160) : ['B', 4, 120.92, 1.3, -1, -1, 110.38, 1.48, -1, -1, 121.49, 0.96, 114.58, 0.86, 123.87, 1.01, 1.3258, 0.0129, 1.4495, 0.0163, -1, -1, 1.513, 0.011, 1.236, 0.011],
(-180, 170) : ['B', 10, 121.03, 1.51, -1, -1, 110.18, 1.56, -1, -1, 121.62, 0.98, 114.67, 1.11, 123.67, 1.16, 1.3267, 0.0124, 1.4516, 0.014, -1, -1, 1.512, 0.0121, 1.2358, 0.0115],
(-170, -180) : ['B', 13, 120.84, 1.91, -1, -1, 110.55, 1.64, -1, -1, 121.6, 0.97, 114.82, 1.35, 123.55, 1.19, 1.3281, 0.0118, 1.4507, 0.0107, -1, -1, 1.5117, 0.0115, 1.2339, 0.0106],
(-170, -170) : ['B', 13, 120.51, 1.63, -1, -1, 111.19, 1.45, -1, -1, 121.41, 0.95, 114.94, 1.39, 123.61, 1.21, 1.3262, 0.0109, 1.4471, 0.0119, -1, -1, 1.5114, 0.0118, 1.2323, 0.0116],
(-170, -160) : ['B', 6, 120.57, 1.39, -1, -1, 111.59, 1.63, -1, -1, 121.21, 1.07, 115.11, 1.43, 123.64, 1.37, 1.3244, 0.0119, 1.445, 0.0131, -1, -1, 1.5104, 0.0139, 1.2319, 0.0105],
(-170, 160) : ['B', 7, 121.09, 1.46, -1, -1, 110.91, 1.49, -1, -1, 121.29, 1.03, 114.84, 1.06, 123.76, 0.93, 1.3278, 0.0136, 1.4492, 0.0128, -1, -1, 1.5102, 0.01, 1.2358, 0.0112],
(-170, 170) : ['B', 14, 121.05, 1.85, -1, -1, 110.56, 1.66, -1, -1, 121.56, 1.07, 114.73, 1.3, 123.66, 1.14, 1.3283, 0.0132, 1.4519, 0.0118, -1, -1, 1.5111, 0.0108, 1.2343, 0.0102],
(-160, -180) : ['B', 11, 121.22, 2.05, -1, -1, 110.66, 1.9, -1, -1, 121.61, 1.05, 114.93, 1.52, 123.44, 1.16, 1.33, 0.0122, 1.4491, 0.0107, -1, -1, 1.5125, 0.011, 1.233, 0.0099],
(-160, -170) : ['B', 5, 121.15, 1.8, -1, -1, 111.27, 1.67, -1, -1, 121.38, 0.94, 115.03, 1.27, 123.56, 1.24, 1.3274, 0.0117, 1.4439, 0.0119, -1, -1, 1.512, 0.0121, 1.2328, 0.0111],
(-160, -160) : ['B', 5, 121.37, 1.56, -1, -1, 111.66, 1.91, -1, -1, 121.33, 1.18, 115.22, 1.15, 123.39, 1.73, 1.3232, 0.0146, 1.4429, 0.0117, -1, -1, 1.5101, 0.0183, 1.2319, 0.0098],
(-160, -150) : ['B', 3, 121.83, 1.19, -1, -1, 111.04, 2.37, -1, -1, 121.16, 1.36, 115.69, 1.14, 123.1, 1.76, 1.3197, 0.0157, 1.4496, 0.0091, -1, -1, 1.5103, 0.0221, 1.2331, 0.007],
(-160, 150) : ['B', 5, 121.27, 1.32, -1, -1, 110.87, 1.54, -1, -1, 121.06, 0.9, 115.59, 1.26, 123.27, 0.76, 1.3294, 0.013, 1.4497, 0.0094, -1, -1, 1.5089, 0.0092, 1.235, 0.0102],
(-160, 160) : ['B', 7, 121.17, 1.66, -1, -1, 111.14, 1.8, -1, -1, 121.37, 1.09, 114.99, 1.39, 123.56, 0.93, 1.3297, 0.0136, 1.4499, 0.0105, -1, -1, 1.5098, 0.0103, 1.2352, 0.0108],
(-160, 170) : ['B', 10, 121.22, 2.07, -1, -1, 110.83, 1.91, -1, -1, 121.68, 1.17, 114.77, 1.57, 123.51, 1.15, 1.3307, 0.0138, 1.4511, 0.0105, -1, -1, 1.5112, 0.011, 1.2331, 0.0098],
(-150, -180) : ['B', 6, 121.93, 1.87, -1, -1, 110.73, 1.9, -1, -1, 121.46, 1.15, 115.24, 1.59, 123.29, 1.06, 1.3315, 0.0124, 1.4466, 0.0101, -1, -1, 1.5132, 0.0115, 1.2326, 0.0107],
(-150, -150) : ['B', 3, 122.42, 1.13, -1, -1, 110.69, 2.05, -1, -1, 120.92, 1.3, 115.88, 1.21, 123.16, 1.31, 1.3233, 0.0166, 1.4527, 0.0086, -1, -1, 1.5109, 0.0197, 1.235, 0.0078],
(-150, -140) : ['B', 3, 122.16, 0.77, -1, -1, 111.16, 1.76, -1, -1, 120.54, 1.25, 116.3, 1.35, 123.14, 0.76, 1.3276, 0.0187, 1.4578, 0.0092, -1, -1, 1.5035, 0.0183, 1.2391, 0.0085],
(-150, 150) : ['B', 7, 121.38, 1.22, -1, -1, 110.8, 1.71, -1, -1, 121.19, 0.91, 115.53, 1.33, 123.23, 0.81, 1.325, 0.0133, 1.4525, 0.0103, -1, -1, 1.5102, 0.0111, 1.2353, 0.011],
(-150, 160) : ['B', 7, 121.26, 1.42, -1, -1, 111.03, 1.87, -1, -1, 121.48, 1.09, 114.93, 1.51, 123.54, 0.92, 1.3301, 0.0132, 1.4504, 0.0109, -1, -1, 1.5126, 0.0108, 1.2355, 0.0122],
(-150, 170) : ['B', 7, 121.47, 1.69, -1, -1, 110.97, 1.92, -1, -1, 121.61, 1.19, 114.92, 1.57, 123.45, 1.06, 1.3333, 0.014, 1.4485, 0.01, -1, -1, 1.5128, 0.0109, 1.2332, 0.0124],
(-140, -180) : ['B', 3, 122.03, 1.28, -1, -1, 111.12, 1.49, -1, -1, 121.31, 1.09, 114.95, 1.41, 123.73, 0.88, 1.334, 0.0145, 1.4474, 0.0093, -1, -1, 1.5159, 0.0104, 1.2324, 0.0128],
(-140, 150) : ['B', 5, 121.46, 0.95, -1, -1, 110.9, 1.53, -1, -1, 121.47, 0.9, 115.09, 1.29, 123.36, 0.89, 1.3251, 0.0119, 1.4507, 0.0106, -1, -1, 1.5127, 0.0103, 1.233, 0.0118],
(-140, 160) : ['B', 13, 121.35, 1.03, -1, -1, 110.96, 1.49, -1, -1, 121.63, 1.07, 114.74, 1.48, 123.57, 0.93, 1.332, 0.0131, 1.4469, 0.0108, -1, -1, 1.5152, 0.0093, 1.2335, 0.0136],
(-140, 170) : ['B', 8, 121.48, 1.06, -1, -1, 111.1, 1.46, -1, -1, 121.49, 1.15, 114.83, 1.49, 123.65, 0.92, 1.336, 0.0156, 1.4462, 0.0095, -1, -1, 1.5155, 0.0089, 1.2334, 0.0152],
(-130, -180) : ['B', 4, 122.17, 0.89, -1, -1, 111.42, 1.42, -1, -1, 121.47, 0.91, 114.56, 1.22, 123.95, 0.77, 1.334, 0.0121, 1.4473, 0.0094, -1, -1, 1.5187, 0.0101, 1.2328, 0.0118],
(-130, -150) : ['B', 5, 123.04, 1.89, -1, -1, 111.2, 1.39, -1, -1, 121.72, 0.96, 114.96, 1.34, 123.31, 1.01, 1.3304, 0.0169, 1.4446, 0.0083, -1, -1, 1.5178, 0.0124, 1.233, 0.0192],
(-130, -140) : ['B', 3, 122.7, 1.81, -1, -1, 110.77, 1.59, -1, -1, 121.78, 0.91, 115.24, 1.44, 122.97, 1.15, 1.3291, 0.0185, 1.4509, 0.0086, -1, -1, 1.5166, 0.013, 1.2308, 0.019],
(-130, 140) : ['B', 3, 121.65, 0.68, -1, -1, 111.46, 1.75, -1, -1, 120.94, 0.78, 115.49, 1.03, 123.49, 0.8, 1.3219, 0.0141, 1.4543, 0.0099, -1, -1, 1.5118, 0.0087, 1.2304, 0.0134],
(-130, 150) : ['B', 5, 121.61, 0.77, -1, -1, 111.38, 1.63, -1, -1, 121.57, 0.87, 114.98, 1.14, 123.37, 0.88, 1.3267, 0.0115, 1.4483, 0.0104, -1, -1, 1.5135, 0.0086, 1.2308, 0.0121],
(-130, 160) : ['B', 5, 121.58, 0.86, -1, -1, 111.18, 1.54, -1, -1, 121.76, 1.03, 114.75, 1.4, 123.42, 0.91, 1.3335, 0.0122, 1.4438, 0.0102, -1, -1, 1.5161, 0.0082, 1.2312, 0.0138],
(-130, 170) : ['B', 5, 121.82, 0.84, -1, -1, 111.14, 1.46, -1, -1, 121.57, 1.07, 114.79, 1.49, 123.6, 0.87, 1.3365, 0.0137, 1.4446, 0.0099, -1, -1, 1.5187, 0.0089, 1.2337, 0.0154],
(-120, -180) : ['B', 4, 122.67, 1.1, -1, -1, 112.06, 1.66, -1, -1, 121.88, 1.14, 114.5, 1.19, 123.59, 0.87, 1.3334, 0.0096, 1.4439, 0.0091, -1, -1, 1.5198, 0.0104, 1.2338, 0.012],
(-120, 140) : ['B', 3, 122.33, 0.73, -1, -1, 111.04, 1.77, -1, -1, 120.57, 0.95, 115.89, 1.04, 123.48, 0.94, 1.3245, 0.0132, 1.4555, 0.0116, -1, -1, 1.5156, 0.0081, 1.2326, 0.0137],
(-120, 150) : ['B', 3, 122.18, 0.69, -1, -1, 111.19, 1.75, -1, -1, 121.11, 0.9, 115.58, 1.07, 123.25, 0.9, 1.3292, 0.0119, 1.4491, 0.0114, -1, -1, 1.5161, 0.0093, 1.2322, 0.0124],
(-120, 170) : ['B', 5, 122.47, 0.89, -1, -1, 111.57, 1.74, -1, -1, 121.77, 1.15, 114.9, 1.44, 123.29, 0.87, 1.3361, 0.0101, 1.444, 0.0102, -1, -1, 1.5218, 0.0106, 1.237, 0.015],
(-110, -180) : ['B', 5, 122.77, 1.21, -1, -1, 112.64, 1.74, -1, -1, 122.56, 1.65, 114.3, 1.2, 123.12, 1.18, 1.3331, 0.01, 1.4431, 0.0086, -1, -1, 1.5213, 0.0113, 1.2287, 0.0125],
(-110, -170) : ['B', 4, 122.69, 1.04, -1, -1, 112.81, 1.38, -1, -1, 122.23, 1.29, 114.65, 0.92, 123.11, 1.07, 1.3332, 0.011, 1.4418, 0.0077, -1, -1, 1.5176, 0.0107, 1.2326, 0.0095],
(-110, -160) : ['B', 4, 122.85, 1.21, -1, -1, 112.79, 1.2, -1, -1, 121.93, 1.06, 115.27, 0.76, 122.79, 0.98, 1.3342, 0.0119, 1.4381, 0.0141, -1, -1, 1.5147, 0.0108, 1.2383, 0.0089],
(-110, 10) : ['B', 5, 122.3, 1.52, -1, -1, 115.8, 1.74, -1, -1, 119.04, 0.91, 118.95, 1.06, 121.97, 0.95, 1.3324, 0.0106, 1.4485, 0.0132, -1, -1, 1.511, 0.0103, 1.2386, 0.0071],
(-110, 130) : ['B', 3, 122.73, 0.93, -1, -1, 110.71, 1.53, -1, -1, 120.75, 0.94, 115.43, 1.18, 123.8, 0.92, 1.3299, 0.0085, 1.4525, 0.014, -1, -1, 1.5201, 0.0073, 1.2326, 0.0128],
(-110, 140) : ['B', 8, 122.8, 0.97, -1, -1, 110.71, 1.78, -1, -1, 120.64, 0.98, 115.83, 1.32, 123.49, 1.1, 1.3274, 0.0111, 1.4562, 0.0132, -1, -1, 1.5185, 0.0073, 1.2342, 0.0134],
(-110, 150) : ['B', 5, 122.66, 0.98, -1, -1, 111.12, 1.89, -1, -1, 120.94, 0.98, 115.83, 1.37, 123.18, 1.13, 1.3303, 0.0136, 1.4507, 0.0116, -1, -1, 1.5165, 0.0101, 1.2331, 0.0128],
(-110, 170) : ['B', 5, 122.69, 1.08, -1, -1, 112.1, 1.82, -1, -1, 122.27, 1.54, 114.61, 1.26, 123.09, 1.11, 1.3335, 0.0111, 1.4439, 0.0093, -1, -1, 1.522, 0.0129, 1.2298, 0.0137],
(-100, -180) : ['B', 10, 122.3, 1.03, -1, -1, 112.58, 1.58, -1, -1, 122.52, 1.46, 114.55, 1.16, 122.91, 1.22, 1.334, 0.012, 1.4445, 0.0096, -1, -1, 1.5227, 0.0136, 1.2285, 0.012],
(-100, -170) : ['B', 5, 122.43, 0.89, -1, -1, 112.57, 1.37, -1, -1, 122.33, 1.11, 114.8, 1.04, 122.86, 1.06, 1.3332, 0.011, 1.4448, 0.0092, -1, -1, 1.5188, 0.0114, 1.2326, 0.0094],
(-100, -160) : ['B', 4, 122.83, 1.21, -1, -1, 112.6, 1.43, -1, -1, 121.9, 1.02, 115.25, 0.98, 122.82, 1.06, 1.3295, 0.0126, 1.4445, 0.0142, -1, -1, 1.5147, 0.0119, 1.2363, 0.0092],
(-100, -150) : ['B', 5, 123.29, 1.88, -1, -1, 112.55, 1.44, -1, -1, 121.53, 1.06, 115.61, 1.03, 122.8, 1.35, 1.3253, 0.0127, 1.4471, 0.0189, -1, -1, 1.5135, 0.0113, 1.2368, 0.0102],
(-100, -140) : ['B', 4, 123.12, 2.16, -1, -1, 112.13, 1.34, -1, -1, 121.28, 1.01, 115.71, 1.0, 122.92, 1.43, 1.3247, 0.0123, 1.4533, 0.0197, -1, -1, 1.5133, 0.0106, 1.2362, 0.0109],
(-100, -90) : ['B', 3, 123.95, 1.5, -1, -1, 110.21, 0.91, -1, -1, 121.36, 0.36, 116.75, 0.67, 121.85, 0.56, 1.3294, 0.0083, 1.4471, 0.0075, -1, -1, 1.5146, 0.0062, 1.2448, 0.0119],
(-100, 0) : ['B', 5, 122.66, 2.06, -1, -1, 115.61, 1.74, -1, -1, 119.28, 1.39, 118.41, 1.29, 122.29, 1.26, 1.33, 0.0147, 1.4452, 0.0132, -1, -1, 1.5106, 0.0162, 1.2349, 0.0115],
(-100, 10) : ['B', 7, 122.83, 1.8, -1, -1, 115.46, 1.63, -1, -1, 119.1, 1.26, 118.6, 1.16, 122.27, 1.14, 1.3296, 0.0124, 1.4468, 0.0124, -1, -1, 1.5127, 0.0128, 1.2368, 0.0094],
(-100, 120) : ['B', 3, 122.29, 0.89, -1, -1, 111.34, 1.97, -1, -1, 120.81, 0.86, 115.82, 1.1, 123.35, 0.63, 1.3322, 0.005, 1.444, 0.0136, -1, -1, 1.5143, 0.0082, 1.233, 0.0135],
(-100, 130) : ['B', 7, 122.2, 0.95, -1, -1, 110.95, 1.74, -1, -1, 120.91, 0.87, 115.47, 1.21, 123.61, 0.77, 1.3309, 0.0066, 1.4516, 0.014, -1, -1, 1.5174, 0.007, 1.2332, 0.0119],
(-100, 140) : ['B', 7, 122.36, 0.97, -1, -1, 111.25, 1.79, -1, -1, 120.92, 0.91, 115.57, 1.37, 123.48, 1.04, 1.3287, 0.0097, 1.4536, 0.0137, -1, -1, 1.5188, 0.007, 1.2313, 0.0133],
(-100, 150) : ['B', 7, 122.38, 1.08, -1, -1, 112.04, 2.02, -1, -1, 121.23, 1.08, 115.52, 1.46, 123.21, 1.2, 1.3287, 0.0139, 1.4487, 0.0118, -1, -1, 1.5175, 0.01, 1.2288, 0.0147],
(-100, 160) : ['B', 4, 122.15, 1.17, -1, -1, 112.51, 1.9, -1, -1, 121.58, 1.5, 115.24, 1.4, 123.13, 1.49, 1.3324, 0.0191, 1.4441, 0.0106, -1, -1, 1.5177, 0.0156, 1.2287, 0.0143],
(-100, 170) : ['B', 4, 122.16, 1.14, -1, -1, 112.51, 1.71, -1, -1, 122.2, 1.7, 114.74, 1.13, 123.03, 1.46, 1.3333, 0.017, 1.4448, 0.0101, -1, -1, 1.5225, 0.0169, 1.2278, 0.0142],
(-90, -180) : ['B', 8, 121.83, 1.18, -1, -1, 112.6, 1.53, -1, -1, 122.36, 1.38, 114.78, 1.16, 122.84, 1.32, 1.3343, 0.0152, 1.4463, 0.0113, -1, -1, 1.5186, 0.0167, 1.2302, 0.0121],
(-90, -170) : ['B', 9, 122.27, 0.99, -1, -1, 112.41, 1.5, -1, -1, 122.28, 1.0, 114.81, 1.16, 122.88, 0.95, 1.3317, 0.0129, 1.4463, 0.0106, -1, -1, 1.5168, 0.0133, 1.2324, 0.0091],
(-90, -160) : ['B', 11, 122.55, 1.1, -1, -1, 112.55, 1.76, -1, -1, 121.92, 1.05, 115.06, 1.23, 122.96, 0.99, 1.3286, 0.0162, 1.4472, 0.0123, -1, -1, 1.5138, 0.0135, 1.2336, 0.0098],
(-90, -150) : ['B', 4, 122.75, 1.28, -1, -1, 112.77, 1.74, -1, -1, 121.64, 1.04, 115.44, 1.28, 122.85, 1.2, 1.326, 0.0163, 1.4496, 0.0143, -1, -1, 1.5122, 0.013, 1.2351, 0.0116],
(-90, -10) : ['B', 7, 121.82, 2.3, -1, -1, 115.66, 1.56, -1, -1, 119.59, 1.66, 117.97, 1.62, 122.42, 1.59, 1.3326, 0.0162, 1.4486, 0.0134, -1, -1, 1.5096, 0.0182, 1.2344, 0.0136],
(-90, 0) : ['B', 21, 122.46, 2.7, -1, -1, 115.62, 1.71, -1, -1, 119.55, 1.85, 118.24, 1.65, 122.18, 1.51, 1.3299, 0.0161, 1.4458, 0.0137, -1, -1, 1.5098, 0.0167, 1.235, 0.0128],
(-90, 10) : ['B', 9, 122.78, 2.61, -1, -1, 115.34, 1.67, -1, -1, 119.34, 1.75, 118.36, 1.46, 122.27, 1.37, 1.3289, 0.015, 1.4461, 0.0133, -1, -1, 1.5121, 0.0137, 1.2355, 0.0111],
(-90, 130) : ['B', 5, 121.62, 0.96, -1, -1, 111.31, 1.95, -1, -1, 120.76, 0.81, 115.86, 1.13, 123.35, 0.74, 1.332, 0.0066, 1.4507, 0.0136, -1, -1, 1.5152, 0.0109, 1.2339, 0.0105],
(-90, 140) : ['B', 3, 121.57, 0.97, -1, -1, 111.62, 1.77, -1, -1, 121.18, 0.88, 115.43, 1.22, 123.35, 1.0, 1.3307, 0.01, 1.452, 0.0159, -1, -1, 1.5204, 0.0099, 1.2294, 0.0134],
(-90, 150) : ['B', 5, 121.45, 1.06, -1, -1, 112.54, 1.79, -1, -1, 121.53, 1.26, 115.32, 1.42, 123.11, 1.41, 1.33, 0.0158, 1.448, 0.0156, -1, -1, 1.5187, 0.0125, 1.2281, 0.0163],
(-90, 160) : ['B', 5, 121.13, 1.35, -1, -1, 113.02, 1.59, -1, -1, 121.71, 2.04, 115.17, 1.43, 123.07, 2.05, 1.3342, 0.0254, 1.4448, 0.0133, -1, -1, 1.5183, 0.0201, 1.2294, 0.0164],
(-90, 170) : ['B', 9, 121.3, 1.44, -1, -1, 112.89, 1.58, -1, -1, 121.99, 2.06, 114.96, 1.15, 123.02, 1.98, 1.3358, 0.0246, 1.4469, 0.0117, -1, -1, 1.5191, 0.0215, 1.2295, 0.0157],
(-80, -180) : ['B', 13, 121.67, 1.43, -1, -1, 112.66, 1.62, -1, -1, 122.51, 1.41, 114.75, 1.26, 122.71, 1.26, 1.3316, 0.0154, 1.4455, 0.013, -1, -1, 1.5165, 0.0175, 1.2309, 0.0117],
(-80, -170) : ['B', 11, 121.96, 1.38, -1, -1, 112.31, 1.59, -1, -1, 122.47, 1.08, 114.66, 1.37, 122.81, 0.86, 1.3296, 0.0131, 1.4457, 0.0123, -1, -1, 1.5171, 0.0143, 1.2321, 0.0094],
(-80, -160) : ['B', 10, 122.04, 1.44, -1, -1, 112.27, 1.86, -1, -1, 122.03, 1.15, 114.96, 1.49, 122.92, 0.91, 1.3294, 0.0167, 1.4471, 0.0113, -1, -1, 1.515, 0.0127, 1.2336, 0.0099],
(-80, -150) : ['B', 3, 122.19, 1.22, -1, -1, 112.64, 1.91, -1, -1, 121.67, 1.08, 115.5, 1.45, 122.77, 1.03, 1.3308, 0.0168, 1.4503, 0.0104, -1, -1, 1.513, 0.0122, 1.2368, 0.0123],
(-80, -30) : ['B', 4, 120.34, 1.26, -1, -1, 113.86, 1.5, -1, -1, 120.09, 1.07, 117.55, 1.11, 122.34, 1.15, 1.3351, 0.0119, 1.4517, 0.0125, -1, -1, 1.5124, 0.0127, 1.235, 0.0118],
(-80, -20) : ['B', 11, 120.79, 1.75, -1, -1, 114.66, 1.24, -1, -1, 119.45, 1.18, 117.82, 1.24, 122.71, 1.26, 1.3358, 0.0132, 1.4518, 0.0137, -1, -1, 1.5123, 0.0139, 1.2351, 0.0114],
(-80, -10) : ['B', 10, 121.34, 2.32, -1, -1, 115.32, 1.31, -1, -1, 119.31, 1.6, 117.98, 1.54, 122.68, 1.41, 1.3329, 0.0157, 1.4505, 0.0157, -1, -1, 1.5119, 0.0167, 1.2347, 0.0123],
(-80, 0) : ['B', 19, 122.06, 2.79, -1, -1, 115.73, 1.59, -1, -1, 119.54, 1.94, 118.17, 1.75, 122.26, 1.49, 1.3308, 0.0175, 1.4473, 0.0158, -1, -1, 1.5097, 0.0166, 1.2341, 0.0125],
(-80, 10) : ['B', 3, 122.46, 2.9, -1, -1, 115.66, 1.63, -1, -1, 119.54, 1.92, 118.23, 1.65, 122.19, 1.41, 1.3313, 0.0179, 1.4462, 0.0152, -1, -1, 1.5099, 0.014, 1.2336, 0.0114],
(-80, 130) : ['B', 4, 120.92, 1.15, -1, -1, 111.15, 1.76, -1, -1, 120.89, 0.92, 116.07, 1.12, 122.99, 0.86, 1.3319, 0.0086, 1.4536, 0.015, -1, -1, 1.5169, 0.0161, 1.2357, 0.0101],
(-80, 140) : ['B', 6, 120.71, 1.13, -1, -1, 111.64, 1.57, -1, -1, 121.64, 0.92, 115.33, 1.15, 122.96, 1.02, 1.3313, 0.011, 1.4532, 0.0177, -1, -1, 1.5212, 0.0128, 1.2308, 0.0111],
(-80, 150) : ['B', 10, 120.6, 1.01, -1, -1, 112.37, 1.4, -1, -1, 121.94, 1.19, 115.18, 1.36, 122.81, 1.37, 1.3315, 0.0146, 1.4487, 0.0168, -1, -1, 1.5177, 0.0118, 1.2304, 0.0138],
(-80, 160) : ['B', 16, 120.64, 1.26, -1, -1, 112.82, 1.38, -1, -1, 122.14, 1.76, 115.01, 1.45, 122.8, 1.84, 1.3335, 0.0214, 1.4451, 0.0139, -1, -1, 1.517, 0.0167, 1.2306, 0.0151],
(-80, 170) : ['B', 19, 121.05, 1.54, -1, -1, 112.85, 1.61, -1, -1, 122.27, 1.9, 114.88, 1.31, 122.82, 1.84, 1.3332, 0.0226, 1.4459, 0.013, -1, -1, 1.517, 0.0196, 1.2307, 0.0147],
(-70, -180) : ['B', 8, 121.54, 1.43, -1, -1, 112.3, 1.68, -1, -1, 122.75, 1.27, 114.62, 1.38, 122.59, 1.03, 1.3284, 0.0134, 1.4457, 0.0139, -1, -1, 1.5182, 0.0166, 1.2316, 0.0107],
(-70, -170) : ['B', 3, 121.48, 1.78, -1, -1, 111.98, 1.63, -1, -1, 122.76, 1.12, 114.4, 1.57, 122.71, 0.78, 1.328, 0.0113, 1.4444, 0.0134, -1, -1, 1.5194, 0.0147, 1.2319, 0.0092],
(-70, -50) : ['B', 16, 119.94, 1.09, -1, -1, 112.49, 1.21, -1, -1, 120.9, 1.12, 116.89, 1.06, 122.19, 0.96, 1.3337, 0.0114, 1.4542, 0.0123, -1, -1, 1.5171, 0.0108, 1.2343, 0.0121],
(-70, -40) : ['B', 74, 120.0, 1.1, -1, -1, 112.77, 1.28, -1, -1, 120.66, 1.06, 117.13, 1.03, 122.19, 0.97, 1.3339, 0.0121, 1.4534, 0.0124, -1, -1, 1.5166, 0.0114, 1.2342, 0.0119],
(-70, -30) : ['B', 35, 120.22, 1.27, -1, -1, 113.37, 1.34, -1, -1, 120.3, 1.1, 117.4, 1.02, 122.28, 1.09, 1.3346, 0.0126, 1.4521, 0.0126, -1, -1, 1.5147, 0.0125, 1.2346, 0.0123],
(-70, -20) : ['B', 35, 120.79, 1.78, -1, -1, 114.16, 1.21, -1, -1, 119.5, 1.18, 117.8, 1.11, 122.68, 1.13, 1.3347, 0.012, 1.4519, 0.014, -1, -1, 1.5137, 0.0141, 1.2355, 0.0121],
(-70, -10) : ['B', 22, 121.19, 2.23, -1, -1, 114.67, 1.1, -1, -1, 119.01, 1.3, 118.13, 1.3, 122.84, 1.16, 1.3328, 0.0131, 1.4519, 0.0164, -1, -1, 1.514, 0.016, 1.2359, 0.0108],
(-70, 0) : ['B', 4, 121.6, 2.51, -1, -1, 115.31, 1.24, -1, -1, 119.15, 1.6, 118.34, 1.54, 122.48, 1.34, 1.3318, 0.0169, 1.4497, 0.0174, -1, -1, 1.512, 0.0166, 1.2346, 0.011],
(-70, 120) : ['B', 4, 120.98, 0.9, -1, -1, 110.97, 1.56, -1, -1, 120.3, 0.83, 117.06, 1.08, 122.62, 0.71, 1.3308, 0.0089, 1.4502, 0.0138, -1, -1, 1.516, 0.0163, 1.2427, 0.0093],
(-70, 130) : ['B', 4, 120.43, 1.06, -1, -1, 111.03, 1.4, -1, -1, 120.98, 0.94, 116.19, 1.13, 122.77, 0.88, 1.3301, 0.0085, 1.4538, 0.0122, -1, -1, 1.5179, 0.0146, 1.237, 0.0097],
(-70, 140) : ['B', 15, 120.31, 1.02, -1, -1, 111.54, 1.36, -1, -1, 121.58, 0.9, 115.51, 1.17, 122.84, 1.03, 1.33, 0.0102, 1.4516, 0.0137, -1, -1, 1.5191, 0.0115, 1.232, 0.0103],
(-70, 150) : ['B', 20, 120.34, 0.95, -1, -1, 112.14, 1.29, -1, -1, 121.9, 1.08, 115.27, 1.34, 122.76, 1.27, 1.3304, 0.0126, 1.4487, 0.0139, -1, -1, 1.5168, 0.0096, 1.2312, 0.0133],
(-70, 160) : ['B', 23, 120.53, 1.13, -1, -1, 112.54, 1.28, -1, -1, 122.31, 1.34, 114.95, 1.5, 122.69, 1.48, 1.3309, 0.0153, 1.4463, 0.0132, -1, -1, 1.5162, 0.0118, 1.2316, 0.0145],
(-70, 170) : ['B', 13, 121.01, 1.42, -1, -1, 112.51, 1.53, -1, -1, 122.62, 1.46, 114.74, 1.51, 122.61, 1.4, 1.329, 0.0167, 1.4467, 0.0136, -1, -1, 1.517, 0.0155, 1.2318, 0.0133],
(-60, -50) : ['B', 38, 119.94, 1.11, -1, -1, 112.5, 1.16, -1, -1, 121.0, 1.08, 116.81, 1.0, 122.18, 0.96, 1.3339, 0.0123, 1.4542, 0.0124, -1, -1, 1.5162, 0.0109, 1.2335, 0.0121],
(-60, -40) : ['B', 119, 119.98, 1.11, -1, -1, 112.73, 1.2, -1, -1, 120.75, 1.03, 117.04, 0.99, 122.19, 0.96, 1.334, 0.0132, 1.4536, 0.0129, -1, -1, 1.5164, 0.0112, 1.2335, 0.012],
(-60, -30) : ['B', 44, 120.14, 1.25, -1, -1, 113.24, 1.31, -1, -1, 120.4, 1.08, 117.34, 1.01, 122.24, 1.06, 1.3344, 0.0142, 1.4524, 0.0134, -1, -1, 1.5152, 0.0122, 1.234, 0.0129],
(-60, -20) : ['B', 18, 120.74, 1.72, -1, -1, 113.99, 1.28, -1, -1, 119.65, 1.18, 117.79, 1.12, 122.54, 1.1, 1.3342, 0.0127, 1.4518, 0.0142, -1, -1, 1.5138, 0.014, 1.2357, 0.0135],
(-60, -10) : ['B', 9, 121.17, 2.11, -1, -1, 114.4, 1.11, -1, -1, 119.09, 1.2, 118.17, 1.26, 122.73, 1.12, 1.3333, 0.0116, 1.4528, 0.0156, -1, -1, 1.5147, 0.0158, 1.2367, 0.0107],
(-60, 140) : ['B', 6, 119.92, 0.96, -1, -1, 111.36, 1.17, -1, -1, 121.41, 0.88, 115.61, 1.15, 122.93, 0.99, 1.3301, 0.0088, 1.4522, 0.0105, -1, -1, 1.5186, 0.0097, 1.2332, 0.0102],
(-60, 150) : ['B', 5, 120.1, 0.95, -1, -1, 111.93, 1.15, -1, -1, 121.71, 1.14, 115.32, 1.26, 122.91, 1.23, 1.3308, 0.012, 1.4501, 0.0119, -1, -1, 1.5164, 0.0089, 1.2326, 0.0139],
(-60, 160) : ['B', 6, 120.44, 1.09, -1, -1, 112.33, 1.1, -1, -1, 122.24, 1.3, 114.88, 1.47, 122.82, 1.33, 1.3306, 0.0137, 1.4487, 0.0123, -1, -1, 1.5163, 0.0107, 1.2322, 0.015],
(-60, 170) : ['B', 3, 121.06, 1.3, -1, -1, 112.25, 1.34, -1, -1, 122.82, 1.29, 114.54, 1.55, 122.6, 1.13, 1.3276, 0.0143, 1.4496, 0.0135, -1, -1, 1.5175, 0.0148, 1.2307, 0.0122],
(-50, -50) : ['B', 3, 119.99, 1.13, -1, -1, 112.64, 1.21, -1, -1, 121.05, 1.03, 116.81, 0.99, 122.13, 0.99, 1.3338, 0.0127, 1.4545, 0.0122, -1, -1, 1.5147, 0.0115, 1.2332, 0.0117],
(-50, -40) : ['B', 13, 120.03, 1.12, -1, -1, 112.83, 1.22, -1, -1, 120.8, 0.98, 117.02, 0.98, 122.17, 0.97, 1.3335, 0.0143, 1.4536, 0.0133, -1, -1, 1.5152, 0.0118, 1.2333, 0.012],
(-50, -30) : ['B', 4, 120.13, 1.26, -1, -1, 113.27, 1.33, -1, -1, 120.45, 1.02, 117.34, 1.04, 122.19, 1.03, 1.3332, 0.0162, 1.4522, 0.0146, -1, -1, 1.5147, 0.0121, 1.2343, 0.0141],
(50, -150) : ['B', 3, 120.73, 3.48, -1, -1, 111.78, 1.69, -1, -1, 122.0, 1.57, 115.34, 1.43, 122.6, 1.04, 1.3287, 0.0128, 1.4467, 0.0193, -1, -1, 1.5137, 0.0126, 1.235, 0.0166],
(50, -140) : ['B', 13, 120.07, 1.98, -1, -1, 111.73, 1.73, -1, -1, 121.56, 1.25, 115.74, 1.31, 122.67, 1.17, 1.3294, 0.0126, 1.451, 0.0148, -1, -1, 1.5117, 0.0152, 1.2363, 0.0147],
(50, -130) : ['B', 13, 120.07, 1.61, -1, -1, 111.34, 1.82, -1, -1, 121.44, 1.26, 116.01, 1.54, 122.52, 1.46, 1.3289, 0.0138, 1.4531, 0.0132, -1, -1, 1.5131, 0.0167, 1.237, 0.0138],
(50, 40) : ['B', 3, 120.11, 1.51, -1, -1, 113.48, 1.46, -1, -1, 120.29, 1.3, 117.19, 1.19, 122.51, 0.81, 1.3282, 0.01, 1.4578, 0.0147, -1, -1, 1.511, 0.0102, 1.2378, 0.0113],
(60, -170) : ['B', 3, 120.42, 3.34, -1, -1, 112.44, 2.44, -1, -1, 122.74, 1.3, 113.98, 1.54, 123.17, 1.12, 1.3297, 0.0186, 1.4467, 0.0232, -1, -1, 1.5239, 0.0167, 1.2291, 0.0168],
(60, -160) : ['B', 8, 120.05, 4.05, -1, -1, 112.01, 2.34, -1, -1, 122.39, 1.34, 114.53, 1.61, 122.96, 1.22, 1.3298, 0.0159, 1.4453, 0.0235, -1, -1, 1.5225, 0.0163, 1.2335, 0.0152],
(60, -150) : ['B', 12, 120.44, 3.25, -1, -1, 111.8, 1.82, -1, -1, 122.06, 1.39, 115.26, 1.49, 122.6, 1.07, 1.33, 0.0133, 1.4475, 0.0188, -1, -1, 1.5171, 0.0131, 1.2358, 0.0152],
(60, -140) : ['B', 22, 120.07, 1.95, -1, -1, 111.5, 1.74, -1, -1, 121.68, 1.26, 115.66, 1.42, 122.61, 1.13, 1.3302, 0.0131, 1.4519, 0.0152, -1, -1, 1.5144, 0.0135, 1.2362, 0.0134],
(60, -130) : ['B', 31, 120.0, 1.63, -1, -1, 111.02, 1.86, -1, -1, 121.51, 1.32, 115.91, 1.62, 122.55, 1.38, 1.3292, 0.0149, 1.4534, 0.0141, -1, -1, 1.5151, 0.0152, 1.2361, 0.0128],
(60, -120) : ['B', 5, 120.25, 1.69, -1, -1, 110.77, 1.93, -1, -1, 121.46, 1.38, 116.15, 1.78, 122.36, 1.61, 1.3263, 0.0164, 1.4531, 0.014, -1, -1, 1.5157, 0.0159, 1.2372, 0.0146],
(60, 20) : ['B', 5, 120.77, 1.94, -1, -1, 114.61, 1.49, -1, -1, 119.69, 1.27, 117.95, 1.34, 122.31, 1.14, 1.331, 0.013, 1.4501, 0.0144, -1, -1, 1.5099, 0.0146, 1.2337, 0.0143],
(60, 30) : ['B', 14, 120.77, 1.74, -1, -1, 114.1, 1.51, -1, -1, 119.8, 1.21, 117.75, 1.26, 122.41, 0.98, 1.3306, 0.0121, 1.4526, 0.0143, -1, -1, 1.5111, 0.0125, 1.2357, 0.0131],
(60, 40) : ['B', 9, 120.66, 1.89, -1, -1, 113.76, 1.8, -1, -1, 120.03, 1.2, 117.38, 1.22, 122.57, 0.91, 1.3291, 0.01, 1.4545, 0.0145, -1, -1, 1.5126, 0.0106, 1.2375, 0.0112],
(70, -180) : ['B', 7, 121.44, 1.45, -1, -1, 112.22, 1.83, -1, -1, 122.61, 1.28, 114.56, 1.56, 122.77, 0.95, 1.329, 0.0163, 1.4497, 0.0145, -1, -1, 1.5196, 0.015, 1.2301, 0.0158],
(70, -170) : ['B', 10, 120.99, 2.31, -1, -1, 112.45, 2.1, -1, -1, 122.58, 1.42, 114.28, 1.56, 123.05, 1.03, 1.3298, 0.0193, 1.4467, 0.0189, -1, -1, 1.5215, 0.0153, 1.2318, 0.0181],
(70, -160) : ['B', 15, 120.36, 2.89, -1, -1, 112.17, 2.16, -1, -1, 122.33, 1.32, 114.62, 1.55, 122.95, 1.15, 1.331, 0.0176, 1.4474, 0.0199, -1, -1, 1.5219, 0.0149, 1.2343, 0.0174],
(70, -150) : ['B', 12, 120.28, 2.48, -1, -1, 112.02, 1.86, -1, -1, 122.01, 1.19, 115.24, 1.49, 122.67, 1.1, 1.3321, 0.0143, 1.449, 0.0168, -1, -1, 1.5198, 0.0128, 1.2348, 0.0144],
(70, -140) : ['B', 5, 120.07, 1.66, -1, -1, 111.47, 1.72, -1, -1, 121.67, 1.24, 115.65, 1.54, 122.62, 1.11, 1.3311, 0.0131, 1.4532, 0.0158, -1, -1, 1.5168, 0.0129, 1.2361, 0.0123],
(70, -130) : ['B', 8, 119.98, 1.51, -1, -1, 110.86, 1.84, -1, -1, 121.4, 1.4, 115.98, 1.73, 122.58, 1.25, 1.3284, 0.015, 1.4544, 0.0161, -1, -1, 1.5155, 0.0149, 1.2362, 0.0127],
(70, -10) : ['B', 3, 122.16, 1.73, -1, -1, 115.59, 1.32, -1, -1, 118.95, 0.99, 118.79, 1.21, 122.23, 1.19, 1.3328, 0.0137, 1.4469, 0.016, -1, -1, 1.511, 0.0145, 1.2374, 0.0145],
(70, 0) : ['B', 12, 121.78, 1.98, -1, -1, 115.47, 1.31, -1, -1, 119.0, 1.12, 118.62, 1.29, 122.34, 1.27, 1.3314, 0.014, 1.4469, 0.0153, -1, -1, 1.5115, 0.0135, 1.2365, 0.0138],
(70, 10) : ['B', 40, 121.18, 2.19, -1, -1, 115.3, 1.44, -1, -1, 119.25, 1.28, 118.36, 1.35, 122.35, 1.33, 1.3314, 0.0135, 1.4484, 0.0153, -1, -1, 1.5103, 0.0139, 1.2346, 0.0135],
(70, 20) : ['B', 51, 120.8, 1.98, -1, -1, 114.9, 1.54, -1, -1, 119.58, 1.3, 118.04, 1.34, 122.34, 1.22, 1.3311, 0.0129, 1.4487, 0.0144, -1, -1, 1.5101, 0.0145, 1.2335, 0.0145],
(70, 30) : ['B', 39, 120.87, 1.79, -1, -1, 114.48, 1.66, -1, -1, 119.72, 1.22, 117.82, 1.28, 122.41, 1.08, 1.3303, 0.0123, 1.4502, 0.0138, -1, -1, 1.5114, 0.014, 1.235, 0.0147],
(70, 40) : ['B', 7, 121.06, 2.04, -1, -1, 114.16, 2.0, -1, -1, 119.82, 1.14, 117.61, 1.2, 122.54, 1.02, 1.3286, 0.0109, 1.4526, 0.015, -1, -1, 1.5132, 0.0123, 1.2378, 0.0132],
(80, -180) : ['B', 10, 121.45, 1.54, -1, -1, 112.58, 1.8, -1, -1, 122.65, 1.28, 114.62, 1.66, 122.68, 1.07, 1.3309, 0.0175, 1.4474, 0.0136, -1, -1, 1.5166, 0.0158, 1.2323, 0.015],
(80, -170) : ['B', 13, 121.32, 1.79, -1, -1, 112.62, 1.87, -1, -1, 122.52, 1.55, 114.51, 1.67, 122.91, 0.95, 1.3292, 0.0195, 1.4457, 0.0173, -1, -1, 1.5175, 0.0135, 1.2347, 0.0169],
(80, -160) : ['B', 15, 121.01, 1.86, -1, -1, 112.37, 1.84, -1, -1, 122.28, 1.55, 114.75, 1.6, 122.9, 0.95, 1.33, 0.0181, 1.4476, 0.017, -1, -1, 1.519, 0.0119, 1.2358, 0.0174],
(80, -150) : ['B', 6, 120.65, 1.54, -1, -1, 112.22, 1.74, -1, -1, 121.83, 1.26, 115.25, 1.43, 122.86, 0.97, 1.3313, 0.0148, 1.4501, 0.0144, -1, -1, 1.5204, 0.0106, 1.2323, 0.0143],
(80, -130) : ['B', 3, 120.42, 1.13, -1, -1, 110.95, 1.7, -1, -1, 120.89, 1.21, 116.16, 1.66, 122.9, 1.17, 1.327, 0.0158, 1.4551, 0.0162, -1, -1, 1.5109, 0.0178, 1.2339, 0.0182],
(80, -50) : ['B', 4, 121.34, 2.35, -1, -1, 115.86, 2.77, -1, -1, 120.12, 1.37, 117.53, 1.11, 122.31, 1.16, 1.3257, 0.0141, 1.4626, 0.0201, -1, -1, 1.511, 0.0219, 1.2343, 0.0098],
(80, -20) : ['B', 10, 122.28, 1.49, -1, -1, 115.42, 1.27, -1, -1, 119.2, 0.99, 118.52, 1.22, 122.25, 1.25, 1.3335, 0.0141, 1.4458, 0.0153, -1, -1, 1.5121, 0.0141, 1.237, 0.0146],
(80, -10) : ['B', 40, 122.09, 1.69, -1, -1, 115.4, 1.32, -1, -1, 119.04, 1.06, 118.65, 1.2, 122.28, 1.29, 1.3328, 0.0143, 1.4463, 0.0158, -1, -1, 1.512, 0.0149, 1.238, 0.0145],
(80, 0) : ['B', 72, 121.93, 1.94, -1, -1, 115.36, 1.33, -1, -1, 119.02, 1.11, 118.55, 1.22, 122.39, 1.27, 1.3314, 0.0146, 1.4465, 0.0154, -1, -1, 1.5122, 0.014, 1.2378, 0.0138],
(80, 10) : ['B', 79, 121.53, 1.97, -1, -1, 115.3, 1.39, -1, -1, 119.13, 1.22, 118.42, 1.26, 122.41, 1.25, 1.3309, 0.014, 1.4476, 0.0151, -1, -1, 1.5107, 0.0134, 1.2363, 0.013],
(80, 20) : ['B', 61, 121.07, 1.79, -1, -1, 115.08, 1.54, -1, -1, 119.44, 1.3, 118.2, 1.27, 122.32, 1.24, 1.3309, 0.0132, 1.4484, 0.0143, -1, -1, 1.5097, 0.0138, 1.2348, 0.0134],
(80, 30) : ['B', 15, 120.91, 1.62, -1, -1, 114.76, 1.7, -1, -1, 119.68, 1.25, 117.94, 1.22, 122.33, 1.17, 1.3304, 0.0127, 1.449, 0.0133, -1, -1, 1.5105, 0.0141, 1.2352, 0.0145],
(80, 40) : ['B', 3, 121.0, 1.7, -1, -1, 114.46, 1.81, -1, -1, 119.88, 1.17, 117.74, 1.11, 122.34, 1.17, 1.3286, 0.0116, 1.4502, 0.0141, -1, -1, 1.5119, 0.0131, 1.2376, 0.0146],
(80, 160) : ['B', 3, 121.87, 1.64, -1, -1, 112.65, 1.3, -1, -1, 122.39, 0.93, 114.88, 1.27, 122.7, 1.06, 1.3263, 0.0132, 1.4457, 0.0126, -1, -1, 1.5191, 0.0101, 1.2303, 0.0129],
(80, 170) : ['B', 9, 121.85, 1.24, -1, -1, 112.61, 1.6, -1, -1, 122.59, 1.04, 114.77, 1.47, 122.6, 1.05, 1.3298, 0.0142, 1.4464, 0.0111, -1, -1, 1.5178, 0.0137, 1.2322, 0.0143],
(90, -180) : ['B', 7, 121.57, 1.67, -1, -1, 112.83, 1.7, -1, -1, 122.78, 1.2, 114.49, 1.69, 122.68, 1.23, 1.3308, 0.0184, 1.448, 0.0135, -1, -1, 1.5146, 0.0159, 1.2345, 0.013],
(90, -170) : ['B', 13, 121.39, 1.72, -1, -1, 112.77, 1.81, -1, -1, 122.71, 1.55, 114.38, 1.7, 122.86, 1.0, 1.3275, 0.018, 1.4473, 0.0168, -1, -1, 1.5144, 0.0131, 1.235, 0.0136],
(90, -160) : ['B', 9, 121.42, 1.55, -1, -1, 112.53, 1.76, -1, -1, 122.43, 1.69, 114.64, 1.6, 122.88, 0.83, 1.3273, 0.0157, 1.4484, 0.017, -1, -1, 1.5167, 0.0114, 1.2348, 0.0134],
(90, -130) : ['B', 3, 121.31, 0.94, -1, -1, 111.24, 1.49, -1, -1, 120.53, 0.9, 116.23, 1.22, 123.19, 0.98, 1.3264, 0.0153, 1.454, 0.0125, -1, -1, 1.5154, 0.0165, 1.2312, 0.021],
(90, -120) : ['B', 3, 121.72, 1.51, -1, -1, 111.35, 1.2, -1, -1, 120.15, 1.41, 116.36, 1.06, 123.41, 0.81, 1.3199, 0.0198, 1.4604, 0.0126, -1, -1, 1.5237, 0.0133, 1.2291, 0.0263],
(90, -110) : ['B', 3, 121.71, 1.82, -1, -1, 111.67, 0.92, -1, -1, 120.15, 1.83, 116.19, 1.03, 123.52, 0.74, 1.3233, 0.0217, 1.4643, 0.0112, -1, -1, 1.5305, 0.0104, 1.2271, 0.0259],
(90, -50) : ['B', 3, 122.0, 2.13, -1, -1, 115.33, 2.74, -1, -1, 120.36, 1.3, 117.05, 1.3, 122.54, 1.25, 1.3206, 0.0153, 1.4596, 0.0187, -1, -1, 1.5133, 0.0223, 1.2302, 0.0108],
(90, -40) : ['B', 4, 122.97, 1.84, -1, -1, 114.74, 2.54, -1, -1, 120.25, 1.43, 117.2, 1.63, 122.5, 0.94, 1.3279, 0.0122, 1.4538, 0.0179, -1, -1, 1.515, 0.0205, 1.2327, 0.0113],
(90, -30) : ['B', 5, 122.86, 1.62, -1, -1, 114.67, 1.41, -1, -1, 119.59, 1.11, 117.84, 1.37, 122.52, 1.06, 1.3325, 0.0136, 1.444, 0.0181, -1, -1, 1.5159, 0.0129, 1.2354, 0.0145],
(90, -20) : ['B', 24, 122.46, 1.46, -1, -1, 115.08, 1.19, -1, -1, 119.27, 1.04, 118.24, 1.26, 122.46, 1.23, 1.3327, 0.0156, 1.4438, 0.0161, -1, -1, 1.5141, 0.0133, 1.2362, 0.0146],
(90, -10) : ['B', 75, 122.2, 1.59, -1, -1, 115.21, 1.3, -1, -1, 119.1, 1.09, 118.46, 1.21, 122.42, 1.31, 1.3326, 0.0157, 1.4455, 0.0153, -1, -1, 1.5131, 0.0145, 1.2379, 0.0145],
(90, 0) : ['B', 79, 122.05, 1.81, -1, -1, 115.32, 1.38, -1, -1, 119.06, 1.12, 118.48, 1.17, 122.43, 1.27, 1.3313, 0.0153, 1.4463, 0.015, -1, -1, 1.5125, 0.0144, 1.2379, 0.0142],
(90, 10) : ['B', 55, 121.85, 1.76, -1, -1, 115.43, 1.41, -1, -1, 119.06, 1.15, 118.46, 1.15, 122.45, 1.17, 1.3298, 0.0142, 1.447, 0.0153, -1, -1, 1.5111, 0.0137, 1.2369, 0.0131],
(90, 20) : ['B', 23, 121.51, 1.52, -1, -1, 115.32, 1.48, -1, -1, 119.19, 1.22, 118.39, 1.18, 122.38, 1.19, 1.3298, 0.0133, 1.4481, 0.0147, -1, -1, 1.5101, 0.0136, 1.2363, 0.0126],
(90, 30) : ['B', 4, 121.26, 1.42, -1, -1, 115.08, 1.64, -1, -1, 119.46, 1.18, 118.19, 1.15, 122.3, 1.19, 1.3302, 0.0133, 1.4473, 0.0135, -1, -1, 1.51, 0.0131, 1.2366, 0.0127],
(90, 150) : ['B', 3, 120.92, 3.09, -1, -1, 112.48, 1.21, -1, -1, 122.24, 0.87, 115.13, 1.05, 122.56, 1.15, 1.324, 0.0149, 1.4545, 0.0154, -1, -1, 1.5149, 0.0108, 1.2307, 0.0126],
(90, 160) : ['B', 8, 121.92, 1.72, -1, -1, 112.68, 1.26, -1, -1, 122.29, 0.81, 114.88, 1.2, 122.78, 1.18, 1.3275, 0.0139, 1.4466, 0.0109, -1, -1, 1.5195, 0.0104, 1.2302, 0.0122],
(90, 170) : ['B', 9, 122.06, 1.45, -1, -1, 112.81, 1.48, -1, -1, 122.57, 0.92, 114.69, 1.43, 122.68, 1.15, 1.3298, 0.0149, 1.4462, 0.0108, -1, -1, 1.5184, 0.0135, 1.2333, 0.0124],
(100, -180) : ['B', 6, 122.21, 1.67, -1, -1, 112.17, 1.4, -1, -1, 122.56, 1.03, 114.36, 1.63, 123.02, 1.33, 1.3289, 0.0157, 1.4501, 0.0119, -1, -1, 1.5165, 0.0137, 1.235, 0.0105],
(100, -170) : ['B', 8, 122.0, 1.7, -1, -1, 112.45, 1.55, -1, -1, 122.59, 1.27, 114.38, 1.45, 122.98, 1.11, 1.3265, 0.0157, 1.4487, 0.0149, -1, -1, 1.5151, 0.0126, 1.2346, 0.0116],
(100, -160) : ['B', 5, 122.05, 1.57, -1, -1, 112.84, 1.58, -1, -1, 122.43, 1.39, 114.62, 1.26, 122.9, 0.86, 1.3258, 0.0125, 1.4466, 0.0168, -1, -1, 1.5152, 0.0112, 1.2333, 0.0115],
(100, -130) : ['B', 3, 121.86, 0.85, -1, -1, 111.45, 1.23, -1, -1, 120.64, 0.88, 116.25, 0.77, 123.08, 0.65, 1.3248, 0.012, 1.453, 0.0101, -1, -1, 1.523, 0.0119, 1.2305, 0.0168],
(100, -30) : ['B', 4, 123.31, 1.57, -1, -1, 114.25, 1.3, -1, -1, 119.55, 1.08, 117.76, 1.36, 122.65, 1.04, 1.3341, 0.0143, 1.4421, 0.0183, -1, -1, 1.5164, 0.0131, 1.2363, 0.0148],
(100, -20) : ['B', 20, 122.86, 1.46, -1, -1, 114.69, 1.19, -1, -1, 119.27, 1.07, 118.05, 1.34, 122.65, 1.13, 1.3321, 0.017, 1.4436, 0.016, -1, -1, 1.5148, 0.0132, 1.2366, 0.0149],
(100, -10) : ['B', 32, 122.51, 1.57, -1, -1, 114.92, 1.3, -1, -1, 119.07, 1.12, 118.31, 1.32, 122.6, 1.19, 1.3319, 0.0166, 1.4462, 0.0142, -1, -1, 1.5136, 0.0139, 1.2374, 0.0144],
(100, 0) : ['B', 27, 122.25, 1.64, -1, -1, 115.27, 1.41, -1, -1, 119.01, 1.11, 118.46, 1.22, 122.5, 1.18, 1.3314, 0.0151, 1.4469, 0.0139, -1, -1, 1.5125, 0.0143, 1.2371, 0.0141],
(100, 10) : ['B', 21, 122.1, 1.53, -1, -1, 115.64, 1.46, -1, -1, 118.96, 1.08, 118.51, 1.11, 122.5, 1.11, 1.329, 0.0136, 1.4464, 0.0149, -1, -1, 1.5117, 0.0143, 1.2363, 0.0137],
(100, 20) : ['B', 5, 122.0, 1.35, -1, -1, 115.72, 1.51, -1, -1, 118.86, 1.14, 118.55, 1.1, 122.55, 1.12, 1.3274, 0.0126, 1.446, 0.0151, -1, -1, 1.5124, 0.015, 1.2363, 0.0136],
(100, 30) : ['B', 3, 122.26, 1.34, -1, -1, 115.67, 1.59, -1, -1, 118.98, 1.06, 118.5, 0.99, 122.47, 1.11, 1.3268, 0.0123, 1.4431, 0.0138, -1, -1, 1.5117, 0.0144, 1.2362, 0.0133],
(100, 150) : ['B', 5, 121.6, 2.86, -1, -1, 112.18, 1.34, -1, -1, 121.88, 0.78, 115.53, 1.09, 122.47, 0.93, 1.3222, 0.0143, 1.448, 0.0119, -1, -1, 1.5171, 0.013, 1.2364, 0.0118],
(100, 160) : ['B', 5, 122.04, 2.18, -1, -1, 112.29, 1.12, -1, -1, 122.23, 0.69, 115.05, 1.26, 122.64, 1.16, 1.3269, 0.0137, 1.4458, 0.0102, -1, -1, 1.5206, 0.0121, 1.2336, 0.0126],
(100, 170) : ['B', 6, 122.43, 1.66, -1, -1, 112.33, 1.21, -1, -1, 122.52, 0.79, 114.55, 1.51, 122.87, 1.24, 1.3279, 0.0129, 1.4473, 0.0099, -1, -1, 1.5194, 0.0127, 1.2337, 0.0112],
(110, -180) : ['B', 9, 122.65, 1.62, -1, -1, 111.7, 1.28, -1, -1, 122.26, 0.99, 114.32, 1.46, 123.37, 1.23, 1.326, 0.0152, 1.4493, 0.0108, -1, -1, 1.5195, 0.011, 1.2322, 0.0095],
(110, -170) : ['B', 8, 122.66, 1.77, -1, -1, 111.76, 1.43, -1, -1, 122.24, 1.08, 114.63, 1.23, 123.1, 1.05, 1.3246, 0.0174, 1.4479, 0.0135, -1, -1, 1.5182, 0.0113, 1.2342, 0.0117],
(110, -160) : ['B', 3, 122.62, 1.7, -1, -1, 112.52, 1.37, -1, -1, 122.25, 0.99, 114.85, 0.95, 122.85, 0.95, 1.3245, 0.0141, 1.4451, 0.0154, -1, -1, 1.5158, 0.011, 1.2342, 0.0129],
(110, -30) : ['B', 4, 123.44, 1.19, -1, -1, 113.79, 1.17, -1, -1, 119.56, 0.87, 117.63, 1.17, 122.77, 0.94, 1.3356, 0.013, 1.4475, 0.014, -1, -1, 1.5165, 0.0134, 1.2375, 0.0136],
(110, -20) : ['B', 7, 123.08, 1.35, -1, -1, 114.37, 1.26, -1, -1, 119.27, 1.01, 118.14, 1.42, 122.56, 1.08, 1.3319, 0.0157, 1.4468, 0.0139, -1, -1, 1.5134, 0.0144, 1.2383, 0.0147],
(110, -10) : ['B', 15, 122.69, 1.59, -1, -1, 114.64, 1.4, -1, -1, 119.03, 1.14, 118.53, 1.55, 122.42, 1.14, 1.331, 0.0154, 1.449, 0.0135, -1, -1, 1.5121, 0.0149, 1.2379, 0.0141],
(110, 0) : ['B', 11, 122.4, 1.62, -1, -1, 115.0, 1.44, -1, -1, 118.97, 1.11, 118.69, 1.48, 122.33, 1.17, 1.332, 0.0139, 1.4495, 0.0133, -1, -1, 1.5125, 0.0149, 1.2369, 0.013],
(110, 10) : ['B', 4, 122.29, 1.42, -1, -1, 115.63, 1.49, -1, -1, 118.95, 1.0, 118.64, 1.24, 122.38, 1.16, 1.3298, 0.0128, 1.4469, 0.0138, -1, -1, 1.5139, 0.0169, 1.2367, 0.0137],
(110, 20) : ['B', 3, 122.63, 1.38, -1, -1, 116.01, 1.64, -1, -1, 118.77, 0.94, 118.67, 0.98, 122.51, 1.04, 1.3244, 0.0133, 1.4427, 0.0147, -1, -1, 1.5194, 0.0234, 1.2378, 0.0169],
(110, 140) : ['B', 3, 121.88, 2.93, -1, -1, 111.04, 2.24, -1, -1, 121.31, 1.14, 115.77, 1.13, 122.75, 0.99, 1.3221, 0.012, 1.4529, 0.0138, -1, -1, 1.518, 0.012, 1.2375, 0.0106],
(110, 150) : ['B', 5, 121.71, 3.1, -1, -1, 111.72, 1.31, -1, -1, 121.77, 0.86, 115.43, 0.98, 122.64, 0.84, 1.3205, 0.0142, 1.4468, 0.0118, -1, -1, 1.5192, 0.014, 1.2386, 0.0116],
(110, 160) : ['B', 8, 122.29, 2.29, -1, -1, 111.95, 0.95, -1, -1, 122.22, 0.65, 114.83, 1.19, 122.87, 1.04, 1.3237, 0.0127, 1.4459, 0.0097, -1, -1, 1.5216, 0.0128, 1.2345, 0.0127],
(110, 170) : ['B', 9, 122.69, 1.58, -1, -1, 112.04, 1.02, -1, -1, 122.45, 0.72, 114.29, 1.41, 123.21, 1.19, 1.3244, 0.0112, 1.4478, 0.009, -1, -1, 1.52, 0.0112, 1.2316, 0.0107],
(120, -180) : ['B', 3, 122.85, 1.47, -1, -1, 111.85, 1.2, -1, -1, 122.13, 0.89, 114.5, 1.16, 123.35, 0.95, 1.3254, 0.0129, 1.4475, 0.0118, -1, -1, 1.5163, 0.0105, 1.2302, 0.009],
(120, -170) : ['B', 6, 123.03, 1.83, -1, -1, 111.52, 1.31, -1, -1, 122.01, 0.97, 114.97, 1.17, 123.0, 0.99, 1.3257, 0.017, 1.4482, 0.0137, -1, -1, 1.5142, 0.0127, 1.2348, 0.0107],
(120, -150) : ['B', 3, 122.42, 1.36, -1, -1, 111.56, 1.01, -1, -1, 121.05, 1.22, 115.3, 0.82, 123.56, 1.41, 1.334, 0.0112, 1.4475, 0.0113, -1, -1, 1.5198, 0.0137, 1.2371, 0.007],
(120, -140) : ['B', 3, 122.63, 1.03, -1, -1, 111.21, 1.04, -1, -1, 120.89, 1.4, 115.64, 0.79, 123.39, 1.43, 1.3347, 0.0075, 1.4497, 0.011, -1, -1, 1.5223, 0.013, 1.2359, 0.0053],
(120, -30) : ['B', 4, 123.3, 1.06, -1, -1, 113.58, 1.07, -1, -1, 119.83, 0.85, 117.4, 0.96, 122.71, 0.8, 1.3351, 0.0098, 1.4533, 0.0106, -1, -1, 1.5163, 0.0098, 1.2354, 0.0118],
(120, -20) : ['B', 4, 123.08, 1.12, -1, -1, 114.48, 1.19, -1, -1, 119.37, 1.0, 118.37, 1.46, 122.22, 1.12, 1.3304, 0.0124, 1.451, 0.0129, -1, -1, 1.5137, 0.0129, 1.2396, 0.0133],
(120, -10) : ['B', 11, 122.63, 1.41, -1, -1, 114.85, 1.35, -1, -1, 119.04, 1.13, 119.12, 1.89, 121.83, 1.43, 1.3293, 0.0126, 1.4522, 0.0141, -1, -1, 1.5135, 0.0152, 1.2402, 0.0129],
(120, 0) : ['B', 5, 122.3, 1.59, -1, -1, 114.95, 1.41, -1, -1, 118.86, 1.07, 119.6, 2.08, 121.53, 1.62, 1.33, 0.0119, 1.4534, 0.0147, -1, -1, 1.5149, 0.0162, 1.2392, 0.0109],
(120, 130) : ['B', 3, 120.77, 3.53, -1, -1, 110.68, 2.8, -1, -1, 121.98, 1.3, 115.27, 1.2, 122.55, 1.3, 1.3292, 0.0108, 1.4627, 0.0207, -1, -1, 1.5158, 0.0069, 1.2307, 0.0147],
(120, 170) : ['B', 8, 122.63, 1.34, -1, -1, 112.08, 1.01, -1, -1, 122.37, 0.73, 114.13, 1.11, 123.48, 1.0, 1.325, 0.0094, 1.4483, 0.0088, -1, -1, 1.5185, 0.0102, 1.2297, 0.0094],
(130, -180) : ['B', 3, 122.92, 1.66, -1, -1, 111.63, 1.15, -1, -1, 122.16, 0.82, 114.75, 0.99, 123.06, 0.95, 1.328, 0.0124, 1.4458, 0.0134, -1, -1, 1.5119, 0.0122, 1.2297, 0.0093],
(130, -170) : ['B', 4, 123.46, 2.42, -1, -1, 110.97, 1.42, -1, -1, 121.76, 0.87, 115.48, 1.38, 122.7, 1.52, 1.3304, 0.0191, 1.4445, 0.0138, -1, -1, 1.5099, 0.0169, 1.2356, 0.011],
(130, -160) : ['B', 3, 123.12, 2.64, -1, -1, 110.6, 1.46, -1, -1, 121.3, 0.98, 115.47, 1.49, 123.16, 1.81, 1.333, 0.02, 1.444, 0.0119, -1, -1, 1.5116, 0.0169, 1.2362, 0.0102],
(130, 150) : ['B', 3, 122.01, 1.64, -1, -1, 111.71, 2.89, -1, -1, 121.66, 0.88, 115.62, 0.76, 122.65, 0.98, 1.3278, 0.0131, 1.4528, 0.0107, -1, -1, 1.5156, 0.0136, 1.2334, 0.0088],
(130, 170) : ['B', 6, 122.57, 1.39, -1, -1, 111.85, 1.06, -1, -1, 122.33, 0.81, 114.23, 0.88, 123.43, 0.85, 1.3267, 0.0081, 1.4487, 0.01, -1, -1, 1.516, 0.0106, 1.2293, 0.0082],
(140, -170) : ['B', 4, 122.82, 2.01, -1, -1, 110.46, 1.43, -1, -1, 121.55, 1.22, 115.41, 1.45, 122.99, 1.73, 1.3254, 0.02, 1.4437, 0.0123, -1, -1, 1.5118, 0.0158, 1.2301, 0.0125],
(140, -160) : ['B', 6, 122.66, 2.13, -1, -1, 110.43, 1.35, -1, -1, 121.12, 1.26, 115.46, 1.65, 123.36, 1.85, 1.326, 0.0183, 1.4437, 0.0132, -1, -1, 1.5121, 0.0157, 1.2298, 0.0128],
(140, 150) : ['B', 5, 122.54, 1.35, -1, -1, 111.07, 3.03, -1, -1, 121.91, 1.11, 115.74, 0.73, 122.3, 1.43, 1.3239, 0.0141, 1.4525, 0.0095, -1, -1, 1.5158, 0.0135, 1.232, 0.0119],
(140, 160) : ['B', 3, 122.64, 1.46, -1, -1, 111.01, 1.86, -1, -1, 122.14, 1.05, 115.34, 0.84, 122.47, 1.32, 1.3213, 0.0124, 1.451, 0.0091, -1, -1, 1.5163, 0.0126, 1.2312, 0.0121],
(150, -180) : ['B', 6, 121.56, 1.42, -1, -1, 110.56, 1.36, -1, -1, 121.86, 1.04, 114.52, 1.09, 123.58, 1.06, 1.3206, 0.013, 1.4493, 0.0098, -1, -1, 1.5146, 0.01, 1.2281, 0.0141],
(150, -170) : ['B', 5, 121.83, 1.3, -1, -1, 110.38, 1.42, -1, -1, 121.47, 1.15, 114.82, 1.23, 123.67, 1.38, 1.3224, 0.0155, 1.4464, 0.0112, -1, -1, 1.5152, 0.0118, 1.2277, 0.0136],
(150, -160) : ['B', 7, 121.97, 1.65, -1, -1, 110.38, 1.28, -1, -1, 121.02, 1.17, 115.0, 1.55, 123.93, 1.59, 1.3233, 0.0153, 1.4467, 0.0149, -1, -1, 1.5157, 0.0131, 1.227, 0.0143],
(150, -150) : ['B', 3, 122.07, 2.3, -1, -1, 110.29, 1.28, -1, -1, 120.79, 0.86, 115.05, 1.65, 124.12, 1.54, 1.3193, 0.0164, 1.4489, 0.0185, -1, -1, 1.5199, 0.0126, 1.2296, 0.0122],
(150, -140) : ['B', 3, 122.02, 1.93, -1, -1, 110.2, 1.32, -1, -1, 120.66, 0.46, 115.31, 1.28, 124.0, 1.19, 1.3189, 0.0144, 1.446, 0.02, -1, -1, 1.5239, 0.012, 1.2327, 0.0069],
(150, 150) : ['B', 3, 122.56, 1.88, -1, -1, 110.66, 2.18, -1, -1, 122.54, 1.52, 115.34, 0.81, 122.04, 2.02, 1.3188, 0.0134, 1.4504, 0.0116, -1, -1, 1.5168, 0.0152, 1.2274, 0.0157],
(150, 160) : ['B', 5, 122.27, 1.8, -1, -1, 111.0, 1.48, -1, -1, 122.39, 1.25, 115.11, 0.95, 122.42, 1.65, 1.3199, 0.0126, 1.4493, 0.0108, -1, -1, 1.5132, 0.0127, 1.2295, 0.0144],
(150, 170) : ['B', 9, 121.62, 1.55, -1, -1, 110.96, 1.19, -1, -1, 122.05, 1.0, 114.66, 1.1, 123.23, 1.1, 1.321, 0.0112, 1.4504, 0.0101, -1, -1, 1.5127, 0.0097, 1.2293, 0.0141],
(160, -180) : ['B', 13, 121.22, 1.44, -1, -1, 110.88, 1.48, -1, -1, 121.83, 1.02, 114.35, 1.22, 123.78, 0.97, 1.3232, 0.0109, 1.4476, 0.0092, -1, -1, 1.5129, 0.0101, 1.2313, 0.0142],
(160, -170) : ['B', 10, 121.23, 1.34, -1, -1, 110.63, 1.43, -1, -1, 121.48, 0.99, 114.53, 1.2, 123.96, 0.99, 1.3247, 0.0106, 1.4469, 0.0092, -1, -1, 1.5164, 0.0103, 1.2306, 0.0138],
(160, -160) : ['B', 4, 121.12, 1.59, -1, -1, 110.45, 1.3, -1, -1, 121.05, 0.9, 114.77, 1.29, 124.15, 1.12, 1.3268, 0.0111, 1.4506, 0.0123, -1, -1, 1.5192, 0.0126, 1.2292, 0.0139],
(160, -150) : ['B', 4, 121.28, 2.26, -1, -1, 110.58, 1.35, -1, -1, 120.91, 0.69, 114.89, 1.36, 124.15, 1.23, 1.3252, 0.0142, 1.4547, 0.0161, -1, -1, 1.5204, 0.0139, 1.2314, 0.013],
(160, 160) : ['B', 4, 121.67, 1.81, -1, -1, 111.37, 1.29, -1, -1, 122.15, 1.17, 114.86, 1.01, 122.91, 1.64, 1.3229, 0.012, 1.4476, 0.0112, -1, -1, 1.5086, 0.0121, 1.2324, 0.0139],
(160, 170) : ['B', 12, 121.32, 1.58, -1, -1, 111.09, 1.33, -1, -1, 121.96, 1.02, 114.53, 1.18, 123.46, 1.19, 1.3239, 0.0115, 1.4488, 0.0104, -1, -1, 1.5093, 0.0104, 1.2313, 0.0145],
(170, -180) : ['B', 13, 120.97, 1.51, -1, -1, 110.75, 1.46, -1, -1, 121.75, 1.02, 114.4, 1.35, 123.81, 1.0, 1.3262, 0.0113, 1.448, 0.0105, -1, -1, 1.5123, 0.011, 1.2352, 0.0141],
(170, -170) : ['B', 10, 120.91, 1.38, -1, -1, 110.69, 1.33, -1, -1, 121.35, 1.05, 114.71, 1.5, 123.92, 0.96, 1.3274, 0.0096, 1.4472, 0.0103, -1, -1, 1.5152, 0.01, 1.2333, 0.0138],
(170, -160) : ['B', 7, 120.72, 1.33, -1, -1, 110.74, 1.37, -1, -1, 120.97, 1.01, 115.12, 1.55, 123.88, 0.95, 1.3287, 0.0096, 1.4505, 0.011, -1, -1, 1.5157, 0.0121, 1.2322, 0.0131],
(170, -150) : ['B', 4, 120.55, 1.58, -1, -1, 111.42, 1.51, -1, -1, 121.04, 0.79, 115.11, 1.21, 123.8, 0.83, 1.3294, 0.0124, 1.4548, 0.0105, -1, -1, 1.5133, 0.0146, 1.2364, 0.0134],
(170, 170) : ['B', 8, 121.04, 1.57, -1, -1, 110.63, 1.45, -1, -1, 121.87, 1.02, 114.48, 1.19, 123.61, 1.15, 1.3263, 0.0125, 1.4493, 0.0124, -1, -1, 1.5099, 0.0118, 1.2347, 0.0138],
},
"Gly_xpro" : {
(-180, -180) : ['I', 44, 121.87, 1.57, -1, -1, 112.34, 2.04, -1, -1, 121.52, 1.43, 116.69, 1.71, 121.77, 1.0, 1.3304, 0.0149, 1.4426, 0.0137, -1, -1, 1.5146, 0.0143, 1.2351, 0.0135],
(-80, -180) : ['B', 6, 121.42, 1.44, -1, -1, 112.23, 1.21, -1, -1, 122.38, 1.03, 115.43, 1.17, 122.18, 1.0, 1.3325, 0.0182, 1.4421, 0.0136, -1, -1, 1.5123, 0.0151, 1.2387, 0.0168],
(-80, 170) : ['B', 3, 121.64, 1.53, -1, -1, 112.1, 1.23, -1, -1, 122.46, 0.97, 115.52, 1.13, 122.03, 1.14, 1.3283, 0.0207, 1.4443, 0.0154, -1, -1, 1.5111, 0.0133, 1.2412, 0.0176],
(-70, -180) : ['B', 3, 121.36, 1.28, -1, -1, 112.0, 1.2, -1, -1, 121.62, 1.05, 115.94, 1.16, 122.42, 0.9, 1.335, 0.0175, 1.4338, 0.0122, -1, -1, 1.5178, 0.0159, 1.2386, 0.0156],
(-60, -40) : ['B', 3, 120.88, 0.52, -1, -1, 115.22, 1.27, -1, -1, 119.65, 0.67, 119.27, 0.85, 121.07, 0.36, 1.34, 0.0066, 1.4437, 0.0088, -1, -1, 1.5108, 0.0069, 1.2373, 0.0102],
(-50, -40) : ['B', 3, 121.13, 0.73, -1, -1, 115.09, 1.22, -1, -1, 119.69, 0.63, 119.17, 0.79, 121.13, 0.33, 1.3393, 0.0075, 1.4465, 0.0087, -1, -1, 1.5116, 0.0077, 1.2381, 0.0097],
},
"IleVal_nonxpro" : {
(-180, -180) : ['I', 1822, 121.97, 1.8, 111.23, 1.65, 109.34, 2.08, 111.29, 1.64, 120.78, 1.25, 116.6, 1.45, 122.57, 1.25, 1.3319, 0.0136, 1.459, 0.0125, 1.5401, 0.0136, 1.523, 0.0127, 1.2362, 0.0119],
(-170, 160) : ['B', 3, 121.97, 1.0, 109.84, 1.32, 107.7, 1.22, 111.74, 0.94, 120.66, 0.67, 116.32, 0.84, 122.94, 1.05, 1.3318, 0.0056, 1.459, 0.0112, 1.553, 0.0074, 1.5197, 0.0107, 1.236, 0.013],
(-160, 140) : ['B', 6, 121.95, 1.53, 111.19, 1.35, 108.06, 1.28, 111.8, 1.54, 120.96, 0.94, 115.8, 1.33, 123.19, 0.96, 1.33, 0.0105, 1.4592, 0.0129, 1.5477, 0.0113, 1.5216, 0.0121, 1.234, 0.0116],
(-160, 150) : ['B', 13, 121.96, 1.34, 111.05, 1.47, 107.88, 1.38, 111.8, 1.39, 120.96, 0.84, 116.0, 1.04, 122.97, 0.87, 1.3326, 0.0094, 1.4583, 0.0122, 1.5505, 0.0103, 1.5201, 0.0117, 1.2338, 0.0121],
(-160, 160) : ['B', 6, 122.11, 1.12, 110.96, 1.65, 107.75, 1.42, 111.4, 1.41, 121.09, 0.82, 116.16, 0.96, 122.67, 1.04, 1.3327, 0.009, 1.4591, 0.0107, 1.5507, 0.0108, 1.5208, 0.0126, 1.2322, 0.0144],
(-150, 130) : ['B', 7, 122.33, 1.6, 111.63, 1.76, 108.27, 1.37, 110.65, 1.76, 120.64, 1.07, 116.29, 1.42, 123.03, 1.15, 1.3301, 0.0121, 1.4606, 0.0122, 1.5427, 0.0136, 1.5218, 0.0128, 1.2347, 0.0102],
(-150, 140) : ['B', 19, 122.25, 1.57, 111.36, 1.64, 108.35, 1.32, 111.3, 1.85, 120.9, 1.07, 115.96, 1.43, 123.09, 1.16, 1.33, 0.0121, 1.4596, 0.0125, 1.5445, 0.0138, 1.5217, 0.0126, 1.2344, 0.0111],
(-150, 150) : ['B', 20, 122.23, 1.44, 111.62, 1.9, 108.42, 1.43, 111.18, 1.8, 121.19, 1.03, 115.75, 1.28, 123.0, 1.1, 1.3324, 0.012, 1.4579, 0.0117, 1.5476, 0.0146, 1.5215, 0.0121, 1.2339, 0.0115],
(-150, 160) : ['B', 9, 122.51, 1.31, 112.0, 2.05, 108.44, 1.55, 110.48, 1.8, 121.45, 1.0, 115.66, 1.22, 122.82, 1.09, 1.3342, 0.0123, 1.4583, 0.0108, 1.5485, 0.0149, 1.522, 0.0123, 1.2328, 0.0125],
(-150, 170) : ['B', 4, 123.17, 1.37, 112.06, 1.6, 108.23, 1.43, 110.38, 1.73, 121.49, 1.01, 115.87, 1.29, 122.58, 1.2, 1.3322, 0.013, 1.4587, 0.0122, 1.5461, 0.0141, 1.5244, 0.0106, 1.2328, 0.0135],
(-140, -180) : ['B', 4, 123.46, 1.37, 112.32, 1.15, 108.53, 1.22, 110.91, 1.46, 121.44, 1.05, 115.78, 1.3, 122.75, 1.06, 1.331, 0.0146, 1.4557, 0.0148, 1.5435, 0.013, 1.525, 0.009, 1.2338, 0.0127],
(-140, 110) : ['B', 4, 122.84, 1.5, 112.34, 1.3, 107.18, 1.73, 110.41, 1.14, 120.22, 0.89, 116.74, 1.01, 122.97, 0.9, 1.3318, 0.0123, 1.4603, 0.0135, 1.5363, 0.0137, 1.5238, 0.0126, 1.2363, 0.0107],
(-140, 120) : ['B', 18, 122.7, 1.53, 111.99, 1.48, 107.78, 1.49, 110.12, 1.36, 120.25, 0.99, 116.67, 1.1, 123.03, 1.03, 1.3319, 0.0123, 1.4598, 0.0122, 1.5395, 0.013, 1.5225, 0.012, 1.2361, 0.0103],
(-140, 130) : ['B', 51, 122.75, 1.45, 111.58, 1.62, 108.17, 1.46, 110.28, 1.58, 120.43, 1.09, 116.46, 1.2, 123.07, 1.08, 1.3308, 0.0129, 1.4593, 0.0119, 1.542, 0.0131, 1.522, 0.0123, 1.2355, 0.01],
(-140, 140) : ['B', 56, 122.71, 1.44, 111.45, 1.64, 108.45, 1.48, 110.71, 1.73, 120.76, 1.1, 116.14, 1.28, 123.05, 1.11, 1.3304, 0.0135, 1.4586, 0.0119, 1.5436, 0.0146, 1.5221, 0.0126, 1.2356, 0.0101],
(-140, 150) : ['B', 41, 122.58, 1.48, 111.92, 1.87, 108.81, 1.62, 110.71, 1.79, 121.28, 1.06, 115.66, 1.31, 123.0, 1.14, 1.332, 0.0137, 1.4572, 0.0114, 1.5458, 0.0175, 1.5222, 0.012, 1.2347, 0.0102],
(-140, 160) : ['B', 43, 122.69, 1.42, 112.36, 1.85, 108.9, 1.66, 110.3, 1.69, 121.63, 0.99, 115.3, 1.33, 123.02, 1.13, 1.3342, 0.0132, 1.457, 0.0111, 1.5462, 0.0169, 1.5228, 0.0117, 1.2328, 0.0108],
(-140, 170) : ['B', 19, 123.03, 1.36, 112.35, 1.49, 108.65, 1.45, 110.52, 1.57, 121.64, 0.98, 115.37, 1.34, 122.95, 1.11, 1.3331, 0.0134, 1.4577, 0.0124, 1.5444, 0.0149, 1.524, 0.0108, 1.2323, 0.0119],
(-130, -180) : ['B', 7, 123.27, 1.47, 112.45, 1.12, 108.82, 1.22, 111.34, 1.4, 121.44, 1.14, 115.61, 1.36, 122.92, 1.05, 1.3313, 0.0136, 1.4536, 0.015, 1.5433, 0.0132, 1.5262, 0.0116, 1.2303, 0.0121],
(-130, -20) : ['B', 4, 121.53, 1.4, 111.57, 1.54, 113.71, 0.95, 110.63, 0.94, 119.35, 1.1, 119.87, 1.34, 120.72, 2.13, 1.3318, 0.0087, 1.4602, 0.0086, 1.5451, 0.0136, 1.5192, 0.0135, 1.2451, 0.0141],
(-130, 0) : ['B', 4, 122.36, 1.16, 112.67, 1.53, 113.2, 0.96, 110.7, 0.99, 119.46, 0.78, 118.71, 1.15, 121.78, 1.03, 1.3346, 0.009, 1.4569, 0.0093, 1.5428, 0.0122, 1.5199, 0.01, 1.232, 0.013],
(-130, 90) : ['B', 3, 122.96, 0.95, 112.65, 1.0, 106.42, 1.51, 111.23, 1.01, 121.09, 1.06, 116.53, 0.98, 122.3, 1.0, 1.3313, 0.0128, 1.4637, 0.0113, 1.5322, 0.0108, 1.5268, 0.0085, 1.2352, 0.0112],
(-130, 100) : ['B', 4, 123.17, 1.28, 112.35, 1.19, 106.61, 1.78, 111.09, 1.11, 120.51, 1.05, 116.7, 1.1, 122.71, 0.97, 1.3307, 0.0126, 1.461, 0.0144, 1.533, 0.0137, 1.5242, 0.0119, 1.2362, 0.0114],
(-130, 110) : ['B', 26, 123.11, 1.38, 112.1, 1.28, 107.24, 1.68, 110.73, 1.19, 120.31, 0.98, 116.61, 1.09, 123.03, 0.97, 1.3306, 0.0122, 1.4597, 0.0144, 1.5355, 0.0136, 1.5229, 0.0131, 1.2374, 0.0113],
(-130, 120) : ['B', 80, 122.98, 1.42, 111.82, 1.36, 107.77, 1.48, 110.42, 1.35, 120.27, 1.01, 116.51, 1.07, 123.18, 1.04, 1.3308, 0.0124, 1.459, 0.0128, 1.5385, 0.013, 1.5222, 0.0129, 1.237, 0.0109],
(-130, 130) : ['B', 130, 122.99, 1.39, 111.52, 1.46, 108.12, 1.44, 110.33, 1.46, 120.36, 1.06, 116.4, 1.12, 123.2, 1.08, 1.3309, 0.0132, 1.4582, 0.0119, 1.5414, 0.0128, 1.522, 0.0124, 1.2361, 0.0104],
(-130, 140) : ['B', 87, 122.94, 1.39, 111.44, 1.64, 108.46, 1.49, 110.5, 1.54, 120.67, 1.12, 116.18, 1.24, 123.1, 1.07, 1.3307, 0.0143, 1.4576, 0.0118, 1.544, 0.0142, 1.5219, 0.0122, 1.2361, 0.0099],
(-130, 150) : ['B', 49, 122.69, 1.59, 111.93, 1.85, 108.86, 1.63, 110.69, 1.6, 121.28, 1.16, 115.67, 1.3, 123.0, 1.07, 1.3312, 0.015, 1.4565, 0.0114, 1.5457, 0.017, 1.5217, 0.0119, 1.2351, 0.0099],
(-130, 160) : ['B', 53, 122.68, 1.58, 112.44, 1.68, 108.95, 1.65, 110.55, 1.52, 121.67, 1.05, 115.24, 1.3, 123.04, 1.11, 1.3333, 0.0134, 1.4557, 0.0111, 1.545, 0.0169, 1.5228, 0.0119, 1.2329, 0.0108],
(-130, 170) : ['B', 29, 122.92, 1.44, 112.52, 1.4, 108.8, 1.46, 110.82, 1.48, 121.67, 1.02, 115.3, 1.34, 123.0, 1.1, 1.3328, 0.0127, 1.4558, 0.0123, 1.5436, 0.015, 1.5242, 0.0122, 1.2314, 0.0117],
(-120, -50) : ['B', 5, 123.16, 1.06, 111.64, 0.82, 111.62, 0.79, 111.05, 0.89, 120.8, 0.89, 117.15, 0.78, 121.98, 0.77, 1.3335, 0.0146, 1.4578, 0.009, 1.5454, 0.0145, 1.5243, 0.0106, 1.2351, 0.0131],
(-120, -40) : ['B', 4, 122.77, 1.05, 111.9, 1.37, 112.12, 0.84, 110.91, 0.98, 120.34, 0.91, 117.65, 1.1, 121.97, 1.02, 1.3345, 0.0121, 1.455, 0.0106, 1.5441, 0.0156, 1.5228, 0.0096, 1.2363, 0.0123],
(-120, -20) : ['B', 8, 121.71, 1.2, 112.12, 1.35, 113.53, 0.98, 110.65, 0.98, 118.98, 1.03, 119.31, 1.15, 121.67, 1.69, 1.3304, 0.011, 1.4564, 0.0095, 1.5432, 0.0124, 1.522, 0.0132, 1.2423, 0.0117],
(-120, -10) : ['B', 4, 122.14, 1.11, 112.33, 1.19, 113.47, 1.01, 110.62, 1.08, 118.98, 0.9, 118.94, 1.22, 122.03, 1.28, 1.3308, 0.0101, 1.4586, 0.0091, 1.5442, 0.0119, 1.52, 0.012, 1.2407, 0.0125],
(-120, 0) : ['B', 5, 122.72, 1.39, 112.36, 1.3, 113.1, 0.97, 110.93, 1.1, 119.38, 0.87, 118.48, 1.16, 122.06, 0.99, 1.3322, 0.0106, 1.4567, 0.0107, 1.5425, 0.0108, 1.5196, 0.0123, 1.2351, 0.0145],
(-120, 10) : ['B', 7, 122.88, 1.76, 112.16, 1.3, 112.43, 0.92, 111.65, 1.22, 119.97, 0.91, 117.84, 1.11, 122.09, 1.09, 1.3331, 0.0122, 1.4553, 0.0104, 1.5416, 0.0108, 1.5231, 0.0127, 1.2312, 0.0151],
(-120, 20) : ['B', 8, 122.69, 1.9, 111.94, 1.3, 111.88, 1.06, 112.36, 1.37, 120.42, 1.14, 117.35, 1.5, 122.14, 1.3, 1.331, 0.0131, 1.456, 0.0109, 1.5407, 0.0105, 1.528, 0.0127, 1.2262, 0.0204],
(-120, 90) : ['B', 3, 122.93, 1.21, 112.4, 1.17, 106.53, 1.41, 111.59, 1.16, 121.36, 1.57, 116.37, 1.24, 122.2, 1.45, 1.327, 0.0147, 1.4628, 0.0141, 1.5309, 0.0111, 1.5247, 0.0098, 1.2345, 0.0125],
(-120, 100) : ['B', 11, 123.1, 1.36, 112.15, 1.21, 106.72, 1.59, 111.32, 1.21, 120.69, 1.3, 116.59, 1.33, 122.66, 1.22, 1.3298, 0.0143, 1.4602, 0.0144, 1.5329, 0.0126, 1.5236, 0.0114, 1.2371, 0.0119],
(-120, 110) : ['B', 47, 123.13, 1.34, 111.9, 1.26, 107.28, 1.59, 110.99, 1.3, 120.48, 1.1, 116.48, 1.22, 122.99, 1.07, 1.33, 0.0131, 1.4595, 0.0142, 1.535, 0.0129, 1.5226, 0.013, 1.238, 0.011],
(-120, 120) : ['B', 113, 123.1, 1.33, 111.64, 1.3, 107.75, 1.46, 110.77, 1.42, 120.39, 1.04, 116.38, 1.13, 123.2, 1.06, 1.3302, 0.0123, 1.4592, 0.0129, 1.5373, 0.0126, 1.5223, 0.0132, 1.2376, 0.011],
(-120, 130) : ['B', 141, 123.14, 1.31, 111.41, 1.38, 108.11, 1.4, 110.63, 1.48, 120.39, 1.05, 116.31, 1.14, 123.26, 1.08, 1.3305, 0.0127, 1.4583, 0.0117, 1.5403, 0.0123, 1.5221, 0.0124, 1.2366, 0.0107],
(-120, 140) : ['B', 82, 123.06, 1.38, 111.39, 1.74, 108.48, 1.44, 110.62, 1.49, 120.67, 1.17, 116.11, 1.29, 123.18, 1.08, 1.3305, 0.014, 1.4575, 0.0114, 1.5435, 0.0132, 1.5219, 0.0118, 1.236, 0.0102],
(-120, 150) : ['B', 39, 122.67, 1.68, 111.91, 2.07, 108.85, 1.54, 110.82, 1.54, 121.32, 1.32, 115.61, 1.38, 123.03, 1.05, 1.3304, 0.0156, 1.4568, 0.0115, 1.5451, 0.0151, 1.5219, 0.0121, 1.2354, 0.0105],
(-120, 160) : ['B', 32, 122.57, 1.65, 112.47, 1.68, 108.99, 1.56, 110.9, 1.44, 121.75, 1.18, 115.23, 1.28, 122.97, 1.07, 1.3316, 0.0139, 1.4556, 0.0115, 1.5433, 0.016, 1.5234, 0.0127, 1.2336, 0.0121],
(-120, 170) : ['B', 9, 122.77, 1.39, 112.6, 1.29, 108.96, 1.42, 111.19, 1.37, 121.67, 1.06, 115.31, 1.29, 122.97, 1.05, 1.3313, 0.012, 1.4553, 0.0118, 1.5416, 0.0152, 1.526, 0.0143, 1.2312, 0.0129],
(-110, -60) : ['B', 6, 122.97, 0.98, 111.57, 0.99, 111.48, 0.94, 111.71, 0.85, 120.7, 0.85, 117.37, 0.74, 121.85, 0.76, 1.3312, 0.0142, 1.4617, 0.0138, 1.5451, 0.0091, 1.5264, 0.0146, 1.2323, 0.0116],
(-110, -50) : ['B', 7, 123.08, 1.01, 111.41, 1.1, 111.56, 0.86, 111.44, 0.95, 120.73, 0.96, 117.23, 1.01, 121.98, 0.89, 1.3294, 0.0144, 1.4574, 0.0128, 1.5455, 0.0109, 1.5249, 0.0128, 1.2316, 0.0115],
(-110, -40) : ['B', 5, 122.66, 0.97, 111.82, 1.67, 111.9, 0.81, 111.3, 0.96, 120.3, 0.94, 117.6, 1.29, 122.07, 1.04, 1.3308, 0.0116, 1.454, 0.0119, 1.5444, 0.0125, 1.5237, 0.0101, 1.2329, 0.0102],
(-110, -30) : ['B', 4, 121.84, 1.13, 112.75, 2.0, 112.96, 1.0, 111.06, 0.88, 119.29, 0.84, 118.65, 1.07, 122.04, 1.07, 1.3322, 0.0116, 1.4522, 0.0118, 1.5429, 0.0127, 1.5257, 0.0117, 1.2367, 0.0098],
(-110, -20) : ['B', 9, 121.85, 1.19, 112.35, 1.38, 113.42, 1.17, 110.88, 1.09, 118.9, 0.88, 118.9, 0.94, 122.17, 1.1, 1.3307, 0.0127, 1.4561, 0.0108, 1.5427, 0.0117, 1.5238, 0.0143, 1.2411, 0.0106],
(-110, -10) : ['B', 10, 122.16, 1.26, 112.21, 1.1, 113.43, 1.09, 110.84, 1.25, 118.96, 0.95, 118.75, 1.1, 122.25, 1.01, 1.3321, 0.0119, 1.4596, 0.0109, 1.5434, 0.0109, 1.5197, 0.0147, 1.2424, 0.0123],
(-110, 0) : ['B', 5, 122.69, 1.49, 112.26, 1.29, 112.9, 0.96, 111.2, 1.24, 119.35, 1.05, 118.43, 1.18, 122.16, 0.91, 1.3324, 0.0115, 1.458, 0.0129, 1.5403, 0.0115, 1.5173, 0.0149, 1.24, 0.0149],
(-110, 10) : ['B', 11, 122.76, 1.57, 112.28, 1.33, 112.17, 0.95, 111.85, 1.27, 119.91, 0.99, 117.97, 1.14, 122.05, 1.05, 1.3316, 0.0116, 1.4568, 0.0129, 1.5374, 0.013, 1.5227, 0.0131, 1.2356, 0.0147],
(-110, 20) : ['B', 8, 122.56, 1.58, 112.22, 1.31, 111.77, 1.04, 112.46, 1.33, 120.26, 1.1, 117.54, 1.47, 122.11, 1.3, 1.3295, 0.0122, 1.4559, 0.0141, 1.5373, 0.0124, 1.5283, 0.012, 1.2295, 0.0178],
(-110, 100) : ['B', 12, 123.1, 1.4, 111.83, 1.23, 106.85, 1.42, 111.53, 1.3, 120.86, 1.33, 116.45, 1.46, 122.62, 1.4, 1.3286, 0.015, 1.4587, 0.013, 1.5331, 0.0119, 1.5239, 0.0111, 1.2363, 0.012],
(-110, 110) : ['B', 41, 123.11, 1.36, 111.67, 1.26, 107.37, 1.48, 111.19, 1.39, 120.66, 1.17, 116.41, 1.43, 122.88, 1.31, 1.3293, 0.0137, 1.4589, 0.0127, 1.535, 0.0124, 1.5229, 0.0127, 1.2374, 0.0108],
(-110, 120) : ['B', 107, 123.12, 1.3, 111.46, 1.26, 107.8, 1.45, 110.96, 1.46, 120.53, 1.07, 116.34, 1.28, 123.1, 1.17, 1.33, 0.0125, 1.4592, 0.0124, 1.5367, 0.0121, 1.5226, 0.0128, 1.2375, 0.0109],
(-110, 130) : ['B', 109, 123.19, 1.24, 111.25, 1.36, 108.17, 1.4, 110.83, 1.49, 120.48, 1.06, 116.31, 1.18, 123.18, 1.05, 1.3304, 0.0126, 1.4588, 0.012, 1.539, 0.0118, 1.5221, 0.0119, 1.2372, 0.0111],
(-110, 140) : ['B', 46, 123.1, 1.29, 111.21, 1.85, 108.53, 1.45, 110.81, 1.52, 120.72, 1.14, 116.1, 1.25, 123.14, 1.02, 1.3303, 0.0142, 1.4582, 0.012, 1.5418, 0.0126, 1.5219, 0.0117, 1.2368, 0.0113],
(-110, 150) : ['B', 9, 122.68, 1.5, 111.81, 2.36, 108.89, 1.52, 110.95, 1.61, 121.4, 1.27, 115.58, 1.36, 122.98, 1.04, 1.3298, 0.0157, 1.4574, 0.0122, 1.5439, 0.0139, 1.522, 0.0127, 1.2365, 0.012],
(-110, 160) : ['B', 10, 122.45, 1.44, 112.43, 1.84, 109.2, 1.55, 111.19, 1.43, 121.92, 1.17, 115.28, 1.26, 122.76, 1.04, 1.3293, 0.0138, 1.4554, 0.0132, 1.5433, 0.0151, 1.5235, 0.0128, 1.235, 0.0131],
(-110, 170) : ['B', 3, 122.48, 1.13, 112.34, 1.14, 109.29, 1.42, 111.7, 1.36, 121.72, 0.96, 115.54, 1.14, 122.69, 0.93, 1.3289, 0.0107, 1.4542, 0.0128, 1.542, 0.0155, 1.5267, 0.0133, 1.2311, 0.0125],
(-100, -50) : ['B', 8, 122.63, 1.19, 110.68, 1.41, 111.67, 0.95, 111.8, 1.18, 120.69, 1.05, 117.27, 1.25, 121.99, 1.39, 1.3282, 0.0104, 1.4597, 0.0164, 1.5453, 0.0105, 1.5228, 0.0137, 1.2309, 0.0107],
(-100, -40) : ['B', 6, 122.35, 1.18, 110.86, 1.75, 111.81, 0.86, 111.55, 1.15, 120.32, 1.1, 117.47, 1.42, 122.16, 1.58, 1.3293, 0.0094, 1.4564, 0.013, 1.544, 0.0117, 1.5235, 0.0107, 1.2313, 0.0102],
(-100, -20) : ['B', 6, 121.55, 1.42, 111.98, 1.73, 113.39, 1.47, 110.95, 1.48, 119.2, 0.96, 118.55, 0.86, 122.23, 0.98, 1.3326, 0.0128, 1.4582, 0.0122, 1.5431, 0.0127, 1.526, 0.0132, 1.2407, 0.0103],
(-100, -10) : ['B', 10, 121.77, 1.44, 112.07, 1.52, 113.22, 1.23, 110.94, 1.81, 119.2, 1.06, 118.56, 0.99, 122.2, 1.0, 1.3352, 0.0122, 1.4603, 0.013, 1.5441, 0.0126, 1.5224, 0.0147, 1.242, 0.0113],
(-100, 0) : ['B', 6, 122.09, 1.49, 112.08, 1.68, 112.83, 0.99, 111.37, 1.68, 119.54, 1.2, 118.27, 1.13, 122.14, 0.97, 1.3354, 0.0106, 1.458, 0.0137, 1.542, 0.0133, 1.5205, 0.0154, 1.2386, 0.0139],
(-100, 10) : ['B', 10, 122.28, 1.42, 112.15, 1.47, 112.29, 0.94, 111.88, 1.37, 119.89, 1.09, 117.95, 1.07, 122.09, 0.9, 1.3332, 0.0107, 1.4578, 0.0135, 1.5369, 0.0138, 1.5251, 0.0129, 1.2347, 0.0145],
(-100, 20) : ['B', 5, 122.26, 1.24, 112.39, 1.17, 111.91, 0.89, 112.19, 1.15, 120.14, 1.0, 117.72, 1.08, 122.05, 1.02, 1.3294, 0.0124, 1.4558, 0.0159, 1.536, 0.0124, 1.5302, 0.0112, 1.2302, 0.0157],
(-100, 90) : ['B', 5, 122.59, 1.1, 111.89, 1.04, 106.32, 1.61, 112.45, 1.24, 121.64, 1.21, 115.9, 1.33, 122.32, 1.26, 1.3284, 0.0119, 1.4622, 0.0132, 1.5279, 0.0134, 1.5255, 0.01, 1.2323, 0.0152],
(-100, 100) : ['B', 9, 122.95, 1.24, 111.6, 1.2, 106.88, 1.52, 111.81, 1.37, 120.97, 1.19, 116.35, 1.45, 122.59, 1.39, 1.329, 0.0129, 1.4588, 0.0122, 1.5312, 0.0116, 1.5249, 0.011, 1.2342, 0.0134],
(-100, 110) : ['B', 30, 122.93, 1.31, 111.41, 1.25, 107.51, 1.49, 111.31, 1.4, 120.74, 1.16, 116.46, 1.51, 122.76, 1.47, 1.3286, 0.0131, 1.4586, 0.0119, 1.5347, 0.0118, 1.5236, 0.0126, 1.2358, 0.0112],
(-100, 120) : ['B', 67, 122.9, 1.28, 111.21, 1.17, 107.99, 1.46, 110.98, 1.37, 120.59, 1.09, 116.4, 1.36, 122.97, 1.32, 1.3294, 0.0132, 1.4588, 0.0124, 1.5371, 0.0117, 1.5228, 0.0126, 1.2371, 0.011],
(-100, 130) : ['B', 74, 122.93, 1.26, 110.99, 1.2, 108.36, 1.43, 110.84, 1.36, 120.57, 1.07, 116.37, 1.22, 123.03, 1.11, 1.3303, 0.0148, 1.4589, 0.0127, 1.5387, 0.0119, 1.522, 0.0121, 1.2377, 0.0117],
(-100, 140) : ['B', 29, 122.91, 1.43, 110.86, 1.6, 108.71, 1.49, 110.98, 1.41, 120.84, 1.16, 116.19, 1.32, 122.93, 1.06, 1.3301, 0.0197, 1.4591, 0.0126, 1.5412, 0.0127, 1.5213, 0.0122, 1.2379, 0.0128],
(-100, 150) : ['B', 10, 122.64, 1.61, 111.37, 2.12, 108.97, 1.55, 111.31, 1.51, 121.48, 1.27, 115.78, 1.45, 122.69, 1.14, 1.3295, 0.0231, 1.4578, 0.0124, 1.544, 0.0135, 1.5213, 0.0127, 1.2368, 0.0138],
(-100, 160) : ['B', 5, 122.34, 1.39, 112.24, 1.94, 109.17, 1.54, 111.38, 1.4, 121.93, 1.12, 115.67, 1.26, 122.36, 1.2, 1.3288, 0.0163, 1.4527, 0.0163, 1.5467, 0.0168, 1.5229, 0.0116, 1.2342, 0.013],
(-100, 170) : ['B', 3, 122.27, 1.07, 112.07, 1.14, 109.46, 1.38, 112.03, 1.55, 121.68, 0.79, 116.16, 1.01, 122.12, 0.93, 1.3269, 0.0095, 1.4487, 0.018, 1.5486, 0.0188, 1.5244, 0.0086, 1.2286, 0.0103],
(-90, -50) : ['B', 7, 121.65, 1.48, 110.31, 1.6, 111.45, 0.93, 111.92, 1.31, 120.83, 1.22, 117.27, 1.51, 121.84, 1.83, 1.3295, 0.0118, 1.4606, 0.0142, 1.544, 0.0138, 1.5226, 0.0135, 1.2338, 0.0109],
(-90, -40) : ['B', 6, 121.34, 1.62, 110.4, 1.85, 111.58, 1.06, 111.94, 1.26, 120.46, 1.11, 117.57, 1.57, 121.91, 1.9, 1.3301, 0.0125, 1.46, 0.0132, 1.5419, 0.0146, 1.5236, 0.0133, 1.2333, 0.0122],
(-90, -30) : ['B', 3, 120.82, 1.55, 111.24, 2.04, 112.35, 1.41, 111.65, 1.41, 119.92, 1.05, 117.99, 1.22, 122.04, 1.5, 1.3309, 0.0126, 1.4581, 0.0132, 1.5381, 0.0142, 1.527, 0.0137, 1.2353, 0.0119],
(-90, -20) : ['B', 8, 121.02, 1.51, 111.76, 2.12, 113.16, 1.49, 111.02, 2.36, 119.42, 1.12, 118.36, 0.97, 122.18, 1.18, 1.3336, 0.0128, 1.4587, 0.0128, 1.5393, 0.0127, 1.5248, 0.0127, 1.2395, 0.0118],
(-90, -10) : ['B', 8, 121.35, 1.58, 111.87, 2.32, 113.07, 1.37, 110.97, 3.18, 119.36, 1.18, 118.48, 1.01, 122.12, 1.16, 1.3368, 0.013, 1.4611, 0.0131, 1.542, 0.0124, 1.5215, 0.0132, 1.241, 0.0119],
(-90, 0) : ['B', 8, 121.52, 1.44, 111.81, 2.24, 112.8, 1.15, 111.42, 2.87, 119.48, 1.26, 118.39, 1.04, 122.07, 1.1, 1.3379, 0.0105, 1.4594, 0.0129, 1.5431, 0.0136, 1.5217, 0.0144, 1.2388, 0.0113],
(-90, 80) : ['B', 4, 121.65, 0.94, 112.28, 1.0, 106.21, 1.07, 113.22, 1.12, 122.63, 0.87, 115.25, 0.95, 121.96, 0.84, 1.3295, 0.0088, 1.4744, 0.0157, 1.5322, 0.0142, 1.5242, 0.0086, 1.2334, 0.0122],
(-90, 90) : ['B', 6, 122.22, 1.15, 112.06, 0.97, 106.55, 1.45, 112.68, 1.14, 121.7, 1.06, 115.81, 1.29, 122.36, 1.11, 1.3316, 0.0096, 1.465, 0.0138, 1.5268, 0.0131, 1.5262, 0.009, 1.2315, 0.0162],
(-90, 100) : ['B', 9, 122.48, 1.25, 111.66, 1.14, 107.15, 1.53, 111.88, 1.29, 121.04, 1.17, 116.27, 1.27, 122.62, 1.17, 1.331, 0.0105, 1.4597, 0.0123, 1.5297, 0.0111, 1.5259, 0.0101, 1.232, 0.0145],
(-90, 110) : ['B', 30, 122.43, 1.26, 111.31, 1.23, 107.73, 1.56, 111.25, 1.27, 120.75, 1.22, 116.43, 1.24, 122.77, 1.24, 1.3293, 0.0115, 1.4591, 0.0115, 1.5334, 0.0113, 1.525, 0.0117, 1.2337, 0.0117],
(-90, 120) : ['B', 50, 122.37, 1.25, 111.0, 1.14, 108.23, 1.53, 110.96, 1.21, 120.65, 1.17, 116.39, 1.17, 122.94, 1.22, 1.3288, 0.0132, 1.459, 0.0119, 1.5363, 0.0117, 1.5237, 0.0123, 1.2359, 0.0109],
(-90, 130) : ['B', 54, 122.37, 1.29, 110.72, 1.09, 108.58, 1.44, 110.91, 1.24, 120.71, 1.13, 116.31, 1.2, 122.95, 1.14, 1.3288, 0.0169, 1.4586, 0.0124, 1.5381, 0.0124, 1.5227, 0.0123, 1.237, 0.012],
(-90, 140) : ['B', 27, 122.5, 1.6, 110.56, 1.38, 108.87, 1.52, 111.21, 1.37, 121.02, 1.27, 116.11, 1.51, 122.83, 1.16, 1.3277, 0.0253, 1.4585, 0.0121, 1.5407, 0.013, 1.5216, 0.0127, 1.2369, 0.0135],
(-90, 150) : ['B', 14, 122.43, 1.81, 110.95, 1.86, 109.12, 1.58, 111.68, 1.49, 121.51, 1.39, 115.83, 1.67, 122.61, 1.25, 1.3273, 0.0297, 1.4581, 0.0112, 1.5435, 0.0131, 1.5218, 0.0128, 1.2356, 0.0135],
(-90, 160) : ['B', 3, 121.85, 1.49, 111.91, 1.92, 109.45, 1.39, 111.49, 1.38, 121.8, 1.23, 115.69, 1.32, 122.47, 1.31, 1.329, 0.0208, 1.4552, 0.0138, 1.5427, 0.0162, 1.5239, 0.0111, 1.2336, 0.0131],
(-80, -60) : ['B', 5, 120.88, 1.22, 110.64, 1.2, 110.74, 0.91, 111.94, 1.32, 121.15, 1.32, 116.86, 1.14, 121.94, 1.22, 1.3319, 0.0122, 1.4607, 0.0122, 1.5399, 0.012, 1.5238, 0.0121, 1.2365, 0.0097],
(-80, -50) : ['B', 12, 120.74, 1.43, 110.52, 1.44, 110.82, 0.97, 112.04, 1.31, 120.96, 1.19, 117.1, 1.24, 121.9, 1.3, 1.3327, 0.0129, 1.4594, 0.0121, 1.5402, 0.013, 1.5234, 0.0127, 1.2363, 0.011],
(-80, -40) : ['B', 20, 120.55, 1.6, 110.56, 1.67, 111.0, 1.09, 112.24, 1.34, 120.71, 1.07, 117.42, 1.29, 121.84, 1.32, 1.3333, 0.0131, 1.4592, 0.0123, 1.5395, 0.0137, 1.5236, 0.0139, 1.236, 0.0123],
(-80, -30) : ['B', 12, 120.29, 1.72, 110.95, 1.89, 111.44, 1.34, 112.16, 1.63, 120.25, 1.08, 117.89, 1.34, 121.82, 1.37, 1.3335, 0.0124, 1.4589, 0.0134, 1.5381, 0.0137, 1.5246, 0.0159, 1.2365, 0.0135],
(-80, -20) : ['B', 12, 120.64, 1.64, 111.5, 2.22, 112.5, 1.39, 111.34, 2.68, 119.58, 1.21, 118.25, 1.33, 122.12, 1.38, 1.3345, 0.0115, 1.4591, 0.0133, 1.5378, 0.0128, 1.523, 0.0142, 1.2374, 0.0132],
(-80, -10) : ['B', 14, 121.09, 1.65, 111.75, 2.73, 113.07, 1.36, 110.73, 3.69, 119.43, 1.24, 118.28, 1.25, 122.26, 1.33, 1.3364, 0.0117, 1.462, 0.0117, 1.5403, 0.0115, 1.519, 0.0114, 1.2375, 0.0132],
(-80, 0) : ['B', 4, 121.34, 1.57, 111.82, 2.75, 112.98, 1.25, 110.83, 3.71, 119.39, 1.27, 118.4, 1.15, 122.17, 1.23, 1.3377, 0.0101, 1.4623, 0.0106, 1.5422, 0.0113, 1.5184, 0.0113, 1.2381, 0.0118],
(-80, 100) : ['B', 6, 122.33, 1.61, 111.9, 1.08, 107.37, 1.42, 111.8, 1.06, 120.89, 1.35, 116.59, 1.44, 122.45, 1.07, 1.3318, 0.0092, 1.4624, 0.0125, 1.5304, 0.0105, 1.5267, 0.0097, 1.232, 0.0133],
(-80, 110) : ['B', 14, 122.01, 1.42, 111.39, 1.16, 107.98, 1.51, 111.23, 1.08, 120.76, 1.23, 116.52, 1.13, 122.68, 1.09, 1.3301, 0.01, 1.4601, 0.011, 1.5329, 0.0114, 1.5259, 0.0113, 1.2331, 0.0109],
(-80, 120) : ['B', 24, 121.8, 1.4, 110.95, 1.12, 108.54, 1.48, 111.08, 1.17, 120.74, 1.18, 116.4, 1.01, 122.83, 1.12, 1.3293, 0.0117, 1.4596, 0.011, 1.5355, 0.0119, 1.524, 0.0116, 1.2355, 0.0103],
(-80, 130) : ['B', 33, 121.66, 1.38, 110.53, 1.09, 108.89, 1.32, 111.15, 1.3, 120.85, 1.14, 116.3, 1.13, 122.81, 1.11, 1.329, 0.0146, 1.459, 0.0119, 1.5372, 0.0125, 1.5228, 0.0114, 1.2369, 0.0115],
(-80, 140) : ['B', 18, 121.71, 1.5, 110.26, 1.37, 109.21, 1.36, 111.34, 1.42, 121.11, 1.19, 116.13, 1.42, 122.72, 1.18, 1.3289, 0.0196, 1.4584, 0.012, 1.5394, 0.0127, 1.5221, 0.0116, 1.2372, 0.0129],
(-80, 150) : ['B', 8, 121.62, 1.6, 110.49, 1.75, 109.55, 1.38, 111.63, 1.38, 121.54, 1.22, 115.82, 1.52, 122.59, 1.23, 1.3293, 0.0219, 1.4581, 0.0117, 1.542, 0.0126, 1.5229, 0.0116, 1.2364, 0.0133],
(-80, 160) : ['B', 5, 120.95, 1.43, 111.38, 1.66, 110.05, 1.09, 111.59, 1.1, 121.98, 1.21, 115.45, 1.18, 122.52, 1.25, 1.332, 0.0173, 1.4571, 0.0135, 1.5394, 0.0138, 1.5259, 0.0104, 1.2339, 0.0143],
(-70, -60) : ['B', 5, 120.72, 1.22, 110.65, 1.13, 110.42, 0.94, 111.87, 1.29, 121.18, 1.16, 116.84, 1.09, 121.94, 1.07, 1.3333, 0.0122, 1.461, 0.012, 1.5389, 0.0113, 1.5244, 0.0118, 1.2364, 0.0109],
(-70, -50) : ['B', 96, 120.56, 1.28, 110.57, 1.28, 110.53, 0.94, 112.02, 1.31, 121.05, 1.11, 117.02, 1.11, 121.9, 1.04, 1.3338, 0.0126, 1.4601, 0.0119, 1.5394, 0.012, 1.5241, 0.0123, 1.2366, 0.0112],
(-70, -40) : ['B', 158, 120.42, 1.42, 110.58, 1.5, 110.72, 1.01, 112.22, 1.38, 120.85, 1.06, 117.28, 1.16, 121.83, 1.03, 1.3343, 0.0126, 1.4596, 0.0121, 1.5396, 0.0129, 1.5237, 0.013, 1.2369, 0.0119],
(-70, -30) : ['B', 36, 120.3, 1.64, 110.77, 1.81, 111.09, 1.25, 112.26, 1.62, 120.47, 1.08, 117.69, 1.27, 121.8, 1.13, 1.3349, 0.012, 1.4593, 0.013, 1.5399, 0.0139, 1.523, 0.0146, 1.2372, 0.0129],
(-70, -20) : ['B', 22, 120.64, 1.66, 111.05, 2.1, 112.04, 1.4, 111.77, 2.27, 119.85, 1.24, 118.05, 1.4, 122.05, 1.31, 1.3355, 0.0109, 1.4576, 0.0141, 1.5402, 0.0145, 1.5223, 0.015, 1.2365, 0.0135],
(-70, -10) : ['B', 14, 121.19, 1.59, 111.23, 2.36, 113.0, 1.3, 111.05, 2.91, 119.53, 1.31, 118.13, 1.37, 122.31, 1.36, 1.3355, 0.0105, 1.4586, 0.0125, 1.5424, 0.0128, 1.5197, 0.0126, 1.2362, 0.0144],
(-70, 110) : ['B', 6, 121.63, 1.69, 111.46, 1.07, 108.12, 1.34, 111.35, 1.09, 120.69, 1.26, 116.61, 1.33, 122.64, 1.12, 1.3309, 0.0098, 1.4606, 0.0108, 1.5328, 0.012, 1.5265, 0.0114, 1.234, 0.0095],
(-70, 120) : ['B', 10, 121.18, 1.5, 110.82, 1.11, 108.84, 1.32, 111.33, 1.34, 120.95, 1.21, 116.36, 0.97, 122.66, 1.15, 1.3315, 0.0111, 1.4591, 0.0117, 1.5342, 0.0122, 1.5235, 0.011, 1.2366, 0.0099],
(-70, 130) : ['B', 29, 120.98, 1.36, 110.31, 1.23, 109.3, 1.25, 111.33, 1.49, 121.04, 1.14, 116.26, 1.05, 122.67, 1.09, 1.3328, 0.012, 1.4579, 0.0124, 1.536, 0.0116, 1.5224, 0.0108, 1.2381, 0.011],
(-70, 140) : ['B', 32, 120.91, 1.39, 110.13, 1.56, 109.58, 1.29, 111.26, 1.52, 121.23, 1.07, 116.1, 1.2, 122.61, 1.09, 1.3336, 0.0124, 1.4572, 0.0122, 1.5384, 0.0113, 1.5226, 0.0114, 1.2389, 0.0122],
(-70, 150) : ['B', 16, 120.75, 1.46, 110.45, 1.95, 109.8, 1.33, 111.28, 1.38, 121.59, 1.03, 115.77, 1.25, 122.57, 1.07, 1.3339, 0.0129, 1.457, 0.0132, 1.5399, 0.011, 1.5247, 0.0122, 1.2387, 0.0134],
(-70, 160) : ['B', 5, 120.34, 1.58, 111.15, 1.92, 110.21, 1.13, 111.45, 1.12, 122.13, 1.11, 115.26, 1.11, 122.54, 1.03, 1.3349, 0.0141, 1.4584, 0.0176, 1.5375, 0.011, 1.5262, 0.0119, 1.237, 0.0136],
(-60, -60) : ['B', 11, 120.7, 1.25, 110.62, 1.09, 110.3, 0.97, 111.81, 1.25, 121.29, 1.07, 116.72, 1.1, 121.94, 1.03, 1.3341, 0.0122, 1.462, 0.0118, 1.5389, 0.0111, 1.5243, 0.0118, 1.2365, 0.0111],
(-60, -50) : ['B', 273, 120.56, 1.26, 110.55, 1.17, 110.42, 0.96, 111.97, 1.28, 121.17, 1.06, 116.89, 1.11, 121.91, 0.98, 1.3343, 0.0125, 1.4612, 0.0117, 1.5395, 0.0117, 1.5239, 0.0122, 1.2368, 0.0113],
(-60, -40) : ['B', 289, 120.46, 1.37, 110.54, 1.36, 110.62, 1.02, 112.14, 1.35, 120.95, 1.04, 117.15, 1.14, 121.87, 0.97, 1.3346, 0.0126, 1.4606, 0.0119, 1.5402, 0.0125, 1.5233, 0.0127, 1.2372, 0.0117],
(-60, -30) : ['B', 59, 120.47, 1.58, 110.65, 1.71, 111.05, 1.25, 112.16, 1.55, 120.57, 1.07, 117.53, 1.19, 121.87, 1.01, 1.3352, 0.0121, 1.4601, 0.0126, 1.5416, 0.0145, 1.5219, 0.0138, 1.2373, 0.0123],
(-60, -20) : ['B', 18, 120.86, 1.67, 110.78, 1.98, 111.89, 1.44, 111.79, 1.91, 120.03, 1.21, 117.87, 1.25, 122.06, 1.14, 1.3354, 0.011, 1.4577, 0.0141, 1.5431, 0.0166, 1.5212, 0.015, 1.2357, 0.0133],
(-60, -10) : ['B', 4, 121.54, 1.64, 110.82, 1.97, 112.76, 1.27, 111.32, 2.1, 119.7, 1.29, 118.04, 1.23, 122.22, 1.24, 1.3343, 0.0109, 1.455, 0.0138, 1.5446, 0.0145, 1.521, 0.0145, 1.2345, 0.0154],
(-60, 120) : ['B', 3, 120.77, 1.46, 110.49, 1.15, 108.93, 1.35, 111.69, 1.56, 120.98, 1.23, 116.33, 1.03, 122.66, 1.07, 1.3331, 0.0123, 1.4589, 0.0129, 1.5322, 0.0147, 1.5217, 0.0116, 1.2373, 0.0098],
(-60, 130) : ['B', 25, 120.63, 1.33, 110.13, 1.34, 109.37, 1.35, 111.59, 1.63, 121.13, 1.16, 116.15, 1.13, 122.67, 1.02, 1.3346, 0.0122, 1.4576, 0.0127, 1.536, 0.0118, 1.521, 0.0121, 1.2376, 0.0106],
(-60, 140) : ['B', 25, 120.5, 1.34, 110.13, 1.68, 109.63, 1.44, 111.32, 1.63, 121.36, 1.1, 115.95, 1.24, 122.63, 1.06, 1.3349, 0.0116, 1.4569, 0.0119, 1.5379, 0.0103, 1.5222, 0.0135, 1.2381, 0.0113],
(-60, 150) : ['B', 13, 120.35, 1.39, 110.64, 2.11, 109.78, 1.58, 111.08, 1.47, 121.58, 1.0, 115.7, 1.26, 122.62, 1.03, 1.3349, 0.0114, 1.4556, 0.013, 1.5384, 0.0098, 1.5266, 0.0152, 1.2378, 0.0123],
(-60, 160) : ['B', 3, 120.13, 1.58, 111.3, 2.32, 110.09, 1.5, 111.13, 1.27, 121.97, 0.98, 115.28, 1.14, 122.65, 0.88, 1.3354, 0.0127, 1.4565, 0.0182, 1.5369, 0.0099, 1.5286, 0.015, 1.2374, 0.0124],
(-50, -60) : ['B', 4, 120.77, 1.31, 110.62, 1.05, 110.23, 1.04, 111.7, 1.28, 121.41, 1.04, 116.58, 1.15, 121.96, 1.08, 1.335, 0.0119, 1.463, 0.0114, 1.5385, 0.0106, 1.5241, 0.0116, 1.2366, 0.0112],
(-50, -50) : ['B', 50, 120.6, 1.29, 110.51, 1.11, 110.36, 1.05, 111.88, 1.28, 121.27, 1.04, 116.75, 1.14, 121.94, 1.0, 1.3349, 0.0123, 1.4621, 0.0114, 1.5395, 0.0111, 1.5236, 0.0122, 1.2368, 0.0114],
(-50, -40) : ['B', 21, 120.53, 1.41, 110.47, 1.25, 110.62, 1.14, 112.04, 1.31, 121.05, 1.04, 117.03, 1.16, 121.89, 0.98, 1.3351, 0.0126, 1.4614, 0.0117, 1.5407, 0.0121, 1.5227, 0.0128, 1.2373, 0.0118],
(-50, -30) : ['B', 10, 120.62, 1.64, 110.54, 1.57, 111.17, 1.38, 112.05, 1.46, 120.64, 1.09, 117.43, 1.16, 121.9, 1.01, 1.3352, 0.0123, 1.4609, 0.0124, 1.5432, 0.0152, 1.5207, 0.0138, 1.2373, 0.0122],
(-50, 130) : ['B', 12, 120.69, 1.46, 110.05, 1.32, 109.3, 1.31, 111.71, 1.58, 120.99, 1.26, 116.17, 1.27, 122.79, 0.97, 1.3343, 0.0126, 1.4574, 0.0125, 1.5394, 0.012, 1.5199, 0.0138, 1.2356, 0.0098],
(-50, 140) : ['B', 6, 120.49, 1.38, 110.14, 1.61, 109.51, 1.43, 111.51, 1.65, 121.28, 1.17, 115.9, 1.3, 122.75, 1.07, 1.3349, 0.0118, 1.4565, 0.0119, 1.5396, 0.0101, 1.5218, 0.0152, 1.2359, 0.01],
},
"IleVal_xpro" : {
(-180, -180) : ['I', 81, 122.13, 1.85, 111.21, 1.4, 108.88, 2.16, 111.36, 1.82, 119.95, 1.34, 118.88, 1.54, 121.1, 1.14, 1.3292, 0.0113, 1.4612, 0.0123, 1.5372, 0.0129, 1.5245, 0.0105, 1.2397, 0.0126],
(-140, 150) : ['B', 3, 121.68, 1.41, 111.64, 1.07, 109.19, 0.82, 109.33, 0.98, 121.59, 1.16, 116.57, 0.98, 121.69, 0.63, 1.3311, 0.0086, 1.4646, 0.0115, 1.5435, 0.0166, 1.5158, 0.0111, 1.2385, 0.0071],
(-140, 160) : ['B', 4, 122.17, 1.55, 111.87, 1.1, 109.01, 1.13, 109.89, 1.08, 121.13, 1.23, 117.0, 0.95, 121.72, 0.7, 1.3292, 0.0086, 1.4624, 0.0091, 1.5418, 0.0144, 1.52, 0.0104, 1.2385, 0.0079],
(-130, 120) : ['B', 4, 122.85, 0.87, 112.27, 1.36, 107.92, 2.12, 110.16, 1.01, 119.94, 0.52, 119.42, 0.93, 120.59, 0.98, 1.3338, 0.0106, 1.4545, 0.0077, 1.5391, 0.0075, 1.5238, 0.0083, 1.2345, 0.0103],
(-130, 160) : ['B', 6, 121.88, 1.63, 111.67, 0.85, 108.45, 1.2, 110.97, 1.42, 120.95, 1.36, 117.33, 1.01, 121.57, 0.89, 1.329, 0.01, 1.4617, 0.0087, 1.547, 0.011, 1.5222, 0.0083, 1.2414, 0.0105],
(-120, 100) : ['B', 3, 123.25, 1.1, 111.36, 1.03, 108.15, 0.99, 111.08, 0.95, 120.88, 0.68, 118.12, 0.81, 120.96, 0.96, 1.3259, 0.0092, 1.4559, 0.0086, 1.5397, 0.009, 1.5239, 0.0109, 1.2315, 0.0101],
(-120, 120) : ['B', 4, 123.28, 1.41, 111.86, 1.42, 107.71, 1.58, 110.52, 1.11, 119.98, 0.86, 119.3, 1.14, 120.66, 1.21, 1.328, 0.0106, 1.4564, 0.0087, 1.5382, 0.0088, 1.5247, 0.0091, 1.2344, 0.0111],
(-120, 130) : ['B', 3, 123.33, 0.87, 112.37, 1.06, 107.61, 1.19, 110.13, 0.97, 119.51, 0.62, 119.33, 1.1, 121.11, 1.01, 1.3288, 0.0073, 1.4572, 0.009, 1.5398, 0.0077, 1.5222, 0.0071, 1.2323, 0.0089],
(-120, 160) : ['B', 4, 122.24, 1.47, 111.83, 0.69, 107.84, 1.11, 111.89, 1.61, 120.9, 1.27, 117.57, 1.01, 121.4, 0.83, 1.3256, 0.0101, 1.4607, 0.0087, 1.5462, 0.0088, 1.5212, 0.0083, 1.2433, 0.0108],
(-110, 110) : ['B', 3, 123.34, 1.85, 111.4, 1.33, 107.6, 1.07, 111.18, 1.15, 119.89, 1.09, 119.15, 1.11, 120.92, 0.92, 1.3284, 0.0098, 1.4578, 0.0077, 1.5347, 0.0102, 1.5279, 0.0085, 1.2402, 0.0114],
(-110, 120) : ['B', 5, 123.46, 1.6, 111.39, 1.26, 107.73, 1.14, 110.85, 1.15, 119.62, 0.96, 119.23, 1.04, 121.12, 0.93, 1.3257, 0.0095, 1.4599, 0.0093, 1.5376, 0.0121, 1.5252, 0.0088, 1.2382, 0.0113],
(-110, 130) : ['B', 3, 123.43, 1.1, 111.61, 1.07, 107.89, 1.09, 110.37, 1.07, 119.38, 0.68, 119.18, 0.97, 121.41, 0.9, 1.324, 0.0086, 1.4617, 0.0101, 1.5413, 0.0124, 1.523, 0.0088, 1.2363, 0.0105],
(-100, 110) : ['B', 5, 122.85, 1.14, 111.31, 1.18, 107.55, 0.99, 111.04, 1.18, 119.25, 0.76, 119.33, 0.8, 121.37, 0.63, 1.3299, 0.0084, 1.4601, 0.0076, 1.5342, 0.0106, 1.5275, 0.0081, 1.2423, 0.012],
(-100, 120) : ['B', 10, 123.02, 1.04, 111.23, 1.23, 107.77, 1.12, 110.78, 1.15, 119.2, 0.73, 119.3, 0.81, 121.46, 0.78, 1.3267, 0.0091, 1.4606, 0.0091, 1.5363, 0.0119, 1.5252, 0.0081, 1.2406, 0.0122],
(-100, 130) : ['B', 6, 123.04, 0.92, 111.21, 1.27, 108.05, 1.18, 110.53, 1.06, 119.19, 0.65, 119.17, 0.83, 121.61, 0.91, 1.3244, 0.0093, 1.4617, 0.0104, 1.5401, 0.0123, 1.5248, 0.0084, 1.239, 0.0119],
(-90, 110) : ['B', 9, 122.6, 0.68, 111.2, 1.11, 107.56, 0.91, 110.95, 1.16, 119.12, 0.56, 119.27, 0.76, 121.55, 0.71, 1.3301, 0.0085, 1.4603, 0.0073, 1.534, 0.01, 1.5277, 0.0077, 1.2428, 0.013],
(-90, 120) : ['B', 7, 122.59, 0.72, 111.08, 1.26, 107.76, 1.01, 110.71, 1.07, 119.15, 0.59, 119.22, 0.78, 121.57, 0.87, 1.3281, 0.0097, 1.4595, 0.0075, 1.5334, 0.0105, 1.5265, 0.0079, 1.2412, 0.0136],
(-80, 130) : ['B', 3, 121.23, 1.38, 110.23, 1.07, 108.63, 0.86, 110.94, 0.93, 119.47, 0.82, 118.89, 1.14, 121.57, 1.15, 1.3256, 0.0119, 1.4647, 0.0102, 1.5259, 0.0155, 1.5266, 0.008, 1.2412, 0.0139],
(-70, 130) : ['B', 10, 120.7, 1.74, 110.08, 0.93, 108.95, 0.98, 110.89, 1.08, 119.71, 0.93, 119.15, 1.2, 121.07, 1.1, 1.3261, 0.0123, 1.468, 0.0122, 1.5305, 0.0172, 1.5255, 0.0099, 1.2441, 0.0135],
(-70, 140) : ['B', 6, 120.59, 1.77, 109.99, 1.03, 109.02, 0.93, 111.0, 0.98, 119.62, 0.9, 119.16, 1.27, 121.14, 1.08, 1.3267, 0.0127, 1.4683, 0.0105, 1.5307, 0.0148, 1.5237, 0.0093, 1.2446, 0.0134],
(-60, -50) : ['B', 6, 120.33, 0.8, 110.45, 0.78, 112.35, 1.2, 114.0, 1.31, 118.69, 0.67, 120.83, 0.61, 120.42, 0.64, 1.3344, 0.0147, 1.463, 0.012, 1.539, 0.0054, 1.5231, 0.0092, 1.242, 0.0086],
(-60, -40) : ['B', 5, 120.24, 0.63, 110.5, 0.63, 112.61, 1.45, 114.35, 1.06, 118.85, 0.85, 121.0, 0.83, 120.07, 0.71, 1.3359, 0.0133, 1.4642, 0.0123, 1.5345, 0.0068, 1.5197, 0.0088, 1.2402, 0.0122],
(-60, 130) : ['B', 5, 120.11, 1.94, 110.17, 1.11, 108.96, 1.09, 110.68, 1.15, 119.82, 0.96, 119.37, 1.13, 120.75, 1.25, 1.3291, 0.0106, 1.4677, 0.0129, 1.5391, 0.0158, 1.5245, 0.012, 1.2471, 0.0123],
(-60, 140) : ['B', 3, 119.72, 2.01, 110.33, 1.23, 108.96, 1.1, 110.88, 0.98, 119.76, 0.88, 119.51, 1.2, 120.69, 1.11, 1.3301, 0.0112, 1.4671, 0.0109, 1.5381, 0.0132, 1.5227, 0.0115, 1.2483, 0.0127],
(-50, -50) : ['B', 3, 120.43, 0.96, 110.52, 0.67, 112.67, 1.25, 113.7, 0.95, 118.71, 0.76, 120.83, 0.59, 120.42, 0.64, 1.3335, 0.0165, 1.4626, 0.0118, 1.5368, 0.005, 1.5244, 0.0111, 1.2385, 0.0085],
},
"NonPGIV_nonxpro" : {
(-180, -180) : ['I', 10921, 121.54, 1.91, 110.49, 1.69, 110.8, 2.13, 110.42, 1.99, 120.51, 1.43, 116.84, 1.71, 122.59, 1.33, 1.3324, 0.014, 1.4574, 0.0129, 1.5302, 0.0169, 1.5232, 0.0134, 1.2353, 0.0126],
(-180, 160) : ['B', 3, 122.19, 2.3, 111.69, 1.69, 108.07, 1.59, 110.03, 1.72, 121.06, 1.11, 115.47, 1.42, 123.41, 0.9, 1.3304, 0.0119, 1.457, 0.0141, 1.5324, 0.0201, 1.5217, 0.012, 1.2345, 0.0117],
(-180, 170) : ['B', 4, 122.41, 2.09, 111.87, 2.13, 107.73, 1.61, 110.56, 1.88, 121.26, 1.12, 115.43, 1.37, 123.26, 0.94, 1.3299, 0.0124, 1.458, 0.0127, 1.5299, 0.0193, 1.5239, 0.0121, 1.2347, 0.01],
(-170, -180) : ['B', 19, 122.45, 1.78, 111.49, 1.76, 107.88, 1.41, 111.78, 1.98, 121.25, 1.09, 115.66, 1.3, 123.04, 1.04, 1.3277, 0.0135, 1.4593, 0.0119, 1.5303, 0.0153, 1.5243, 0.0125, 1.2351, 0.0102],
(-170, -170) : ['B', 6, 122.84, 1.81, 111.35, 1.53, 107.73, 1.34, 112.82, 2.17, 120.94, 1.04, 116.26, 1.42, 122.75, 1.16, 1.3254, 0.0141, 1.4609, 0.0129, 1.53, 0.0136, 1.5255, 0.0123, 1.2372, 0.0094],
(-170, 140) : ['B', 9, 121.81, 2.16, 110.77, 1.66, 108.46, 1.51, 109.72, 1.61, 120.31, 1.13, 116.08, 1.38, 123.52, 1.1, 1.3311, 0.0123, 1.4559, 0.0113, 1.5349, 0.0158, 1.5205, 0.0131, 1.2334, 0.0135],
(-170, 150) : ['B', 15, 121.87, 2.24, 111.24, 1.59, 108.52, 1.52, 109.99, 1.61, 120.75, 1.12, 115.61, 1.41, 123.56, 1.06, 1.3301, 0.0123, 1.4562, 0.0127, 1.5343, 0.0165, 1.5206, 0.013, 1.2345, 0.0129],
(-170, 160) : ['B', 40, 121.91, 2.03, 111.56, 1.52, 108.42, 1.54, 110.43, 1.68, 121.1, 1.1, 115.38, 1.4, 123.46, 0.99, 1.3299, 0.0122, 1.4566, 0.0128, 1.5327, 0.0172, 1.5209, 0.0122, 1.2344, 0.0119],
(-170, 170) : ['B', 43, 122.09, 1.86, 111.57, 1.68, 108.14, 1.52, 110.95, 1.8, 121.28, 1.07, 115.38, 1.33, 123.29, 1.0, 1.3294, 0.0125, 1.4575, 0.0118, 1.5314, 0.0167, 1.5223, 0.012, 1.2339, 0.0109],
(-160, -180) : ['B', 47, 122.1, 1.66, 111.24, 1.58, 108.38, 1.35, 111.91, 2.06, 121.31, 1.07, 115.65, 1.3, 122.99, 1.07, 1.3294, 0.0127, 1.457, 0.012, 1.5316, 0.0156, 1.5237, 0.0123, 1.2341, 0.011],
(-160, -170) : ['B', 18, 122.32, 1.76, 110.97, 1.56, 108.24, 1.32, 112.78, 2.18, 121.05, 1.05, 116.18, 1.29, 122.72, 1.15, 1.3284, 0.0123, 1.4579, 0.0142, 1.5326, 0.0135, 1.5252, 0.0125, 1.2357, 0.0096],
(-160, -160) : ['B', 4, 121.95, 1.96, 110.51, 1.42, 108.23, 1.38, 113.8, 2.05, 120.56, 0.97, 116.52, 1.17, 122.88, 1.15, 1.3283, 0.0104, 1.4574, 0.0156, 1.5381, 0.0122, 1.5277, 0.0123, 1.2363, 0.0073],
(-160, -150) : ['B', 4, 120.81, 1.63, 109.51, 1.02, 108.49, 1.15, 114.87, 1.51, 120.19, 0.72, 116.68, 0.88, 123.11, 0.75, 1.3316, 0.0083, 1.4601, 0.0102, 1.5424, 0.0089, 1.5298, 0.0091, 1.2366, 0.0041],
(-160, 20) : ['B', 3, 119.35, 1.68, 110.65, 1.71, 113.21, 1.4, 110.99, 2.3, 118.38, 1.36, 119.65, 1.82, 121.85, 0.93, 1.3381, 0.0179, 1.4666, 0.0087, 1.5324, 0.0196, 1.5242, 0.0088, 1.2349, 0.0075],
(-160, 90) : ['B', 3, 121.26, 1.49, 111.74, 1.69, 107.28, 1.75, 111.51, 1.38, 120.63, 1.05, 115.81, 1.15, 123.5, 0.92, 1.3338, 0.0124, 1.4652, 0.0135, 1.5158, 0.0165, 1.5331, 0.0096, 1.231, 0.0095],
(-160, 100) : ['B', 8, 121.33, 1.4, 110.86, 1.54, 107.2, 1.7, 111.43, 1.24, 120.09, 1.01, 116.2, 1.24, 123.62, 1.02, 1.3351, 0.0135, 1.4625, 0.0132, 1.5206, 0.0148, 1.5289, 0.0104, 1.2339, 0.0107],
(-160, 110) : ['B', 9, 121.4, 1.52, 110.37, 1.46, 107.49, 1.74, 110.94, 1.28, 119.98, 1.17, 116.6, 1.34, 123.36, 1.2, 1.3321, 0.0126, 1.4615, 0.0122, 1.5248, 0.0177, 1.5226, 0.011, 1.2349, 0.0118],
(-160, 120) : ['B', 13, 121.58, 1.62, 110.32, 1.65, 107.93, 1.65, 110.34, 1.4, 119.98, 1.22, 116.71, 1.3, 123.26, 1.24, 1.3311, 0.0123, 1.4612, 0.012, 1.5298, 0.0222, 1.5192, 0.0114, 1.2353, 0.0124],
(-160, 130) : ['B', 30, 121.64, 1.7, 110.57, 1.69, 108.32, 1.64, 109.89, 1.69, 120.14, 1.22, 116.38, 1.35, 123.42, 1.14, 1.3317, 0.0125, 1.4575, 0.0116, 1.5334, 0.0189, 1.5204, 0.012, 1.2347, 0.0125],
(-160, 140) : ['B', 54, 121.69, 1.85, 110.99, 1.77, 108.55, 1.62, 109.86, 1.8, 120.43, 1.18, 116.01, 1.41, 123.48, 1.14, 1.331, 0.0126, 1.4554, 0.0118, 1.5336, 0.0164, 1.5213, 0.0128, 1.2335, 0.013],
(-160, 150) : ['B', 72, 121.63, 1.92, 111.39, 1.75, 108.76, 1.58, 110.16, 1.83, 120.89, 1.1, 115.55, 1.42, 123.48, 1.12, 1.3307, 0.0124, 1.4554, 0.0123, 1.5331, 0.0166, 1.5209, 0.0128, 1.2338, 0.0124],
(-160, 160) : ['B', 140, 121.62, 1.83, 111.56, 1.55, 108.79, 1.53, 110.62, 1.86, 121.23, 1.07, 115.29, 1.42, 123.42, 1.07, 1.3306, 0.0123, 1.4557, 0.0123, 1.5328, 0.0165, 1.5208, 0.0121, 1.2338, 0.012],
(-160, 170) : ['B', 109, 121.8, 1.71, 111.46, 1.54, 108.6, 1.46, 111.17, 1.96, 121.38, 1.06, 115.31, 1.36, 123.26, 1.05, 1.3301, 0.0126, 1.4563, 0.0116, 1.5323, 0.0168, 1.5218, 0.012, 1.2333, 0.0117],
(-150, -180) : ['B', 40, 122.11, 1.59, 111.21, 1.67, 108.74, 1.38, 111.95, 2.38, 121.36, 1.06, 115.67, 1.36, 122.92, 1.17, 1.3308, 0.013, 1.4553, 0.0132, 1.5322, 0.0168, 1.5234, 0.0124, 1.2343, 0.012],
(-150, -170) : ['B', 11, 122.2, 1.72, 110.76, 1.78, 108.45, 1.26, 113.02, 2.29, 121.14, 1.03, 116.08, 1.29, 122.73, 1.29, 1.3295, 0.0115, 1.4568, 0.0154, 1.5342, 0.0134, 1.5249, 0.0125, 1.2348, 0.0108],
(-150, -160) : ['B', 4, 122.08, 1.84, 110.55, 1.62, 108.19, 1.29, 114.1, 2.11, 120.8, 1.05, 116.47, 1.19, 122.68, 1.25, 1.3272, 0.0094, 1.4581, 0.0161, 1.5389, 0.0136, 1.5258, 0.0118, 1.2354, 0.009],
(-150, 0) : ['B', 3, 120.7, 1.63, 110.88, 1.88, 114.16, 1.48, 110.37, 1.54, 118.52, 1.1, 119.58, 1.34, 121.85, 1.03, 1.3306, 0.0222, 1.4572, 0.011, 1.5376, 0.0212, 1.5212, 0.0114, 1.2339, 0.0116],
(-150, 10) : ['B', 3, 120.17, 1.54, 111.07, 1.99, 113.5, 1.65, 110.45, 2.1, 118.65, 1.07, 119.45, 1.44, 121.84, 1.18, 1.3355, 0.0197, 1.4581, 0.009, 1.5351, 0.0248, 1.5248, 0.0111, 1.2377, 0.0118],
(-150, 20) : ['B', 5, 120.23, 1.67, 111.1, 2.17, 112.99, 1.61, 110.14, 2.77, 119.08, 1.05, 118.8, 1.51, 122.05, 1.15, 1.3398, 0.0173, 1.4593, 0.0091, 1.5353, 0.0275, 1.5266, 0.0121, 1.2368, 0.011],
(-150, 30) : ['B', 3, 121.08, 1.64, 111.42, 1.75, 112.03, 1.31, 110.46, 2.47, 119.97, 0.94, 117.68, 1.37, 122.3, 1.03, 1.34, 0.0171, 1.4592, 0.0115, 1.5328, 0.0221, 1.5245, 0.0144, 1.2362, 0.0098],
(-150, 40) : ['B', 3, 121.53, 1.53, 111.79, 1.2, 110.41, 1.18, 111.24, 1.64, 121.02, 0.9, 116.77, 1.21, 122.18, 0.99, 1.3337, 0.0143, 1.4585, 0.0133, 1.5306, 0.0134, 1.5243, 0.0143, 1.2356, 0.0088],
(-150, 50) : ['B', 3, 121.83, 1.48, 111.19, 1.47, 109.83, 1.55, 112.07, 1.54, 121.67, 0.93, 116.49, 1.3, 121.78, 1.4, 1.3289, 0.0117, 1.4583, 0.0141, 1.5287, 0.0102, 1.5273, 0.012, 1.232, 0.0112],
(-150, 60) : ['B', 4, 122.62, 1.97, 110.79, 1.73, 109.24, 1.89, 112.44, 1.72, 122.31, 1.31, 116.25, 1.53, 121.35, 2.15, 1.3287, 0.0123, 1.4574, 0.017, 1.5274, 0.0076, 1.5283, 0.0107, 1.2294, 0.0174],
(-150, 70) : ['B', 3, 122.95, 2.38, 111.96, 1.75, 108.18, 2.01, 111.86, 1.67, 122.62, 1.87, 115.78, 1.35, 121.5, 2.64, 1.3362, 0.0171, 1.459, 0.0215, 1.5305, 0.0098, 1.5313, 0.0115, 1.2306, 0.0187],
(-150, 80) : ['B', 5, 122.2, 2.32, 112.27, 1.77, 107.6, 1.83, 111.7, 1.52, 122.2, 1.64, 115.51, 1.08, 122.22, 1.97, 1.3391, 0.018, 1.4648, 0.0175, 1.5284, 0.0113, 1.5324, 0.0121, 1.2335, 0.0142],
(-150, 90) : ['B', 3, 121.87, 1.83, 111.36, 1.82, 107.32, 1.65, 111.7, 1.31, 120.89, 1.27, 115.75, 1.08, 123.28, 1.16, 1.3342, 0.0152, 1.4652, 0.0131, 1.5218, 0.0127, 1.5304, 0.0108, 1.2329, 0.0112],
(-150, 100) : ['B', 9, 121.72, 1.54, 110.79, 1.63, 107.23, 1.67, 111.42, 1.31, 120.27, 1.24, 116.26, 1.27, 123.4, 1.13, 1.3336, 0.0142, 1.4627, 0.0127, 1.523, 0.0135, 1.5264, 0.0103, 1.2346, 0.0122],
(-150, 110) : ['B', 15, 121.76, 1.51, 110.71, 1.53, 107.61, 1.74, 110.79, 1.39, 120.15, 1.37, 116.55, 1.45, 123.24, 1.32, 1.3315, 0.0132, 1.4611, 0.0119, 1.5269, 0.0165, 1.5218, 0.0108, 1.2347, 0.0126],
(-150, 120) : ['B', 21, 121.86, 1.58, 110.59, 1.65, 108.13, 1.72, 110.24, 1.46, 120.11, 1.37, 116.5, 1.44, 123.34, 1.37, 1.3311, 0.0128, 1.4594, 0.012, 1.5308, 0.0183, 1.5198, 0.0112, 1.2347, 0.0118],
(-150, 130) : ['B', 58, 121.89, 1.74, 110.71, 1.66, 108.48, 1.8, 109.8, 1.7, 120.21, 1.35, 116.29, 1.45, 123.44, 1.23, 1.3313, 0.013, 1.4569, 0.012, 1.5331, 0.0169, 1.5204, 0.012, 1.2345, 0.0115],
(-150, 140) : ['B', 89, 121.94, 1.76, 111.13, 1.81, 108.75, 1.71, 109.68, 1.98, 120.54, 1.23, 115.98, 1.45, 123.41, 1.17, 1.3311, 0.0129, 1.4552, 0.0121, 1.5334, 0.0172, 1.5209, 0.0126, 1.2339, 0.0122],
(-150, 150) : ['B', 142, 121.85, 1.77, 111.52, 1.86, 108.99, 1.57, 109.94, 2.13, 120.99, 1.12, 115.61, 1.45, 123.33, 1.13, 1.3312, 0.0125, 1.4547, 0.0125, 1.5337, 0.0178, 1.521, 0.0124, 1.234, 0.0122],
(-150, 160) : ['B', 181, 121.75, 1.73, 111.66, 1.67, 109.07, 1.52, 110.45, 2.15, 121.33, 1.08, 115.36, 1.48, 123.25, 1.14, 1.3312, 0.0122, 1.4548, 0.0127, 1.5338, 0.0176, 1.5211, 0.0123, 1.2338, 0.0122],
(-150, 170) : ['B', 105, 121.87, 1.64, 111.56, 1.58, 108.96, 1.49, 111.09, 2.27, 121.45, 1.07, 115.38, 1.45, 123.1, 1.15, 1.3309, 0.0128, 1.4549, 0.0125, 1.5329, 0.0182, 1.5218, 0.0124, 1.2336, 0.0125],
(-140, -180) : ['B', 29, 122.53, 1.61, 111.31, 1.67, 108.86, 1.41, 111.65, 2.4, 121.4, 1.11, 115.77, 1.52, 122.78, 1.33, 1.3319, 0.0137, 1.4552, 0.0141, 1.5336, 0.0157, 1.5232, 0.0131, 1.2351, 0.0128],
(-140, -170) : ['B', 18, 122.39, 1.64, 110.87, 1.8, 108.34, 1.31, 113.19, 2.37, 121.32, 1.18, 116.01, 1.45, 122.61, 1.57, 1.3304, 0.0119, 1.4568, 0.0153, 1.5348, 0.0132, 1.5251, 0.0134, 1.235, 0.0114],
(-140, -160) : ['B', 5, 122.23, 1.48, 110.86, 1.79, 108.07, 1.38, 114.41, 2.3, 121.47, 1.33, 116.35, 1.3, 122.11, 1.66, 1.3276, 0.0089, 1.4588, 0.0141, 1.5367, 0.0145, 1.5253, 0.0111, 1.236, 0.0099],
(-140, -30) : ['B', 4, 121.63, 1.91, 111.18, 1.58, 114.62, 1.14, 109.28, 1.33, 118.54, 1.26, 119.71, 1.17, 121.67, 1.3, 1.3327, 0.0192, 1.4599, 0.0114, 1.534, 0.0179, 1.5224, 0.012, 1.2351, 0.0102],
(-140, -20) : ['B', 6, 121.52, 1.74, 111.15, 1.46, 114.75, 1.26, 109.16, 1.29, 118.47, 1.14, 119.8, 1.34, 121.64, 1.23, 1.3331, 0.0141, 1.4601, 0.0127, 1.5331, 0.016, 1.52, 0.0137, 1.2358, 0.0111],
(-140, -10) : ['B', 6, 121.41, 1.83, 111.06, 1.59, 114.64, 1.52, 109.29, 1.51, 118.43, 1.25, 119.58, 1.39, 121.93, 1.06, 1.3334, 0.0151, 1.4572, 0.0142, 1.5353, 0.0164, 1.5201, 0.0137, 1.2346, 0.0119],
(-140, 0) : ['B', 10, 121.44, 1.59, 111.01, 1.56, 114.09, 1.55, 109.8, 1.61, 118.79, 1.13, 119.07, 1.23, 122.09, 1.09, 1.3337, 0.0179, 1.4551, 0.0127, 1.5373, 0.0185, 1.5217, 0.0125, 1.2351, 0.0126],
(-140, 10) : ['B', 12, 121.18, 1.64, 111.43, 1.88, 113.19, 1.58, 110.35, 1.78, 119.08, 1.03, 118.82, 1.26, 122.04, 1.35, 1.3356, 0.0175, 1.4569, 0.0106, 1.5333, 0.0215, 1.5241, 0.0124, 1.2378, 0.0139],
(-140, 20) : ['B', 12, 121.15, 1.85, 111.6, 1.99, 112.54, 1.51, 110.41, 2.17, 119.51, 1.04, 118.26, 1.38, 122.15, 1.36, 1.337, 0.0173, 1.4579, 0.01, 1.5321, 0.0223, 1.5257, 0.0131, 1.2371, 0.0138],
(-140, 30) : ['B', 8, 121.81, 1.94, 111.66, 1.56, 111.71, 1.34, 110.75, 1.99, 120.32, 1.02, 117.4, 1.41, 122.21, 1.24, 1.3356, 0.0168, 1.4575, 0.0125, 1.53, 0.0184, 1.524, 0.0147, 1.2361, 0.0126],
(-140, 40) : ['B', 11, 122.54, 1.82, 111.65, 1.4, 110.61, 1.25, 111.35, 1.72, 121.2, 1.04, 116.74, 1.42, 121.99, 1.24, 1.3316, 0.0142, 1.4588, 0.0152, 1.5281, 0.0147, 1.5216, 0.0152, 1.2354, 0.0112],
(-140, 50) : ['B', 4, 122.62, 1.63, 111.53, 1.93, 110.06, 1.43, 111.97, 1.99, 121.78, 1.12, 116.22, 1.44, 121.92, 1.35, 1.3301, 0.0128, 1.4598, 0.015, 1.5275, 0.0149, 1.5251, 0.014, 1.2316, 0.0101],
(-140, 60) : ['B', 3, 122.67, 1.47, 111.36, 2.05, 109.56, 1.84, 112.12, 2.09, 122.32, 1.51, 115.95, 1.39, 121.63, 1.84, 1.3332, 0.0134, 1.4578, 0.0177, 1.5277, 0.0133, 1.5305, 0.0123, 1.2277, 0.0139],
(-140, 70) : ['B', 5, 123.04, 1.59, 111.64, 1.53, 108.53, 2.07, 111.74, 1.59, 122.23, 1.94, 115.92, 1.28, 121.74, 2.3, 1.3412, 0.0213, 1.4597, 0.022, 1.5307, 0.0137, 1.5323, 0.0141, 1.2301, 0.0174],
(-140, 80) : ['B', 7, 122.92, 1.75, 111.58, 1.62, 107.67, 2.11, 111.95, 1.45, 121.62, 1.77, 115.85, 1.23, 122.44, 1.82, 1.3411, 0.0226, 1.4661, 0.0177, 1.5284, 0.0167, 1.531, 0.0147, 1.2332, 0.0147],
(-140, 90) : ['B', 8, 122.76, 1.63, 111.11, 1.88, 107.37, 2.07, 111.82, 1.38, 120.81, 1.61, 116.05, 1.19, 123.06, 1.36, 1.3344, 0.0158, 1.4665, 0.0136, 1.5237, 0.0162, 1.5281, 0.0118, 1.234, 0.0122],
(-140, 100) : ['B', 15, 122.47, 1.5, 110.95, 1.73, 107.44, 1.93, 111.23, 1.42, 120.47, 1.35, 116.33, 1.32, 123.14, 1.28, 1.3326, 0.0138, 1.4637, 0.0125, 1.5245, 0.0146, 1.5257, 0.0108, 1.2347, 0.0121],
(-140, 110) : ['B', 31, 122.44, 1.45, 110.9, 1.56, 107.8, 1.73, 110.62, 1.46, 120.25, 1.26, 116.57, 1.4, 123.14, 1.3, 1.3317, 0.0133, 1.461, 0.0119, 1.5293, 0.0154, 1.522, 0.0114, 1.235, 0.0119],
(-140, 120) : ['B', 58, 122.39, 1.48, 110.77, 1.63, 108.26, 1.66, 110.14, 1.54, 120.2, 1.22, 116.48, 1.39, 123.28, 1.28, 1.3316, 0.0126, 1.4588, 0.0122, 1.5323, 0.0162, 1.5199, 0.0116, 1.2347, 0.0113],
(-140, 130) : ['B', 111, 122.33, 1.68, 110.81, 1.68, 108.69, 1.77, 109.65, 1.75, 120.28, 1.23, 116.31, 1.48, 123.36, 1.22, 1.3314, 0.0133, 1.4567, 0.0126, 1.5337, 0.0172, 1.52, 0.012, 1.2345, 0.0111],
(-140, 140) : ['B', 136, 122.37, 1.72, 111.13, 1.79, 109.06, 1.7, 109.38, 2.03, 120.6, 1.2, 116.01, 1.51, 123.33, 1.21, 1.3313, 0.0143, 1.4551, 0.0125, 1.5347, 0.0202, 1.5205, 0.0122, 1.2342, 0.0118],
(-140, 150) : ['B', 203, 122.29, 1.65, 111.53, 1.86, 109.23, 1.55, 109.56, 2.22, 121.06, 1.16, 115.6, 1.47, 123.27, 1.16, 1.3313, 0.0137, 1.4546, 0.0126, 1.5353, 0.0209, 1.5211, 0.012, 1.2338, 0.0122],
(-140, 160) : ['B', 203, 122.21, 1.62, 111.69, 1.74, 109.24, 1.51, 110.07, 2.2, 121.4, 1.13, 115.36, 1.53, 123.17, 1.21, 1.3312, 0.013, 1.4546, 0.0129, 1.5352, 0.019, 1.5216, 0.0124, 1.2335, 0.0124],
(-140, 170) : ['B', 93, 122.36, 1.6, 111.62, 1.62, 109.14, 1.49, 110.67, 2.23, 121.51, 1.12, 115.46, 1.57, 122.96, 1.26, 1.3313, 0.0133, 1.4547, 0.0132, 1.5343, 0.0177, 1.522, 0.0127, 1.234, 0.0129],
(-130, -180) : ['B', 13, 123.01, 1.78, 111.22, 1.58, 109.18, 1.42, 111.11, 2.1, 121.49, 1.16, 115.71, 1.6, 122.74, 1.38, 1.3305, 0.0139, 1.4556, 0.0144, 1.5344, 0.0145, 1.5245, 0.0135, 1.2348, 0.0136],
(-130, -160) : ['B', 4, 122.16, 1.32, 110.88, 2.22, 108.65, 1.85, 114.11, 2.44, 121.98, 1.47, 116.18, 1.15, 121.7, 1.84, 1.3283, 0.0085, 1.4578, 0.0117, 1.5341, 0.0149, 1.5274, 0.0098, 1.2375, 0.0106],
(-130, -40) : ['B', 3, 122.15, 2.83, 110.83, 2.36, 113.18, 1.33, 110.23, 1.76, 119.47, 1.34, 118.22, 1.03, 122.25, 1.18, 1.3243, 0.0256, 1.4587, 0.0141, 1.5372, 0.0252, 1.5203, 0.0125, 1.2335, 0.0146],
(-130, -20) : ['B', 13, 122.08, 1.53, 111.0, 1.33, 114.56, 1.27, 109.13, 1.56, 118.55, 1.14, 119.26, 1.14, 122.1, 1.06, 1.3326, 0.0152, 1.4571, 0.014, 1.536, 0.0146, 1.5202, 0.0148, 1.2371, 0.0128],
(-130, -10) : ['B', 24, 121.98, 1.53, 110.98, 1.32, 114.39, 1.45, 109.27, 1.64, 118.69, 1.15, 119.07, 1.2, 122.19, 1.03, 1.334, 0.0158, 1.4549, 0.015, 1.5365, 0.0146, 1.5209, 0.0138, 1.236, 0.0123],
(-130, 0) : ['B', 31, 121.99, 1.56, 110.95, 1.44, 113.89, 1.58, 109.75, 1.72, 119.03, 1.13, 118.7, 1.22, 122.23, 1.09, 1.3341, 0.0163, 1.4541, 0.014, 1.5363, 0.0158, 1.5219, 0.0131, 1.2359, 0.0129],
(-130, 10) : ['B', 23, 122.08, 1.59, 111.27, 1.66, 113.02, 1.49, 110.44, 1.68, 119.34, 1.09, 118.39, 1.25, 122.2, 1.26, 1.335, 0.015, 1.4568, 0.0119, 1.5331, 0.0163, 1.5239, 0.0125, 1.2367, 0.0143],
(-130, 20) : ['B', 24, 122.14, 1.67, 111.49, 1.66, 112.3, 1.36, 110.85, 1.64, 119.78, 1.16, 117.89, 1.34, 122.26, 1.37, 1.336, 0.0155, 1.4583, 0.0108, 1.5307, 0.0151, 1.5247, 0.0122, 1.2353, 0.0148],
(-130, 30) : ['B', 18, 122.5, 1.82, 111.54, 1.45, 111.56, 1.38, 111.18, 1.56, 120.53, 1.18, 117.2, 1.45, 122.19, 1.34, 1.334, 0.0158, 1.4579, 0.0122, 1.5283, 0.0139, 1.5239, 0.0131, 1.2339, 0.0147],
(-130, 40) : ['B', 19, 123.13, 1.89, 111.51, 1.48, 110.88, 1.28, 111.45, 1.72, 121.32, 1.16, 116.76, 1.58, 121.83, 1.35, 1.3304, 0.0143, 1.4577, 0.0144, 1.5266, 0.0139, 1.521, 0.0154, 1.2346, 0.0141],
(-130, 50) : ['B', 8, 123.34, 1.8, 111.69, 2.25, 110.44, 1.2, 111.77, 2.28, 121.89, 1.29, 116.19, 1.66, 121.83, 1.33, 1.3303, 0.0136, 1.4596, 0.0145, 1.5258, 0.0168, 1.5226, 0.0161, 1.2328, 0.0119],
(-130, 60) : ['B', 5, 122.87, 1.44, 111.74, 2.41, 109.54, 1.37, 111.83, 2.33, 121.94, 1.68, 115.71, 1.54, 122.28, 1.3, 1.3333, 0.0136, 1.4611, 0.0151, 1.5277, 0.0182, 1.5299, 0.0144, 1.2304, 0.0115],
(-130, 70) : ['B', 6, 123.03, 1.34, 111.23, 1.53, 108.49, 1.65, 111.85, 1.47, 121.35, 1.96, 115.94, 1.33, 122.61, 1.54, 1.3352, 0.0186, 1.4621, 0.0167, 1.5301, 0.022, 1.5314, 0.0146, 1.2325, 0.0144],
(-130, 80) : ['B', 8, 123.24, 1.54, 110.9, 1.84, 107.67, 2.09, 112.09, 1.43, 121.03, 1.97, 116.07, 1.3, 122.81, 1.53, 1.3361, 0.0187, 1.4658, 0.0151, 1.5306, 0.0312, 1.5281, 0.016, 1.2331, 0.0136],
(-130, 90) : ['B', 16, 123.23, 1.54, 110.82, 1.85, 107.48, 2.29, 111.77, 1.52, 120.69, 1.93, 116.28, 1.39, 122.93, 1.6, 1.3331, 0.013, 1.464, 0.0136, 1.5273, 0.0248, 1.5264, 0.0135, 1.2339, 0.012],
(-130, 100) : ['B', 27, 122.95, 1.44, 110.87, 1.63, 107.7, 2.09, 111.17, 1.54, 120.52, 1.39, 116.43, 1.51, 122.99, 1.52, 1.3317, 0.0131, 1.4625, 0.012, 1.5261, 0.017, 1.5258, 0.012, 1.2347, 0.0114],
(-130, 110) : ['B', 50, 122.86, 1.42, 110.84, 1.52, 108.02, 1.78, 110.62, 1.51, 120.33, 1.08, 116.51, 1.34, 123.12, 1.32, 1.3317, 0.0135, 1.4601, 0.0117, 1.5295, 0.0157, 1.5224, 0.0118, 1.2354, 0.0113],
(-130, 120) : ['B', 119, 122.77, 1.41, 110.77, 1.57, 108.34, 1.64, 110.14, 1.6, 120.24, 1.06, 116.45, 1.23, 123.27, 1.17, 1.3315, 0.0129, 1.4582, 0.0119, 1.5319, 0.0158, 1.5204, 0.0117, 1.2354, 0.0112],
(-130, 130) : ['B', 164, 122.74, 1.54, 110.8, 1.73, 108.76, 1.69, 109.7, 1.81, 120.32, 1.11, 116.32, 1.38, 123.31, 1.17, 1.3312, 0.0138, 1.4566, 0.0124, 1.533, 0.019, 1.5205, 0.0121, 1.2352, 0.0114],
(-130, 140) : ['B', 185, 122.73, 1.62, 111.0, 1.81, 109.24, 1.67, 109.35, 1.98, 120.66, 1.15, 116.0, 1.5, 123.27, 1.22, 1.331, 0.0155, 1.4553, 0.0125, 1.5345, 0.0247, 1.5209, 0.0124, 1.2347, 0.0122],
(-130, 150) : ['B', 204, 122.62, 1.56, 111.37, 1.82, 109.5, 1.58, 109.38, 2.09, 121.11, 1.17, 115.58, 1.48, 123.24, 1.23, 1.331, 0.0151, 1.4544, 0.0127, 1.5358, 0.0253, 1.5215, 0.0121, 1.2341, 0.0126],
(-130, 160) : ['B', 154, 122.59, 1.57, 111.55, 1.74, 109.52, 1.55, 109.79, 2.05, 121.44, 1.17, 115.34, 1.56, 123.15, 1.3, 1.3307, 0.0141, 1.4541, 0.0129, 1.5357, 0.0208, 1.5222, 0.0123, 1.2337, 0.0126],
(-130, 170) : ['B', 61, 122.82, 1.68, 111.43, 1.59, 109.41, 1.52, 110.3, 1.98, 121.58, 1.16, 115.42, 1.64, 122.94, 1.37, 1.3305, 0.0138, 1.4545, 0.0133, 1.5353, 0.0171, 1.5228, 0.0125, 1.234, 0.0128],
(-120, -180) : ['B', 15, 123.32, 1.88, 110.87, 1.51, 109.69, 1.44, 111.22, 2.02, 121.6, 1.21, 115.54, 1.52, 122.81, 1.42, 1.3275, 0.0147, 1.456, 0.015, 1.5317, 0.0145, 1.5262, 0.0137, 1.2335, 0.0147],
(-120, -170) : ['B', 4, 123.09, 1.94, 110.65, 1.68, 109.65, 1.56, 112.44, 2.07, 121.46, 1.25, 115.75, 1.34, 122.72, 1.33, 1.3277, 0.0151, 1.4559, 0.014, 1.5306, 0.0148, 1.529, 0.0144, 1.2344, 0.0151],
(-120, -120) : ['B', 3, 121.84, 1.42, 111.59, 0.93, 108.34, 1.47, 116.54, 1.46, 119.34, 0.91, 118.57, 0.88, 122.03, 0.73, 1.3371, 0.0129, 1.4584, 0.0063, 1.5189, 0.0189, 1.5252, 0.0042, 1.2274, 0.0078],
(-120, -100) : ['B', 4, 121.79, 1.35, 111.22, 1.68, 108.3, 1.56, 115.27, 2.0, 119.77, 0.57, 119.29, 0.48, 120.83, 0.74, 1.3366, 0.012, 1.4529, 0.0118, 1.5327, 0.0146, 1.5196, 0.0048, 1.2389, 0.0126],
(-120, -70) : ['B', 4, 121.9, 1.26, 111.21, 2.08, 111.34, 1.49, 112.31, 1.53, 119.4, 1.1, 118.76, 1.29, 121.79, 0.98, 1.3349, 0.0121, 1.461, 0.0097, 1.5297, 0.0124, 1.5232, 0.0082, 1.2332, 0.0126],
(-120, -60) : ['B', 9, 122.17, 1.54, 110.63, 1.94, 112.12, 1.34, 111.26, 1.66, 119.61, 1.24, 118.39, 1.38, 121.95, 1.17, 1.333, 0.0134, 1.4589, 0.0115, 1.5343, 0.0155, 1.5222, 0.0093, 1.2353, 0.0124],
(-120, -50) : ['B', 13, 122.46, 1.8, 110.44, 1.74, 112.72, 1.28, 110.37, 1.64, 119.81, 1.17, 118.04, 1.32, 122.09, 1.23, 1.3314, 0.014, 1.4574, 0.0117, 1.5371, 0.0176, 1.5194, 0.0101, 1.2369, 0.0136],
(-120, -40) : ['B', 8, 122.58, 2.07, 110.51, 1.7, 113.43, 1.26, 109.65, 1.68, 119.64, 1.19, 118.15, 1.39, 122.1, 1.34, 1.3288, 0.0179, 1.4575, 0.0135, 1.5355, 0.0201, 1.5188, 0.0119, 1.2337, 0.0154],
(-120, -30) : ['B', 14, 122.42, 1.77, 110.81, 1.48, 114.04, 1.24, 109.15, 1.78, 119.06, 1.25, 118.58, 1.26, 122.25, 1.2, 1.3308, 0.0173, 1.4555, 0.0136, 1.5366, 0.0167, 1.5197, 0.014, 1.2329, 0.0146],
(-120, -20) : ['B', 28, 122.24, 1.57, 110.9, 1.33, 114.31, 1.29, 109.02, 1.68, 118.77, 1.11, 118.81, 1.15, 122.34, 1.1, 1.3344, 0.0152, 1.4544, 0.0131, 1.5371, 0.0138, 1.5202, 0.0139, 1.2358, 0.0131],
(-120, -10) : ['B', 36, 122.23, 1.57, 110.88, 1.38, 114.12, 1.39, 109.38, 1.68, 118.9, 1.1, 118.79, 1.22, 122.27, 1.16, 1.3337, 0.0161, 1.4538, 0.0142, 1.5369, 0.0141, 1.5209, 0.0134, 1.2364, 0.0128],
(-120, 0) : ['B', 48, 122.29, 1.56, 110.8, 1.49, 113.61, 1.5, 109.99, 1.74, 119.18, 1.18, 118.59, 1.28, 122.2, 1.18, 1.3328, 0.0151, 1.4547, 0.0138, 1.5348, 0.0151, 1.5214, 0.0131, 1.2367, 0.0133],
(-120, 10) : ['B', 51, 122.37, 1.54, 110.98, 1.65, 112.94, 1.41, 110.64, 1.72, 119.48, 1.18, 118.27, 1.3, 122.19, 1.21, 1.3333, 0.0134, 1.4575, 0.0122, 1.5315, 0.0152, 1.5231, 0.0128, 1.2369, 0.0139],
(-120, 20) : ['B', 46, 122.49, 1.57, 111.2, 1.65, 112.41, 1.3, 111.02, 1.62, 119.95, 1.21, 117.76, 1.38, 122.22, 1.3, 1.3344, 0.0139, 1.4583, 0.0114, 1.5297, 0.0139, 1.5245, 0.0129, 1.2351, 0.014],
(-120, 30) : ['B', 27, 122.79, 1.63, 111.39, 1.56, 111.87, 1.41, 111.28, 1.58, 120.65, 1.23, 117.06, 1.53, 122.2, 1.34, 1.3329, 0.0156, 1.4576, 0.0119, 1.5279, 0.0134, 1.5252, 0.0127, 1.2326, 0.0143],
(-120, 40) : ['B', 15, 123.25, 1.69, 111.43, 1.48, 111.3, 1.43, 111.46, 1.71, 121.34, 1.18, 116.62, 1.65, 121.95, 1.35, 1.3301, 0.0152, 1.4571, 0.0129, 1.5266, 0.0136, 1.5238, 0.014, 1.2329, 0.0149],
(-120, 70) : ['B', 4, 123.2, 1.38, 110.6, 1.8, 108.54, 1.41, 111.7, 1.48, 120.96, 1.98, 116.11, 1.3, 122.83, 1.35, 1.328, 0.0125, 1.4612, 0.0147, 1.5362, 0.0346, 1.527, 0.0132, 1.2344, 0.0161],
(-120, 80) : ['B', 7, 123.37, 1.64, 110.32, 2.44, 107.71, 1.9, 111.76, 1.47, 121.09, 1.79, 115.97, 1.24, 122.82, 1.3, 1.331, 0.0125, 1.463, 0.0136, 1.5394, 0.0488, 1.5259, 0.0151, 1.2329, 0.0135],
(-120, 90) : ['B', 16, 123.33, 1.64, 110.64, 2.02, 107.49, 2.16, 111.51, 1.66, 120.85, 1.67, 116.18, 1.41, 122.87, 1.48, 1.3305, 0.0129, 1.4619, 0.014, 1.5307, 0.0328, 1.5265, 0.0142, 1.2334, 0.0115],
(-120, 100) : ['B', 36, 123.13, 1.51, 110.69, 1.65, 107.69, 2.01, 111.23, 1.68, 120.57, 1.26, 116.41, 1.53, 122.96, 1.52, 1.3305, 0.0148, 1.4618, 0.0128, 1.5268, 0.0175, 1.5256, 0.0128, 1.2351, 0.0114],
(-120, 110) : ['B', 77, 123.07, 1.46, 110.65, 1.58, 108.02, 1.75, 110.74, 1.61, 120.4, 1.05, 116.44, 1.32, 123.12, 1.32, 1.3313, 0.0144, 1.4599, 0.012, 1.5285, 0.0151, 1.5231, 0.0121, 1.2359, 0.0114],
(-120, 120) : ['B', 147, 123.0, 1.41, 110.65, 1.56, 108.41, 1.63, 110.16, 1.66, 120.3, 1.07, 116.39, 1.17, 123.27, 1.16, 1.3309, 0.0132, 1.4579, 0.0119, 1.5305, 0.015, 1.5214, 0.0117, 1.2358, 0.0114],
(-120, 130) : ['B', 183, 122.99, 1.41, 110.68, 1.68, 108.9, 1.63, 109.71, 1.83, 120.36, 1.08, 116.29, 1.3, 123.3, 1.19, 1.3305, 0.0134, 1.4564, 0.0121, 1.5317, 0.0182, 1.5213, 0.0119, 1.2356, 0.012],
(-120, 140) : ['B', 210, 122.94, 1.5, 110.83, 1.74, 109.4, 1.63, 109.37, 1.91, 120.7, 1.08, 116.01, 1.49, 123.23, 1.3, 1.3302, 0.0144, 1.4553, 0.0123, 1.533, 0.0229, 1.5218, 0.0122, 1.2352, 0.0128],
(-120, 150) : ['B', 174, 122.81, 1.57, 111.08, 1.71, 109.72, 1.6, 109.33, 1.97, 121.11, 1.13, 115.63, 1.51, 123.19, 1.3, 1.3302, 0.0145, 1.4541, 0.0123, 1.5344, 0.0233, 1.5225, 0.012, 1.2348, 0.013],
(-120, 160) : ['B', 109, 122.81, 1.68, 111.2, 1.62, 109.85, 1.58, 109.66, 1.94, 121.46, 1.17, 115.36, 1.56, 123.11, 1.34, 1.3299, 0.0141, 1.4535, 0.0123, 1.5349, 0.0193, 1.5231, 0.0121, 1.2342, 0.0128],
(-120, 170) : ['B', 47, 123.03, 1.79, 111.05, 1.5, 109.81, 1.53, 110.24, 1.88, 121.68, 1.18, 115.32, 1.61, 122.94, 1.43, 1.3289, 0.0137, 1.4543, 0.0131, 1.5345, 0.016, 1.5236, 0.0124, 1.2338, 0.0131],
(-110, -180) : ['B', 21, 123.27, 1.85, 110.6, 1.52, 109.95, 1.44, 111.48, 1.91, 121.73, 1.35, 115.46, 1.34, 122.76, 1.44, 1.3282, 0.0162, 1.4546, 0.0136, 1.5304, 0.0152, 1.526, 0.0137, 1.2344, 0.0141],
(-110, -170) : ['B', 9, 123.2, 2.05, 110.14, 1.72, 109.96, 1.58, 112.43, 1.91, 121.46, 1.33, 115.9, 1.21, 122.59, 1.35, 1.329, 0.0176, 1.4529, 0.0139, 1.5305, 0.0168, 1.5278, 0.0151, 1.2367, 0.015],
(-110, -160) : ['B', 3, 123.16, 2.32, 109.1, 1.77, 109.8, 1.7, 113.37, 1.61, 120.77, 1.06, 116.34, 1.04, 122.84, 1.1, 1.3316, 0.0141, 1.4512, 0.0162, 1.5315, 0.0169, 1.5311, 0.0139, 1.2398, 0.0146],
(-110, -150) : ['B', 3, 123.99, 2.08, 108.96, 1.23, 109.29, 1.41, 114.4, 1.25, 119.91, 0.96, 116.93, 0.9, 123.13, 1.07, 1.3316, 0.0102, 1.451, 0.0164, 1.5263, 0.0128, 1.5318, 0.0115, 1.2441, 0.0117],
(-110, -130) : ['B', 3, 123.13, 1.07, 109.95, 0.43, 108.75, 0.96, 116.53, 1.47, 118.33, 0.63, 119.95, 1.19, 121.65, 0.83, 1.3245, 0.0097, 1.4603, 0.0082, 1.5228, 0.0155, 1.5306, 0.0054, 1.2321, 0.0039],
(-110, -100) : ['B', 5, 121.98, 1.35, 111.04, 1.68, 108.12, 1.59, 115.28, 2.01, 119.55, 0.61, 119.56, 0.58, 120.71, 0.9, 1.3387, 0.0137, 1.453, 0.0126, 1.5341, 0.0124, 1.5186, 0.0053, 1.2452, 0.0159],
(-110, -90) : ['B', 3, 121.64, 1.2, 111.15, 1.95, 108.48, 1.65, 114.52, 1.81, 119.68, 0.71, 119.46, 0.61, 120.58, 1.13, 1.3365, 0.0125, 1.4526, 0.0136, 1.5351, 0.0119, 1.5172, 0.0063, 1.2469, 0.0161],
(-110, -70) : ['B', 3, 122.44, 1.19, 111.0, 1.99, 111.02, 1.52, 111.65, 1.44, 119.98, 1.21, 118.24, 1.18, 121.76, 1.15, 1.3327, 0.0116, 1.4591, 0.0106, 1.5305, 0.0145, 1.5244, 0.007, 1.2332, 0.0132],
(-110, -60) : ['B', 12, 122.56, 1.5, 110.48, 1.98, 112.13, 1.37, 110.83, 1.58, 120.16, 1.49, 117.88, 1.4, 121.92, 1.3, 1.3327, 0.0131, 1.4569, 0.0124, 1.535, 0.0169, 1.5232, 0.0084, 1.2343, 0.013],
(-110, -50) : ['B', 16, 122.79, 1.7, 110.34, 1.74, 112.93, 1.33, 110.08, 1.57, 120.07, 1.35, 117.82, 1.46, 122.03, 1.36, 1.3317, 0.0129, 1.4569, 0.0125, 1.5356, 0.0165, 1.5206, 0.0099, 1.2349, 0.0143],
(-110, -40) : ['B', 17, 122.79, 1.78, 110.4, 1.45, 113.55, 1.26, 109.34, 1.55, 119.67, 1.15, 118.09, 1.63, 122.13, 1.5, 1.3306, 0.0138, 1.4579, 0.013, 1.5328, 0.016, 1.5191, 0.0122, 1.2329, 0.0153],
(-110, -30) : ['B', 34, 122.36, 1.72, 110.59, 1.33, 113.88, 1.23, 109.03, 1.62, 119.24, 1.13, 118.29, 1.47, 122.36, 1.34, 1.3325, 0.0138, 1.4563, 0.0128, 1.5338, 0.0145, 1.5193, 0.0132, 1.2325, 0.0138],
(-110, -20) : ['B', 43, 122.11, 1.64, 110.67, 1.39, 113.97, 1.28, 109.07, 1.68, 118.97, 1.07, 118.47, 1.26, 122.48, 1.21, 1.3348, 0.0142, 1.4549, 0.0129, 1.5358, 0.0142, 1.5206, 0.0127, 1.2348, 0.0125],
(-110, -10) : ['B', 55, 122.26, 1.59, 110.65, 1.47, 113.72, 1.3, 109.55, 1.68, 119.05, 1.1, 118.55, 1.24, 122.35, 1.23, 1.3334, 0.0149, 1.4546, 0.0137, 1.5359, 0.0153, 1.5213, 0.0129, 1.236, 0.0132],
(-110, 0) : ['B', 80, 122.49, 1.55, 110.61, 1.51, 113.3, 1.34, 110.17, 1.69, 119.32, 1.19, 118.4, 1.28, 122.24, 1.21, 1.332, 0.0139, 1.4553, 0.0133, 1.533, 0.016, 1.5215, 0.0131, 1.2357, 0.0139],
(-110, 10) : ['B', 101, 122.6, 1.56, 110.73, 1.55, 112.88, 1.29, 110.72, 1.69, 119.59, 1.18, 118.11, 1.27, 122.25, 1.19, 1.3324, 0.0129, 1.4565, 0.0122, 1.53, 0.0154, 1.523, 0.0134, 1.2356, 0.0138],
(-110, 20) : ['B', 71, 122.67, 1.59, 110.92, 1.6, 112.59, 1.22, 111.02, 1.61, 119.95, 1.18, 117.71, 1.28, 122.26, 1.23, 1.3336, 0.013, 1.457, 0.0116, 1.5288, 0.014, 1.5247, 0.0135, 1.2351, 0.0132],
(-110, 30) : ['B', 30, 122.86, 1.53, 111.17, 1.64, 112.26, 1.32, 111.13, 1.61, 120.55, 1.21, 117.15, 1.44, 122.2, 1.28, 1.333, 0.0142, 1.4572, 0.0116, 1.5275, 0.0135, 1.526, 0.0128, 1.2333, 0.013],
(-110, 40) : ['B', 10, 123.17, 1.49, 111.25, 1.46, 111.81, 1.54, 111.23, 1.7, 121.17, 1.24, 116.73, 1.64, 121.97, 1.35, 1.3308, 0.0142, 1.4586, 0.0119, 1.526, 0.0136, 1.5259, 0.0123, 1.2324, 0.0136],
(-110, 70) : ['B', 4, 122.79, 1.34, 110.11, 1.57, 109.11, 1.42, 111.72, 1.53, 121.86, 1.39, 115.41, 1.34, 122.65, 1.24, 1.329, 0.0114, 1.459, 0.0161, 1.5346, 0.0303, 1.5261, 0.0097, 1.233, 0.0158],
(-110, 80) : ['B', 5, 123.12, 1.52, 110.29, 2.15, 107.73, 1.8, 111.73, 1.55, 121.58, 1.24, 115.68, 1.24, 122.64, 1.06, 1.3304, 0.0117, 1.4611, 0.0141, 1.536, 0.041, 1.5268, 0.0119, 1.2316, 0.0135],
(-110, 90) : ['B', 14, 123.23, 1.57, 110.56, 1.86, 107.41, 2.02, 111.41, 1.7, 121.11, 1.23, 115.96, 1.31, 122.84, 1.2, 1.3293, 0.0151, 1.4617, 0.0146, 1.5283, 0.0261, 1.5275, 0.0132, 1.2321, 0.012],
(-110, 100) : ['B', 46, 123.14, 1.48, 110.46, 1.69, 107.62, 1.97, 111.22, 1.72, 120.7, 1.14, 116.23, 1.37, 123.01, 1.3, 1.3299, 0.0176, 1.4612, 0.0138, 1.5263, 0.0153, 1.5256, 0.013, 1.2344, 0.0116],
(-110, 110) : ['B', 79, 123.11, 1.42, 110.47, 1.66, 107.99, 1.77, 110.79, 1.63, 120.46, 1.07, 116.37, 1.28, 123.13, 1.26, 1.3307, 0.0166, 1.4594, 0.0127, 1.5275, 0.0139, 1.524, 0.0127, 1.2358, 0.0117],
(-110, 120) : ['B', 150, 123.05, 1.4, 110.55, 1.57, 108.52, 1.63, 110.19, 1.64, 120.32, 1.1, 116.37, 1.19, 123.27, 1.18, 1.3299, 0.014, 1.4576, 0.0122, 1.529, 0.0138, 1.5227, 0.0123, 1.2359, 0.0119],
(-110, 130) : ['B', 230, 123.0, 1.38, 110.57, 1.57, 109.07, 1.61, 109.72, 1.73, 120.38, 1.09, 116.28, 1.26, 123.29, 1.18, 1.3296, 0.0132, 1.4564, 0.0121, 1.5306, 0.0152, 1.5221, 0.012, 1.2357, 0.0121],
(-110, 140) : ['B', 194, 122.93, 1.45, 110.69, 1.61, 109.59, 1.61, 109.38, 1.8, 120.71, 1.06, 116.02, 1.42, 123.21, 1.27, 1.3296, 0.0136, 1.4552, 0.0121, 1.5315, 0.0174, 1.5225, 0.0119, 1.2352, 0.0123],
(-110, 150) : ['B', 130, 122.87, 1.61, 110.85, 1.6, 109.95, 1.59, 109.37, 1.83, 121.16, 1.13, 115.6, 1.48, 123.16, 1.26, 1.3293, 0.0138, 1.454, 0.0119, 1.5321, 0.0174, 1.5232, 0.0118, 1.2344, 0.0122],
(-110, 160) : ['B', 85, 122.92, 1.76, 110.85, 1.54, 110.14, 1.55, 109.71, 1.8, 121.56, 1.21, 115.27, 1.47, 123.1, 1.29, 1.3289, 0.0136, 1.4538, 0.0118, 1.533, 0.016, 1.5233, 0.0119, 1.2341, 0.0128],
(-110, 170) : ['B', 39, 123.05, 1.79, 110.7, 1.49, 110.14, 1.47, 110.36, 1.78, 121.78, 1.28, 115.19, 1.48, 122.97, 1.39, 1.3283, 0.0137, 1.4546, 0.0125, 1.5334, 0.0151, 1.5237, 0.0123, 1.2339, 0.0134],
(-100, -180) : ['B', 20, 122.64, 1.77, 110.51, 1.61, 110.17, 1.51, 111.6, 2.0, 121.88, 1.3, 115.63, 1.36, 122.43, 1.26, 1.3296, 0.0153, 1.4525, 0.0122, 1.5301, 0.0149, 1.5272, 0.0142, 1.2334, 0.0131],
(-100, -170) : ['B', 6, 122.73, 1.92, 110.07, 1.81, 109.94, 1.57, 112.63, 2.16, 121.55, 1.26, 116.25, 1.3, 122.14, 1.28, 1.3286, 0.0171, 1.4517, 0.013, 1.53, 0.0161, 1.5279, 0.0145, 1.235, 0.0138],
(-100, -160) : ['B', 3, 122.82, 2.12, 109.18, 1.79, 109.63, 1.49, 113.45, 1.98, 120.89, 1.11, 116.82, 1.1, 122.2, 1.1, 1.3276, 0.0161, 1.4519, 0.0141, 1.5335, 0.017, 1.5314, 0.0132, 1.2365, 0.0135],
(-100, -130) : ['B', 3, 123.04, 1.08, 109.69, 0.32, 108.78, 0.82, 117.07, 1.44, 117.94, 0.58, 120.47, 1.03, 121.47, 0.75, 1.3258, 0.0083, 1.4566, 0.0064, 1.5285, 0.0155, 1.5331, 0.0056, 1.2326, 0.0038],
(-100, -60) : ['B', 4, 122.42, 1.55, 110.27, 1.79, 111.96, 1.41, 110.88, 1.77, 120.42, 1.48, 117.34, 1.22, 122.19, 1.18, 1.3333, 0.0125, 1.4593, 0.0128, 1.5347, 0.0158, 1.5252, 0.0102, 1.2345, 0.0117],
(-100, -50) : ['B', 17, 122.6, 1.88, 110.33, 1.68, 112.68, 1.33, 110.24, 1.67, 120.13, 1.4, 117.6, 1.39, 122.19, 1.31, 1.3324, 0.0129, 1.4578, 0.0127, 1.5334, 0.0158, 1.5236, 0.0116, 1.2344, 0.0135],
(-100, -40) : ['B', 29, 122.53, 1.92, 110.42, 1.53, 113.12, 1.25, 109.56, 1.65, 119.78, 1.21, 117.93, 1.55, 122.2, 1.46, 1.3319, 0.0135, 1.4576, 0.0128, 1.5318, 0.0157, 1.5218, 0.0131, 1.2347, 0.014],
(-100, -30) : ['B', 48, 122.09, 1.79, 110.47, 1.46, 113.41, 1.22, 109.24, 1.75, 119.41, 1.13, 118.14, 1.56, 122.36, 1.42, 1.3321, 0.0136, 1.4569, 0.0127, 1.5325, 0.0153, 1.5207, 0.0136, 1.2353, 0.0131],
(-100, -20) : ['B', 52, 121.92, 1.73, 110.53, 1.47, 113.5, 1.23, 109.29, 1.82, 119.14, 1.1, 118.31, 1.4, 122.49, 1.34, 1.3334, 0.0143, 1.456, 0.0132, 1.5335, 0.0158, 1.5217, 0.0132, 1.2359, 0.0128],
(-100, -10) : ['B', 88, 122.26, 1.73, 110.53, 1.49, 113.38, 1.23, 109.65, 1.74, 119.15, 1.14, 118.38, 1.3, 122.42, 1.31, 1.3327, 0.0147, 1.4556, 0.0135, 1.5337, 0.0171, 1.5224, 0.0134, 1.2356, 0.0134],
(-100, 0) : ['B', 151, 122.54, 1.65, 110.49, 1.48, 113.17, 1.26, 110.09, 1.67, 119.35, 1.17, 118.27, 1.31, 122.34, 1.25, 1.3313, 0.0143, 1.4556, 0.0132, 1.5319, 0.0174, 1.5221, 0.014, 1.2349, 0.0138],
(-100, 10) : ['B', 145, 122.65, 1.6, 110.56, 1.46, 112.92, 1.23, 110.56, 1.69, 119.56, 1.17, 118.06, 1.26, 122.34, 1.2, 1.3317, 0.0134, 1.4555, 0.0126, 1.5297, 0.0164, 1.5229, 0.0148, 1.2351, 0.0134],
(-100, 20) : ['B', 71, 122.73, 1.61, 110.7, 1.49, 112.72, 1.14, 110.94, 1.65, 119.78, 1.19, 117.79, 1.22, 122.35, 1.23, 1.3331, 0.0127, 1.4558, 0.0118, 1.529, 0.0146, 1.5244, 0.0148, 1.2357, 0.0128],
(-100, 30) : ['B', 17, 122.83, 1.54, 110.91, 1.58, 112.57, 1.13, 111.06, 1.55, 120.15, 1.29, 117.51, 1.32, 122.19, 1.29, 1.3337, 0.0124, 1.4573, 0.011, 1.5282, 0.0137, 1.5249, 0.0138, 1.2358, 0.0134],
(-100, 40) : ['B', 6, 122.95, 1.66, 110.79, 1.48, 112.25, 1.36, 111.14, 1.39, 120.65, 1.64, 117.42, 1.89, 121.63, 1.52, 1.3315, 0.0114, 1.4615, 0.0115, 1.5252, 0.0143, 1.5225, 0.0143, 1.2343, 0.0155],
(-100, 50) : ['B', 6, 122.62, 1.78, 110.42, 1.37, 111.55, 1.37, 111.4, 1.29, 121.38, 1.76, 116.55, 2.23, 121.89, 1.55, 1.3277, 0.0113, 1.4638, 0.012, 1.5236, 0.0151, 1.5235, 0.0138, 1.2307, 0.0171],
(-100, 60) : ['B', 8, 122.24, 1.46, 110.35, 1.15, 110.65, 1.26, 111.74, 1.37, 122.2, 1.57, 115.05, 1.74, 122.67, 1.52, 1.3289, 0.0133, 1.4628, 0.0127, 1.526, 0.0149, 1.528, 0.0111, 1.2314, 0.0187],
(-100, 70) : ['B', 5, 122.06, 1.39, 110.35, 1.12, 109.71, 1.41, 112.07, 1.48, 122.51, 1.34, 114.59, 1.48, 122.83, 1.31, 1.331, 0.0133, 1.4617, 0.0144, 1.526, 0.0151, 1.5283, 0.0104, 1.2318, 0.0161],
(-100, 80) : ['B', 5, 122.41, 1.41, 110.49, 1.47, 108.24, 1.81, 112.05, 1.52, 122.13, 1.13, 115.25, 1.34, 122.55, 1.13, 1.3333, 0.0133, 1.4621, 0.0138, 1.5261, 0.0176, 1.5265, 0.0111, 1.2311, 0.0141],
(-100, 90) : ['B', 18, 122.77, 1.48, 110.53, 1.66, 107.57, 1.94, 111.68, 1.67, 121.39, 1.12, 115.9, 1.36, 122.63, 1.22, 1.3313, 0.0151, 1.4628, 0.0137, 1.5247, 0.0147, 1.5256, 0.0122, 1.2315, 0.0132],
(-100, 100) : ['B', 47, 122.85, 1.39, 110.39, 1.65, 107.75, 1.86, 111.31, 1.68, 120.84, 1.08, 116.21, 1.36, 122.87, 1.23, 1.3308, 0.0166, 1.4616, 0.0135, 1.5253, 0.0129, 1.5251, 0.0129, 1.2336, 0.0119],
(-100, 110) : ['B', 95, 122.84, 1.3, 110.37, 1.65, 108.2, 1.71, 110.78, 1.6, 120.54, 1.04, 116.36, 1.28, 123.05, 1.19, 1.331, 0.0165, 1.459, 0.0127, 1.5273, 0.013, 1.5248, 0.0128, 1.2354, 0.0119],
(-100, 120) : ['B', 150, 122.77, 1.33, 110.42, 1.63, 108.73, 1.63, 110.19, 1.62, 120.36, 1.07, 116.37, 1.23, 123.22, 1.14, 1.33, 0.0146, 1.4572, 0.0123, 1.5287, 0.0134, 1.5238, 0.0123, 1.2359, 0.0122],
(-100, 130) : ['B', 185, 122.72, 1.38, 110.43, 1.63, 109.24, 1.63, 109.75, 1.65, 120.43, 1.09, 116.25, 1.23, 123.27, 1.13, 1.3296, 0.0139, 1.4565, 0.0123, 1.5297, 0.0143, 1.5228, 0.0123, 1.2356, 0.0121],
(-100, 140) : ['B', 146, 122.65, 1.49, 110.52, 1.65, 109.76, 1.64, 109.48, 1.68, 120.8, 1.11, 115.96, 1.29, 123.19, 1.17, 1.3293, 0.0143, 1.4554, 0.0122, 1.5302, 0.0155, 1.5228, 0.0124, 1.2346, 0.0118],
(-100, 150) : ['B', 112, 122.64, 1.7, 110.63, 1.63, 110.17, 1.61, 109.5, 1.69, 121.28, 1.18, 115.55, 1.33, 123.1, 1.15, 1.3288, 0.0144, 1.4543, 0.0117, 1.5304, 0.0158, 1.5237, 0.0125, 1.2337, 0.0117],
(-100, 160) : ['B', 67, 122.74, 1.82, 110.56, 1.56, 110.42, 1.55, 109.8, 1.65, 121.66, 1.22, 115.23, 1.3, 123.03, 1.13, 1.3281, 0.0142, 1.4543, 0.0115, 1.5313, 0.0158, 1.5245, 0.0131, 1.2335, 0.0125],
(-100, 170) : ['B', 38, 122.67, 1.73, 110.46, 1.55, 110.46, 1.48, 110.45, 1.73, 121.89, 1.27, 115.21, 1.33, 122.84, 1.16, 1.3282, 0.014, 1.4543, 0.0116, 1.5319, 0.0159, 1.5255, 0.0136, 1.2331, 0.013],
(-90, -180) : ['B', 28, 122.02, 1.89, 110.49, 1.53, 110.36, 1.55, 111.78, 2.2, 121.82, 1.21, 115.9, 1.56, 122.2, 1.24, 1.3304, 0.0147, 1.4525, 0.0125, 1.5279, 0.0148, 1.5278, 0.0135, 1.2334, 0.0128],
(-90, -170) : ['B', 13, 122.12, 1.76, 110.39, 1.59, 109.86, 1.55, 113.15, 2.38, 121.5, 1.25, 116.58, 1.55, 121.83, 1.28, 1.3296, 0.016, 1.4539, 0.0117, 1.5272, 0.0149, 1.5285, 0.0128, 1.2339, 0.0116],
(-90, -160) : ['B', 4, 122.15, 1.74, 109.94, 1.44, 109.31, 1.42, 114.16, 2.31, 120.84, 1.33, 117.21, 1.42, 121.78, 1.31, 1.3289, 0.0167, 1.4554, 0.0109, 1.5319, 0.0154, 1.5305, 0.0112, 1.2339, 0.01],
(-90, -70) : ['B', 3, 121.71, 1.39, 110.39, 1.54, 110.56, 1.94, 112.0, 1.79, 120.71, 1.1, 116.84, 1.12, 122.38, 1.08, 1.3324, 0.0154, 1.4682, 0.0124, 1.53, 0.0124, 1.5261, 0.0092, 1.2343, 0.0083],
(-90, -60) : ['B', 6, 121.81, 1.83, 110.14, 1.56, 111.56, 1.53, 111.03, 1.87, 120.56, 1.21, 117.07, 1.21, 122.32, 1.15, 1.3327, 0.0126, 1.4597, 0.0122, 1.533, 0.0146, 1.5268, 0.0121, 1.235, 0.011],
(-90, -50) : ['B', 18, 121.8, 2.16, 110.19, 1.55, 112.04, 1.44, 110.56, 1.83, 120.31, 1.25, 117.32, 1.42, 122.3, 1.35, 1.3325, 0.0137, 1.4576, 0.0127, 1.5317, 0.0162, 1.5252, 0.0129, 1.2349, 0.0123],
(-90, -40) : ['B', 39, 121.64, 2.13, 110.26, 1.49, 112.45, 1.39, 110.11, 1.89, 120.0, 1.22, 117.65, 1.55, 122.28, 1.47, 1.3327, 0.0145, 1.4575, 0.0128, 1.5308, 0.0159, 1.5235, 0.0137, 1.2358, 0.0128],
(-90, -30) : ['B', 79, 121.52, 1.84, 110.33, 1.5, 112.9, 1.31, 109.67, 2.01, 119.6, 1.17, 117.96, 1.51, 122.36, 1.42, 1.3326, 0.015, 1.457, 0.0129, 1.5311, 0.0156, 1.5215, 0.014, 1.2366, 0.0131],
(-90, -20) : ['B', 98, 121.66, 1.76, 110.44, 1.56, 113.23, 1.24, 109.55, 2.03, 119.27, 1.17, 118.21, 1.36, 122.46, 1.37, 1.3328, 0.0155, 1.4561, 0.0133, 1.5318, 0.0165, 1.5216, 0.0137, 1.2364, 0.0132],
(-90, -10) : ['B', 182, 122.06, 1.86, 110.46, 1.57, 113.28, 1.22, 109.72, 1.92, 119.18, 1.19, 118.36, 1.33, 122.41, 1.42, 1.3319, 0.0153, 1.4558, 0.0133, 1.5323, 0.0179, 1.5224, 0.0137, 1.2358, 0.0132],
(-90, 0) : ['B', 218, 122.38, 1.81, 110.44, 1.53, 113.16, 1.24, 110.01, 1.8, 119.28, 1.21, 118.32, 1.35, 122.37, 1.38, 1.3306, 0.0148, 1.456, 0.0132, 1.5319, 0.0178, 1.5226, 0.0141, 1.2354, 0.0133],
(-90, 10) : ['B', 106, 122.56, 1.72, 110.47, 1.45, 113.02, 1.2, 110.37, 1.78, 119.43, 1.21, 118.13, 1.28, 122.39, 1.29, 1.3309, 0.0143, 1.4556, 0.0132, 1.5306, 0.0169, 1.5233, 0.0156, 1.2353, 0.0133],
(-90, 20) : ['B', 30, 122.65, 1.66, 110.56, 1.38, 112.93, 1.12, 110.81, 1.73, 119.59, 1.23, 117.96, 1.23, 122.37, 1.28, 1.3328, 0.0136, 1.4553, 0.0125, 1.53, 0.0151, 1.5244, 0.0166, 1.2365, 0.0133],
(-90, 30) : ['B', 7, 122.66, 1.63, 110.65, 1.42, 112.97, 1.06, 111.17, 1.53, 119.8, 1.34, 117.92, 1.35, 122.06, 1.34, 1.3349, 0.0139, 1.4577, 0.0112, 1.529, 0.0134, 1.5236, 0.0159, 1.2386, 0.0147],
(-90, 40) : ['B', 8, 122.61, 1.94, 110.22, 1.63, 112.72, 1.36, 111.22, 1.23, 120.42, 1.8, 117.65, 1.98, 121.53, 1.6, 1.3313, 0.0132, 1.4624, 0.0131, 1.5248, 0.0136, 1.5209, 0.0165, 1.2346, 0.0159],
(-90, 50) : ['B', 11, 122.27, 1.85, 110.25, 1.5, 111.81, 1.44, 111.5, 1.29, 121.53, 1.74, 116.2, 2.01, 122.08, 1.46, 1.3296, 0.012, 1.4627, 0.0131, 1.5237, 0.0131, 1.5258, 0.0136, 1.2302, 0.0156],
(-90, 60) : ['B', 26, 122.08, 1.5, 110.45, 1.26, 110.68, 1.39, 111.88, 1.41, 122.38, 1.49, 114.87, 1.55, 122.68, 1.38, 1.3316, 0.0131, 1.4629, 0.0124, 1.5243, 0.013, 1.5301, 0.0114, 1.2307, 0.0162],
(-90, 70) : ['B', 36, 122.05, 1.48, 110.53, 1.22, 109.62, 1.5, 112.12, 1.5, 122.63, 1.29, 114.6, 1.3, 122.71, 1.25, 1.3327, 0.0128, 1.4635, 0.013, 1.5233, 0.0127, 1.5295, 0.0111, 1.2324, 0.0136],
(-90, 80) : ['B', 23, 122.16, 1.5, 110.57, 1.35, 108.56, 1.74, 112.03, 1.56, 122.37, 1.15, 115.1, 1.26, 122.46, 1.19, 1.334, 0.0129, 1.4631, 0.0131, 1.5236, 0.0133, 1.5262, 0.012, 1.2329, 0.0127],
(-90, 90) : ['B', 32, 122.34, 1.6, 110.49, 1.48, 107.98, 1.88, 111.68, 1.68, 121.58, 1.12, 115.89, 1.4, 122.43, 1.3, 1.3322, 0.014, 1.4628, 0.0128, 1.5236, 0.013, 1.5232, 0.0125, 1.2318, 0.0137],
(-90, 100) : ['B', 58, 122.41, 1.47, 110.35, 1.49, 107.99, 1.76, 111.3, 1.7, 120.92, 1.04, 116.32, 1.37, 122.68, 1.27, 1.3311, 0.014, 1.4619, 0.0126, 1.5246, 0.0125, 1.5238, 0.0127, 1.2334, 0.0126],
(-90, 110) : ['B', 92, 122.42, 1.33, 110.21, 1.59, 108.41, 1.61, 110.81, 1.65, 120.58, 1.07, 116.43, 1.27, 122.93, 1.2, 1.3308, 0.0143, 1.4593, 0.0123, 1.5266, 0.0127, 1.5247, 0.0125, 1.2354, 0.0123],
(-90, 120) : ['B', 117, 122.3, 1.35, 110.17, 1.68, 108.96, 1.59, 110.22, 1.67, 120.43, 1.12, 116.39, 1.26, 123.13, 1.15, 1.3302, 0.0141, 1.4573, 0.0123, 1.5282, 0.0135, 1.5242, 0.0122, 1.236, 0.0124],
(-90, 130) : ['B', 161, 122.19, 1.41, 110.16, 1.65, 109.46, 1.66, 109.8, 1.64, 120.54, 1.13, 116.2, 1.25, 123.22, 1.14, 1.3303, 0.0142, 1.4563, 0.0129, 1.5293, 0.0143, 1.5233, 0.0124, 1.2353, 0.0122],
(-90, 140) : ['B', 135, 122.09, 1.48, 110.23, 1.62, 109.96, 1.68, 109.53, 1.65, 120.92, 1.15, 115.86, 1.24, 123.16, 1.16, 1.33, 0.0145, 1.4554, 0.0133, 1.5297, 0.0148, 1.5228, 0.0128, 1.2344, 0.0122],
(-90, 150) : ['B', 98, 122.07, 1.71, 110.41, 1.63, 110.32, 1.59, 109.51, 1.71, 121.36, 1.2, 115.51, 1.24, 123.06, 1.12, 1.329, 0.0143, 1.4543, 0.0127, 1.5297, 0.0155, 1.5236, 0.0133, 1.234, 0.0123],
(-90, 160) : ['B', 79, 122.07, 2.01, 110.46, 1.6, 110.52, 1.48, 109.83, 1.75, 121.72, 1.18, 115.27, 1.24, 122.94, 1.12, 1.3283, 0.0144, 1.4538, 0.0121, 1.5294, 0.0164, 1.5256, 0.0142, 1.2333, 0.0128],
(-90, 170) : ['B', 63, 122.03, 2.01, 110.42, 1.52, 110.59, 1.45, 110.51, 1.89, 121.89, 1.17, 115.36, 1.37, 122.68, 1.17, 1.3287, 0.0144, 1.4533, 0.0122, 1.5289, 0.0165, 1.5271, 0.0141, 1.2329, 0.0132],
(-80, -180) : ['B', 26, 121.66, 1.92, 110.38, 1.38, 110.35, 1.38, 111.71, 2.23, 121.88, 1.13, 115.82, 1.6, 122.23, 1.33, 1.3304, 0.0137, 1.4534, 0.0127, 1.5269, 0.0144, 1.5277, 0.0133, 1.2343, 0.0131],
(-80, -170) : ['B', 16, 121.86, 1.65, 110.45, 1.44, 109.79, 1.56, 113.33, 2.26, 121.67, 1.26, 116.5, 1.63, 121.74, 1.31, 1.3298, 0.0142, 1.4562, 0.0114, 1.5262, 0.0144, 1.5282, 0.0134, 1.2341, 0.0107],
(-80, -70) : ['B', 3, 120.89, 1.5, 110.1, 1.42, 111.04, 1.55, 111.39, 1.59, 120.89, 1.05, 116.93, 1.26, 122.11, 1.18, 1.3333, 0.0124, 1.463, 0.0108, 1.5323, 0.0128, 1.5263, 0.0107, 1.2348, 0.0103],
(-80, -60) : ['B', 13, 120.88, 1.62, 110.07, 1.47, 111.24, 1.29, 110.86, 1.65, 120.8, 1.05, 117.04, 1.24, 122.11, 1.16, 1.3336, 0.013, 1.4592, 0.012, 1.5312, 0.0157, 1.525, 0.0125, 1.2357, 0.0117],
(-80, -50) : ['B', 41, 120.71, 1.67, 110.13, 1.48, 111.4, 1.22, 110.79, 1.68, 120.55, 1.07, 117.23, 1.31, 122.17, 1.21, 1.334, 0.0141, 1.4587, 0.0124, 1.5297, 0.0163, 1.5242, 0.0129, 1.2359, 0.0119],
(-80, -40) : ['B', 126, 120.58, 1.71, 110.2, 1.49, 111.69, 1.23, 110.7, 1.83, 120.24, 1.11, 117.48, 1.41, 122.23, 1.3, 1.3343, 0.0143, 1.4585, 0.0126, 1.5289, 0.0162, 1.5238, 0.0132, 1.2361, 0.0122],
(-80, -30) : ['B', 165, 120.68, 1.7, 110.3, 1.54, 112.23, 1.26, 110.38, 2.04, 119.79, 1.18, 117.82, 1.42, 122.33, 1.34, 1.3344, 0.0146, 1.4579, 0.013, 1.5293, 0.0163, 1.5228, 0.0137, 1.2361, 0.0129],
(-80, -20) : ['B', 196, 121.14, 1.75, 110.4, 1.63, 112.89, 1.24, 109.99, 2.09, 119.31, 1.24, 118.17, 1.33, 122.46, 1.38, 1.3341, 0.0149, 1.4568, 0.0133, 1.53, 0.0168, 1.5222, 0.0139, 1.2358, 0.0132],
(-80, -10) : ['B', 265, 121.58, 1.95, 110.41, 1.68, 113.18, 1.21, 109.95, 1.99, 119.11, 1.28, 118.41, 1.34, 122.43, 1.46, 1.3332, 0.0149, 1.4565, 0.0131, 1.5305, 0.0175, 1.5224, 0.0137, 1.2358, 0.0131],
(-80, 0) : ['B', 129, 121.94, 2.0, 110.42, 1.62, 113.2, 1.21, 110.11, 1.9, 119.12, 1.31, 118.44, 1.41, 122.39, 1.48, 1.3318, 0.0152, 1.4568, 0.0132, 1.5308, 0.0172, 1.5226, 0.0141, 1.2358, 0.0135],
(-80, 10) : ['B', 33, 122.31, 2.0, 110.46, 1.54, 113.15, 1.19, 110.36, 1.85, 119.23, 1.54, 118.27, 1.59, 122.42, 1.61, 1.3312, 0.0162, 1.4567, 0.014, 1.5308, 0.0162, 1.5233, 0.018, 1.2358, 0.0147],
(-80, 20) : ['B', 3, 122.55, 2.03, 110.57, 1.45, 113.21, 1.15, 110.72, 1.77, 119.36, 1.81, 118.15, 1.8, 122.34, 1.8, 1.3327, 0.0173, 1.4563, 0.0144, 1.5305, 0.0148, 1.5236, 0.0225, 1.2371, 0.0162],
(-80, 40) : ['B', 3, 122.31, 1.81, 109.93, 1.82, 113.2, 1.36, 111.22, 1.24, 120.37, 1.56, 117.6, 1.76, 121.72, 1.44, 1.3314, 0.0178, 1.4619, 0.0136, 1.5267, 0.0115, 1.5234, 0.0162, 1.2334, 0.0138],
(-80, 60) : ['B', 11, 122.21, 1.48, 110.49, 1.58, 110.7, 1.55, 111.91, 1.52, 122.44, 1.34, 114.9, 1.37, 122.61, 1.32, 1.3335, 0.0125, 1.4622, 0.0123, 1.5231, 0.0121, 1.5311, 0.0112, 1.2307, 0.0124],
(-80, 70) : ['B', 23, 122.23, 1.54, 110.6, 1.51, 109.39, 1.59, 112.0, 1.61, 122.64, 1.25, 114.76, 1.14, 122.56, 1.31, 1.334, 0.0125, 1.4632, 0.0129, 1.5223, 0.0132, 1.5298, 0.011, 1.2329, 0.0109],
(-80, 80) : ['B', 32, 122.26, 1.6, 110.58, 1.44, 108.52, 1.74, 111.83, 1.6, 122.41, 1.21, 115.14, 1.22, 122.38, 1.32, 1.3336, 0.0127, 1.4629, 0.013, 1.5235, 0.0141, 1.5265, 0.0121, 1.2337, 0.0114],
(-80, 90) : ['B', 25, 122.32, 1.76, 110.46, 1.42, 108.17, 1.85, 111.41, 1.65, 121.66, 1.17, 115.84, 1.49, 122.41, 1.38, 1.3313, 0.0141, 1.4624, 0.0128, 1.5238, 0.0137, 1.5235, 0.0135, 1.232, 0.0137],
(-80, 100) : ['B', 40, 122.17, 1.62, 110.24, 1.45, 108.23, 1.72, 111.05, 1.69, 120.98, 1.08, 116.37, 1.45, 122.57, 1.34, 1.3307, 0.0137, 1.4615, 0.0127, 1.5244, 0.0127, 1.5233, 0.013, 1.2331, 0.0128],
(-80, 110) : ['B', 69, 121.99, 1.49, 109.94, 1.6, 108.67, 1.55, 110.77, 1.67, 120.6, 1.13, 116.54, 1.36, 122.82, 1.3, 1.331, 0.0138, 1.4594, 0.0124, 1.526, 0.0126, 1.524, 0.0126, 1.2354, 0.0122],
(-80, 120) : ['B', 97, 121.72, 1.45, 109.87, 1.63, 109.25, 1.53, 110.29, 1.64, 120.49, 1.16, 116.46, 1.35, 123.02, 1.23, 1.3306, 0.0142, 1.4575, 0.0124, 1.5271, 0.0138, 1.5241, 0.013, 1.2359, 0.0121],
(-80, 130) : ['B', 157, 121.5, 1.43, 109.95, 1.55, 109.76, 1.59, 109.84, 1.63, 120.69, 1.14, 116.23, 1.3, 123.04, 1.17, 1.3305, 0.0141, 1.4561, 0.0125, 1.5284, 0.0149, 1.5235, 0.0131, 1.2351, 0.0121],
(-80, 140) : ['B', 152, 121.42, 1.43, 110.06, 1.51, 110.2, 1.58, 109.53, 1.69, 121.05, 1.14, 115.86, 1.26, 123.01, 1.18, 1.3301, 0.0138, 1.4553, 0.013, 1.5289, 0.0153, 1.523, 0.013, 1.2344, 0.0123],
(-80, 150) : ['B', 121, 121.39, 1.66, 110.29, 1.52, 110.48, 1.48, 109.46, 1.84, 121.47, 1.15, 115.49, 1.24, 122.96, 1.13, 1.3295, 0.0136, 1.4542, 0.0131, 1.5291, 0.0158, 1.524, 0.0131, 1.2344, 0.0127],
(-80, 160) : ['B', 107, 121.32, 2.1, 110.45, 1.52, 110.55, 1.35, 109.76, 1.99, 121.81, 1.18, 115.27, 1.3, 122.85, 1.14, 1.3296, 0.0137, 1.453, 0.0131, 1.5291, 0.0166, 1.5263, 0.0137, 1.2341, 0.0133],
(-80, 170) : ['B', 79, 121.45, 2.14, 110.44, 1.43, 110.53, 1.29, 110.4, 2.07, 121.94, 1.15, 115.35, 1.42, 122.65, 1.23, 1.3299, 0.0138, 1.4527, 0.0131, 1.528, 0.0161, 1.5276, 0.0137, 1.234, 0.0135],
(-70, -180) : ['B', 10, 121.29, 1.74, 110.25, 1.36, 110.19, 1.24, 111.3, 2.23, 122.01, 1.05, 115.58, 1.55, 122.36, 1.34, 1.3305, 0.0126, 1.4539, 0.0134, 1.5268, 0.0144, 1.5284, 0.0139, 1.2345, 0.0138],
(-70, -170) : ['B', 5, 121.74, 1.58, 110.39, 1.51, 109.6, 1.53, 112.99, 2.1, 121.98, 1.13, 116.17, 1.54, 121.79, 1.24, 1.3282, 0.0126, 1.4564, 0.012, 1.5253, 0.0139, 1.5289, 0.014, 1.2342, 0.0114],
(-70, -60) : ['B', 19, 120.63, 1.36, 109.98, 1.45, 111.03, 1.11, 110.95, 1.55, 120.9, 1.03, 117.02, 1.17, 122.03, 1.08, 1.3339, 0.0127, 1.4593, 0.0118, 1.53, 0.0157, 1.5241, 0.0124, 1.2365, 0.0116],
(-70, -50) : ['B', 397, 120.44, 1.36, 110.07, 1.45, 111.14, 1.08, 110.9, 1.58, 120.7, 1.03, 117.17, 1.18, 122.09, 1.08, 1.3343, 0.0133, 1.4592, 0.012, 1.5289, 0.0158, 1.5238, 0.0126, 1.2366, 0.0116],
(-70, -40) : ['B', 1251, 120.29, 1.42, 110.16, 1.48, 111.36, 1.09, 110.85, 1.7, 120.42, 1.06, 117.39, 1.24, 122.15, 1.14, 1.3348, 0.0136, 1.4591, 0.0123, 1.5283, 0.0159, 1.5235, 0.0129, 1.2366, 0.0119],
(-70, -30) : ['B', 631, 120.31, 1.52, 110.28, 1.55, 111.82, 1.16, 110.67, 1.92, 119.97, 1.15, 117.72, 1.31, 122.27, 1.23, 1.3351, 0.0138, 1.4586, 0.0128, 1.5284, 0.0166, 1.5229, 0.0135, 1.2363, 0.0126],
(-70, -20) : ['B', 436, 120.72, 1.67, 110.39, 1.66, 112.54, 1.22, 110.31, 2.09, 119.38, 1.23, 118.14, 1.31, 122.43, 1.34, 1.3349, 0.0138, 1.4575, 0.0133, 1.5291, 0.0174, 1.5224, 0.014, 1.2356, 0.0129],
(-70, -10) : ['B', 279, 121.18, 1.98, 110.39, 1.75, 113.01, 1.2, 110.17, 2.04, 119.05, 1.3, 118.43, 1.33, 122.46, 1.38, 1.3343, 0.0138, 1.4571, 0.0135, 1.5294, 0.0178, 1.5222, 0.0138, 1.2357, 0.0129],
(-70, 0) : ['B', 51, 121.52, 2.34, 110.42, 1.76, 113.19, 1.19, 110.27, 1.94, 118.91, 1.6, 118.59, 1.63, 122.41, 1.6, 1.3333, 0.0156, 1.4576, 0.0142, 1.5295, 0.0169, 1.5217, 0.0172, 1.2362, 0.0147],
(-70, 10) : ['B', 5, 122.2, 3.42, 110.67, 2.08, 113.37, 1.38, 110.57, 1.93, 118.58, 3.46, 118.87, 3.45, 122.06, 3.24, 1.3307, 0.0256, 1.4602, 0.0212, 1.5291, 0.0153, 1.5179, 0.0401, 1.2388, 0.025],
(-70, 80) : ['B', 4, 122.32, 1.63, 110.42, 1.66, 108.58, 1.82, 111.5, 1.64, 122.36, 1.21, 115.29, 1.18, 122.29, 1.4, 1.3334, 0.0131, 1.4628, 0.0123, 1.5244, 0.0153, 1.5265, 0.0115, 1.2334, 0.0106],
(-70, 100) : ['B', 4, 122.07, 1.7, 109.88, 1.58, 108.63, 1.6, 110.88, 1.6, 121.02, 1.15, 116.45, 1.46, 122.48, 1.36, 1.3302, 0.0143, 1.4614, 0.013, 1.5245, 0.0122, 1.5231, 0.013, 1.2328, 0.0121],
(-70, 110) : ['B', 17, 121.66, 1.56, 109.6, 1.64, 109.15, 1.44, 110.67, 1.52, 120.62, 1.19, 116.57, 1.39, 122.77, 1.35, 1.3309, 0.0142, 1.4595, 0.0128, 1.5257, 0.0125, 1.5238, 0.0129, 1.2352, 0.0115],
(-70, 120) : ['B', 72, 121.24, 1.44, 109.71, 1.54, 109.59, 1.47, 110.26, 1.5, 120.58, 1.16, 116.43, 1.37, 122.96, 1.26, 1.3306, 0.0144, 1.4575, 0.0125, 1.5266, 0.0144, 1.5241, 0.0135, 1.2356, 0.0117],
(-70, 130) : ['B', 187, 120.95, 1.4, 109.85, 1.49, 109.96, 1.5, 109.89, 1.6, 120.81, 1.15, 116.21, 1.33, 122.93, 1.23, 1.3305, 0.0137, 1.4564, 0.0122, 1.5279, 0.0158, 1.5237, 0.0133, 1.2349, 0.012],
(-70, 140) : ['B', 209, 120.87, 1.42, 109.97, 1.47, 110.28, 1.48, 109.65, 1.71, 121.16, 1.12, 115.88, 1.28, 122.89, 1.22, 1.3301, 0.0132, 1.4557, 0.0122, 1.5284, 0.0166, 1.5236, 0.013, 1.2342, 0.0122],
(-70, 150) : ['B', 177, 120.94, 1.57, 110.17, 1.44, 110.5, 1.41, 109.54, 1.84, 121.56, 1.09, 115.51, 1.27, 122.86, 1.18, 1.3299, 0.0131, 1.4548, 0.0127, 1.5287, 0.0166, 1.5248, 0.0132, 1.234, 0.0127],
(-70, 160) : ['B', 123, 120.97, 1.82, 110.36, 1.43, 110.53, 1.32, 109.68, 2.05, 121.87, 1.16, 115.27, 1.34, 122.79, 1.14, 1.33, 0.0131, 1.4535, 0.0134, 1.5289, 0.0161, 1.5267, 0.0135, 1.2343, 0.0136],
(-70, 170) : ['B', 65, 121.06, 1.88, 110.38, 1.37, 110.41, 1.23, 110.19, 2.18, 121.99, 1.14, 115.29, 1.44, 122.65, 1.22, 1.3304, 0.013, 1.4531, 0.0137, 1.5283, 0.0154, 1.5283, 0.0138, 1.2345, 0.014],
(-60, -60) : ['B', 40, 120.65, 1.32, 109.91, 1.46, 110.97, 1.09, 110.96, 1.54, 121.0, 1.05, 116.92, 1.16, 122.03, 1.04, 1.3339, 0.0123, 1.459, 0.0117, 1.5298, 0.0157, 1.5242, 0.0124, 1.2363, 0.0115],
(-60, -50) : ['B', 1284, 120.44, 1.3, 110.01, 1.45, 111.07, 1.07, 110.88, 1.57, 120.82, 1.05, 117.07, 1.14, 122.07, 1.03, 1.3344, 0.0127, 1.4593, 0.0119, 1.529, 0.0155, 1.5237, 0.0127, 1.2365, 0.0115],
(-60, -40) : ['B', 2245, 120.28, 1.34, 110.12, 1.47, 111.28, 1.09, 110.79, 1.66, 120.55, 1.06, 117.3, 1.16, 122.12, 1.06, 1.3349, 0.0131, 1.4591, 0.0121, 1.5285, 0.0156, 1.5233, 0.013, 1.2367, 0.0117],
(-60, -30) : ['B', 718, 120.28, 1.44, 110.22, 1.54, 111.71, 1.15, 110.63, 1.85, 120.1, 1.13, 117.63, 1.25, 122.22, 1.17, 1.3352, 0.0134, 1.4587, 0.0125, 1.5287, 0.0164, 1.5225, 0.0136, 1.2364, 0.0125],
(-60, -20) : ['B', 299, 120.6, 1.6, 110.32, 1.7, 112.38, 1.22, 110.32, 2.11, 119.49, 1.21, 118.08, 1.3, 122.39, 1.3, 1.3349, 0.0135, 1.4577, 0.013, 1.5293, 0.0178, 1.5221, 0.0141, 1.2359, 0.0128],
(-60, -10) : ['B', 59, 120.99, 1.86, 110.32, 1.82, 112.87, 1.2, 110.21, 2.19, 119.1, 1.26, 118.42, 1.31, 122.43, 1.33, 1.3345, 0.0133, 1.4573, 0.0135, 1.5297, 0.0187, 1.5219, 0.0143, 1.2361, 0.0128],
(-60, 120) : ['B', 33, 121.02, 1.48, 109.51, 1.58, 109.96, 1.49, 110.16, 1.44, 120.7, 1.15, 116.24, 1.34, 123.01, 1.33, 1.3305, 0.0145, 1.457, 0.013, 1.528, 0.0155, 1.5229, 0.0142, 1.235, 0.012],
(-60, 130) : ['B', 179, 120.82, 1.41, 109.69, 1.53, 110.1, 1.49, 109.9, 1.56, 120.92, 1.14, 116.06, 1.29, 122.95, 1.24, 1.3309, 0.0136, 1.4565, 0.0128, 1.5288, 0.0164, 1.5233, 0.0132, 1.2345, 0.012],
(-60, 140) : ['B', 224, 120.71, 1.42, 109.83, 1.51, 110.23, 1.45, 109.72, 1.66, 121.19, 1.1, 115.85, 1.29, 122.87, 1.23, 1.3308, 0.0133, 1.456, 0.0123, 1.5293, 0.0169, 1.5236, 0.0126, 1.2341, 0.0119],
(-60, 150) : ['B', 139, 120.75, 1.51, 110.04, 1.47, 110.35, 1.36, 109.62, 1.79, 121.55, 1.06, 115.56, 1.3, 122.81, 1.23, 1.3306, 0.0131, 1.4555, 0.0125, 1.5293, 0.017, 1.5246, 0.0128, 1.234, 0.0124],
(-60, 160) : ['B', 61, 120.87, 1.69, 110.26, 1.43, 110.43, 1.31, 109.65, 2.07, 121.87, 1.1, 115.3, 1.33, 122.75, 1.17, 1.3305, 0.0129, 1.4541, 0.0132, 1.5287, 0.0159, 1.5266, 0.0134, 1.2341, 0.014],
(-60, 170) : ['B', 21, 120.95, 1.78, 110.29, 1.36, 110.33, 1.29, 110.02, 2.3, 122.03, 1.13, 115.22, 1.43, 122.68, 1.18, 1.3306, 0.0129, 1.4528, 0.0141, 1.5281, 0.015, 1.5289, 0.0141, 1.2334, 0.0157],
(-50, -60) : ['B', 13, 120.79, 1.39, 109.82, 1.52, 111.02, 1.22, 110.92, 1.59, 121.07, 1.1, 116.79, 1.28, 122.08, 1.07, 1.3341, 0.012, 1.4586, 0.0116, 1.5303, 0.0158, 1.5245, 0.0128, 1.2359, 0.0116],
(-50, -50) : ['B', 233, 120.54, 1.35, 109.94, 1.49, 111.11, 1.2, 110.81, 1.6, 120.9, 1.07, 116.97, 1.2, 122.09, 1.04, 1.3345, 0.0125, 1.4591, 0.012, 1.5296, 0.0156, 1.5238, 0.0132, 1.2362, 0.0115],
(-50, -40) : ['B', 254, 120.38, 1.37, 110.06, 1.5, 111.33, 1.21, 110.68, 1.7, 120.63, 1.08, 117.22, 1.17, 122.12, 1.06, 1.335, 0.013, 1.459, 0.0123, 1.5293, 0.0158, 1.523, 0.0135, 1.2365, 0.0118],
(-50, -30) : ['B', 74, 120.38, 1.46, 110.14, 1.58, 111.75, 1.28, 110.46, 1.94, 120.2, 1.12, 117.56, 1.22, 122.2, 1.14, 1.3353, 0.0132, 1.4584, 0.0127, 1.5296, 0.0169, 1.522, 0.0139, 1.2364, 0.0124],
(-50, -20) : ['B', 8, 120.63, 1.61, 110.18, 1.8, 112.34, 1.3, 110.18, 2.24, 119.61, 1.18, 118.01, 1.3, 122.33, 1.3, 1.335, 0.0135, 1.4576, 0.0129, 1.5304, 0.0185, 1.5216, 0.0145, 1.2363, 0.0128],
(-50, 120) : ['B', 12, 121.26, 1.59, 109.28, 1.64, 110.3, 1.5, 110.06, 1.39, 120.8, 1.08, 116.07, 1.37, 123.07, 1.37, 1.3301, 0.0143, 1.4572, 0.0128, 1.5302, 0.0158, 1.5215, 0.014, 1.2346, 0.0126],
(-50, 130) : ['B', 82, 121.05, 1.43, 109.48, 1.55, 110.24, 1.47, 109.84, 1.5, 120.96, 1.09, 115.91, 1.29, 123.06, 1.2, 1.3311, 0.0133, 1.4566, 0.0131, 1.5301, 0.0157, 1.5228, 0.0128, 1.234, 0.0122],
(-50, 140) : ['B', 90, 120.9, 1.41, 109.69, 1.59, 110.24, 1.41, 109.7, 1.61, 121.15, 1.1, 115.79, 1.34, 122.97, 1.22, 1.3316, 0.0135, 1.4561, 0.0127, 1.5304, 0.0162, 1.5231, 0.0123, 1.2337, 0.0117],
(-50, 150) : ['B', 27, 120.82, 1.47, 109.92, 1.6, 110.24, 1.3, 109.64, 1.77, 121.44, 1.08, 115.64, 1.39, 122.82, 1.28, 1.3317, 0.0137, 1.4557, 0.0125, 1.5304, 0.0166, 1.5234, 0.0123, 1.2344, 0.0121],
(-40, -60) : ['B', 3, 121.19, 1.59, 109.72, 1.7, 111.37, 1.64, 110.84, 1.66, 121.02, 1.17, 116.69, 1.58, 122.2, 1.21, 1.3344, 0.012, 1.4573, 0.0117, 1.5322, 0.0158, 1.5249, 0.0137, 1.2362, 0.0121],
(-40, -50) : ['B', 7, 120.82, 1.5, 109.78, 1.63, 111.37, 1.65, 110.74, 1.66, 120.92, 1.12, 116.91, 1.45, 122.11, 1.15, 1.3345, 0.0127, 1.4585, 0.0123, 1.5308, 0.0159, 1.5238, 0.0144, 1.2356, 0.0118],
(-40, 120) : ['B', 5, 121.97, 1.73, 109.19, 1.54, 110.64, 1.48, 109.8, 1.23, 120.88, 0.94, 116.15, 1.34, 122.89, 1.24, 1.33, 0.0137, 1.4563, 0.0124, 1.5308, 0.0169, 1.5215, 0.0124, 1.2353, 0.0126],
(-40, 130) : ['B', 9, 121.56, 1.56, 109.34, 1.53, 110.42, 1.46, 109.71, 1.39, 120.95, 1.0, 115.86, 1.29, 123.11, 1.12, 1.331, 0.0129, 1.4567, 0.0131, 1.531, 0.0165, 1.5226, 0.0123, 1.2336, 0.0123],
(-40, 140) : ['B', 5, 121.31, 1.49, 109.56, 1.65, 110.35, 1.4, 109.61, 1.58, 121.07, 1.08, 115.73, 1.39, 123.12, 1.2, 1.3323, 0.0137, 1.4566, 0.0132, 1.5316, 0.0166, 1.5224, 0.0126, 1.2334, 0.0119],
(40, 50) : ['B', 5, 122.46, 1.41, 111.62, 1.43, 111.3, 1.36, 111.95, 1.5, 122.03, 1.17, 115.33, 1.34, 122.57, 1.25, 1.3299, 0.0129, 1.4597, 0.0154, 1.5271, 0.017, 1.5259, 0.0135, 1.2329, 0.0122],
(40, 60) : ['B', 4, 122.82, 1.42, 111.71, 1.52, 111.17, 1.41, 112.06, 1.57, 122.27, 1.16, 114.81, 1.42, 122.86, 1.2, 1.3277, 0.013, 1.4598, 0.0142, 1.5271, 0.0161, 1.5275, 0.0136, 1.2312, 0.0116],
(50, -150) : ['B', 3, 121.76, 2.19, 111.08, 2.12, 109.32, 1.84, 115.79, 1.19, 120.83, 1.43, 117.21, 1.44, 121.92, 2.08, 1.3248, 0.0114, 1.4632, 0.013, 1.5175, 0.0208, 1.5298, 0.014, 1.2352, 0.0103],
(50, -130) : ['B', 4, 122.89, 1.72, 111.04, 2.5, 108.31, 1.52, 116.54, 1.15, 119.21, 1.59, 119.52, 0.79, 121.23, 1.57, 1.3315, 0.014, 1.4665, 0.0173, 1.522, 0.0186, 1.5292, 0.0093, 1.2388, 0.0096],
(50, 20) : ['B', 3, 122.61, 1.56, 112.28, 1.49, 112.47, 1.24, 111.48, 1.59, 120.55, 1.28, 117.24, 1.65, 122.11, 1.89, 1.3324, 0.0141, 1.4617, 0.0148, 1.532, 0.0151, 1.5249, 0.0163, 1.2352, 0.0159],
(50, 30) : ['B', 22, 122.08, 1.47, 112.08, 1.51, 111.9, 1.32, 111.66, 1.57, 121.08, 1.25, 116.59, 1.47, 122.23, 1.61, 1.3331, 0.0139, 1.462, 0.0154, 1.5302, 0.0154, 1.5255, 0.0139, 1.2334, 0.0143],
(50, 40) : ['B', 69, 122.07, 1.43, 111.84, 1.49, 111.54, 1.36, 111.8, 1.46, 121.54, 1.16, 115.97, 1.27, 122.4, 1.31, 1.3323, 0.014, 1.4612, 0.0152, 1.529, 0.0162, 1.5261, 0.0129, 1.2329, 0.013],
(50, 50) : ['B', 61, 122.36, 1.42, 111.7, 1.48, 111.39, 1.38, 111.89, 1.42, 121.84, 1.16, 115.51, 1.3, 122.55, 1.24, 1.3313, 0.0136, 1.4603, 0.0151, 1.529, 0.0158, 1.527, 0.013, 1.233, 0.0128],
(50, 60) : ['B', 16, 122.68, 1.47, 111.65, 1.58, 111.24, 1.38, 112.09, 1.54, 122.14, 1.24, 114.92, 1.43, 122.86, 1.23, 1.3302, 0.013, 1.4599, 0.0145, 1.5304, 0.0151, 1.5287, 0.0126, 1.2323, 0.0137],
(50, 70) : ['B', 3, 122.78, 1.52, 111.4, 1.75, 111.02, 1.25, 112.3, 1.84, 122.45, 1.3, 114.17, 1.55, 123.32, 1.27, 1.3306, 0.0123, 1.4607, 0.0138, 1.5316, 0.0136, 1.5313, 0.0108, 1.231, 0.0147],
(60, -150) : ['B', 3, 121.53, 2.25, 111.15, 2.02, 109.02, 1.68, 115.89, 1.32, 120.71, 1.34, 117.19, 1.5, 122.05, 2.1, 1.3275, 0.0111, 1.4668, 0.0132, 1.5168, 0.0241, 1.5312, 0.0135, 1.238, 0.0102],
(60, -140) : ['B', 5, 122.04, 2.11, 111.3, 2.5, 108.0, 1.48, 116.34, 1.4, 119.8, 1.49, 118.73, 1.19, 121.42, 1.92, 1.327, 0.0106, 1.4707, 0.0174, 1.5134, 0.0259, 1.5322, 0.0112, 1.2406, 0.0108],
(60, -130) : ['B', 8, 122.66, 1.73, 111.16, 2.8, 108.08, 1.69, 116.63, 1.16, 119.13, 1.65, 119.63, 0.81, 121.2, 1.61, 1.3298, 0.0123, 1.4673, 0.0165, 1.5231, 0.0194, 1.5276, 0.0088, 1.2416, 0.01],
(60, -120) : ['B', 3, 123.04, 1.46, 110.71, 2.51, 108.67, 1.67, 117.23, 1.36, 118.65, 1.53, 119.98, 0.85, 121.33, 1.26, 1.3322, 0.0138, 1.4651, 0.0122, 1.5296, 0.0153, 1.5239, 0.0095, 1.2434, 0.0095],
(60, 10) : ['B', 7, 123.91, 1.66, 112.78, 1.53, 113.38, 1.17, 111.23, 1.63, 119.78, 1.07, 118.08, 1.31, 122.04, 1.4, 1.3306, 0.014, 1.459, 0.0115, 1.5334, 0.0166, 1.5226, 0.0149, 1.2371, 0.0161],
(60, 20) : ['B', 33, 123.05, 1.57, 112.41, 1.55, 112.86, 1.22, 111.36, 1.63, 120.32, 1.18, 117.49, 1.62, 122.09, 1.83, 1.332, 0.014, 1.4599, 0.0139, 1.5324, 0.0156, 1.524, 0.0157, 1.2353, 0.0162],
(60, 30) : ['B', 75, 122.4, 1.45, 112.3, 1.52, 112.24, 1.28, 111.51, 1.58, 120.81, 1.24, 116.87, 1.56, 122.21, 1.73, 1.333, 0.0139, 1.4613, 0.0149, 1.5309, 0.0151, 1.5254, 0.014, 1.2335, 0.0144],
(60, 40) : ['B', 86, 122.19, 1.41, 112.13, 1.51, 111.74, 1.35, 111.73, 1.42, 121.28, 1.19, 116.21, 1.29, 122.41, 1.34, 1.3328, 0.0145, 1.4619, 0.0146, 1.5297, 0.015, 1.5266, 0.0127, 1.2327, 0.0129],
(60, 50) : ['B', 49, 122.34, 1.39, 111.91, 1.52, 111.52, 1.4, 111.86, 1.34, 121.65, 1.17, 115.67, 1.23, 122.58, 1.2, 1.3328, 0.0142, 1.4616, 0.0146, 1.5302, 0.0148, 1.528, 0.0125, 1.2328, 0.013],
(60, 60) : ['B', 20, 122.63, 1.44, 111.74, 1.58, 111.28, 1.35, 112.11, 1.46, 122.03, 1.25, 114.98, 1.34, 122.91, 1.19, 1.3326, 0.0129, 1.461, 0.0141, 1.5321, 0.0148, 1.5302, 0.0117, 1.2328, 0.0147],
(60, 70) : ['B', 4, 122.93, 1.51, 111.53, 1.66, 110.91, 1.17, 112.27, 1.75, 122.44, 1.32, 114.17, 1.45, 123.33, 1.22, 1.3334, 0.0119, 1.4617, 0.0131, 1.5333, 0.0137, 1.5324, 0.0096, 1.2327, 0.0154],
(70, 0) : ['B', 8, 125.02, 1.76, 113.65, 1.47, 113.72, 1.52, 110.65, 1.95, 119.16, 1.33, 118.87, 1.18, 121.87, 1.05, 1.332, 0.0124, 1.4582, 0.0137, 1.535, 0.0137, 1.5221, 0.0151, 1.2372, 0.0195],
(70, 10) : ['B', 22, 124.31, 1.67, 113.15, 1.63, 113.56, 1.39, 111.06, 1.89, 119.59, 1.31, 118.3, 1.26, 122.0, 1.25, 1.332, 0.0134, 1.4587, 0.0132, 1.5324, 0.0143, 1.5218, 0.0133, 1.2378, 0.0183],
(70, 20) : ['B', 28, 123.47, 1.53, 112.63, 1.61, 113.23, 1.22, 111.26, 1.67, 120.12, 1.15, 117.74, 1.58, 122.03, 1.61, 1.3324, 0.0138, 1.4582, 0.0135, 1.5324, 0.0153, 1.5227, 0.0145, 1.2353, 0.0166],
(70, 30) : ['B', 32, 122.74, 1.44, 112.47, 1.52, 112.58, 1.22, 111.39, 1.55, 120.57, 1.2, 117.12, 1.63, 122.2, 1.67, 1.3334, 0.0138, 1.4595, 0.0148, 1.5314, 0.0153, 1.5252, 0.014, 1.233, 0.0145],
(70, 40) : ['B', 15, 122.35, 1.46, 112.46, 1.57, 111.92, 1.34, 111.63, 1.36, 120.98, 1.24, 116.45, 1.35, 122.47, 1.32, 1.3334, 0.0143, 1.4616, 0.015, 1.5303, 0.0147, 1.5278, 0.0132, 1.2316, 0.0134],
(70, 50) : ['B', 6, 122.36, 1.47, 112.25, 1.6, 111.56, 1.43, 111.82, 1.28, 121.4, 1.19, 115.83, 1.18, 122.67, 1.13, 1.334, 0.0142, 1.4629, 0.0147, 1.5308, 0.0145, 1.5298, 0.013, 1.2316, 0.0136],
(80, -10) : ['B', 5, 126.45, 1.77, 114.17, 1.14, 113.28, 1.57, 110.06, 1.44, 119.0, 1.0, 119.38, 1.24, 121.56, 0.95, 1.3309, 0.0135, 1.4561, 0.0123, 1.541, 0.012, 1.5257, 0.0175, 1.2318, 0.0169],
(80, 0) : ['B', 8, 125.66, 1.85, 114.27, 1.64, 113.29, 2.0, 110.35, 1.91, 118.94, 1.62, 119.08, 1.35, 121.88, 1.07, 1.3305, 0.0135, 1.4583, 0.0177, 1.5368, 0.0131, 1.5243, 0.015, 1.2378, 0.023],
(80, 10) : ['B', 7, 124.82, 1.78, 113.89, 1.93, 113.31, 2.04, 110.76, 2.18, 119.32, 1.87, 118.58, 1.48, 121.97, 1.26, 1.3315, 0.0143, 1.4595, 0.0195, 1.5318, 0.0133, 1.5222, 0.012, 1.2409, 0.0243],
(80, 20) : ['B', 4, 123.93, 1.54, 113.1, 1.75, 113.4, 1.47, 111.06, 1.83, 119.96, 1.46, 118.02, 1.74, 121.91, 1.5, 1.3325, 0.0146, 1.4574, 0.0158, 1.532, 0.0142, 1.5218, 0.0129, 1.2359, 0.0188],
(90, -10) : ['B', 3, 126.86, 1.57, 114.1, 1.0, 113.51, 1.52, 109.83, 0.99, 119.18, 0.82, 118.88, 1.17, 121.89, 0.98, 1.332, 0.0136, 1.4596, 0.0128, 1.5386, 0.012, 1.5236, 0.0151, 1.2297, 0.0131],
(90, 0) : ['B', 3, 126.32, 1.74, 114.45, 1.56, 113.2, 2.08, 110.04, 1.51, 118.92, 1.52, 119.01, 1.38, 122.0, 1.02, 1.3304, 0.0138, 1.4602, 0.0183, 1.5381, 0.0135, 1.5241, 0.0143, 1.2361, 0.0215],
},
"NonPGIV_xpro" : {
(-180, -180) : ['I', 511, 121.8, 2.44, 110.37, 1.78, 109.81, 2.21, 110.17, 1.97, 120.16, 1.37, 118.44, 1.59, 121.32, 1.15, 1.331, 0.0207, 1.4569, 0.0141, 1.5298, 0.0158, 1.5238, 0.0126, 1.2378, 0.0128],
(-170, 160) : ['B', 4, 122.56, 1.58, 111.27, 0.94, 108.13, 0.9, 110.03, 1.37, 120.13, 0.86, 117.62, 1.03, 122.17, 1.05, 1.3266, 0.0105, 1.4562, 0.0098, 1.5375, 0.014, 1.5257, 0.0147, 1.2343, 0.0156],
(-160, 140) : ['B', 4, 121.68, 2.38, 110.65, 1.86, 107.95, 2.14, 109.63, 1.47, 119.13, 1.0, 118.95, 1.29, 121.84, 0.78, 1.336, 0.0148, 1.4556, 0.0148, 1.5329, 0.0149, 1.5173, 0.0107, 1.2388, 0.0112],
(-160, 150) : ['B', 4, 122.08, 1.83, 110.77, 1.39, 108.11, 1.29, 109.92, 1.36, 119.76, 0.97, 118.33, 1.0, 121.83, 0.78, 1.3317, 0.0121, 1.4562, 0.0104, 1.5358, 0.015, 1.5191, 0.0129, 1.2362, 0.0121],
(-160, 160) : ['B', 12, 122.26, 1.6, 111.1, 1.05, 108.22, 0.9, 110.22, 1.32, 120.26, 0.95, 117.96, 0.81, 121.71, 0.91, 1.3292, 0.0116, 1.4556, 0.0104, 1.5374, 0.0147, 1.521, 0.013, 1.2369, 0.013],
(-160, 170) : ['B', 3, 122.06, 1.45, 111.29, 1.03, 108.07, 0.89, 110.76, 1.22, 120.56, 0.91, 117.82, 0.78, 121.56, 0.99, 1.328, 0.0113, 1.4565, 0.0094, 1.5384, 0.0138, 1.5207, 0.0119, 1.239, 0.0132],
(-150, 70) : ['B', 4, 122.37, 0.93, 110.71, 1.13, 108.76, 1.44, 111.15, 1.24, 121.34, 0.94, 117.43, 0.85, 121.19, 0.73, 1.3343, 0.0122, 1.464, 0.0111, 1.5281, 0.013, 1.5222, 0.0113, 1.2364, 0.0116],
(-150, 80) : ['B', 4, 122.28, 0.88, 111.23, 1.27, 108.82, 1.65, 110.87, 1.39, 121.32, 1.0, 117.52, 0.79, 121.12, 0.78, 1.331, 0.0118, 1.4639, 0.0098, 1.5294, 0.0131, 1.5196, 0.0131, 1.2372, 0.0112],
(-150, 90) : ['B', 4, 122.0, 1.08, 111.77, 1.43, 108.55, 1.79, 110.81, 1.27, 121.06, 0.97, 117.67, 0.88, 121.23, 0.7, 1.3318, 0.0086, 1.4627, 0.0093, 1.5278, 0.0107, 1.5189, 0.0153, 1.2385, 0.0112],
(-150, 100) : ['B', 4, 122.26, 1.1, 111.78, 1.71, 108.12, 1.97, 110.98, 1.18, 120.63, 1.05, 118.05, 0.95, 121.27, 0.6, 1.3315, 0.0056, 1.4627, 0.0088, 1.5263, 0.0093, 1.5215, 0.0152, 1.241, 0.0105],
(-150, 130) : ['B', 3, 122.13, 2.52, 111.11, 2.74, 107.32, 3.39, 109.65, 1.3, 119.22, 1.02, 118.56, 1.31, 122.16, 1.18, 1.3346, 0.0141, 1.4515, 0.0273, 1.5292, 0.0166, 1.5227, 0.0119, 1.2416, 0.0142],
(-150, 140) : ['B', 6, 122.31, 2.45, 111.25, 2.24, 107.84, 2.84, 109.45, 1.45, 119.5, 1.06, 118.36, 1.35, 122.06, 1.02, 1.3345, 0.0142, 1.453, 0.0223, 1.5321, 0.0169, 1.5205, 0.0116, 1.2398, 0.0124],
(-150, 150) : ['B', 8, 122.45, 2.03, 111.17, 1.7, 108.23, 1.62, 109.55, 1.57, 119.91, 1.02, 118.16, 1.08, 121.85, 0.7, 1.3305, 0.012, 1.4551, 0.0125, 1.5361, 0.0148, 1.519, 0.0116, 1.2369, 0.0107],
(-150, 160) : ['B', 7, 122.38, 1.73, 111.25, 1.41, 108.25, 1.16, 109.97, 1.55, 120.34, 0.92, 117.95, 0.77, 121.65, 0.73, 1.328, 0.0114, 1.4547, 0.0096, 1.5347, 0.0136, 1.519, 0.0109, 1.2368, 0.0103],
(-150, 170) : ['B', 3, 122.07, 1.44, 111.35, 1.27, 108.14, 1.15, 110.37, 1.37, 120.71, 0.87, 117.68, 0.71, 121.54, 0.85, 1.3266, 0.0119, 1.4555, 0.0087, 1.5332, 0.0132, 1.5176, 0.0096, 1.2375, 0.0096],
(-140, 60) : ['B', 4, 122.59, 1.11, 110.74, 1.4, 109.3, 1.49, 111.41, 1.38, 121.29, 1.02, 117.47, 0.99, 121.2, 0.84, 1.333, 0.0137, 1.4643, 0.0103, 1.5284, 0.0117, 1.5241, 0.0121, 1.2341, 0.0113],
(-140, 70) : ['B', 17, 122.85, 1.1, 110.79, 1.3, 108.75, 1.7, 111.27, 1.47, 121.28, 1.1, 117.44, 0.92, 121.23, 0.81, 1.3315, 0.0133, 1.464, 0.0107, 1.5303, 0.0122, 1.5218, 0.0126, 1.2365, 0.0115],
(-140, 80) : ['B', 15, 122.74, 1.06, 111.09, 1.24, 108.71, 2.02, 111.15, 1.65, 121.22, 1.16, 117.57, 0.87, 121.17, 0.85, 1.331, 0.0139, 1.4635, 0.0109, 1.5308, 0.0133, 1.5203, 0.0125, 1.2372, 0.0111],
(-140, 90) : ['B', 6, 122.42, 1.23, 111.4, 1.31, 108.81, 2.23, 111.02, 1.53, 121.0, 1.13, 117.69, 0.95, 121.27, 0.8, 1.3323, 0.0114, 1.4618, 0.0106, 1.5292, 0.012, 1.521, 0.0123, 1.2379, 0.0108],
(-140, 100) : ['B', 6, 122.52, 1.16, 111.39, 1.7, 108.64, 2.18, 111.01, 1.38, 120.34, 1.14, 118.14, 0.98, 121.44, 0.83, 1.3317, 0.0075, 1.4618, 0.0093, 1.5266, 0.0105, 1.5235, 0.0122, 1.242, 0.0097],
(-140, 130) : ['B', 6, 122.4, 1.98, 110.48, 2.94, 107.37, 2.96, 110.16, 1.33, 119.72, 0.91, 118.39, 1.28, 121.79, 1.18, 1.335, 0.0143, 1.4549, 0.024, 1.5315, 0.0167, 1.5251, 0.0107, 1.245, 0.0153],
(-140, 140) : ['B', 8, 122.67, 2.19, 110.95, 2.25, 108.4, 2.52, 109.2, 1.5, 120.03, 1.08, 117.94, 1.37, 121.94, 1.05, 1.3332, 0.0139, 1.4536, 0.0209, 1.5352, 0.0163, 1.5224, 0.0106, 1.2403, 0.0129],
(-140, 150) : ['B', 16, 122.9, 2.07, 111.19, 1.8, 108.82, 1.69, 108.91, 1.65, 120.28, 1.03, 117.75, 1.17, 121.88, 0.71, 1.3288, 0.0121, 1.4538, 0.013, 1.5372, 0.0138, 1.5203, 0.0102, 1.237, 0.0105],
(-140, 160) : ['B', 11, 123.11, 1.79, 111.18, 1.8, 108.55, 1.56, 109.32, 1.71, 120.5, 0.92, 117.71, 0.92, 121.71, 0.64, 1.3256, 0.0112, 1.4533, 0.0092, 1.5349, 0.0121, 1.5193, 0.0095, 1.2359, 0.0089],
(-130, 50) : ['B', 5, 122.28, 1.02, 110.75, 1.72, 110.73, 1.55, 111.11, 1.28, 121.07, 0.96, 117.84, 0.97, 121.05, 0.88, 1.3356, 0.0153, 1.4647, 0.0105, 1.5251, 0.0124, 1.5272, 0.0111, 1.2311, 0.01],
(-130, 60) : ['B', 13, 122.89, 1.12, 110.75, 1.57, 109.79, 1.6, 111.21, 1.31, 121.15, 1.16, 117.64, 1.06, 121.17, 0.93, 1.331, 0.0135, 1.4636, 0.0105, 1.5276, 0.0114, 1.5241, 0.0123, 1.2346, 0.0116],
(-130, 70) : ['B', 26, 123.15, 1.21, 110.99, 1.58, 108.94, 1.76, 111.14, 1.56, 121.02, 1.28, 117.59, 1.03, 121.34, 0.89, 1.3311, 0.0135, 1.4626, 0.0111, 1.5293, 0.0113, 1.5232, 0.0124, 1.237, 0.0117],
(-130, 80) : ['B', 18, 123.16, 1.23, 111.21, 1.47, 108.39, 2.1, 111.29, 1.92, 120.83, 1.35, 117.75, 0.99, 121.37, 0.9, 1.332, 0.0148, 1.4627, 0.0121, 1.5295, 0.0132, 1.5224, 0.0116, 1.2387, 0.0117],
(-130, 90) : ['B', 8, 122.98, 1.37, 111.2, 1.41, 108.4, 2.37, 111.2, 1.81, 120.74, 1.26, 117.89, 1.02, 121.32, 0.91, 1.3324, 0.0132, 1.4621, 0.0115, 1.5274, 0.014, 1.5221, 0.0105, 1.239, 0.0117],
(-130, 100) : ['B', 3, 122.74, 1.36, 111.03, 1.76, 108.74, 2.22, 110.71, 1.53, 120.08, 1.14, 118.34, 1.03, 121.47, 1.16, 1.3306, 0.0098, 1.462, 0.01, 1.5241, 0.014, 1.5228, 0.0114, 1.2438, 0.0093],
(-130, 110) : ['B', 5, 122.64, 1.25, 110.61, 1.94, 108.73, 2.16, 110.55, 1.66, 119.49, 1.03, 118.9, 1.07, 121.47, 1.39, 1.3279, 0.0096, 1.4621, 0.0105, 1.5264, 0.012, 1.5217, 0.0117, 1.2488, 0.0085],
(-130, 120) : ['B', 5, 122.56, 1.34, 110.5, 2.04, 107.91, 2.05, 110.62, 1.57, 119.59, 0.78, 119.06, 1.05, 121.23, 1.13, 1.3315, 0.0105, 1.4598, 0.0129, 1.5309, 0.0146, 1.5223, 0.0084, 1.2485, 0.0126],
(-130, 130) : ['B', 5, 122.48, 1.77, 110.27, 2.2, 108.45, 1.93, 110.02, 1.5, 119.86, 0.96, 118.63, 1.21, 121.38, 0.96, 1.3324, 0.014, 1.4546, 0.0161, 1.5351, 0.02, 1.524, 0.0081, 1.2437, 0.0141],
(-130, 140) : ['B', 11, 122.36, 2.42, 110.42, 1.9, 109.48, 1.75, 109.15, 1.6, 120.23, 1.21, 117.93, 1.42, 121.72, 0.98, 1.3318, 0.0146, 1.4526, 0.015, 1.5361, 0.0183, 1.5223, 0.0091, 1.2373, 0.0138],
(-130, 150) : ['B', 14, 122.74, 2.44, 110.72, 1.76, 109.58, 1.63, 108.87, 1.55, 120.46, 1.13, 117.62, 1.32, 121.8, 0.86, 1.3288, 0.0135, 1.4527, 0.0118, 1.5359, 0.0146, 1.5204, 0.0099, 1.2353, 0.0129],
(-130, 160) : ['B', 11, 123.65, 1.88, 110.63, 1.85, 109.09, 1.74, 109.22, 1.52, 120.64, 0.99, 117.67, 1.08, 121.55, 0.78, 1.325, 0.0125, 1.4531, 0.0083, 1.5361, 0.0123, 1.519, 0.0101, 1.2359, 0.0101],
(-130, 170) : ['B', 4, 123.96, 1.44, 110.09, 1.81, 109.06, 1.78, 109.56, 1.51, 120.94, 1.01, 117.59, 0.99, 121.32, 0.85, 1.325, 0.0124, 1.4551, 0.007, 1.5378, 0.0129, 1.5166, 0.0102, 1.2353, 0.0082],
(-120, 60) : ['B', 4, 123.21, 1.19, 110.9, 1.73, 110.02, 1.78, 110.96, 1.33, 120.87, 1.24, 117.78, 1.06, 121.31, 0.99, 1.3316, 0.0122, 1.4619, 0.0099, 1.5264, 0.0109, 1.5255, 0.0115, 1.2368, 0.0111],
(-120, 70) : ['B', 14, 123.34, 1.29, 111.24, 1.83, 108.97, 1.82, 110.87, 1.58, 120.8, 1.32, 117.73, 1.04, 121.42, 0.91, 1.3336, 0.0127, 1.4611, 0.0107, 1.5275, 0.0107, 1.5254, 0.0112, 1.2387, 0.0108],
(-120, 80) : ['B', 10, 123.46, 1.35, 111.3, 1.66, 108.21, 2.0, 111.12, 1.86, 120.64, 1.37, 117.95, 1.04, 121.36, 0.91, 1.3351, 0.014, 1.4615, 0.0119, 1.5279, 0.0127, 1.5246, 0.0104, 1.2406, 0.0115],
(-120, 90) : ['B', 7, 123.3, 1.44, 110.88, 1.54, 108.27, 2.25, 110.97, 1.58, 120.54, 1.21, 118.36, 1.11, 121.04, 0.98, 1.3339, 0.0126, 1.4625, 0.0107, 1.5276, 0.0141, 1.5229, 0.01, 1.2414, 0.0123],
(-120, 100) : ['B', 7, 122.66, 1.43, 110.43, 1.7, 108.93, 2.22, 110.34, 1.3, 120.09, 0.98, 118.8, 1.21, 121.02, 1.13, 1.3302, 0.0121, 1.4633, 0.0108, 1.5279, 0.0136, 1.5216, 0.0123, 1.2443, 0.01],
(-120, 110) : ['B', 7, 122.42, 1.52, 110.17, 1.86, 109.11, 2.13, 110.13, 1.4, 119.62, 0.94, 119.18, 1.5, 121.12, 1.33, 1.3273, 0.0132, 1.4627, 0.0122, 1.5287, 0.0126, 1.521, 0.0132, 1.2461, 0.0092],
(-120, 120) : ['B', 5, 122.65, 1.66, 110.27, 1.88, 108.85, 1.88, 110.13, 1.34, 119.55, 0.96, 119.28, 1.61, 121.1, 1.23, 1.3306, 0.0124, 1.4577, 0.014, 1.531, 0.0179, 1.5222, 0.0108, 1.2435, 0.011],
(-120, 130) : ['B', 4, 122.7, 1.98, 110.23, 1.77, 109.4, 1.6, 109.42, 1.35, 119.69, 1.02, 118.81, 1.29, 121.39, 0.89, 1.3308, 0.0136, 1.4509, 0.017, 1.5384, 0.0255, 1.5227, 0.0106, 1.2395, 0.0116],
(-120, 140) : ['B', 8, 122.21, 2.87, 110.49, 1.9, 110.14, 1.51, 108.88, 1.5, 120.04, 1.2, 118.16, 1.34, 121.66, 0.94, 1.3325, 0.0159, 1.4508, 0.0169, 1.5365, 0.0207, 1.5238, 0.0118, 1.2359, 0.0127],
(-120, 150) : ['B', 5, 122.38, 2.9, 110.7, 2.02, 110.1, 1.53, 108.84, 1.51, 120.41, 1.19, 117.88, 1.36, 121.57, 0.97, 1.3312, 0.0159, 1.4521, 0.0154, 1.5342, 0.0141, 1.5242, 0.0127, 1.2352, 0.013],
(-120, 160) : ['B', 8, 123.56, 1.98, 110.39, 1.79, 109.82, 1.68, 109.08, 1.53, 120.66, 1.03, 117.84, 1.16, 121.35, 0.85, 1.3268, 0.0139, 1.4522, 0.0111, 1.5358, 0.0125, 1.5227, 0.0125, 1.2369, 0.0103],
(-110, 90) : ['B', 6, 123.08, 1.72, 110.38, 1.67, 108.66, 2.16, 110.65, 1.04, 120.38, 1.03, 118.87, 1.06, 120.68, 1.09, 1.3341, 0.0132, 1.4604, 0.0104, 1.5309, 0.0122, 1.5232, 0.0122, 1.2401, 0.0124],
(-110, 100) : ['B', 7, 122.35, 1.8, 110.12, 1.61, 109.01, 2.07, 110.33, 1.02, 119.99, 0.87, 119.12, 1.18, 120.83, 1.06, 1.3323, 0.015, 1.4597, 0.011, 1.5317, 0.0126, 1.5228, 0.0131, 1.2411, 0.0114],
(-110, 110) : ['B', 7, 122.06, 1.78, 110.05, 1.7, 109.1, 1.91, 110.17, 1.11, 119.59, 0.92, 119.25, 1.6, 121.12, 1.14, 1.3303, 0.0158, 1.4583, 0.0125, 1.5297, 0.0138, 1.5215, 0.0122, 1.2415, 0.0116],
(-110, 120) : ['B', 6, 122.28, 1.77, 110.05, 1.79, 109.15, 1.67, 110.15, 1.15, 119.54, 1.26, 119.14, 2.03, 121.29, 1.24, 1.3321, 0.0144, 1.4558, 0.0158, 1.5281, 0.0168, 1.52, 0.0118, 1.2403, 0.0114],
(-110, 130) : ['B', 4, 122.31, 2.34, 109.94, 1.7, 109.64, 1.56, 109.47, 1.18, 119.67, 1.24, 118.67, 1.79, 121.6, 1.18, 1.3318, 0.0192, 1.4535, 0.0174, 1.5333, 0.0199, 1.5191, 0.0128, 1.2385, 0.0114],
(-110, 140) : ['B', 9, 121.95, 3.74, 110.45, 2.07, 110.32, 1.51, 108.76, 1.37, 120.05, 1.15, 118.12, 1.58, 121.7, 1.29, 1.3346, 0.0304, 1.4527, 0.0179, 1.5336, 0.0157, 1.5238, 0.014, 1.2362, 0.0125],
(-110, 150) : ['B', 12, 122.15, 3.47, 110.56, 2.27, 110.4, 1.43, 108.63, 1.54, 120.54, 1.23, 117.93, 1.49, 121.39, 1.18, 1.3326, 0.0274, 1.4524, 0.018, 1.5335, 0.013, 1.5258, 0.0143, 1.2351, 0.0121],
(-110, 160) : ['B', 12, 123.15, 2.23, 110.1, 1.88, 110.5, 1.52, 108.91, 1.53, 120.87, 1.11, 117.8, 1.26, 121.2, 0.9, 1.3267, 0.0171, 1.4524, 0.015, 1.5348, 0.0142, 1.5229, 0.0142, 1.2357, 0.01],
(-110, 170) : ['B', 4, 124.01, 1.84, 109.82, 1.44, 110.58, 1.56, 109.48, 1.46, 121.08, 0.89, 117.67, 1.09, 121.14, 0.72, 1.3237, 0.0138, 1.4515, 0.013, 1.533, 0.0149, 1.522, 0.0157, 1.2356, 0.0081],
(-100, 100) : ['B', 8, 122.17, 2.19, 110.11, 1.5, 108.59, 1.96, 110.44, 0.9, 119.71, 0.81, 119.38, 1.1, 120.85, 1.01, 1.3344, 0.0172, 1.4556, 0.0113, 1.5313, 0.0136, 1.5229, 0.0155, 1.2405, 0.0129],
(-100, 110) : ['B', 11, 121.76, 1.74, 110.07, 1.47, 108.69, 1.8, 110.17, 0.99, 119.36, 0.84, 119.4, 1.32, 121.19, 0.94, 1.333, 0.0169, 1.4544, 0.0121, 1.5275, 0.015, 1.5201, 0.0122, 1.2407, 0.0133],
(-100, 120) : ['B', 8, 121.83, 1.56, 110.01, 1.46, 109.04, 1.52, 109.85, 1.14, 119.32, 1.12, 119.28, 1.69, 121.36, 1.11, 1.3333, 0.0161, 1.455, 0.016, 1.5244, 0.0155, 1.5186, 0.0115, 1.2414, 0.0129],
(-100, 130) : ['B', 5, 121.59, 3.54, 109.9, 1.54, 109.62, 1.45, 109.31, 1.23, 119.61, 1.12, 118.75, 1.99, 121.59, 1.64, 1.335, 0.0359, 1.4577, 0.0169, 1.5263, 0.0151, 1.519, 0.0138, 1.2399, 0.0141],
(-100, 140) : ['B', 4, 120.71, 6.53, 110.11, 1.65, 110.31, 1.38, 108.68, 1.39, 120.19, 0.93, 117.84, 2.44, 121.87, 2.39, 1.3448, 0.0663, 1.4558, 0.0155, 1.5294, 0.0137, 1.5233, 0.0138, 1.2364, 0.0156],
(-100, 150) : ['B', 10, 121.41, 5.58, 110.1, 1.66, 110.39, 1.3, 108.61, 1.53, 120.63, 1.03, 117.66, 2.07, 121.59, 1.99, 1.3394, 0.0557, 1.4529, 0.0164, 1.5318, 0.015, 1.5244, 0.0128, 1.2349, 0.0134],
(-100, 160) : ['B', 12, 122.71, 3.03, 109.88, 1.42, 110.4, 1.31, 109.09, 1.51, 120.97, 1.05, 117.69, 1.42, 121.21, 1.21, 1.327, 0.0286, 1.4526, 0.0151, 1.5323, 0.0158, 1.5206, 0.0137, 1.2346, 0.0112],
(-100, 170) : ['B', 5, 123.55, 1.87, 109.72, 1.14, 110.31, 1.2, 109.96, 1.5, 121.27, 1.04, 117.63, 1.13, 120.99, 0.95, 1.3226, 0.0164, 1.453, 0.0125, 1.5296, 0.0157, 1.5192, 0.0146, 1.2342, 0.0104],
(-90, 110) : ['B', 4, 121.74, 1.32, 110.17, 1.27, 108.47, 1.79, 110.08, 1.15, 119.29, 0.65, 119.42, 1.04, 121.23, 0.81, 1.3333, 0.015, 1.4563, 0.012, 1.5223, 0.0171, 1.5226, 0.0117, 1.2409, 0.0128],
(-90, 120) : ['B', 8, 121.61, 1.39, 110.23, 1.31, 109.24, 1.39, 109.38, 1.44, 119.32, 0.74, 119.28, 1.1, 121.35, 0.92, 1.3313, 0.0163, 1.4566, 0.0147, 1.5194, 0.0173, 1.5222, 0.0114, 1.2385, 0.0127],
(-90, 130) : ['B', 10, 121.27, 3.4, 110.32, 1.48, 109.72, 1.25, 109.08, 1.49, 119.66, 0.82, 118.75, 1.49, 121.54, 1.45, 1.3318, 0.036, 1.4593, 0.0156, 1.5225, 0.0175, 1.5238, 0.0133, 1.2368, 0.0135],
(-90, 140) : ['B', 9, 120.3, 6.38, 110.29, 1.35, 110.07, 1.26, 108.87, 1.41, 120.19, 0.84, 117.79, 2.25, 121.93, 2.3, 1.3429, 0.0659, 1.4577, 0.0148, 1.5258, 0.0173, 1.5267, 0.0131, 1.2348, 0.0145],
(-90, 150) : ['B', 12, 120.81, 5.77, 110.03, 1.21, 110.29, 1.38, 108.86, 1.44, 120.6, 0.9, 117.51, 2.04, 121.77, 2.04, 1.3403, 0.0587, 1.4541, 0.0144, 1.5262, 0.0173, 1.5257, 0.0125, 1.2354, 0.0137],
(-90, 160) : ['B', 10, 121.98, 3.11, 109.74, 1.16, 110.36, 1.34, 109.37, 1.59, 120.96, 1.09, 117.57, 1.39, 121.34, 1.3, 1.3287, 0.0303, 1.4532, 0.0132, 1.5268, 0.0161, 1.5216, 0.0129, 1.2349, 0.0137],
(-90, 170) : ['B', 8, 122.48, 1.62, 109.49, 1.13, 110.13, 1.15, 110.47, 1.77, 121.46, 1.47, 117.47, 1.16, 120.96, 1.39, 1.3251, 0.0158, 1.4554, 0.0117, 1.526, 0.015, 1.5191, 0.0122, 1.2334, 0.0148],
(-80, -180) : ['B', 3, 122.29, 1.48, 109.59, 1.21, 109.41, 1.53, 111.89, 2.35, 121.67, 1.79, 117.69, 0.93, 120.56, 1.79, 1.3258, 0.015, 1.4566, 0.0139, 1.5259, 0.0124, 1.5247, 0.0123, 1.2347, 0.0154],
(-80, 120) : ['B', 10, 121.2, 1.4, 109.9, 1.56, 109.42, 1.48, 109.51, 1.6, 119.46, 0.77, 119.19, 0.95, 121.31, 0.85, 1.3276, 0.0167, 1.4574, 0.0159, 1.5233, 0.0183, 1.5238, 0.0108, 1.2363, 0.0122],
(-80, 130) : ['B', 15, 120.94, 1.9, 110.01, 1.63, 109.65, 1.26, 109.41, 1.62, 119.76, 0.89, 118.75, 0.97, 121.42, 1.06, 1.327, 0.0231, 1.4583, 0.016, 1.5261, 0.0198, 1.525, 0.0114, 1.2351, 0.0128],
(-80, 140) : ['B', 14, 120.69, 2.95, 110.14, 1.41, 109.93, 1.24, 109.26, 1.47, 120.23, 1.02, 118.03, 1.19, 121.64, 1.36, 1.3308, 0.0312, 1.4562, 0.0153, 1.5274, 0.0196, 1.5281, 0.0118, 1.2339, 0.0129],
(-80, 150) : ['B', 22, 120.97, 2.84, 110.04, 1.35, 110.24, 1.46, 109.11, 1.5, 120.64, 1.03, 117.6, 1.2, 121.64, 1.27, 1.331, 0.0283, 1.4528, 0.0144, 1.5249, 0.017, 1.5278, 0.0126, 1.234, 0.0126],
(-80, 160) : ['B', 18, 121.48, 2.04, 109.78, 1.38, 110.39, 1.5, 109.45, 1.81, 120.88, 1.12, 117.48, 1.15, 121.53, 1.12, 1.3288, 0.0186, 1.4519, 0.0146, 1.5251, 0.0152, 1.525, 0.0134, 1.2336, 0.0131],
(-80, 170) : ['B', 11, 121.92, 1.6, 109.55, 1.3, 110.07, 1.46, 110.5, 2.08, 121.27, 1.44, 117.51, 1.13, 121.12, 1.42, 1.3278, 0.0145, 1.454, 0.0147, 1.5262, 0.0136, 1.5226, 0.0128, 1.2327, 0.0141],
(-70, -60) : ['B', 4, 119.83, 1.11, 110.39, 0.95, 112.17, 1.36, 113.57, 1.57, 119.13, 0.92, 120.58, 0.74, 120.27, 0.69, 1.3405, 0.0165, 1.4632, 0.0069, 1.5294, 0.0126, 1.5212, 0.0108, 1.2439, 0.0091],
(-70, -50) : ['B', 6, 119.78, 1.24, 110.42, 1.18, 112.35, 1.34, 113.04, 1.63, 118.79, 0.96, 120.81, 0.86, 120.38, 0.79, 1.3371, 0.0161, 1.4619, 0.0085, 1.5305, 0.013, 1.5208, 0.0114, 1.2439, 0.01],
(-70, 110) : ['B', 3, 121.63, 2.17, 109.37, 1.87, 109.6, 2.01, 109.85, 1.61, 119.24, 0.97, 119.51, 1.14, 121.2, 0.9, 1.324, 0.0154, 1.4572, 0.017, 1.5279, 0.0203, 1.5228, 0.0126, 1.2384, 0.0121],
(-70, 120) : ['B', 16, 121.17, 1.62, 109.44, 1.91, 109.44, 1.81, 109.82, 1.65, 119.49, 0.99, 119.27, 1.13, 121.18, 0.93, 1.3252, 0.0177, 1.4585, 0.0176, 1.5259, 0.0197, 1.5231, 0.0119, 1.2382, 0.0128],
(-70, 130) : ['B', 15, 120.67, 1.34, 109.68, 1.83, 109.5, 1.47, 109.67, 1.65, 119.8, 1.0, 118.85, 0.95, 121.28, 1.0, 1.3262, 0.0184, 1.4575, 0.0164, 1.5272, 0.0189, 1.5249, 0.0113, 1.2368, 0.0136],
(-70, 140) : ['B', 26, 120.49, 1.42, 110.02, 1.58, 109.83, 1.27, 109.42, 1.57, 120.25, 1.08, 118.23, 0.92, 121.43, 1.12, 1.3287, 0.016, 1.4543, 0.0145, 1.5283, 0.0175, 1.5275, 0.0108, 1.2352, 0.0135],
(-70, 150) : ['B', 32, 120.68, 1.52, 110.11, 1.46, 110.08, 1.38, 109.27, 1.61, 120.7, 1.09, 117.67, 1.01, 121.53, 1.1, 1.33, 0.0147, 1.4521, 0.0141, 1.526, 0.0159, 1.5284, 0.0118, 1.234, 0.0127],
(-70, 160) : ['B', 17, 121.03, 1.6, 110.05, 1.44, 110.2, 1.44, 109.51, 1.85, 120.87, 1.1, 117.44, 1.13, 121.6, 1.06, 1.3307, 0.0148, 1.4508, 0.016, 1.5262, 0.0153, 1.5268, 0.0132, 1.2333, 0.0126],
(-70, 170) : ['B', 7, 121.57, 1.62, 110.04, 1.33, 109.87, 1.62, 110.31, 2.06, 121.01, 1.18, 117.6, 1.18, 121.31, 1.17, 1.3315, 0.0154, 1.4507, 0.0178, 1.5275, 0.014, 1.5251, 0.0138, 1.233, 0.0128],
(-60, -60) : ['B', 3, 120.44, 1.3, 110.11, 1.44, 112.55, 1.35, 113.49, 1.82, 119.08, 0.95, 120.52, 0.83, 120.38, 0.79, 1.3352, 0.0149, 1.4621, 0.0077, 1.5301, 0.0126, 1.5212, 0.0111, 1.2436, 0.0094],
(-60, -50) : ['B', 19, 120.26, 1.34, 110.3, 1.49, 112.75, 1.36, 112.76, 1.86, 118.73, 0.98, 120.77, 0.97, 120.48, 0.89, 1.3324, 0.015, 1.4611, 0.0092, 1.5313, 0.0133, 1.5203, 0.0123, 1.2435, 0.01],
(-60, -40) : ['B', 27, 120.09, 1.25, 110.43, 1.55, 113.16, 1.42, 112.05, 1.91, 118.34, 0.97, 120.93, 1.06, 120.71, 0.94, 1.3319, 0.0133, 1.4592, 0.0104, 1.5332, 0.0139, 1.5218, 0.0126, 1.2436, 0.0098],
(-60, -30) : ['B', 4, 120.06, 1.19, 110.39, 1.61, 113.57, 1.38, 111.64, 1.86, 117.98, 0.97, 121.08, 1.08, 120.92, 0.98, 1.332, 0.0109, 1.4569, 0.0113, 1.5354, 0.0149, 1.5246, 0.0119, 1.2433, 0.0095],
(-60, 120) : ['B', 11, 121.35, 1.73, 109.45, 2.07, 109.58, 1.75, 109.69, 1.64, 119.51, 0.98, 119.12, 1.05, 121.31, 0.87, 1.3262, 0.0166, 1.4556, 0.0157, 1.5266, 0.0179, 1.5248, 0.0129, 1.2407, 0.0133],
(-60, 130) : ['B', 36, 120.65, 1.36, 109.73, 1.79, 109.48, 1.44, 109.62, 1.57, 119.75, 0.94, 118.87, 0.9, 121.3, 0.89, 1.3272, 0.0161, 1.4551, 0.0139, 1.5282, 0.0157, 1.5261, 0.0114, 1.2391, 0.0129],
(-60, 140) : ['B', 31, 120.39, 1.39, 109.98, 1.57, 109.64, 1.27, 109.52, 1.58, 120.17, 1.04, 118.45, 0.96, 121.3, 1.03, 1.328, 0.0144, 1.454, 0.0129, 1.5296, 0.0146, 1.5272, 0.0102, 1.2371, 0.0129],
(-60, 150) : ['B', 24, 120.6, 1.53, 110.03, 1.51, 109.84, 1.39, 109.46, 1.64, 120.69, 1.13, 117.79, 1.08, 121.43, 1.12, 1.3303, 0.0137, 1.4527, 0.0137, 1.5273, 0.0152, 1.5285, 0.0111, 1.2349, 0.0128],
(-60, 160) : ['B', 8, 120.86, 1.6, 110.03, 1.45, 110.01, 1.45, 109.61, 1.78, 120.87, 1.16, 117.38, 1.18, 121.66, 1.14, 1.3335, 0.0161, 1.4517, 0.0161, 1.5276, 0.0162, 1.5273, 0.0125, 1.2337, 0.0129],
(-50, -50) : ['B', 12, 120.97, 1.48, 110.08, 1.89, 113.25, 1.3, 112.38, 2.17, 118.63, 0.92, 120.79, 0.97, 120.55, 0.95, 1.3318, 0.0138, 1.4616, 0.0095, 1.5343, 0.0118, 1.5214, 0.0117, 1.2414, 0.0098],
(-50, -40) : ['B', 16, 120.58, 1.32, 110.34, 1.74, 113.45, 1.39, 111.8, 2.08, 118.33, 0.92, 120.95, 1.09, 120.7, 0.99, 1.3304, 0.0128, 1.4594, 0.0104, 1.535, 0.0132, 1.5216, 0.0129, 1.2428, 0.0099],
(-50, 120) : ['B', 3, 121.69, 1.82, 109.28, 2.04, 109.71, 1.42, 109.6, 1.51, 119.59, 0.87, 118.87, 0.95, 121.47, 0.78, 1.3281, 0.016, 1.4531, 0.013, 1.5268, 0.0155, 1.5282, 0.0124, 1.2405, 0.0134],
(-50, 130) : ['B', 8, 120.83, 1.43, 109.57, 1.72, 109.57, 1.23, 109.5, 1.53, 119.71, 0.84, 118.83, 0.87, 121.38, 0.82, 1.3275, 0.0154, 1.4534, 0.0116, 1.5296, 0.0143, 1.528, 0.0113, 1.2393, 0.0123],
(-50, 140) : ['B', 5, 120.51, 1.45, 109.75, 1.47, 109.6, 1.15, 109.56, 1.64, 120.02, 0.97, 118.63, 0.99, 121.27, 0.97, 1.3265, 0.0153, 1.4539, 0.0114, 1.5313, 0.0137, 1.5279, 0.0101, 1.2382, 0.0119],
(-40, -50) : ['B', 4, 121.62, 1.57, 109.9, 2.28, 113.77, 1.32, 111.77, 2.5, 118.44, 0.94, 121.01, 0.95, 120.51, 0.93, 1.3343, 0.0126, 1.4645, 0.0114, 1.536, 0.0091, 1.5233, 0.01, 1.2381, 0.0095],
(40, 60) : ['B', 4, 124.21, 1.21, 111.66, 1.11, 111.53, 2.18, 111.2, 0.71, 120.26, 0.8, 118.09, 0.83, 121.53, 0.46, 1.3312, 0.0118, 1.4602, 0.0071, 1.5247, 0.0083, 1.5341, 0.0095, 1.2344, 0.005],
(50, 50) : ['B', 3, 123.1, 0.96, 111.7, 1.61, 112.4, 2.07, 110.71, 0.94, 120.47, 0.69, 118.16, 0.7, 121.25, 0.22, 1.3301, 0.0139, 1.4566, 0.0091, 1.5221, 0.0089, 1.5321, 0.0065, 1.233, 0.0048],
(50, 60) : ['B', 4, 122.83, 1.08, 111.51, 1.43, 112.23, 2.2, 111.0, 0.87, 120.48, 0.77, 118.09, 0.82, 121.32, 0.27, 1.3288, 0.0112, 1.4577, 0.0074, 1.5223, 0.007, 1.5312, 0.0074, 1.2349, 0.0047],
},
"Pro_nonxpro" : {
(-180, -180) : ['I', 639, 119.84, 1.25, 103.25, 1.05, 112.47, 2.06, 111.56, 1.65, 120.6, 1.82, 116.7, 2.07, 122.64, 1.35, 1.3339, 0.0234, 1.4687, 0.0128, 1.5332, 0.0142, 1.5195, 0.0142, 1.2351, 0.013],
(-100, 0) : ['B', 7, 121.04, 1.21, 101.88, 1.01, 114.98, 1.46, 109.89, 1.23, 118.38, 1.13, 118.86, 1.56, 122.74, 1.56, 1.3322, 0.0082, 1.4728, 0.0085, 1.5334, 0.014, 1.5236, 0.0106, 1.2357, 0.0136],
(-100, 10) : ['B', 7, 120.94, 1.14, 101.83, 0.84, 114.68, 1.28, 109.92, 1.1, 118.29, 0.96, 118.87, 1.37, 122.83, 1.55, 1.3331, 0.0078, 1.474, 0.0074, 1.5329, 0.0113, 1.5249, 0.0111, 1.2358, 0.0133],
(-90, -10) : ['B', 5, 120.47, 1.07, 102.76, 1.12, 114.75, 1.7, 110.49, 1.57, 118.78, 1.4, 118.6, 1.68, 122.55, 1.39, 1.3359, 0.0098, 1.467, 0.0117, 1.5368, 0.0187, 1.5193, 0.0127, 1.239, 0.0122],
(-90, 0) : ['B', 7, 120.89, 1.21, 102.33, 1.18, 114.8, 1.42, 110.27, 1.29, 118.81, 1.3, 118.63, 1.73, 122.52, 1.6, 1.3324, 0.0089, 1.4681, 0.011, 1.5356, 0.0169, 1.5207, 0.011, 1.2362, 0.012],
(-90, 10) : ['B', 6, 121.0, 1.16, 102.17, 1.05, 114.92, 1.19, 110.0, 1.12, 118.68, 1.14, 118.81, 1.61, 122.47, 1.62, 1.3315, 0.0079, 1.4701, 0.0101, 1.535, 0.0137, 1.5221, 0.0098, 1.2346, 0.0111],
(-90, 50) : ['B', 3, 121.65, 1.01, 102.81, 0.67, 113.12, 1.65, 112.1, 1.59, 121.38, 0.77, 116.45, 0.85, 122.11, 1.33, 1.3401, 0.0276, 1.4676, 0.0079, 1.5313, 0.0062, 1.5272, 0.0135, 1.2361, 0.0147],
(-90, 60) : ['B', 3, 120.96, 1.41, 102.28, 0.75, 112.26, 1.44, 112.64, 1.43, 121.77, 1.14, 115.95, 1.12, 122.26, 1.2, 1.3553, 0.0815, 1.474, 0.0133, 1.5329, 0.0104, 1.5283, 0.0091, 1.2356, 0.0176],
(-90, 70) : ['B', 3, 120.56, 2.23, 102.36, 0.78, 112.36, 2.06, 112.97, 1.43, 122.57, 1.56, 115.65, 1.56, 121.75, 1.76, 1.3796, 0.1343, 1.4803, 0.0171, 1.5309, 0.0122, 1.5261, 0.0085, 1.2389, 0.02],
(-90, 80) : ['B', 3, 120.89, 2.25, 102.73, 0.73, 113.27, 3.02, 112.06, 1.67, 123.07, 1.38, 115.35, 1.61, 121.52, 1.84, 1.3734, 0.1298, 1.4811, 0.0185, 1.5297, 0.0099, 1.529, 0.0108, 1.2329, 0.0189],
(-90, 140) : ['B', 3, 120.25, 1.35, 102.67, 1.09, 111.69, 1.97, 110.25, 1.59, 121.98, 1.23, 115.14, 1.38, 122.78, 1.4, 1.333, 0.012, 1.4672, 0.0113, 1.5351, 0.0112, 1.5204, 0.0108, 1.2328, 0.0099],
(-90, 150) : ['B', 5, 120.51, 1.26, 102.72, 1.06, 112.01, 1.84, 110.21, 1.57, 122.19, 1.26, 114.66, 1.34, 123.05, 1.34, 1.3302, 0.0123, 1.4648, 0.0111, 1.5358, 0.0113, 1.5198, 0.0106, 1.2323, 0.0109],
(-90, 160) : ['B', 3, 120.66, 1.09, 102.85, 1.13, 111.77, 1.67, 110.17, 1.45, 122.13, 1.23, 114.58, 1.16, 123.21, 1.21, 1.3295, 0.0122, 1.4641, 0.0101, 1.5362, 0.0135, 1.5229, 0.0103, 1.2327, 0.0123],
(-90, 170) : ['B', 4, 120.85, 1.08, 102.72, 1.16, 111.03, 1.78, 110.2, 1.46, 121.96, 1.23, 114.74, 1.03, 123.23, 1.11, 1.328, 0.0125, 1.4635, 0.0093, 1.5354, 0.016, 1.5254, 0.0097, 1.2324, 0.0125],
(-80, -180) : ['B', 7, 120.98, 1.07, 102.86, 1.23, 110.4, 1.61, 110.96, 1.66, 121.9, 1.47, 115.12, 1.25, 122.89, 1.25, 1.3262, 0.0144, 1.4652, 0.0117, 1.5306, 0.0167, 1.5257, 0.0113, 1.2295, 0.0156],
(-80, -20) : ['B', 11, 119.64, 1.01, 103.46, 0.93, 114.18, 1.39, 111.31, 1.61, 118.86, 1.33, 118.67, 1.46, 122.38, 1.39, 1.3371, 0.0124, 1.47, 0.0134, 1.5348, 0.0164, 1.5169, 0.0154, 1.2385, 0.0122],
(-80, -10) : ['B', 23, 120.04, 1.08, 103.2, 0.95, 114.27, 1.35, 111.04, 1.51, 118.9, 1.26, 118.68, 1.5, 122.37, 1.37, 1.3365, 0.0106, 1.4691, 0.0125, 1.5341, 0.0179, 1.5183, 0.0152, 1.2388, 0.0127],
(-80, 0) : ['B', 14, 120.45, 1.11, 102.88, 1.09, 114.35, 1.25, 110.88, 1.41, 118.98, 1.22, 118.62, 1.64, 122.36, 1.64, 1.335, 0.0094, 1.4673, 0.0117, 1.5352, 0.0173, 1.5194, 0.013, 1.2362, 0.0123],
(-80, 10) : ['B', 3, 120.83, 1.02, 102.6, 1.17, 114.68, 1.04, 110.52, 1.36, 118.92, 1.14, 118.69, 1.7, 122.33, 1.84, 1.3336, 0.0084, 1.4663, 0.0113, 1.5365, 0.0139, 1.5204, 0.0095, 1.234, 0.01],
(-80, 50) : ['B', 3, 121.91, 1.35, 102.79, 0.66, 113.7, 1.76, 112.04, 1.43, 121.31, 0.74, 116.2, 0.8, 122.44, 1.28, 1.3392, 0.034, 1.4687, 0.0074, 1.5315, 0.0071, 1.5276, 0.012, 1.2322, 0.0143],
(-80, 60) : ['B', 4, 120.88, 1.72, 102.25, 0.7, 112.48, 1.35, 112.89, 1.31, 121.97, 1.22, 115.89, 1.12, 122.12, 1.42, 1.3635, 0.1005, 1.4742, 0.0124, 1.5342, 0.0117, 1.5258, 0.0098, 1.2343, 0.0173],
(-80, 70) : ['B', 7, 120.25, 2.57, 102.35, 0.71, 112.33, 1.87, 113.09, 1.36, 122.82, 1.65, 115.59, 1.5, 121.58, 2.04, 1.3988, 0.158, 1.479, 0.0156, 1.5323, 0.0126, 1.5242, 0.0092, 1.236, 0.0201],
(-80, 80) : ['B', 5, 120.53, 2.52, 102.65, 0.68, 112.92, 2.73, 112.27, 1.56, 123.16, 1.49, 115.35, 1.54, 121.45, 2.05, 1.3904, 0.1512, 1.4794, 0.0171, 1.5303, 0.0103, 1.5271, 0.0107, 1.231, 0.0197],
(-80, 110) : ['B', 4, 120.79, 1.3, 102.92, 0.56, 110.74, 1.66, 111.87, 0.84, 121.11, 1.08, 116.09, 0.92, 122.73, 0.71, 1.3342, 0.0065, 1.4696, 0.0101, 1.5356, 0.0105, 1.5206, 0.0093, 1.235, 0.0079],
(-80, 120) : ['B', 5, 120.46, 1.47, 103.23, 0.67, 110.21, 1.64, 111.4, 0.91, 120.85, 1.24, 116.16, 1.22, 122.93, 0.97, 1.335, 0.0087, 1.4715, 0.0117, 1.5337, 0.0121, 1.522, 0.0094, 1.2329, 0.0096],
(-80, 130) : ['B', 8, 120.13, 1.13, 103.36, 0.83, 110.55, 1.63, 111.11, 1.17, 120.97, 1.17, 115.93, 1.26, 123.03, 1.13, 1.3339, 0.0111, 1.4701, 0.0123, 1.5333, 0.0126, 1.5227, 0.011, 1.2333, 0.0106],
(-80, 140) : ['B', 12, 119.99, 1.08, 103.19, 0.95, 111.32, 1.71, 110.85, 1.41, 121.48, 1.2, 115.37, 1.32, 123.06, 1.26, 1.3314, 0.0128, 1.4669, 0.0119, 1.5338, 0.0128, 1.5202, 0.0126, 1.2337, 0.0108],
(-80, 150) : ['B', 27, 120.14, 1.06, 103.15, 0.97, 111.68, 1.67, 110.63, 1.43, 121.86, 1.22, 114.91, 1.29, 123.13, 1.26, 1.3294, 0.0125, 1.4647, 0.0115, 1.5335, 0.0123, 1.5196, 0.0124, 1.2332, 0.0112],
(-80, 160) : ['B', 28, 120.31, 0.98, 103.23, 1.13, 111.57, 1.52, 110.6, 1.38, 122.12, 1.24, 114.65, 1.27, 123.14, 1.22, 1.3287, 0.012, 1.4646, 0.0112, 1.5328, 0.0135, 1.5216, 0.0118, 1.2323, 0.012],
(-80, 170) : ['B', 16, 120.52, 0.99, 103.15, 1.29, 111.13, 1.49, 110.75, 1.48, 122.15, 1.32, 114.72, 1.27, 123.04, 1.2, 1.3283, 0.0126, 1.4651, 0.011, 1.5322, 0.0158, 1.5237, 0.0111, 1.2315, 0.0131],
(-70, -40) : ['B', 9, 118.85, 1.09, 103.44, 1.12, 113.4, 1.34, 112.55, 1.5, 119.74, 1.45, 117.98, 1.43, 122.23, 1.25, 1.336, 0.012, 1.4713, 0.0129, 1.5341, 0.0144, 1.5163, 0.0142, 1.2374, 0.012],
(-70, -30) : ['B', 34, 119.19, 1.06, 103.52, 1.06, 113.57, 1.31, 112.11, 1.46, 119.34, 1.47, 118.34, 1.41, 122.27, 1.35, 1.3356, 0.0123, 1.47, 0.0133, 1.534, 0.014, 1.5166, 0.0154, 1.2372, 0.0116],
(-70, -20) : ['B', 56, 119.56, 1.01, 103.51, 0.96, 113.86, 1.25, 111.68, 1.46, 119.0, 1.4, 118.64, 1.4, 122.3, 1.36, 1.3359, 0.0125, 1.4705, 0.0137, 1.5335, 0.0149, 1.5166, 0.017, 1.2373, 0.0128],
(-70, -10) : ['B', 37, 119.87, 1.04, 103.41, 0.94, 114.03, 1.23, 111.44, 1.51, 118.86, 1.38, 118.75, 1.43, 122.35, 1.4, 1.3365, 0.0111, 1.4707, 0.0132, 1.5328, 0.0161, 1.5179, 0.0175, 1.238, 0.0137],
(-70, 0) : ['B', 6, 120.12, 1.11, 103.19, 1.0, 114.2, 1.2, 111.21, 1.71, 118.99, 1.32, 118.82, 1.56, 122.17, 1.67, 1.3366, 0.0098, 1.4696, 0.0122, 1.5347, 0.0172, 1.5187, 0.0155, 1.2365, 0.0136],
(-70, 120) : ['B', 7, 120.23, 1.23, 103.3, 0.8, 110.5, 1.57, 111.56, 1.09, 120.92, 1.17, 116.01, 1.27, 123.03, 1.06, 1.3335, 0.0101, 1.4716, 0.0121, 1.533, 0.0128, 1.5217, 0.0099, 1.2328, 0.0116],
(-70, 130) : ['B', 22, 119.9, 1.05, 103.36, 0.88, 110.8, 1.51, 111.46, 1.21, 121.03, 1.14, 115.81, 1.22, 123.1, 1.12, 1.3327, 0.0117, 1.4693, 0.0122, 1.5328, 0.0131, 1.5218, 0.0116, 1.233, 0.0113],
(-70, 140) : ['B', 44, 119.76, 1.0, 103.34, 0.93, 111.19, 1.57, 111.21, 1.33, 121.31, 1.2, 115.5, 1.27, 123.1, 1.2, 1.3316, 0.0132, 1.467, 0.0121, 1.5326, 0.0134, 1.5202, 0.0133, 1.2333, 0.011],
(-70, 150) : ['B', 73, 119.85, 1.01, 103.33, 0.93, 111.38, 1.59, 110.98, 1.31, 121.67, 1.22, 115.16, 1.28, 123.06, 1.23, 1.3305, 0.0131, 1.4656, 0.0119, 1.5325, 0.0135, 1.5196, 0.0131, 1.2335, 0.0114],
(-70, 160) : ['B', 56, 120.03, 0.99, 103.38, 1.05, 111.41, 1.5, 110.95, 1.31, 122.08, 1.28, 114.82, 1.35, 123.0, 1.22, 1.33, 0.0122, 1.4654, 0.0119, 1.5319, 0.014, 1.5206, 0.0125, 1.233, 0.0118],
(-70, 170) : ['B', 15, 120.21, 0.96, 103.42, 1.32, 111.22, 1.4, 111.22, 1.51, 122.31, 1.41, 114.75, 1.45, 122.86, 1.24, 1.33, 0.0125, 1.4665, 0.0121, 1.5306, 0.0149, 1.5213, 0.012, 1.2325, 0.0127],
(-60, -50) : ['B', 13, 118.97, 1.04, 103.23, 1.07, 113.47, 1.43, 113.06, 1.59, 120.03, 1.45, 117.75, 1.5, 122.17, 1.13, 1.3352, 0.013, 1.4733, 0.0132, 1.5336, 0.0162, 1.5182, 0.0137, 1.238, 0.0136],
(-60, -40) : ['B', 78, 119.05, 1.11, 103.33, 1.1, 113.53, 1.39, 112.62, 1.65, 119.86, 1.56, 117.87, 1.56, 122.23, 1.2, 1.3354, 0.0136, 1.4717, 0.0132, 1.5339, 0.0149, 1.5171, 0.0146, 1.2374, 0.0126],
(-60, -30) : ['B', 97, 119.28, 1.1, 103.39, 1.08, 113.65, 1.35, 112.21, 1.56, 119.55, 1.52, 118.19, 1.47, 122.22, 1.29, 1.3346, 0.0128, 1.4707, 0.0132, 1.5339, 0.014, 1.5163, 0.0161, 1.2375, 0.0124],
(-60, -20) : ['B', 63, 119.56, 1.02, 103.48, 1.0, 113.84, 1.3, 111.85, 1.42, 119.18, 1.43, 118.53, 1.37, 122.24, 1.34, 1.3346, 0.0119, 1.4708, 0.0132, 1.5337, 0.014, 1.5161, 0.0175, 1.2373, 0.0132],
(-60, -10) : ['B', 11, 119.82, 0.98, 103.52, 0.95, 113.98, 1.29, 111.62, 1.46, 118.89, 1.51, 118.71, 1.36, 122.37, 1.43, 1.3358, 0.0108, 1.4712, 0.0128, 1.5335, 0.0146, 1.5176, 0.0185, 1.2378, 0.0142],
(-60, 120) : ['B', 7, 119.98, 1.16, 103.17, 0.89, 110.95, 1.62, 111.71, 1.3, 121.27, 1.05, 115.71, 1.19, 122.98, 1.09, 1.332, 0.0112, 1.4706, 0.0127, 1.5324, 0.0134, 1.5205, 0.0109, 1.2333, 0.0134],
(-60, 130) : ['B', 43, 119.83, 1.08, 103.27, 0.9, 111.03, 1.54, 111.64, 1.26, 121.23, 1.07, 115.7, 1.21, 123.01, 1.15, 1.3312, 0.012, 1.468, 0.012, 1.5323, 0.0133, 1.5215, 0.0119, 1.2331, 0.0123],
(-60, 140) : ['B', 84, 119.76, 1.03, 103.31, 0.89, 111.14, 1.56, 111.46, 1.29, 121.34, 1.14, 115.56, 1.27, 123.03, 1.21, 1.3316, 0.013, 1.4668, 0.0121, 1.5321, 0.0134, 1.5211, 0.0127, 1.2328, 0.0116],
(-60, 150) : ['B', 80, 119.78, 1.03, 103.35, 0.87, 111.21, 1.59, 111.23, 1.28, 121.56, 1.16, 115.33, 1.28, 123.01, 1.24, 1.3319, 0.0134, 1.4661, 0.0124, 1.5324, 0.0139, 1.5207, 0.0124, 1.233, 0.0119],
(-60, 160) : ['B', 30, 119.92, 1.07, 103.39, 0.94, 111.34, 1.55, 111.12, 1.29, 121.95, 1.25, 115.04, 1.35, 122.91, 1.21, 1.3317, 0.0126, 1.4657, 0.0121, 1.5328, 0.0147, 1.5212, 0.0119, 1.233, 0.0121],
(-60, 170) : ['B', 4, 120.11, 1.12, 103.45, 1.21, 111.33, 1.43, 111.4, 1.54, 122.31, 1.44, 114.89, 1.49, 122.71, 1.2, 1.3313, 0.0121, 1.4669, 0.0124, 1.5315, 0.0148, 1.5208, 0.012, 1.2329, 0.0124],
(-50, -50) : ['B', 13, 119.24, 1.04, 103.15, 1.09, 113.78, 1.62, 113.2, 1.69, 120.05, 1.58, 117.74, 1.53, 122.18, 1.08, 1.335, 0.0138, 1.4726, 0.0133, 1.5332, 0.0159, 1.5189, 0.0146, 1.2376, 0.0135],
(-50, -40) : ['B', 38, 119.32, 1.14, 103.26, 1.14, 113.75, 1.49, 112.64, 1.74, 119.84, 1.69, 117.89, 1.64, 122.24, 1.15, 1.3342, 0.0151, 1.4716, 0.0134, 1.5336, 0.0152, 1.5182, 0.0151, 1.2372, 0.0129],
(-50, -30) : ['B', 19, 119.47, 1.16, 103.3, 1.12, 113.81, 1.45, 112.26, 1.67, 119.64, 1.58, 118.15, 1.58, 122.17, 1.21, 1.3332, 0.0144, 1.4708, 0.0132, 1.5336, 0.0143, 1.5164, 0.0172, 1.238, 0.0133],
(-50, 130) : ['B', 21, 119.93, 1.07, 103.19, 0.9, 111.26, 1.63, 111.64, 1.27, 121.32, 1.09, 115.78, 1.24, 122.85, 1.22, 1.3302, 0.0119, 1.4669, 0.0117, 1.5316, 0.0136, 1.5211, 0.0121, 1.2333, 0.0139],
(-50, 140) : ['B', 45, 119.9, 1.02, 103.25, 0.88, 111.15, 1.58, 111.56, 1.27, 121.36, 1.13, 115.67, 1.3, 122.89, 1.27, 1.3311, 0.0127, 1.4663, 0.0117, 1.5317, 0.0129, 1.5219, 0.0119, 1.2329, 0.0124],
(-50, 150) : ['B', 24, 119.89, 1.02, 103.32, 0.84, 111.11, 1.59, 111.39, 1.28, 121.43, 1.12, 115.48, 1.32, 122.99, 1.27, 1.3317, 0.0133, 1.4661, 0.0123, 1.5325, 0.013, 1.5222, 0.0115, 1.2328, 0.0123],
},
"Pro_xpro" : {
(-180, -180) : ['I', 12, 120.38, 1.03, 103.08, 0.97, 110.7, 1.22, 110.92, 1.22, 120.56, 1.45, 117.93, 1.2, 121.46, 1.18, 1.3292, 0.0118, 1.4649, 0.0203, 1.5357, 0.0137, 1.5171, 0.0093, 1.2404, 0.0112],
(-70, 150) : ['B', 4, 119.66, 0.72, 103.22, 0.52, 110.58, 1.07, 111.17, 0.94, 120.73, 0.79, 118.06, 0.83, 121.15, 0.47, 1.3346, 0.0115, 1.4594, 0.014, 1.5393, 0.0093, 1.517, 0.0067, 1.2432, 0.0085],
(-60, 150) : ['B', 4, 119.66, 0.73, 103.19, 0.56, 110.47, 0.96, 111.39, 0.94, 120.9, 0.72, 117.73, 0.9, 121.31, 0.46, 1.3313, 0.0087, 1.457, 0.0131, 1.5349, 0.0093, 1.5143, 0.0055, 1.2456, 0.0085],
},
}
Gly_nonxpro = cdl_database["Gly_nonxpro"]
Gly_nonxpro[(-180, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-180, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-170, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-160, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-150, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-140, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-130, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-120, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-110, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-100, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-90, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-80, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-70, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-60, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-50, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-40, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-30, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-20, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(-10, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(0, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(10, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(20, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(30, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(40, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(50, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(60, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(70, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(80, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(90, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(100, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(110, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(120, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(130, 160)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -180)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(140, 170)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(150, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(160, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, -10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 0)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 10)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 20)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 30)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 40)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 50)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 60)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 70)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 80)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 90)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 100)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 110)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 120)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 130)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 140)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 150)]=Gly_nonxpro[(-180, -150)]
Gly_nonxpro[(170, 160)]=Gly_nonxpro[(-180, -150)]
Gly_xpro = cdl_database["Gly_xpro"]
Gly_xpro[(-180, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-180, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-170, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-160, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-150, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-140, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-130, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-120, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-110, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-100, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-90, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-80, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-70, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-60, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-50, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-40, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-30, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-20, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(-10, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(0, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(10, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(20, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(30, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(40, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(50, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(60, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(70, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(80, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(90, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(100, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(110, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(120, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(130, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(140, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(150, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(160, 170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -180)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -170)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, -10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 0)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 10)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 20)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 30)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 40)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 50)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 60)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 70)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 80)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 90)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 100)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 110)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 120)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 130)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 140)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 150)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 160)]=Gly_xpro[(-180, -180)]
Gly_xpro[(170, 170)]=Gly_xpro[(-180, -180)]
IleVal_nonxpro = cdl_database["IleVal_nonxpro"]
IleVal_nonxpro[(-180, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-180, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-170, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-160, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-150, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-140, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-130, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-120, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-110, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-100, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-90, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-80, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-70, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-60, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-50, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-40, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-30, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-20, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(-10, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(0, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(10, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(20, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(30, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(40, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(50, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(60, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(70, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(80, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(90, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(100, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(110, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(120, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(130, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(140, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(150, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(160, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -180)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -170)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, -10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 0)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 10)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 20)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 30)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 40)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 50)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 60)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 70)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 80)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 90)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 100)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 110)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 120)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 130)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 140)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 150)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 160)]=IleVal_nonxpro[(-180, -180)]
IleVal_nonxpro[(170, 170)]=IleVal_nonxpro[(-180, -180)]
IleVal_xpro = cdl_database["IleVal_xpro"]
IleVal_xpro[(-180, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-180, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-170, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-160, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-150, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-140, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-130, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-120, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-110, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-100, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-90, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-80, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-70, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-60, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-50, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-40, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-30, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-20, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(-10, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(0, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(10, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(20, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(30, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(40, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(50, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(60, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(70, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(80, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(90, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(100, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(110, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(120, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(130, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(140, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(150, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(160, 170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -180)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -170)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, -10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 0)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 10)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 20)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 30)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 40)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 50)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 60)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 70)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 80)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 90)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 100)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 110)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 120)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 130)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 140)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 150)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 160)]=IleVal_xpro[(-180, -180)]
IleVal_xpro[(170, 170)]=IleVal_xpro[(-180, -180)]
NonPGIV_nonxpro = cdl_database["NonPGIV_nonxpro"]
NonPGIV_nonxpro[(-180, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-180, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-170, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-160, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-150, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-140, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-130, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-120, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-110, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-100, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-90, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-80, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-70, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-60, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-50, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-40, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-30, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-20, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(-10, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(0, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(10, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(20, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(30, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(40, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(50, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(60, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(70, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(80, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(90, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(100, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(110, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(120, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(130, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(140, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(150, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(160, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -180)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, -10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 0)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 10)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 20)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 30)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 40)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 50)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 60)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 70)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 80)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 90)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 100)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 110)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 120)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 130)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 140)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 150)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 160)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_nonxpro[(170, 170)]=NonPGIV_nonxpro[(-180, -180)]
NonPGIV_xpro = cdl_database["NonPGIV_xpro"]
NonPGIV_xpro[(-180, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-180, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-170, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-160, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-150, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-140, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-130, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-120, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-110, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-100, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-90, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-80, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-70, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-60, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-50, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-40, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-30, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-20, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(-10, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(0, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(10, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(20, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(30, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(40, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(50, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(60, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(70, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(80, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(90, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(100, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(110, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(120, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(130, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(140, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(150, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(160, 170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -180)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -170)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, -10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 0)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 10)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 20)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 30)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 40)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 50)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 60)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 70)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 80)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 90)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 100)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 110)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 120)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 130)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 140)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 150)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 160)]=NonPGIV_xpro[(-180, -180)]
NonPGIV_xpro[(170, 170)]=NonPGIV_xpro[(-180, -180)]
Pro_nonxpro = cdl_database["Pro_nonxpro"]
Pro_nonxpro[(-180, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-180, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-170, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-160, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-150, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-140, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-130, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-120, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-110, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-100, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-90, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-80, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-70, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-60, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-50, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-40, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-30, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-20, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(-10, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(0, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(10, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(20, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(30, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(40, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(50, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(60, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(70, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(80, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(90, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(100, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(110, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(120, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(130, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(140, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(150, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(160, 170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -180)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -170)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, -10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 0)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 10)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 20)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 30)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 40)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 50)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 60)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 70)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 80)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 90)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 100)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 110)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 120)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 130)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 140)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 150)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 160)]=Pro_nonxpro[(-180, -180)]
Pro_nonxpro[(170, 170)]=Pro_nonxpro[(-180, -180)]
Pro_xpro = cdl_database["Pro_xpro"]
Pro_xpro[(-180, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-180, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-170, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-160, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-150, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-140, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-130, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-120, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-110, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-100, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-90, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-80, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-70, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-60, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-50, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-40, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-30, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-20, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(-10, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(0, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(10, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(20, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(30, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(40, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(50, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(60, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(70, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(80, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(90, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(100, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(110, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(120, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(130, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(140, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(150, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(160, 170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -180)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -170)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, -10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 0)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 10)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 20)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 30)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 40)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 50)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 60)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 70)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 80)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 90)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 100)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 110)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 120)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 130)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 140)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 150)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 160)]=Pro_xpro[(-180, -180)]
Pro_xpro[(170, 170)]=Pro_xpro[(-180, -180)]
#
# adjustments due to too large esd
#
Pro_nonxpro[(-90, 60)][16]=1.333900 # mCN
Pro_nonxpro[(-90, 60)][17]=0.023400 # sCN
Pro_nonxpro[(-90, 70)][16]=1.333900 # mCN
Pro_nonxpro[(-90, 70)][17]=0.023400 # sCN
Pro_nonxpro[(-90, 80)][16]=1.333900 # mCN
Pro_nonxpro[(-90, 80)][17]=0.023400 # sCN
Pro_nonxpro[(-80, 60)][16]=1.333900 # mCN
Pro_nonxpro[(-80, 60)][17]=0.023400 # sCN
Pro_nonxpro[(-80, 70)][16]=1.333900 # mCN
Pro_nonxpro[(-80, 70)][17]=0.023400 # sCN
Pro_nonxpro[(-80, 80)][16]=1.333900 # mCN
Pro_nonxpro[(-80, 80)][17]=0.023400 # sCN
Pro_nonxpro[(-80, 110)][16]=1.333900 # mCN
Pro_nonxpro[(-80, 110)][17]=0.023400 # sCN
Gly_nonxpro[(-100, -90)][10]=120.570000 # mACO
Gly_nonxpro[(-100, -90)][11]=1.740000 # sACO
Gly_nonxpro[(-100, -90)][12]=116.690000 # mACN
Gly_nonxpro[(-100, -90)][13]=2.040000 # sACN
Gly_nonxpro[(150, -140)][10]=120.570000 # mACO
Gly_nonxpro[(150, -140)][11]=1.740000 # sACO
NonPGIV_xpro[(-150, 100)][16]=1.331000 # mCN
NonPGIV_xpro[(-150, 100)][17]=0.020700 # sCN
NonPGIV_xpro[(-100, 140)][16]=1.331000 # mCN
NonPGIV_xpro[(-100, 140)][17]=0.020700 # sCN
NonPGIV_xpro[(-90, 140)][16]=1.331000 # mCN
NonPGIV_xpro[(-90, 140)][17]=0.020700 # sCN
NonPGIV_xpro[(50, 50)][14]=121.320000 # mOCN
NonPGIV_xpro[(50, 50)][15]=1.150000 # sOCN
NonPGIV_xpro[(50, 60)][14]=121.320000 # mOCN
NonPGIV_xpro[(50, 60)][15]=1.150000 # sOCN
NonPGIV_nonxpro[(-160, -150)][24]=1.235300 # mCO
NonPGIV_nonxpro[(-160, -150)][25]=0.012600 # sCO
NonPGIV_nonxpro[(-120, -120)][22]=1.523200 # mAC
NonPGIV_nonxpro[(-120, -120)][23]=0.013400 # sAC
NonPGIV_nonxpro[(-120, -100)][12]=116.840000 # mACN
NonPGIV_nonxpro[(-120, -100)][13]=1.710000 # sACN
NonPGIV_nonxpro[(-110, -130)][4]=110.490000 # mNAB
NonPGIV_nonxpro[(-110, -130)][5]=1.690000 # sNAB
NonPGIV_nonxpro[(-110, -130)][24]=1.235300 # mCO
NonPGIV_nonxpro[(-110, -130)][25]=0.012600 # sCO
NonPGIV_nonxpro[(-100, -130)][4]=110.490000 # mNAB
NonPGIV_nonxpro[(-100, -130)][5]=1.690000 # sNAB
NonPGIV_nonxpro[(-100, -130)][24]=1.235300 # mCO
NonPGIV_nonxpro[(-100, -130)][25]=0.012600 # sCO
Gly_xpro[(-60, -40)][2]=121.870000 # mCNA
Gly_xpro[(-60, -40)][3]=1.570000 # sCNA
Gly_xpro[(-50, -40)][14]=121.770000 # mOCN
Gly_xpro[(-50, -40)][15]=1.000000 # sOCN
class custom_cdl_dict(dict):
def __init__(self):
self.version=None
O = custom_cdl_dict()
for k,v in zip(cdl_database.keys(), cdl_database.values()): O[k]=v
cdl_database=O
cdl_database.version=version
def run(args):
assert len(args) == 0
print cdl_database["Pro_nonxpro"][(-180,-180)]
for res_group_type in cdl_database:
print res_group_type, len(cdl_database[res_group_type])
if (__name__ == "__main__"):
import sys
run(args=sys.argv[1:])
| 1.640625
| 2
|
parlaseje/models.py
|
VesterDe/parlalize
| 1
|
12775084
|
# -*- coding: utf-8 -*-
from django.db import models
from django.utils.translation import ugettext_lazy as _
from jsonfield import JSONField
from behaviors.models import Timestampable, Versionable
from parlalize.settings import API_OUT_DATE_FORMAT
from datetime import datetime
class PopoloDateTimeField(models.DateTimeField):
"""Converting datetime to popolo."""
def get_popolo_value(self, value):
return str(datetime.strftime(value, '%Y-%m-%d'))
class Session(Timestampable, models.Model):
"""Model of all sessions that happened in parliament, copied from parladata."""
name = models.CharField(_('name'),
blank=True, null=True,
max_length=128,
help_text=_('Session name'))
date = PopoloDateTimeField(_('date of session'),
blank=True, null=True,
help_text=_('date of session'))
id_parladata = models.IntegerField(_('parladata id'),
blank=True, null=True,
help_text=_('id parladata'))
mandate = models.CharField(_('mandate name'),
blank=True, null=True,
max_length=128,
help_text=_('Mandate name'))
start_time = PopoloDateTimeField(_('start time of session'),
blank=True, null=True,
help_text='Start time')
end_time = PopoloDateTimeField(_('end time of session'),
blank=True, null=True,
help_text='End time')
organization = models.ForeignKey('parlaskupine.Organization',
blank=True, null=True,
related_name='session',
help_text='The organization in session')
organizations = models.ManyToManyField('parlaskupine.Organization',
related_name='sessions',
help_text='The organizations in session')
classification = models.CharField(_('classification'),
max_length=128,
blank=True, null=True,
help_text='Session classification')
actived = models.CharField(_('actived'),
null=True, blank=True,
max_length=128,
help_text=_('Yes if PG is actived or no if it is not'))
classification = models.CharField(_('classification'),
max_length=128,
blank=True, null=True,
help_text=_('An organization category, e.g. committee'))
gov_id = models.TextField(blank=True, null=True,
help_text='Gov website ID.')
in_review = models.BooleanField(default=False,
help_text='Is session in review?')
def __str__(self):
return self.name
def getSessionDataMultipleOrgs(self):
orgs_data = [org.getOrganizationData()
for org
in self.organizations.all()]
return {'name': self.name,
'date': self.start_time.strftime(API_OUT_DATE_FORMAT),
'date_ts': self.start_time,
'id': self.id_parladata,
'orgs': orgs_data,
'in_review': self.in_review}
def getSessionData(self):
orgs_data = [org.getOrganizationData()
for org
in self.organizations.all()]
return {'name': self.name,
'date': self.start_time.strftime(API_OUT_DATE_FORMAT),
'date_ts': self.start_time,
'id': self.id_parladata,
'org': self.organization.getOrganizationData(),
'orgs': orgs_data,
'in_review': self.in_review}
class Activity(Timestampable, models.Model):
"""All activities of MP."""
id_parladata = models.IntegerField(_('parladata id'),
blank=True, null=True,
help_text=_('id parladata'))
session = models.ForeignKey('Session',
blank=True, null=True,
related_name="%(app_label)s_%(class)s_related",
help_text=_('Session '))
person = models.ForeignKey('parlaposlanci.Person',
blank=True, null=True,
help_text=_('MP'))
start_time = PopoloDateTimeField(blank=True, null=True,
help_text='Start time')
end_time = PopoloDateTimeField(blank=True, null=True,
help_text='End time')
def get_child(self):
if Speech.objects.filter(activity_ptr=self.id):
return Speech.objects.get(activity_ptr=self.id)
elif Ballot.objects.filter(activity_ptr=self.id):
return Ballot.objects.get(activity_ptr=self.id)
else:
return Question.objects.get(activity_ptr=self.id)
class Speech(Versionable, Activity):
"""Model of all speeches in parlament."""
content = models.TextField(blank=True, null=True,
help_text='Words spoken')
order = models.IntegerField(blank=True, null=True,
help_text='Order of speech')
organization = models.ForeignKey('parlaskupine.Organization',
blank=True, null=True,
help_text='Organization')
def __init__(self, *args, **kwargs):
super(Activity, self).__init__(*args, **kwargs)
@staticmethod
def getValidSpeeches(date_):
return Speech.objects.filter(valid_from__lt=date_, valid_to__gt=date_)
class Question(Activity):
"""Model of MP questions to the government."""
content_link = models.URLField(help_text='Words spoken',
max_length=350,
blank=True, null=True)
title = models.TextField(blank=True, null=True,
help_text='Words spoken')
recipient_persons = models.ManyToManyField('parlaposlanci.Person',
blank=True,
null=True,
help_text='Recipient persons (if it\'s a person).',
related_name='questions')
recipient_organizations = models.ManyToManyField('parlaskupine.Organization',
blank=True,
null=True,
help_text='Recipient organizations (if it\'s an organization).',
related_name='questions_org')
recipient_text = models.TextField(blank=True,
null=True,
help_text='Recipient name as written on dz-rs.si')
def getQuestionData(self):
# fix import issue
from parlalize.utils import getMinistryData
persons = []
orgs = []
for person in self.recipient_persons.all():
persons.append(getMinistryData(person.id_parladata, self.start_time.strftime(API_DATE_FORMAT)))
for org in self.recipient_organizations.all():
orgs.append(org.getOrganizationData())
return {'title': self.title,
'recipient_text': self.recipient_text,
'recipient_persons': persons,
'recipient_orgs': orgs,
'url': self.content_link,
'id': self.id_parladata}
class Ballot(Activity):
"""Model of all ballots"""
vote = models.ForeignKey('Vote',
blank=True, null=True,
related_name='vote',
help_text=_('Vote'))
option = models.CharField(max_length=128,
blank=True, null=True,
help_text='Yes, no, abstain')
org_voter = models.ForeignKey('parlaskupine.Organization',
blank=True, null=True,
related_name='OrganizationVoter',
help_text=_('Organization voter'))
def __init__(self, *args, **kwargs):
super(Activity, self).__init__(*args, **kwargs)
class Vote(Timestampable, models.Model):
"""Model of all votes that happend on specific sessions,
with number of votes for, against, abstain and not present.
"""
created_for = models.DateField(_('date of vote'),
blank=True, null=True,
help_text=_('date of vote'))
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='in_session',
help_text=_('Session '))
motion = models.TextField(blank=True, null=True,
help_text='The motion for which the vote took place')
tags = JSONField(blank=True, null=True)
votes_for = models.IntegerField(blank=True, null=True,
help_text='Number of votes for')
against = models.IntegerField(blank=True, null=True,
help_text='Number votes againt')
abstain = models.IntegerField(blank=True, null=True,
help_text='Number votes abstain')
not_present = models.IntegerField(blank=True, null=True,
help_text='Number of MPs that warent on the session')
result = models.NullBooleanField(blank=True, null=True,
default=False,
help_text='The result of the vote')
id_parladata = models.IntegerField(_('parladata id'),
blank=True, null=True,
help_text=_('id parladata'))
document_url = JSONField(blank=True,
null=True)
start_time = PopoloDateTimeField(blank=True,
null=True,
help_text='Start time')
is_outlier = models.NullBooleanField(default=False,
help_text='is outlier')
has_outlier_voters = models.NullBooleanField(default=False,
help_text='has outlier voters')
intra_disunion = models.FloatField(default=0.0,
help_text='intra disunion for all members')
class VoteDetailed(Timestampable, models.Model):
"""Model of votes with data, how each MP and PG voted."""
motion = models.TextField(blank=True, null=True,
help_text='The motion for which the vote took place')
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='in_session_for_VG',
help_text=_('Session '))
vote = models.ForeignKey('Vote',
blank=True, null=True,
related_name='vote_of_graph',
help_text=_('Vote'))
created_for = models.DateField(_('date of vote'),
blank=True, null=True,
help_text=_('date of vote'))
votes_for = models.IntegerField(blank=True, null=True,
help_text='Number of votes for')
against = models.IntegerField(blank=True, null=True,
help_text='Number votes againt')
abstain = models.IntegerField(blank=True, null=True,
help_text='Number votes abstain')
not_present = models.IntegerField(blank=True, null=True,
help_text='Number of MPs that warent on the session')
result = models.NullBooleanField(blank=True, null=True,
default=False,
help_text='The result of the vote')
pgs_yes = JSONField(blank=True, null=True)
pgs_no = JSONField(blank=True, null=True)
pgs_np = JSONField(blank=True, null=True)
pgs_kvor = JSONField(blank=True, null=True)
mp_yes = JSONField(blank=True, null=True)
mp_no = JSONField(blank=True, null=True)
mp_np = JSONField(blank=True, null=True)
mp_kvor = JSONField(blank=True, null=True)
class Vote_analysis(Timestampable, models.Model):
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='in_session_for_VA',
help_text=_('Session '))
vote = models.ForeignKey('Vote',
blank=True, null=True,
related_name='analysis',
help_text=_('Vote'))
created_for = models.DateField(_('date of vote'),
blank=True,
null=True,
help_text=_('date of vote'))
votes_for = models.IntegerField(blank=True, null=True,
help_text='Number of votes for')
against = models.IntegerField(blank=True, null=True,
help_text='Number votes againt')
abstain = models.IntegerField(blank=True, null=True,
help_text='Number votes abstain')
not_present = models.IntegerField(blank=True, null=True,
help_text='Number of MPs that warent on the session')
pgs_data = JSONField(blank=True, null=True)
mp_yes = JSONField(blank=True, null=True)
mp_no = JSONField(blank=True, null=True)
mp_np = JSONField(blank=True, null=True)
mp_kvor = JSONField(blank=True, null=True)
coal_opts = JSONField(blank=True, null=True)
oppo_opts = JSONField(blank=True, null=True)
class AbsentMPs(Timestampable, models.Model):
"""Model for analysis absent MPs on session."""
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='session_absent',
help_text=_('Session '))
absentMPs = JSONField(blank=True, null=True)
created_for = models.DateField(_('date of vote'),
blank=True, null=True,
help_text=_('date of vote'))
class Quote(Timestampable, models.Model):
"""Model for quoted text from speeches."""
quoted_text = models.TextField(_('quoted text'),
blank=True, null=True,
help_text=_('text quoted in a speech'))
speech = models.ForeignKey('Speech',
help_text=_('the speech that is being quoted'))
first_char = models.IntegerField(blank=True, null=True,
help_text=_('index of first character of quote string'))
last_char = models.IntegerField(blank=True, null=True,
help_text=_('index of last character of quote string'))
class PresenceOfPG(Timestampable, models.Model):
"""Model for analysis presence of PG on session."""
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='session_presence',
help_text=_('Session '))
presence = JSONField(blank=True, null=True)
created_for = models.DateField(_('date of activity'),
blank=True, null=True,
help_text=_('date of analize'))
class Tfidf(Timestampable, models.Model):
"""Model for analysis TFIDF."""
session = models.ForeignKey('Session',
blank=True, null=True,
related_name='tfidf',
help_text=_('Session '))
created_for = models.DateField(_('date of activity'),
blank=True,
null=True,
help_text=_('date of analize'))
is_visible = models.BooleanField(_('is visible'),
default=True)
data = JSONField(blank=True, null=True)
def __str__(self):
return unicode(self.session.name) + " --> " + unicode(self.session.organization.name)
class Tag(models.Model):
"""All tags of votes."""
id_parladata = models.IntegerField(_('parladata id'),
blank=True,
null=True,
help_text=_('id parladata'))
name = models.TextField(blank=True,
null=True,
help_text=_('tag name'))
| 2.109375
| 2
|
model/dnn.py
|
msamribeiro/deep-cca
| 27
|
12775085
|
<reponame>msamribeiro/deep-cca
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Parallel network and feedforward network.
Author: <NAME>
Date: 2017
"""
import numpy
import theano
import theano.tensor as T
from cca_layer import CCA
from layers import HiddenLayer, ConvPoolLayer
class DNN(object):
def __init__(self, rng, in_x, in_size, architecture, activation=T.tanh):
''' Single feedforward Deep Neural Network '''
self.layers = []
self.params = []
self.n_layers = len(architecture)
assert self.n_layers > 0
self.x = in_x
for i in xrange(self.n_layers):
if i == 0:
input_size = in_size
else:
input_size = architecture[i-1]
if i == 0:
layer_input = self.x
else:
layer_input = self.layers[-1].output
hidden_layer = HiddenLayer(rng=rng,
input=layer_input,
n_in=input_size,
n_out=architecture[i],
activation=activation)
self.layers.append(hidden_layer)
self.params.extend(hidden_layer.params)
self.output = self.layers[-1].output
class ParallelDNN(object):
def __init__(self, config, data):
''' Parallel DNN with CCA objective function '''
index = T.lscalar() # index to a [mini]batch
x1 = T.matrix("x1", dtype=theano.config.floatX) # view1 of the data
x2 = T.matrix("x2", dtype=theano.config.floatX) # view2 of the data
rng = numpy.random.RandomState(1234)
# parallel networks
dnn1 = DNN(rng, x1, config.x1_dim, config.architecture1)
dnn2 = DNN(rng, x2, config.x2_dim, config.architecture2)
# CCA objective function
cca = CCA(config)
cost, mean = cca.cca(dnn1.output, dnn2.output)
params = dnn1.params + dnn2.params
gparams = [T.grad(cost, param) for param in params]
updates = [
(param, param - config.learning_rate * gparam)
for param, gparam in zip(params, gparams)
]
train_set_x1, train_set_x2 = data[0]
valid_set_x1, valid_set_x2 = data[1]
test_set_x1, test_set_x2 = data[2]
self.train = theano.function(
inputs=[index],
outputs=[cost, mean],
updates=updates,
givens={
x1: train_set_x1[index * config.batch_size: (index + 1) * config.batch_size],
x2: train_set_x2[index * config.batch_size: (index + 1) * config.batch_size]
}
)
self.valid = theano.function(
inputs=[index],
outputs=[cost, mean],
givens={
x1: valid_set_x1[index * config.batch_size:(index + 1) * config.batch_size],
x2: valid_set_x2[index * config.batch_size:(index + 1) * config.batch_size]
}
)
self.test = theano.function(
inputs=[index],
outputs=[cost, mean],
givens={
x1: test_set_x1[index * config.batch_size:(index + 1) * config.batch_size],
x2: test_set_x2[index * config.batch_size:(index + 1) * config.batch_size]
}
)
| 3
| 3
|
Registration/ImageRegistration.py
|
yuzhounaut/SpaceM
| 8
|
12775086
|
<gh_stars>1-10
from skimage import transform as tf
from skimage import filters
from skimage import exposure
from scipy import ndimage
from scipy.optimize import basinhopping
from scipy import spatial
import os, gc, glob, spaceM
import numpy as np
import matplotlib.pyplot as plt
import tifffile as tiff
import spaceM.ImageFileManipulation.FIJIcalls as fc
import spaceM.Pipeline as sp
# MFA = sp.getPath('MF') + 'Analysis/'
def penMarksFeatures(MF, prefix='', input=[], whole_image=True, output=[]):
"""Obtain coordinates of the pixels at the edge of the penmarks from the tile frames in both pre- and post-MALDI
microscopy datasets using matlab implementation of the SURF algorithm.
Args:
MF (str): path to Main Folder.
prefix (str): either 'pre' or 'post' for pre- or post-MALDI dataset, respectively.
whole_image (bool): whether or not perform the fiducial detection on the stitched image. If False, performs
on the tiled images, uses less RAM but much slower.
"""
def fiducialFinder(im_p):
# prefix= 'post'
# im_p = MF + 'Analysis/StitchedMicroscopy/' + prefix + 'MALDI_FLR/' + 'img_t1_z1_c1'
# im_p = 'E:\Experiments\TNFa_2.3_SELECTED\Analysis\StitchedMicroscopy\preMALDI_FLR\img_XY030.tif'
im = tiff.imread(im_p)
if len(np.shape(im)) > 2:
im = im[0,:,:]
# im = np.log2(im+1)
val = filters.threshold_otsu(im, nbins=65536)
val = np.mean(im) - np.std(im)/2
hist, bins_center = exposure.histogram(im)
plt.plot(bins_center, hist, lw=2)
plt.axvline(val, color='k', ls='--', label='Threshold')
plt.yscale('log')
plt.xlabel('Pixel intensities')
plt.ylabel('Log10(counts)')
# plt.title('Mean- std/2')
plt.legend()
plt.savefig(MF + 'Analysis/Fiducials/' + prefix + '_histogram.png')
plt.close('all')
BW = np.zeros(np.shape(im))
BW[im < val] = 1
BW[im < 100] = 0
im = []
# opening
struct2 = ndimage.generate_binary_structure(2,1)
iteration = 10
rec_o1 = ndimage.binary_erosion(BW, structure=struct2, iterations=iteration).astype(BW.dtype)
BW = []
rec_o2 = ndimage.binary_dilation(rec_o1, structure=struct2, iterations=iteration).astype(rec_o1.dtype)
rec_o1 = []
rec_c1 = ndimage.binary_dilation(rec_o2, structure=struct2, iterations=iteration).astype(rec_o2.dtype)
rec_o2 = []
rec_c2 = ndimage.binary_dilation(rec_c1, structure=struct2, iterations=iteration).astype(rec_c1.dtype)
gc.collect()
edge = filters.sobel(rec_c2)
rec_o2 = []
# plt.imshow(edge)
x,y = np.where(edge > 0)
return x,y
folder = MF + 'Analysis/StitchedMicroscopy/' + prefix + 'MALDI_FLR/'
if whole_image:
if prefix == 'pre':
X,Y = fiducialFinder(im_p=folder + 'img_t1_z1_c0')
if prefix == 'post':
X,Y = fiducialFinder(im_p=folder + 'img_t1_z1_c0')
# if prefix == 'timelapse':
# os.chdir(MF + 'Input/Timelapse/BF/')
# X,Y = fiducialFinder(im_p= MF + 'Input/Timelapse/BF/{}'.format(
# glob.glob(r'T*')[np.argsort([int(s[1:]) for s in glob.glob(r'T*')])[-1]]))
if type(input) == str:
X, Y = fiducialFinder(im_p=input)
else:
[picXcoord, picYcoord] = fc.readTileConfReg(folder)
X = []
Y = []
for item in os.listdir(folder):
if item.endswith('.tif'):
x_coord, y_coord = fiducialFinder(folder + item)
picInd = int(item[len(item) - 7:len(item) - 4])
for i in range(len(x_coord)):
if x_coord[i] < (1608 - 1608*0.1) and y_coord[i] < (1608 - 1608*0.1):
xScaled = x_coord[i] + picXcoord[picInd - 1]
yScaled = y_coord[i] + picYcoord[picInd - 1]
X = np.append(X, xScaled)
Y = np.append(Y, yScaled)
print(item)
if type(output) == str:
np.save(output, [X, Y])
else:
np.save(MF + 'Analysis/Fiducials/' + prefix + 'XYpenmarks.npy', [X, Y])
plt.figure()
plt.scatter(X, Y, 1)
plt.xlabel('X dimension', fontsize=20)
plt.ylabel('Y dimension', fontsize=20)
plt.title('Fiducials detection ' + prefix +'MALDI', fontsize=25)
plt.axis('equal')
plt.savefig(MF + 'Analysis/Fiducials/' + prefix + 'CHECK.png', dpi = 500)
plt.close('all')
def transform(postX, postY, transX, transY, rot):
"""Coordinate transform function.
Args:
postX (list): X coordinates to transform (1D).
postY (list): Y coordinates to transform (1D).
transX (float): Translation value in X dimension.
transY (float): Translation value in Y dimension.
rot (float): Rotation value in degree.
Returns:
transformed (list): Transformed coordinates (2D).
"""
tform = tf.SimilarityTransform(scale=1, rotation=rot, translation=(transX, transY))
transformed = tf.matrix_transform(np.transpose([postX, postY]), tform.params)
return transformed
def fiducialsAlignment(MF,
src,
dst):
"""Define the coordinate transform parameters leading to the optimal overlap between the pre and post-MALDI
fiducials.
Args:
MFA (str): path to Main Folder Analysis.
"""
def get_distance(x_spots,y_spots,xe,ye,n_neighbor):
"""Measure the euclidean distance between each point of an array to its n nearest neighbor in a second array using
kd-tree algorithm.
Args:
x_spots (list): X coordinates of the array to query (1D).
y_spots (list): Y coordinates of the array to query (1D).
xe (list): X coordinates of the array to index (1D).
ye (list): Y coordinates of the array to index(1D).
n_neighbor (int): The number of nearest neighbor to consider.
Returns:
distances (list): Distances of the indexed points n nearest queried neighbors (2D).
"""
data = list(zip(xe.ravel(), ye.ravel()))
tree = spatial.KDTree(data)
return tree.query(list(zip(x_spots.ravel(), y_spots.ravel())),n_neighbor)
def err_func(params, preX, preY, postX, postY):
"""Error function passed in the optimizer. Transforms coordinates of target frame and returns the mean nearest neighbor
distance to the 1st frame fiducials.
Args:
params (list): Array of coordinate transformation function:
[Translation in X(float), Translation in Y(float), rotation(float)] (1D).
preX (list): X coordinates of the 1st frame fiducials (1D).
preY (list): Y coordinates of the 1st frame fiducials (1D).
postX (list): X coordinates of the target frame fiducials (1D).
postY (list): Y coordinates of the target frame fiducials (1D).
Returns:
mean_distances (): Mean N nearest neighbor distance to the 1st frame fiducials.
"""
transX, transY, rot = params
transformed = transform(postX, postY, transX, transY, rot)
distances = np.array(get_distance(transformed[:, 0], transformed[:, 1], preX, preY, 1)[0])
return np.mean(distances)
preX, preY = np.load(dst)
postX, postY = np.load(src)
n_features = 2000
post_den = int(np.round(np.shape(postX)[0] / n_features))
postX_redu = postX[::post_den]#reduces optimizer computation time
#TODO --> need to evaluate impact on alignment precision
postY_redu = postY[::post_den]
# print('post features length = {}'.format(np.shape(postX_redu)))
pre_den = int(np.round(np.shape(preX)[0] / n_features))
preX_redu = preX[::pre_den]
preY_redu = preY[::pre_den]
# print('pre features length = {}'.format(np.shape(preX_redu)))
minF = basinhopping(err_func, x0=(0, 0, 0 ),
niter=1, T=1.0, stepsize=10,
minimizer_kwargs={'args': ((preX_redu, preY_redu, postX_redu, postY_redu))},
take_step=None, accept_test=None, callback=None, interval=50, disp=True,
niter_success=1)
# print(minF)
# #Case of 180deg rotation:
# deg = 180
# rad = -deg / 180. * np.pi
# transformed = transform(postX_redu, postY_redu, 0, 0, rad)
#
# minF_rot = basinhopping(err_func, x0=((np.mean(postX) - np.mean(transformed[:, 0])), (np.mean(postY) - np.mean(transformed[:, 1])), rad),
# niter=1, T=1.0, stepsize=10,
# minimizer_kwargs={'args': ((preX_redu, preY_redu, postX_redu, postY_redu))},
# take_step=None, accept_test=None, callback=None, interval=50, disp=True,
# niter_success=1)
# print(minF_rot)
# if minF.fun < minF_rot.fun:
transX = minF.x[0]
transY = minF.x[1]
rot = minF.x[2]
# scale = minF.x[3]
# print('rot = 0 deg')
# else:
# transX = minF_rot.x[0]
# transY = minF_rot.x[1]
# rot = minF_rot.x[2]
# # scale = minF.x[3]
# print('rot = 180 deg')
if dst == MF + 'Analysis/Fiducials/timelapseXYpenmarks.npy':
np.save(MF + 'Analysis//Fiducials/optimized_params_timelapse.npy', [transX, transY, rot])
else:
np.save(MF + 'Analysis//Fiducials/optimized_params.npy', [transX, transY, rot])
transformed = transform(postX, postY, transX, transY, rot)
plt.figure()
plt.scatter(transformed[:, 0], transformed[:, 1],1)
plt.scatter(preX, preY, 1, 'r')
plt.axis('equal')
plt.savefig(MF + 'Analysis//Fiducials/surfRegResults.png', dpi = 500)
plt.close('all')
def TransformMarks(MF, dst=''):
"""Transform the ablation mark coordinates from the post-MALDI dataset using the geometric transform parameters
defined in SURF_Alignment() function to estimate their position in the pre-MALDI dataset.
Args:
MFA (str): path to Main Folder Analysis.
"""
MFA = MF+'Analysis/'
xe_clean2, ye_clean2 = np.load(MFA + '/gridFit/xye_clean2.npy', allow_pickle=True)
x_spots, y_spots = np.load(MFA + '/gridFit/xye_grid.npy', allow_pickle=True)
if dst == 'timelapse':
transX, transY, rot = np.load(MFA + '/Fiducials/optimized_params_timelapse.npy', allow_pickle=True)
else:
transX, transY, rot = np.load(MFA + '/Fiducials/optimized_params.npy', allow_pickle=True)
xye_tf = transform(xe_clean2, ye_clean2, transX, transY, rot)
X = xye_tf[:, 0]
Y = xye_tf[:, 1]
np.save(MFA + '/Fiducials/{}transformedMarks.npy'.format(dst), [X, Y])
xyg_tf = transform(x_spots.ravel(), y_spots.ravel(), transX, transY, rot)
Xg = xyg_tf[:, 0]
Yg = xyg_tf[:, 1]
np.save(MFA + '/Fiducials/{}transformedGrid.npy'.format(dst), [Xg, Yg])
if os.path.exists(MFA + 'gridFit/marksMask.npy'):
marksMask = np.load(MFA + 'gridFit/marksMask.npy', allow_pickle=True)
tfMarksMask = []
for i in range(np.shape(marksMask)[0]):
if np.shape(marksMask[i][0].T)[0] > 1:
tfMask = transform(marksMask[i][0].T, marksMask[i][1].T, transX, transY, rot)
tfMarksMask.append([tfMask[:, 0], tfMask[:, 1]])
else:
tfMarksMask.append([[], []])
print('empty')
np.save(MFA + '/Fiducials/{}transformedMarksMask.npy'.format(dst), tfMarksMask)
tfMarksMask = np.array(tfMarksMask)
if dst == 'timelapse':
penmarks = np.load(MFA + 'Fiducials/{}XYpenmarks.npy'.format(dst), allow_pickle=True)
else:
penmarks = np.load(MFA + 'Fiducials/preXYpenmarks.npy', allow_pickle=True)
plt.figure(figsize=[50,25])
plt.scatter(penmarks[0,:], penmarks[1,:], 1, c='k')
plt.axis('equal')
for i in range(np.shape(tfMarksMask)[0]):
if np.shape(tfMarksMask[i][0])[0] > 1:
plt.scatter(tfMarksMask[i][0], tfMarksMask[i][1], 1, 'r')
plt.scatter(X, Y, 1, c='g')
plt.savefig(MFA + '/Fiducials/{}registration_result.png'.format(dst), dpi=100)
plt.close('all')
| 2.28125
| 2
|
cc_modes/mm_tribute.py
|
epthegeek/cactuscanyon
| 10
|
12775087
|
## ____ _ ____
## / ___|__ _ ___| |_ _ _ ___ / ___|__ _ _ __ _ _ ___ _ __
## | | / _` |/ __| __| | | / __| | | / _` | '_ \| | | |/ _ \| '_ \
## | |__| (_| | (__| |_| |_| \__ \ | |__| (_| | | | | |_| | (_) | | | |
## \____\__,_|\___|\__|\__,_|___/ \____\__,_|_| |_|\__, |\___/|_| |_|
## |___/
## ___ ___ _ _ _____ ___ _ _ _ _ ___ ___
## / __/ _ \| \| |_ _|_ _| \| | | | | __| \
## | (_| (_) | .` | | | | || .` | |_| | _|| |) |
## \___\___/|_|\_| |_| |___|_|\_|\___/|___|___/
##
## A P-ROC Project by <NAME>, Copyright 2012-2013
## Built on the PyProcGame Framework from <NAME> and <NAME>
## Original Cactus Canyon software by <NAME>
##
##
## The Medieval Madness Tribute
##
from procgame import dmd,game
import ep
import random
class MM_Tribute(ep.EP_Mode):
"""This is Just a Tribute """
def __init__(self,game,priority):
super(MM_Tribute, self).__init__(game,priority)
self.myID = "MM Tribute"
self.halted = False
self.running = False
self.hitsToWin = 3
self.won = False
self.tauntTimer = 8
script = []
# set up the pause text layer
textString = "< TROLLS PAUSED >"
textLayer = ep.EP_TextLayer(128/2, 24, self.game.assets.font_6px_az_inverse, "center", opaque=False).set_text(textString,color=ep.GREEN)
script.append({'seconds':0.3,'layer':textLayer})
# set up the alternating blank layer
blank = dmd.FrameLayer(opaque=False, frame=self.game.assets.dmd_blank.frames[0])
blank.composite_op = "blacksrc"
script.append({'seconds':0.3,'layer':blank})
# make a script layer with the two
self.pauseView = dmd.ScriptedLayer(128,32,script)
self.pauseView.composite_op = "blacksrc"
self.leftTaunts = [self.game.assets.quote_mmLT1,
self.game.assets.quote_mmLT2,
self.game.assets.quote_mmLT3,
self.game.assets.quote_mmLT4,
self.game.assets.quote_mmLT5,
self.game.assets.quote_mmLT6]
self.rightTaunts = [self.game.assets.quote_mmRT1,
self.game.assets.quote_mmRT2,
self.game.assets.quote_mmRT3,
self.game.assets.quote_mmRT4,
self.game.assets.quote_mmRT5,
self.game.assets.quote_mmRT6]
self.leftSoloTaunts = [self.game.assets.quote_mmLTS1,
self.game.assets.quote_mmLTS2,
self.game.assets.quote_mmLTS3,
self.game.assets.quote_mmLTS4,
self.game.assets.quote_mmLTS5,
self.game.assets.quote_mmLTS6]
self.rightSoloTaunts = [self.game.assets.quote_mmRTS1,
self.game.assets.quote_mmRTS2,
self.game.assets.quote_mmRTS3,
self.game.assets.quote_mmRTS4,
self.game.assets.quote_mmRTS5,
self.game.assets.quote_mmRTS6]
def mode_started(self):
self.tauntChoices = [0,1,2,3,4,5]
self.tauntTimer = 8
# overall mode timer
self.modeTimer = 30
self.timeLayer = ep.EP_TextLayer(64,22,self.game.assets.font_9px_az,"center",opaque=True).set_text(str(self.modeTimer),color=ep.GREEN)
# fire up the switch block if it's not already loaded
self.game.switch_blocker('add',self.myID)
# unload the launcher
self.game.tribute_launcher.unload()
# first hit is 250, but it adds the bump first in the routine
self.value = 175000
self.running = True
self.halted = False
self.won = False
# total left troll hits
self.leftHitsSoFar = 0
# total right troll hits
self.rightHitsSoFar = 0
# score for the mode
self.totalPoints = 0
# set up the text layers
self.titleLine = ep.EP_TextLayer(64,2,self.game.assets.font_5px_AZ,"center",opaque=False)
self.update_titleLine()
self.scoreLayer = ep.EP_TextLayer(64,10,self.game.assets.font_5px_AZ,"center",opaque=False)
self.intro()
def ball_drained(self):
# if we get to zero balls while running, finish
if self.game.trough.num_balls_in_play == 0 and self.running:
self.finish_trolls()
def halt_test(self):
if not self.halted:
self.halt_trolls()
# if the mode is already halted, cancel any pending resume delay
else:
self.cancel_delayed("Resume")
# halt switches
# bonus lanes pause save polly
def sw_leftBonusLane_active(self,sw):
self.halt_test()
def sw_rightBonusLane_active(self,sw):
self.halt_test()
# bumpers pause quickdraw
def sw_leftJetBumper_active(self,sw):
self.halt_test()
def sw_rightJetBumper_active(self,sw):
self.halt_test()
def sw_bottomJetBumper_active(self,sw):
self.halt_test()
# so does the mine and both pass the 'advanced' flag to avoid moo sounds
def sw_minePopper_active_for_350ms(self,sw):
#print "Trolls It Mine Popper Register"
self.halt_test()
def sw_saloonPopper_active_for_250ms(self,sw):
#print "Trolls It Saloon Popper Register"
self.halt_test()
def sw_saloonPopper_inactive(self,sw):
if self.running and self.halted:
self.halted = False
self.delay("Resume",delay=1,handler=self.resume_trolls)
# resume when exit
def sw_jetBumpersExit_active(self,sw):
if self.running and self.halted:
# kill the halt flag
self.halted = False
self.delay("Resume",delay=1,handler=self.resume_trolls)
def intro(self,step=1):
if step == 1:
self.stop_music()
self.delay(delay=0.5,handler=self.game.base.play_quote,param=self.game.assets.quote_mmTrolls)
introWait = self.game.sound.play(self.game.assets.sfx_mmIntro)
self.delay(delay=introWait,handler=self.game.music_on,param=self.game.assets.music_trolls)
border = dmd.FrameLayer(opaque = True, frame=self.game.assets.dmd_singlePixelBorder.frames[0])
titleLine = ep.EP_TextLayer(64,2,self.game.assets.font_9px_az,"center",False).set_text("TROLLS!",color=ep.GREEN)
infoLine1 = ep.EP_TextLayer(64,14,self.game.assets.font_5px_AZ,"center",False).set_text("SHOOT EACH TROLL " + str(self.hitsToWin) + " TIMES")
infoLine2 = ep.EP_TextLayer(64,20,self.game.assets.font_5px_AZ,"center",False).set_text("TO FINISH")
combined = dmd.GroupedLayer(128,32,[border,titleLine,infoLine1,infoLine2])
self.layer = combined
self.delay(delay=2,handler=self.intro,param=2)
if step == 2:
startFrame = dmd.FrameLayer(opaque = True, frame=self.game.assets.dmd_mmTrollsIntro.frames[0])
transition = ep.EP_Transition(self,self.layer,startFrame,ep.EP_Transition.TYPE_PUSH,ep.EP_Transition.PARAM_NORTH)
self.delay(delay=1.5,handler=self.intro,param=3)
if step == 3:
anim = self.game.assets.dmd_mmTrollsIntro
myWait = len(anim.frames) / 10.0
animLayer = ep.EP_AnimatedLayer(anim)
animLayer.hold = True
animLayer.frame_time = 6
animLayer.repeat = False
animLayer.opaque = True
# sounds ?
animLayer.add_frame_listener(1,self.game.sound.play,param=self.game.assets.sfx_lightning1)
animLayer.add_frame_listener(13,self.game.sound.play,param=self.game.assets.sfx_lightning1)
# trolls raising
animLayer.add_frame_listener(10,self.game.bad_guys.target_up,param=1)
animLayer.add_frame_listener(21,self.game.bad_guys.target_up,param=2)
# first taunt
animLayer.add_frame_listener(25,self.taunt)
self.layer = animLayer
self.delay(delay = myWait,handler=self.get_going)
def get_going(self):
self.game.ball_search.enable()
# release the ball
if self.game.tribute_launcher.shot == 3:
self.game.mountain.eject()
else:
self.game.coils.leftGunFightPost.disable()
# start the timer
self.modeTimer += 1
self.time_trolls()
# start the score updater
self.score_update()
# start the display
self.display_trolls(mode="idle",troll="both")
def display_trolls(self,troll="both",mode="idle"):
self.cancel_delayed("Display")
if troll == "left":
self.cancel_delayed("Left Display")
elif troll == "right":
self.cancel_delayed("Right Display")
if mode == "idle":
if troll == "left" or troll == "both":
anim = self.game.assets.dmd_mmTrollIdleLeft
self.leftTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=False,opaque=False,repeat=True,frame_time=6)
myWait = 0
if troll == "right" or troll == "both":
anim = self.game.assets.dmd_mmTrollIdleRight
self.rightTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=False,opaque=False,repeat=True,frame_time=6)
myWait = 0
elif mode == "hit":
if troll == "left":
anim = self.game.assets.dmd_mmTrollHitLeft
myWait = len(anim.frames) / 10.0
self.leftTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=6)
if troll == "right":
anim = self.game.assets.dmd_mmTrollHitRight
myWait = len(anim.frames) / 10.0
self.rightTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=6)
elif mode == "dead":
if troll == "left":
anim = self.game.assets.dmd_mmTrollDeadLeft
myWait = len(anim.frames) / 10.0
self.leftTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=6)
if troll == "right":
anim = self.game.assets.dmd_mmTrollDeadRight
myWait = len(anim.frames) / 10.0
self.rightTrollLayer = dmd.AnimatedLayer(frames=anim.frames,hold=True,opaque=False,repeat=False,frame_time=6)
else:
# if we didn't get a cue to change trolls, don't mess with them
myWait = 0
# build the layer
self.leftTrollLayer.composite_op = "blacksrc"
self.rightTrollLayer.composite_op = "blacksrc"
combined = dmd.GroupedLayer(128,32,[self.timeLayer,self.titleLine,self.scoreLayer,self.leftTrollLayer,self.rightTrollLayer])
self.layer = combined
# set the delay for fixing it after a hit or a miss
if mode == "hit":
#print "It's a hit - setting loop back to idle"
# if a troll got hit loop back to that one to set it to idle after the animation finishes
if troll == "left":
self.delay("Left Display",delay=myWait,handler=self.reset_troll,param="left")
if troll == "right":
self.delay("Right Display",delay=myWait,handler=self.reset_troll,param="right")
if mode == "dead":
if self.won:
# if both trolls are dead, go to the finish
self.delay(delay=myWait,handler=self.finish_trolls)
def reset_troll(self,side):
# set the display back
self.display_trolls(side)
# put the target back up
if side == "left":
target = 1
else:
target = 2
#print "Resetting Troll on target " + str(target)
self.game.bad_guys.target_up(target)
def hit_troll(self,target):
# score the points
self.game.score(self.value)
# add to the total
self.totalPoints += self.value
# play the smack sound
self.game.sound.play(self.game.assets.sfx_mmTrollSmack)
# delay the taunt timer
if self.tauntTimer <= 2:
self.tauntTimer += 3
if target == 1:
# register the hit
self.leftHitsSoFar += 1
if self.leftHitsSoFar >= self.hitsToWin:
# troll is dead
if self.rightHitsSoFar >= self.hitsToWin:
# both dead? Winner!
self.win()
# then display the troll dying
self.display_trolls(mode="dead",troll="left")
# play the death sound
self.game.sound.play(self.game.assets.quote_mmLeftDeath)
# if the other troll isn't dead yet, he comments
if not self.won:
self.delay(delay=0.5,handler=self.game.base.play_quote,param=self.game.assets.quote_mmRightAlone)
# if troll is not dead, just hit it
else:
self.display_trolls(mode="hit",troll="left")
# and play the pain sound
self.game.sound.play(self.game.assets.quote_mmLeftPain)
# other target is 2
else:
self.rightHitsSoFar += 1
if self.rightHitsSoFar >= self.hitsToWin:
# troll is dead
if self.leftHitsSoFar >= self.hitsToWin:
# both dead? Winner!
self.win()
# then display the troll dying
self.display_trolls(mode="dead",troll="right")
# play the death sound
self.game.sound.play(self.game.assets.quote_mmRightDeath)
# if the other troll isn't dead yet, he comments
if not self.won:
self.delay(delay=0.5,handler=self.game.base.play_quote,param=self.game.assets.quote_mmLeftAlone)
else:
self.display_trolls(mode="hit",troll="right")
# and play the pain sound
self.game.sound.play(self.game.assets.quote_mmRightPain)
# update the title line
self.update_titleLine()
def win(self):
self.won = True
self.cancel_delayed("Mode Timer")
self.cancel_delayed("Taunt Timer")
def score_update(self):
# update the score line total every half second
p = self.game.current_player()
scoreString = ep.format_score(p.score)
self.scoreLayer.set_text(scoreString,color=ep.GREEN)
self.delay("Score Update",delay=0.5,handler=self.score_update)
def update_titleLine(self):
left = self.hitsToWin - self.leftHitsSoFar
right = self.hitsToWin - self.rightHitsSoFar
self.titleLine.set_text(str(left) + " - TROLLS! - " + str(right),color=ep.BROWN)
def time_trolls(self):
self.modeTimer -= 1
# if we get to zero, end the mode
if self.modeTimer < 0:
self.finish_trolls()
# otherwise update the timer layers and loop back
else:
if self.modeTimer > 9:
color = ep.GREEN
elif self.modeTimer > 4:
color = ep.YELLOW
else:
color = ep.RED
self.timeLayer.set_text(str(self.modeTimer),color=color)
self.delay("Mode Timer",delay=1,handler=self.time_trolls)
def halt_trolls(self):
if self.modeTimer <= 0:
return
#print "HALTING TROLLS IN BUMPERS/MINE"
self.cancel_delayed("Resume")
# cancel delays
self.cancel_delayed("Mode Timer")
# do the halted delay
self.layer = self.pauseView
# set the flag
self.halted = True
def resume_trolls(self):
# turn the timer back on
self.time_trolls()
# turn the display back on
if self.leftHitsSoFar == self.hitsToWin:
self.display_trolls(mode="idle",troll="right")
elif self.rightHitsSoFar == self.hitsToWin:
self.display_trolls(mode="idle",troll="left")
else:
self.display_trolls(mode="idle",troll="both")
def taunt(self):
# cancel any existing timer and taunt calls
self.cancel_delayed("Taunt Timer")
self.cancel_delayed("Taunt Call")
# pick a taunt
index = random.choice(self.tauntChoices)
# remove that from the list
self.tauntChoices.remove(index)
# make sure it's not now empty
if len(self.tauntChoices) == 0:
self.tauntChoices = [0,1,2,3,4,5]
# if they're both alive - double taunt
if self.leftHitsSoFar < self.hitsToWin and self.rightHitsSoFar < self.hitsToWin:
# play the left taunt
myWait = self.game.base.priority_quote(self.leftTaunts[index])
# then delay the second
self.delay("Taunt Call",delay=myWait+0.5,handler=self.game.base.play_quote,param=self.rightTaunts[index])
# if one of them is already dead - play a single taunt
else:
if self.leftHitsSoFar < self.hitsToWin:
# play a left taunt
self.game.base.play_quote(self.leftSoloTaunts[index])
else:
self.game.base.play_quote(self.rightSoloTaunts[index])
# set the timer for the next one
self.tauntTimer = 8
# then start the timer
self.taunt_timer()
def taunt_timer(self):
# loop for calling the troll taunting
self.tauntTimer -= 1
if self.tauntTimer <= 0:
self.taunt()
else:
self.delay("Taunt Timer", delay = 1, handler=self.taunt_timer)
def finish_trolls(self):
# kill the delays
self.wipe_delays()
# drop the targets
self.game.bad_guys.drop_targets()
border = dmd.FrameLayer(opaque=True, frame=self.game.assets.dmd_mmTrollFinalFrame.frames[0])
textLayer1 = ep.EP_TextLayer(64,8,self.game.assets.font_5px_AZ,"center",opaque=False)
if self.won:
textLayer1.set_text("TROLLS DESTROYED",color=ep.DARK_GREEN)
# add some extra points if won - to make it a cool 1.5 million
self.game.score(450000)
self.totalPoints += 450000
else:
textLayer1.set_text("TROLLS ESCAPED",color=ep.DARK_GREEN)
textLayer2 = ep.EP_TextLayer(64,14,self.game.assets.font_9px_az,"center",opaque=False).set_text(str(ep.format_score(self.totalPoints)),color=ep.GREEN)
combined = dmd.GroupedLayer(128,32,[border,textLayer1,textLayer2])
self.layer = combined
# play a final quote ?
if self.won:
self.delay(delay=1,handler=self.game.base.priority_quote,param=self.game.assets.quote_mmFatality)
elif self.leftHitsSoFar == 0 and self.rightHitsSoFar == 0:
self.game.base.priority_quote(self.game.assets.quote_mmYouSuck)
else:
self.game.sound.play(self.game.assets.sfx_cheers)
myWait = 2
self.delay(delay=myWait,handler=self.done)
def done(self):
self.running = False
# turn the level 5 stack flag back off
self.game.stack_level(5,False)
# set the music back to the main loop
self.music_on(self.game.assets.music_mainTheme,mySlice=5)
# remove the switch blocker
self.game.switch_blocker('remove',self.myID)
# then unload
self.unload()
| 2.421875
| 2
|
AlgorithmTest/PROGRAMMERS_PYTHON/Lv1/Prog_64061.py
|
bluesky0960/AlgorithmTest
| 0
|
12775088
|
<reponame>bluesky0960/AlgorithmTest
#https://programmers.co.kr/learn/courses/30/lessons/64061
# 크레인 인형뽑기
def solution(board, moves):
answer = 0
size = len(board[0])
a = []
for m in moves:
for i in range(size):
if board[i][m-1] != 0:
a.append(board[i][m-1])
board[i][m-1] = 0
break
if len(a) == 1 or len(a) == 0:
continue
else:
if a[-1] == a[-2]:
a.pop()
a.pop()
answer+=2
print(a)
return answer
| 3.421875
| 3
|
Sea/adapter/materials/ViewProviderMaterial.py
|
FRidh/Sea
| 2
|
12775089
|
<reponame>FRidh/Sea<filename>Sea/adapter/materials/ViewProviderMaterial.py<gh_stars>1-10
from ..base import ViewProviderBase
class ViewProviderMaterial(ViewProviderBase):
pass
| 1.203125
| 1
|
tests/Serial/test_multi-planet_serial.py
|
VirtualPlanetaryLaboratory/multiplanet
| 0
|
12775090
|
import subprocess
import numpy as np
import os
import pathlib
import multiprocessing as mp
import sys
def test_mp_serial():
#gets current path
path = pathlib.Path(__file__).parents[0].absolute()
sys.path.insert(1, str(path.parents[0]))
if not (path / "MP_Serial").exists():
subprocess.check_output(["vspace", "vspace.in"], cwd=path)
# Run multi-planet
if not (path / ".MP_Serial").exists():
subprocess.check_output(["multiplanet", "vspace.in", "-c", "1"], cwd=path)
folders = sorted([f.path for f in os.scandir(path / "MP_Serial") if f.is_dir()])
for i in range(len(folders)):
os.chdir(folders[i])
assert os.path.isfile('earth.earth.forward') == True
os.chdir('../')
if __name__ == "__main__":
test_mp_serial()
| 2.40625
| 2
|
nagare/services/create_root.py
|
nagareproject/core
| 40
|
12775091
|
<filename>nagare/services/create_root.py
# --
# Copyright (c) 2008-2021 Net-ng.
# All rights reserved.
#
# This software is licensed under the BSD License, as described in
# the file LICENSE.txt, which you should have received as part of
# this distribution.
# --
from nagare.services import plugin
class RootService(plugin.Plugin):
LOAD_PRIORITY = 109
def create_root(self, app, **params):
root = app.create_root()
# Initialize the objects graph from the URL
args = app.create_dispatch_args(root=root, **params)
app.route(args)
return root
def handle_request(self, chain, session, **params):
if session:
root = session['nagare.root']
else:
root = session['nagare.root'] = self.create_root(**params)
return chain.next(session=session, root=root, **params)
| 2.25
| 2
|
install.py
|
nikolhm/Pokus
| 1
|
12775092
|
import platform
import os
import sys
def install(package):
print("""Colorama er ikke installert. Du trenger Colorama for å spille Pokus med farger.
For å spille må du installere Colorama og starte spillet på nytt.""")
if input("Vil du installere colorama nå?\n> ").lower() in {"ja", "j"}:
osys = platform.system()
if osys == "Linux" or osys == "Darwin":
os.system("pip3 install --user colorama")
os.system("clear")
else:
os.system("pip install --user colorama")
os.system("cls")
sys.exit("Du må starte spillet på nytt nå.")
| 2.984375
| 3
|
ganimides_server/ganimides_database/xxx.py
|
leandrou-technology-forward/api_server
| 0
|
12775093
|
def dbapi_subscription(dbsession, action, input_dict, action_filter={}, caller_area={}):
_api_name = "dbapi_subscription"
_api_entity = 'SUBSCRIPTION'
_api_action = action
_api_msgID = set_msgID(_api_name, _api_action, _api_entity)
_process_identity_kwargs = {'type': 'api', 'module': module_id, 'name': _api_name, 'action': _api_action, 'entity': _api_entity, 'msgID': _api_msgID,}
_process_adapters_kwargs = {'dbsession': dbsession}
_process_log_kwargs = {'indent_method': 'AUTO', 'indent_level':None}
_process_debug_level = get_debug_level(caller_area.get('debug_level'), **_process_identity_kwargs, **_process_adapters_kwargs)
_process_debug_files = get_debug_files(_process_debug_level, **_process_identity_kwargs, **_process_adapters_kwargs)
_process_debug_kwargs={'debug_level':_process_debug_level,'debug_files':_process_debug_files}
_process_signature = build_process_signature(**_process_identity_kwargs, **_process_adapters_kwargs, **_process_debug_kwargs, **_process_log_kwargs)
_process_call_area = build_process_call_area(_process_signature, caller_area)
log_process_start(_api_msgID,**_process_call_area)
log_process_input('', 'input_dict', input_dict,**_process_call_area)
log_process_input('', 'action_filter', action_filter,**_process_call_area)
log_process_input('', 'caller_area', caller_area,**_process_call_area)
input_dict.update({'client_type': 'subscriber'})
if action.upper() in ('REGISTER','ADD','REFRESH'):
action='REFRESH'
action_result = dbsession.table_action(dbmodel.CLIENT, action, input_dict, action_filter, auto_commit=True, caller_area=_process_call_area)
api_result = action_result
thismsg=action_result.get('api_message')
api_result.update({'api_action': _api_action, 'api_name': _api_name})
if not api_result.get('api_status') == 'success':
# msg = f"subscription not registered"
# api_result.update({'api_message':msg})
log_process_finish(_api_msgID, api_result, **_process_call_area)
return api_result
client = api_result.get('api_data')
client_id = client.get('client_id')
input_dict.update({'client_id': client_id})
elif action.upper() in ('CONFIRM', 'ACTIVATE', 'DEACTIVATE', 'DELETE'):
subscription_dict = dbsession.get(dbmodel.SUBSCRIPTION, input_dict, 'DICT', caller_area=_process_call_area)
if not subscription_dict:
msg = f'subscription not found'
action_status='error'
api_result = {'api_status': action_status, 'api_message': msg, 'api_data': input_dict, 'api_action': _api_action.upper(), 'api_name': _api_name}
log_process_finish(_api_msgID, api_result, **_process_call_area)
return api_result
client_dict=dbsession.get(dbmodel.CLIENT, subscription_dict,'DICT', caller_area=_process_call_area)
if not client_dict:
msg = f'client not found'
action_status='error'
api_result = {'api_status': action_status, 'api_message': msg, 'api_data': subscription_dict, 'api_action': _api_action.upper(), 'api_name': _api_name}
log_process_finish(_api_msgID, api_result, **_process_call_area)
return api_result
#action='CONFIRM'
action_result = dbsession.table_action(dbmodel.CLIENT, action, input_dict, action_filter, auto_commit=True, caller_area=_process_call_area)
api_result = action_result
api_result.update({'api_action': _api_action, 'api_name': _api_name})
thismsg=action_result.get('api_message')
if not api_result.get('api_status') == 'success':
# msg = f'client confirmation failed'
# api_result.update({'api_message':msg})
log_process_finish(_api_msgID, api_result, **_process_call_area)
return api_result
subscription_dict = dbsession.get(dbmodel.SUBSCRIPTION, subscription_dict, 'DICT', caller_area=_process_call_area)
status=subscription_dict.get('status')
client_id=subscription_dict.get('client_id')
# if not subscription_dict.get('status') == 'Active':
# msg = f"service provider not confirmed. status={status}"
# action_status='error'
# api_result = {'api_status': action_status, 'api_message': msg, 'api_data': subscription_dict, 'messages': messages, 'rows_added': rows_added, 'rows_updated': rows_updated, 'api_action': _api_action.upper(), 'api_name': _api_name}
# log_process_finish(_api_msgID, api_result, **_process_call_area)
# return api_result
input_dict.update({'status': status})
input_dict.update({'client_id': client_id})
action_result = dbsession.table_action(dbmodel.SUBSCRIPTION, action, input_dict, action_filter, auto_commit=True, caller_area=_process_call_area)
api_result = action_result
thismsg=thismsg.replace('CLIENT',_api_entity)
api_result.update({'api_action': _api_action, 'api_name': _api_name,'api_message':thismsg})
log_process_finish(_api_msgID, api_result, **_process_call_area)
return api_result
| 1.859375
| 2
|
Code/Base_Models_and_MLR.py
|
IshanKuchroo/SuperStore_Sales_Forecast
| 0
|
12775094
|
from scipy import stats
from PreProcessing import *
#################################################################
# ------------------ Base Methods ------------------ #
################################################################
col = 'Sales'
method = ['Average', 'Naive', 'Drift', 'SES']
def base_methods(train, test):
for i in range(len(method)):
if method[i] == 'Average':
h_step_forecast, residual_err, forecast_err = avg_forecast_method(train, test)
elif method[i] == 'Naive':
h_step_forecast, residual_err, forecast_err = naive_forecast_method(train, test)
elif method[i] == 'Drift':
h_step_forecast, residual_err, forecast_err = drift_forecast_method(train, test)
else:
h_step_forecast, residual_err, forecast_err = ses_forecast_method(train, test, train[0], 0.5)
squared_train_err = [number ** 2 for number in residual_err]
squared_test_err = [number ** 2 for number in forecast_err]
lst = ["{0:.2f}".format(np.sum(squared_test_err) / len(squared_test_err))
, "{0:.2f}".format(np.sum(squared_train_err) / len(squared_train_err))
, "{0:.2f}".format(np.var(residual_err))
, "{0:.2f}".format(np.var(forecast_err))
, "{0:.2f}".format(q_value(residual_err, 15))
, "{0:.2f}".format(np.var(residual_err) / np.var(forecast_err))
]
# final_df = pd.DataFrame()
if i == 0:
final_df = pd.DataFrame(lst, columns=['Average'],
index=['MSE_Fcast', 'MSE_Residual', 'Var_Pred', 'Var_Fcast', 'QValue_Residual'
, 'Variance_Ratio'])
else:
final_df[method[i]] = lst
y_axis, x_axis = auto_corr_func_lags(forecast_err, 20)
span = 1.96 / np.sqrt(len(forecast_err))
plt.axhspan(-1 * span, span, alpha=0.2, color='blue')
plt.stem(x_axis, y_axis)
plt.legend()
plt.xlabel("Lags")
plt.ylabel("ACF")
plt.title(f"{method[i]} Forecast ACF Plot")
plt.grid()
plt.show()
plt.figure()
plt.plot(train, label='Training dataset')
plt.plot([None for i in train] + [x for x in test], label='Testing dataset')
plt.plot([None for i in train] + [x for x in h_step_forecast], label=f'{method[i]} method h-step prediction')
plt.legend()
plt.xlabel('Sample set')
plt.ylabel('Sales')
plt.title(f"{method[i]} Method Forecasting")
plt.grid()
plt.show()
return final_df
final_df = base_methods(X_train[col], X_test[col])
#################################################################
# ------------------ Holt-Winters Method ------------------ #
################################################################
holtt = ets.ExponentialSmoothing(X_train[col], trend='add', damped_trend=False, seasonal='add',
seasonal_periods=7).fit()
# holtt = ets.ExponentialSmoothing(X_train['Sales'], trend='add', damped_trend=False, seasonal=None).fit(optimized=True)
# holtt = ets.Holt(X_train['Sales'], damped_trend=False).fit(optimized=True)
holtf = holtt.forecast(steps=len(X_test[col]))
pred_train_holtf = holtt.predict(start=0, end=(len(X_train[col]) - 1))
holtf = pd.DataFrame(holtf, columns=['Forecast']).set_index(X_test.index)
pred_train_holtf = pd.DataFrame(pred_train_holtf, columns=['Residual']).set_index(X_train.index)
forecast_err_hw = []
residual_err_hw = []
for i in range(np.min(X_test.index), np.max(X_test.index)):
forecast_err_hw.append(X_test[col][i] - holtf['Forecast'][i])
for j in range(len(X_train)):
residual_err_hw.append(X_train[col][j] - pred_train_holtf['Residual'][j])
squared_train_err = [number ** 2 for number in residual_err_hw]
squared_test_err = [number ** 2 for number in forecast_err_hw]
lst = ["{0:.2f}".format(np.sum(squared_test_err) / len(squared_test_err))
, "{0:.2f}".format(np.sum(squared_train_err) / len(squared_train_err))
, "{0:.2f}".format(np.var(residual_err_hw))
, "{0:.2f}".format(np.var(forecast_err_hw))
, "{0:.2f}".format(q_value(residual_err_hw, 15))
, "{0:.2f}".format(np.var(residual_err_hw) / np.var(forecast_err_hw))]
final_df['Holt-Winter'] = lst
y_axis, x_axis = auto_corr_func_lags(forecast_err_hw, 20)
span = 1.96 / np.sqrt(len(forecast_err_hw))
plt.axhspan(-1 * span, span, alpha=0.2, color='blue')
plt.stem(x_axis, y_axis)
plt.legend()
plt.xlabel("Lags")
plt.ylabel("ACF")
plt.title("Holt-Winter Forecast ACF Plot")
plt.grid()
plt.show()
plt.figure()
plt.plot(X_train['Order Date'], X_train[col], label='Training dataset')
plt.plot(X_test['Order Date'], X_test[col], label='Testing dataset')
plt.plot(X_test['Order Date'], holtf, label='Holt-Winter h-step prediction')
plt.legend()
plt.xlabel('Date')
plt.ylabel('Sales')
plt.title("Holt-Winter Method Forecasting")
# plt.xticks(X_train['Month'][::20])
plt.grid()
plt.show()
#######################################################################
# ------------------ Multiple Linear Regression ------------------ #
######################################################################
# Label encoding on categorical variables
def mapping(xx):
dict = {}
count = -1
for x in xx:
dict[x] = count + 1
count = count + 1
return dict
for i in ['City', 'State', 'Sub-Category', 'Ship Mode', 'Region', 'Segment', 'Category']:
unique_tag = df_2[i].value_counts().keys().values
dict_mapping = mapping(unique_tag)
df_2[i] = df_2[i].map(lambda x: dict_mapping[x] if x in dict_mapping.keys() else -1)
df_2['norm_Sales'] = np.log(df_2['Sales'])
X = df_2[['Quantity', 'Discount', 'Profit']]
Y = df_2[['norm_Sales']]
#######################################################################
# ------------------ SVD and Condition Number ------------------ #
######################################################################
s, d, v = np.linalg.svd(X, full_matrices=True)
print(f"Singular value of dataframe are {d}")
print(f"Condition number for dataframe is {LA.cond(X)}")
# X = sm.add_constant(X)
X_train, X_test, y_train, y_test = train_test_split(X, Y, shuffle=False, test_size=0.20)
model = sm.OLS(y_train, X_train).fit()
print(model.summary())
#######################################################################
# ------------------ Multiple Linear Regression ------------------ #
######################################################################
#########################################################################################
# ------------------ Feature selection - Backward stepwise regression ------------------ #
########################################################################################
X_train.drop(['Discount'], axis=1, inplace=True)
model = sm.OLS(y_train, X_train).fit()
print(model.summary())
# X_train.drop(['Quantity'], axis=1, inplace=True)
# model = sm.OLS(y_train, X_train).fit()
# print(model.summary())
print("t-test p-values for all features: \n", model.pvalues)
print("#" * 100)
print("F-test for final model: \n", model.f_pvalue)
# stats.probplot(model.resid, dist="norm", plot= plt)
# plt.title("OLS Model Residuals Q-Q Plot")
col = ['Discount']
for i in col:
X_test.drop(i, axis=1, inplace=True)
prediction = model.predict(X_train)
prediction = pd.DataFrame(prediction, columns=['Residual']).set_index(X_train.index)
forecast = model.predict(X_test)
forecast = pd.DataFrame(forecast, columns=['forecast']).set_index(X_test.index)
plt.figure()
plt.plot(y_train, label='Training Data')
plt.plot(y_test, label="Testing Data")
plt.plot(forecast['forecast'], label="MLR h-step Prediction")
plt.xlabel("Sample Space")
plt.ylabel("Sales")
plt.legend()
plt.title("Sales Dataset Predictions - Multiple Linear Regression")
plt.grid()
plt.tight_layout()
plt.show()
pred_error = np.subtract(y_train, np.asarray(prediction))
pred_error = pred_error.reset_index()
pred_error.drop('index', axis=1, inplace=True)
y_axis, x_axis = auto_corr_func_lags(pred_error['norm_Sales'], 20)
span = 1.96 / np.sqrt(len(pred_error['norm_Sales']))
plt.axhspan(-1 * span, span, alpha=0.2, color='blue')
plt.stem(x_axis, y_axis)
plt.xlabel("Lags")
plt.ylabel("ACF")
plt.title("Residual Error ACF Plot - Multiple Linear Regression")
plt.grid()
plt.show()
forecast_error = np.subtract(y_test, np.asarray(forecast))
forecast_error = forecast_error.reset_index()
forecast_error.drop('index', axis=1, inplace=True)
Q = sm.stats.acorr_ljungbox(pred_error['norm_Sales'], lags=[20], boxpierce=True, return_df=True)['bp_stat'].values[0]
lst = [np.round(np.sum(np.square(forecast_error['norm_Sales'])) / len(forecast_error), 2)
, np.round(np.sum(np.square(pred_error['norm_Sales'])) / len(pred_error), 2)
, np.round(np.var(pred_error['norm_Sales']), 2)
, np.round(np.var(forecast_error['norm_Sales']), 2)
, np.round(Q, 2)
, np.round(np.var(pred_error['norm_Sales']) / np.var(forecast_error['norm_Sales']), 2)]
final_df['OLS_Model'] = lst
print(final_df.to_string())
#
# K = len(X_train.columns) # number of columns for prediction
#
# T = len(y_train)
#
# var_pred = np.sqrt(np.sum(np.square(pred_error)) / (T - K - 1))
#
# print("Variance of residual error: ", var_pred[0])
#
# # Variance of forecast error
#
# T = len(y_test)
#
# var_fore = np.sqrt(np.sum(np.square(forecast_error)) / (T - K - 1))
#
# print("Variance of forecast error: ", var_fore[0])
| 2.734375
| 3
|
train/blocks.py
|
shi510/ffem-anti-spoofing
| 0
|
12775095
|
import tensorflow as tf
def attach_GNAP(x : tf.Tensor):
out = x
norm = tf.norm(out, ord=2, axis=3, keepdims=True)
norm = tf.math.maximum(norm, 1e-12)
mean = tf.math.reduce_mean(norm)
out = tf.keras.layers.BatchNormalization(scale=False)(out)
out = tf.math.divide(out, norm)
out = tf.multiply(out, mean)
out = tf.keras.layers.GlobalAveragePooling2D()(out)
out = tf.keras.layers.BatchNormalization(scale=False)(out)
return out
def attach_l2_norm_features(x : tf.Tensor, scale=30):
x = tf.math.l2_normalize(x, axis=1)
x = tf.multiply(x, scale)
return x
def attach_embedding_projection(x : tf.Tensor, embedding_dim : int):
out = x
out = tf.keras.layers.Dense(embedding_dim,
use_bias=False,
kernel_regularizer=tf.keras.regularizers.l2(5e-4))(out)
out = tf.keras.layers.BatchNormalization(name='embeddings')(out)
return out
| 2.484375
| 2
|
app.py
|
marcelgiglio/multiplicative-persistence
| 0
|
12775096
|
def recursiveCalc(n, counter=0, steps=''):
if n<10:
steps += 'Total Steps: ' + str(counter) + '.'
return steps, counter
counter+=1
result = calc(n)
steps += str(result)+', '
return recursiveCalc(result, counter, steps)
def calc(n):
result = 1
while (n>0):
mod = n % 10
result *= mod
n -= mod
n /= 10
return result
def printNumber(n, steps):
print (str(n) + ': ' + steps)
max = -1
bestNumbers = []
for i in range(1000000):
result = recursiveCalc(i)
if(result[1] > max):
max = result[1]
printNumber(i, result[0])
bestNumbers.append(i)
print (bestNumbers)
| 3.703125
| 4
|
deploy/virenv/lib/python2.7/site-packages/haystack/mappings/rek.py
|
wangvictor2012/liuwei
| 0
|
12775097
|
# -*- coding: utf-8 -*-
"""
rekall backed memory_handler.
- rekallProcessMapping: a wrapper around rekall addresspace
- rekallProcessMapper: the memory_handler builder.
"""
import os
import sys
import logging
import struct
from functools import partial
from haystack.mappings import base
from haystack.abc import interfaces
from haystack import target
log = logging.getLogger('rekall')
class RekallProcessMappingA(base.AMemoryMapping):
"""Process memory mapping using rekall.
"""
def __init__(self, address_space, start, end, permissions='r--',
offset=0, major_device=0, minor_device=0, inode=0, pathname=''):
base.AMemoryMapping.__init__(
self,
start,
end,
permissions,
offset,
major_device,
minor_device,
inode,
pathname)
self._backend = address_space
def read_word(self, addr):
ws = self._target_platform.get_word_size()
data = self._backend.read(addr, ws)
if ws == 4:
return struct.unpack('I', data)[0]
elif ws == 8:
return struct.unpack('Q', data)[0]
def read_bytes(self, addr, size):
return self._backend.read(addr, size)
def read_struct(self, addr, struct):
size = self._target_platform.get_target_ctypes().sizeof(struct)
instance = struct.from_buffer_copy(self._backend.read(addr, size))
instance._orig_address_ = addr
return instance
def read_array(self, addr, basetype, count):
size = self._target_platform.get_target_ctypes().sizeof(basetype * count)
array = (basetype *count).from_buffer_copy(self._backend.read(addr, size))
return array
def reset(self):
pass
class RekallProcessMapper(interfaces.IMemoryLoader):
def __init__(self, imgname, pid):
log.debug("RekallProcessMapper %s %p",imgname, pid)
self.pid = pid
self.imgname = imgname
self._memory_handler = None
self._init_rekall()
def _init_rekall(self):
from rekall import session
from rekall import plugins
s = session.Session(
filename = self.imgname,
autodetect=["rsds"],
logger=logging.getLogger(),
profile_path=[
"http://profiles.rekall-forensic.com"
])
self.session = s
task_plugin = s.plugins.pslist(pid=self.pid)
maps = []
# print type(task)
for task in task_plugin.filter_processes():
# we need the file address space reader
address_space = task.get_process_address_space()
# then we look at vad
for vad in task.VadRoot.traverse():
# print type(vad)
if vad is None:
continue
offset = vad.obj_offset
start = vad.Start
end = vad.End
tag = vad.Tag
flags = str(vad.u.VadFlags)
perms = PERMS_PROTECTION[vad.u.VadFlags.Protection.v() & 7]
pathname = ''
if vad.u.VadFlags.PrivateMemory == 1 or not vad.ControlArea:
pathname = ''
else:
try:
file_obj = vad.ControlArea.FilePointer
if file_obj:
pathname = file_obj.FileName or "Pagefile-backed section"
except AttributeError:
pass
pmap = RekallProcessMappingA(
address_space,
start,
end,
permissions=perms,
pathname=pathname)
maps.append(pmap)
# get the platform
meta = s.profile._metadata
if meta['os'] == "windows":
os = ''
if meta['major'] == 5.0:
os = 'winxp'
elif meta['major'] == 7.0:
os = 'win7'
#
if meta['arch'] == u'I386':
self._target = target.TargetPlatform.make_target_win_32(os)
else:
self._target = target.TargetPlatform.make_target_win_64(os)
else:
if meta['arch'] == u'I386':
self._target = target.TargetPlatform.make_target_linux_32()
else:
self._target = target.TargetPlatform.make_target_linux_64()
memory_handler = base.MemoryHandler(maps, self._target, self.imgname)
self._memory_handler = memory_handler
def make_memory_handler(self):
return self._memory_handler
PERMS_PROTECTION = dict(enumerate([
'---', # 'PAGE_NOACCESS',
'r--', # 'PAGE_READONLY',
'--x', # 'PAGE_EXECUTE',
'r-x', # 'PAGE_EXECUTE_READ',
'rw-', # 'PAGE_READWRITE',
'rc-', # 'PAGE_WRITECOPY',
'rwx', # 'PAGE_EXECUTE_READWRITE',
'rcx', # 'PAGE_EXECUTE_WRITECOPY',
]))
# RekallProcessMapper('/home/other/outputs/vol/zeus.vmem', 856)
# RekallProcessMapper('~/outputs/vol/victoria-v8.kcore.img', 1)
def rekall_dump_to_haystack(filename, pid, output_folder_name):
# rek.py -f vol/zeus.vmem vaddump -p 856 --dump-dir vol/zeus.vmem.856.dump/ > vol/zeus.vmem.856.dump/mappings.vol
# rek2map.py vol/zeus.vmem.856.dump/mappings.vol > vol/zeus.vmem.856.dump/mappings
# vaddummp
log.debug("rekall_dump_to_haystack %s %p", filename, pid)
if not os.access(output_folder_name, os.F_OK):
os.mkdir(output_folder_name)
from rekall import session
from rekall import plugins
from rekall.ui import json_renderer
s = session.Session(
filename = filename,
autodetect=["rsds"],
logger=logging.getLogger(),
profile_path=[
"http://profiles.rekall-forensic.com"
])
task_plugin = s.plugins.vaddump(pid=pid, dump_dir=output_folder_name)
# get a renderer.
renderer = json_renderer.JsonRenderer()
task_plugin.render(renderer)
print renderer
maps = []
# FIXME get stdout in here.
with open(filename,'r') as fin:
entries = fin.readlines()
i_start = entries[0].index('Start')
i_end = entries[0].index('End')
i_path = entries[0].index('Result')
fmt = b'0x%08x'
if i_end - i_start > 12:
fmt = b'0x%016x'
for i, line in enumerate(entries[2:]):
start = int(line[i_start:i_end].strip(), 16)
end = int(line[i_end:i_path].strip(), 16) + 1
path = line[i_path:].strip()
o_path = "%s-%s" % (fmt % start, fmt % end)
# rename file
try:
os.rename(path, o_path)
except OSError, e:
sys.stderr.write('File rename error\n')
# offset is unknown.
print '%s %s r-xp %s 00:00 %d [vol_mapping_%03d]' % (fmt % start, fmt % end, fmt % 0, 0, i)
pass
| 2.28125
| 2
|
accountifie/common/apiv1/__init__.py
|
imcallister/accountifie
| 4
|
12775098
|
<gh_stars>1-10
from .server_info import *
| 1.28125
| 1
|
tests/test_lorwrapper.py
|
Victoraq/Riot-API-Wrapper
| 0
|
12775099
|
from riotwrapper.lor import LoRWrapper
from riotwrapper.const.lor_const import REGION_URL
import pytest
import re
@pytest.fixture
def environment():
import os
api_key = os.environ.get('API_KEY')
account_id = os.environ.get('ACCOUNT_ID')
env = {
'api_key': api_key,
'account_id': account_id
}
return env
@pytest.fixture
def wrapper(environment):
wrapper = LoRWrapper(environment['api_key'], region="AMERICAS")
return wrapper
class TestLoRWrapper:
def test_wrong_region(self):
"""Tests the exception raised after try to initialize
the wrapper with a not available region"""
region = "WRONG"
with pytest.raises(Exception) as region_info:
_ = LoRWrapper("key", region=region)
assert f"{region} is not available" in str(region_info.value)
assert ', '.join(list(REGION_URL.keys())) in str(region_info.value)
def test_platform_data(self, wrapper):
"""Tests an API call to get platform data."""
response = wrapper.platform_data()
assert isinstance(response, dict)
assert "id" in response.keys()
assert "maintenances" in response.keys()
assert "incidents" in response.keys()
def test_leaderboard(self, wrapper):
"""Tests an API call to get the leaderboard."""
response = wrapper.leaderboard()
assert isinstance(response, dict)
assert "players" in response.keys()
assert isinstance(response["players"], list)
assert len(response["players"]) > 0
assert "name" in response["players"][0].keys()
def test_match_ids(self, wrapper, environment):
"""Tests an API call to get the match id list by user."""
account_id = environment['account_id']
response = wrapper.match_ids(account_id)
pattern = re.compile(r'^(\w+\-\w+\-\w+\-\w+\-\w+)$')
assert isinstance(response, list)
assert pattern.match(response[0])
def test_match_by_id(self, wrapper, environment):
"""Tests and API call to get a match by id."""
account_id = environment['account_id']
match_list = wrapper.match_ids(account_id)
match_id = match_list[0]
response = wrapper.match_by_id(match_id)
assert isinstance(response, dict)
assert "metadata" in response.keys()
assert "info" in response.keys()
| 2.53125
| 3
|
django_magnificent_messages/constants.py
|
NoNameItem/django-magnificent-messages
| 0
|
12775100
|
"""
Constants and defaults values
"""
import datetime
import django
SECONDARY = 10
PRIMARY = 20
INFO = 30
SUCCESS = 40
WARNING = 50
ERROR = 60
DEFAULT_TAGS = {
SECONDARY: 'secondary',
PRIMARY: 'primary',
INFO: 'info',
SUCCESS: 'success',
WARNING: 'warning',
ERROR: 'danger',
}
DEFAULT_LEVELS = {
'SECONDARY': SECONDARY,
'PRIMARY': PRIMARY,
'INFO': INFO,
'SUCCESS': SUCCESS,
'WARNING': WARNING,
'ERROR': ERROR,
}
MESSAGE_FILES_UPLOAD_TO = "django_magnificent_messages/message_files"
MESSAGE_DB_MODEL = "django_magnificent_messages.Message"
DEFAULT_NOTIFICATION_STORAGE = "django_magnificent_messages.storage.notification_storage.session.SessionStorage"
DEFAULT_MESSAGE_STORAGE = "django_magnificent_messages.storage.message_storage.db.DatabaseStorage"
MIN_DATETIME = django.utils.timezone.make_aware(datetime.datetime(1900, 1, 1))
| 2.0625
| 2
|
setup.py
|
Colin-b/pyconfigparser
| 4
|
12775101
|
<filename>setup.py
import os
from setuptools import setup, find_packages
this_dir = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(this_dir, 'README.md'), 'r') as f:
long_description = f.read()
setup(name='pyconfigparser',
version='0.1',
author='<NAME>',
maintainer='<NAME>',
url='https://github.com/Colin-b/pyconfigparser',
description='Helper to parse configuration files.',
long_description=long_description,
download_url='https://github.com/Colin-b/pyconfigparser',
classifiers=[
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers"
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Operating System :: Microsoft :: Windows :: Windows 7"
],
keywords=[
'configuration'
],
packages=find_packages(),
install_requires=[
],
platforms=[
'Windows'
]
)
| 1.742188
| 2
|
test/EN.py
|
miaopei/deep_landmark
| 327
|
12775102
|
<reponame>miaopei/deep_landmark
#!/usr/bin/env python2.7
# coding: utf-8
"""
This file use Caffe model to predict landmarks and evaluate the mean error.
"""
import os, sys
import time
import cv2
import numpy as np
from numpy.linalg import norm
from common import getDataFromTxt, logger, processImage, getCNNs
TXT = 'dataset/train/testImageList.txt'
template = '''################## Summary #####################
Test Number: %d
Time Consume: %.03f s
FPS: %.03f
LEVEL - %d
Mean Error:
Left Eye = %f
Right Eye = %f
Nose = %f
Failure:
Left Eye = %f
Right Eye = %f
Nose = %f
'''
def evaluateError(landmarkGt, landmarkP, bbox):
e = np.zeros(3)
for i in range(3):
e[i] = norm(landmarkGt[i] - landmarkP[i])
e = e / bbox.w
print 'landmarkGt'
print landmarkGt
print 'landmarkP'
print landmarkP
print 'error', e
return e
def EN(img, bbox):
"""
LEVEL-1, EN
img: gray image
bbox: bounding box of face
"""
bbox = bbox.expand(0.05)
face = img[bbox.top:bbox.bottom+1,bbox.left:bbox.right+1]
face = cv2.resize(face, (39, 39)).reshape((1, 1, 39, 39))
face = processImage(face)
F, EN, NM = getCNNs(level=1) # TODO more flexible load needed.
landmark = EN.forward(face[:, :, :31, :])
return landmark
def E():
data = getDataFromTxt(TXT)
error = np.zeros((len(data), 3))
for i in range(len(data)):
imgPath, bbox, landmarkGt = data[i]
landmarkGt = landmarkGt[:3, :]
img = cv2.imread(imgPath, cv2.CV_LOAD_IMAGE_GRAYSCALE)
assert(img is not None)
logger("process %s" % imgPath)
landmarkP = EN(img, bbox)
# real landmark
landmarkP = bbox.reprojectLandmark(landmarkP)
landmarkGt = bbox.reprojectLandmark(landmarkGt)
error[i] = evaluateError(landmarkGt, landmarkP, bbox)
return error
if __name__ == '__main__':
t = time.clock()
error = E()
t = time.clock() - t
N = len(error)
fps = N / t
errorMean = error.mean(0)
# failure
failure = np.zeros(3)
threshold = 0.05
for i in range(3):
failure[i] = float(sum(error[:, i] > threshold)) / N
# log string
s = template % (N, t, fps, 1, errorMean[0], errorMean[1], errorMean[2], \
failure[0], failure[1], failure[2])
print s
logfile = 'log/1_EN_test.log'
with open(logfile, 'w') as fd:
fd.write(s)
| 2.640625
| 3
|
GroupmeChatbot/bot.py
|
dgisolfi/marty-gruopme-chatbot
| 0
|
12775103
|
#!/usr/bin/python3
# 2019-05-29
import re
import requests
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer
class Bot:
def __init__(self, name, bot_id, group_id, api_token):
self.name = name
self.bot_id = bot_id
self.group_id = group_id
self.api_token = api_token
self.api_base_url = 'https://api.groupme.com/v3'
self.api_session = requests.session()
# Create a instnce of a chatterbot and tell the bot where to find data
self.chatbot = ChatBot(self.name)
trainer = ChatterBotCorpusTrainer(self.chatbot)
trainer.train(
'chatterbot.corpus.english'
)
def sendMessage(self, msg):
'''Send a message from the bot to its assigned group.
Args:
msg (str): message to be sent to group
Returns:
request response
'''
# set parameters for post request
params = {
'bot_id': self.bot_id,
'text': msg
}
# send the request to the api and get the results in the response var
response = self.api_session.post(
f'{self.api_base_url}/bots/post',
params=params
)
return response
def getMessages(self):
'''Get all messages for the bot's group chat.
Args:
none
Returns:
request response
'''
# authenticate the request with the api token
params = {
'token': self.api_token
}
# get the messages for the bot's group
response = self.api_session.post(
f'{self.api_base_url}/groups/{self.group_id}/messages',
params=params
)
return response
def checkForMention(self, msg):
'''Checks the recent messages of the bots group for instances of its name
Args:
msg (str): message sent in group chat
Returns:
boolean: a value denoting if the bot was mentioned or not
'''
return re.match(r'.*@'+self.name+r'.*', msg)
def removeMention(self, msg):
'''Checks the recent messages of the bots group for instances of its name
Args:
msg (str): message sent in group chat
Returns:
msg (str): a messaged with the '@<bot_name>' removed
'''
return re.sub(f'@{self.name}', '', msg)
def getResponse(self, msg):
'''Given a message the appropriate response is returned.
Args:
msg (str): a message to respond to
Returns:
response (str): the bot's response to the message
'''
# makes a call to the chatterbot package for a response
response = self.chatbot.get_response(msg)
return response
| 3.03125
| 3
|
eggs/boto-2.5.2-py2.7.egg/boto/cloudsearch/document.py
|
bopopescu/phyG
| 3
|
12775104
|
# Copyright (c) 2012 <NAME> http://garnaat.org/
# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.
# All Rights Reserved
#
# 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, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing 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 MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR 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.
#
try:
import simplejson as json
except ImportError:
import json
import boto.exception
import requests
import boto
class SearchServiceException(Exception):
pass
class CommitMismatchError(Exception):
pass
class DocumentServiceConnection(object):
def __init__(self, domain=None, endpoint=None):
self.domain = domain
self.endpoint = endpoint
if not self.endpoint:
self.endpoint = domain.doc_service_endpoint
self.documents_batch = []
self._sdf = None
def add(self, _id, version, fields, lang='en'):
d = {'type': 'add', 'id': _id, 'version': version, 'lang': lang,
'fields': fields}
self.documents_batch.append(d)
def delete(self, _id, version):
d = {'type': 'delete', 'id': _id, 'version': version}
self.documents_batch.append(d)
def get_sdf(self):
return self._sdf if self._sdf else json.dumps(self.documents_batch)
def clear_sdf(self):
self._sdf = None
self.documents_batch = []
def add_sdf_from_s3(self, key_obj):
"""@todo (lucas) would be nice if this could just take an s3://uri..."""
self._sdf = key_obj.get_contents_as_string()
def commit(self):
sdf = self.get_sdf()
if ': null' in sdf:
boto.log.error('null value in sdf detected. This will probably raise '
'500 error.')
index = sdf.index(': null')
boto.log.error(sdf[index - 100:index + 100])
url = "http://%s/2011-02-01/documents/batch" % (self.endpoint)
request_config = {
'pool_connections': 20,
'keep_alive': True,
'max_retries': 5,
'pool_maxsize': 50
}
r = requests.post(url, data=sdf, config=request_config,
headers={'Content-Type': 'application/json'})
return CommitResponse(r, self, sdf)
class CommitResponse(object):
"""Wrapper for response to Cloudsearch document batch commit.
:type response: :class:`requests.models.Response`
:param response: Response from Cloudsearch /documents/batch API
:type doc_service: :class:`exfm.cloudsearch.DocumentServiceConnection`
:param doc_service: Object containing the documents posted and methods to
retry
:raises: :class:`boto.exception.BotoServerError`
:raises: :class:`exfm.cloudsearch.SearchServiceException`
"""
def __init__(self, response, doc_service, sdf):
self.response = response
self.doc_service = doc_service
self.sdf = sdf
try:
self.content = json.loads(response.content)
except:
boto.log.error('Error indexing documents.\nResponse Content:\n{}\n\n'
'SDF:\n{}'.format(response.content, self.sdf))
raise boto.exception.BotoServerError(self.response.status_code, '',
body=response.content)
self.status = self.content['status']
if self.status == 'error':
self.errors = [e.get('message') for e in self.content.get('errors',
[])]
else:
self.errors = []
self.adds = self.content['adds']
self.deletes = self.content['deletes']
self._check_num_ops('add', self.adds)
self._check_num_ops('delete', self.deletes)
def _check_num_ops(self, type_, response_num):
"""Raise exception if number of ops in response doesn't match commit
:type type_: str
:param type_: Type of commit operation: 'add' or 'delete'
:type response_num: int
:param response_num: Number of adds or deletes in the response.
:raises: :class:`exfm.cloudsearch.SearchServiceException`
"""
commit_num = len([d for d in self.doc_service.documents_batch
if d['type'] == type_])
if response_num != commit_num:
raise CommitMismatchError(
'Incorrect number of {}s returned. Commit: {} Respose: {}'\
.format(type_, commit_num, response_num))
| 1.828125
| 2
|
demo_project/urls.py
|
zmcddn/DRF-demo-user-creditcard
| 0
|
12775105
|
from django.contrib import admin
from django.urls import path, re_path, include, reverse_lazy
from rest_framework.routers import DefaultRouter
from users.views import LoginViewCustom
from accounts.views import CardSerializerViewSet
router = DefaultRouter()
router.register(r'card', CardSerializerViewSet)
urlpatterns = [
path("", include(router.urls)),
path("admin/", admin.site.urls),
path("api/auth/", include("rest_auth.urls")),
path("api/auth/registration/", include("rest_auth.registration.urls")),
path("api/auth/login/", LoginViewCustom.as_view(), name="rest_login"),
]
| 1.8125
| 2
|
PythonLearn/opencv/synthesis.py
|
OKKyu/PythonLearn
| 0
|
12775106
|
#!python3
# -*- coding:utf-8 -*-
# 『Pythonで始めるOpenCV4プログラミング』
# 北山尚洋
import cv2
import sys, traceback
import numpy as np
def add(imgName1, imgName2):
try:
img1 = cv2.imread(imgName1)
img2 = cv2.imread(imgName2)
if img1 is None or img2 is None:
print("no file reading...")
sys.exit(1)
#caution!
#src file size have to same size each img1 and img2. and same type.
img1 = cv2.resize(img1, (500,500))
img2 = cv2.resize(img2, (500,500))
cv2.imshow('image1', img1)
cv2.imshow('image2', img2)
dst = cv2.add(img1, img2)
cv2.imshow('synthesize', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
except Exception as ex:
print("Error:", sys.exc_info()[0])
print(sys.exc_info()[1])
print(traceback.format_tb(sys.exc_info()[2]))
finally:
pass
def addScolor(imgName1):
try:
img1 = cv2.imread(imgName1)
if img1 is None:
print("no file reading...")
sys.exit(1)
cv2.imshow("img1",img1)
height = img1.shape[0]
width = img1.shape[1]
blue = np.zeros((height, width, 3), np.uint8)
blue[:,:] = [128, 0, 0]
dst = cv2.add(img1, blue)
cv2.imshow("after", dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
except Exception as ex:
print("Error:", sys.exc_info()[0])
print(sys.exc_info()[1])
print(traceback.format_tb(sys.exc_info()[2]))
finally:
pass
def addMask(imgName1, imgName2):
try:
img1 = cv2.imread(imgName1)
img2 = cv2.imread(imgName2)
if img1 is None or img2 is None:
print("no file reading...")
sys.exit(1)
#caution!
#src file size have to same size each img1 and img2. and same type.
img1 = cv2.resize(img1, (500,500))
img2 = cv2.resize(img2, (500,500))
cv2.imshow('image1', img1)
cv2.imshow('image2', img2)
#create mask
height = img1.shape[0]
width = img1.shape[1]
img_mask = np.zeros((height, width), np.uint8)
img_mask[ height//4:height*3//4, width//4:width*3//4 ] = [255]
#add two image with mask.
dst = cv2.add(img1, img2, mask = img_mask)
cv2.imshow('dst1', dst)
#add two image with mask.
dst = cv2.add(img1, img2, mask = img_mask)
cv2.imshow('dst1', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
except Exception as ex:
print("Error:", sys.exc_info()[0])
print(sys.exc_info()[1])
print(traceback.format_tb(sys.exc_info()[2]))
finally:
pass
#add(sys.argv[1], sys.argv[2])
#addScolor(sys.argv[1])
addMask(sys.argv[1], sys.argv[2])
| 3.078125
| 3
|
zipline/currency.py
|
chalant/pluto
| 1
|
12775107
|
<reponame>chalant/pluto
from functools import partial, total_ordering
from iso4217 import Currency as ISO4217Currency
import numpy as np
_ALL_CURRENCIES = {}
def strs_to_sids(strs, category_num):
"""TODO: Improve this.
"""
out = np.full(len(strs), category_num << 50, dtype='i8')
casted_buffer = np.ndarray(
shape=out.shape,
dtype='S6',
buffer=out,
strides=out.strides,
)
casted_buffer[:] = np.array(strs, dtype='S6')
return out
def str_to_sid(str_, category_num):
return strs_to_sids([str_], category_num)[0]
iso_currency_to_sid = partial(str_to_sid, category_num=3)
@total_ordering
class Currency(object):
"""A currency identifier, as defined by ISO-4217.
Parameters
----------
code : str
ISO-4217 code for the currency.
Attributes
----------
code : str
ISO-4217 currency code for the currency, e.g., 'USD'.
name : str
Plain english name for the currency, e.g., 'US Dollar'.
"""
def __new__(cls, code):
try:
return _ALL_CURRENCIES[code]
except KeyError:
try:
iso_currency = ISO4217Currency(code)
except ValueError:
raise ValueError(
"{!r} is not a valid currency code.".format(code)
)
obj = _ALL_CURRENCIES[code] = super(Currency, cls).__new__(cls)
obj._currency = iso_currency
obj._sid = iso_currency_to_sid(iso_currency.value)
return obj
@property
def code(self):
"""ISO-4217 currency code for the currency.
Returns
-------
code : str
"""
return self._currency.value
@property
def name(self):
"""Plain english name for the currency.
Returns
-------
name : str
"""
return self._currency.currency_name
@property
def sid(self):
"""Unique integer identifier for this currency.
"""
return self._sid
def __eq__(self, other):
if type(self) != type(other):
return NotImplemented
return self.code == other.code
def __hash__(self):
return hash(self.code)
def __lt__(self, other):
return self.code < other.code
def __repr__(self):
return "{}({!r})".format(
type(self).__name__,
self.code
)
| 2.65625
| 3
|
entity.py
|
Alberdi/rogueforce
| 0
|
12775108
|
import libtcodpy as libtcod
import cmath as math
NEUTRAL_SIDE = 555
class Entity(object):
def __init__(self, battleground, side=NEUTRAL_SIDE, x=-1, y=-1, char=' ', color=libtcod.white):
self.bg = battleground
self.x = x
self.y = y
self.side = side
self.char = char
self.original_char = char
self.color = color
self.original_color = color
self.bg.tiles[(x, y)].entity = self
self.default_next_action = 5
self.next_action = self.default_next_action
self.pushed = False
self.alive = True
self.statuses = []
self.path = []
self.attack_effect = None
self.attack_type = "physical"
self.kills = 0
self.owner = None
def can_be_attacked(self):
return False
def can_be_pushed(self, dx, dy):
next_tile = self.bg.tiles[(self.x+dx, self.y+dy)]
return next_tile.is_passable(self) and (next_tile.entity is None or next_tile.entity.can_be_pushed(dx, dy))
def can_move(self, dx, dy):
next_tile = self.bg.tiles[(self.x+dx, self.y+dy)]
if not next_tile.is_passable(self): return False
if next_tile.entity is None: return True
if not next_tile.entity.is_ally(self): return False
return next_tile.entity.can_be_pushed(dx, dy)
def change_battleground(self, bg, x, y):
self.bg.tiles[(self.x, self.y)].entity = None
self.bg = bg
(self.x, self.y) = (x, y)
self.bg.tiles[(self.x, self.y)].entity = self
def clone(self, x, y):
if self.bg.is_inside(x, y) and self.bg.tiles[(x, y)].entity is None and self.bg.tiles[(x, y)].is_passable(self):
return self.__class__(self.bg, self.side, x, y, self.char, self.original_color)
return None
def die(self):
self.bg.tiles[(self.x, self.y)].entity = None
self.alive = False
def get_char(self, x, y):
return self.char
def get_passable_neighbours(self):
neighbours = [(self.x+i, self.y+j) for i in range(-1,2) for j in range(-1,2)]
return filter(lambda t: self.bg.tiles[t].passable and t != (self.x, self.y), neighbours)
def get_pushed(self, dx, dy):
self.pushed = False
self.move(dx, dy)
self.pushed = True
def is_ally(self, entity):
return self.side == entity.side
def move(self, dx, dy):
if self.pushed:
self.pushed = False
return False
(dx,dy) = (int(dx), int(dy))
next_tile = self.bg.tiles[(self.x+dx, self.y+dy)]
if self.can_move(dx, dy):
if next_tile.entity is not None:
next_tile.entity.get_pushed(dx, dy)
self.bg.tiles[(self.x, self.y)].entity = None
next_tile.entity = self
self.x += dx
self.y += dy
return True
return False
def move_path(self):
if self.path:
next_tile = self.path.pop(0)
if self.move(next_tile.x - self.x, next_tile.y - self.y):
return True
else:
self.path.insert(0, next_tile)
return False
def register_kill(self, killed):
self.kills += 1
if self.owner:
self.owner.kills += 1
def reset_action(self):
self.next_action = self.default_next_action
def teleport(self, x, y):
if self.bg.tiles[(x, y)].entity is None and self.bg.tiles[(x, y)].is_passable(self):
self.bg.tiles[(x, y)].entity = self
self.bg.tiles[(self.x, self.y)].entity = None
(self.x, self.y) = (x, y)
return True
return False
def update(self):
for s in self.statuses:
s.update()
class BigEntity(Entity):
def __init__(self, battleground, side, x, y, chars=["a", "b", "c", "d"], colors=[libtcod.white]*4):
super(BigEntity, self).__init__(battleground, side, x, y, chars[0], colors[0])
self.chars = chars
self.colors = colors
self.length = int(math.sqrt(len(self.chars)).real)
self.update_body()
def can_be_pushed(self, dx, dy):
return False
def can_move(self, dx, dy):
for (x,y) in [(self.x+dx+x,self.y+dy+y) for x in range (0, self.length) for y in range (0, self.length)]:
next_tile = self.bg.tiles[(x, y)]
if not next_tile.is_passable(self): return False
if next_tile.entity is None: continue
if not next_tile.entity.is_ally(self): return False
if next_tile.entity is self: continue
if not next_tile.entity.can_be_pushed(dx, dy): return False
return True
def clear_body(self):
for i in range(self.length):
for j in range(self.length):
self.bg.tiles[(self.x+i, self.y+j)].entity = None
def die(self):
self.clear_body()
self.alive = False
def get_char(self, dx, dy):
self.color = self.colors[self.length*dx+dy]
return self.chars[self.length*dx+dy]
def move(self, dx, dy):
if self.pushed:
self.pushed = False
return
next_tile = self.bg.tiles[(self.x+dx, self.y+dy)]
if self.can_move(dx, dy):
if next_tile.entity is not None and next_tile.entity is not self:
next_tile.entity.get_pushed(dx, dy)
self.clear_body()
next_tile.entity = self
self.x += dx
self.y += dy
self.update_body()
def update_body(self):
for i in range(self.length):
for j in range(self.length):
self.bg.tiles[(self.x+i, self.y+j)].entity = self
class Fortress(BigEntity):
def __init__(self, battleground, side=NEUTRAL_SIDE, x=-1, y=-1, chars=[':']*4, colors=[libtcod.white]*4, requisition_production=1):
super(Fortress, self).__init__(battleground, side, x, y, chars, colors)
self.capacity = len(chars)
self.connected_fortresses = []
self.guests = []
self.name = "Fortress"
self.requisition_production = requisition_production
def can_be_attacked(self):
return True
def can_host(self, entity):
return self.side == entity.side or self.side == NEUTRAL_SIDE
def can_move(self, dx, dy):
return False
def get_connections(self):
# Gather all tiles inside and surrounding the fortress
starting_tiles = [(self.x+i, self.y+j) for i in range(-1,3) for j in range(-1,3)]
# Remove those inside it
checked = [(self.x+i, self.y+j) for i in range(0,2) for j in range(0,2)]
starting_tiles = filter(lambda t: self.bg.tiles[t].passable and t not in checked, starting_tiles)
# Try every reachable tile from the fortress and save the connections
for starting in starting_tiles:
tiles = [starting]
while tiles:
(x, y) = tiles.pop()
checked.append((x, y))
for t in [(x+i, y+j) for i in range(-1,2) for j in range(-1,2)]:
entity = self.bg.tiles[t].entity
if entity in self.bg.fortresses and entity is not self and entity not in self.connected_fortresses:
self.connected_fortresses.append((entity, starting))
if self.bg.tiles[t].passable and t not in checked:
tiles.append(t)
def host(self, entity):
if not self.can_host(entity) or len(self.guests) >= self.capacity: return
if not self.guests:
self.side = entity.side
self.bg.tiles[(entity.x, entity.y)].entity = None
(entity.x, entity.y) = (self.x, self.y)
self.bg.generals.remove(entity)
self.chars[len(self.guests)] = entity.char
self.colors[len(self.guests)] = entity.color
self.guests.append(entity)
self.update_body()
def refresh_chars(self):
self.chars = [':']*len(self.chars)
self.colors = [libtcod.white]*len(self.colors)
for i in range(len(self.guests)):
self.chars[i] = self.guests[i].char
self.colors[i] = self.guests[i].color
def unhost(self, entity):
self.guests.remove(entity)
self.bg.generals.append(entity)
self.refresh_chars()
if not self.guests:
self.side = NEUTRAL_SIDE
class Mine(Entity):
def __init__(self, battleground, x=-1, y=-1, power=50):
super(Mine, self).__init__(battleground, NEUTRAL_SIDE, x, y, 'X', libtcod.red)
self.power = power
def can_be_attacked(self):
return True
def clone(self, x, y):
if self.bg.is_inside(x, y) and self.bg.tiles[(x, y)].entity is None and self.bg.tiles[(x, y)].is_passable(self):
return self.__class__(self.bg, x, y, self.power)
return None
def get_attacked(self, attacker):
if attacker.can_be_attacked():
attacker.get_attacked(self)
self.die()
| 2.65625
| 3
|
pgxnclient/tar.py
|
ankane/pgxnclient
| 0
|
12775109
|
"""
pgxnclient -- tar file utilities
"""
# Copyright (C) 2011-2020 <NAME>
# This file is part of the PGXN client
import os
import tarfile
from pgxnclient.i18n import _
from pgxnclient.errors import PgxnClientException
from pgxnclient.archive import Archive
import logging
logger = logging.getLogger('pgxnclient.tar')
class TarArchive(Archive):
"""Handle .tar archives"""
_file = None
def can_open(self):
return tarfile.is_tarfile(self.filename)
def open(self):
assert not self._file, "archive already open"
try:
self._file = tarfile.open(self.filename, 'r')
except Exception as e:
raise PgxnClientException(
_("cannot open archive '%s': %s") % (self.filename, e)
)
def close(self):
if self._file is not None:
self._file.close()
self._file = None
def list_files(self):
assert self._file, "archive not open"
return self._file.getnames()
def read(self, fn):
assert self._file, "archive not open"
return self._file.extractfile(fn).read()
def unpack(self, destdir):
tarname = self.filename
logger.info(_("unpacking: %s"), tarname)
destdir = os.path.abspath(destdir)
self.open()
try:
for fn in self.list_files():
fname = os.path.abspath(os.path.join(destdir, fn))
if not fname.startswith(destdir):
raise PgxnClientException(
_("archive file '%s' trying to escape!") % fname
)
self._file.extractall(path=destdir)
finally:
self.close()
return self._find_work_directory(destdir)
def unpack(filename, destdir):
return TarArchive(filename).unpack(destdir)
| 2.40625
| 2
|
bids/convert_log_to_events.py
|
Charestlab/caos
| 0
|
12775110
|
<filename>bids/convert_log_to_events.py
"""
Function to convert psychopy log to BIDS events file. See BIDS spec:
https://bids-specification.readthedocs.io/en/latest/04-modality-specific-files/05-task-events.html
https://bids-specification.readthedocs.io/en/latest/04-modality-specific-files/07-behavioral-experiments.html
"""
import pandas, mne
from numpy.testing import assert_array_equal
def check_row_valid(row):
if row.ptype in ['INFO', 'WARNING']:
return False
messages = ['unnamed MovieStim', 'Created window', 'mouseVisible']
for message in messages:
if message in row.desc:
return False
return True
def trial_type(row):
if 'Keypr' in row.desc:
return 'response'
elif 'nback' in row.desc:
return 'nback'
else:
return row.desc.split(',')[2]
def duration(row):
if row.trial_type == 'response':
return 0.0
else:
return 3.0
def value(row):
if row.trial_type == 'response':
return 0
else:
return int(row.desc.split(',')[0])
def stim_name(row):
if row.trial_type == 'response':
return ''
else:
return row.desc.split(',')[1]
def convert_log_to_events(in_fpath, out_fpath):
"""BIDS events tsv from psychopy log
"""
df = pandas.read_csv(
in_fpath,
delimiter='\t',
names=['onset', 'ptype', 'desc'],
converters={'ptype': str.strip}
)
valid_rows = df.apply(check_row_valid, axis=1)
df = df[valid_rows]
df['trial_type'] = df.apply(trial_type, axis=1)
df['duration'] = df.apply(duration, axis=1)
df['value'] = df.apply(value, axis=1)
df['stim_name'] = df.apply(stim_name, axis=1)
df = df.drop(['ptype', 'desc'], axis=1)
first_onset = df.iloc[0].onset
df.onset -= first_onset
# check if this behavior matches up with the corresponding eeg file
eeg_path = out_fpath.replace('_events.tsv', '_eeg.edf')
raw = mne.io.read_raw_edf(eeg_path, verbose='error')
events = mne.find_events(raw, verbose='error')
## index only events that have triggers in eeg
stimulus_events = df.trial_type != 'response'
## check if number of relevant events matches
assert events.shape[0] == stimulus_events.sum()
## check if event values match
assert_array_equal(events[:, 2], df[stimulus_events].value)
## onset should be relative to first sample
df.onset += events[0, 0] / raw.info['sfreq']
# add sample column
df['sample'] = None
df.loc[stimulus_events, 'sample'] = events[:, 0]
df.to_csv(out_fpath, sep='\t', index=False, float_format='%.8f')
return df
| 2.703125
| 3
|
tests/core/test_proxy.py
|
joewilliams/dd-agent
| 11
|
12775111
|
<gh_stars>10-100
# stdlib
from unittest import TestCase
# 3p
from requests.utils import get_environ_proxies
# project
from utils.proxy import set_no_proxy_settings
class TestProxy(TestCase):
def test_no_proxy(self):
"""
Starting with Agent 5.0.0, there should always be a local forwarder
running and all payloads should go through it. So we should make sure
that we pass the no_proxy environment variable that will be used by requests
(See: https://github.com/kennethreitz/requests/pull/945 )
"""
from os import environ as env
env["http_proxy"] = "http://localhost:3128"
env["https_proxy"] = env["http_proxy"]
env["HTTP_PROXY"] = env["http_proxy"]
env["HTTPS_PROXY"] = env["http_proxy"]
set_no_proxy_settings()
self.assertTrue("no_proxy" in env)
self.assertEquals(env["no_proxy"], "127.0.0.1,localhost,169.254.169.254")
self.assertEquals({}, get_environ_proxies(
"http://localhost:17123/api/v1/series"))
expected_proxies = {
'http': 'http://localhost:3128',
'https': 'http://localhost:3128',
'no': '127.0.0.1,localhost,169.254.169.254'
}
environ_proxies = get_environ_proxies("https://www.google.com")
self.assertEquals(expected_proxies, environ_proxies, (expected_proxies, environ_proxies))
# Clear the env variables set
env.pop("http_proxy", None)
env.pop("https_proxy", None)
env.pop("HTTP_PROXY", None)
env.pop("HTTPS_PROXY", None)
| 2.75
| 3
|
easy/110.Balanced_Binary_Tree.py
|
Leesoar/leetcode
| 2
|
12775112
|
<filename>easy/110.Balanced_Binary_Tree.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Question:
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as:
a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
Example 1:
Given the following tree [3,9,20,null,null,15,7]:
3
/ \
9 20
/ \
15 7
Return true.
Example 2:
Given the following tree [1,2,2,3,3,null,null,4,4]:
1
/ \
2 2
/ \
3 3
/ \
4 4
Return false.
'''
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isBalanced(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
def check(root):
if root is None:
return 0
left = check(root.left) #左子树的深度
right = check(root.right) #右子树的深度
if left == -1 or right == -1 or abs(left - right) > 1:
return -1 #如果左子树严重倾斜，left == -1可以大大节省递归时间
return 1 + max(left, right)
return check(root) != -1
| 4.3125
| 4
|
about.py
|
sjtrny/toomanyguns
| 1
|
12775113
|
<filename>about.py
from common import MarkdownApp
import flask
class About(MarkdownApp):
title = "About"
breadcrumbs = None
markdown = """
## About
----
This website shows ownership of firearms in NSW by postcode. This information has been made public thanks to the NSW Greens through a FOI request to NSW Police.
## FAQ
----
##### Doesn't toomanyguns.org already exist?
Yes, but it could be better. It's 2019 and they don't even [use HTTPS](https://doesmysiteneedhttps.com/)!
So we built our own.
##### This doesn't work on my computer/browser?
It's best viewed on a modern browser such as Safari or Chrome with graphics acceleration enabled.
##### How did you make this?
This website is built on [Dash for Python](https://github.com/plotly/dash) by Plotly.
You can find the code on [Github](https://github.com/sjtrny/toomanyguns)
##### Who made this?
I did, you can find more details on my website [sjtrny.com](https://sjtrny.com)
## Data
----
##### Postcode Information
Sourced from [https://www.matthewproctor.com/australian_postcodes](https://www.matthewproctor.com/australian_postcodes)
##### Postal Area Geography Data
This information is available from the ABS under the listing [1270.0.55.003 - Australian Statistical Geography Standard (ASGS): Volume 3 - Non ABS Structures, July 2016](https://www.abs.gov.au/AUSSTATS/abs@.nsf/DetailsPage/1270.0.55.003July%202016?OpenDocument)
The specific file used is titled "Postal Areas ASGS Ed 2016 Digital Boundaries in ESRI Shapefile Format"
##### Firearms Data
We did our best to scrape [http://toomanyguns.org](http://toomanyguns.org).
Don't worry, you don't need to scrape it yourself, [click here to download it](downloads/firearms_2019.csv).
"""
def postlayout_setup(self):
@self.server.route(
f"{self.config.url_base_pathname}downloads/firearms_2019.csv",
endpoint=f"{self.config.url_base_pathname}:serve_file",
)
def serve_file():
return flask.send_file(
"data_generated/firearms_2019.csv", as_attachment=True
)
| 3.03125
| 3
|
mininet/exabgp-vip/topo.py
|
ljjjustin/stack-vagrants
| 1
|
12775114
|
#!/usr/bin/python
from mininet.topo import Topo
from mininet.net import Mininet
from mininet.node import Node
from mininet.log import setLogLevel, info
from mininet.cli import CLI
import time
import os
workdir = os.path.dirname(os.path.realpath(__file__))
class LinuxRouter( Node ):
"A Node with IP forwarding enabled."
def config( self, **params ):
super( LinuxRouter, self).config( **params )
# Enable forwarding on the router
self.cmd( 'sysctl net.ipv4.ip_forward=1' )
def terminate( self ):
self.cmd( 'sysctl net.ipv4.ip_forward=0' )
super( LinuxRouter, self ).terminate()
class NetworkTopo( Topo ):
"A LinuxRouter connecting three IP subnets"
def build( self, **_opts ):
defaultIP1 = '10.0.3.10/24' # IP address for r1-eth1
defaultIP2 = '10.0.3.20/24'
router1 = self.addNode( 'r1', cls=LinuxRouter, ip=defaultIP1 ) # cls = class
router2 = self.addNode( 'r2', cls=LinuxRouter, ip=defaultIP2 )
self.addLink(router1,router2,intfName1='r1-r2',intfName2='r2-r1')
h1 = self.addHost( 'h1', ip='192.168.1.10/24', defaultRoute='via 192.168.1.1') # define gateway
h2 = self.addHost( 'h2', ip='192.168.2.10/24', defaultRoute='via 192.168.2.1')
# h1-eth0 <-> r1-eth2, r1-eth2 = 10.0.1.10/24
self.addLink(h1,router1,intfName2='r1-h1',params2={ 'ip': '192.168.1.1/24' })
# h2-eth0 <-> r2-eth2, r2-eth2 = 10.0.2.20/24
self.addLink(h2,router2,intfName2='r2-h2',params2={ 'ip': '192.168.2.1/24' })
lb1 = self.addHost( 'lb1', ip='192.168.10.10/24', defaultRoute='via 192.168.10.1')
lb2 = self.addHost( 'lb2', ip='192.168.20.10/24', defaultRoute='via 192.168.20.1')
self.addLink(lb1,router1,intfName1='eth0',intfName2='r1-lb1',params2={ 'ip': '192.168.10.1/24' })
self.addLink(lb2,router2,intfName1='eth0',intfName2='r2-lb2',params2={ 'ip': '192.168.20.1/24' })
def run():
"Test linux router"
topo = NetworkTopo()
net = Mininet(controller = None, topo=topo ) # no controller
net.start()
info( '*** Routing Table on Router:\n' )
r1=net.getNodeByName('r1')
r2=net.getNodeByName('r2')
info('starting zebra and bgpd service:\n')
dirs = {"workdir": workdir}
r1.cmd('/usr/sbin/zebra -f %(workdir)s/r1zebra.conf -d -z %(workdir)s/r1zebra.api -i %(workdir)s/r1zebra.pid' % dirs)
time.sleep(2) # time for zebra to create api socket
r2.cmd('/usr/sbin/zebra -f %(workdir)s/r2zebra.conf -d -z %(workdir)s/r2zebra.api -i %(workdir)s/r2zebra.pid' % dirs)
time.sleep(2) # time for zebra to create api socket
r1.cmd('/usr/sbin/bgpd -f %(workdir)s/r1bgpd.conf -d -z %(workdir)s/r1zebra.api -i %(workdir)s/r1bgpd.pid' % dirs)
r2.cmd('/usr/sbin/bgpd -f %(workdir)s/r2bgpd.conf -d -z %(workdir)s/r2zebra.api -i %(workdir)s/r2bgpd.pid' % dirs)
lb1=net.getNodeByName('lb1')
lb2=net.getNodeByName('lb2')
lb1.cmd('/usr/sbin/keepalived -n -R -f %(workdir)s/keep1.conf &' % dirs)
lb2.cmd('/usr/sbin/keepalived -n -R -f %(workdir)s/keep2.conf &' % dirs)
lb1.cmd('/usr/sbin/exabgp --env %(workdir)s/exabgp1.env %(workdir)s/exabgp1.conf &' % dirs)
lb2.cmd('/usr/sbin/exabgp --env %(workdir)s/exabgp2.env %(workdir)s/exabgp2.conf &' % dirs)
CLI( net )
net.stop()
os.system("killall -9 bgpd zebra keepalived exabgp")
os.system("rm -f *api*")
os.system("rm -f *pid*")
if __name__ == '__main__':
setLogLevel( 'info' )
run()
| 2.390625
| 2
|
lab8-Mid-Course/code/app.py
|
MadCreeper/SJTU_ICE2602
| 0
|
12775115
|
<reponame>MadCreeper/SJTU_ICE2602<filename>lab8-Mid-Course/code/app.py
# SJTU EE208
from flask import Flask, redirect, render_template, request, url_for
app = Flask(__name__)
@app.route('/form', methods=['POST', 'GET'])
def bio_data_form():
if request.method == "POST":
username = request.form['username']
age = request.form['age']
email = request.form['email']
hobbies = request.form['hobbies']
return redirect(url_for('showbio', username=username, age=age, email=email, hobbies=hobbies))
return render_template("bio_form.html")
@app.route('/showbio', methods=['GET'])
def showbio():
"""
username = request.args.get('username')
age = request.args.get('age')
email = request.args.get('email')
hobbies = request.args.get('hobbies')
"""
username = "excited"
age = "114514"
email = "<EMAIL>"
hobbies = "?"
return render_template("show_bio.html", username=username, age=age, email=email, hobbies=hobbies)
if __name__ == '__main__':
app.run(debug=True, port=8080)
| 2.953125
| 3
|
mistral/scheduler/scheduler_server.py
|
soda-research/mistral
| 205
|
12775116
|
<reponame>soda-research/mistral
# Copyright 2018 - Nokia Networks.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from oslo_config import cfg
from oslo_log import log as logging
from mistral.rpc import base as rpc
from mistral.service import base as service_base
LOG = logging.getLogger(__name__)
CONF = cfg.CONF
class SchedulerServer(service_base.MistralService):
"""Scheduler server.
Manages scheduler life-cycle and gets registered as an RPC
endpoint to process scheduler specific calls.
"""
def __init__(self, scheduler, setup_profiler=True):
super(SchedulerServer, self).__init__(
'scheduler_group',
setup_profiler
)
self.scheduler = scheduler
self._rpc_server = None
def start(self):
super(SchedulerServer, self).start()
self._rpc_server = rpc.get_rpc_server_driver()(cfg.CONF.engine)
self._rpc_server.register_endpoint(self)
self._rpc_server.run()
self._notify_started('Scheduler server started.')
def stop(self, graceful=False):
super(SchedulerServer, self).stop()
if self._rpc_server:
self._rpc_server.stop(graceful)
def schedule(self, rpc_ctx, job):
"""Receives requests over RPC to schedule delayed calls.
:param rpc_ctx: RPC request context.
:param job: Scheduler job.
"""
LOG.info("Received RPC request 'schedule'[job=%s]", job)
return self.scheduler.schedule(job, allow_redistribute=False)
| 1.882813
| 2
|
quant/example/ex_binance.py
|
doubleDragon/QuantBot
| 7
|
12775117
|
<filename>quant/example/ex_binance.py<gh_stars>1-10
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from __future__ import print_function
from quant.brokers.broker_factory import create_brokers
pair_code = 'Binance_ZRX_ETH'
'''test broker'''
brokers = create_brokers([pair_code])
broker = brokers[pair_code]
'''sell order'''
# amount = 10
# price = 0.0019
# order_id = broker.sell_limit(amount=amount, price=price)
# if order_id:
# print('sell order success, id = %s' % order_id)
# else:
# print('sell order failed')
'''buy order'''
'''get order 5863126'''
# order = broker.get_order(order_id=5863126)
# if order:
# print('get order success, %s' % order)
# else:
# print('get order failed')
'''cancel order 5957505'''
# order_id = 5957505
# res = broker.cancel_order(order_id=order_id)
# if res:
# print('cancel order: % success' % order_id)
# else:
# print('cancel order: % failed' % order_id)
| 2.34375
| 2
|
src/krpsim/parsing.py
|
arlaine4/Krp
| 1
|
12775118
|
import sys
from src.krpsim.utils import split_need_result_delay, build_process_dic
class Parser:
"""
Parsing Class, heart of the parsing is here.
-> stocks is a list of Stock class instances
-> content is a list of Process class instances
-> optimize is a list of Optimize class instances
-> delay corresponds to the maximal delay given as a parameter
"""
def __init__(self, options):
self.path, self.delay = options.input_path, options.delay
self.stocks = {}
self.content = {}
self.optimize = []
self.verbose = options.verbose
self.fd = open(self.path, 'r+')
def main_parsing(self):
"""
Main parsing loop, the goal here is to iterate over
the fd content, and to parse every line we encounter to
determine its type
"""
curr_line = None
for line in self.fd:
if line[0] == '#':
print("Found a comment") if self.verbose == 1 or self.verbose == 3 else 0
continue
elif len(line) == 1 and line[0] == '\n':
print("Skipping empty line") if self.verbose == 1 or self.verbose == 3 else 0
continue
else:
curr_line = self.parse_line(line)
self.fill_parser_lists(curr_line)
print(curr_line) if self.verbose == 1 or self.verbose == 3 else 0
self.fd = self.fd.close()
def fill_parser_lists(self, line):
"""
Comparing the line type after parse_line,
we compare class instances with the base classes
"""
if type(line) is Process:
self.content[line.name] = line
elif type(line) is Optimize:
self.optimize.append(line)
elif type(line) is Stock:
self.stocks[line.name] = line
def verify_parsing_content(self):
"""
Afterward check method for the parsing content
"""
if not self.optimize:
sys.exit("Missing optimize content.")
elif not self.stocks:
sys.exit("Missing initial stocks.")
elif not self.content:
sys.exit("No process detected inside {}, please provide at least one".format(self.path))
#Check if what need to be optimized is indeed inside at least one process and is accesible
#like if the process never gets called because of stocks that can never be filled, then
#the optimize values are not valid.
def parse_line(self, line):
"""
Method used to parse a line and extract the corresponding elem
tmp -> Used for splitting the line and removing some junk from the list
res -> Class instance, either Stock, Process or Optimize
every instance is filled with the corresponding params
"""
tmp = None
res = None
line = line.replace('\n', '')
tmp = [i for i in line.split(':')]
tmp.pop(tmp.index('')) if '' in tmp else tmp
# Parsing for stock elem
if '(' not in line:
if tmp[0].isalpha() and tmp[1].isdecimal() or\
tmp[0].replace('_', '').isalpha() and tmp[1].isdecimal():
res = Stock(tmp[0], int(tmp[1]))
else:
res = 'Error'
# Parsing for optimize elem
elif 'optimize:' in line:
if tmp[-1].isdigit():
sys.exit("You can't specify a delay for an optimize element, error with \033[4m{}\033[0m"
.format(line))
tmp = str(tmp[1]).replace('(', '').replace(')', '')
res = Optimize(tmp.split(';'))
# Parsing for process elem
elif tmp[-1].isdigit():
tmp = [i.replace(')', '') for i in line.split('(')]
name, need, result, delay = split_need_result_delay(tmp, line)
res = Process(name, build_process_dic(need), build_process_dic(result), delay)
# Invalid elem
elif not tmp[-1].isdigit():
sys.exit("Error with \033[4m{}\033[0m, invalid element.".format(line))
return res
class Stock:
"""
Stock elem associated Class
-> name is obviously the stock name
-> qty is the quantity available for this stock
"""
def __init__(self, name, qty):
self.name = name
self.qty = qty
def __str__(self):
return '\033[1mStock\033[0m -> \033[38;5;155m{}\033[0m : {}'.format(self.name, self.qty)
def __eq__(self, other):
return self.name == other.name and self.qty == other.qty
class Process:
"""
Process elem associated Class
-> name is obviously the process name
-> need is a list of stocks (name & qty) needed to run this process
-> result is a list of resulting stocks after running the process
-> delay is the delay needed to run the process
"""
def __init__(self, name, need, result, delay):
self.name = name
self.need = need
self.result = result
self.delay = delay
def __str__(self):
return '\033[38;5;74m{}\033[0m - \033[1mneeds\033[0m : {} -> \033[1mresult\033[0m : {} - \033[1mdelay\033[0m : {}'\
.format(self.name, self.need, self.result, self.delay)
def __eq__(self, other):
return self.name == other.name and \
self.delay == other.delay and \
self.need == other.need and \
self.result == other.result
class Optimize:
"""
Optimize elem associated Class
-> opti_elems is a list of name associated with what is
to optimize, like client and time
"""
def __init__(self, elems):
self.opti_elems = [i for i in elems]
def __str__(self):
return '\033[1mOptimize\033[0m -> \033[38;5;218m{}\033[0m'.format(str(self.opti_elems).replace('[', '').replace(']', ''))
def __eq__(self, other):
return self.opti_elems == other.opti_elems
| 3.015625
| 3
|
templatetags/myfilters.py
|
RoGryza/blog
| 0
|
12775119
|
<filename>templatetags/myfilters.py
from statik.templatetags import register
@register.filter(name='localized_date')
def localized_date(value, lang):
months = lang.months.split(',')
month = months[value.month - 1]
fmt = str(lang.date_format).replace('%b', month)
return value.strftime(fmt)
| 2.46875
| 2
|
project_code/topology_getter/tools.py
|
statnett/relevant_assets
| 1
|
12775120
|
import datetime
import pickle
from enum import Enum
from decorator import decorator
def time_this(fn):
"""
This decorator time the input function :func:`fn`
"""
def timed_fn(fn, *args, **kwargs):
time1 = datetime.datetime.now()
result = fn(*args, **kwargs)
calc_time = datetime.datetime.now() - time1
print('%s execution time: %s.' % (fn.__name__, str(calc_time)))
return result
return decorator(timed_fn, fn)
class RaspEnum(Enum):
def __str__(self):
return self.value[1]
def get_index(self):
return self.value[0]
@classmethod
def get_enum(cls, index):
e = [e.value for e in cls if e.value[0] == index][0]
return cls.__new__(cls, e)
@classmethod
def enum_from_string(cls, index):
e = [e.value for e in cls if e.value[1] == index][0]
return cls.__new__(cls, e)
@classmethod
def enum_from_name_string(cls, name):
e = [e.value for e in cls if e.name == name][0]
return cls.__new__(cls, e)
def __ge__(self, other):
if self.__class__ is other.__class__:
return self.value[0] >= other.value[0]
return NotImplemented
def __gt__(self, other):
if self.__class__ is other.__class__:
return self.value[0] > other.value[0]
return NotImplemented
def __le__(self, other):
if self.__class__ is other.__class__:
return self.value[0] <= other.value[0]
return NotImplemented
def __lt__(self, other):
if self.__class__ is other.__class__:
return self.value[0] < other.value[0]
return NotImplemented
def write_to_pickle(file_name, data, file_path=r'c:\temp'):
with open(file_path + '\\' + file_name, 'wb') as f:
pickle.dump(data, f, protocol=2)
def read_data(file_name, file_path=r'c:\temp'):
with open(file_path + '\\' + file_name, 'rb') as f:
data = pickle.load(f)
return data
| 3.21875
| 3
|
src/flowket/machines/simple_conv_net_autoregressive_1D.py
|
vigsterkr/FlowKet
| 21
|
12775121
|
from .abstract_machine import AutoNormalizedAutoregressiveMachine
from ..deepar.layers import ToFloat32, DownShiftLayer, ExpandInputDim, WeightNormalization
from ..layers import VectorToComplexNumber
from tensorflow.keras.layers import Activation, Conv1D, ZeroPadding1D, Activation, Add
def causal_conv_1d(x, filters, kernel_size, weights_normalization, dilation_rate=1, activation=None, skip_connection=None):
padding = kernel_size + (kernel_size - 1) * (dilation_rate - 1) - 1
if padding > 0:
x = ZeroPadding1D(padding=(padding, 0))(x)
conv_layer = Conv1D(filters=filters, kernel_size=kernel_size, strides=1, dilation_rate=dilation_rate)
if weights_normalization:
conv_layer = WeightNormalization(conv_layer)
x = conv_layer(x)
if skip_connection is not None:
x = Add()([x, skip_connection])
if activation is not None:
x = Activation(activation)(x)
return x
class SimpleConvNetAutoregressive1D(AutoNormalizedAutoregressiveMachine):
"""docstring for ConvNetAutoregressive1D"""
def __init__(self, keras_input_layer, depth, num_of_channels, kernel_size=3,
use_dilation=True, add_skip_connections=False, max_dilation_rate=None, activation='relu',
weights_normalization=True, should_expand_input_dim=True, **kwargs):
self.depth = depth
self.num_of_channels = num_of_channels
self.kernel_size = kernel_size
self.use_dilation = use_dilation
self.add_skip_connections = add_skip_connections
self.max_dilation_rate = max_dilation_rate
self.activation = activation
self.weights_normalization = weights_normalization
self.should_expand_input_dim = should_expand_input_dim
self._build_unnormalized_conditional_log_wave_function(keras_input_layer)
super(SimpleConvNetAutoregressive1D, self).__init__(keras_input_layer, **kwargs)
@property
def unnormalized_conditional_log_wave_function(self):
return self._unnormalized_conditional_log_wave_function
def _build_unnormalized_conditional_log_wave_function(self, keras_input_layer):
dilation_rate = 1
x = keras_input_layer
if self.should_expand_input_dim:
x = ExpandInputDim()(x)
x = ToFloat32()(x)
for i in range(self.depth - 2):
skip_connection = x if self.add_skip_connections and i > 0 else None
x = causal_conv_1d(x, filters=self.num_of_channels,
kernel_size=self.kernel_size,
activation=self.activation,
weights_normalization=self.weights_normalization,
dilation_rate=dilation_rate, skip_connection=skip_connection)
if self.use_dilation:
if self.max_dilation_rate is not None and dilation_rate < self.max_dilation_rate:
dilation_rate *= 2
x = DownShiftLayer()(x)
x = causal_conv_1d(x, filters=4, kernel_size=1,
weights_normalization=self.weights_normalization)
self._unnormalized_conditional_log_wave_function = VectorToComplexNumber()(x)
| 2.4375
| 2
|
fb4_example/bootstrap_flask/exampleapp.py
|
tholzheim/pyFlaskBootstrap4
| 0
|
12775122
|
<filename>fb4_example/bootstrap_flask/exampleapp.py
# -*- coding: utf-8 -*-
import uuid
from fb4.app import AppWrap
from fb4.login_bp import LoginForm
from fb4.sqldb import db
from fb4.login_bp import LoginBluePrint
from fb4.sse_bp import SSE_BluePrint
from fb4.widgets import Link, Icon, Image, Menu, MenuItem, DropDownMenu, LodTable, DropZoneField, ButtonField
from flask import redirect,render_template, request, flash, Markup, url_for, abort
from flask_wtf import FlaskForm, CSRFProtect
from wtforms import BooleanField, DateField, DateTimeField, FieldList, FileField, \
FloatField, FormField, IntegerField, MultipleFileField, RadioField, SelectField, SelectMultipleField, \
StringField, SubmitField, TextAreaField, PasswordField
from wtforms.validators import DataRequired, Length
from sqlalchemy import Column
import sqlalchemy.types as types
from datetime import datetime, timedelta
import json
import os
import http.client
import re
import time
from sqlalchemy.ext.hybrid import hybrid_property
from werkzeug.utils import secure_filename
class ExampleForm(FlaskForm):
"""An example form that contains all the supported bootstrap style form fields."""
date = DateField(description="We'll never share your email with anyone else.") # add help text with `description`
datetime = DateTimeField(render_kw={'placeholder': 'this is placeholder'}) # add HTML attribute with `render_kw`
image = FileField(render_kw={'class': 'my-class'}) # add your class
option = RadioField(choices=[('dog', 'Dog'), ('cat', 'Cat'), ('bird', 'Bird'), ('alien', 'Alien')])
select = SelectField(choices=[('dog', 'Dog'), ('cat', 'Cat'), ('bird', 'Bird'), ('alien', 'Alien')])
selectmulti = SelectMultipleField(choices=[('dog', 'Dog'), ('cat', 'Cat'), ('bird', 'Bird'), ('alien', 'Alien')])
bio = TextAreaField()
title = StringField()
secret = PasswordField()
remember = BooleanField('Remember me')
submit = SubmitField()
class ButtonForm(FlaskForm):
username = StringField('Username', validators=[DataRequired(), Length(1, 20)])
submit = SubmitField()
delete = SubmitField()
cancel = SubmitField()
class TelephoneForm(FlaskForm):
country_code = IntegerField('Country Code')
area_code = IntegerField('Area Code/Exchange')
number = StringField('Number')
class IMForm(FlaskForm):
protocol = SelectField(choices=[('aim', 'AIM'), ('msn', 'MSN')])
username = StringField()
class ContactForm(FlaskForm):
first_name = StringField()
last_name = StringField()
mobile_phone = FormField(TelephoneForm)
office_phone = FormField(TelephoneForm)
emails = FieldList(StringField("Email"), min_entries=3)
im_accounts = FieldList(FormField(IMForm), min_entries=2)
class PingForm(FlaskForm):
host=SelectField(choices=[('facebook','www.facebook.com'),
('google','www.google.com'),
('IBM','www.ibm.com'),
('twitter','www.twitter.com'),
],
#https://stackoverflow.com/a/38157356/1497139
render_kw={"onchange":"this.form.submit()"}
)
pingState=StringField('ping state')
class IconSearchForm(FlaskForm):
search=StringField('search', render_kw={"onchange":"this.form.submit()"})
perPage=SelectField(choices=[('twenty','20'),
('fifty','50'),
('hundred','100'),
('twohundred','200'),
('all','all'),
],
#https://stackoverflow.com/a/38157356/1497139
render_kw={"onchange":"this.form.submit()"}
)
class UploadForm(FlaskForm):
'''
upload form example
'''
file = MultipleFileField('File(s) to Upload')
submit = SubmitField()
class DropZoneWidgetForm(FlaskForm):
dropzone = DropZoneField(id="TestDropZone")
fileName=StringField()
submit = ButtonField( )
class ExampleApp(AppWrap):
'''
flask app wrapped in class
'''
def __init__(self):
'''
Constructor
'''
scriptdir = os.path.dirname(os.path.abspath(__file__))
template_folder=scriptdir + '/templates'
super().__init__(template_folder=template_folder)
self.app.secret_key = 'dev'
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
# set default button style and size, will be overwritten by macro parameters
self.app.config['BOOTSTRAP_BTN_STYLE'] = 'primary'
self.app.config['BOOTSTRAP_BTN_SIZE'] = 'sm'
# app.config['BOOTSTRAP_BOOTSWATCH_THEME'] = 'lumen' # uncomment this line to test bootswatch theme
db.init_app(self.app)
self.db=db
self.csrf = CSRFProtect(self.app)
self.loginBluePrint=LoginBluePrint(self.app,'login')
self.loginBluePrint.hint="'try user: scott, password: <PASSWORD>'"
self.sseBluePrint=SSE_BluePrint(self.app,'sse')
app=self.app
#
# setup global handlers
#
@app.before_first_request
def before_first_request_func():
self.initDB()
#
# setup the RESTFUL routes for this application
#
@app.route('/')
def index():
return self.home()
@app.route('/form', methods=['GET', 'POST'])
def test_form():
return self.form()
@app.route('/upload', methods=['GET', 'POST'])
def test_upload():
return self.upload()
@app.route('/nav', methods=['GET', 'POST'])
def test_nav():
return self.nav()
@app.route('/pagination', methods=['GET', 'POST'])
def test_pagination():
return self.pagination()
@app.route('/static', methods=['GET', 'POST'])
def test_static():
return self.static()
@app.route('/startsse1', methods=['POST'])
def test_startSSE1():
return self.startSSE1()
@app.route('/flash', methods=['GET', 'POST'])
def test_flash():
return self.flash()
@app.route('/datatable')
def test_datatable():
return self.datatable()
@app.route('/table')
def test_table():
return self.table()
@app.route('/table/<message_id>/view')
def view_message(message_id):
return self.message_view(message_id)
@app.route('/table/<message_id>/edit')
def edit_message(message_id):
return self.message_edit(message_id)
@app.route('/table/<message_id>/delete', methods=['POST'])
def delete_message(message_id):
return self.message_delete(message_id)
@app.route('/icon')
def test_icon():
return self.icon()
@app.route('/widgets', methods=['GET', 'POST'])
def test_widgets():
return self.widgets()
@app.route('/ping',methods=['GET', 'POST'])
def test_ping():
return self.ping()
@app.route('/events')
def test_events():
return self.eventExample()
@app.route('/eventfeed')
def test_eventFeed():
return self.eventFeed()
@app.route('/progressfeed')
def test_progressFeed():
return self.progressFeed()
def initDB(self,limit=20):
'''
initialize the database
'''
self.db.drop_all()
self.db.create_all()
self.initUsers()
self.initMessages(limit)
self.initIcons()
def initUsers(self):
self.loginBluePrint.addUser(self.db,"scott","tiger2021",userid=100)
def initMessages(self,limit=20):
'''
create an initial set of message with the given limit
Args:
limit(int): the number of messages to create
'''
for i in range(limit):
m = Message(
text='Test message {}'.format(i+1),
author='Author {}'.format(i+1),
category='Category {}'.format(i+1),
create_time=4321*(i+1)
)
if i % 4:
m.draft = True
self.db.session.add(m)
self.db.session.commit()
def initIcons(self):
'''
initialize the icons
'''
iconNames=Icon.getBootstrapIconsNames()
for index,iconName in enumerate(iconNames):
bootstrapIcon=BootstrapIcon(id=iconName,index=index+1)
self.db.session.add(bootstrapIcon)
self.db.session.commit()
def getDisplayIcons(self,icons):
displayIcons=[]
for icon in icons:
displayIcons.append("%04d%s%s" % (icon.index,icon.icon,icon.link))
return displayIcons
def pagePing(self,host, path="/"):
""" This function retrieves the status code of a website by requesting
HEAD data from the host. This means that it only requests the headers.
If the host cannot be reached or something else goes wrong, it returns
False.
see https://stackoverflow.com/a/1949507/1497139
"""
startTime=time.time()
try:
conn = http.client.HTTPConnection(host)
conn.request("HEAD", path)
if re.match("^[23]\d\d$", str(conn.getresponse().status)):
state=True
except Exception:
state=False
elapsed=time.time()-startTime
return state,elapsed
def getTimeEvent(self):
'''
get the next time stamp
'''
time.sleep(1.0)
s=datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
return s
def progressFeed(self):
'''
feed progress info as json
'''
self.pc=0
def progress():
time.sleep(0.5)
self.pc=(self.pc+5) % 100
pcdict={"progress":self.pc}
return json.dumps(pcdict)
sse=self.sseBluePrint
return sse.streamFunc(progress)
def eventFeed(self):
'''
create a Server Sent Event Feed
'''
sse=self.sseBluePrint
# stream from the given function
return sse.streamFunc(self.getTimeEvent)
def startSSE1(self):
'''
start a Server Sent Event Feed
'''
if "channel" in request.form and "ssechannel" in request.form:
channel=request.form["channel"]
ssechannel=request.form["ssechannel"]
#pubsub=PubSub.forChannel(ssechannel)
sse=self.sseBluePrint
now=datetime.now()
limit=15
self.debug=True
# 0.5 secs per Job
timePerJob=1
for i in range(limit):
run_date=now+timedelta(seconds=timePerJob*i)
print("scheduling job %d for %s" % (i,run_date.isoformat()))
sse.scheduler.add_job(sse.publish, 'date',run_date=run_date,kwargs={"channel":ssechannel,"message":"message %d" %(i+1),"debug":self.debug})
return "%s started" % channel
else:
abort(501)
def eventExample(self):
gen = ({"id": i, "data": str(uuid.uuid1())} for i in range(150))
generator = self.sseBluePrint.streamDictGenerator(gen, slowdown=1)
return render_template("event.html", dictStreamdemo=generator)
def flash(self):
flash('A simple default alert—check it out!')
flash('A simple primary alert—check it out!', 'primary')
flash('A simple secondary alert—check it out!', 'secondary')
flash('A simple success alert—check it out!', 'success')
flash('A simple danger alert—check it out!', 'danger')
flash('A simple warning alert—check it out!', 'warning')
flash('A simple info alert—check it out!', 'info')
flash('A simple light alert—check it out!', 'light')
flash('A simple dark alert—check it out!', 'dark')
flash(Markup('A simple success alert with <a href="#" class="alert-link">an example link</a>. Give it a click if you like.'), 'success')
return render_template('flash.html')
def form(self):
form = LoginForm()
return render_template('form.html', form=form, telephone_form=TelephoneForm(), contact_form=ContactForm(), im_form=IMForm(), button_form=ButtonForm(), example_form=ExampleForm())
def upload(self):
'''
handle the uploading
'''
upload_form= UploadForm()
dropzone_form=DropZoneWidgetForm()
filenames=""
delim=""
if upload_form.validate_on_submit():
for file in upload_form.file.data:
file_filename = secure_filename(file.filename)
if file_filename == "":
file_filename="Test"
filePath=f'/tmp/{file_filename}'
with open(filePath, 'wb') as f:
f.write(file.read())
size=os.path.getsize(filePath)
filenames=f"{filenames}{delim}{file_filename}({size})"
delim="<br/>"
if filenames:
flash(Markup(filenames), 'info')
filenames=""
if dropzone_form.validate_on_submit():
for file in dropzone_form.dropzone.data:
file_filename = secure_filename(file.filename)
if file_filename == "":
file_filename="Test"
filePath=f'/tmp/{file_filename}'
with open(filePath, 'wb') as f:
f.write(file.read())
size=os.path.getsize(filePath)
filenames=f"{filenames}{delim}{file_filename}({size})"
delim="<br/>"
flash(f"File {file_filename} stored under {dropzone_form.fileName.data}")
return render_template('upload.html',upload_form=upload_form,dropzone_form=dropzone_form)
def getMenu(self):
menu=Menu()
for menuLink in self.getMenuLinks():
menu.addItem(MenuItem(menuLink.url,menuLink.title))
return menu
def getMenuLinks(self):
links=[
Link( url_for('test_form'),"Form"),
Link( url_for('test_upload'),"Upload"),
Link( url_for('test_nav'),"Nav"),
Link( url_for('test_pagination'),"Pagination"),
Link( url_for('test_ping'),"Ping"),
Link( url_for('test_events'),"Events"),
Link( url_for('test_static'),"Static"),
Link( url_for('test_flash'),"Flash Messages"),
Link( url_for('test_table'),"Table"),
Link( url_for('test_datatable'),"DataTable"),
Link( url_for('test_icon'),"Icon"),
Link( url_for('test_widgets'),"Widgets")
]
return links
def home(self):
menuLinks=self.getMenuLinks()
return render_template('index.html',menuLinks=menuLinks)
def icon(self):
return render_template('icon.html')
def message_delete(self,message_id):
message = Message.query.get(message_id)
if message:
db.session.delete(message)
db.session.commit()
return f'Message {message_id} has been deleted. Return to <a href="/table">table</a>.'
return f'Message {message_id} did not exist and could therefore not be deleted. Return to <a href="/table">table</a>.'
def message_edit(self,message_id):
message = Message.query.get(message_id)
if message:
message.draft = not message.draft
db.session.commit()
return f'Message {message_id} has been edited by toggling draft status. Return to <a href="/table">table</a>.'
return f'Message {message_id} did not exist and could therefore not be edited. Return to <a href="/table">table</a>.'
def message_view(self,message_id):
message = Message.query.get(message_id)
if message:
return f'Viewing {message_id} with text "{message.text}". Return to <a href="/table">table</a>.'
return f'Could not view message {message_id} as it does not exist. Return to <a href="/table">table</a>.'
def nav(self):
return render_template('nav.html')
def pagination(self):
'''
pagination example
Returns:
rendered html for pagination
'''
search_form=IconSearchForm()
perPageChoice=search_form.perPage.data
if perPageChoice is None:
perPageChoice="twenty"
choices=dict(search_form.perPage.choices)
perPageSelection=choices[perPageChoice]
search_form.perPage.data=perPageChoice
if perPageChoice=="all":
per_page=2000
else:
per_page=int(perPageSelection)
pagination=None
icons=None
if search_form.validate_on_submit() and search_form.search.data:
search="%{}%".format(search_form.search.data)
print("searching %s: " % search)
icons = BootstrapIcon.query.filter(BootstrapIcon.id.like(search)).all()
if icons is None:
page = request.args.get('page', 1, type=int)
pagination = BootstrapIcon.query.paginate(page, per_page=per_page)
icons = pagination.items
displayIcons=self.getDisplayIcons(icons)
return render_template('pagination.html', form=search_form,pagination=pagination, icons=displayIcons)
def ping(self):
'''
ping test
'''
ping_form=PingForm()
if ping_form.validate_on_submit():
choices=dict(ping_form.host.choices)
host=choices[ping_form.host.data]
state,pingTime=self.pagePing(host)
pingState="%s %5.0f ms" % ("✅" if state else "❌",pingTime*1000)
ping_form.pingState.data=pingState
pass
else:
ping_form.pingState=""
return render_template('ping.html',ping_form=ping_form)
def static(self):
'''
test static content
'''
return render_template('static.html')
def datatable(self):
'''
test data table
'''
icons=BootstrapIcon.query.all()
dictList=[]
for icon in icons:
dictList.append(icon.asDict())
return render_template('datatable.html',listOfDicts=dictList)
def table(self):
'''
test table
'''
page = request.args.get('page', 1, type=int)
pagination = Message.query.paginate(page, per_page=10)
messages = pagination.items
titles = [('id', '#'), ('text', 'Message'), ('author', 'Author'), ('category', 'Category'), ('draft', 'Draft'), ('create_time', 'Create Time')]
return render_template('table.html', messages=messages, titles=titles)
def widgets(self):
'''
test widgets
'''
dropDownMenu=DropDownMenu("Links")
dropDownMenu.addItem(Link("http://www.bitplan.com","BITPlan Website"))
dropDownMenu.addItem(Link("https://bootstrap-flask.readthedocs.io/","Docs"))
dropDownMenu.addItem(Link("https://github.com/WolfgangFahl/pyFlaskBootstrap4","github"))
dropDownMenu.addItem(Link("https://getbootstrap.com/","bootstrap"))
menu=Menu()
menu.addItem(MenuItem("http://wiki.bitplan.com","BITPlan Wiki",True))
menu.addItem(MenuItem("https://bootstrap-flask.readthedocs.io/","Docs"))
menu.addItem(MenuItem("https://github.com/WolfgangFahl/pyFlaskBootstrap4","github",))
menu.addItem(dropDownMenu)
lodDataGenerator=lambda n: [{'text':f'Text messaage {i}', 'author': f"Author {i}", "Category":f"Category {i}", "create time":datetime.now()+timedelta(days=i)} for i in range(n)]
lodTable=LodTable(lodDataGenerator(5))
lodDataTable=LodTable(lodDataGenerator(500), isDatatable=True)
widgetList=[
[
Link("https://github.com/WolfgangFahl/pyFlaskBootstrap4","pyFlaskBootstrap4","Extended Flask + Bootstrap4 Library"),
Link("http://wiki.bitplan.com/index.php/PyFlaskBootstrap4","Wiki","pyFlaskBootstrap4 wiki"),
Link("https://github.com/greyli/bootstrap-flask","bootstrap-flask","Flask + Bootstrap4 Library by <NAME>"),
Link("https://palletsprojects.com/p/flask/","flask","web application framework"),
Link("https://getbootstrap.com/","bootstrap","Open source web toolkit")
],
[
Image("https://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Tux.svg/299px-Tux.svg.png",alt="Tux",height=150,title='Tux - the Linux kernel penguin mascot'),
Image("https://upload.wikimedia.org/wikipedia/commons/thumb/e/e9/Eiffel_Tower_Paris.jpg/180px-Eiffel_Tower_Paris.jpg",alt="Eiffel Tower",height=150,title='Eiffel Tower, Paris'),
Image("https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/Croce-Mozart-Detail.jpg/185px-Croce-Mozart-Detail.jpg",alt="Mozart",height=150,title='Wolfgang Amadeus Mozart'),
Image("https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/The_Blue_Marble.jpg/240px-The_Blue_Marble.jpg",alt="Earth",width=150,title='Earth as seen from Apollo 17 mission')
],
[
Icon("award"),Icon("battery"),Icon("book"),Icon("heart"),
Icon("calculator",size=48),Icon("person",size=48,color='red'),
Icon("wifi",size=64),Icon("wrench",size=64)
],
[
menu
],
[
dropDownMenu
],
[
lodTable,
lodDataTable
]
]
return render_template('widgets.html',widgetList=widgetList)
# initialization of flask globals
# we can't help that these are needed and can't be wrapped
# since db.Model needs to be global the Message class is defined here
class Message(db.Model):
id = Column(types.Integer, primary_key=True)
text = Column(types.Text, nullable=False)
author = Column(types.String(100), nullable=False)
category = Column(types.String(100), nullable=False)
draft = Column(types.Boolean, default=False, nullable=False)
create_time = Column(types.Integer, nullable=False, unique=True)
# wget https://raw.githubusercontent.com/twbs/icons/main/bootstrap-icons.svg
# xq .svg bootstrap-icons.svg | grep -v http | sed 's/@//' | jq .symbol[].id | cut -d'"' -f2 | awk ' { if ( length > x ) { x = length; y = $0 } }END{ print y; print x }'
# file-earmark-spreadsheet-fill
# 29
class BootstrapIcon(db.Model):
id=Column(types.String(30), primary_key=True)
index=Column(types.Integer)
@hybrid_property
def url(self):
myUrl="https://icons.getbootstrap.com/icons/%s/" % self.id
return myUrl
@hybrid_property
def link(self):
myLink=Link(self.url,self.id)
return myLink
@hybrid_property
def icon(self):
myIcon=Icon(self.id)
myIcon.userdata['#']=self.index
return myIcon
def asDict(self):
myDict={
'link': self.link,
'icon': self.icon
}
return myDict
#
# Command line entry point
#
if __name__ == '__main__':
ea=ExampleApp()
parser=ea.getParser("Flask + Bootstrap4 demo application for bootstrap-flask")
args=parser.parse_args()
# allow remote debugging if specified so on command line
ea.optionalDebug(args)
ea.run(args)
| 2.25
| 2
|
docs/load_accessions.py
|
detrout/htsworkflow
| 0
|
12775123
|
<reponame>detrout/htsworkflow<gh_stars>0
"""We have many accessions for our libraries,
our data isn't really part of the htsworkflow project
so it seemed unnecessary to put it in the normal migrations
"""
from datetime import datetime
import os
import socket
os.environ.setdefault(
"DJANGO_SETTINGS_MODULE",
"htsworkflow.settings.{}".format(socket.gethostname()))
import django
django.setup()
from samples.models import (
AccessionAgency,
Library,
LibraryAccession
)
def load_encode3_accessions():
data = [
('02973', 'ENCLB661EBH', '2013-12-31T01:24:29.450163+0000'),
('10007', 'ENCLB372ZZZ', '2013-09-13T13:31:00.667863-0800'),
('10065', 'ENCLB350ZZZ', '2013-09-13T13:31:00.711427-0800'),
('10135', 'ENCLB371ZZZ', '2013-09-13T13:31:00.800862-0800'),
('10150', 'ENCLB375ZZZ', '2013-09-13T13:31:00.845686-0800'),
('10158', 'ENCLB349ZZZ', '2013-09-13T13:31:00.888358-0800'),
('10296', 'ENCLB326ZZZ', '2013-09-13T13:31:01.050362-0800'),
('10330', 'ENCLB316ZZZ', '2013-09-13T13:31:01.094821-0800'),
('10331', 'ENCLB312ZZZ', '2013-09-13T13:31:01.138188-0800'),
('10333', 'ENCLB348ZZZ', '2013-09-13T13:31:01.182426-0800'),
('10335', 'ENCLB325ZZZ', '2013-09-13T13:31:01.226356-0800'),
('10409', 'ENCLB335ZZZ', '2013-09-13T13:31:01.268879-0800'),
('10409', 'ENCLB373ZZZ', '2013-09-13T13:31:03.237846-0800'),
('10481', 'ENCLB328ZZZ', '2013-09-13T13:31:01.312917-0800'),
('10502', 'ENCLB322ZZZ', '2013-09-13T13:31:01.357314-0800'),
('10506', 'ENCLB354ZZZ', '2013-09-13T13:31:01.402055-0800'),
('10515', 'ENCLB150CGC', '2013-12-31T01:24:31.329052+0000'),
('10516', 'ENCLB858EYY', '2014-02-11T04:54:55.778298+0000'),
('10517', 'ENCLB296STQ', '2013-12-31T01:24:31.650260+0000'),
('10536', 'ENCLB317ZZZ', '2013-09-13T13:31:01.484966-0800'),
('10565', 'ENCLB700LMU', '2013-12-31T01:24:31.490950+0000'),
('10567', 'ENCLB912OTZ', '2013-12-31T01:24:31.813954+0000'),
('10599', 'ENCLB329ZZZ', '2013-09-13T13:31:01.589610-0800'),
('10703', 'ENCLB347ZZZ', '2013-09-13T13:31:01.634288-0800'),
('10704', 'ENCLB353ZZZ', '2013-09-13T13:31:01.678096-0800'),
('10874', 'ENCLB211VHB', '2013-12-31T00:56:50.185938+0000'),
('10876', 'ENCLB827ADT', '2014-02-11T04:54:56.056039+0000'),
('10878', 'ENCLB596OCH', '2013-12-31T01:24:32.312287+0000'),
('10879', 'ENCLB285RFV', '2013-12-31T01:24:32.481428+0000'),
('10881', 'ENCLB928ZOL', '2013-12-31T01:24:31.988425+0000'),
('10882', 'ENCLB070EUV', '2013-12-31T01:24:32.157600+0000'),
('10883', 'ENCLB553XIA', '2013-12-31T00:56:50.961345+0000'),
('10884', 'ENCLB439WFS', '2013-12-31T01:24:32.695166+0000'),
('10885', 'ENCLB369MMK', '2013-12-31T00:56:51.214725+0000'),
('10947', 'ENCLB184USD', '2014-02-11T04:54:52.964669+0000'),
('10985', 'ENCLB359ZZZ', '2013-09-13T13:31:02.337847-0800'),
('10986', 'ENCLB356ZZZ', '2013-09-13T13:31:02.556929-0800'),
('11007', 'ENCLB866SQE', '2014-02-11T04:54:52.164787+0000'),
('11008', 'ENCLB424IFK', '2014-02-11T04:54:51.864439+0000'),
('11009', 'ENCLB205QXO', '2015-01-15T19:40:15.525219+0000'),
('11010', 'ENCLB529ELW', '2014-02-11T04:54:51.647823+0000'),
('11011', 'ENCLB732DFW', '2014-02-11T04:54:51.042384+0000'),
('11038', 'ENCLB857ING', '2013-12-31T01:24:29.125690+0000'),
('11039', 'ENCLB637FKG', '2013-12-31T01:24:29.779715+0000'),
('11154', 'ENCLB358ZZZ', '2013-09-13T13:31:02.792781-0800'),
('11155', 'ENCLB357ZZZ', '2013-09-13T13:31:02.954320-0800'),
('11204', 'ENCLB625YJM', '2014-02-11T04:54:55.290109+0000'),
('11206', 'ENCLB043WCL', '2014-02-11T04:54:53.934271+0000'),
('11207', 'ENCLB540GQH', '2014-02-11T04:54:54.151840+0000'),
('11208', 'ENCLB267LXR', '2014-02-11T04:54:54.367250+0000'),
('11209', 'ENCLB334AQY', '2014-02-11T04:54:54.659774+0000'),
('11210', 'ENCLB267HUY', '2014-02-11T04:54:54.901232+0000'),
('11286', 'ENCLB227WEO', '2013-12-31T00:56:50.365755+0000'),
('11288', 'ENCLB764TBI', '2013-12-31T00:56:50.539923+0000'),
('11289', 'ENCLB221REA', '2013-12-31T00:56:50.771930+0000'),
('11565', 'ENCLB332ZZZ', '2013-09-13T13:31:03.112170-0800'),
('11581', 'ENCLB794RXE', '2013-12-31T01:24:31.159562+0000'),
('11582', 'ENCLB445LWQ', '2013-12-31T01:24:30.715684+0000'),
('11584', 'ENCLB866FVU', '2013-12-31T01:24:30.539689+0000'),
('11585', 'ENCLB415HFJ', '2013-12-31T01:24:30.323719+0000'),
('11586', 'ENCLB170HBR', '2013-12-31T01:24:32.842478+0000'),
('11587', 'ENCLB271DFX', '2013-12-31T00:56:49.784310+0000'),
('11588', 'ENCLB224GWZ', '2013-12-31T00:56:50.002023+0000'),
('11612', 'ENCLB370ZZZ', '2013-09-13T13:31:03.835164-0800'),
('11612', 'ENCLB370ZZZ', '2013-09-13T13:31:03.835164-0800'),
('11621', 'ENCLB282WJS', '2013-12-31T00:56:49.527454+0000'),
('11622', 'ENCLB379BUZ', '2013-12-31T00:56:49.274381+0000'),
('11638', 'ENCLB507FSU', '2015-03-12T23:49:04.901543+0000'),
('11644', 'ENCLB341ZZZ', '2013-09-13T13:31:04.092318-0800'),
('11653', 'ENCLB344ZZZ', '2013-09-13T13:31:04.212140-0800'),
('11669', 'ENCLB321ZZZ', '2013-09-13T13:31:04.327003-0800'),
('11670', 'ENCLB715BMJ', '2015-03-12T23:18:09.561375+0000'),
('11682', 'ENCLB331ZZZ', '2013-09-13T13:31:04.445816-0800'),
('11697', 'ENCLB314ZZZ', '2013-09-13T13:31:04.621147-0800'),
('11718', 'ENCLB327ZZZ', '2013-09-13T13:31:04.713973-0800'),
('11719', 'ENCLB330ZZZ', '2013-09-13T13:31:04.755910-0800'),
('11719', 'ENCLB373ZZZ', '2013-09-13T13:31:03.237846-0800'),
('11832', 'ENCLB318ZZZ', '2013-09-13T13:31:04.798657-0800'),
('11847', 'ENCLB345ZZZ', '2013-09-13T13:31:04.842142-0800'),
('11905', 'ENCLB320ZZZ', '2013-09-13T13:31:04.885807-0800'),
('11906', 'ENCLB315ZZZ', '2013-09-13T13:31:04.927936-0800'),
('11907', 'ENCLB313ZZZ', '2013-09-13T13:31:04.970793-0800'),
('11923', 'ENCLB346ZZZ', '2013-09-13T13:31:05.014078-0800'),
('11924', 'ENCLB343ZZZ', '2013-09-13T13:31:05.057237-0800'),
('11926', 'ENCLB342ZZZ', '2013-09-13T13:31:05.098878-0800'),
('11927', 'ENCLB351ZZZ', '2013-09-13T13:31:05.142104-0800'),
('11942', 'ENCLB340ZZZ', '2013-09-13T13:31:05.185199-0800'),
('11942', 'ENCLB374ZZZ', '2013-09-13T13:31:00.932762-0800'),
('11956', 'ENCLB323ZZZ', '2013-09-13T13:31:05.229141-0800'),
('11957', 'ENCLB319ZZZ', '2013-09-13T13:31:05.271096-0800'),
('12096', 'ENCLB330KCB', '2013-12-31T01:24:29.929490+0000'),
('12097', 'ENCLB308ZDI', '2013-12-31T01:24:30.117992+0000'),
('12098', 'ENCLB849ZXB', '2013-12-31T01:24:30.951897+0000'),
('12517', 'ENCLB482LEX', '2014-04-17T22:46:52.690510+0000'),
('12518', 'ENCLB898RJN', '2014-04-17T22:46:52.789971+0000'),
('13024', 'ENCLB386HBI', '2014-04-17T22:46:51.828778+0000'),
('13025', 'ENCLB976CMA', '2014-04-17T22:46:51.909420+0000'),
('13262', 'ENCLB164LQL', '2014-04-17T22:46:51.996269+0000'),
('13263', 'ENCLB621DLJ', '2014-04-17T22:46:52.081511+0000'),
('13274', 'ENCLB036MBQ', '2014-04-17T22:46:52.331729+0000'),
('13275', 'ENCLB284CYK', '2014-04-17T22:46:52.424102+0000'),
('13280', 'ENCLB187EEQ', '2014-04-17T22:46:56.606142+0000'),
('13281', 'ENCLB146LAW', '2014-04-17T22:46:56.763676+0000'),
('13282', 'ENCLB267CXI', '2014-04-17T22:46:57.686887+0000'),
('13283', 'ENCLB198OUV', '2014-04-17T22:46:57.765163+0000'),
('13284', 'ENCLB319PGU', '2014-04-17T22:46:57.859868+0000'),
('13285', 'ENCLB391GZT', '2014-04-17T22:46:57.942156+0000'),
('13286', 'ENCLB714NCU', '2014-04-17T22:46:58.029639+0000'),
('13287', 'ENCLB868NQU', '2014-04-17T22:46:58.123540+0000'),
('13288', 'ENCLB264YKE', '2014-04-17T22:46:58.206637+0000'),
('13289', 'ENCLB206JYT', '2014-04-17T22:46:58.292642+0000'),
('13290', 'ENCLB476CZO', '2014-04-17T22:46:58.374543+0000'),
('13291', 'ENCLB402YMB', '2014-04-17T22:46:58.456242+0000'),
('13292', 'ENCLB211FCW', '2014-04-17T22:46:56.889940+0000'),
('13294', 'ENCLB283IJI', '2014-04-17T22:46:57.082795+0000'),
('13295', 'ENCLB720ZUM', '2014-04-17T22:46:57.198472+0000'),
('13296', 'ENCLB108EAP', '2014-04-17T22:46:57.341596+0000'),
('13297', 'ENCLB882HPA', '2014-04-17T22:46:57.428995+0000'),
('13298', 'ENCLB804XTY', '2014-04-17T22:46:57.507323+0000'),
('13299', 'ENCLB242XIT', '2014-04-17T22:46:57.604855+0000'),
('13300', 'ENCLB550GYC', '2014-04-17T22:46:52.512366+0000'),
('13301', 'ENCLB576ZGP', '2014-04-17T22:46:52.601612+0000'),
('13347', 'ENCLB928LID', '2014-04-17T22:46:52.162858+0000'),
('13349', 'ENCLB532KHK', '2014-04-17T22:46:52.248810+0000'),
('13413', 'ENCLB510UJB', '2014-12-16T00:45:13.360830+0000'),
('13414', 'ENCLB414SJG', '2014-12-16T00:45:13.800356+0000'),
('13415', 'ENCLB569DAO', '2014-12-16T00:45:14.213313+0000'),
('13416', 'ENCLB193ILA', '2014-12-16T00:45:14.431853+0000'),
('13417', 'ENCLB578MIX', '2014-12-16T00:45:14.860425+0000'),
('13418', 'ENCLB322YDP', '2014-12-16T00:45:15.320136+0000'),
('13419', 'ENCLB921XPI', '2014-12-16T00:45:16.561156+0000'),
('13420', 'ENCLB133ICO', '2014-12-16T00:45:16.784349+0000'),
('13421', 'ENCLB541QCS', '2014-12-16T00:45:17.049659+0000'),
('13422', 'ENCLB711HMD', '2014-12-16T00:45:17.306141+0000'),
('13423', 'ENCLB036AMX', '2014-12-16T00:45:17.587710+0000'),
('13424', 'ENCLB641AYP', '2014-12-16T00:45:18.075095+0000'),
('13425', 'ENCLB042QFS', '2014-12-16T00:45:18.620202+0000'),
('13426', 'ENCLB507MOC', '2014-12-16T00:45:19.791431+0000'),
('13427', 'ENCLB442ZCO', '2014-12-16T00:45:20.402307+0000'),
('13428', 'ENCLB714KUY', '2014-12-16T00:45:20.848934+0000'),
('13429', 'ENCLB243CVS', '2014-12-16T00:45:21.329370+0000'),
('13430', 'ENCLB204EWE', '2014-12-16T00:45:22.235057+0000'),
('13431', 'ENCLB751POF', '2014-12-16T00:45:23.092374+0000'),
('13432', 'ENCLB729FQY', '2014-12-16T00:45:23.458123+0000'),
('13433', 'ENCLB988OPM', '2014-12-16T00:45:23.707750+0000'),
('13435', 'ENCLB981WTU', '2014-12-16T00:45:24.273572+0000'),
('13436', 'ENCLB364NZB', '2014-12-16T00:45:25.243385+0000'),
('13437', 'ENCLB461BIJ', '2014-12-16T00:45:25.696471+0000'),
('13438', 'ENCLB580JUS', '2014-12-16T00:45:26.678862+0000'),
('13439', 'ENCLB318YQB', '2014-12-16T00:45:27.109024+0000'),
('13440', 'ENCLB407NSA', '2014-12-16T00:45:27.519366+0000'),
('13619', 'ENCLB901PGF', '2014-04-17T22:46:51.257931+0000'),
('13620', 'ENCLB392ZIG', '2014-04-17T22:46:51.468689+0000'),
('13622', 'ENCLB426EUN', '2014-04-17T22:46:51.379932+0000'),
('13623', 'ENCLB036TZY', '2014-04-17T22:46:51.581073+0000'),
('13625', 'ENCLB331AUZ', '2014-04-17T22:46:52.874393+0000'),
('13626', 'ENCLB327MTR', '2014-04-17T22:46:52.954204+0000'),
('13627', 'ENCLB228BIT', '2014-04-17T22:46:53.033480+0000'),
('13628', 'ENCLB641KNK', '2014-04-17T22:46:53.114120+0000'),
('13629', 'ENCLB403JBC', '2014-04-17T22:46:53.192762+0000'),
('13630', 'ENCLB804XKW', '2014-04-17T22:46:53.273136+0000'),
('13631', 'ENCLB087SVF', '2014-04-17T22:46:53.371845+0000'),
('13632', 'ENCLB747ZHK', '2014-04-17T22:46:53.457184+0000'),
('13633', 'ENCLB710XHU', '2014-04-17T22:46:53.538836+0000'),
('13634', 'ENCLB211OUD', '2014-04-17T22:46:53.615476+0000'),
('13635', 'ENCLB222MSP', '2014-04-17T22:46:53.715943+0000'),
('13636', 'ENCLB619TYA', '2014-04-17T22:46:53.884920+0000'),
('13637', 'ENCLB350NUB', '2014-04-17T22:46:53.980565+0000'),
('13638', 'ENCLB257OVB', '2014-04-17T22:46:54.073274+0000'),
('13639', 'ENCLB218HBM', '2014-04-17T22:46:54.155566+0000'),
('13640', 'ENCLB617JJG', '2014-04-17T22:46:54.244908+0000'),
('13641', 'ENCLB876ZIU', '2014-04-17T22:46:54.340786+0000'),
('13642', 'ENCLB552DLJ', '2014-04-17T22:46:54.430325+0000'),
('13643', 'ENCLB509KSM', '2014-04-17T22:46:54.529638+0000'),
('13644', 'ENCLB632SOL', '2014-04-17T22:46:54.617599+0000'),
('13645', 'ENCLB678KFT', '2014-04-17T22:46:54.699948+0000'),
('13646', 'ENCLB432EQY', '2014-04-17T22:46:54.778444+0000'),
('13647', 'ENCLB546SWD', '2014-04-17T22:46:54.858448+0000'),
('13648', 'ENCLB151CUN', '2014-04-17T22:46:54.937278+0000'),
('13649', 'ENCLB340FFP', '2014-04-17T22:46:55.022324+0000'),
('13650', 'ENCLB205HHN', '2014-04-17T22:46:55.098461+0000'),
('13651', 'ENCLB452IVF', '2014-04-17T22:46:55.184097+0000'),
('13652', 'ENCLB294BYK', '2014-04-17T22:46:55.262903+0000'),
('13653', 'ENCLB078UJF', '2014-04-17T22:46:55.341750+0000'),
('13654', 'ENCLB614VPZ', '2014-04-17T22:46:55.416400+0000'),
('13655', 'ENCLB611KGC', '2014-04-17T22:46:55.540595+0000'),
('13656', 'ENCLB462FVS', '2014-04-17T22:46:55.622867+0000'),
('13657', 'ENCLB562SNL', '2014-04-17T22:46:55.701402+0000'),
('13658', 'ENCLB147KNI', '2014-04-17T22:46:55.786033+0000'),
('13659', 'ENCLB904FTO', '2014-04-17T22:46:55.881860+0000'),
('13660', 'ENCLB857XKO', '2014-04-17T22:46:55.967510+0000'),
('13661', 'ENCLB720FXC', '2014-04-17T22:46:56.045285+0000'),
('13662', 'ENCLB632CVX', '2014-04-17T22:46:56.126475+0000'),
('13663', 'ENCLB229ENW', '2014-04-17T22:46:56.202064+0000'),
('13664', 'ENCLB912XSU', '2014-04-17T22:46:56.461112+0000'),
('13665', 'ENCLB915IHV', '2014-04-17T22:46:51.664093+0000'),
('13666', 'ENCLB204VYG', '2014-04-17T22:46:51.747073+0000'),
('13711', 'ENCLB043ZZZ', '2013-09-13T13:31:21.704089-0800'),
('13712', 'ENCLB044ZZZ', '2013-09-13T13:31:21.995955-0800'),
('13713', 'ENCLB045ZZZ', '2013-09-13T13:31:21.121478-0800'),
('13714', 'ENCLB046ZZZ', '2013-09-13T13:31:19.986238-0800'),
('13715', 'ENCLB061ZZZ', '2013-09-13T13:31:26.233894-0800'),
('13716', 'ENCLB062ZZZ', '2013-09-13T13:31:21.394322-0800'),
('13717', 'ENCLB063ZZZ', '2013-09-13T13:31:22.543146-0800'),
('13718', 'ENCLB064ZZZ', '2013-09-13T13:31:26.615177-0800'),
('14485', 'ENCLB463KOX', '2014-07-30T22:13:29.658606+0000'),
('14486', 'ENCLB941VYE', '2014-07-30T22:13:30.865419+0000'),
('14487', 'ENCLB237OAE', '2014-07-30T22:13:32.006665+0000'),
('14488', 'ENCLB171NYD', '2014-07-30T22:13:32.876751+0000'),
('14495', 'ENCLB719BQO', '2014-07-30T22:13:34.234738+0000'),
('14499', 'ENCLB356IIP', '2014-07-30T22:13:35.356726+0000'),
('14501', 'ENCLB304LFK', '2014-07-30T22:13:36.682522+0000'),
('14626', 'ENCLB766UOB', '2014-07-30T22:13:37.751613+0000'),
('14627', 'ENCLB238LIR', '2014-07-30T22:13:38.488612+0000'),
('14628', 'ENCLB652HKH', '2014-07-30T22:13:39.079002+0000'),
('14629', 'ENCLB181TCJ', '2014-07-30T22:13:39.612566+0000'),
('14630', 'ENCLB669AEL', '2014-07-30T22:13:40.373455+0000'),
('14631', 'ENCLB765HDK', '2014-07-30T22:13:41.017277+0000'),
('14632', 'ENCLB348BMH', '2014-07-30T22:13:41.597441+0000'),
('14633', 'ENCLB791CRT', '2014-07-30T22:13:42.145408+0000'),
('14634', 'ENCLB096HAH', '2014-07-30T22:13:42.871555+0000'),
('14635', 'ENCLB005HHX', '2014-07-30T22:13:43.673544+0000'),
('14636', 'ENCLB185MNU', '2014-07-30T22:13:44.242558+0000'),
('14653', 'ENCLB917PKP', '2014-07-22T21:16:09.466969+0000'),
('14654', 'ENCLB026BHP', '2014-07-22T21:16:36.206892+0000'),
('14655', 'ENCLB449LBZ', '2014-07-22T21:17:23.464962+0000'),
('14656', 'ENCLB905LVV', '2014-07-22T21:18:02.970100+0000'),
('15007', 'ENCLB835LVO', '2014-10-23T21:25:29.431984+0000'),
('15008', 'ENCLB471QMM', '2014-10-23T21:25:30.115849+0000'),
('15009', 'ENCLB659UFY', '2014-10-23T21:25:30.756915+0000'),
('15010', 'ENCLB426JKF', '2014-10-23T21:25:31.349525+0000'),
('15011', 'ENCLB454ZUS', '2014-10-23T21:25:32.065385+0000'),
('15012', 'ENCLB061TDP', '2014-10-23T21:25:32.733245+0000'),
('15013', 'ENCLB331VAA', '2014-10-23T21:25:33.732239+0000'),
('15014', 'ENCLB761PCA', '2014-10-23T21:25:34.879860+0000'),
('15015', 'ENCLB601XLL', '2014-10-23T21:25:35.898934+0000'),
('15016', 'ENCLB347FRI', '2014-10-23T21:25:36.765768+0000'),
('15017', 'ENCLB055KYV', '2014-10-23T21:25:37.604795+0000'),
('15018', 'ENCLB357KYA', '2014-10-23T21:25:38.564710+0000'),
('15019', 'ENCLB495FUZ', '2014-10-23T21:25:39.571864+0000'),
('15020', 'ENCLB979DZW', '2014-10-23T21:25:40.266492+0000'),
('15021', 'ENCLB162EJJ', '2014-10-23T21:25:41.173920+0000'),
('15022', 'ENCLB627LDZ', '2014-10-23T21:25:42.094283+0000'),
('15072', 'ENCLB336GOL', '2014-12-10T23:00:17.177956+0000'),
('15073', 'ENCLB964APA', '2014-12-10T23:00:17.550508+0000'),
('15074', 'ENCLB000EUQ', '2014-12-10T23:00:17.847597+0000'),
('15075', 'ENCLB597GRF', '2014-12-10T23:00:18.331925+0000'),
('15076', 'ENCLB989QNS', '2014-12-10T23:00:18.850689+0000'),
('15077', 'ENCLB567WFL', '2014-12-10T23:00:19.145366+0000'),
('15078', 'ENCLB254AMJ', '2014-12-10T23:00:19.420436+0000'),
('15079', 'ENCLB015WCJ', '2014-12-10T23:00:19.713321+0000'),
('15080', 'ENCLB200EFP', '2014-12-10T23:00:20.013418+0000'),
('15081', 'ENCLB278MMD', '2014-12-10T23:00:20.516203+0000'),
('15082', 'ENCLB819PZM', '2014-12-10T23:00:21.265192+0000'),
('15083', 'ENCLB220DVX', '2014-12-10T23:00:21.537679+0000'),
('15084', 'ENCLB906TKN', '2014-12-10T23:00:21.824807+0000'),
('15085', 'ENCLB949YQN', '2014-12-10T23:00:22.369090+0000'),
('15086', 'ENCLB584VFZ', '2014-12-10T23:00:23.080355+0000'),
('15087', 'ENCLB931ORG', '2014-12-10T23:00:23.626841+0000'),
('15088', 'ENCLB409LKR', '2014-12-10T23:00:24.173237+0000'),
('15089', 'ENCLB595PNG', '2014-12-10T23:00:24.554339+0000'),
('15090', 'ENCLB156EMG', '2014-12-10T23:00:25.382334+0000'),
('15091', 'ENCLB030NEC', '2014-12-10T23:00:26.743561+0000'),
('15092', 'ENCLB377PCX', '2014-12-10T23:00:28.034636+0000'),
('15093', 'ENCLB214UZM', '2014-12-10T23:00:28.526626+0000'),
('15094', 'ENCLB813BQB', '2014-12-10T23:00:29.029220+0000'),
('15095', 'ENCLB949WIO', '2014-12-10T23:00:29.343030+0000'),
('15241', 'ENCLB604HVJ', '2014-12-15T23:31:51.819207+0000'),
('15242', 'ENCLB357UPR', '2014-12-16T01:03:11.301778+0000'),
('15243', 'ENCLB521CXU', '2014-12-16T01:03:12.409916+0000'),
('15244', 'ENCLB969JPS', '2014-12-16T01:03:12.638218+0000'),
('15245', 'ENCLB893OOW', '2014-12-16T01:03:12.851385+0000'),
('15246', 'ENCLB730HDZ', '2014-12-16T01:03:13.532201+0000'),
('15247', 'ENCLB229LFR', '2014-12-16T01:03:13.888442+0000'),
('15248', 'ENCLB700NFV', '2014-12-16T01:03:14.123376+0000'),
('15256', 'ENCLB253LOZ', '2014-12-16T01:15:42.800855+0000'),
('15257', 'ENCLB857GUO', '2014-12-16T01:15:43.062548+0000'),
('15258', 'ENCLB891HIS', '2014-12-16T01:15:44.686534+0000'),
('15259', 'ENCLB587ZYP', '2014-12-16T01:15:45.407813+0000'),
('15260', 'ENCLB183ZSO', '2014-12-16T01:15:46.051548+0000'),
('15261', 'ENCLB809LQF', '2014-12-16T01:15:46.336850+0000'),
('15262', 'ENCLB112DAD', '2014-12-16T01:15:47.111994+0000'),
('15263', 'ENCLB417MEI', '2014-12-16T01:15:47.354094+0000'),
('15264', 'ENCLB035MJZ', '2014-12-16T01:15:47.581360+0000'),
('15265', 'ENCLB663WPK', '2014-12-16T01:15:47.823408+0000'),
('15266', 'ENCLB640QPM', '2014-12-16T01:15:48.094692+0000'),
('15267', 'ENCLB708TZF', '2014-12-16T01:15:48.518860+0000'),
('15268', 'ENCLB678FAD', '2014-12-16T01:15:49.637634+0000'),
('15269', 'ENCLB284YTS', '2014-12-16T01:15:50.317441+0000'),
('15270', 'ENCLB108LLJ', '2014-12-16T01:15:50.793306+0000'),
('15271', 'ENCLB518MNF', '2014-12-16T01:15:51.255098+0000'),
('15288', 'ENCLB435TVJ', '2014-12-16T01:15:53.184310+0000'),
('15289', 'ENCLB337IRK', '2014-12-16T01:15:54.829508+0000'),
('15290', 'ENCLB863GTU', '2014-12-16T01:15:56.220924+0000'),
('15291', 'ENCLB033OYZ', '2014-12-16T01:15:56.821935+0000'),
('15292', 'ENCLB577KCS', '2014-12-16T01:15:57.362521+0000'),
('15293', 'ENCLB950QWJ', '2014-12-16T01:15:58.109787+0000'),
('15294', 'ENCLB219UWV', '2014-12-16T01:15:58.782565+0000'),
('15295', 'ENCLB196QXY', '2014-12-16T01:15:59.455275+0000'),
('15296', 'ENCLB430RUN', '2014-12-16T01:16:00.122073+0000'),
('15297', 'ENCLB384GBY', '2014-12-16T01:16:00.929045+0000'),
('15298', 'ENCLB030QYZ', '2014-12-16T01:16:01.373251+0000'),
('15299', 'ENCLB721WMG', '2014-12-16T01:16:01.597127+0000'),
('15300', 'ENCLB359XUW', '2014-12-16T01:16:01.825260+0000'),
('15301', 'ENCLB807MQE', '2014-12-16T01:16:02.132204+0000'),
('15302', 'ENCLB462UWC', '2014-12-16T01:16:03.048372+0000'),
('15303', 'ENCLB296VEF', '2014-12-16T01:16:03.815641+0000'),
('15475', 'ENCLB266LCY', '2015-03-27T22:01:32.864613+0000'),
('15476', 'ENCLB055JUC', '2015-03-27T22:01:33.316038+0000'),
('15477', 'ENCLB080NNG', '2015-03-27T22:01:33.809928+0000'),
('15478', 'ENCLB180OTB', '2015-03-27T22:01:34.281900+0000'),
('15479', 'ENCLB274VUA', '2015-03-27T22:01:34.760956+0000'),
('15480', 'ENCLB441AFS', '2015-03-27T22:01:35.242213+0000'),
('15481', 'ENCLB790ZKD', '2015-03-27T22:01:35.693423+0000'),
('15482', 'ENCLB319NLX', '2015-03-27T22:01:36.114223+0000'),
('15483', 'ENCLB074REG', '2015-03-27T22:01:36.679913+0000'),
('15484', 'ENCLB415KPR', '2015-03-27T22:01:37.266549+0000'),
('15485', 'ENCLB658ICO', '2015-03-27T22:01:37.835601+0000'),
('15486', 'ENCLB741KQB', '2015-03-27T22:01:38.396352+0000'),
('15487', 'ENCLB810TRL', '2015-03-27T22:01:38.910449+0000'),
('15488', 'ENCLB544VIE', '2015-03-27T22:01:39.534590+0000'),
('15489', 'ENCLB370ZFK', '2015-03-27T22:01:40.115768+0000'),
('15490', 'ENCLB273BPC', '2015-03-27T22:01:40.746450+0000'),
('15491', 'ENCLB847UDV', '2015-03-27T22:01:41.366532+0000'),
('15492', 'ENCLB704CYQ', '2015-03-27T22:01:41.934480+0000'),
('15493', 'ENCLB318WHF', '2015-03-27T22:01:42.583021+0000'),
('15494', 'ENCLB590UZK', '2015-03-27T22:01:43.220918+0000'),
('15495', 'ENCLB260QNG', '2015-03-27T22:01:43.823840+0000'),
('15496', 'ENCLB817LXB', '2015-03-27T22:01:44.356874+0000'),
('15497', 'ENCLB169SNA', '2015-03-27T22:01:44.903888+0000'),
('15498', 'ENCLB459OYG', '2015-03-27T22:01:45.457150+0000'),
('15499', 'ENCLB217DSV', '2015-03-27T22:01:46.051760+0000'),
('15500', 'ENCLB159SLV', '2015-03-27T22:01:46.609807+0000'),
('15501', 'ENCLB022VFG', '2015-03-27T22:01:47.188586+0000'),
('15502', 'ENCLB416HZP', '2015-03-27T22:01:47.742894+0000'),
('15503', 'ENCLB556YSG', '2015-03-27T22:01:48.360245+0000'),
('15504', 'ENCLB803HJK', '2015-03-27T22:01:48.918921+0000'),
('SL2970', 'ENCLB871LCB', '2013-12-31T01:24:29.617351+0000'),
('SL2971', 'ENCLB503AOQ', '2013-12-31T01:24:29.290708+0000'),
]
encode = AccessionAgency.objects.get(name="ENCODE3")
for jumpgate_id, accession, created in data:
jumpgate_id = {
'SL2970': '02970',
'SL2971': '02971',
'SL2972': '02972',
}.get(jumpgate_id, jumpgate_id)
jumpgate = Library.objects.get(pk=jumpgate_id)
date_created = datetime.strptime(created, '%Y-%m-%dT%H:%M:%S.%f%z')
o = LibraryAccession(agency=encode,
library=jumpgate,
accession=accession,
created=date_created,)
o.save()
def main():
print('loading encode3 accessions')
load_encode3_accessions()
if __name__ == '__main__':
main()
| 1.890625
| 2
|
physionet-django/user/management/commands/loaddemo.py
|
T-CAIREM/physionet-build
| 0
|
12775124
|
"""
Command to:
- load all fixtures named 'demo-*.*'
- create copy the demo media files
This should only be called in a clean database, such as after
`resetdb` is run. This should generally only be used in
development environments.
"""
import os
import shutil
from django.conf import settings
from django.core.management import call_command
from django.core.management.base import BaseCommand
from physionet.utility import get_project_apps
from lightwave.views import DBCAL_FILE, ORIGINAL_DBCAL_FILE
class Command(BaseCommand):
def handle(self, *args, **options):
# If not in development, prompt warning messages twice
if 'development' not in os.environ['DJANGO_SETTINGS_MODULE']:
warning_messages = ['You are NOT in the development environment. Are you sure you want to insert demo data? [y/n]',
'The demo data will be mixed with existing data. Are you sure? [y/n]',
'Final warning. Are you ABSOLUTELY SURE? [y/n]']
for i in range(3):
choice = input(warning_messages[i]).lower()
if choice != 'y':
sys.exit('Exiting from load. No actions applied.')
print('Continuing loading demo data')
# Load licences and software languages
site_data_fixtures = os.path.join(settings.BASE_DIR, 'project',
'fixtures', 'site-data.json')
call_command('loaddata', site_data_fixtures, verbosity=1)
# Load fixtures for default project types
project_types_fixtures = os.path.join(settings.BASE_DIR, 'project',
'fixtures', 'project-types.json')
call_command('loaddata', project_types_fixtures, verbosity=1)
# Load fixtures for default sites
site_fixtures = os.path.join(settings.BASE_DIR, 'physionet',
'fixtures', 'sites.json')
call_command('loaddata', site_fixtures, verbosity=1)
# Load other app fixtures
project_apps = get_project_apps()
demo_fixtures = find_demo_fixtures(project_apps)
call_command('loaddata', *demo_fixtures, verbosity=1)
# Copy the demo media and static content
copy_demo_media()
copy_demo_static()
print('Copied demo media and static files.')
# Make symlink of wfdbcal for lightwave
if os.path.exists(ORIGINAL_DBCAL_FILE):
os.symlink(ORIGINAL_DBCAL_FILE, DBCAL_FILE)
def find_demo_fixtures(project_apps):
"""
Find non-empty demo fixtures
"""
demo_fixtures = []
for app in project_apps:
fixture = 'demo-{}'.format(app)
file_name = os.path.join(settings.BASE_DIR, app,
'fixtures', '{}.json'.format(fixture))
if os.path.exists(file_name) and open(file_name).read(4) != '[\n]\n':
demo_fixtures.append(fixture)
return demo_fixtures
def copy_demo_media():
"""
Copy the demo media files into the media root.
Copy all items from within the immediate subfolders of the demo
media root.
"""
demo_media_root = os.path.join(settings.DEMO_FILE_ROOT, 'media')
for subdir in os.listdir(demo_media_root):
demo_subdir = os.path.join(demo_media_root, subdir)
target_subdir = os.path.join(settings.MEDIA_ROOT, subdir)
for item in [i for i in os.listdir(demo_subdir) if i != '.gitkeep']:
shutil.copytree(os.path.join(demo_subdir, item),
os.path.join(target_subdir, item))
# Published project files should have been made read-only at
# the time of publication
ppdir = os.path.join(settings.MEDIA_ROOT, 'published-projects')
for dirpath, subdirs, files in os.walk(ppdir):
if dirpath != ppdir:
for f in files:
os.chmod(os.path.join(dirpath, f), 0o444)
for d in subdirs:
os.chmod(os.path.join(dirpath, d), 0o555)
def copy_demo_static():
"""
Copy the demo static files into the effective static root.
"""
demo_static_root = os.path.join(settings.DEMO_FILE_ROOT, 'static')
# Either the actual static root if defined, or the staticfiles_dirs
effective_static_root = settings.STATIC_ROOT if settings.STATIC_ROOT else settings.STATICFILES_DIRS[0]
for subdir in os.listdir(demo_static_root):
demo_subdir = os.path.join(demo_static_root, subdir)
target_subdir = os.path.join(effective_static_root, subdir)
for item in [i for i in os.listdir(demo_subdir) if i != '.gitkeep']:
shutil.copytree(os.path.join(demo_subdir, item),
os.path.join(target_subdir, item))
# Published project files should have been made read-only at
# the time of publication
ppdir = os.path.join(effective_static_root, 'published-projects')
for dirpath, subdirs, files in os.walk(ppdir):
if dirpath != ppdir:
for f in files:
os.chmod(os.path.join(dirpath, f), 0o444)
for d in subdirs:
os.chmod(os.path.join(dirpath, d), 0o555)
| 2.21875
| 2
|
common/replace-placeholders.py
|
dutradda/devtools
| 1
|
12775125
|
#!/usr/bin/env python3
import argparse
import re
def main(args):
with open(args.source) as file:
content = file.read()
for pattern, filename in re.findall(r'(\{!(.*)!\})', content):
with open(filename) as file:
match_content = file.read()
dest_content = re.sub(pattern, match_content, content)
with open(args.dest, mode='w') as file:
file.write(dest_content)
with open(args.dest) as file:
content = file.read()
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description="Replace placeholders with it's file contents"
)
parser.add_argument(
'source',
metavar='SOURCE',
type=str,
help='File to parse'
)
parser.add_argument(
'dest',
metavar='DEST',
type=str,
help='destination file'
)
args = parser.parse_args()
main(args)
| 3.328125
| 3
|
python/codingame/practice/community/the_greatest_number_python2.py
|
TGITS/programming-workouts
| 0
|
12775126
|
import sys
import math
# Auto-generated code below aims at helping you parse
# the standard input according to the problem statement.
# Write an action using print
# To debug: print >> sys.stderr, "Debug messages..."
n = int(raw_input())
dot = False
minus = False
numbers = []
characters = raw_input()
print >> sys.stderr, "characters : {}".format(characters)
for c in characters.split(' '):
if c == '.': #Est-ce que le caractere lu est un '.'
dot = True
elif c == '-': #Is this a - minus sign
minus = True
else : #Is this a number
numbers.append(int(c))
print >> sys.stderr, "numbers : {}".format(",".join(map(str,numbers)))
greatest = ""
number_of_zeros=numbers.count(0)
print >> sys.stderr, "number_of_zeros : {}".format(number_of_zeros)
if number_of_zeros == len(numbers):
greatest = "0"
else :
if minus: # On cherche a faire le nombre le plus petit possible en valeur absolue
numbers.sort()
greatest += '-'
del numbers[0:number_of_zeros]
if number_of_zeros > 0 and dot:
greatest += '0'
number_of_zeros -= 1
else:
greatest += str(numbers[0])
del numbers[0:1]
if dot:
greatest += '.'
if number_of_zeros > 0:
greatest += '0' * number_of_zeros
for n in numbers:
greatest += str(n)
else: #On cherche a faire le nombre le plus grand possible
numbers.sort(reverse=True)
if number_of_zeros > 0:
del numbers[-number_of_zeros:]
#qu'il y ait un '.' ou pas, s'il y des zeros, on fait un nombre sans partie decimale
for i in range(len(numbers)):
greatest += str(numbers[i])
if dot:
if number_of_zeros > 1:
greatest += '0' * (number_of_zeros - 1)
else:
greatest += '0' * number_of_zeros
print >> sys.stderr, "greatest : {}".format(greatest)
else:
if dot:
for i in range(len(numbers)-1):
greatest += str(numbers[i])
greatest += '.' + str(numbers[len(numbers)-1])
print >> sys.stderr, "greatest : {}".format(greatest)
else:
for i in range(len(numbers)):
greatest += str(numbers[i])
print >> sys.stderr, "greatest : {}".format(greatest)
print(greatest)
| 3.796875
| 4
|
tests/testapp/urls.py
|
niteshsinha17/openwisp-users
| 0
|
12775127
|
from django.urls import path
from . import views
urlpatterns = [
path('member_view', views.api_member_view, name='test_api_member_view'),
path('manager_view', views.api_manager_view, name='test_api_manager_view'),
path('owner_view', views.api_owner_view, name='test_api_owner_view'),
path('base_org_view', views.base_org_view, name='test_base_org_permission_view'),
path('org_field_view', views.org_field_view, name='test_organization_field_view'),
path('error_field_view', views.error_field_view, name='test_error_field_view'),
]
| 1.71875
| 2
|
predict_helper.py
|
Emad2018/aipnd-project
| 0
|
12775128
|
import time
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets, models
from collections import OrderedDict
from PIL import Image
import matplotlib.pyplot as plt
import json
import argparse
def load_checkpoint(checkpoint_path, model):
checkpoint = torch.load(checkpoint_path)
if(model == "vgg"):
nhu = checkpoint['nhu']
model = models.vgg11(pretrained=True)
for param in model.parameters():
param.requires_grad = False
classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(25088, nhu)),
('relu', nn.ReLU()),
('fc2', nn.Linear(nhu, 102)),
('output', nn.LogSoftmax(dim=1))
]))
model.classifier = classifier
model.load_state_dict(checkpoint['state_dict'])
model.class_to_idx = checkpoint['class_to_idx']
elif(model == "densenet"):
nhu = checkpoint['nhu']
model = models.densenet121(pretrained=True)
for param in model.parameters():
param.requires_grad = False
classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(1024, nhu)),
('relu', nn.ReLU()),
('fc2', nn.Linear(nhu, 102)),
('output', nn.LogSoftmax(dim=1))
]))
model.classifier = classifier
model.load_state_dict(checkpoint['state_dict'])
model.class_to_idx = checkpoint['class_to_idx']
return model
def process_image(image):
''' Scales, crops, and normalizes a PIL image for a PyTorch model,
returns an Numpy array
'''
pil_image = Image.open(image)
pil_image = pil_image.resize((256, 256))
width, height = pil_image.size # Get dimensions
left = (width - 224)/2
top = (height - 224)/2
right = (width + 224)/2
bottom = (height + 224)/2
pil_image = pil_image.crop((left, top, right, bottom))
pil_image = pil_image.convert('RGB')
np_image = np.array(pil_image)/255
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
np_image = (np_image-mean)/std
np_image = np_image.transpose((2, 0, 1))
return torch.from_numpy(np_image)
def predict(image_path, model, device="cpu", topk=5):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
print(device)
output_image = process_image(image_path).to(device)
image = torch.zeros([64, 3, 224, 224], dtype=torch.float64).to(device)
image += output_image.to(device)
model.to(device)
model.eval()
torch.no_grad()
logps = model.forward(image.float())
ps = torch.exp(logps)
probability, index = torch.topk(ps, topk, dim=1)
return probability.to(device), index.to(device)
def get_input_args():
"""
Retrieves and parses the 3 command line arguments provided by the user when
they run the program from a terminal window. This function uses Python's
argparse module to created and defined these 3 command line arguments. If
the user fails to provide some or all of the 3 arguments, then the default
values are used for the missing arguments.
Command Line Arguments:
1. Image Folder as --dir with default value 'flowers'
2. CNN Model Architecture as --arch with default value 'vgg'
3. GPU as --GPU with default value 'cpu'
This function returns these arguments as an ArgumentParser object.
Parameters:
None - simply using argparse module to create & store command line arguments
Returns:
parse_args() -data structure that stores the command line arguments object
"""
# Replace None with parser.parse_args() parsed argument collection that
# you created with this function
# Creates Argument Parser object named parser
parser = argparse.ArgumentParser()
# Argument 1: that's a path to a folder
parser.add_argument('input', type=str,
help='path to the image')
parser.add_argument('ckpdir', type=str,
help='path to the folder of check point')
parser.add_argument('--arch', type=str, default='vgg',
help='The Network architecture')
parser.add_argument('--gpu', type=bool, default=False,
help='gpu enable')
parser.add_argument('--topk', type=float, default=5,
help='topk')
parser.add_argument('--category_names', type=str, default='cat_to_name.json',
help='directory of jason file')
# Assigns variable in_args to parse_args()
in_args = parser.parse_args()
return in_args
| 2.453125
| 2
|
main.py
|
larabetul/blm2010
| 0
|
12775129
|
# Ad Soyad: <NAME> No: 180401041
#import numpy.matlib #Matrislerde kullanılabilir
from matrix_operations import matrix_transpose # gerekli matris işlemleri için fonksiyonların dahil edilmesi.
# D=A^T --> D= np.transpose(A) --> transpose kullanımı
from matrix_operations import matrix_multiplication # C=AxB(AB=C) --> C=np.dot(A,B) --> matrislerde çarpma işlemi
from matrix_operations import matrix_inverse # D=A^-1 --> D= np.linalg.inv --> matrisin tersinin alınması için..
from copy import copy #ilk veriyi kaybetmeden kopyası üzerinde işlem yapmak için kullanılır..
from __init__ import __data_file__ #veri girişi için kullandım , init=initialization(başlatma) ile daha kolay bir görünüm elde ettik..
from __init__ import __output_file__ #veri çıkışı için kullandım
import numpy as np # numpy artık np değişkeniyle ifade ediliyor..
import sys #dir(sys) sys.argv komutu, programın ismi ile birlikte, bu programa parametre olarak verilen değerleri de bir liste halinde saklıyor.
import os #gerek yok silinebilir
# import sys sayesinde %d,%s gibi C diline ait göstergelerle sayısal ifadelerimiz daha da kolaylaştı
'''
sys kullanımı ....--> en aşağıda arguments=sys.argv..
def çık():
print('Çıkılıyor...')
sys.exit() # programı kapanmaya zorlamak için kullanılabilir.
if len(sys.argv) < 2: #eğer parametre veya verilerde istenilenden fazlası veya azı varsa kullanılabilir
print('Gerekli parametreleri girmediniz!')
çık()
elif len(sys.argv) > 2: #sys.argv kullandığım parametreleri liste halinde tutar
print('Çok fazla parametre girdiniz!')
çık()
elif sys.argv[1] in ['-v', '-V']:
print('Program sürümü: 0.8')
else:
mesaj = 'Girdiğiniz parametre ({}) anlaşılamadı!'
print(mesaj.format(sys.argv[1]))
çık()
---> BU ŞEKİLDE YETERLİ DEĞİL DETAYLANMASI LAZIM..
'''
'''
class BColors:
ENDC = '\033[0m'-->kullanılır
BOLD = '\033[1m'-->??
UNDERLINE = '\033[4m'-->??
INACTIVE = '\033[90m'
FAIL = '\033[91m'-->kullanılır
OKGREEN = '\033[92m'
WARNING = '\033[93m'-->kullanılır
OKBLUE = '\033[94m'
HEADER = '\033[95m'
COMMENT = '\033[96m'
BLOCK = '\033[97m'
CODE = '\033[98m'
'''
class term_renkleri:
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
#BOLD = '\033[1m'
#UNDERLINE = '\033[4m'
#COMMENT = '\033[96m'
class process:#süreç
def __init__(self, veri_içerik: list): # init yapıcı(constructor) fonksiyondur , self parametresi zorunludur.
"""
Bu sınıf tüm ana işlemleri yürütür
: param veri_içerik: Bir veri listesi
"""
self.veri_ = veri_içerik
self.first_var = 0 #ilk varyasyon = 0 , başlangıc
self.last_var = len(self.veri_) #son varyasyon =len(self.veri)
self.grade_regression_result = None # regresyon iki ya da daha fazla değişken arasındaki değişimleri ölçmeye yarar.(Grafikler ile görselleşmesi sonucunda da anlaşılırlığı yükselir.)
self.results = list() #sonuçları listeye atacağız aşağıdaki işlemlerle
self.error_results = list() #hata sonuçları için yine bir boş liste kullanımı yapıldı.(for error results..)
def set_data_range(self, first=0, last=0, all_=False):
"""
Regresyon için veri aralığını ayarlama
: param first: Verilerin ilk dizini
: param last: Son dizin veri verileri
: param all_: Tüm verileri seç
: dönüş: Yok(None)
"""
if all_:#if dene
self.first_var = 0
self.last_var = len(self.veri_)
else:
self.first_var = first #ilk varyasyon ilk son v.. son
self.last_var = last
print(
term_renkleri.WARNING + "Veri aralığının %d dan %d a kadar ayarlanması!" % (self.first_var, self.last_var) + term_renkleri.ENDC)
# veri aralığının 0 dan 59 a ayarlaması gibi
def regression_for_grade(self, derece=0, no_print=False):#sınıf için regresyon
# çözüme(solution) ulaşmam için :
# X * çözümler = Y
# çözümler = (X_t * X)^-1 * X_t * Y
solution_matrix = np.zeros(shape=(derece + 1, 1), dtype=float)#çözelti matrix
x_matrix = np.zeros(shape=((self.last_var - self.first_var), derece + 1), dtype=float)
y_matrix = np.zeros(shape=((self.last_var - self.first_var), 1), dtype=float)
# Prepair matrixs matris hazırlanışı
y_index = 0
for i in range(0, (self.last_var - self.first_var)):
for j in range(0, x_matrix.shape[1]):
x_matrix[i][j] = pow(float(self.veri_[i + self.first_var]), j)
y_matrix[i][0] = float(y_index)
y_index += 1
x_trans_matrix = matrix_transpose(x_matrix) #transpozunun alınması
multi_matrix = matrix_multiplication(x_trans_matrix, x_matrix)#matris ile transpozunun alınması tersini alma işlemi
inversed_matrix = matrix_inverse(multi_matrix)#matrisin tersinin alınması
multi_two_matrix = matrix_multiplication(x_trans_matrix, y_matrix)
multi_three_matrix = matrix_multiplication(inversed_matrix, multi_two_matrix)
solution_matrix = multi_three_matrix
self.grade_regression_result = copy(solution_matrix)
self.results.append(self.grade_regression_result) #regresyon sonuçları listemize atıldı.. 1
to_printed = ""
to_printed += str(derece) + ". derece regresyon sonuçlarım : \n"
to_printed += str(self.grade_regression_result[0])
for i in range(1, derece + 1):
to_printed += " + " + str(self.grade_regression_result[i]) + "X"
to_printed += "^^" + str(i)
to_printed += " = Y"
if not no_print:
print(to_printed)
def calculate_most_usefull(self): #en yararlı olanı hesapla
for i in range(len(self.results)):
avarage = 0.0
y_index = 0
for x_data in self.veri_:
X = float(x_data)
Y = y_index
y_index += 1
total = 0.0
for j in self.results[i]:
total += float(j) * pow(X, j)
E = total - Y
avarage += E
avarage /= len(self.veri_)
self.error_results.append(avarage)
for i in range(len(self.error_results)):
if self.error_results[i] < 0:
self.error_results[i] *= -1
the_lowest_error = self.error_results[0]
the_lowest_error_index = 0
for i in range(len(self.error_results)):
if self.error_results[i] < the_lowest_error:
the_lowest_error = self.error_results[i]
the_lowest_error_index = i
print("Polinom bölgesindeki en düşük hata (aralıklar karşılaştırıldı): %d .derece regresyon ile E=%s"
% ((the_lowest_error_index + 1), the_lowest_error))
def veri_uzunluk(self): #verileri almak için fonksiyon
return len(self.veri_)
def kill_vars(self): #ölüm varyasyonu
self.grade_regression_result = None
self.results = list()
self.error_results = list()
def write_to_file(self, the_dir): #dosyaya yazma işlemi
with open(the_dir + "/%s" % __output_file__, "w") as fh:
to_printed = ""
for i in range(len(self.results)):
to_printed += str(i + 1) + " Reggression\t"
for j in range(len(self.results[i])):
to_printed += str(self.results[i][j]) + "X^^" + str(j) + "\t"
to_printed += "\n"
fh.write(to_printed)
print(term_renkleri.WARNING + "%s file generated!" % __output_file__ + term_renkleri.ENDC)
def main():
if arguman: # argüman(args)=sys.argv ataması ile ana listede parametre tutmayı tercih ettim.
print(term_renkleri.WARNING + "Argüman işleyici yok!" + term_renkleri.ENDC)
# Aslında buna gerek yok ,çünkü dosyam zaten var
yeni_veri = None
working_directory = os.getcwd()
try: #try exception yapısı bak, hata mesajı vermek için
with open(working_directory + "/%s" % __data_file__, "r") as fh:
string_format = fh.read()
a = string_format.splitlines()
# If last line of file is not /n son dosya satırı değilse
for i in range(len(a)):
if a[i] == "":
a.pop(len(a)-1)
yeni_veri = copy(a) #copy ile ana liste elemanları korundu..
except FileNotFoundError: #dosya bulunamadı hatası buna da gerek yok aslında
raise Exception("Dosya bulunamadı! %s file" % __data_file__)
if not yeni_veri: #dosya var ama veri yoksa verilecek mesaj
raise Exception("Dosya bulundu ancak okuma başarısız oldu. ")
print(term_renkleri.WARNING + "Dosya açıldı ve başarıyla okundu" + term_renkleri.ENDC)
#başarılı dosyaaçılması ve veriokunması durumu
print(term_renkleri.WARNING + "İlk soru başlangıç:" + term_renkleri.ENDC)
new_process = process(yeni_veri)
new_process.set_data_range(all_=True)
new_process.regression_for_grade(derece=1)
new_process.regression_for_grade(derece=2)
new_process.regression_for_grade(derece=3)
new_process.regression_for_grade(derece=4)
new_process.regression_for_grade(derece=5)
new_process.regression_for_grade(derece=6)
#new_process.regressionn_for_grade(grade=7)
new_process.write_to_file(working_directory)
print(term_renkleri.WARNING + "İLK SORUNUN BAŞARIYLA SONLANMASI. \t" + term_renkleri.ENDC)#ilk soru bitti ikinci soru işleniyor
print(term_renkleri.WARNING + "Burası ikincinin başlangıc noktası:" + term_renkleri.ENDC)
new_process.calculate_most_usefull()
print(term_renkleri.WARNING + "İKİNCİ SORUNUN BAŞARILA SONLANMASI. \t" + term_renkleri.ENDC)#ikinci soru bitti üçüncü soru işleniyor
print(term_renkleri.WARNING + "Burası üçüncünün başlangıç noktası :" + term_renkleri.ENDC)
print(term_renkleri.FAIL + "Taşma durumuna dikkat edilmeli !!" + term_renkleri.ENDC)# taşmaya dikkat et
for i in range(int(new_process.veri_uzunluk() / 10) + 1):
first = i * 10
last = i * 10 + 10 #last > first
if i >= int(new_process.veri_uzunluk() / 10):
last = new_process.veri_uzunluk()
new_process.kill_vars()
new_process.set_data_range(first, last)# ilk ,son karşılaştırma için olabilir??
new_process.regression_for_grade(derece=1, no_print=True)
new_process.regression_for_grade(derece=2, no_print=True)
new_process.regression_for_grade(derece=3, no_print=True)
new_process.regression_for_grade(derece=4, no_print=True)
new_process.regression_for_grade(derece=5, no_print=True)
new_process.regression_for_grade(derece=6, no_print=True)
new_process.calculate_most_usefull()
if __name__ == '__main__':
arguman = sys.argv[1:]
main()
| 2.71875
| 3
|
codeforce_round_647/johnnt_and_ancient_computer.py
|
NamanMathur77/programming_questions
| 0
|
12775130
|
def ifPossible(a):
while a%2==0:
a/=2
return a
test=int(input())
while test:
a,b = input().split()
a=int(a)
b=int(b)
if a>b:
n=b
b=a
a=n
num=ifPossible(b)
ans=0
if num!=ifPossible(a):
print("-1")
else:
b/=a
while b>=8:
b/=8
ans+=1
if b>1:
ans+=1
print(ans)
test-=1
| 3.578125
| 4
|
migen/fomu.py
|
Freax13/fomu-workshop
| 127
|
12775131
|
<filename>migen/fomu.py
""" Fomu board definitions (mapping of I/O pins, clock, etc.) """
from migen import *
from migen.build.generic_platform import *
from migen.build.lattice import LatticePlatform
class FomuPvtPlatform(LatticePlatform):
""" Based on
https://github.com/litex-hub/litex-boards/blob/master/litex_boards/partner/platforms/fomu_pvt.py """
_io = [
('clk48', 0, Pins('F4'), IOStandard('LVCMOS33')),
('user_led_n', 0, Pins('A5'), IOStandard('LVCMOS33')),
('rgb_led', 0,
Subsignal('r', Pins('C5')),
Subsignal('g', Pins('B5')),
Subsignal('b', Pins('A5')),
IOStandard('LVCMOS33')),
('user_touch_n', 0, Pins('E4'), IOStandard('LVCMOS33')),
('user_touch_n', 1, Pins('D5'), IOStandard('LVCMOS33')),
('user_touch_n', 2, Pins('E5'), IOStandard('LVCMOS33')),
('user_touch_n', 3, Pins('F5'), IOStandard('LVCMOS33')),
('usb', 0,
Subsignal('d_p', Pins('A1')),
Subsignal('d_n', Pins('A2')),
Subsignal('pullup', Pins('A4')),
IOStandard('LVCMOS33'))
]
_connectors = [
('touch_pins', 'E4 D5 E5 F5')
]
default_clk_name = 'clk48'
default_clk_period = 1e9 / 48e6
def __init__(self):
LatticePlatform.__init__(self,
'ice40-up5k-uwg30',
self._io,
self._connectors,
toolchain='icestorm')
def create_programmer(self):
return IceStormProgrammer()
class FomuHackerPlatform(LatticePlatform):
""" Based on
https://github.com/litex-hub/litex-boards/blob/master/litex_boards/partner/platforms/fomu_hacker.py """
_io = [
('clk48', 0, Pins('F5'), IOStandard('LVCMOS33')),
('user_led_n', 0, Pins('A5'), IOStandard('LVCMOS33')),
('rgb_led', 0,
Subsignal('r', Pins('C5')),
Subsignal('g', Pins('B5')),
Subsignal('b', Pins('A5')),
IOStandard('LVCMOS33')),
('user_touch_n', 0, Pins('F4'), IOStandard('LVCMOS33')),
('user_touch_n', 1, Pins('E5'), IOStandard('LVCMOS33')),
('user_touch_n', 2, Pins('E4'), IOStandard('LVCMOS33')),
('user_touch_n', 3, Pins('F2'), IOStandard('LVCMOS33')),
('usb', 0,
Subsignal('d_p', Pins('A4')),
Subsignal('d_n', Pins('A2')),
Subsignal('pullup', Pins('D5')),
IOStandard('LVCMOS33'))
]
_connectors = [
('touch_pins', 'F4 E5 E4 F2')
]
default_clk_name = 'clk48'
default_clk_period = 1e9 / 48e6
def __init__(self):
LatticePlatform.__init__(self,
'ice40-up5k-uwg30',
self._io,
self._connectors,
toolchain='icestorm')
def create_programmer(self):
return IceStormProgrammer()
class FomuEvt2Platform(LatticePlatform):
""" Based on
https://github.com/litex-hub/litex-boards/blob/master/litex_boards/partner/platforms/fomu_evt.py """
_io = [
('clk48', 0, Pins('44'), IOStandard('LVCMOS33')),
('user_led_n', 0, Pins('41'), IOStandard('LVCMOS33')),
('rgb_led', 0,
Subsignal('r', Pins('40')),
Subsignal('g', Pins('39')),
Subsignal('b', Pins('41')),
IOStandard('LVCMOS33')),
('user_touch_n', 0, Pins('48'), IOStandard('LVCMOS33')),
('user_touch_n', 1, Pins('47'), IOStandard('LVCMOS33')),
('user_touch_n', 2, Pins('46'), IOStandard('LVCMOS33')),
('user_touch_n', 3, Pins('45'), IOStandard('LVCMOS33')),
('usb', 0,
Subsignal('d_p', Pins('34')),
Subsignal('d_n', Pins('37')),
Subsignal('pullup', Pins('35')),
Subsignal('pulldown', Pins('36')),
IOStandard('LVCMOS33'))
]
_connectors = [
('touch_pins', '48 47 46 45')
]
default_clk_name = 'clk48'
default_clk_period = 1e9 / 48e6
def __init__(self):
LatticePlatform.__init__(self,
'ice40-up5k-sg48',
self._io,
self._connectors,
toolchain='icestorm')
def create_programmer(self):
return IceStormProgrammer()
FomuEvt3Platform = FomuEvt2Platform
| 2.09375
| 2
|
htdocs/plotting/auto/scripts100/p141.py
|
trentford/iem
| 0
|
12775132
|
"""yieldfx plot"""
import calendar
from collections import OrderedDict
import datetime
import pandas as pd
from pyiem.meteorology import gdd
from pyiem.plot.use_agg import plt
from pyiem.datatypes import temperature, distance
from pyiem.util import get_autoplot_context
STATIONS = OrderedDict([
('ames', 'Central (Ames)'),
('cobs', 'Central (COBS)'),
('crawfordsville', 'Southeast (Crawfordsville)'),
('kanawha', 'Northern (Kanawha)'),
('lewis', 'Southwest (Lewis)'),
('mcnay', 'Southern (Chariton/McNay)'),
('muscatine', 'Southeast (Muscatine)'),
('nashua', 'Northeast (Nashua)'),
('sutherland', 'Northwest (Sutherland)')])
PLOTS = OrderedDict([
('gdd', 'Growing Degree Days [F]'),
('rain', 'Precipitation [in]'),
('maxt', 'Daily Maximum Temperature [F]'),
('mint', 'Daily Minimum Temperature [F]'),
])
def get_description():
""" Return a dict describing how to call this plotter """
desc = dict()
desc['data'] = True
desc['description'] = """ """
desc['arguments'] = [
dict(type='select', name='location', default='ames',
label='Select Location:', options=STATIONS),
dict(type='select', name='ptype', default='gdd',
label='Select Plot Type:', options=PLOTS),
dict(type='text', name='sdate', default='mar15',
label='Start Date:')
]
return desc
def load(dirname, location, sdate):
""" Read a file please """
data = []
idx = []
mindoy = int(sdate.strftime("%j"))
for line in open("%s/%s.met" % (dirname, location)):
line = line.strip()
if not line.startswith('19') and not line.startswith('20'):
continue
tokens = line.split()
if int(tokens[1]) < mindoy:
continue
data.append(tokens)
ts = (datetime.date(int(tokens[0]), 1, 1) +
datetime.timedelta(days=int(tokens[1])-1))
idx.append(ts)
if len(data[0]) < 10:
cols = ['year', 'doy', 'radn', 'maxt', 'mint', 'rain']
else:
cols = ['year', 'doy', 'radn', 'maxt', 'mint',
'rain', 'gdd', 'st4', 'st12', 'st24',
'st50', 'sm12', 'sm24', 'sm50']
df = pd.DataFrame(data, index=idx,
columns=cols)
for col in cols:
df[col] = pd.to_numeric(df[col], errors='coerce')
if len(data[0]) < 10:
df['gdd'] = gdd(temperature(df['maxt'].values, 'C'),
temperature(df['mint'].values, 'C'))
df['gddcum'] = df.groupby(['year'])['gdd'].apply(lambda x: x.cumsum())
df['raincum'] = distance(
df.groupby(['year'])['rain'].apply(lambda x: x.cumsum()),
'MM').value('IN')
return df
def plotter(fdict):
""" Go """
ctx = get_autoplot_context(fdict, get_description())
location = ctx['location']
ptype = ctx['ptype']
sdate = datetime.datetime.strptime(ctx['sdate'], '%b%d')
df = load("/mesonet/share/pickup/yieldfx", location, sdate)
cdf = load("/opt/iem/scripts/yieldfx/baseline", location, sdate)
today = datetime.date.today()
thisyear = df[df['year'] == today.year].copy()
thisyear.reset_index(inplace=True)
thisyear.set_index('doy', inplace=True)
# Drop extra day from cdf during non-leap year
if today.year % 4 != 0:
cdf = cdf[cdf['doy'] < 366]
df = df[df['doy'] < 366]
# Create a specialized result dataframe for CSV, Excel output options
resdf = pd.DataFrame(index=thisyear.index)
resdf.index.name = 'date'
resdf['doy'] = thisyear.index.values
resdf.reset_index(inplace=True)
resdf.set_index('doy', inplace=True)
# write current year data back to resdf
for _v, _u in zip(['gddcum', 'raincum'],
['F', 'in']):
resdf["%s[%s]" % (_v, _u)] = thisyear[_v]
for _v in ['mint', 'maxt']:
resdf["%s[F]" % (_v)] = temperature(thisyear[_v].values,
'C').value('F')
resdf['rain[in]'] = distance(thisyear['rain'], 'MM').value('IN')
for _ptype, unit in zip(['gdd', 'rain'], ['F', 'in']):
resdf[_ptype+'cum_climo[%s]' % (unit, )
] = cdf.groupby('doy')[_ptype+'cum'].mean()
resdf[_ptype+'cum_min[%s]' % (unit, )
] = df.groupby('doy')[_ptype+'cum'].min()
resdf[_ptype+'cum_max[%s]' % (unit, )
] = df.groupby('doy')[_ptype+'cum'].max()
for _ptype in ['maxt', 'mint']:
resdf[_ptype+'_climo[F]'] = temperature(
cdf.groupby('doy')[_ptype].mean().values, 'C').value('F')
resdf[_ptype+'_min[F]'] = temperature(
df.groupby('doy')[_ptype].min().values, 'C').value('F')
resdf[_ptype+'_max[F]'] = temperature(
df.groupby('doy')[_ptype].max().values, 'C').value('F')
(fig, ax) = plt.subplots(1, 1, figsize=(8, 6))
if ptype in ['gdd', 'rain']:
ax.plot(thisyear.index.values, thisyear[ptype+'cum'], zorder=4,
color='b',
lw=2, label='%s Obs + CFS Forecast' % (today.year,))
climo = cdf.groupby('doy')[ptype+'cum'].mean()
ax.plot(climo.index.values, climo.values, lw=2, color='k',
label="Climatology", zorder=3)
xrng = df.groupby('doy')[ptype+'cum'].max()
nrng = df.groupby('doy')[ptype+'cum'].min()
ax.fill_between(xrng.index.values, nrng.values, xrng.values,
color='tan', label="Range", zorder=2)
else:
ax.plot(thisyear.index.values,
temperature(thisyear[ptype], 'C').value('F'),
zorder=4, color='b',
lw=2, label='%s Obs + CFS Forecast' % (today.year,))
climo = cdf.groupby('doy')[ptype].mean()
ax.plot(climo.index.values,
temperature(climo.values, 'C').value('F'), lw=2, color='k',
label='Climatology', zorder=3)
xrng = df.groupby('doy')[ptype].max()
nrng = df.groupby('doy')[ptype].min()
ax.fill_between(xrng.index.values,
temperature(nrng.values, 'C').value('F'),
temperature(xrng.values, 'C').value('F'),
color='tan', label="Range", zorder=2)
ax.set_title("%s %s" % (STATIONS[location], PLOTS[ptype]))
ax.set_ylabel(PLOTS[ptype])
ax.legend(loc=(0.03, -0.16), ncol=3, fontsize=12)
ax.set_xticks((1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335,
365))
ax.set_xticklabels(calendar.month_abbr[1:])
ax.grid(True)
ax.set_xlim(int(sdate.strftime("%j")),
int(datetime.date(today.year, 12, 1).strftime("%j")))
pos = ax.get_position()
ax.set_position([pos.x0, pos.y0 + 0.05, pos.width, pos.height * 0.95])
return fig, resdf
if __name__ == '__main__':
plotter(dict())
| 2.75
| 3
|
0x0B-python-input_output/13-student.py
|
johncoleman83/bootcampschool-higher_level_programming
| 0
|
12775133
|
#!/usr/bin/python3
class Student():
"""Student class with name and age"""
def __init__(self, first_name, last_name, age):
"""initializes new instance of Student"""
self.first_name = first_name
self.last_name = last_name
self.age = age
def to_json(self, attrs=None):
"""returns dict attributes of Student"""
if attrs is None:
obj_dict = self.__dict__
return obj_dict
else:
o_D = self.__dict__
D = dict(([k, v] for k, v in o_D.items() if k in attrs))
return D
def reload_from_json(self, json):
"""reloads Student instance from input dictionary"""
for k, v in json.items():
setattr(self, k, v)
| 3.859375
| 4
|
TML/src/utils/load_data.py
|
Pepijnnn/MasterThesis
| 0
|
12775134
|
<gh_stars>0
import numpy as np
import sklearn.datasets as datasets
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
import string
from scipy.io import arff
import cv2
import torch
from torchvision import transforms
from torch.utils.data import DataLoader, Dataset, TensorDataset
import pandas as pd
from sklearn.utils import Bunch
from .args import args
from PIL import ImageFont, ImageDraw, Image
# temp
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import hamming_loss, average_precision_score, precision_score
# ----- Data to Image Transformer -----
# FONT_HERSHEY_PLAIN,
def data2img(arr, font_size=50, resolution=(256, 256), font=cv2.FONT_HERSHEY_SIMPLEX): # SIMPLEX
""" Structured Tabular Data to Image with cv2
NOTE currently supports only iris, wine and womanshealth dataset
"""
x, y = resolution
if args.dataset=='mltoy':
n_colums, n_features = 17, len(arr)
elif args.dataset =="yeast14c":
n_colums, n_features = 4, len(arr)
else:
n_colums, n_features = 2, len(arr)
n_lines = n_features % n_colums + int(n_features / n_colums)
frame = np.ones((*resolution, 3), np.uint8)*0
k = 0
# ----- iris -----
if args.dataset=='iris':
for i in range(n_colums):
for j in range(n_lines):
try:
cv2.putText(
frame, str(arr[k]), (30+i*(x//n_colums), 5+(j+1)*(y//(n_lines+1))),
fontFace=font, fontScale=1, color=(255, 255, 255), thickness=2)
k += 1
except IndexError:
break
# ----- wine -----
elif args.dataset=='wine':
for i in range(n_colums):
for j in range(n_lines):
try:
cv2.putText(
frame, str(arr[k]), (30+i*(x//n_colums), 5+(j+1)*(y//(n_lines+1))),
fontFace=font, fontScale=0.6, color=(255, 255, 255), thickness=1)
k += 1
except IndexError:
break
# ----- toy -----
elif args.dataset=='mltoy':
for i in range(n_colums):
for j in range(n_lines):
try:
cv2.putText(
frame, str(arr[k]), (5+i*(x//n_colums), 5+(j+1)*(y//(n_lines+1))),
fontFace=font, fontScale=0.5, color=(255, 255, 255), thickness=1)
k += 1
except IndexError:
break
# ----- toy -----
elif args.dataset=='yeast14c':
# font = ImageFont.truetype("src/utils/arial-unicode-ms.ttf", 28, encoding="unic")
# font = cv2.FONT_ITALIC
n_lines-=5 #extra
for i in range(n_colums):
for j in range(n_lines):
try:
cv2.putText(
frame, str(arr[k]), (5+i*(x//n_colums), 5+(j+1)*(y//(n_lines+1))),
fontFace=font, fontScale=0.32, color=(255, 255, 255), thickness=1)
k += 1
except IndexError:
break
# font 0.3 lines 5 SIMPLEX round 5
return np.array(frame, np.uint8)
# ----- Dataset -----
class CustomTensorDataset(Dataset):
def __init__(self, data, transform=None, make_img=True):
self.data = data
self.transform = transform
self.make_img = make_img
self.le = preprocessing.LabelEncoder()
self.le.fit(list(string.ascii_lowercase)+list(string.ascii_uppercase))
def __len__(self):
return len(self.data[0])
def __getitem__(self, index):
try:
x = self.data[0].loc[index]
except:
x = self.data[0][index]
if self.make_img:
img = data2img(x)
else:
# print(x)
# try:
# x[43:] = self.le.transform(x[43:])
# x[2] = self.le.transform([x[2]])[0]
# except:
# pass
img = np.array([x]).astype(dtype = 'float32')
x = torch.from_numpy(img)
if self.transform and self.make_img == True:
x = self.transform(img)
try:
y = self.data[1].loc[index]
except:
y = self.data[1][index]
# y = self.data[1].loc[index]
# print(y)
return x, y
from sklearn.multioutput import MultiOutputClassifier
from sklearn.preprocessing import MultiLabelBinarizer
from sklearn.multiclass import OneVsRestClassifier
def classical_predictors(x_train, y_train, x_val, y_val):
# xgboost predictions
xgboost_est = XGBClassifier(eval_metric='map',objective='binary:logistic',n_jobs=-1, max_depth=4, use_label_encoder=False)
clf = OneVsRestClassifier(xgboost_est)
print(x_train.shape, y_train.shape)
clf.fit(x_train,y_train)
print("xgboost results:")
print("Hamming Loss: ",hamming_loss(y_val,clf.predict(x_val)))
print("avg precsion: ",average_precision_score(y_val,clf.predict(x_val)))
print("precision mi: ",precision_score(y_val,clf.predict(x_val),average='micro'))
# randomforest predictions
clf = RandomForestClassifier(max_depth=4, random_state=0)
clf.fit(x_train, y_train)
print("\nRandom Forest results:")
print("Hamming Loss: ",hamming_loss(y_val,clf.predict(x_val)))
print("avg precsion: ",average_precision_score(y_val,clf.predict(x_val)))
print("precision mi: ",precision_score(y_val,clf.predict(x_val),average='micro'))
exit()
# ----- Load Data Pipeline -----
import os
def load_data(dataset=args.dataset, batch_size=args.batch_size, val_size=args.val_size, test_size=args.test_size, device='cpu'):
# load dataset
if dataset=='iris':
data = datasets.load_iris()
elif dataset=='wine':
data = datasets.load_wine()
elif dataset=='mltoy':
xtrain = pd.read_csv("src/utils/ml/X_train_RE.csv")
xtrain.reset_index(inplace=True)
xtrain = xtrain[:int(len(xtrain)/50)]
xtrain = xtrain.to_numpy()
ytrain = pd.read_csv("src/utils/ml/y_train_RE.csv")
ytrain = ytrain.drop(ytrain.columns[[0]], axis=1)
ytrain.reset_index(inplace=True)
ytrain = ytrain[:int(len(ytrain)/50)]
ytrain = ytrain.to_numpy()
ytrain = ytrain[..., 1:] # remove first index element from each row
data = Bunch(data=xtrain, target=ytrain)
elif dataset == "yeast14c":
data = pd.read_csv("src/utils/ml/yeast_14class.csv")
xtrain = data.iloc[:, :len(list(data))-14]
xtrain = xtrain.to_numpy().round(8)
# print(xtrain.shape)
ytrain = data.iloc[:, len(list(data))-14:]
ytrain = ytrain.to_numpy()
data = Bunch(data=xtrain, target=ytrain)
elif dataset == "yeast14c_m":
train_df = arff.loadarff('src/utils/ml/mulan_yeast/yeast-train.arff')
train_df = pd.DataFrame(train_df[0])
# train_df.reset_index(inplace=True)
x_train = train_df.iloc[:, :len(list(train_df))-14]
x_train = x_train.to_numpy().round(8)
y_train = train_df.iloc[:, len(list(train_df))-14:].to_numpy().astype(str).astype(int)
test_df = arff.loadarff('src/utils/ml/mulan_yeast/yeast-test.arff')
test_df = pd.DataFrame(test_df[0])
# test_df.reset_index(inplace=True)
x_test = test_df.iloc[:, :len(list(test_df))-14]
x_test = x_test.to_numpy().round(8)
y_test = test_df.iloc[:, len(list(test_df))-14:].to_numpy().astype(str).astype(int)
if dataset != "yeast14c_m":
# Split dataset -- Cross Vaidation
x_train, x_test, y_train, y_test \
= train_test_split(data.data, data.target, test_size=test_size, random_state=1)
x_train, x_val, y_train, y_val \
= train_test_split(x_train, y_train, test_size=val_size, random_state=1)
# Dataset and Dataloader settings
kwargs = {} if args.device=='cpu' else {'num_workers': 2, 'pin_memory': True}
loader_kwargs = {'batch_size':batch_size, **kwargs}
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
# classical_predictors(x_train, y_train, x_val, y_val)
make_img = False if args.model == 'no_img' else True
# Build Dataset
train_data = CustomTensorDataset(data=(x_train, y_train), transform=transform, make_img=make_img)
val_data = CustomTensorDataset(data=(x_val, y_val), transform=transform, make_img=make_img)
test_data = CustomTensorDataset(data=(x_test, y_test), transform=transform, make_img=make_img)
# Build Dataloader
train_loader = DataLoader(train_data, shuffle=True, **loader_kwargs)
val_loader = DataLoader(val_data, shuffle=True, **loader_kwargs)
test_loader = DataLoader(test_data, shuffle=False, **loader_kwargs)
# 3, 256, 256
#return train_data, val_data, test_data
return train_loader, val_loader, test_loader
if __name__ == "__main__":
pass
| 2.359375
| 2
|
routes/friends.py
|
Prouser123/xbl-web-api
| 16
|
12775135
|
from quart import jsonify
from providers.BlueprintProvider import BlueprintProvider
class Friends(BlueprintProvider):
def __craftSummary(self, data):
return jsonify(
{
"following": data.target_following_count,
"followers": data.target_follower_count,
}
)
def routes(self):
@self.xbl_decorator.cachedRoute("/summary/xuid/<int:xuid>")
async def xuid(xuid):
return self.__craftSummary(
await self.xbl_client.people.get_friends_summary_by_xuid(xuid)
)
@self.xbl_decorator.cachedRoute("/summary/gamertag/<gamertag>")
async def gamertag(gamertag):
return self.__craftSummary(
await self.xbl_client.people.get_friends_summary_by_gamertag(gamertag)
)
| 2.4375
| 2
|
api/tests/integration/tests/deco/deco_iter.py
|
f1nzer/Indigo
| 0
|
12775136
|
<filename>api/tests/integration/tests/deco/deco_iter.py
import sys
sys.path.append("../../common")
from env_indigo import *
#
# Prepare a molecule for printing out
#
def prepareStructure(mol):
for atom in mol.iterateAtoms():
atom.setXYZ(0, 0, 0)
for rg in mol.iterateRGroups():
if rg.iterateRGroupFragments().hasNext():
rg_next = rg.iterateRGroupFragments().next()
for atom in rg_next.iterateAtoms():
atom.setXYZ(0, 0, 0)
indigo = Indigo()
indigo.setOption("molfile-saving-skip-date", True)
def printMolfile(mol):
smiles = mol.canonicalSmiles()
print("Smiles: " + smiles)
for format in ["2000", "3000", "auto"]:
print("Format: " + format)
indigo.setOption("molfile-saving-mode", format)
molfile = mol.molfile()
print(molfile)
# Check correctness by loading molfile and saving into smiles
sm2 = indigo.loadMolecule(molfile).canonicalSmiles()
if smiles != sm2:
sys.stderr.write(
"Error: smiles are different\n %s\n %s\n" % (smiles, sm2)
)
indigo.setOption("molfile-saving-mode", "auto")
def printQMolfile(qmol):
smiles = qmol.smiles()
print("Smiles: " + smiles)
for format in ["2000", "3000", "auto"]:
print("Format: " + format)
indigo.setOption("molfile-saving-mode", format)
molfile = qmol.molfile()
print(molfile)
indigo.setOption("molfile-saving-mode", "auto")
def printRGroups(mol):
print("separate RGroups: ")
for rg in mol.iterateRGroups():
print("RGROUP # %d" % (rg.index()))
if rg.iterateRGroupFragments().hasNext():
print(rg.iterateRGroupFragments().next().molfile())
else:
print("NO FRAGMENT")
def testDeco(scaf, structures):
scaffold = indigo.loadQueryMolecule(scaf)
deco = indigo.createDecomposer(scaffold)
for smiles in structures:
str = indigo.loadMolecule(smiles)
item = deco.decomposeMolecule(str)
print(
"highlighted structure: "
+ item.decomposedMoleculeHighlighted().smiles()
)
print(
"molecule scaffold: " + item.decomposedMoleculeScaffold().smiles()
)
print("molecule with rgroups: ")
mol = item.decomposedMoleculeWithRGroups()
prepareStructure(mol)
printMolfile(mol)
printRGroups(mol)
full_scaf = deco.decomposedMoleculeScaffold()
prepareStructure(full_scaf)
print("full scaffold: ")
printQMolfile(full_scaf)
def testDecoIterate(scaffold, structures):
deco = indigo.createDecomposer(scaffold)
for smiles in structures:
str = indigo.loadMolecule(smiles)
item = deco.decomposeMolecule(str)
match_idx = 1
for q_match in item.iterateDecompositions():
print("MATCH # %d" % match_idx)
print(
"highlighted structure: "
+ q_match.decomposedMoleculeHighlighted().smiles()
)
print(
"molecule scaffold: "
+ q_match.decomposedMoleculeScaffold().smiles()
)
print("molecule with rgroups: ")
mol = q_match.decomposedMoleculeWithRGroups()
prepareStructure(mol)
printMolfile(mol)
printRGroups(mol)
deco.addDecomposition(q_match)
match_idx += 1
full_scaf = deco.decomposedMoleculeScaffold()
prepareStructure(full_scaf)
print("full scaffold: ")
printQMolfile(full_scaf)
def testDecoIterateSmile(scaf, structures):
scaffold = indigo.loadQueryMolecule(scaf)
testDecoIterate(scaffold, structures)
def testDecoIterateFile(scaf, structures):
scaffold = indigo.loadQueryMoleculeFromFile(scaf)
testDecoIterate(scaffold, structures)
print(
"should decompose molecules with iteration api*************************************************************************"
)
testDeco(
"C1=CC=CC=C1",
[
"COCC1=C(N=CC2=C1C1=C(OC3=CC=C(Cl)C=C3)C=CC=C1N2)C(=O)OC(C)C",
"COCC1=CN=C(C(=O)OC(C)C)C2=C1C1=CC=C(OC3=CC=C(Cl)C=C3)C=C1N2",
],
)
print(
"should have only one match for simple molecule*************************************************************************"
)
testDecoIterateSmile("C1CCCCC1", ["OC1CCCCC1"])
print(
"should have only two matches for simple molecule*************************************************************************"
)
testDecoIterateSmile("C1CCCCC1", ["OC1(N)CCCCC1"])
print(
"should add all match to full scaffold*************************************************************************"
)
testDecoIterateSmile("C1CCCCC1", ["NC1CCC(CC1O)C1CCC(N)C(N)C1N"])
print(
"should add all matches to full scaffold within decomposition*************************************************************************"
)
testDecoIterateSmile("C1CCCCC1", ["NC1CCC(CC1O)C1CCCCC1N"])
print(
"should save only one rsite*************************************************************************"
)
testDecoIterateSmile("C1CCCCC1", ["NC1CCCCC1", "C1CC(O)CCC1"])
print(
"user defined scaffold should have only two matches for simple molecule*************************************************************************"
)
testDecoIterateFile(
joinPathPy("molecules/deco_user_def1.mol", __file__), ["NC1CCCC(O)C1"]
)
print(
"user defined scaffold should have only 4 matches for molecule*************************************************************************"
)
testDecoIterateFile(
joinPathPy("molecules/deco_user_def1.mol", __file__),
["NC1CCCC(C1)C1CCCC(O)C1"],
)
print(
"user defined scaffold should have no matches for molecule with connected atoms*************************************************************************"
)
testDecoIterateFile(
joinPathPy("molecules/deco_user_def1.mol", __file__), ["CC1CCC(O)CC1C"]
)
print(
"should save attachment points bond orders*************************************************************************"
)
indigo.setOption("deco-save-ap-bond-orders", True)
testDecoIterateSmile("C1CCCCC1", ["OC1(N)CCCCC1", "O=C1CCCCC1"])
indigo.setOption("deco-save-ap-bond-orders", False)
| 2.234375
| 2
|
task_manager.py
|
technetbytes/Nested-Object-Serialization
| 0
|
12775137
|
from task import Task
from tasks import Tasks
from status import Status
import redis
import datetime
import json
from json_extension import check_update_list
from converter import datetime_converter
class TaskManager:
_redis = None
_task_management_key = None
def __redis():
server = "localhost"
port = 6379
db = 0
TaskManager._redis = redis.Redis(server, port, db)
TaskManager._task_management_key = "object-serial"
@staticmethod
def __find_task_object(json_object, name):
for dict in json_object:
x = json.loads(dict)
if x['task_id'] == name:
return x
@staticmethod
def __find_task(json_object, name):
task = [obj for obj in json_object if obj['task_id']==name]
if len(task) > 1 and task is not None:
return task[0]
return None
@staticmethod
def clear_task_tasks_obj_as_dict():
# check and then create redis server object
if TaskManager._redis is None:
TaskManager.__redis()
TaskManager._redis.delete(TaskManager._task_management_key)
def get_task_management():
# check and then create redis server object
if TaskManager._redis is None:
TaskManager.__redis()
tasks_data_as_bytes = TaskManager._redis.get(TaskManager._task_management_key)
if tasks_data_as_bytes is not None:
tasks_data_as_str = tasks_data_as_bytes.decode("utf-8")
tasks_obj_as_dict = json.loads(tasks_data_as_str)
return tasks_obj_as_dict
else:
return None
@staticmethod
def __update_json_object(tasks_obj_as_dict, replace_obj):
for task in tasks_obj_as_dict:
if json.loads(task)['task_id'] == replace_obj['task_id']:
task = json.dumps(replace_obj)
break
return tasks_obj_as_dict
@staticmethod
def update_task_management_ext(event, name, status, id):
tasks_obj_as_dict = TaskManager.get_task_management()
if tasks_obj_as_dict is not None:
for element in tasks_obj_as_dict:
#print("@@@@@",tasks_obj_as_dict[element])
for elt in tasks_obj_as_dict[element]:
#print(";;;;;;;;;;;",elt['task_id'])
if elt['task_id'] == id:
new_status = Status(id, name, str(datetime.datetime.now()), status)
elt['conditions'].append(new_status)
print("***->",elt)
# print("!!!!!!!->",tasks_obj_as_dict['conditions'])
tasks = Tasks(tasks_obj_as_dict['conditions'])
TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# #Iterating all the fields of the JSON
# for element in tasks_obj_as_dict:
# #If Json Field value is a list
# if (isinstance(tasks_obj_as_dict[element], list)):
# # add new status in the task_conditions list
# new_status = Status(id, name, datetime.datetime.now(), status)
# check_update_list(tasks_obj_as_dict[element], element, new_status)
# print(tasks_obj_as_dict['conditions'])
# tasks = Tasks(tasks_obj_as_dict['conditions'])
# #TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
@staticmethod
def update_task_management(event, name, status, id):
tasks_obj_as_dict = TaskManager.get_task_management()
if tasks_obj_as_dict is not None:
#convert dict into json object called cache_object and add new item in the existing collection
cache_data = json.loads(json.dumps(tasks_obj_as_dict))
if cache_data is not None:
current_task = TaskManager.__find_task_object(cache_data['conditions'], id)
if current_task is not None:
# get task status list
current_task_conditions = current_task['conditions']
# add new status in the task_conditions list
new_status = Status(id, name, datetime.datetime.now(), status)
current_task_conditions.append(new_status)
# update object
update_json_obj = TaskManager.__update_json_object(cache_data['conditions'], current_task)
@staticmethod
def create_new_task(message_type, task):
# check and then create redis server object
if TaskManager._redis is None:
TaskManager.__redis()
_conditions = []
_tasks = []
tasks_obj_as_dict = TaskManager.get_task_management()
if tasks_obj_as_dict is None:
#first time creating task in the redis
if task is not None:
new_task = Task(message_type, task['id'], "init", _conditions)
_tasks.append(new_task)
tasks = Tasks(_tasks)
TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
else:
new_task = Task(message_type, task['id'], "init", _conditions)
# #convert dict into json object called cache_object and add new item in the existing collection
cache_data = json.loads(json.dumps(tasks_obj_as_dict))
# # print(cache_data)
cache_data['conditions'].append(new_task)
#print("---->",type(*cache_data.values()))
#print(len(*cache_data.values()))
# # prefixed by an asterisk operator to unpack the values in order to create a typename tuple subclass
tasks = Tasks(*cache_data.values())
TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# return tasks_obj_as_dict
# new_task = Task(message_type, task['id'], "init", _conditions)
# #convert dict into json object called cache_object and add new item in the existing collection
# cache_data = json.loads(json.dumps(tasks_obj_as_dict))
# # print(cache_data)
# cache_data['conditions'].append(new_task)
# # prefixed by an asterisk operator to unpack the values in order to create a typename tuple subclass
# tasks = Tasks(*cache_data.values())
# TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# return tasks_obj_as_dict
@staticmethod
def testing_create_new_task(task):
# check and then create redis server object
if TaskManager._redis is None:
TaskManager.__redis()
tasks_obj_as_dict = TaskManager.get_task_management()
if tasks_obj_as_dict is None:
TaskManager._redis.set(TaskManager._task_management_key, json.dumps(task))
else:
return tasks_obj_as_dict
# from task_store.task import Task
# from task_store.tasks import Tasks
# from task_store.status import Status
# import redis
# import datetime
# from config.setting import Config
# import json
# from utilities.json_extension import check_update_list
# from task_store.converter import datetime_converter
# class TaskManager:
# _redis = None
# _task_management_key = None
# def __redis():
# server = Config.get_complete_property('redis','server')
# port = Config.get_complete_property('redis','port')
# db = Config.get_complete_property('redis','db')
# TaskManager._redis = redis.Redis(server, port, db)
# TaskManager._task_management_key = Config.get_complete_property('redis','task_management_key')
# @staticmethod
# def __find_task_object(json_object, name):
# for dict in json_object:
# x = json.loads(dict)
# if x['task_id'] == name:
# return x
# @staticmethod
# def __find_task(json_object, name):
# task = [obj for obj in json_object if obj['task_id']==name]
# if len(task) > 1 and task is not None:
# return task[0]
# return None
# @staticmethod
# def clear_task_tasks_obj_as_dict():
# # check and then create redis server object
# if TaskManager._redis is None:
# TaskManager.__redis()
# TaskManager._redis.delete(TaskManager._task_management_key)
# def get_task_management():
# # check and then create redis server object
# if TaskManager._redis is None:
# TaskManager.__redis()
# tasks_data_as_bytes = TaskManager._redis.get(TaskManager._task_management_key)
# if tasks_data_as_bytes is not None:
# tasks_data_as_str = tasks_data_as_bytes.decode("utf-8")
# tasks_obj_as_dict = json.loads(tasks_data_as_str)
# return tasks_obj_as_dict
# else:
# return None
# @staticmethod
# def __update_json_object(tasks_obj_as_dict, replace_obj):
# for task in tasks_obj_as_dict:
# if json.loads(task)['task_id'] == replace_obj['task_id']:
# task = json.dumps(replace_obj)
# break
# return tasks_obj_as_dict
# @staticmethod
# def update_task_management_ext(event, name, status, id):
# tasks_obj_as_dict = TaskManager.get_task_management()
# if tasks_obj_as_dict is not None:
# #Iterating all the fields of the JSON
# for element in tasks_obj_as_dict:
# #If Json Field value is a list
# if (isinstance(tasks_obj_as_dict[element], list)):
# # add new status in the task_conditions list
# new_status = Status(id, name, datetime.datetime.now(), status)
# check_update_list(tasks_obj_as_dict[element], element, new_status)
# tasks = Tasks(tasks_obj_as_dict['conditions'])
# TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# @staticmethod
# def update_task_management(event, name, status, id):
# tasks_obj_as_dict = TaskManager.get_task_management()
# if tasks_obj_as_dict is not None:
# #convert dict into json object called cache_object and add new item in the existing collection
# cache_data = json.loads(json.dumps(tasks_obj_as_dict))
# if cache_data is not None:
# current_task = TaskManager.__find_task_object(cache_data['conditions'], id)
# if current_task is not None:
# # get task status list
# current_task_conditions = current_task['conditions']
# # add new status in the task_conditions list
# new_status = Status(id, name, datetime.datetime.now(), status)
# current_task_conditions.append(new_status)
# # update object
# update_json_obj = TaskManager.__update_json_object(cache_data['conditions'], current_task)
# @staticmethod
# def create_new_task(message_type, task):
# # check and then create redis server object
# if TaskManager._redis is None:
# TaskManager.__redis()
# _conditions = []
# _tasks = []
# tasks_obj_as_dict = TaskManager.get_task_management()
# if tasks_obj_as_dict is None:
# #first time creating task in the redis
# if task is not None:
# new_task = Task(message_type, task.id, "init", _conditions)
# _tasks.append(new_task)
# tasks = Tasks(_tasks)
# TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# else:
# new_task = Task(message_type, task.id, "init", _conditions)
# #convert dict into json object called cache_object and add new item in the existing collection
# cache_data = json.loads(json.dumps(tasks_obj_as_dict))
# # print(cache_data)
# cache_data['conditions'].append(new_task)
# # prefixed by an asterisk operator to unpack the values in order to create a typename tuple subclass
# tasks = Tasks(*cache_data.values())
# TaskManager._redis.set(TaskManager._task_management_key, json.dumps(tasks.to_json()))
# return tasks_obj_as_dict
# @staticmethod
# def testing_create_new_task(task):
# # check and then create redis server object
# if TaskManager._redis is None:
# TaskManager.__redis()
# tasks_obj_as_dict = TaskManager.get_task_management()
# if tasks_obj_as_dict is None:
# TaskManager._redis.set(TaskManager._task_management_key, json.dumps(task))
# else:
# return tasks_obj_as_dict
| 2.578125
| 3
|
getNBAStats.py
|
JasonG7234/NBA-Draft-Model-Hopefully-
| 0
|
12775138
|
from utils import *
import pandas as pd
import sys
import csv
GP = []
MPG = []
WS = []
WSP48 = []
BPM = []
VORP = []
PLUSMINUS = []
NBA_STATS = [GP, MPG, WS, WSP48, BPM, VORP, PLUSMINUS]
def main():
all = get_csv_file("add NBA stats? ")
all = populate_NBA_all_statistics(all)
addNBAStatsToMasterList(pd.read_csv('temp_master.csv'), all)
def populate_NBA_all_statistics(all):
couldNotFindList = []
nba_stats = all[['Season','Name']].copy()
base_url = "https://www.basketball-reference.com/players"
for index, row in all.iterrows():
if(row['Season'] == get_season_from_year(get_current_year())):
print(row['Name'] + " is still in college.")
appendValuesToNBALists(["?", "?", "?", "?", "?", "?", "?"])
continue
bkrefCorrectPage = True
bkrefIdentifier, bkrefIndex, bkrefName = getBKRefIdentifierAndIndex(row['Name'])
while True:
url = base_url + bkrefIdentifier + "0" + str(bkrefIndex) + ".html"
print(url)
soup = find_site(url)
if (soup):
if (soup.find('div', {'class': 'index reading'}) or not soup.find('table')):
print("Reached 404 page - assuming there are no stats for " + row['Name'])
appendValuesToNBALists(["0", "0", "0", "0", "0", "0", "0"])
break
quickBKRefPlayerInfoDiv = get_basketball_reference_player_info(soup)
if (quickBKRefPlayerInfoDiv):
if (isOnCorrectPlayerPage(bkrefName, row['School'], quickBKRefPlayerInfoDiv)):
try:
tableID = soup.find('table')['id']
except KeyError:
tableID = None
if (not tableID or tableID == 'all_college_stats'):
print("Could not find an NBA Basketball Reference page for " + row['Name'])
bkrefIndex = bkrefIndex + 1
bkrefCorrectPage = False
continue
else:
print("Found NBA player page for " + row['Name'])
populateNBAPlayerStatistics(soup)
break
else:
if (bkrefCorrectPage == True):
bkrefIndex = bkrefIndex + 1
bkrefCorrectPage = False
continue
else:
print("Could not find a correct NBA player page for " + row['Name'])
couldNotFindList.append(index)
appendValuesToNBALists(["0", "0", "0", "0", "0", "0", "0"])
bkrefIndex = bkrefIndex + 1
break
else:
print("Could not find player info div for " + url)
else:
print("Could not find page for url: " + url)
nba_stats['NBA GP'] = GP
nba_stats['NBA MPG'] = MPG
nba_stats['NBA WS'] = WS
nba_stats['NBA WSP48'] = WSP48
nba_stats['NBA BPM'] = BPM
nba_stats['NBA VORP'] = VORP
nba_stats['NBA PLUSMINUS'] = PLUSMINUS
nba_stats.to_csv('all_nba_stats.csv', index=False)
return nba_stats
def getBKRefIdentifierAndIndex(name):
bkrefName = get_basketball_reference_formatted_name(name, NBA_PLAYER_NAME_EXCEPTIONS)
firstName, lastName = bkrefName.replace("-", "").split(' ', 1)
bkrefIdentifier = ("/" + lastName[0] + "/" + lastName[:5] + firstName[:2]).lower()
bkrefIndex = check_value_in_dictionary_of_exceptions(bkrefName, NBA_INDEX_EXCEPTIONS, 1)
return bkrefIdentifier, bkrefIndex, bkrefName
def isOnCorrectPlayerPage(name, school, playerInfo):
school = get_basketball_reference_formatted_school(school, NBA_SCHOOL_NAME_EXCEPTIONS, school)
return name.lower() in playerInfo.replace("'", "").lower() and school in playerInfo
def populateNBAPlayerStatistics(soup):
statValueList = []
statValueList.extend(findGivenStatOnPlayerPage(soup, 'all_per_game', ['g','mp_per_g']))
statValueList.extend(findGivenStatOnPlayerPage(soup, 'all_advanced', ['ws', 'ws_per_48', 'bpm', 'vorp']))
statValueList.extend(findGivenStatOnPlayerPage(soup, 'all_pbp', ['plus_minus_net']))
appendValuesToNBALists(statValueList)
# Check the designated table for the designated datastat
def findGivenStatOnPlayerPage(soup, table_ID, datastat_IDs):
table = soup.find('div', {'id': table_ID})
list = []
if table:
career_stats = table('tfoot')[0] #Guarantees first row in the footer (career)
for datastat_ID in datastat_IDs:
stat = (career_stats.find("td", {"data-stat": datastat_ID})).getText()
list.append(stat)
else:
for datastat_ID in datastat_IDs:
print("Did not find a stat for " + datastat_ID + " - adding zero.")
list.append("0")
return list
# For each player, add an entry to the NBA stats lists
def appendValuesToNBALists(l):
for i in range(0,7):
NBA_STATS[i].append(l[i])
# Final step, add NBA stats to master list and export to CSV
def addNBAStatsToMasterList(all, nba):
all['NBA GP'] = nba['NBA GP']
all['NBA MPG'] = nba['NBA MPG']
all['NBA WS'] = nba ['NBA WS']
all['NBA WSP48'] = nba['NBA WSP48']
all['NBA BPM'] = nba['NBA BPM']
all['NBA VORP'] = nba['NBA VORP']
all['NBA PLUSMINUS'] = nba['NBA PLUSMINUS']
all = reorder_columns(all)
all.to_csv("new_master.csv", index=False)
if __name__ == "__main__":
main()
| 3.296875
| 3
|
app/backend-test/core_datasets/run01_create_dataset_from_config_v2.py
|
SummaLabs/DLS
| 32
|
12775139
|
<reponame>SummaLabs/DLS
#!/usr/bin/python
# -*- coding: utf-8 -*-
__author__ = 'ar'
import os
import sys
import glob
import numpy as np
import matplotlib.pyplot as plt
import skimage.io as skio
import app.backend.core.utils as dlsutils
from app.backend.core.datasets.dbbuilder import DBImage2DBuilder
#################################################
pathToDirWithJson="../../../data-test"
pathDirOutRoot="../../../data/datasets"
#################################################
if __name__ == '__main__':
lstConfigFn=[os.path.abspath(xx) for xx in glob.glob('%s/dbconfig_*.json' % pathToDirWithJson)]
prefixDataset='dbset'
for ii,pp in enumerate(lstConfigFn):
print ('[%d/%d] : %s' % (ii, len(lstConfigFn), pp))
pathToJson = pp
tdirDbId = dlsutils.getUniqueTaskId(prefixDataset)
pathDirOut = os.path.abspath(os.path.join(pathDirOutRoot, tdirDbId))
dlsutils.makeDirIfNotExists(pathDirOut)
dbBuilder2DImage = DBImage2DBuilder(pathCfgInp=pathToJson,
pathDirOut=pathDirOut)
dbBuilder2DImage.initializeInfo()
print (dbBuilder2DImage)
dbBuilder2DImage.buildDataset(parProgressor=None)
print ('\n\n')
| 2.078125
| 2
|
w3testrunner/browsers/dummy.py
|
formido/browsercontrol
| 0
|
12775140
|
import logging
import urllib2
from w3testrunner.browsers.browser import Browser
log = logging.getLogger(__name__)
class DummyBrowser(Browser):
"""Extension of Browser that does nothing."""
name = "dummy"
nopath = True
def __init__(self, browser_info):
super(DummyBrowser, self).__init__(browser_info)
self.alive = False
def launch(self):
self.alive = True
# Simulate a browser fetching the runner url.
try:
urllib2.urlopen(self.RUNNER_URL).read()
except urllib2.URLError, e:
log.debug("Error connecting to runner url: %s", e)
def is_alive(self):
return self.alive
def terminate(self):
self.alive = False
| 2.65625
| 3
|
trane/core/labeler.py
|
FeatureLabs/Trane
| 31
|
12775141
|
<gh_stars>10-100
import logging
import time
import pandas as pd
from .prediction_problem_saver import prediction_problems_from_json_file
__all__ = ['Labeler']
class Labeler():
"""
Object for executing prediction problems on data in order
to generate labels for many prediction problems.
The execute method performs the labelling operation.
"""
def __init__(self):
pass
def execute(self, data, cutoff_df, json_prediction_problems_filename):
"""
Generate the labels.
Parameters
----------
cutoff_df: dataframe. Each row corresponds to an entity.
entity_id (indexed) | training_cutoff | test_cutoff
json_prediction_problems_filename: filename to read
prediction problems from, structured in JSON.
Returns
-------
dfs: a list of DataFrames. One dataframe for each problem.
Each dataframe contains entities, cutoff times and labels.
"""
(prediction_problems,
table_meta,
entity_id_column,
label_generating_column,
time_column) = prediction_problems_from_json_file(
json_prediction_problems_filename)
dfs = []
columns = [entity_id_column, 'training_labels',
'test_labels', 'training_cutoff_time', 'label_cutoff_time']
for idx, prediction_problem in enumerate(prediction_problems):
start = time.time()
df_rows = []
logging.debug(
"in labeller and beginning exuection of problem: {} \n".format(
prediction_problem))
for index, row in cutoff_df.iterrows():
entity_id = index
training_cutoff = row[0]
label_cutoff = row[1]
entity_data = pd.DataFrame(data.loc[entity_id]).T
(df_pre_label_cutoff_time_result,
df_all_data_result) = prediction_problem.execute(
entity_data, time_column, label_cutoff,
prediction_problem.filter_column_order_of_types,
prediction_problem.label_generating_column_order_of_types) # noqa
if len(df_pre_label_cutoff_time_result) == 1:
label_precutoff_time = df_pre_label_cutoff_time_result[
label_generating_column].values[0]
elif len(df_pre_label_cutoff_time_result) > 1:
logging.warning("Received output from prediction problem \
execution on pre-label cutoff data with \
more than one result.")
label_precutoff_time = None
else:
label_precutoff_time = None
if len(df_all_data_result) == 1:
label_postcutoff_time = df_all_data_result[
label_generating_column].values[0]
elif len(df_all_data_result) > 1:
logging.warning("Received output from prediction problem execution \
on all data with more than one result.")
label_postcutoff_time = None
else:
label_postcutoff_time = None
df_row = [entity_id, label_precutoff_time,
label_postcutoff_time, training_cutoff, label_cutoff]
df_rows.append(df_row)
df = pd.DataFrame(df_rows, columns=columns)
end = time.time()
logging.info(
"Finished labelling problem: {} of {}.Time elapsed: {}".format(
idx, len(prediction_problems), end - start))
dfs.append(df)
return dfs
| 2.96875
| 3
|
sona/create_sounds.py
|
jayfry1077/runeterra_audio_discord_bot
| 0
|
12775142
|
<filename>sona/create_sounds.py
from boto3 import Session
from botocore.exceptions import BotoCoreError, ClientError
from contextlib import closing
import os
import pydub
import sys
import subprocess
from tempfile import gettempdir
def text_to_audio(path_to_text=str, OGG_PATH=str, WAV_PATH=str, voice_id='Salli'):
'''
path_to_text: Specify the location of your text files. Text files must contain cardCode followed by a space in the name
\nOGG_PATH: Specify the location you want to save the audio output.
\nvoice_id: Default is Salli. Options are.
Salli, Joanna, Ivy, Kendra, Kimberly, Matthew, Justin, Joey
\nprofile used for aws is 'default'
'''
if not os.path.isdir(OGG_PATH):
print('Creating Path {}'.format(OGG_PATH))
os.mkdir(OGG_PATH)
if not os.path.isdir(WAV_PATH):
print('Creating Path {}'.format(WAV_PATH))
os.mkdir(WAV_PATH)
# Create a client using the credentials and region defined in the [adminuser]
# section of the AWS credentials file (~/.aws/credentials).
session = Session(profile_name="default")
polly = session.client("polly")
for file in os.listdir(path_to_text):
with open((path_to_text + file), 'r') as f:
try:
# Request speech synthesis
response = polly.synthesize_speech(Text=f.read(), OutputFormat="ogg_vorbis",
VoiceId="Salli")
f = open(OGG_PATH + file[:-4] + ".ogg", "wb")
f.write(response['AudioStream'].read())
f.close
wav_file_name = file.split(" ")[0]
sound = pydub.AudioSegment.from_ogg(OGG_PATH + file[:-4] + ".ogg")
sound.export(WAV_PATH + wav_file_name + ".wav", format='wav')
print('Wrote {} to disk.'.format(file[7:-4]))
except (BotoCoreError, ClientError) as error:
# The service returned an error, exit gracefully
print(error)
sys.exit(-1)
| 2.8125
| 3
|
trainer.py
|
safdark/AI-VUI-Capstone
| 0
|
12775143
|
from train_utils import train_model
from sample_models import custom_rnn_model
from keras.layers import SimpleRNN, GRU, LSTM
import argparse
import sys
import os
from os.path import join
if __name__ == '__main__':
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.5
set_session(tf.Session(config=config))
print ("###############################################")
print ("# ASR Trainer #")
print ("###############################################")
parser = argparse.ArgumentParser(description='ASR Driver')
parser.add_argument('-o', dest='output', required=True, type=str, help='Path to folder containing model data input/output (.hd5 and .pickle files).')
parser.add_argument('-i', dest='id', required=True, type=int, help='Id or name of the model')
parser.add_argument('-cf', dest='conv_filters', type=int, help='# of convolution filters')
parser.add_argument('-ck', dest='kernel_size', type=int, help='Size of convolution kernel')
parser.add_argument('-cs', dest='conv_stride', type=int, help='Convolutional stride')
parser.add_argument('-cp', dest='conv_padding', type=str, help="Convolutional padding mode ('same', or 'valid')")
parser.add_argument('-cd', dest='conv_dropout', type=float, help='Dropout for convolutional output (between 0.0 and 1.0)')
parser.add_argument('-rl', dest='recur_layers', type=int, help='Number of recurrent layers')
parser.add_argument('-ru', dest='recur_units', nargs='*', type=int, help="List of 'rl' recurrent unit sizes")
parser.add_argument('-rc', dest='recur_cells', nargs='*', type=int, help="List of 'rl' recurrent cell types (0: SimpleRNN, 1: GRU, or 2: LSTM)")
parser.add_argument('-rb', dest='recur_bidis', nargs='*', type=int, help="List of 'rl' flags indicating whether the layer is bidirectional ('True', 'False')")
parser.add_argument('-rd', dest='recur_dropouts', nargs='*', type=float, help="List of 'rl' dropouts (between 0.0 and 1.0)")
parser.add_argument('-dd', dest='dense_dropout', type=float, help="Dropout for fully connected output layer")
parser.add_argument('-e', dest='num_epochs', required=False, default=20, type=int, help="Number of epochs to train")
args = parser.parse_args()
args.recur_cells = map(lambda x: SimpleRNN if x is 0 else GRU if x is 1 else LSTM, list(args.recur_cells))
args.recur_bidis = map(lambda x: False if x is 0 else True, list(args.recur_bidis))
print (args)
model_weights_path = "model_{}.h5".format(args.id) #join(os.getcwd(), args.output, "model_{}.h5".format(args.id))
model_hist_path = "model_{}.pickle".format(args.id) #join(os.getcwd(), args.output, "model_{}.pickle".format(args.id))
print("\tModel weights path: {}".format(model_weights_path))
print("\tModel train hist path: {}".format(model_hist_path))
# --------
model_5 = custom_rnn_model(input_dim=13, # change to 13 if you would like to use MFCC features
conv_filters=args.conv_filters, conv_kernel_size=args.kernel_size, conv_stride=args.conv_stride, conv_border_mode=args.conv_padding, conv_batch_mode=True, conv_dropout=args.conv_dropout, \
recur_layers=args.recur_layers, recur_units=args.recur_units, recur_cells=args.recur_cells, recur_bidis=args.recur_bidis, recur_batchnorms=[True]*args.recur_layers, recur_dropouts=args.recur_dropouts, \
output_dropout=args.dense_dropout, output_dim=29)
train_model(input_to_softmax=model_5,
epochs=args.num_epochs,
pickle_path=model_hist_path,
save_model_path=model_weights_path,
spectrogram=False) # change to False if you would like to use MFCC features
print ("Training complete!")
print ("\tModel weights stored in: {}".format(model_weights_path))
print ("\tModel hist stored in: {}".format(model_hist_path))
print ("# Thank you! #")
| 2.234375
| 2
|
pro.py
|
CMWENLIU/Fuzzy_text_matching
| 0
|
12775144
|
<reponame>CMWENLIU/Fuzzy_text_matching
import os
import time
import collections
import pandas as pd
import numpy as np
from collections import Counter
from google_images_download import google_images_download #importing the library
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
class Drug(object):
"""__init__() functions as the class constructor"""
def __init__(self, name=None, text=None, label=None):
self.name = name
self.text = text
self.label = label
def download_images(label, key_words):
response = google_images_download.googleimagesdownload() #class instantiation
argument = {"keywords": key_words, "limit":5, "image_directory": "images", "prefix": label}
paths = response.download(argument)
#split line in dm2000, then get finename, textContents and labels
def split_fname_texts(line):
obj = {}
if '.jpg' in line:
obj['name'] = line.split('.jpg', 1)[0] + '.jpg'
obj['text'] = line.split('.jpg', 1)[1]
obj['label'] = line.split('_', 1)[0]
return obj
def construt(filepath):
name_list, string_list = [], []
with open(filepath, 'r') as rf:
for line in rf:
if '.jpg' in line:
splitted = line.split('.jpg', 1)
name_list.append(splitted[0][:-1])
string_list.append(splitted[1])
def split_keywords(line):
obj = {}
if '_' in line:
split = line.split('_', 1)
obj['label'] = split[0]
obj['keywords'] = split[1]
return obj
def frequency_distribution(druglist):
label_list = []
for item in druglist:
label_list.append(item.label)
counter=collections.Counter(label_list)
new_counter = collections.Counter(counter.values())
return new_counter
def frequency(druglist, n):
print('Drugs containing more than ' + str(n) + ' images are selected')
label_list = []
for item in druglist:
label_list.append(item.label)
counter=collections.Counter(label_list)
result = []
count_list = []
for item in counter:
if counter[item] > n:
result.append(item)
count_list.append(counter[item])
df = pd.DataFrame({'count':count_list})
return result
def cal_top(df, n, test_str):
#samples = df.sample(m)
#for index, row in samples.iterrows():
t_label = 'label'
obj = test_str
list_label, list_score, list_text,list_name = [], [], [], []
for i, r in df.iterrows():
list_label.append(r['label'])
list_name.append(r['name'])
list_text.append(r['text'])
list_score.append((fuzz.partial_ratio(obj, r['text']) + fuzz.ratio(obj, r['text']))/2)
#list_score.append(fuzz.partial_ratio(obj, r['text']))
result_df = pd.DataFrame({'result_label': list_label, 'result_score': list_score, 'result_text': list_text, 'result_name': list_name})
result_df = result_df.sort_values(by=['result_score'], ascending=False).head(n)
result_df1 = result_df.groupby('result_label')['result_score'].sum().reset_index(name ='total_score')
result_df1 = result_df1.sort_values(by=['total_score'], ascending=False)
scores = result_df1['total_score'].tolist()
norm = [round(float(i)/sum(scores), 2) for i in scores]
result_df1['probability'] = norm
'''
print ('True label of test drug: ' + t_label + '\n')
print ('Following are most similar texts from images:' + '\n')
print (result_df)
print ('Following are candidates from reference dataset:' + '\n')
print (result_df1)
'''
return result_df, result_df1
def softmax(x):
"""Compute softmax values for each sets of scores in x."""
e_x = np.exp(x - np.max(x))
return e_x / e_x.sum(axis=0) # only difference
'''
drug_list=[]#list of drugs to store fileName,Text and lablel information
with open('data/ocr.txt', 'r') as rf:
for line in rf:
split_r = split_fname_texts(line)
drug_list.append(Drug(split_r['name'], split_r['text'], split_r['label']))
print len(drug_list)
df = pd.DataFrame([vars(f) for f in drug_list])
df.columns = ["label", "name", "text"]
#frequency(drug_list, 2)
final_list = frequency(drug_list, 4)#get the records with count more than 3
print len(final_list)
#print df['label']
df = df[df['label'].isin(final_list)]
print len(df)
cal_top(df, 15, 2)
'''
| 2.640625
| 3
|
livemelee/startup.py
|
wong-justin/melee-bot
| 1
|
12775145
|
'''Create entry point to init everything and start Dolphin.'''
import argparse
# import sys
from pathlib import Path
import melee
from .interact import LiveInputsThread
def start_game(ports, cmds={}, log=True):
'''Main method to fully start game.
Command-line first needs dolphin path and iso path, then game starts.
Iso path is optional if you have a default iso set to run on Dolphin startup.
```
# main.py
...
start_game(...)
```
`python main.py path/to/dolphin path/to/iso`
Args:
ports: tuple containing 4 bot instances or Nones.
eg. `(None, my_bot, None, None)`
cmds: optional.
- `dict`: of custom commands `'cmd': (func, 'descrip')` or `'cmd': func`.
- default: empty dict, no custom commands
- `None`: no live thread desired (probably for performance)
log: `bool`, write game logs to file with `melee.Logger` if True (default)'''
args = _start_command_line()
dolphin_folder = str( Path(args.dolphin_path).parent )
console = melee.Console(path=dolphin_folder) # libmelee wants the folder
# controllers must be connected before console run/connect...
bots = _assign_controllers(ports, console)
console.run(iso_path=args.iso_path) # if None, relies on default Dolphin iso on startup
console.connect()
# ... and then controllers are connected afterward
_connect_controllers(bots)
logger = melee.Logger() if log else None
live_interface = None
if cmds is not None:
live_interface = LiveInputsThread(commands=cmds)
live_interface.onshutdown = _shutdown(console, logger)
live_interface.start()
while True:
gamestate = console.step()
if not gamestate:
break
for bot in bots:
bot.act(gamestate)
if live_interface:
live_interface.update(gamestate)
if logger:
logger.logframe(gamestate)
logger.log('Frame Process Time', console.processingtime) # ms
logger.writeframe()
def _start_command_line():
# simple CLI to get paths for dolphin and optionally iso
parser = argparse.ArgumentParser()
parser.add_argument('paths', nargs='+', help='dolphin/path [iso/path]')
args = parser.parse_args()
args.dolphin_path = args.paths[0]
args.iso_path = args.paths[1] if len(args.paths) > 1 else None
return args
def _assign_controllers(ports, console):
# make + give controllers to any bots present in 4-tuple of ports
bots = []
for port, bot in enumerate(ports):
if bot:
controller = melee.Controller(console=console, port=port+1)
# controller = melee.Controller(console=console, port=port+1, type=melee.ControllerType.STANDARD)
bot.controller = controller
bots.append(bot)
return bots
def _connect_controllers(bots):
for bot in bots:
bot.controller.connect()
def _shutdown(console, logger):
# returns callable that closes dolphin and anything else
def f():
console.stop()
if logger:
print()
logger.writelog()
print('Log file created: ' + logger.filename)
print('Shutting down')
return f
| 2.796875
| 3
|
APP/SpeechExtraction/speech_blueprint.py
|
Valuebai/Text-Auto-Summarization
| 39
|
12775146
|
<gh_stars>10-100
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''=================================================
@IDE ：PyCharm
@Author ：LuckyHuibo
@Date ：2019/10/16 22:32
@Desc ：
=================================================='''
from flask import request, render_template, jsonify, Blueprint
# from flask import current_app
app_extraction = Blueprint("speech_extraction", __name__, static_folder='static', template_folder='templates')
from conf.logConf import logger
@app_extraction.route('/')
def index():
logger.info('speech_extraction')
return 'app_extraction'
| 2.015625
| 2
|
rnaposerplugin/__init__.py
|
atfrank/RNAPosers
| 7
|
12775147
|
<gh_stars>1-10
from __future__ import absolute_import
from __future__ import print_function
# Avoid importing "expensive" modules here (e.g. scipy), since this code is
# executed on PyMOL's startup. Only import such modules inside functions.
def __init_plugin__(app=None):
from pymol.plugins import addmenuitemqt
addmenuitemqt('RNAPosers Plugin', run_plugin_gui)
# global reference to avoid garbage collection of our dialog
dialog = None
def run_plugin_gui():
global dialog
if dialog is None:
# create a new (empty) Window
dialog = make_dialog()
dialog.show()
def make_dialog():
import os
# entry point to PyMOL's API
from pymol import cmd
# pymol.Qt provides the PyQt5 interface, but may support PyQt4
# and/or PySide as well
from pymol.Qt import QtWidgets
from pymol.Qt.utils import loadUi, getSaveFileNameWithExt
# from pymol.Qt.QtWidgets.QFileDialog import getOpenFileName, getSaveFileName
dialog = QtWidgets.QDialog()
# filename of our UI file
uifile = os.path.join(os.path.dirname(__file__), 'rnaposers.ui')
# load the UI file into our dialog
global form
form = loadUi(uifile, dialog)
print("[RNAPosers Debugging] Dialog created")
def eta_converter(eta_input):
if eta_input == '2A, 4A and 8A':
return '248'
elif eta_input == '2A and 4A':
return '24'
else:
return '2'
def run():
import os
import tempfile
# get form data and initialize parameters
rmsd = form.rmsd.currentText()
eta = eta_converter(form.eta.currentText())
receptor = form.pdb_filename.text()
poses = form.dcd_filename.text()
start_frame = 1
try:
stop_frame = int(form.stop_frame.text())
except:
stop_frame = -1
score = form.output_filename.text()
complex_name = "complex"
# some debugging feedback
print('[RNAPosers Debugging] Parameters:', rmsd, eta, receptor, poses, stop_frame, score)
# redefine pdb and dcd
from .generate_complex_files import generate_complexes
with tempfile.TemporaryDirectory() as tmpDir:
mol2 = tmpDir + "/lig.mol2"
pdb = tmpDir + "/complex.pdb"
dcd = tmpDir + "/complexes.dcd"
generate_complexes(receptor, poses, dcd, pdb, mol2)
cmd.delete(complex_name)
cmd.load(pdb, complex_name)
cmd.load_traj(dcd, complex_name, state=1, stop=stop_frame)
featureFile = tmpDir + "/features"
dir_path = os.path.dirname(os.path.realpath(__file__))
rnaposers_cmd = " ".join(["bash", dir_path + "/run.sh", pdb, mol2, dcd, rmsd, eta, featureFile, score, str(stop_frame)])
print('[RNAPosers Debugging]',rnaposers_cmd)
os.system(rnaposers_cmd)
from .reorder_traj import reorder_traj
reorder_traj(complex_name, score)
def set_saveas_path():
filename = QtWidgets.QFileDialog.getSaveFileName()[0]
if filename:
form.output_filename.setText(filename)
def make_set_path(form, name):
def set_path():
from pymol.Qt import QtWidgets
set_command = "".join(["form.", name, "_filename.setText(QtWidgets.QFileDialog.getOpenFileName()[0])"])
eval(set_command)
return set_path
def set_dcd_path():
form.dcd_path.setText(QtWidgets.QFileDialog.getOpenFileName()[0])
for object in ["pdb", "dcd"]:
set_command = "".join(["form.button_", object, ".clicked.connect(make_set_path(form, '", object, "'))"])
eval(set_command)
form.button_saveas.clicked.connect(set_saveas_path)
form.button_run.clicked.connect(run)
form.button_close.clicked.connect(dialog.close)
return dialog
| 2.296875
| 2
|
offer_curves.py
|
ElisNycander/nordic_model
| 1
|
12775148
|
# -*- coding: utf-8 -*-
"""
Class for storing supply curves and calculating marginal costs
Created on Thu Feb 7 15:34:33 2019
@author: elisn
"""
import pickle
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
class SupplyCurve():
""" Has panda dataframe with list of bids
One or many generators may be added to the supply curve. The generators must be in the form
of a panda data frame, with the columns ['c2','c1','pmax']
The marginal cost of a generator is given by MC = 2*c2*q + c1, where q ranges from 0 to pmax
Hence a generator with c2 = 0 has constant marginal cost
(Thus note that the coefficients are those for the Total Cost function)
It is also possible to add bids, which then must have the columns [cap,mc_min,mc_max]
Note that the internal functions use the bid structure.
Class methods:
price2quantity(price) - calculates the quantity offered for a given price, straightforward calculation
quantity2price(quantity) - calculates price required for given quantity
not straightforward since constant bids produce discrete jumps in the offered quantity
plot() - plots supply curve
"""
def __init__(self,bids = pd.DataFrame(columns=['cap','mc_min','mc_max']),gens = pd.DataFrame(columns=['c2','c1','pmax']) ):
self.bids = bids.append(get_generator_bids(gens),ignore_index=True).sort_values(by=['mc_min','mc_max'])
self._calculate_inflection_points_()
def add_bids(self,bids):
""" Add bids to supply curve, in the form of a data frame """
self.bids = self.bids.append(bids,ignore_index=True).sort_values(by=['mc_min','mc_max'])
self._calculate_inflection_points_()
def add_gens(self,gens):
""" Add generators with c1, c2, pmax coefficients to supply curve """
self.bids = self.bids.append(get_generator_bids(gens),ignore_index=True).sort_values(by=['mc_min','mc_max'])
self._calculate_inflection_points_()
def price2quantity(self,price):
""" Calculate the offered quantity for a given price """
# loop over bids, calculate offer by each
quantity = 0
for i in self.bids.index:
if price >= self.bids.loc[i,'mc_min']:
if self.bids.loc[i,'mc_min'] != self.bids.loc[i,'mc_max']: # variable MC
q = (price - self.bids.loc[i,'mc_min'])/(self.bids.loc[i,'mc_max']-self.bids.loc[i,'mc_min'])*self.bids.loc[i,'cap']
if q > self.bids.loc[i,'cap']:
q = self.bids.loc[i,'cap']
quantity += q
else: # fixed MC
quantity += self.bids.loc[i,'cap']
else:
# mc_min exceeds price, can exit as bids are sorted by increasing mc_min
return quantity
return quantity
def _calculate_inflection_points_(self):
""" Find all inflection points in the supply curve """
ppoints = []
for i in self.bids.index:
if self.bids.loc[i,'mc_min'] not in ppoints:
ppoints.append(self.bids.loc[i,'mc_min'])
if self.bids.loc[i,'mc_max'] not in ppoints:
ppoints.append(self.bids.loc[i,'mc_max'])
ppoints.sort()
# find curresponding quantities
qpoints = []
for point in ppoints:
qpoints.append(self.price2quantity(point))
self.xprice = ppoints
self.xquant = qpoints
def quantity2price(self,quantity,plot=False,verbose=False):
""" Calculate minimum price needed for given quantity """
idx = 0
while True:
if idx == self.xprice.__len__():
# quantity > qmax, not enough capacity
if verbose:
print("Insufficient capacity: {0} MW available, but quantity = {1:.3}".format(self.xquant[-1],quantity))
#return np.nan
p = np.nan
break
elif self.xquant[idx] < quantity:
idx += 1 # go to next price level
else:
if idx == 0:
# quantity <= 0 - return lowest marginal cost
#print("Non-positive quantity = {0:.3}, returning lowest available MC".format(quantity))
#return self.xprice[0]
p = self.xprice[0]
break
elif self.xquant[idx] == quantity:
# price corresponds exactly to quantity
#return self.xprice[idx]
p = self.xprice[idx]
break
else:
# check if offer curve is linear by evaluating quantity between prices
if self.price2quantity(self.xprice[idx-1]+(self.xprice[idx]-self.xprice[idx-1])/2) > self.xquant[idx-1]:
# if offer curve is linear, interpolate to find correct price
# Note: Cannot interpolate linearly to next intersection point, as there
# the curve may consist of a linear horizontal section to the next point
# Thus we must instead find the inverse slope by summing the inverse slopes
# of linear bids at this point
# use inverse slope at price xprice[idx] for interpolation
p = self.xprice[idx-1] + (quantity-self.xquant[idx-1]) / self._find_slope_(self.xprice[idx])
if p > self.xprice[idx]: # cap price increase up to xprice[idx]
# if idx == 3:
# print(p)
# pass
p = self.xprice[idx]
#return p
break
else:
# else return this price
p = self.xprice[idx]
#return self.xprice[idx]
break
if plot:
# plot supply curve with determined point
self.plot(qpoints=[quantity],ppoints=[p])
return p
def _find_slope_(self,price):
""" Find the slope of the supply curve, in MW/EUR (quantity/price) for given price """
# loop over all linear bids and see which are active in this price range
slope = 0 # slope in MW/EUR
for index in self.bids.index:
if self.bids.loc[index,'mc_min'] != self.bids.loc[index,'mc_max'] and \
price > self.bids.loc[index,'mc_min'] and price <= self.bids.loc[index,'mc_max']:
slope += self.bids.loc[index,'cap']/(self.bids.loc[index,'mc_max']-self.bids.loc[index,'mc_min'])
return slope
def plot(self,qpoints=[],ppoints=[]):
""" Plot supply curve """
x_quantity = np.linspace(0,self.xquant[-1])
y_price = np.array([self.quantity2price(x) for x in x_quantity])
y2_price = np.linspace(self.xprice[0],self.xprice[-1])
x2_quantity = np.array([self.price2quantity(p) for p in y2_price])
# # merge data points into single array
# x = np.array([x for x,_ in sorted(zip(list(x_quantity)+list(x2_quantity),list(y_price)+list(y2_price)))])
# y = np.array([y for _,y in sorted(zip(list(x_quantity)+list(x2_quantity),list(y_price)+list(y2_price)))])
#
plt.plot()
plt.plot(x_quantity,y_price,'*')
plt.plot(x2_quantity,y2_price,'*')
#plt.plot(x,y)
# add given points to plot
if qpoints.__len__() > 0:
plt.plot(np.array(qpoints),np.array(ppoints),'r*')
plt.grid()
plt.xlabel('MW')
plt.ylabel('EUR/MWh')
plt.title('Supply curve')
plt.legend(['quantity2price','price2quantity'])
plt.show()
def get_curve(self):
""" Return x and y vector with points to plot the offer curve """
x_quantity = np.linspace(0,self.xquant[-1])
y_price = np.array([self.quantity2price(x) for x in x_quantity])
y2_price = np.linspace(self.xprice[0],self.xprice[-1])
x2_quantity = np.array([self.price2quantity(p) for p in y2_price])
# merge data points into single array
x = np.array([x for x,_ in sorted(zip(list(x_quantity)+list(x2_quantity),list(y_price)+list(y2_price)))])
y = np.array([y for _,y in sorted(zip(list(x_quantity)+list(x2_quantity),list(y_price)+list(y2_price)))])
return x,y
def get_generator_bids(gens):
""" Takes a panda dataframe with generator info, and returns a dataframe with bids
with the columns [cap,mc_min,mc_max]
cap - total capacity of bid
mc_min - minimum marginal cost (=c1)
mc_max - maximum marginal cost (=2*c2)
"""
bids = pd.DataFrame(columns=['cap','mc_min','mc_max'])
bids.loc[:,'cap'] = gens.loc[:,'pmax']
bids.loc[:,'mc_min'] = gens.loc[:,'c1']
bids.loc[:,'mc_max'] = gens.loc[:,'pmax'] * gens.loc[:,'c2']*2 + gens.loc[:,'c1']
bids.index = list(range(bids.__len__()))
return bids
if __name__ == "__main__":
with open('Data/generators.pkl','rb') as f:
gens = pickle.load(f)
# gens = pd.DataFrame(columns=['c1','c2','pmax'],index=[1,2])
# gens.loc[1,:] = [10,0,10000]
# gens.loc[2,:] = [20,0,10000]
# gens.loc[3,:] = [15,0.0005,10000]
s = SupplyCurve(gens=gens)
s.plot()
s.add_bids(pd.DataFrame(np.array([[10000,10,10],[10000,80,80]]),columns=['cap','mc_min','mc_max']))
s.plot()
x,y = s.get_curve()
plt.plot(x,y)
| 3.421875
| 3
|
setup.py
|
jsfehler/pytest-packagetree
| 0
|
12775149
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import codecs
from setuptools import setup
setup(
name='pytest-packagetree',
version='0.0.1',
author='<NAME>',
author_email='<EMAIL>',
maintainer='<NAME>',
maintainer_email='<EMAIL>',
license='MIT',
url='https://github.com/jsfehler/pytest-packagetree',
description='Pytest plugin or package-tree',
packages=['pytest_packagetree'],
install_requires=['pytest>=3.5.0', 'package-tree'],
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: Pytest',
'Intended Audience :: Developers',
'Topic :: Software Development :: Testing',
'Programming Language :: Python',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: Implementation :: CPython',
'Operating System :: OS Independent',
'License :: OSI Approved :: MIT License',
],
entry_points={
'pytest11': [
'packagetree = pytest_packagetree.plugin',
],
},
)
| 1.101563
| 1
|
eufySecurityApi/cli.py
|
Rihan9/uefiSecurityApi
| 1
|
12775150
|
<gh_stars>1-10
import click, logging, asyncio, time
from .api import Api
from .const import TWO_FACTOR_AUTH_METHODS
import asyncio
_logger = logging.getLogger(__name__)
logging.basicConfig(format='%(name)-10s %(levelname)-8s %(message)s')
uefyApi = None
#pylint: disable=no-value-for-parameter
try:
loop = asyncio.get_running_loop()
except:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
class MyContext(click.Context):
def __init__(self):
self.uefyApi = None
@click.group(chain=True)
@click.pass_context
@click.option('--debug/--no-debug', prompt='activate debug', default=False)
def cli(ctx, debug):
_logger.debug('cli: %s, %s' %(type(ctx), ctx))
if(ctx.obj is None):
ctx.obj = MyContext()
_logger.parent.setLevel(logging.DEBUG if debug else logging.INFO)
_logger.setLevel(logging.DEBUG if debug else logging.INFO)
@cli.command()
@click.pass_context
@click.option('--username', prompt='eufy security username', default=None)
@click.option('--password', prompt='<PASSWORD> password', default=None)
@click.option('--tfa', prompt='preferred two factor authentication method (EMAIL, SMS, PUSH)', default='EMAIL')
def login(ctx, username, password, tfa):
_logger.debug('Username: %s, Password: %s, tfa: %s' % (username, password, tfa))
try:
ctx.parent.obj.uefyApi = Api(username=username, password=password, preferred2FAMethod=TWO_FACTOR_AUTH_METHODS[tfa])
response = asyncio.run(ctx.parent.obj.uefyApi.authenticate())
click.echo('Response: %s' % response)
if(response == 'OK'):
click.echo('Token: %s' % ctx.parent.obj.uefyApi.token)
click.echo('Token_expire: %s' % ctx.parent.obj.uefyApi.token_expire_at)
click.echo('Domain: %s' % ctx.parent.obj.uefyApi.domain)
elif(response == 'send_verify_code'):
verificationCode = click.prompt('Enter verification code: %s')
response = asyncio.run(ctx.parent.obj.uefyApi.sendVerifyCode(verificationCode))
click.echo('Response: %s' % response)
if(response == 'OK'):
click.echo('Token: %s' % ctx.parent.obj.uefyApi.token)
click.echo('Token_expire: %s' % ctx.parent.obj.uefyApi.token_expire_at)
click.echo('Domain: %s' % ctx.parent.obj.uefyApi.domain)
except Exception as e:
_logger.exception(e)
pass
pass
@cli.command()
@click.pass_context
@click.option('--token', prompt='eufy token', default=None, required=False)
@click.option('--token_expire_at', prompt='eufy token expiratio timestamp', default=None, required=False)
@click.option('--domain', prompt='eufy domain', default=None, required=False)
def session(ctx, token, domain, token_expire_at):
ctx.parent.obj.uefyApi = Api(token=token, domain=domain, token_expire_at=int(token_expire_at))
@cli.command()
@click.pass_context
def devices(ctx):
try:
asyncio.run(ctx.parent.obj.uefyApi.update())
for deviceSn, device in ctx.parent.obj.uefyApi.devices.items():
click.echo(device)
for stationSn, station in ctx.parent.obj.uefyApi.stations.items():
click.echo(station)
# print(ctx.parent.obj.uefyApi.devices.values())
except Exception as e:
_logger.exception(e)
pass
@cli.command()
@click.pass_context
@click.option('--serial', prompt='eufy device serial id', default=None, required=False)
def monitor(ctx, serial):
asyncio.run(ctx.parent.obj.uefyApi.update(device_sn=serial))
async def update_print(attributes):
for attribute in attributes:
# _logger.debug(attribute)
click.echo('updated: %s, from \'%s\' to \'%s\'' % attribute)
if(serial in ctx.parent.obj.uefyApi.devices):
ctx.parent.obj.uefyApi.devices[serial].subscribe([], update_print)
try:
for i in range(0,60*5):
asyncio.run(ctx.parent.obj.uefyApi.update(device_sn=serial))
time.sleep(1)
except Exception as e:
_logger.exception(e)
else:
click.echo('unknown serial: %s' % serial)
if __name__ == '__main__':
cli()
loop.run_until_complete()
loop.close()
| 2.3125
| 2
|