blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 616 | content_id stringlengths 40 40 | detected_licenses listlengths 0 69 | license_type stringclasses 2
values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 63 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.91k 686M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 220
values | src_encoding stringclasses 30
values | language stringclasses 1
value | is_vendor bool 2
classes | is_generated bool 2
classes | length_bytes int64 2 10.3M | extension stringclasses 257
values | content stringlengths 2 10.3M | authors listlengths 1 1 | author_id stringlengths 0 212 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
fe9104398906dec76bfa43b3935fecd2e7278928 | 887d40b6b2222942567d1a1fe36aec7194f63a5b | /tests/providers/hashicorp/_internal_client/test_vault_client.py | 585f19c02474f0589b5f922f4bb56fb563917a2a | [
"Apache-2.0",
"BSD-3-Clause",
"MIT",
"Python-2.0"
] | permissive | bryzgaloff/airflow | 41dd16619edd79e9cd9feb9fabd8269b155b586d | d7602654526fdd2876466371404784bd17cfe0d2 | refs/heads/master | 2022-12-05T08:35:02.005873 | 2020-08-25T08:50:21 | 2020-08-25T08:50:21 | 290,187,177 | 0 | 0 | Apache-2.0 | 2020-08-25T10:41:31 | 2020-08-25T10:41:30 | null | UTF-8 | Python | false | false | 45,470 | py | # pylint: disable=no-member
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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 unittest import mock
from unittest.case import TestCase
from hvac.exceptions import InvalidPath, VaultError
from mock import mock_open, patch
from airflow.providers.hashicorp._internal_client.vault_client import _VaultClient # noqa
class TestVaultClient(TestCase):
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_version_wrong(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, 'The version is not supported: 4'):
_VaultClient(auth_type="approle", kv_engine_version=4)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_custom_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="userpass", mount_point="custom")
self.assertEqual("custom", vault_client.mount_point)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_version_one_init(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="userpass", kv_engine_version=1)
self.assertEqual(1, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_approle(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="approle", role_id="role", url="http://localhost:8180",
secret_id="pass")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_approle.assert_called_with(role_id="role", secret_id="pass")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_approle_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="approle", role_id="role", url="http://localhost:8180",
secret_id="pass", auth_mount_point="other")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_approle.assert_called_with(role_id="role", secret_id="pass", mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_approle_missing_role(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "requires 'role_id'"):
_VaultClient(
auth_type="approle",
url="http://localhost:8180",
secret_id="pass")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_aws_iam(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="aws_iam", role_id="role", url="http://localhost:8180",
key_id="user", secret_id='pass')
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_aws_iam.assert_called_with(
access_key='user',
secret_key='pass',
role="role",
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_aws_iam_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="aws_iam", role_id="role", url="http://localhost:8180",
key_id="user", secret_id='pass', auth_mount_point="other")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_aws_iam.assert_called_with(
access_key='user',
secret_key='pass',
role="role",
mount_point='other'
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_azure(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="azure", azure_tenant_id="tenant_id", azure_resource="resource",
url="http://localhost:8180", key_id="user", secret_id='pass')
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.azure.configure.assert_called_with(
tenant_id="tenant_id",
resource="resource",
client_id="user",
client_secret="pass",
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_azure_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="azure", azure_tenant_id="tenant_id", azure_resource="resource",
url="http://localhost:8180", key_id="user", secret_id='pass',
auth_mount_point="other")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.azure.configure.assert_called_with(
tenant_id="tenant_id",
resource="resource",
client_id="user",
client_secret="pass",
mount_point="other"
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_azure_missing_resource(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "requires 'azure_resource'"):
_VaultClient(
auth_type="azure",
azure_tenant_id="tenant_id",
url="http://localhost:8180",
key_id="user",
secret_id='pass')
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_azure_missing_tenant_id(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "requires 'azure_tenant_id'"):
_VaultClient(
auth_type="azure",
azure_resource='resource',
url="http://localhost:8180",
key_id="user",
secret_id='pass')
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider._get_scopes")
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider.get_credentials_and_project_id")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_gcp(self, mock_hvac, mock_get_credentials, mock_get_scopes):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_get_scopes.return_value = ['scope1', 'scope2']
mock_get_credentials.return_value = ("credentials", "project_id")
vault_client = _VaultClient(auth_type="gcp", gcp_key_path="path.json", gcp_scopes="scope1,scope2",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
mock_get_scopes.assert_called_with("scope1,scope2")
mock_get_credentials.assert_called_with(
key_path="path.json",
keyfile_dict=None,
scopes=['scope1', 'scope2']
)
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.gcp.configure.assert_called_with(
credentials="credentials",
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider._get_scopes")
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider.get_credentials_and_project_id")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_gcp_different_auth_mount_point(self, mock_hvac, mock_get_credentials, mock_get_scopes):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_get_scopes.return_value = ['scope1', 'scope2']
mock_get_credentials.return_value = ("credentials", "project_id")
vault_client = _VaultClient(auth_type="gcp", gcp_key_path="path.json", gcp_scopes="scope1,scope2",
url="http://localhost:8180", auth_mount_point="other")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
mock_get_scopes.assert_called_with("scope1,scope2")
mock_get_credentials.assert_called_with(
key_path="path.json",
keyfile_dict=None,
scopes=['scope1', 'scope2']
)
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.gcp.configure.assert_called_with(
credentials="credentials",
mount_point="other"
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider._get_scopes")
@mock.patch("airflow.providers.google.cloud.utils.credentials_provider.get_credentials_and_project_id")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_gcp_dict(self, mock_hvac, mock_get_credentials, mock_get_scopes):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_get_scopes.return_value = ['scope1', 'scope2']
mock_get_credentials.return_value = ("credentials", "project_id")
vault_client = _VaultClient(auth_type="gcp", gcp_keyfile_dict={"key": "value"},
gcp_scopes="scope1,scope2",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
mock_get_scopes.assert_called_with("scope1,scope2")
mock_get_credentials.assert_called_with(
key_path=None,
keyfile_dict={"key": "value"},
scopes=['scope1', 'scope2']
)
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.gcp.configure.assert_called_with(
credentials="credentials",
)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_github(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="github",
token="s.7AU0I51yv1Q1lxOIg1F3ZRAS",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.github.login.assert_called_with(
token="s.7AU0I51yv1Q1lxOIg1F3ZRAS")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_github_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="github",
token="s.7AU0I51yv1Q1lxOIg1F3ZRAS",
url="http://localhost:8180", auth_mount_point="other")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.github.login.assert_called_with(
token="s.7AU0I51yv1Q1lxOIg1F3ZRAS", mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_github_missing_token(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "'github' authentication type requires 'token'"):
_VaultClient(auth_type="github", url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_kubernetes_default_path(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="kubernetes",
kubernetes_role="kube_role",
url="http://localhost:8180")
with patch("builtins.open", mock_open(read_data="data")) as mock_file:
client = vault_client.client
mock_file.assert_called_with("/var/run/secrets/kubernetes.io/serviceaccount/token")
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_kubernetes.assert_called_with(
role="kube_role", jwt="data")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_kubernetes(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="kubernetes",
kubernetes_role="kube_role",
kubernetes_jwt_path="path",
url="http://localhost:8180")
with patch("builtins.open", mock_open(read_data="data")) as mock_file:
client = vault_client.client
mock_file.assert_called_with("path")
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_kubernetes.assert_called_with(
role="kube_role", jwt="data")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_kubernetes_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="kubernetes",
kubernetes_role="kube_role",
kubernetes_jwt_path="path",
auth_mount_point="other",
url="http://localhost:8180")
with patch("builtins.open", mock_open(read_data="data")) as mock_file:
client = vault_client.client
mock_file.assert_called_with("path")
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_kubernetes.assert_called_with(
role="kube_role", jwt="data", mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_kubernetes_missing_role(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "requires 'kubernetes_role'"):
_VaultClient(auth_type="kubernetes",
kubernetes_jwt_path="path",
url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_kubernetes_kubernetes_jwt_path_none(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "requires 'kubernetes_jwt_path'"):
_VaultClient(auth_type="kubernetes",
kubernetes_role='kube_role',
kubernetes_jwt_path=None,
url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_ldap(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="ldap",
username="user",
password="pass",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.ldap.login.assert_called_with(
username="user", password="pass")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_ldap_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="ldap",
username="user",
password="pass",
auth_mount_point="other",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.ldap.login.assert_called_with(
username="user", password="pass", mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_radius_missing_host(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "radius_host"):
_VaultClient(auth_type="radius", radius_secret="pass", url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_radius_missing_secret(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "radius_secret"):
_VaultClient(auth_type="radius", radius_host="radhost", url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_radius(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="radius",
radius_host="radhost",
radius_secret="pass",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.radius.configure.assert_called_with(
host="radhost",
secret="pass",
port=None)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_radius_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="radius",
radius_host="radhost",
radius_secret="pass",
auth_mount_point="other",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.radius.configure.assert_called_with(
host="radhost",
secret="pass",
port=None,
mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_radius_port(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth.radius.configure.assert_called_with(
host="radhost",
secret="pass",
port=8110)
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_token_missing_token(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with self.assertRaisesRegex(VaultError, "'token' authentication type requires 'token'"):
_VaultClient(auth_type="token", url="http://localhost:8180")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_token(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="token",
token="s.7AU0I51yv1Q1lxOIg1F3ZRAS", url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.is_authenticated.assert_called_with()
self.assertEqual("s.7AU0I51yv1Q1lxOIg1F3ZRAS", client.token)
self.assertEqual(2, vault_client.kv_engine_version)
self.assertEqual("secret", vault_client.mount_point)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_token_path(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
with open('/tmp/test_token.txt', 'w+') as the_file:
the_file.write('s.7AU0I51yv1Q1lxOIg1F3ZRAS')
vault_client = _VaultClient(auth_type="token",
token_path="/tmp/test_token.txt", url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.is_authenticated.assert_called_with()
self.assertEqual("s.7AU0I51yv1Q1lxOIg1F3ZRAS", client.token)
self.assertEqual(2, vault_client.kv_engine_version)
self.assertEqual("secret", vault_client.mount_point)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_default_auth_type(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(token="s.7AU0I51yv1Q1lxOIg1F3ZRAS", url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.is_authenticated.assert_called_with()
self.assertEqual("s.7AU0I51yv1Q1lxOIg1F3ZRAS", client.token)
self.assertEqual("token", vault_client.auth_type)
self.assertEqual(2, vault_client.kv_engine_version)
self.assertEqual("secret", vault_client.mount_point)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_userpass(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="userpass",
username="user", password="pass", url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_userpass.assert_called_with(
username="user", password="pass")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_userpass_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="userpass",
username="user",
password="pass",
auth_mount_point="other",
url="http://localhost:8180")
client = vault_client.client
mock_hvac.Client.assert_called_with(url='http://localhost:8180')
client.auth_userpass.assert_called_with(
username="user", password="pass", mount_point="other")
client.is_authenticated.assert_called_with()
self.assertEqual(2, vault_client.kv_engine_version)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_non_existing_key_v2(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
# Response does not contain the requested key
mock_client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath()
vault_client = _VaultClient(auth_type="token", token="s.7AU0I51yv1Q1lxOIg1F3ZRAS",
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertIsNone(secret)
mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
mount_point='secret', path='missing', version=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_non_existing_key_v2_different_auth(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
# Response does not contain the requested key
mock_client.secrets.kv.v2.read_secret_version.side_effect = InvalidPath()
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertIsNone(secret)
self.assertEqual("secret", vault_client.mount_point)
mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
mount_point='secret', path='missing', version=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_non_existing_key_v1(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
# Response does not contain the requested key
mock_client.secrets.kv.v1.read_secret.side_effect = InvalidPath()
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertIsNone(secret)
mock_client.secrets.kv.v1.read_secret.assert_called_once_with(
mount_point='secret', path='missing')
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_existing_key_v2(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v2.read_secret_version.return_value = {
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'data': {
'data': {'secret_key': 'secret_value'},
'metadata': {'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1}},
'wrap_info': None,
'warnings': None,
'auth': None
}
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertEqual({'secret_key': 'secret_value'}, secret)
mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
mount_point='secret', path='missing', version=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_existing_key_v2_version(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v2.read_secret_version.return_value = {
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'data': {
'data': {'secret_key': 'secret_value'},
'metadata': {'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1}},
'wrap_info': None,
'warnings': None,
'auth': None
}
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing", secret_version=1)
self.assertEqual({'secret_key': 'secret_value'}, secret)
mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
mount_point='secret', path='missing', version=1)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_existing_key_v1(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v1.read_secret.return_value = {
'request_id': '182d0673-618c-9889-4cba-4e1f4cfe4b4b',
'lease_id': '',
'renewable': False,
'lease_duration': 2764800,
'data': {'value': 'world'},
'wrap_info': None,
'warnings': None,
'auth': None}
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertEqual({'value': 'world'}, secret)
mock_client.secrets.kv.v1.read_secret.assert_called_once_with(
mount_point='secret', path='missing')
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_existing_key_v1_different_auth_mount_point(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v1.read_secret.return_value = {
'request_id': '182d0673-618c-9889-4cba-4e1f4cfe4b4b',
'lease_id': '',
'renewable': False,
'lease_duration': 2764800,
'data': {'value': 'world'},
'wrap_info': None,
'warnings': None,
'auth': None}
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
auth_mount_point="other",
url="http://localhost:8180")
secret = vault_client.get_secret(secret_path="missing")
self.assertEqual({'value': 'world'}, secret)
mock_client.secrets.kv.v1.read_secret.assert_called_once_with(
mount_point='secret', path='missing')
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_existing_key_v1_version(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(auth_type="token", token="s.7AU0I51yv1Q1lxOIg1F3ZRAS",
url="http://localhost:8180", kv_engine_version=1)
with self.assertRaisesRegex(VaultError, "Secret version"):
vault_client.get_secret(secret_path="missing", secret_version=1)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_secret_metadata_v2(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v2.read_secret_metadata.return_value = {
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'metadata': [
{'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1},
{'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 2},
]
}
vault_client = _VaultClient(auth_type="token", token="s.7AU0I51yv1Q1lxOIg1F3ZRAS",
url="http://localhost:8180")
metadata = vault_client.get_secret_metadata(secret_path="missing")
self.assertEqual(
{
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'metadata': [
{'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1},
{'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 2},
]
}, metadata)
mock_client.secrets.kv.v2.read_secret_metadata.assert_called_once_with(
mount_point='secret', path='missing')
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_secret_metadata_v1(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
with self.assertRaisesRegex(VaultError, "Metadata might only be used with"
" version 2 of the KV engine."):
vault_client.get_secret_metadata(secret_path="missing")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_secret_including_metadata_v2(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
mock_client.secrets.kv.v2.read_secret_version.return_value = {
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'data': {
'data': {'secret_key': 'secret_value'},
'metadata': {'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1}},
'wrap_info': None,
'warnings': None,
'auth': None
}
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
metadata = vault_client.get_secret_including_metadata(secret_path="missing")
self.assertEqual(
{
'request_id': '94011e25-f8dc-ec29-221b-1f9c1d9ad2ae',
'lease_id': '',
'renewable': False,
'lease_duration': 0,
'data': {
'data': {'secret_key': 'secret_value'},
'metadata': {'created_time': '2020-03-16T21:01:43.331126Z',
'deletion_time': '',
'destroyed': False,
'version': 1}},
'wrap_info': None,
'warnings': None,
'auth': None
}, metadata)
mock_client.secrets.kv.v2.read_secret_version.assert_called_once_with(
mount_point='secret', path='missing', version=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_get_secret_including_metadata_v1(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
with self.assertRaisesRegex(VaultError, "Metadata might only be used with"
" version 2 of the KV engine."):
vault_client.get_secret_including_metadata(secret_path="missing")
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v2(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'}
)
mock_client.secrets.kv.v2.create_or_update_secret.assert_called_once_with(
mount_point='secret', secret_path='path', secret={'key': 'value'}, cas=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v2_method(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
with self.assertRaisesRegex(VaultError, "The method parameter is only valid for version 1"):
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'},
method="post"
)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v2_cas(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
url="http://localhost:8180")
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'},
cas=10
)
mock_client.secrets.kv.v2.create_or_update_secret.assert_called_once_with(
mount_point='secret', secret_path='path', secret={'key': 'value'}, cas=10)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v1(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'}
)
mock_client.secrets.kv.v1.create_or_update_secret.assert_called_once_with(
mount_point='secret', secret_path='path', secret={'key': 'value'}, method=None)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v1_cas(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
with self.assertRaisesRegex(VaultError, "The cas parameter is only valid for version 2"):
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'},
cas=10
)
@mock.patch("airflow.providers.hashicorp._internal_client.vault_client.hvac")
def test_create_or_update_secret_v1_post(self, mock_hvac):
mock_client = mock.MagicMock()
mock_hvac.Client.return_value = mock_client
vault_client = _VaultClient(
auth_type="radius",
radius_host="radhost",
radius_port=8110,
radius_secret="pass",
kv_engine_version=1,
url="http://localhost:8180")
vault_client.create_or_update_secret(
secret_path="path",
secret={'key': 'value'},
method="post"
)
mock_client.secrets.kv.v1.create_or_update_secret.assert_called_once_with(
mount_point='secret', secret_path='path', secret={'key': 'value'}, method="post")
| [
"noreply@github.com"
] | bryzgaloff.noreply@github.com |
f73bf75821ac30a9200e86ef0137dfc76d611fad | 45fa6e79ef919321be687a5fa92d9ce33b11a46f | /python_training/p9.py | 6390edb41c87f63983fe58a89e8125ec4a84fc98 | [] | no_license | AlanMorningLight/GAN_work_internship | 95ac378261dc53ef1d9050e62b505a75943352fb | 9c98540797f09fbc57791257dc7472986ae71705 | refs/heads/master | 2022-03-29T10:45:48.562142 | 2020-01-23T16:15:49 | 2020-01-23T16:15:49 | 258,431,214 | 0 | 1 | null | 2020-04-24T06:53:16 | 2020-04-24T06:53:16 | null | UTF-8 | Python | false | false | 231 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 14 18:21:22 2019
@author: sarfaraz
"""
import numpy as np
x = [1,2, 3, 4,5, 6, 7, 9,10]
np_x = np.array(x)
high = np_x > 2
print(high)
print(np_x[high])
| [
"sarfarazalam.sa53@gmail.com"
] | sarfarazalam.sa53@gmail.com |
8688f0f01915077265c19b58b0e1101afbd6b545 | 6bf7c633f31b2c7c222f160b5526bde5fa734690 | /magenta/models/latent_transfer/common.py | 4f8028201667b166e47fec00669c1c5d5f950408 | [
"Apache-2.0"
] | permissive | dax-1895/magenta | 04fb27f15fdfd7452980858c364dae46bd861c35 | 4393c218147e92d805bbe85fddebd3397c766715 | refs/heads/master | 2020-04-03T22:29:31.388322 | 2018-10-31T03:39:54 | 2018-10-31T03:39:54 | 155,604,293 | 0 | 1 | Apache-2.0 | 2018-10-31T18:18:48 | 2018-10-31T18:18:47 | null | UTF-8 | Python | false | false | 8,387 | py | # Copyright 2018 Google Inc. All Rights Reserved.
#
# 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.
"""Common functions/helpers for dataspace model.
This library contains many common functions and helpers used to for the
dataspace model (defined in `train_dataspace.py`) that is used in training
(`train_dataspace.py` and `train_dataspace_classifier.py`), sampling
(`sample_dataspace.py`) and encoding (`encode_dataspace.py`).
These components are classified in the following categories:
- Loading helper that makes dealing with config / dataset easier. This
includes:
`get_model_uid`, `load_config`, `dataset_is_mnist_family`,
`load_dataset`, `get_index_grouped_by_label`.
- Helper making dumping dataspace data easier. This includes:
`batch_image`, `save_image`, `make_grid`, `post_proc`
- Miscellaneous Helpers, including
`get_default_scratch`, `ObjectBlob`,
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from functools import partial
import importlib
import os
import numpy as np
from PIL import Image
import tensorflow as tf
from magenta.models.latent_transfer import local_mnist
FLAGS = tf.flags.FLAGS
tf.flags.DEFINE_string(
'default_scratch', '/tmp/', 'The default root directory for scratching. '
'It can contain \'~\' which would be handled correctly.')
def get_default_scratch():
"""Get the default directory for scratching."""
return os.path.expanduser(FLAGS.default_scratch)
class ObjectBlob(object):
"""Helper object storing key-value pairs as attributes."""
def __init__(self, **kwargs):
for k, v in kwargs.items():
self.__dict__[k] = v
def get_model_uid(config_name, exp_uid):
"""Helper function returning model's uid."""
return config_name + exp_uid
def load_config(config_name):
"""Load config from corresponding configs.<config_name> module."""
return importlib.import_module('configs.%s' % config_name).config
def _load_celeba(data_path, postfix):
"""Load the CelebA dataset."""
with tf.gfile.Open(os.path.join(data_path, 'train' + postfix), 'rb') as f:
train_data = np.load(f)
with tf.gfile.Open(os.path.join(data_path, 'eval' + postfix), 'rb') as f:
eval_data = np.load(f)
with tf.gfile.Open(os.path.join(data_path, 'test' + postfix), 'rb') as f:
test_data = np.load(f)
with tf.gfile.Open(os.path.join(data_path, 'attr_train.npy'), 'rb') as f:
attr_train = np.load(f)
with tf.gfile.Open(os.path.join(data_path, 'attr_eval.npy'), 'rb') as f:
attr_eval = np.load(f)
with tf.gfile.Open(os.path.join(data_path, 'attr_test.npy'), 'rb') as f:
attr_test = np.load(f)
attr_mask = [4, 8, 9, 11, 15, 20, 24, 31, 35, 39]
attribute_names = [
'Bald',
'Black_Hair',
'Blond_Hair',
'Brown_Hair',
'Eyeglasses',
'Male',
'No_Beard',
'Smiling',
'Wearing_Hat',
'Young',
]
attr_train = attr_train[:, attr_mask]
attr_eval = attr_eval[:, attr_mask]
attr_test = attr_test[:, attr_mask]
return (train_data, eval_data, test_data, attr_train, attr_eval, attr_test,
attribute_names)
def dataset_is_mnist_family(dataset):
"""returns if dataset is of MNIST family."""
return dataset.lower() == 'mnist' or dataset.lower() == 'fashion-mnist'
def load_dataset(config):
"""Load dataset following instruction in `config`."""
if dataset_is_mnist_family(config['dataset']):
crop_width = config.get('crop_width', None) # unused
img_width = config.get('img_width', None) # unused
scratch = config.get('scratch', get_default_scratch())
basepath = os.path.join(scratch, config['dataset'].lower())
data_path = os.path.join(basepath, 'data')
save_path = os.path.join(basepath, 'ckpts')
tf.gfile.MakeDirs(data_path)
tf.gfile.MakeDirs(save_path)
# black-on-white MNIST (harder to learn than white-on-black MNIST)
# Running locally (pre-download data locally)
mnist_train, mnist_eval, mnist_test = local_mnist.read_data_sets(
data_path, one_hot=True)
train_data = np.concatenate([mnist_train.images, mnist_eval.images], axis=0)
attr_train = np.concatenate([mnist_train.labels, mnist_eval.labels], axis=0)
eval_data = mnist_test.images
attr_eval = mnist_test.labels
attribute_names = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
elif config['dataset'] == 'CELEBA':
crop_width = config['crop_width']
img_width = config['img_width']
postfix = '_crop_%d_res_%d.npy' % (crop_width, img_width)
# Load Data
scratch = config.get('scratch', get_default_scratch())
basepath = os.path.join(scratch, 'celeba')
data_path = os.path.join(basepath, 'data')
save_path = os.path.join(basepath, 'ckpts')
(train_data, eval_data, _, attr_train, attr_eval, _,
attribute_names) = _load_celeba(data_path, postfix)
else:
raise NotImplementedError
return ObjectBlob(
crop_width=crop_width,
img_width=img_width,
basepath=basepath,
data_path=data_path,
save_path=save_path,
train_data=train_data,
attr_train=attr_train,
eval_data=eval_data,
attr_eval=attr_eval,
attribute_names=attribute_names,
)
def get_index_grouped_by_label(label):
"""Get (an array of) index grouped by label.
This array is used for label-level sampling.
It aims at MNIST and CelebA (in Jesse et al. 2018) with 10 labels.
Args:
label: a list of labels in integer.
Returns:
A (# label - sized) list of lists contatining indices of that label.
"""
index_grouped_by_label = [[] for _ in range(10)]
for i, label in enumerate(label):
index_grouped_by_label[label].append(i)
return index_grouped_by_label
def batch_image(b, max_images=64, rows=None, cols=None):
"""Turn a batch of images into a single image mosaic."""
mb = min(b.shape[0], max_images)
if rows is None:
rows = int(np.ceil(np.sqrt(mb)))
cols = rows
diff = rows * cols - mb
b = np.vstack([b[:mb], np.zeros([diff, b.shape[1], b.shape[2], b.shape[3]])])
tmp = b.reshape(-1, cols * b.shape[1], b.shape[2], b.shape[3])
img = np.hstack(tmp[i] for i in range(rows))
return img
def save_image(img, filepath):
"""Save an image to filepath.
It assumes `img` is a float numpy array with value in [0, 1]
Args:
img: a float numpy array with value in [0, 1] representing the image.
filepath: a string of file path.
"""
img = np.maximum(0, np.minimum(1, img))
im = Image.fromarray(np.uint8(img * 255))
im.save(filepath)
def make_grid(boundary=2.0, number_grid=50, dim_latent=2):
"""Helper function making 1D or 2D grid for evaluation purpose."""
zs = np.linspace(-boundary, boundary, number_grid)
z_grid = []
if dim_latent == 1:
for x in range(number_grid):
z_grid.append([zs[x]])
dim_grid = 1
else:
for x in range(number_grid):
for y in range(number_grid):
z_grid.append([0.] * (dim_latent - 2) + [zs[x], zs[y]])
dim_grid = 2
z_grid = np.array(z_grid)
return ObjectBlob(z_grid=z_grid, dim_grid=dim_grid)
def make_batch_image_grid(dim_grid, number_grid):
"""Returns a patched `make_grid` function for grid."""
assert dim_grid in (1, 2)
if dim_grid == 1:
batch_image_grid = partial(
batch_image,
max_images=number_grid,
rows=1,
cols=number_grid,
)
else:
batch_image_grid = partial(
batch_image,
max_images=number_grid * number_grid,
rows=number_grid,
cols=number_grid,
)
return batch_image_grid
def post_proc(img, config):
"""Post process image `img` according to the dataset in `config`."""
x = img
x = np.minimum(1., np.maximum(0., x)) # clipping
if dataset_is_mnist_family(config['dataset']):
x = np.reshape(x, (-1, 28, 28))
x = np.stack((x,) * 3, -1) # grey -> rgb
return x
| [
"adarob@google.com"
] | adarob@google.com |
8164c15ce080bba486b0e97395893638e109f140 | 673e829dda9583c8dd2ac8d958ba1dc304bffeaf | /data/multilingual/Latn.QVA/Sun-ExtA_16/pdf_to_json_test_Latn.QVA_Sun-ExtA_16.py | c9e6eeadc61bf0cfc64ae23cd016123070abc397 | [
"BSD-3-Clause"
] | permissive | antoinecarme/pdf_to_json_tests | 58bab9f6ba263531e69f793233ddc4d33b783b7e | d57a024fde862e698d916a1178f285883d7a3b2f | refs/heads/master | 2021-01-26T08:41:47.327804 | 2020-02-27T15:54:48 | 2020-02-27T15:54:48 | 243,359,934 | 2 | 1 | null | null | null | null | UTF-8 | Python | false | false | 311 | py | import pdf_to_json as p2j
import json
url = "file:data/multilingual/Latn.QVA/Sun-ExtA_16/udhr_Latn.QVA_Sun-ExtA_16.pdf"
lConverter = p2j.pdf_to_json.pdf_to_json_converter()
lConverter.mImageHashOnly = True
lDict = lConverter.convert(url)
print(json.dumps(lDict, indent=4, ensure_ascii=False, sort_keys=True))
| [
"antoine.carme@laposte.net"
] | antoine.carme@laposte.net |
1613bf3f12a9e5fccc309f948050bb9bdf630b88 | be043d749f7b9fe23d9e8de2311315dbfb77dbd1 | /projeto/urls.py | 98b646b26c231fdc0e33106b062cf2b3a724e49f | [] | no_license | lpsiqueira/trab8DevWeb | 835aa656d51e72838e6e02573c8a641900d3b0b7 | b3594ba297eaa25d0a1c1e696a9894e3359d7e7b | refs/heads/master | 2020-04-11T18:57:15.066380 | 2018-12-18T00:07:35 | 2018-12-18T00:07:35 | 162,017,059 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 965 | py | """projeto URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from django.conf.urls import include, url
from appsite.views import index
urlpatterns = [
path('admin/', admin.site.urls),
path('appsite/', include('appsite.urls')),
path('carrinho/', include('carrinho.urls')),
path('', index)
]
| [
"lucas@imac-de-lucas.home"
] | lucas@imac-de-lucas.home |
3a009aec8225f6560469ccca7aba70d535dcedea | d836e9652029cac18ed81ccb87cb11054c26e5da | /app/models/WelcomeModel.py | afe61ffb7122bea23fe250c62848b96641e75217 | [] | no_license | MikeHannon/notes_no_update | 96328a66c265db2eeb2f91348425a913ee75afda | f631f3a93b9f7f0f6b6b933102f6584c8f2cf340 | refs/heads/master | 2021-01-01T03:57:52.074913 | 2016-05-20T00:05:57 | 2016-05-20T00:05:57 | 59,227,295 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,041 | py |
from system.core.model import Model
class WelcomeModel(Model):
def __init__(self):
super(WelcomeModel, self).__init__()
def index(self):
query = "SELECT * FROM notes"
values = {}
return self.db.query_db(query,values)
def update(self,data,id):
query = "UPDATE notes set title = :title, description = :description, updated_at = NOW() where id = :id"
values = {
"title": data['title'],
"description": data['description'],
"id": id
}
self.db.query_db(query,values)
def delete(self,id):
query = "DELETE from notes WHERE id = :id"
values = {
"id" : id
}
self.db.query_db(query,values)
def create(self,data):
query = "INSERT into notes (title,description, created_at, updated_at) VALUES (:title,:description,NOW(), NOW())"
values = {
"title":data['title'],
"description":data['description']
}
self.db.query_db(query,values)
| [
"mjhannon@gmail.com"
] | mjhannon@gmail.com |
c7e8281c5e591ff8080371d412ff270244a0483f | 5f365910d9459e2ad17770565351e3f06889336c | /apps/coordenacao/views.py | 671fd72f732bd36c794de454e7d8ab462066eb21 | [] | no_license | AlissonMacedo/gestao_escolar | 0d40fa84d627bc9a571314dd256a78692ecf57b0 | cd42d950565496e8ffefbfac9603f8e1c3de85f0 | refs/heads/master | 2020-04-15T01:00:08.400258 | 2019-04-23T16:11:28 | 2019-04-23T16:11:28 | 164,259,591 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,438 | py | import json
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from secretaria.models import Matricula
from .forms import MatriculaCoordenacaoFormEditar
from django.http import HttpResponse
# ---------- Funções para COODENACAO Conferir e Conferidas ------------------------------------------
@login_required
def list_matriculas_coordenacao_conferir(request):
matriculas = Matricula.objects.filter(status_coordenacao=False)
return render(request, 'coordenacao/list_matricula_conferir.html', {'matriculas': matriculas})
@login_required
def list_matriculas_coordenacao_conferidas(request):
matriculas = Matricula.objects.filter(status_coordenacao=True)
return render(request, 'coordenacao/list_matricula_conferidas.html', {'matriculas': matriculas})
def editar_matricula_coordenacao(request, id):
matricula = Matricula.objects.get(id=id)
empresa_logada = request.user.funcionario.empresa
aluno = matricula.nomeAluno
turma = matricula.turma
form = MatriculaCoordenacaoFormEditar(request.POST or None,
request.FILES or None, instance=matricula)
if form.is_valid():
form.save()
return redirect('coordenacao')
return render(request, 'coordenacao/editar_matricula.html', {'form': form, 'matricula': matricula})
# ---------- FIM para COODENACAO ------------------------------------------
| [
"alissonmacedo@Alissons-MacBook-Pro.local"
] | alissonmacedo@Alissons-MacBook-Pro.local |
fcabb3413bd2cde35c9ddea8c6d5056e7efc6ac1 | 106d80a003d2c885d3e6d9b5321007ce1084fb03 | /icons_rc.py | 3ef007cd89ec072c5b3c3628d37a53061baba757 | [] | no_license | djays/RhythmBird | 22fedb2c4bc3f25798e65288a34208c27ed21ba1 | 5b55c467633da56bb55d2b7deb366947162fd0d0 | refs/heads/master | 2020-11-26T19:32:15.468153 | 2015-02-23T16:29:54 | 2015-02-23T16:29:54 | 31,215,326 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 229,884 | py | # -*- coding: utf-8 -*-
# Resource object code
#
# Created by: The Resource Compiler for PyQt (Qt v4.6.2)
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore
qt_resource_data = "\
\x00\x00\x07\xce\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x4b\x49\x44\
\x41\x54\x78\xda\xc5\x57\x5b\x6c\x9c\x47\x19\x3d\xdf\xfc\xd7\x5d\
\xef\xae\xed\xf5\x35\x59\xdf\x73\xb7\x93\x40\xd3\x5c\x68\xd2\xd2\
\x14\x24\xc2\xfd\x22\xd4\x08\x95\x07\x78\xe1\xa2\xbe\x10\xd4\xc2\
\x03\x12\x2a\x95\x0a\x82\x16\x91\x8a\x07\x10\xd0\x07\x54\x28\x54\
\x89\x44\x1f\x40\x82\x20\x55\x80\x42\x15\x10\xa9\xdb\x26\x21\x57\
\x12\xe3\xfa\x12\x67\xbd\xeb\xb5\x77\xff\xfd\xef\x33\xc3\xfc\xeb\
\xd4\x51\x12\xdb\x84\x12\xa9\x67\x75\x76\x66\xb5\x3b\x73\xce\x77\
\xbe\x59\xe9\x1f\x92\x52\xe2\xff\x01\x81\x48\xe2\xed\x6f\x72\xc7\
\x06\x0e\x1e\x25\xad\xb2\x66\xfd\x03\x39\xab\xf5\xe1\x1e\xab\x7f\
\x6f\x21\xd5\xbf\x76\x6d\xaa\xbf\xad\xc5\xc8\xd3\x7c\x58\x5a\x98\
\x0d\xa6\x66\xae\x05\x93\xff\x28\x05\x13\xbf\xd6\xa4\xf7\xf2\x4f\
\xee\x3d\x19\xdd\x15\x03\x3b\x5f\x2d\xa4\x6d\xdf\xfc\x8a\x49\xc6\
\x63\xdb\x5b\x76\xb6\x0d\x66\x87\xd0\x6e\xe7\x91\x36\x6c\xd8\x9a\
\x09\x8e\x08\x95\xb0\x82\x52\x54\x82\xe3\xfb\xf0\x03\x17\x63\xce\
\xa9\x79\x08\xf1\xc3\xb8\x29\x7e\xe6\xc8\xf0\x19\x07\xb7\xe0\xf0\
\xa5\x47\x7b\x36\x64\xdf\xdd\xfd\xd1\xee\x2f\x9e\x5c\xd5\xc0\xae\
\xe3\x7d\x9f\xb1\xa0\xfd\x60\x4f\xfb\x83\x6b\xb6\xe7\x87\x11\x50\
\x15\x91\x0c\xb1\x1a\x74\x32\x00\x6e\xe2\xd4\xdc\x28\x16\xdc\x89\
\x22\x11\xbe\xf6\x8b\x9d\xa3\xcf\xe3\x3a\xbe\x34\xba\xe7\x5b\x9b\
\x5a\xf6\x3d\x91\x86\x5e\xf9\xf2\xd0\xd3\xf9\x65\x0d\x10\x88\xbd\
\xeb\x77\x6b\x9f\x2e\xb4\xf5\x3c\xf6\x50\xe1\x7d\x10\xe4\x82\x4b\
\xfe\xbf\x9e\x0d\xcc\x45\x0b\xb8\x56\xfd\x17\x24\x0f\x9e\xf5\xc7\
\xd6\x3d\x9e\x5d\x37\xf6\xcd\x8c\xd1\xfd\xc4\x48\xfb\x7d\x78\x7d\
\xe6\xb7\xf8\xd1\x3d\x27\x48\x5f\xee\x50\x6d\x7a\xb1\xf3\xa5\x8d\
\x3d\x5b\x3e\x3e\xd2\x35\x82\x72\x54\xc4\xdb\x85\x06\x03\xeb\x9a\
\x77\x62\xc1\x2f\x1d\x2a\x0d\x5d\xf8\x90\xad\x77\x6f\x6a\x6b\x1a\
\x42\x29\x9c\x5d\x32\x79\x5b\x02\x1b\x7e\xde\x76\x78\xf3\xda\x6d\
\x87\x36\x0f\xac\x87\xc7\x5d\xac\x06\x5b\x4b\x81\x4b\x89\x58\x04\
\x90\xb8\xb1\x0f\x03\x81\x96\x2a\x22\x34\x69\x4d\xd0\xa4\x0e\xc1\
\x04\x6a\x51\x15\x19\x3d\x8b\xb9\xda\x1b\x58\xb3\xe3\x6f\x37\x27\
\x30\xf0\xb3\xfc\x67\x7b\x9a\x7a\x0e\x15\x0a\x05\xcc\x06\xe5\xdb\
\x2b\x22\x0d\x0b\xb1\x87\x71\x77\x1a\xa5\xa0\x84\x49\x6f\xa6\xd1\
\x9a\x76\x33\x8f\x56\x2b\x8b\x1e\xab\x0b\x85\x54\x27\x52\xcc\x04\
\x11\xe1\x2d\x4f\x01\x57\x06\x25\x96\x4c\xea\x64\x81\xcb\x5b\xfe\
\x05\x85\x9f\x16\x52\x96\x17\x8e\xdd\x7f\xdf\xfd\x5d\xae\xee\xe1\
\x56\x24\x8b\x4e\xd7\x2e\xe0\xac\x62\x02\x46\x84\x9c\x96\x69\x88\
\xd4\xb8\xa3\x44\x0d\x58\xa4\x23\xad\xa7\xb0\x2d\xbb\x11\x9d\x76\
\x07\x08\x4b\x1e\x20\xaf\xcb\x27\x7a\x19\x23\x8b\x30\xb8\x82\xea\
\xe5\xbe\x1b\x09\xc4\xe5\xda\x53\xc3\x03\x5b\xbb\x4a\x34\x0f\xc9\
\x6f\x6e\x0b\x07\xc3\x89\xf2\x2b\x70\x94\x50\x07\x6f\x81\x3c\x1b\
\xa1\x23\x50\xa3\x17\x3a\x9a\x65\x08\xbb\xd5\xca\xd5\x9a\x00\xa3\
\xcf\x82\x2f\x3d\x5c\x72\x2e\xa1\x12\x54\x30\x90\xee\x87\xa6\x69\
\x37\x89\x73\x08\x58\x3c\x82\x90\xc0\x48\xc7\x2c\x18\x14\xe8\x20\
\x69\xa6\x63\x7e\xc1\xe8\xb1\xe1\x44\x1e\xea\x91\xbf\xc4\x30\xe6\
\x78\xa5\xfc\x77\x84\x32\x40\x76\xc2\x42\xee\xaf\x86\xdf\xea\x59\
\xcf\x68\x46\xb4\xed\xdc\x77\x8b\xd9\x33\x4f\x4e\x35\x0b\xae\x0f\
\xa6\x2b\xe6\x93\x99\x7f\x9a\x6e\x6f\xdc\x85\x0c\x99\xf0\xe2\x2a\
\xa6\xfc\x71\xc4\x71\xd4\x60\xa4\x18\x72\xc5\x38\x46\xa0\x46\x90\
\xc4\x74\xb6\xb6\xd8\x82\xce\xa7\x32\x1f\xec\x6f\xe9\xfb\xbd\xdc\
\x6e\xde\xda\x73\x39\x11\x4c\xcb\xab\xc1\x8c\xd8\x12\xf4\xf2\xe8\
\xa2\x7b\xce\xb6\xcd\x03\xa7\x0f\x4d\x17\xb1\x0c\xf6\x3c\x37\x30\
\xc8\x38\x9d\x68\xde\x9c\xe9\xaa\xc9\x1a\x04\x24\xf2\x86\x3a\x13\
\x7a\x06\x22\xa9\xfe\x7a\x02\x39\x33\x03\x8b\xca\x30\xa5\x58\x6c\
\x01\xd7\xe4\x27\xec\x6e\x4b\xce\x71\x4f\x02\x48\xc8\x13\xfa\x32\
\x8c\x94\x78\xd4\xa7\x77\x06\xf2\x5a\x38\x9f\xea\xc6\xfe\x53\x9f\
\x9f\x5e\xc0\x0a\xd0\x32\xe2\xd1\xf6\xd6\x7c\x57\xc4\x42\xa4\xa4\
\x0e\x92\x1a\x34\x02\x84\x88\x95\xb8\x40\xac\xc8\xa1\x28\x42\x84\
\x9e\x40\xbd\xdd\x47\xc3\x80\x8c\xe4\xb0\xc8\x90\xe7\x8b\x30\x11\
\x0e\x15\x03\x45\xb7\x18\x16\x5d\x00\x7e\x7b\x90\x76\xdd\x66\xef\
\xfb\xa7\x3e\x5d\x5a\x51\xfc\x81\x63\x03\x5f\xef\xe8\x6b\x7b\x9c\
\x91\x04\x13\x1a\xb2\xd4\x0e\xc6\xcc\x44\x54\x91\x83\x2b\x4a\x09\
\xf8\xd2\x05\xe2\x08\x99\x28\x46\xb6\x58\x5f\x34\x60\x93\x65\x39\
\x70\x4a\x9e\xf0\xc3\x44\x50\xd1\x23\x90\xeb\x4a\xcf\x6b\xd2\x2d\
\x2f\xf6\x23\x8f\x6c\x9c\xc0\x0a\xf8\xdc\x99\x87\x7a\x87\xba\x0b\
\xdf\x33\x62\x80\x25\x95\x93\xd6\x88\x3b\x96\x00\x27\x42\xc0\x95\
\x09\x11\xa2\xce\x1d\x84\xe0\x68\xd2\xb2\x88\x3c\x59\xac\x7b\xbb\
\x16\x0d\x64\x0c\x0b\x73\x70\x66\x03\x1e\x04\x6f\x19\x10\x52\xf8\
\x8a\x5e\xb7\xd5\xe2\x3b\xd3\x7e\xf5\xca\x99\x72\x05\x1f\xc1\xb2\
\x48\x33\x74\x3a\x75\x59\x9d\xa8\x96\xd5\xce\x04\x8a\x49\x20\x82\
\x24\x0e\xa8\x77\x52\x23\x29\x20\x47\x16\x18\x23\x80\xc5\x13\xaa\
\xed\x07\x8f\x3c\x7c\x04\x3a\x1a\x10\x73\x5e\xec\xb2\x1a\x0b\x02\
\x02\xf9\x44\xa4\xc4\xb9\x9f\x98\x61\x24\x03\x21\xe1\x60\x18\x2b\
\xe2\xc7\xc3\x7f\x7a\x15\x40\xf3\x4d\x2d\xf9\x55\x3f\x8e\x3f\x32\
\x8e\xff\x86\x86\x81\x6a\x10\x8e\x2b\x77\xb9\xb2\xac\x2d\x26\x20\
\x91\x8c\x8d\xf9\xd5\x60\x21\xd8\x9c\xef\x0e\x36\xea\x5a\x0e\xc0\
\x02\xee\x00\xef\x79\xa1\x07\x62\x81\xe9\xbb\x9f\xed\x95\x42\x4a\
\x71\xf2\xab\x93\x72\x55\x03\x4e\xe8\xbe\xd9\x4b\x6b\xba\xc7\xe4\
\xd2\x01\x6c\x8c\x09\x9d\x28\x08\x72\xcd\x76\xe8\x54\xeb\x7d\x00\
\x4e\xe3\x0e\xc0\x3d\x62\x83\xeb\xdb\xb4\x2b\xa9\x12\x37\x23\x9d\
\xed\xfb\xc3\xa0\x34\x23\x4d\x9a\xb1\x8e\x63\x9f\x3a\x2f\x6f\x33\
\x40\x26\xce\xa5\x7c\xdd\x82\x95\x08\x27\xbc\x61\x44\x27\x16\x3a\
\x96\x17\x66\xac\xd4\xc0\x3d\x7f\xee\xbc\xf8\xda\xfe\x62\x80\x55\
\xb0\xf7\x97\xeb\x91\x13\x29\xeb\x4d\x7d\x4e\x5c\x76\x4b\x88\x55\
\x06\x91\xe0\xd2\xff\x58\xbc\x6c\x0a\x0c\x09\x34\x39\xaa\xd5\xb4\
\x0a\x80\x84\xf3\xd7\x59\x55\xe2\x55\x93\xb4\xda\x85\x5a\xb1\x56\
\xe8\x6c\xa9\xeb\xc2\xdc\xb2\xfb\x2f\x6b\xb4\x55\x7b\x5a\x87\x5e\
\xd8\xd2\x82\x49\x31\xcf\x2c\xd2\x49\xad\x87\xff\xe1\x58\xae\xfa\
\x48\x46\x20\x0c\x7d\xbb\xfd\x11\x7b\x97\x8e\xb3\xd1\x4c\x04\x20\
\xd6\x40\xa1\xc9\xf4\xc8\x62\x5a\x64\x90\x16\xe5\x8d\x74\xc4\x04\
\xdc\x7e\x3b\x3f\x5f\x0d\xfc\xa2\x88\x64\x78\xe2\xc0\xb8\x6c\x54\
\xfd\xd2\x20\xa4\x27\x28\x17\xa7\xa9\x77\x7d\x2b\x1d\xf7\x2f\x31\
\x55\x39\x8b\x92\xea\x25\x8f\x93\x04\x4a\x07\xea\x72\xc5\x33\x20\
\xd5\xab\x29\xb6\x5e\x7f\xaf\xb3\x61\xf0\xac\x35\x13\x13\x10\x1b\
\x4c\x8b\x13\x61\xc5\xd8\x54\xf3\x50\xc4\xc9\xdc\x4b\xa5\xcd\x68\
\x21\xf4\x52\x5b\x3b\x7a\x8d\x4f\xfe\x71\x2b\x67\x21\xf1\x91\x96\
\x35\xe2\x74\x30\x29\x9b\x36\x19\x62\xd4\x1f\x97\x16\xd3\x85\xa6\
\x0c\x30\xc9\x41\xa2\x91\xf3\x8a\x58\xfa\xca\x45\x78\xfe\xc2\x85\
\x6b\x95\xdd\xf6\x80\xa3\xa2\x6f\xd0\x20\x56\x57\xa2\x0d\x9a\x4a\
\x5c\x19\x09\xc6\xab\xe5\x90\x6b\x32\x3e\xef\x4e\xf3\x74\x97\xc5\
\xad\x1e\x43\x8c\x59\x45\x69\xf5\xe8\x72\x36\xaa\x61\xf4\xc1\x29\
\x79\x6a\xff\x55\xa9\x7e\x2b\x4c\x52\x64\x9a\x54\xeb\xef\xec\xa9\
\x38\xf3\x1d\x2b\xbf\xa3\xaf\xaf\x77\x66\x6d\x2d\x9e\x8d\x16\xb8\
\xaa\x84\x5b\xa4\xc8\x12\xaa\x24\x48\x8f\xd4\x86\xbe\x32\x16\xe9\
\xa4\x71\x9d\x48\x10\x91\x24\x90\x4c\x70\x6c\xef\xc5\x65\x63\x5e\
\xf7\x72\x1b\xed\x68\xed\xc7\xd1\x1d\xa3\x72\xc5\x04\x12\x38\xdf\
\x08\xe6\x4e\x4e\x8d\x4f\x8d\xc4\x5d\x6e\x4e\x4f\xb9\x3a\x98\xa7\
\x53\x83\x4a\x54\x0b\x0c\xc6\x42\x55\x95\x32\xd1\x30\x25\x2c\x66\
\xc8\x14\x33\x84\xcd\xf4\x15\xc5\x13\x5c\x7e\x7f\x59\x7a\x93\xfe\
\x9d\xdf\x0b\xb2\x87\x8d\xd6\x03\xf7\x6e\x35\xa6\x58\x45\x94\xc3\
\x7a\x22\x20\x12\x41\x7b\x31\x89\x48\x25\x21\x92\x88\x55\x12\x52\
\x23\x86\x17\x77\xbd\x71\xf7\x6f\x46\x99\xe7\x52\xd6\xbe\x0d\x03\
\x66\xbe\x35\x25\xce\x57\x66\x92\x83\x25\x6d\x66\xf0\x86\x19\xd2\
\x44\xf2\xd9\x60\x1a\x5e\xd8\xf9\xda\xd2\x06\x77\xfd\x6a\xd6\x7a\
\xd4\x66\x6d\xad\x19\x2d\x04\xc7\x07\x0a\x9b\xe4\xbf\x2b\x73\xd2\
\x24\x26\x93\xc8\x7f\xb3\xe7\xcc\x2a\xc2\x77\xf1\x6e\x48\x47\x09\
\xf9\x5c\x8a\xda\xed\x0c\xf6\x74\xf6\xe1\xf9\x2d\x27\x97\x16\xdc\
\x35\x03\xef\x24\x18\xde\x61\xfc\x07\x3b\x00\xdf\x09\xb1\xdb\x7c\
\x84\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x1a\x63\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x40\x00\x00\x00\x40\x08\x06\x00\x00\x00\xaa\x69\x71\xde\
\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\
\x00\x41\x64\x6f\x62\x65\x20\x49\x6d\x61\x67\x65\x52\x65\x61\x64\
\x79\x71\xc9\x65\x3c\x00\x00\x1a\x05\x49\x44\x41\x54\x78\xda\xec\
\x5b\x79\x98\x5c\x55\x95\xff\xdd\xb7\xd4\xde\x55\xbd\xa6\xb7\xa4\
\x93\xce\x66\x42\x20\x98\xc4\x40\xfc\x20\x68\x00\x23\x2a\x13\x44\
\x01\x65\x19\x47\x40\xd1\x71\x61\x9c\x51\x3e\xbe\x6f\x60\x46\x1c\
\xc4\xf9\x14\x1c\x07\x47\xc7\x51\x26\x0a\x22\x82\x2c\x93\xcf\xc9\
\x48\x90\x10\x99\xb0\x84\x24\x40\xc8\x46\x3a\x7b\x7a\xdf\xab\xaa\
\x6b\xaf\xb7\xde\x39\xf7\xbd\x57\xdd\xd5\x9d\xee\xa4\x43\xf2\x9f\
\x53\xfd\xdd\xae\x7a\x5d\x55\xef\xdd\x73\xce\xef\xfc\xce\xef\xdc\
\xfb\x9a\x71\xce\xf1\xe7\xfc\x90\xf0\x67\xfe\xf8\x7f\x07\xfc\xb9\
\x3b\x40\x11\xbf\x9e\xf8\xaf\x2b\xce\xf9\x89\x05\xb7\x28\x4a\xb0\
\x69\xed\x47\xa5\x70\x45\x20\x7a\xa4\x2f\x3f\x0b\xd5\xea\xed\x90\
\x58\x10\xb2\xc4\x90\xb3\xd2\xb8\xe6\xef\xaf\x82\xdc\x2e\xe1\xfb\
\x0f\xdd\x05\x9f\x2f\x08\xdb\xb6\xe1\x83\x8a\xbd\xf6\x21\xec\x0f\
\xec\x41\xb4\x27\x8a\xb9\x17\xf4\x60\xd7\xce\x13\xf8\xdd\xf7\xba\
\x11\xac\x94\xd1\xba\xba\x15\x43\xaa\x0e\xc9\x9e\xc6\x1c\xc0\x58\
\x34\x62\xae\xd9\x76\x57\xff\xb1\x42\x97\xd9\x31\xa5\x03\xfa\x3a\
\x6c\xd8\x92\x05\x76\x2e\x0c\x1f\x7d\xc5\xa0\xeb\x49\x2b\xad\x1c\
\xfc\xea\x8d\x9f\x78\x7f\x5c\x95\x5a\xef\x07\x64\xfa\xab\x44\x83\
\x7e\x33\xf9\xcc\x4f\x4e\x13\x94\x72\x34\xcf\x28\x5d\x45\x22\xf0\
\xda\xa7\x26\x70\x6e\xf3\xa8\x1a\x96\x37\xce\xb9\xbd\x6e\x4b\xdb\
\x77\xfb\xae\x83\x09\x7d\xd2\x14\x18\x8e\x25\x61\x19\x32\x74\x93\
\x9d\xf5\x30\x2d\x09\xdc\xe4\xe0\x16\x4d\x8e\xb3\x81\x9f\xff\x62\
\xe4\xde\xfb\x9e\x7c\xf9\x52\x3b\xf0\xca\x23\x0a\xb3\x60\xf2\x02\
\x8d\x3c\x8a\x46\x16\x67\x5c\x81\x18\x83\x92\xd5\x61\x1c\x1d\x86\
\xa5\xd9\xce\xf1\x69\x53\xdc\x46\xa1\xf5\xc2\xfa\x7a\x25\x2c\x37\
\x4c\x89\x80\xde\xa5\xc7\x91\x78\xf1\x32\x18\x05\x3a\x94\xde\x7b\
\x59\x24\x8f\x23\x54\xed\x47\x65\x65\x1a\x31\x72\x40\xe2\x70\x3f\
\xb4\x2c\xcf\x3e\xf6\x23\x7c\x2e\xdc\xf0\xda\xbe\x3b\x2e\xb9\xaf\
\x73\x20\x5d\x7b\x7f\xc0\x6f\x62\xf3\xeb\xbd\x48\xa4\xb2\x68\x94\
\xab\xcf\xcc\x07\x8a\x84\x42\x77\x1e\xaa\x94\x46\x78\x51\x35\xb8\
\x6e\x9d\xf2\xf3\x9a\x61\xe8\x17\xbf\x6f\x71\xe3\x9e\x8b\xba\x2f\
\xee\xd9\x3c\xdc\x39\x29\x02\x18\x79\xd2\xa4\x67\x8b\xb3\xb3\x1e\
\x3a\xf9\x2f\x13\x09\x20\x5e\x2b\x23\x1e\xab\xc4\xac\xca\x0f\x23\
\xfe\x26\x06\x7e\xf6\x03\x7e\xdf\xc6\x9e\xa7\xff\x49\x33\xfb\x56\
\x76\x67\x07\x31\x98\x1b\x04\x13\x20\xe1\xa5\xc4\xe1\xce\x0f\x73\
\x90\x7e\xea\xc8\x72\x9a\x75\xa5\xc5\xe0\xd7\x08\xd1\xd2\xa9\x3f\
\x6b\x58\x86\x3d\x33\xdc\xa4\xfe\xd5\x3f\xae\xbb\x1b\x51\xfa\x99\
\xb4\x0a\x70\x78\x17\x3e\x47\x83\xa2\xcf\x15\x13\x57\xdc\xb2\x0c\
\x8f\xff\xea\x51\xdc\x75\xff\x9d\x48\x1d\xf1\x3f\xf9\xec\x6b\xe6\
\xc8\xbe\xf4\xee\x87\x7a\xb2\x71\x39\x55\xd0\xc8\x01\x12\x24\xc5\
\x6e\x94\x25\x25\x2a\x4b\x2a\x02\x72\x88\x82\x21\x53\x30\x8c\xd3\
\xb3\xb7\x4c\xce\x3e\x3c\x8c\xc2\x40\x9e\xa8\x45\x3a\x15\x19\xf3\
\x7c\xb1\xa0\x7f\xe5\xd2\x5b\x56\x5c\xfb\x2f\xab\xff\x9d\x26\x28\
\x9f\x94\x02\xe7\xfa\x21\x22\xc8\x08\x0d\xc5\xb4\x81\xda\xd9\x0d\
\xf8\xc1\xbd\xdf\xc3\x5e\xfe\x72\x72\xf7\xb6\xfd\x2f\xbd\x3e\xf7\
\xc8\x75\x4b\x95\xb9\x6b\x8f\x6e\x0b\x6e\xaa\x3e\xaf\x78\xff\xe2\
\x25\xa1\xab\xea\xaa\x5b\xae\x56\x10\x4d\x77\x6a\x27\xf0\x66\xfa\
\x0d\x0c\x4a\xdd\x54\x0d\x7c\xa7\x25\x44\x87\x07\x06\xb2\x90\x9b\
\x42\xb0\xec\x71\x0c\x3c\xfa\xf0\xc9\x3e\x65\xe7\xb1\x5d\x7d\x8a\
\xae\xb2\xbf\xb9\xfd\xb3\x37\xe7\x92\xf9\xe4\x8b\x77\xbd\xfd\xf5\
\xf1\x0e\xa0\xc9\xda\xa6\x3c\x16\xc2\xb3\x50\xc7\xb2\x2c\x4b\x52\
\x00\x75\x2c\xc4\x97\x77\x5a\x87\x2e\xfc\x6d\xe7\x03\xf5\x1a\xf2\
\x85\x45\x97\x57\xec\x8f\x6f\xab\xe2\x1d\x83\x09\x40\xed\xfa\x92\
\x35\x5f\xfb\x10\x9b\x9f\xbb\x9b\x47\x67\x3f\xf9\x7c\xe7\x86\x81\
\x22\x7d\x29\x18\x0a\xe2\x78\xf1\x08\x2a\xc2\xa1\x69\x5e\x8c\x41\
\xd5\x0d\x68\xc7\x87\x60\x37\x56\xc2\xa7\x2a\x27\xcd\xdd\x17\x52\
\x82\x6f\x6e\x6f\xdb\xf7\xec\x67\xb6\x7f\xf7\xbc\xeb\x66\xad\xfb\
\xe2\xc3\x1f\x7f\x60\xb8\x7f\x64\x60\xd7\x0f\x8f\x7d\x77\xd4\x01\
\x72\xc0\x40\x78\x56\x1c\xc3\xbb\x9b\xa1\x84\x74\xb0\xf7\x48\x84\
\x12\xa1\x6b\x68\x28\xd1\xda\x76\x60\xcf\xd5\xa9\x81\x64\x63\xce\
\x32\x2a\xf5\xc0\x9f\x6a\x83\xf5\x58\x50\x3b\x1f\xdf\xf4\x35\x42\
\x4d\x25\x81\x7e\xf9\xc0\x3a\xb5\x11\xd7\x58\x29\xe0\x2d\xe3\x10\
\xcf\x59\x35\x75\xcd\x55\x0b\x87\xe6\xa1\x96\x54\x80\xef\xcc\x88\
\x97\x38\x40\x4a\x9b\x68\x9d\x3f\x03\x9d\x5a\xdc\x29\xb4\x13\x1f\
\xaa\xa4\x70\xe4\xd1\x7e\xe0\xd7\x5d\x3f\x7c\xe0\xc4\x6f\x0f\xde\
\xf2\xe8\xea\x47\x8f\x6d\xe9\xfb\x53\x6a\x77\x7e\x9b\xe2\x92\x20\
\xc7\xec\x4f\xec\x83\xbf\x26\x83\xfe\x6d\x73\x60\xe6\x14\x48\xc4\
\xd4\x02\x19\xd3\x82\xbc\x29\x39\x90\x97\x28\x02\x3d\x83\x43\x1d\
\x6d\x6f\x0c\x3e\x8c\x76\x60\xce\xaa\x19\xf0\xcd\xb7\xa1\x2b\xc3\
\x8a\xdc\x15\xfc\x72\x5d\x93\xfc\xa3\xf3\x96\x35\x2b\xcd\xa1\x5a\
\x56\xe1\xf7\x13\x5a\x68\x5e\x76\xe6\xc6\x02\x1b\x5c\x23\x41\xdf\
\x91\xe4\x83\x9b\xb9\x64\x6e\xb6\xed\xc0\x91\xe9\x4a\x54\xa7\x94\
\xd2\x79\xbe\x78\xc1\x5f\xe2\x27\x07\x7e\x87\xfe\x5c\x37\x14\xa6\
\x4c\xf8\x8c\x2d\xe4\x87\x4a\x25\xd1\x18\x7e\x35\xf3\x87\xad\xff\
\xb9\xef\x91\xe5\x5f\x99\xf5\x8d\x97\xef\x38\xf4\x86\xe2\x96\x2f\
\x31\x79\x1b\x33\x3f\x7a\x18\x91\x39\x71\x0c\x6e\x5d\x88\x62\x77\
\x0d\x98\x6a\x9d\x56\xf5\x30\x12\x24\x85\x96\x14\x72\x15\x59\x04\
\x06\x83\x88\x56\xd9\xe6\x25\x6b\x2a\xa1\x84\x83\x98\x51\x1d\xad\
\x68\x98\x13\xbe\x7e\x7e\xf8\xe2\x9b\x2e\xae\xbd\x64\x45\xad\x3c\
\x4b\xf2\x21\xe4\x90\x9c\x4e\x21\x31\x90\xa1\xd7\x19\xa6\x21\xd9\
\x98\x45\xdf\x27\x53\x76\xdf\x27\x2b\xaa\xe3\x99\xa1\x02\x7f\xb1\
\x60\x35\xfd\x9c\x5b\x75\x9b\x31\x0d\x79\x66\x5a\x06\xea\xc3\x8d\
\x58\x37\xf7\x5a\xfc\x78\xd7\x83\x88\xf8\x22\x13\x1c\x30\xfe\xf3\
\xfb\xd7\xf7\x3e\xb2\x66\xfd\x82\x27\x95\x0a\xa9\x41\x19\xab\xe1\
\x54\x0a\x73\x3e\x54\x2d\x19\x80\x39\x58\x85\xe1\xae\x06\x48\x32\
\x3f\xad\x03\x64\x45\x46\xbe\x35\x83\x4c\x73\x1f\xac\xc3\x01\x84\
\xcf\x4f\x43\xce\x1b\x88\xb2\xaa\xcf\x5d\xd5\xfc\xc1\x6f\xad\x69\
\xb8\xe6\x82\x28\x1a\x51\x44\x01\x39\x24\x30\xc2\x93\x64\x74\x5a\
\x18\x4e\x25\x33\x0d\x83\xe7\xe8\x75\x01\x54\xd5\x10\xe2\x75\x08\
\xa9\xb1\x8a\x3a\x5f\xfc\xd3\xc3\x76\xc7\xa7\x47\xea\x87\x7e\xc1\
\xa5\xe0\x3d\x64\xc0\xb0\x45\x95\x45\x48\xe5\xa9\x1e\x45\xa3\xe8\
\x38\xe0\x99\xc3\xbf\x41\x52\x4b\x4e\x40\xc1\x98\x1d\x81\x59\x2a\
\x82\xf3\x95\xee\xc4\x50\xb6\x4f\x89\x4a\x75\x27\x55\x01\x5b\x97\
\x61\x93\x2a\x74\xab\xf2\x74\x20\x28\x42\x40\xe5\x8c\xbe\xc7\x0d\
\x86\x82\x9d\x9f\xbb\xb2\xe5\xc2\x1f\x7d\x7e\xc6\x37\xd7\x35\x60\
\x11\x99\x4a\x46\x83\x04\x11\x19\x6c\x20\x0b\x83\xa5\xe9\xbc\x29\
\x8a\x6b\x12\x36\x4b\x91\xe9\x19\x14\xad\x3c\x4c\x5b\xa7\x8c\xb3\
\x04\x5c\x69\x12\x12\x62\xac\x1a\xc1\x99\xc9\x3b\x8a\x18\x5e\x45\
\x25\xf2\xdb\x91\x48\xf0\x10\x53\x8c\x9e\x5c\x31\x97\xce\x52\xe5\
\xd3\x0d\xc3\x71\x48\x49\x4d\x9a\xdc\x44\x63\x44\xa0\xe0\x53\xf8\
\xf9\xde\x9f\x8e\x43\x41\xb9\x25\xfe\x16\x19\x15\x97\xfa\x59\x32\
\x91\x1b\x32\x69\xb2\xe7\xac\x0c\x9a\x26\x4d\xbc\x2e\xb1\xe6\xf6\
\x59\x77\xac\xff\x64\xec\xd6\x56\x8d\xcc\x4d\xa0\x9b\xa0\x9e\xa3\
\x48\x67\x50\xe0\xc3\xf4\xaa\x97\x7c\x35\x84\x7c\x2e\x81\xa3\x6f\
\x65\xa1\x44\x8b\x68\x5e\x66\xa0\x20\x1b\x30\x74\x93\xa6\xe9\xd6\
\x32\xce\x44\xb4\x39\x89\x52\x92\xe7\x96\xbd\xf4\xe2\xe6\xab\x37\
\x5c\xfb\xf0\x45\xc5\x91\xdc\x40\x5f\xff\x40\xdf\x89\xc3\x8b\x8f\
\x1f\x1a\xce\x77\xbe\xb5\xef\xe0\xc1\xb7\x8b\x7a\xf6\x80\x59\x84\
\x21\x5a\x03\x83\x64\xf6\xb5\x0b\xae\xc5\xa6\x8e\xff\xc6\x50\x61\
\xd8\x2d\xf9\x7c\x7c\x61\x48\xef\xa5\xe4\x1b\x34\x2b\xaa\x6f\xf0\
\xa7\xcd\xb4\x3d\x70\x4e\x1c\x60\x99\x16\xfc\x51\x76\xed\x37\x3f\
\x70\xf7\x63\x57\xfa\xae\xab\x48\x52\xc4\x05\xdc\x0d\xfa\x5d\xa0\
\xe7\x14\x3f\x81\xac\xd5\x05\x9d\x8d\x10\x59\xe6\xb1\xf1\x67\x09\
\xf4\xee\xf5\x23\x5c\x29\xa1\xf9\x40\x16\x1f\xb8\xd9\xa2\xa0\xdb\
\x8e\x13\x1d\x27\x30\xdb\x9b\xb4\x4d\x52\x5a\xa1\xd4\xa4\x49\xc7\
\x0e\x07\x62\x75\xc1\xd6\xe6\xd6\x96\xd6\x4b\x2f\x59\x78\xb9\x6e\
\xe9\x18\xca\x0e\xea\xfb\x8f\x1f\xdc\xf7\x76\xdb\xfe\x8d\x96\xad\
\xae\x4f\x67\x7c\xdd\x55\xf2\x02\xac\x88\xad\xc1\xd3\xc3\x8f\xa2\
\x2a\x1a\x3b\x09\xc7\xcc\x47\xa5\x73\xae\xbc\xa4\x70\xc2\x3e\x21\
\xf2\x50\x99\x1c\xd6\x36\x09\x0b\x8a\x88\x6d\x9e\xba\xec\x59\xf4\
\x75\x43\x82\x59\x5d\xf8\xf8\xdf\x2e\xbc\xf3\x71\x32\x3e\x9c\x40\
\x27\xd1\x5b\x92\x72\x3e\x4d\x3f\xdd\x48\x59\xc7\x89\xe9\xe3\x30\
\xec\x2c\xd5\xa3\x22\xfa\x3b\xd2\xd8\xf9\x52\x3f\x2e\x58\x34\x17\
\x37\x5c\xff\x31\xfc\xf3\x0f\x7f\x81\x8a\x05\x16\x5a\x2e\x62\xa4\
\xdb\x2d\x41\x46\x0e\x02\x84\x4e\xe6\xdc\x42\x36\x19\xc2\xb1\xe4\
\x0e\x74\xe4\xe8\x7a\xd4\x07\x40\x25\x64\x90\x11\x8a\x4a\x74\xea\
\x8b\xfa\x16\x2c\x99\xb5\x82\xe7\x1b\x56\xfc\xdd\x37\xde\x62\x5a\
\xff\xe2\xfb\x94\xc6\xdd\xe8\xbb\xfc\x09\xa4\x77\xe5\x61\x55\xa9\
\x46\xf5\xa7\x02\xe3\x38\xc0\x4e\xd8\x50\xe7\x2b\xef\xcf\xbf\x50\
\x7c\x65\x52\x25\x28\x72\x2a\x12\x8c\x41\xad\x9d\x03\xe6\xd7\xa6\
\x2e\x7d\x36\x91\x5f\xb4\x07\x87\xa2\xfb\x97\x7e\x66\xe5\xba\xc7\
\xd6\xfa\xd6\x85\x93\x38\x41\x11\x4f\x39\x51\x4f\xe2\x28\x52\x36\
\x45\xdd\xa2\xbc\xa7\x14\xd0\xec\xbc\x20\x18\xa4\x33\x39\x14\x8b\
\x05\xec\x79\xf7\x30\xda\x7b\x3b\x91\x4a\x14\xb0\x77\x8b\x89\xba\
\x95\x36\x71\x81\x3d\x16\x31\x26\x24\x35\xc3\xc8\x30\xe5\x7b\xbe\
\x0b\x8a\xce\x1c\xe1\xce\x25\x37\x45\x44\x53\x34\x23\x54\x8b\x1d\
\x7f\x38\x88\x2d\x1b\x3a\xd0\x7f\xb4\xab\xd2\xc8\xf7\x42\xab\x7b\
\x19\xfe\x02\x11\xab\xce\x94\xe3\x1b\xe2\x0d\x73\x3e\xd2\x20\x96\
\x0e\x1c\x48\xb1\x18\x29\x95\xf3\x7c\x33\x8d\x14\xcf\x1a\xc7\xac\
\xfd\x93\x3a\xc0\xb6\x2d\x44\xfc\x35\x98\x51\x3b\x0f\xdc\x9f\x9b\
\xd2\x01\xaa\x11\x44\x5b\xcb\x91\x8a\x25\x1f\x9a\xf1\xcb\x1b\xd4\
\x1b\x6a\x47\xd0\x45\x80\x4f\x52\xf4\xe3\x64\xfe\x21\x64\xec\x01\
\x6a\x8f\xb3\x64\xb8\x18\x34\x21\xbb\x48\xe7\x26\xc1\xd5\x64\x40\
\x0a\x51\x01\x4c\x14\x91\xd5\x52\xb0\x35\x89\x50\x61\x21\xa3\x51\
\xab\x6c\x7a\xb1\x12\xc6\x4b\x42\xea\x4a\xc8\x12\x70\x6c\x93\x9a\
\x1e\x72\x86\x68\xda\x84\x34\x51\x54\x89\x24\x53\x25\x76\x6d\xee\
\xc7\xbe\xed\x49\xa7\x81\x55\xf8\x87\x07\x0a\xc1\xf9\x40\xcd\x26\
\xb9\xa5\x25\xf4\xd7\x8b\x3f\x12\xbe\xc5\xaf\xcb\xad\x84\x96\x48\
\xf7\x41\x54\x39\xb9\x65\xd0\xaf\x76\x33\x91\x7f\xc7\x7a\x46\x64\
\xee\xa4\x0e\x60\xb6\x02\xa3\xea\x04\xfa\xf2\x1d\x60\xba\x3d\x95\
\x0c\x87\xa9\x71\xf4\x45\xd2\xdf\xfe\x8e\xfa\xf5\x15\x05\xe2\xf9\
\x0c\x06\xc8\xf8\x04\xfd\x1c\x41\x86\x0b\xe3\x73\xd0\xc8\x01\x3a\
\xe5\xbc\x61\x6b\x54\xab\x35\xaa\x10\x54\x09\x88\x21\x5a\xaf\xd1\
\xf0\xda\x03\x36\x2a\xea\xa8\x5f\x18\xb1\x21\x55\xb8\x71\xb7\xad\
\x31\xb0\x8a\x2a\xa6\x65\xc5\x75\x98\xd3\xa2\x8b\xf5\x05\x8b\xd2\
\x23\x10\x20\x16\xe7\x61\xec\xd9\x19\x47\xe7\x51\x6a\x8b\xc9\x19\
\x06\x55\x20\xc3\xa8\xdc\x6e\xcd\x7e\x48\x5d\x75\x5b\xe0\xb1\xb5\
\x6b\x6a\x6e\xa4\x4b\x23\x39\x48\x32\xb9\x60\x23\x12\x90\x2b\x1d\
\x70\xe7\xe9\x3c\x79\x33\x7f\xea\x66\xc8\x52\x21\xcd\x3c\x8a\x8e\
\xc8\x4b\xe8\x3d\x10\x81\xe2\x3b\xd9\x09\x8c\xf2\x7e\xa4\x79\xf8\
\xa2\xdb\x2f\xbc\xfc\x6b\x33\x51\x8f\x3e\x92\x7d\x45\x72\x42\x9c\
\x52\x20\x4b\x91\xd7\x08\xf6\x1a\x39\x40\xb7\x0a\x14\x79\x8d\x8e\
\x0b\x48\x5b\xc3\xe4\x98\x04\x78\xda\xc2\x8a\xcf\xd2\xe4\x86\x80\
\x83\x4f\x73\x04\xe6\x70\x9c\x7f\xa3\x30\x14\x4e\x43\xc3\xbc\xd2\
\x2a\x58\x5d\xcb\x91\x61\x16\xdc\xb6\x99\x7e\xfc\x01\x05\xf9\x23\
\x0a\x4e\xa4\x12\x54\xf7\x4d\xa8\xa2\x73\xb4\x4c\x72\xd4\x82\x83\
\x05\x2d\xf0\x6a\xcb\x65\xf9\xaf\xac\xbe\x2c\x76\x63\x26\x5b\x44\
\x66\xc4\x44\x96\xae\x25\xc2\x9c\x1a\xd2\x87\x44\xcc\xa6\x5c\x10\
\x99\xb8\xa4\xa5\x90\x2a\x0c\xb4\x50\xd3\xd2\x53\x01\x29\xc8\x4f\
\x8a\x7e\x2e\x9f\x47\xcd\x2a\x7e\xef\x47\x83\x1f\xf4\xf7\xe3\xb8\
\x03\xfb\x11\x22\xbc\xac\xdd\x47\x44\x46\x39\x4e\x4e\x2e\x19\x5f\
\xb0\x32\x88\x1b\x54\x15\x28\xfa\xa5\x5e\x4b\x26\x43\x3f\x72\x27\
\x70\xe1\xf5\x24\x4c\xa8\xef\x89\x85\xc9\xd8\xbc\xbb\xc0\xc3\xbc\
\x8b\x08\x34\x88\xbf\x99\x96\x58\x23\xe0\xf0\xf9\x25\xf4\xbd\x65\
\xe1\xdd\xcd\x59\xa8\x31\xa0\x71\xa9\xe2\x10\xa6\xe0\xe9\x42\x62\
\xf1\xc3\x4a\xf3\x26\x73\xc6\x12\x63\x6d\x36\xa5\x21\x9b\xa2\xea\
\x91\xa3\xaa\x42\xdf\x1b\x1c\x40\xba\x7b\x83\xf6\xcb\x12\xe4\x4f\
\xeb\x00\xb7\xac\x11\xc1\x34\x13\xc4\x45\x5f\x9f\xb3\xc6\x2f\x3d\
\x11\x19\x85\x16\xf0\x4b\xaf\x5f\x71\xc9\xc7\x39\xc5\x3d\x45\xb5\
\x3d\x87\x21\xa4\x85\xf1\x84\xbb\x22\x19\x6e\x88\x61\x92\xf2\x33\
\xd3\x18\x32\x7a\x51\xa4\xfc\x97\x46\x97\x3d\x5c\xe3\x44\xcb\x5f\
\x1b\x73\xa3\xad\xe5\xc7\x9c\x0b\x36\xd6\x94\x16\x8a\x02\x15\x64\
\x7c\x40\x42\xc7\x36\x0b\x47\x5e\xa6\xf3\x28\x94\x36\x44\x8c\x23\
\x1d\x14\xa4\xa8\x85\xf4\xc0\x45\x5b\xd3\xc3\x5f\xfa\x95\x91\xf9\
\x2c\x4e\x3c\x6b\x6d\xa8\x7b\x9f\x76\xa5\x4f\xe5\xfe\x42\x81\x9a\
\xae\x7d\x7c\xcf\xe1\x9f\xe8\xf7\x6b\x87\xcd\xcd\xa7\x5c\x15\x3e\
\x89\x08\xa9\x35\x0e\x35\xf5\x21\x1a\x8d\xa0\x78\xac\x85\x7a\x02\
\x73\x6c\xa1\xb3\x68\x22\xb8\x66\xe0\x0b\x4b\xd5\x99\xf2\x10\x95\
\x3c\x51\xef\xd3\xbc\x1f\x05\x93\xa4\xad\x9e\x27\xb8\x93\x2a\x21\
\x65\x92\x33\x46\x30\x68\xf6\x42\x27\xe6\x97\xf8\x98\xf1\xa3\xd2\
\x9e\x0e\x74\x6d\xec\x58\xf8\xb8\xb4\x38\x24\x20\x2f\x16\x7a\x4c\
\x22\x2d\xc2\x39\xba\xde\x30\x71\x68\x93\x06\x25\x40\x58\xa0\xa9\
\x08\x4e\x4c\x77\x53\xf4\xeb\xd5\x3d\xe9\xbe\x0f\x7d\x8e\x5b\x07\
\x34\x4e\xd7\x8f\xff\xde\x5e\xbf\xe5\x48\xb1\x3d\xd2\xca\x2e\x2c\
\xf6\xf1\x9e\xfc\x3e\x6b\x3b\x11\x5f\xe7\xa9\x1a\x7c\x65\x2a\x8d\
\xaf\xf8\x39\x66\xae\x34\x30\x98\x0b\x51\x67\xa8\x7b\x04\x49\x8d\
\x8f\x3f\xdd\xb4\xfc\x03\x33\xaf\x16\x21\x4c\x83\xd4\x9d\x4d\xcc\
\xaf\xa7\x08\xfa\x04\x7b\x4a\x64\x9d\x8c\x2f\x12\x12\x06\xf4\x3e\
\xc7\x78\x36\x01\x7b\xe5\xcb\x0d\xac\xcc\x21\xbc\xec\x3d\x56\x72\
\x04\xcd\xae\x8b\x22\x7f\x68\x83\x0e\x35\xcc\x08\x99\x8e\x36\x22\
\x42\x14\xb0\x17\x48\x32\x37\xf8\x42\x2f\x76\x59\xd1\x06\xaa\x26\
\x8d\x54\x35\x7a\xa0\x1f\x30\xb7\x24\x0e\x60\xcb\x59\x6f\x8c\xd8\
\xba\x82\xe0\xdc\x6e\xd2\xee\x43\xc8\xa5\xf2\xc8\x67\xb2\xc8\x25\
\x73\x30\x6a\xbb\xaf\x9c\x19\x8b\xd6\x8c\x10\xec\x33\xf6\x30\x95\
\xb2\x04\x0a\x3a\x91\x1e\x35\x23\x05\x91\xff\x46\x16\x43\x5a\x3f\
\x39\x41\x83\xe8\x5d\x2c\xcb\x1d\xb6\x37\x9c\xd7\xb6\x93\xbe\xce\
\xb3\x5d\xfe\x9e\xf7\x37\xcb\x7b\x9f\x51\x33\x36\xdc\x29\x84\x11\
\x89\xa4\x14\x19\x3d\x48\x4d\x4f\x92\x46\x9a\xd2\x66\x84\x43\xf5\
\xf3\x7f\x08\xc5\x3a\xb6\x51\x79\x58\x1d\x9d\xb3\x1c\x95\x8b\x1a\
\x08\x49\x67\xb6\xd7\xa3\x94\xe0\x77\xf2\x0a\x2f\x83\x3f\x62\x22\
\x7a\x59\x1b\xc9\xd6\x2a\xea\xfa\xa8\x0c\xe9\x1c\x33\x16\xe8\x57\
\x52\x27\x8f\x11\x73\xc0\x31\xb6\xa8\x0b\xb6\xa7\xc8\x93\x03\x04\
\x02\x52\x04\xfd\x8c\x56\xa6\x1f\xbc\x22\xc2\xcb\x17\x0d\xf9\x24\
\xd7\x64\x13\x96\xbb\x28\xda\x2a\x91\x71\xfd\x6a\x05\x4d\x97\x48\
\xc8\xf5\xd8\xc8\xf5\x72\x68\x71\x0e\x3d\xcb\x61\xe4\xa8\x85\x0f\
\x30\xb9\xa2\x6a\x64\x15\x94\xd7\xff\x68\x60\xde\xb7\x7d\x35\xb3\
\x1e\x54\x63\x41\xc4\xdf\x69\xa7\x00\xf2\xe9\x3b\x80\xbc\xfe\x17\
\x54\x76\x8e\x59\x9c\x1f\x28\x03\x21\xfd\x9d\x21\xda\x9c\xc2\xfe\
\x47\xea\x61\x15\x14\x12\x46\x5a\xb0\xf5\x4a\x7d\xa5\x4e\x70\x2f\
\x16\x8b\x44\x7a\xc4\xf4\xa4\xc9\x35\x82\xbd\x70\x80\x46\x0e\x18\
\xa1\x10\x71\x6f\xb5\x97\x79\xb9\x3f\x6a\x2c\x9b\xa4\x41\x65\x27\
\xa7\x83\xdb\xe3\x03\x61\xd2\x07\x26\x09\x24\x4e\x2d\x77\x74\xa1\
\x84\xaa\xf3\xbc\xa5\x7e\x93\x82\x41\xfc\x20\xb8\x40\xd7\x88\xaf\
\x50\x0c\x26\xdb\xf6\xad\x4e\x1d\x90\x1f\xf4\x45\x25\x84\x1a\x80\
\x6c\xe7\x19\x20\xe0\xd0\x16\x73\xde\xac\x9b\xfc\xcf\xd6\xaa\xf2\
\x0b\x26\x33\x7e\x4d\x9d\xc0\xf3\xa4\x99\x0a\xc2\x08\x7f\x10\x68\
\xb8\x7c\x18\x03\xdd\x54\x8e\x02\x46\xab\x2f\x18\x6d\x4d\x17\x04\
\xe1\x69\x04\x55\xea\xe2\xc8\xe8\x22\x39\x44\xb4\xa6\xc2\x78\xd3\
\xb0\x47\x2d\x2c\x91\x1e\x9f\x10\x69\x86\x29\x1c\xc2\xc6\x7b\x47\
\x25\x19\x5f\xdb\x68\xe3\xd8\x6e\x6a\x8f\x1b\x84\xfe\x17\xfa\xc0\
\x1e\xe7\x24\xd3\x11\x4f\xa4\x18\xdb\xf1\x6c\xfa\xb0\x49\x7d\x82\
\x57\xca\xe9\xbb\x14\x97\xe9\x71\xc0\xc0\x56\xeb\x5f\x5f\x7b\xae\
\xf0\xb3\x78\xc1\x5e\xc7\x8a\x91\x67\xc3\xbc\xe6\xf5\x80\x14\xb9\
\x8d\x64\xb1\x9f\x51\xd1\x5e\x78\x45\x06\xca\x6c\x4a\xbe\xba\xdc\
\x3c\x89\x73\x7f\x36\x47\xd0\x2f\xe6\xa9\x4c\x15\x90\x2d\x92\xda\
\xa3\x56\x36\x47\xaf\xf3\x7a\x61\x5c\xde\x4f\xcc\xff\x93\x86\x59\
\xf6\xda\xe3\x03\xee\xf6\x43\xce\x20\x50\xa1\x65\xb1\x0d\x5f\xc8\
\x46\xa2\x8f\x13\x0f\x11\xfc\x49\x81\x1a\xba\x5b\x41\x44\x95\x10\
\x9b\x31\x46\x06\x29\x6d\xc8\x7e\xc5\x5f\xc3\xe0\x8b\x51\xea\x56\
\x32\x44\xe6\x50\x8a\x28\xd3\x74\x80\xde\x03\xf4\xbd\x62\xde\xbd\
\x63\x6b\x6e\x63\x67\x3c\x85\x64\xd2\x5c\x16\x33\xe6\xad\x6f\xf5\
\x5f\xfc\xbf\x01\x56\x75\xb5\x1a\xa1\x68\xbf\xeb\x43\xff\xd6\x40\
\xb3\x25\x91\xb1\x05\x22\x45\x9d\x4a\x5d\x91\xf2\x5f\x37\x68\x50\
\xd7\x46\x44\x68\x96\x1b\xe2\x2d\x53\x73\xcf\xa8\x72\xa3\x27\x75\
\x8e\xe9\xbd\x67\x7a\xe7\xb0\x85\x81\x34\x41\x6a\xe9\xcf\x5f\x4d\
\x69\x40\xb2\x3c\x35\x64\x53\x0f\x41\x8e\x20\x0e\xd0\x34\xc2\xa9\
\x29\x96\xa4\x88\x14\xe3\x7c\x27\x69\xaf\x76\x8e\xb1\xeb\x0b\x34\
\x55\xcc\x25\x87\x90\x33\x04\x2f\x96\x8f\x93\x52\x40\x23\xc2\xf0\
\x53\x0a\xb7\x6f\xb2\x6f\xb3\x35\xe3\x8f\xad\x4b\xe2\xcb\x93\xd4\
\xb5\x2d\xa8\xb9\x60\xd5\xe2\xc8\xc7\x36\xf6\xb3\x7d\x4f\xcc\x5c\
\x72\xfc\x5b\xf1\x8c\x59\x59\xc8\x1b\x54\x9a\x99\xd3\xd8\x58\xdc\
\x70\x48\xce\x22\x0b\x35\xcb\x2d\x79\x0e\x7b\x3b\x4b\x65\x63\x70\
\xb6\x4b\x7c\xc0\xc7\xe0\xcd\xc7\x41\x9f\x39\x6a\xaf\xc4\x17\x8e\
\xf3\xbc\x74\x20\x3f\x23\x56\xcb\xb1\x6c\xad\x89\xdd\x9b\x65\xe4\
\x48\x04\x05\x62\xa2\x42\xb8\xc6\x48\x7e\x20\xdf\x87\xcd\x92\x9f\
\x39\xf0\x9f\x48\xac\x91\xa0\x70\xec\x58\xae\x89\xef\x15\x87\x5c\
\x32\x75\x8e\x45\xfb\x7b\xd3\xf7\x43\x50\xa2\xc0\x5b\x5b\x49\x3c\
\x56\x62\x6e\xcb\xc5\xd2\xe6\xfa\x99\x6c\xae\xe2\xb3\xd0\x14\x99\
\x89\x45\xd5\xcb\x88\x00\x33\x6d\x1b\x77\xee\x48\x45\x6a\x95\x55\
\xd5\x61\x05\x62\x33\x8d\x79\xca\x45\xe7\xe4\x3d\x6a\x82\xc5\x65\
\x84\x86\x57\x7d\x9e\x11\x5e\x73\x53\x32\xdc\xf6\x9e\x47\x17\x29\
\xed\x12\xe5\x4a\x8e\xe1\x26\x7d\xa9\x9c\x2f\x4b\x95\xc3\x59\xf8\
\x25\x43\xb3\x54\xfe\xda\x5e\x65\x18\x6a\xa7\xb6\x96\x0c\x16\xda\
\x80\x10\x62\x24\x76\xda\xab\x48\x75\xef\x3a\xa9\xa8\x97\xaa\x0d\
\x9b\x58\xe1\xc6\xaa\x93\xe3\x80\xf5\x5d\x95\xce\xc4\x0f\xbe\x6d\
\xe1\x95\x67\x34\x0c\x6b\x7c\x69\xd3\x6a\xf9\x85\x19\x4d\x52\xa3\
\xa4\x1a\x08\xf9\x7d\x58\x58\xbb\x08\xed\x19\xea\xf6\xb4\x41\xd4\
\x56\x28\x50\x65\x37\x7f\x24\x49\x08\xe2\x3c\x44\xdb\xa1\xd2\x24\
\x83\xa1\x31\x38\xa3\x2c\xea\x4e\x65\xb0\xc7\x9c\x30\x2a\x7e\x9c\
\xf7\xdc\x4d\x73\xdd\xb4\xc7\x57\x45\x69\xcc\x01\x36\x73\xf1\xca\
\xe9\xba\xf1\x5e\xa0\xf7\x20\x43\x7a\x58\x6c\x94\x62\xef\xd0\x4b\
\xd6\x4a\x11\x87\x33\xda\xdf\x67\x65\x0e\xf8\x8f\xe3\x31\xd1\x6b\
\x33\x89\x8e\x72\x19\x03\xed\xc7\x0c\xec\x7f\xd7\xbe\x30\xc3\xf0\
\xfb\x9a\x46\xdf\x6c\x1f\x31\xaa\xcf\x27\xd6\xf0\x99\xe3\xf9\xea\
\xb0\x04\xbf\x58\x95\x11\x39\x25\x5b\x28\xf2\x02\x54\x82\x5a\xac\
\xc6\xcd\x3f\xd1\xd9\x09\xc9\x5a\x8a\xf4\x28\x1f\xf0\xb2\xea\xc0\
\xc7\xf6\x24\x9d\x14\x10\x5b\x69\x94\xd7\xa3\x0e\x62\x63\x2c\x65\
\x7b\x68\x10\x43\xa4\xb7\x2d\xbb\xad\x9d\xd0\xa7\x1d\x2f\xe0\xb7\
\xbd\x2f\xe1\x66\xc1\xfa\xef\xf9\x0e\x91\x63\xbb\x2c\x51\xc6\xd4\
\xa6\x39\xe1\xef\xd4\xd5\xd6\x35\xc6\x96\xc8\x89\x0b\xce\x63\x9d\
\xfb\xf6\xe9\x7b\x76\xbe\x3b\x30\xdb\x5f\x65\x22\x10\x94\xa0\x11\
\x01\x52\xb3\x8c\xa2\xe2\x46\xce\x56\x85\x71\x96\x73\x96\xaa\x19\
\xee\x9c\x05\x89\x39\xb0\x93\x4b\x9d\x8f\x9b\xab\xdc\x83\x3c\x2b\
\x2d\xf8\x78\x86\x8a\x7d\x4d\x5e\x12\x01\x9a\x4b\x8c\xa3\x69\x20\
\x79\xd1\x2f\x2b\xa7\xc2\x41\x3a\x59\x2e\xaa\x2d\x27\xb4\xe5\x7b\
\xd1\x96\xd8\x47\x69\x17\x3e\x0b\x07\x1c\x7f\xc7\x44\x21\x6b\xeb\
\x6f\x6d\xca\xbe\x7a\xdd\xd7\x2a\x9f\xab\x8c\x56\x04\x6c\x33\x84\
\x95\x4b\x55\xaa\xf5\x0c\x5b\xb7\x77\x20\x5a\x27\x16\xee\xe9\xa2\
\x8a\xed\x38\x40\x66\xde\xc4\x08\x01\x8d\xad\x6e\xde\x0b\xc2\x72\
\x78\x80\xb9\x51\x62\x7c\x0c\xc2\xa5\xd7\x4e\xa3\xc3\xbd\xf4\x71\
\x36\x2f\x29\x9a\xe4\x05\xd3\x16\x02\xc7\x1a\x75\x20\x2b\x17\x08\
\xde\x7e\xae\xe5\x6c\xe1\xbb\xe9\x20\xf6\x11\x38\x39\x4c\x8b\xe3\
\xed\x50\x3d\x4e\x26\xc0\x33\x71\x80\x42\x5f\x0e\x10\xa1\x1c\x7c\
\x53\x7b\xfe\x37\x3f\x39\xf1\xe1\x35\x5f\xf0\x3d\xa5\xaa\x98\x93\
\xa3\x96\x52\xae\x97\xd1\x32\x57\xc5\xb1\xbd\x16\x42\x8d\x74\xd5\
\x00\xf5\xda\x24\x8b\x55\xb2\x42\x44\xab\x69\x91\x8d\x30\xb1\xb2\
\x56\x28\x83\xb4\xec\xec\x56\x8d\x83\x32\xf3\xa2\x2f\x8c\x56\xbc\
\x67\x95\x7e\xf9\x09\x45\x05\x81\x2a\x62\x6a\xcb\x43\x80\x28\x7d\
\x52\x89\xd0\xe4\xb1\x26\x49\xf4\x08\xa6\xe7\x04\xc1\x05\xd4\x86\
\x0c\x25\xdf\xc5\x2e\xdb\x70\xcb\xdf\x7b\x76\xc0\xe8\x01\xe5\x75\
\x2e\x21\xed\x38\x71\x1c\x1f\x23\x87\x3c\x11\xad\x64\xcb\x45\x5e\
\xd6\xcc\x95\x90\x4e\x73\xf4\xb4\x59\x90\x2b\x6c\xe8\xd4\x29\xe6\
\x48\x8b\x37\xcf\xb5\x51\xdb\xcc\x9d\x9c\x77\x16\x72\x25\xb1\x3b\
\x3c\xbe\xe4\xb1\xb2\xf6\x56\x04\x92\xda\x79\x4a\x23\xf7\x75\x40\
\x16\x0e\x60\x04\x67\x09\x8a\x30\xae\xe0\x46\x76\xb4\x3f\xb1\xdd\
\xb2\xc5\x9d\x1b\x1d\xe8\x7d\x2f\xf2\x8e\xad\xa2\x2a\x74\xe0\x35\
\x6a\x38\x07\x98\x5a\xa6\x30\x27\x91\xdd\xd3\x76\x80\xe3\x70\xc5\
\xb9\xf8\xc1\xb6\xd7\xcc\xb5\xd5\xf3\xa5\x87\x2a\x9b\xd9\xe7\x45\
\xde\x55\x93\x16\xcf\xa4\x38\xb2\x7d\x16\x29\x33\x8e\x40\x15\xc7\
\xac\xc5\xdc\x15\x16\xcc\xcd\x65\xe6\x2d\x66\x32\x2f\xdf\x1d\x98\
\xbb\x5a\xc5\x41\x04\xd9\xea\xec\xfd\x8a\x63\x3f\xbd\x19\x50\xc5\
\xea\x93\x42\xdd\xa3\x02\xc9\xa0\x34\xa4\x1e\x4a\x0e\x8a\x34\xf3\
\xb4\x03\x73\x87\x28\x0e\x62\x79\x52\xa4\x55\x09\xfe\x42\xe5\x0d\
\x6d\xc7\x06\x2b\x4f\xe7\x88\x78\x02\x87\xbe\x63\x19\xee\xb5\x8d\
\xdc\xf4\xb6\xf9\x1d\x07\x48\x25\x95\xe4\x5d\x50\x56\x1d\x23\xe2\
\xe9\x41\xfb\xd6\xd4\x08\xfe\xa4\x46\xd9\x77\xd4\x0a\xd6\x1a\x5b\
\xc4\x90\xea\x25\xdd\x1d\xb7\x70\xfe\x4a\x12\x19\x31\xb1\x64\xed\
\x9e\xc4\x61\xe9\x92\x38\xf1\xd6\xf4\x64\xcf\x78\x61\xb8\x1f\x13\
\x8c\xa7\x2f\xa9\xe2\x7e\x1f\xfa\x2b\x97\x54\x18\x29\xc3\x59\x01\
\x0a\x07\x3c\x29\xec\x21\x4a\x18\x5f\x74\x77\xcb\x5c\x95\x27\xae\
\x23\xf8\x66\x18\x5d\x99\x63\xf8\x43\x90\x1a\x1f\x2d\xe9\x19\x2c\
\x3e\x1b\x1f\x2f\xb8\xa6\xe5\x00\xb1\x24\x25\xf4\xb5\xf0\x9e\xe8\
\xb0\x34\xd2\xdc\x04\x2d\xa7\xd6\x93\x1c\x7d\x7c\xa4\x8b\xbf\x44\
\x22\xe5\xcb\x81\x7a\x76\x2b\x11\xd6\xac\x90\x6a\xa1\x65\x81\xb3\
\xcc\xef\xac\xef\x95\x08\x4e\x92\xcb\x8c\xf6\x4e\xee\xf7\x22\x3f\
\x7a\x2c\xf2\xde\xa9\x12\xd4\xe0\x04\x42\x78\x27\x1f\x40\x84\x48\
\xe1\x78\x97\x39\xba\x5c\x26\x79\xe7\x13\x39\x5f\xa4\x39\x59\x5e\
\x15\x11\xc6\x8b\xa5\x73\x5f\x35\xd0\xf5\x0c\x1e\xcd\x9c\x40\x82\
\x7c\x87\x6c\x97\x57\x6a\xdf\xcb\xdd\x2c\x42\x07\xf8\x82\x6e\x8d\
\xb1\xbc\xe5\x3f\x89\x66\x2c\x72\x2f\x5c\x4f\x5a\xba\xc6\x5d\x89\
\xc9\x0f\xd8\xf0\x37\xb0\x19\x04\xc5\xab\xae\xf8\xaa\xf4\x8d\xb5\
\xb7\x9a\xcb\x8c\x82\xd8\x1d\x12\x1b\x18\x63\xe4\xa6\x4c\x30\xb8\
\x94\xef\x02\x01\x01\xc9\xd3\x36\x94\x67\xb5\xc1\x08\xfa\xad\x20\
\xf6\x5b\x3e\x18\xc7\x46\xb0\x69\x4b\x8a\x9a\x18\x71\x47\x07\x7d\
\x27\xe4\x7e\xa9\x68\xba\xc6\x8b\xd7\x02\xfe\x8e\x23\x7c\x8e\x83\
\x06\x5f\xf9\x0c\x96\xe7\xfa\xd0\x73\x4e\xee\x14\x35\x26\xb4\x8d\
\xa2\xd7\x76\x74\x38\x21\x01\x47\xc7\x9c\x95\xef\xe6\x83\xb1\x46\
\xe9\xd7\x73\x67\xaa\xcb\x24\x58\xcb\x64\x4a\x54\x05\x2e\xf1\x29\
\x9e\x03\x7c\x9e\xb1\x25\xe3\x45\xb4\x7d\xac\x74\xf7\x1d\x39\x54\
\x09\x61\x86\x3f\x86\x14\x0b\xa1\x8b\x05\x51\x5f\xcc\xe0\x99\xad\
\x19\x88\xbe\x26\xc8\x5c\xc7\x13\x1d\x38\x25\x55\x18\xcc\x3c\x3e\
\xb0\x28\x50\xa2\x0c\xfa\xab\x48\xb7\xfc\x14\x0f\x7a\xc6\xb3\x93\
\xf6\xbf\xcf\xa6\x0a\x9c\x42\x34\x8e\x8e\x5c\x9c\x5a\x8b\x4c\x48\
\xad\x65\x15\x48\x4b\x19\x9a\x9d\x46\x27\xb1\x47\x8d\x55\xbd\x5c\
\x17\x28\x50\x3c\xf2\x63\xe2\xc6\x17\x39\x8c\xa8\x1a\xa3\x11\xc5\
\x10\xc2\x68\x47\x00\x0d\x5a\x06\x4f\x3f\xd5\x8f\xce\x41\x1b\x55\
\x8d\xee\xd6\x57\x51\x87\xe3\x0c\x17\x52\x9e\xac\x76\x56\x88\x48\
\x2e\x57\x00\xe9\xdd\xd8\x7e\xf4\x37\xfc\xa7\x18\x93\x12\x7c\xc2\
\x38\xa7\x0e\x90\x26\x38\x40\x22\x8e\xb0\xdf\xf9\x1d\x7b\xfe\x53\
\x9f\xae\xfd\x6a\x75\xa8\x86\xf4\xbb\xd8\x44\x25\x19\x4e\xda\x57\
\xa2\xae\x50\xa1\x39\xa8\xce\xfd\x28\xb2\x73\xbf\x4f\x90\xa2\x1c\
\x92\xc2\x44\x7a\x21\x18\x2c\x80\x6e\x04\x45\xd7\x00\x7f\x5f\x37\
\x1e\x7d\xbc\x0d\xef\xf6\x15\x51\xdd\xc4\x9c\x7c\xcf\x17\xdc\x0a\
\xe0\x96\x0d\xaf\x77\x90\xdd\xb2\x67\x2b\xce\xde\x6a\x6a\xff\xf7\
\x71\x27\xe9\x05\xb1\x9e\x1c\xf0\xb4\x51\xa9\xb5\x61\x63\xda\xf3\
\x0c\x39\x80\x9d\xbc\x28\x38\xce\xe8\xb2\x21\xbb\x4e\x63\xd6\x0d\
\x5f\xae\xbf\xe9\xb6\x7b\x66\xdc\xd3\x38\x33\x32\x8b\x3a\x03\xfa\
\xa0\xe2\xdc\x24\xe5\xfe\x28\xde\x50\x1d\x77\x50\xe1\x84\x41\x9f\
\xb1\xe9\x13\xb9\x4c\x1c\xaf\x6e\x79\x07\x4f\xbf\x70\x18\x23\x44\
\xf1\x31\xe2\x19\xf2\x0d\xc8\x37\x4e\x09\x64\x3e\xaf\xa2\x48\xee\
\xb0\xbc\x2d\x9d\x60\x0d\xf8\x91\x7f\xc3\x9d\x3d\x2f\x72\xb1\xc9\
\x11\x72\x77\x16\x5c\x71\xe8\x7d\x84\xbf\x17\x34\x4c\xe5\x00\xa9\
\x2c\xfa\x1e\x18\x47\x47\x29\xcd\xcd\x86\x26\xff\xec\x35\x37\x47\
\xee\x5d\xbd\xae\xee\xaa\x79\xef\xab\x47\x55\x55\x25\x82\x4a\x8c\
\x0c\x0f\x7a\xf7\x24\xc9\xce\xbd\x03\xb9\x6c\x11\x3d\x47\xfa\xb0\
\xeb\x9d\x63\x78\xe5\x8d\xe3\x68\x1f\xd2\x11\x24\xc2\x0b\x46\x99\
\x53\xc3\x55\x82\xb6\x14\xf2\xe4\xac\x87\x49\xcb\xbb\x17\x5a\x58\
\xe7\xa3\x72\xdb\xf3\x1c\x7e\xdc\xf1\x1c\x7f\xd8\xfb\x44\xc1\xeb\
\x85\x0c\xef\xd9\x2a\x43\x43\x69\x29\x76\x5a\x4e\x98\xe8\x00\x56\
\xb6\x54\x3e\x21\xea\x6e\x9a\x7b\xd0\x13\x11\x88\x78\xce\xa8\x0d\
\x34\xe3\x9e\xc6\x79\x6c\x79\x4d\xb5\x1f\xd5\x95\x11\x52\x77\xaa\
\xd3\xde\x1a\x34\xa7\x5c\x2e\x87\x44\xa6\x80\xe1\x94\xe5\xcc\x36\
\x44\xc6\x06\x22\xd4\x55\xd2\x59\x54\x3a\x83\x42\xc7\x0e\x02\xfc\
\x2e\xe1\x39\xdb\x62\xcc\x6b\x76\x24\xb7\x22\xf4\x6d\xc4\x53\xdd\
\xff\xc3\xd7\x7b\x06\x67\xc5\xee\x9c\xe7\x84\x62\x99\x23\x4a\x4e\
\xe0\x13\x1c\xc0\xcf\x84\x03\xd8\x84\x14\x90\xc6\x32\x72\x34\xfa\
\x25\x07\x88\xfe\x4b\xdc\xe9\x5c\x51\xec\xc5\xb3\xfd\x8c\xfb\x87\
\x13\xc5\x25\xa6\x56\x1c\x15\x31\xa2\xc7\x10\x6b\x04\xbe\xb0\x28\
\x6f\xcc\xd1\xfd\x52\x19\xc4\x2d\xee\x2d\x9a\xe8\xde\x94\xbd\x7c\
\x77\x36\x49\xe9\x2a\x12\xf5\x5d\xed\x4f\xe1\x8f\x43\x3b\xf8\xab\
\xf4\xe7\x66\x1a\x23\x65\x06\xda\x65\x51\xe7\x13\x0c\x9f\xf6\xed\
\x9e\xca\x34\x2b\x40\xb9\x23\x54\x6f\x04\xbc\x21\xee\x43\x09\x15\
\xba\xf1\x6a\x88\xba\xea\x8a\x59\x38\x8f\xb4\xb9\xec\x2c\x72\xc8\
\x6e\x54\x85\x58\xb1\xcb\xda\xd9\xd2\xe2\x88\xd3\xf8\x88\x0e\xd2\
\x74\xaf\xe0\xb4\xc5\xe4\x20\x85\xb8\x40\x3b\x8e\x44\xef\x46\xbe\
\x23\xd7\x8b\x23\x02\x65\x9e\x41\x05\x0f\x85\xc5\xb2\x94\x34\x26\
\x21\x6b\x7e\x2e\xcb\xe0\x64\x1b\xc8\x93\x6d\x6b\xb0\x7c\x1f\xda\
\x8c\x2c\xb4\x8a\x56\x2c\x0c\xcc\xe0\x51\xe6\x2b\xc3\xa0\xec\xd6\
\x78\x61\xa4\x90\xb5\xce\xda\xa1\xe1\x35\x4c\x96\xbb\xb6\x27\xab\
\x54\xeb\x13\xd0\xe3\x6f\xa3\x27\xfe\x26\x8e\xd2\x5b\x09\x0f\x75\
\x93\x5d\x93\x4f\xf1\xfa\xac\xca\xe0\xc4\x0b\x95\xc3\xca\x2e\x63\
\x5c\xdd\x8b\x42\xde\xcb\xc7\x80\x17\x19\xbf\x91\x41\x6f\x62\x2f\
\x0a\xfe\x1a\x34\x84\x9b\x51\x17\x68\x40\x05\x11\x9d\xcc\x7c\x6e\
\x0f\xcc\x3c\x54\x08\x0c\x09\x64\x88\x2e\x51\xac\x1e\x19\xdd\xc8\
\xc7\xdb\x90\x4c\x1f\xc6\xa0\xa5\x63\xd8\x83\x7b\xc6\x1b\xb9\xb2\
\xbc\xd7\xbc\x39\x94\xe6\x32\x91\xf0\xf8\xd9\x22\x80\x4f\xe2\x00\
\x0f\xa4\xce\xc5\xa5\x49\x9a\xce\xd2\x67\x0a\x1e\x49\xa5\xb5\x38\
\x92\x34\xba\xa4\x36\x44\xc9\x19\x51\x62\xf2\x88\x12\x86\x5f\x0e\
\xb9\xff\x2d\xe3\xdc\x83\x25\x76\xd3\xd2\x28\x14\x06\x90\xd5\xc5\
\x3d\x55\xee\x77\x9d\xef\xc3\x8d\x7e\xaa\xec\xf5\x88\x77\x9c\xf1\
\x1c\xaf\x4d\x20\x3f\xfb\x4c\x35\xc0\x54\x55\x00\x13\x4a\x60\x79\
\x25\x28\x55\x03\x9f\x47\x84\xa1\x32\x42\x14\xff\x8c\x50\xe1\x8d\
\xd2\xb1\x78\x0e\x62\xac\x19\x54\xca\xce\xcd\x3d\xa7\x99\x9e\x31\
\x25\x44\x65\xca\x1c\x91\xf1\x1c\x50\x32\x3a\x3f\x09\xfb\x9b\x65\
\x48\xb0\xce\x54\x0b\x9c\x4a\x08\x95\x97\x43\xb9\x74\x73\x47\x99\
\x33\x4a\x46\x95\x97\xc7\x60\x99\xd1\x25\x92\xf4\x95\x7d\x4e\x29\
\x3b\x2f\x2f\x83\xb1\xe1\x39\xa1\xe4\x88\x42\x99\xc1\x45\x6f\x68\
\x65\x9f\x33\xcb\x22\x6f\x4d\x48\xd3\x73\x22\x84\x26\x53\x83\x6c\
\x12\x71\x54\x5e\x1d\x7c\x65\x15\xa2\x7c\x94\x1c\x26\x97\x21\x0a\
\x93\xf0\x4a\xf9\x28\x09\x1c\xbd\xec\xd8\x2a\xfb\xfc\x54\xf5\x9e\
\x9f\x0b\x0e\x98\xc8\x05\xe5\xab\x7b\x65\x7b\x36\xa3\xbc\x50\x9e\
\x36\xca\x84\xb4\x91\x27\xe9\x29\x26\xde\x2b\xc1\xcb\xd0\xc0\x27\
\x89\xac\x7d\x0a\x43\x31\xc5\xf1\x39\x6b\x86\xf8\x84\xea\xc0\x26\
\xb4\xa0\xd6\xa9\x3a\xc7\x53\x18\x8e\x49\x26\xcc\x27\x89\xea\x54\
\x06\xbd\x67\xd6\x3f\x1b\x1d\x30\x71\xcb\x62\xb2\xe5\xc7\xd3\x4d\
\x84\x9d\xa6\xea\x4c\x77\x0e\x67\x55\xfb\xcf\x85\x10\x9a\x4a\x10\
\xe1\x2c\x0c\x64\x67\xe8\x80\x73\xf2\xf8\x3f\x01\x06\x00\x62\x88\
\xd0\x2f\x2b\x81\xc0\x25\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\
\x60\x82\
\x00\x00\x06\x38\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x37\x5c\x00\x00\x37\x5c\
\x01\xcb\xc7\xa4\xb9\x00\x00\x00\x06\x62\x4b\x47\x44\x00\xff\x00\
\xff\x00\xff\xa0\xbd\xa7\x93\x00\x00\x05\xaa\x49\x44\x41\x54\x78\
\xda\xed\x57\xbf\x6f\x14\x57\x10\xfe\xe6\xdd\xee\xde\x9d\x7d\x3e\
\xff\x42\x18\x0c\x36\x52\x80\x28\xa0\x28\x31\x18\x39\x0a\x21\x41\
\x10\x89\x3a\x28\xff\x43\xa8\x10\x29\x52\xd0\xa5\x48\x97\x26\x34\
\x91\x22\x45\x6e\x50\x28\x30\x55\x20\x0d\x45\x10\x21\x21\x02\x84\
\x8c\xad\x40\x64\x8c\xf9\x61\xb0\x03\x8e\xb0\xf1\x8f\xf3\xe1\xbb\
\xbd\xf7\x26\xb3\xbb\x5e\xb1\x7b\xab\xd3\x15\x29\xdc\xec\x27\x7d\
\x9a\xd9\xe7\xdb\xdd\x99\xef\xcd\xcc\x3e\x23\x45\x8a\x14\x29\x52\
\xa4\x48\x91\x22\x45\x8a\x0d\x03\x95\x5c\x17\x17\x0f\x1d\xc2\xa6\
\xc1\x41\xe4\xb7\x6c\x41\x61\xd7\x2e\x3c\x3e\x7b\x56\xcd\x8f\x8f\
\xd3\xea\xdc\x1c\x8c\x31\xc9\x9b\x22\x54\x6f\x6c\x82\x99\xd0\x36\
\xa0\x95\xb4\x49\x2a\x05\x67\xf3\x66\xe4\x06\x06\xb8\x78\xe2\x84\
\xd1\xd3\xd3\xa8\xcd\xce\xa2\xf6\xf8\x31\xba\x46\x46\x40\xcc\x8c\
\x9f\x89\xfc\x20\xba\x4e\x9e\xa4\xa5\x3b\x77\x38\x63\xdb\xf0\x50\
\x59\x59\xc1\x67\xb7\x6f\x63\x23\x31\xbb\x77\x2f\x32\x6d\x6d\xbe\
\xcf\x22\x76\x7e\x68\x88\x4a\xc3\xc3\xec\xf9\x5f\x02\xa0\x9f\x7a\
\x7a\x90\xeb\xeb\x43\x6b\x7f\x3f\xbd\x77\xe6\x0c\xaf\x3c\x7c\x58\
\x7c\x38\x3c\x7c\xf8\xf9\xd5\xab\x7b\x4a\x33\x33\x79\x83\xa4\xfa\
\x08\x95\x0f\xd9\x44\x7d\xd5\x48\xfd\xd0\x6f\xb2\x0b\xd9\x6d\xdb\
\xca\x2d\x47\x8f\xfe\x5d\x3c\x75\xea\x9a\x3d\x38\xb8\xb2\x74\xfc\
\x38\xc9\x4e\xb0\x99\x99\x81\x95\x95\x92\xe9\x1a\x18\xa0\xde\x03\
\x07\xf8\x9f\x4b\x97\x8e\xac\x3d\x7b\xf6\x83\x5e\x59\x79\xdb\x2e\
\x16\x19\x8e\x43\xa6\x5a\x05\x88\x00\xe6\x58\xf9\x98\xba\xe0\x4d\
\x5d\x92\xa6\xae\xdc\xb8\x8e\xa6\xee\x5e\x53\xe7\x33\x11\x98\x19\
\xec\x38\x80\xc4\xa2\x17\x17\xa9\x7c\xe1\xc2\x84\x33\x3a\x7a\xc2\
\xf9\xfc\xf3\x6b\xb5\x5b\xb7\xa8\x36\x3e\xce\x56\x41\x94\x2f\xbf\
\x78\xc1\x53\x97\x2f\x7f\xd8\xd2\xdd\x7d\x31\xbf\x69\x53\x21\xb7\
\x75\xab\x76\x5e\xbd\xe2\xea\xe4\x24\x6a\x10\x30\xc7\xeb\xbf\x89\
\xfa\x3a\xa2\xbc\x69\x40\xae\x63\x08\x0e\x9f\x1b\x0a\x66\x0c\x4c\
\x67\x27\xd0\xd3\x43\xc6\xb6\xdf\x71\xc7\xc6\x7e\xa1\xc5\xc5\x63\
\x70\xdd\x1b\x56\x5f\x1f\x59\xcf\x46\x46\xb8\x7d\xcf\x1e\x85\x42\
\xe1\x3b\xd6\xba\x60\x75\x74\xd4\xb2\x9d\x9d\x56\xae\xb7\x97\xf3\
\xdb\xb7\x43\x57\xab\x04\x22\x44\x41\x0d\x1b\xb9\x79\x13\xab\x26\
\x25\x14\x5a\x9b\x08\x19\xad\x91\x51\x8a\xb3\xfd\xfd\x40\x67\x27\
\x19\xd7\xad\x61\x6e\xae\x8d\x66\x67\xcf\x74\x54\x2a\x07\x31\x31\
\x61\xe8\xfb\x5c\x0e\x64\x59\x9f\x38\x5d\x5d\xbf\xb5\xed\xde\xad\
\x0b\x3b\x76\x64\xb6\x1d\x3c\xc8\x1d\xed\xed\x54\x9e\x98\xf0\xd5\
\x57\x91\xc0\x55\xbd\x42\x0d\x88\x98\x9f\xec\x21\xae\xdb\x59\xdf\
\x23\x02\x0b\x4d\xad\x06\x16\x5a\xf9\x3c\x9c\x9d\x3b\xb1\x54\x2e\
\xa3\xbd\x54\x62\x8c\x8d\x11\x3d\x7d\xaa\x69\x6a\x2a\xa3\x16\x16\
\x0e\x43\xeb\x6b\x56\xb5\x52\x81\xaa\xd5\xf6\xb9\x2f\x5f\x42\x67\
\xb3\xac\x8a\x45\xb4\xb5\xb4\xd0\xfc\xf9\xf3\xd0\xcb\xcb\xfe\x18\
\x53\x40\x43\x22\x1a\x64\x93\xe0\x11\xe9\x0d\x8e\xd4\xba\x67\x0d\
\x33\xb4\xeb\x42\x8b\xcd\x48\x0c\x24\x23\xfd\x5f\xe9\xbf\x89\x73\
\xe7\x30\x7d\xff\x3e\x8e\x9d\x3e\x4d\x6f\xc9\x54\x74\xa5\x79\x2d\
\x89\x15\xd5\xea\x3e\x3f\x01\xc3\xec\x65\x5c\xd4\x92\xf1\xca\x83\
\x07\x78\x2d\x0f\xd9\x25\xa3\x6b\x6d\x61\x01\x56\x2e\xe7\x3f\x90\
\xd1\x18\x2a\xd2\x80\x08\xfc\x64\x42\x75\xd7\x1c\x96\xa4\x31\xfe\
\x68\x64\xb1\x24\xef\x92\x69\x03\xee\xee\xc6\xd2\xd2\x12\xa6\xaf\
\x5f\xc7\xcc\xbd\x7b\xa8\x30\x03\xc2\xb9\xbb\x77\xd1\x27\xd7\xee\
\xa3\x47\xa1\x38\x45\x16\x6b\x99\xc8\x8b\xb5\xb0\x22\xdb\xe5\xbe\
\x7e\x0d\x06\x7c\x45\x50\x37\x75\x38\xc1\x98\xea\x49\x86\xc1\x32\
\xfb\x81\x22\xa4\x57\xe3\x52\x22\x96\x8c\x71\x48\x93\x56\x00\xcc\
\xcb\x47\x6a\xee\xca\x15\xcc\xcf\xcc\xf8\xd7\x96\xd0\x28\xe5\x97\
\x2b\x89\xc0\x46\xe2\x32\x91\xdd\xf3\x60\x71\x98\x40\x84\xde\x6e\
\x68\xad\xe3\x75\x1a\x82\x28\x92\x48\x1c\x1c\xf6\x86\x30\x54\x18\
\x61\x82\x99\x0c\x54\x36\x0b\x2a\x14\x40\x52\x22\x46\x14\x77\xa5\
\x44\x4a\xcf\x9f\x63\xe9\xe6\x4d\x2c\x3f\x79\x82\xb2\xbc\xb7\x06\
\xc0\x21\x02\x8b\x5d\x0b\x9e\x15\x08\xa8\x75\x62\x7a\x45\x13\x08\
\x14\xf7\xc8\x8c\x5a\xb5\xea\xab\xa5\x6c\x3b\xd6\xb4\x14\x4d\x48\
\x2c\xc5\x13\x0b\xfa\x42\x02\x25\xa1\x7f\xaf\xe3\x80\x84\x10\x9f\
\x89\xa0\xa5\xdf\xdc\xc5\x45\x54\x64\x3c\xaf\xcd\xce\xfa\x65\xea\
\x7a\xef\x5b\x9f\x3c\x59\xef\x5e\x66\x68\x63\xe2\x3b\xe8\xad\x05\
\xa5\xd6\x30\x81\xe5\x70\xa1\xb2\xba\x8a\xe7\xf3\xf3\x58\x90\x09\
\x64\x8b\x22\xad\xa2\x5a\x5e\x82\xc8\x09\xb3\x12\x88\x23\xb4\x89\
\x60\xc9\xcb\xa4\xc1\x7d\xab\xbc\x72\x10\x72\x98\xa8\xd6\x80\x57\
\x7e\x5e\x29\xca\xf3\x8c\xd4\xb4\x29\x95\xe0\xf7\x5b\xa4\x1c\x9d\
\xc8\x54\x63\x08\xd6\x77\x9d\x23\x25\xed\x1a\xe3\x0b\xd0\xd1\xd2\
\x02\x2d\x4d\xcc\x6f\x7a\x6e\xd9\x4f\x00\x01\x46\x39\xb0\x54\x96\
\x1e\x98\x1a\x1b\xe3\xde\xfd\xfb\xc9\x78\x6a\x11\xf9\x0f\x5a\x13\
\x6b\x09\xfd\xf9\xec\xfb\x42\xc0\xf7\x33\xcc\xc8\x18\xe3\x53\x31\
\x07\xb3\xde\xb2\xa0\xe4\x0c\xe3\x4d\x35\x25\xcd\xa9\x94\x02\xd6\
\x93\x25\xe6\xf0\x77\x9e\x0d\x8e\x0b\xc2\x3c\x11\x6a\xeb\x3b\x12\
\xb2\xca\x8c\x96\xf6\x76\x6c\x9d\x9c\x64\xe9\x4f\xb2\x01\x5a\x4f\
\x72\x14\x02\x0a\xcb\xe7\x1b\xe0\xf7\x35\xe0\x50\x15\x70\x2b\x80\
\x6d\xb5\xb6\xc2\x6e\x6d\x65\x13\xfe\x26\x52\x36\x21\x95\x77\x1d\
\x24\x11\xff\x78\x11\xc5\xcf\x3e\xcc\xbe\xb5\x42\xdb\x80\x76\x68\
\xa3\x3e\x11\x67\x56\x57\x89\x45\x58\x59\x73\x1d\x2f\x36\xe0\x8f\
\x1d\xc0\xc7\x7e\x1c\x5f\x0b\x55\x10\xdf\xfb\x15\xe0\x57\x49\xa2\
\xbb\x06\x68\x17\xe0\x5a\xb2\x51\x1b\x1f\x9d\xff\xe7\x81\xcd\x8e\
\xf9\x49\xeb\x00\x24\x36\x23\x9c\x97\xb5\x4f\x01\x8c\x33\x40\x16\
\x03\x5c\x11\x47\xcb\x82\x02\x8e\x00\xf8\x51\xfc\x0f\x4c\x28\x3a\
\x40\xc9\xaf\x68\xc8\x24\x38\xe6\x37\x07\x35\xf9\x10\x0a\x99\xde\
\x2c\xdd\x60\xe0\x8b\x2a\xf0\x97\x5a\x17\xde\xa2\x20\x4b\x16\xd2\
\x90\xfc\xe1\x2a\xf0\x11\x07\x1c\xd2\x40\x41\x2c\x73\xe2\x28\x91\
\x0c\xc0\xd4\xf9\x4a\xc8\x31\x3f\x4e\x34\x10\x83\xe3\xeb\x21\x4a\
\xe2\xdf\x22\xe0\xcf\x6e\x40\x2f\x86\xdf\x43\x88\xf3\x55\xfc\x8c\
\x4f\xa6\x4e\x3c\x12\x7e\x8b\x8d\xc1\x5d\x61\x26\xbe\xf3\xa4\x02\
\xcb\x88\x7e\x44\x4f\x21\x80\xb5\xbe\x58\x01\x94\x0b\x90\x8e\x1c\
\x7d\x13\xa7\xcf\x26\xff\xb4\x58\x09\xdb\x94\xc9\xda\x8f\x93\x85\
\x86\x00\x68\x04\x78\x17\x29\x52\xa4\x48\x91\x22\x45\x8a\x14\x29\
\x52\x6c\x24\xfe\x03\x3b\xea\xca\x76\x89\x47\x2b\x6f\x00\x00\x00\
\x22\x7a\x54\x58\x74\x53\x6f\x66\x74\x77\x61\x72\x65\x00\x00\x78\
\xda\x2b\x2f\x2f\xd7\xcb\xcc\xcb\x2e\x4e\x4e\x2c\x48\xd5\xcb\x2f\
\x4a\x07\x00\x36\xd8\x06\x58\x10\x53\xca\x5c\x00\x00\x00\x00\x49\
\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\x63\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x02\x73\x42\x49\x54\x08\x08\x55\xec\x46\x04\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\x01\xb7\
\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x06\xe2\x49\x44\x41\x54\
\x78\xda\x9d\x58\x5b\x68\x9c\x45\x14\xfe\xfe\xfd\x77\x37\x7b\x4b\
\xac\xad\x97\x64\x83\xa8\x28\xc5\x0b\x3e\x88\x4d\x40\xad\xf4\xa1\
\x04\x5f\xb4\x16\x1f\x54\xbc\xbc\xf5\xd1\x07\xc1\x20\x5a\x4a\x09\
\x52\x54\x24\x82\x3e\x1b\x14\xaa\xb5\x17\x5f\x5a\xaf\x0f\xa1\xa2\
\x18\xbc\x54\xb1\x58\xd1\x82\x54\x14\x4a\xd2\x20\x06\x6d\xbb\xc9\
\x66\x93\xdd\x39\x7e\xff\x39\x33\x19\xd6\x36\xc6\x3a\x1f\xe7\x4f\
\x76\x67\xe6\xfb\xe6\x9c\x99\x9d\x39\xf3\x27\x82\xb5\xca\x4b\x65\
\x6c\x95\xcd\x18\x44\x5d\x0d\x98\xc1\x74\x66\xc9\x14\x8e\x3e\xdb\
\xc4\x1a\xe5\x5f\x05\x5e\xd8\x20\xdb\x71\x3f\x46\x50\x11\x00\xb4\
\xd8\xcd\x6c\x01\x93\x78\x3f\x39\xbc\x73\xee\x7f\x08\xec\xa9\xca\
\x28\x46\x51\x13\x08\x1c\xc2\x33\xd0\xe7\x68\xe1\x89\x06\xc6\x93\
\xf1\x5d\xf3\x97\x20\xf0\x7c\x2a\x3b\x30\x86\x7e\x87\x0c\x1d\xa2\
\x4d\x73\x84\x18\x3d\x91\x22\x8f\x94\xc8\x29\x30\x8b\xb1\x64\x62\
\x77\xe7\x3f\x09\x8c\xd5\xe5\x30\x86\x44\x89\x97\x89\x25\x62\x19\
\x65\x94\x68\x15\x64\x71\x69\x62\x91\x56\x40\x91\x28\x10\x29\x91\
\x00\xdf\x24\xdb\xc7\x66\xd6\x14\xd8\x3d\x4c\xfa\x01\x87\xb6\x12\
\x2f\x92\xfa\x0a\x5c\x83\x1b\x50\xf5\xa3\x65\x51\x5f\xce\xe3\x14\
\x4e\xe3\x0f\xd2\x97\x54\x28\x9f\xd5\x9d\x49\xb6\x3f\x7f\xec\x5f\
\x05\x76\x3d\x26\x13\x52\xea\xe8\xb8\x17\x68\x1b\x71\x07\x2a\x28\
\x11\x3d\x36\x4e\x4f\xdf\xd6\x16\xcb\x94\x39\x86\x9f\x49\x5f\x51\
\x5f\x58\xbf\x98\xec\xd8\xb3\x6f\x55\x81\x9d\x8f\xe3\x2d\xd1\xce\
\x4d\x34\x38\xee\x61\xac\x47\x15\x7d\xa4\xcf\x23\x51\x00\xa2\x12\
\xa2\x22\x2d\x2c\xd2\x7e\xc7\x17\xf4\xa5\x86\x32\x0a\xda\x0e\x4f\
\xbc\xf0\xf6\x45\x05\x9e\x1b\x96\xcf\xa4\x94\x85\x66\x9e\x1d\xef\
\xc6\x4d\xec\xb4\x8e\x96\x12\x08\x2b\x46\x25\xc4\x04\xbc\xc8\x02\
\x5b\x1f\xc7\x14\x4a\xa8\x6a\xa8\xe8\xc5\x96\x17\x8f\x5d\x20\xf0\
\x6c\x5d\xbe\x95\x81\x0e\x5a\xa4\x77\x18\xe1\xf8\xaf\x44\x1f\x3b\
\xe4\x0c\x46\x4f\x93\x2e\x09\xc3\x02\xf1\x0b\x3e\x66\xab\xaa\x86\
\x32\x39\x93\x6c\x7a\x69\xa6\x4b\xe0\x99\x54\xbe\xc4\x90\x8d\xbe\
\x83\x07\xb1\x01\x03\xe8\xd5\x85\xe8\xe9\x69\x30\x0f\x82\x84\x5f\
\xc2\x0c\x28\xb1\xc8\x7e\x67\x70\x00\xa9\xf7\x82\x2b\xea\xce\x97\
\x3b\x50\xcf\xb5\xb8\x1d\x32\xd4\xc9\x62\x4f\xdc\x4b\xfa\x3a\x2e\
\x43\x41\x63\x1a\x90\xae\x7c\x2a\x74\xa1\x88\x1e\xa2\x8c\x5e\xf6\
\xb9\x4f\xfb\x2f\x53\x56\x86\xdc\x0e\x44\x0f\x9e\xae\xe2\x94\xeb\
\x6f\xb3\xf2\x2c\xb6\xe0\x36\xa5\xcf\x13\x39\xf5\x20\xfc\x62\x63\
\x89\x5e\x74\x14\xb6\xa6\x16\xb9\xa6\xbe\xc6\x27\xec\x5b\xce\xfa\
\xce\xe2\xc6\x57\xe6\xbd\x07\x6e\xd4\xf5\x77\x74\xba\xae\xc5\xcd\
\xb8\xca\xd3\xa7\x26\x41\x84\x39\xc8\x5d\x00\xfa\xa3\x56\x54\x4f\
\xaa\xd8\x84\xeb\xc8\xd2\xa2\xa8\xeb\x77\xa3\xde\x83\xa7\x36\xc8\
\x6f\xae\x96\x4d\x55\x03\x8f\xe1\x1a\xa2\x18\xb6\x01\x1a\x62\xf4\
\x2f\x28\x61\x87\x6a\x7b\x1f\x5a\x64\x38\x8d\xd7\x51\x43\x25\x1b\
\x5c\x23\xb9\xee\xd5\xb9\x3c\x20\x0f\x48\xcd\xe9\x44\xdd\x8a\xf5\
\x44\xc1\xc8\x95\xfe\x0d\x38\x62\x49\x09\xda\x1a\x0e\x67\xe1\x31\
\x69\xd2\x38\xec\xe2\x33\xac\xab\x32\xae\x66\x88\x4f\x92\x83\x3e\
\xd7\xb0\x0d\x6f\x52\xa0\xb3\x8d\x63\xd0\xdf\xe5\x30\x9d\xec\x45\
\x0c\x00\xc0\x5a\x1d\x99\x19\x45\x54\x86\x54\xde\xa7\xd4\x82\xa7\
\x12\x4e\x03\x5b\xe6\x2c\x9e\xc0\x92\x0e\x20\x79\x80\x02\x4f\x96\
\x65\xc4\x29\x4d\x3f\xe9\xd7\xfb\xe0\x24\x3e\xee\xf0\xcb\x70\xc9\
\xa3\xad\x10\x82\x25\x2e\x02\x95\x32\x81\x22\xd6\x61\x00\x73\xf6\
\x0b\x1a\x79\xb2\x9c\x73\x5b\x5d\x25\x5b\xa0\x2d\x5c\x4f\xf5\x9a\
\x27\x8e\xdb\x5a\x3b\x4a\x64\x5b\x03\xd1\x52\xf3\x5e\x11\x89\x22\
\x55\x98\xc4\x46\xb4\x74\xb1\xba\x8a\xdb\x9a\x73\x9b\x85\x34\x99\
\xc4\x46\x92\xb6\xe2\x71\xa2\xb0\x2d\x9b\x01\xf4\x68\x05\x7a\x23\
\xd7\xb0\xc1\xb7\xcd\x99\x47\x14\xb8\xcd\xe8\x41\xe6\xcd\x79\x37\
\x28\x4a\x52\x45\x8d\xea\x6d\x76\x4f\x11\x57\xbd\xd3\x98\xc7\x55\
\xb2\xac\x72\xce\x13\xa6\x21\x58\x41\xc0\x2f\xeb\x75\xa8\xb2\x5d\
\x21\xfb\x76\x30\x2f\x75\xea\x10\x35\xbf\x76\x12\x25\xec\x81\x15\
\xd6\x45\x01\x8f\x0e\xc4\x07\xc5\x75\x2d\xe0\x5c\xf4\x83\x02\xe7\
\x6d\xbd\xd5\xf3\x32\x68\xbf\xc8\xaa\x56\x24\x06\x4f\x01\x34\x55\
\x20\x1c\x9b\x76\x00\xb5\x3d\xbd\x10\x81\x3e\xf6\xb1\xba\x1a\xfe\
\x32\xef\x82\x07\xc2\xaf\x62\xe4\x63\x39\x8e\x73\x3a\x71\x12\x42\
\xa4\x06\x3f\x98\xbc\x9e\x67\x88\x65\x85\xa1\x17\xb2\xe2\x01\x3c\
\xa2\xbb\x5d\x12\x4b\x94\xb0\x33\x98\x4f\x35\x9e\xcd\x6a\x7c\xaa\
\x74\x2c\xb1\x7f\xe4\xcc\xc9\x8c\x35\x69\xd0\x42\x63\xe9\x8a\x2b\
\xcc\x6c\xef\x51\xd2\x5c\xd7\xf7\xb1\xc4\xfe\xe7\xfd\x5f\x99\xc9\
\xc9\xb4\x7d\x6d\x93\x62\x88\x25\x8d\x6b\x43\x03\xd2\x83\x0a\xad\
\xd0\x9d\xb2\x74\x49\x18\xce\x85\x4f\xd3\x79\x99\x31\xa7\xe6\x75\
\x2a\xa3\x84\x4d\x21\x89\xc2\x29\x60\x9f\xfd\x33\x9e\x15\x69\xa0\
\x8a\xf4\xe4\x69\x98\x67\xf4\x20\x2f\xd3\x1a\x0a\x6a\x9e\x45\x1f\
\x5c\xc8\xe2\x7c\xc7\x30\x72\x07\xd1\x20\x15\xc2\x5f\xa2\xe8\x3d\
\xf1\x25\xf4\x24\xfe\x24\x5b\x9f\x85\x6c\x3a\x97\x4c\x59\x7c\xf3\
\x38\x19\xf6\xcb\x15\x19\x74\x9d\x5b\x36\xb9\xc1\x7a\x54\x80\x58\
\xf1\x20\xe6\x81\xdf\x23\x1f\x66\x69\x2a\x2f\x47\x65\x01\x95\x2c\
\xca\xa7\x70\x0f\x96\xd0\x63\x12\xe6\xac\x92\x88\x1f\x75\x9b\x70\
\x80\x6d\xd3\x44\xf0\x22\x84\xc6\xe8\x1d\x39\x7e\xd2\xf9\x01\xc8\
\x7c\x34\xb7\xb7\x29\x93\xd0\xb8\x9e\xc6\x39\xbf\x5f\x76\x14\x42\
\xf4\xd8\x59\x45\x94\x88\x72\x80\xa5\x62\xbe\x56\xba\x0e\xcf\x36\
\x43\xfd\x9b\xe5\x47\x90\xc9\xbd\xcd\x4c\xe8\x3d\x41\x82\x94\xf6\
\x29\x5a\x41\xc2\xfc\xd0\xad\x2b\x52\x57\x89\x1a\xd1\x4b\xab\x66\
\x46\x54\x6c\xec\x81\x9e\xfd\x3f\xf2\x6c\x02\x1c\x01\xa5\x20\x47\
\xe4\x35\xd4\xb2\x89\xfb\x0e\x77\xea\xa8\xda\x7e\x57\x2a\x60\x0f\
\x12\xc5\x6a\x45\x3c\xda\x2b\x02\xd3\xf8\x1a\x25\x0b\x50\x03\xef\
\xe9\x81\xbb\x6f\x4e\xc6\x35\xae\xb4\x49\xfd\xb5\xda\x9e\xc9\x0e\
\x71\xba\x57\xa5\xb7\x4c\x35\xe4\x47\x4d\xbc\xef\x99\x00\x19\xdf\
\x37\x17\xf2\xa2\x71\xcc\x02\x29\x8a\x38\x49\x7d\xa6\x82\xe1\x78\
\xe4\xd3\x19\xa2\x4c\xa4\x36\x68\xcb\x90\xb8\x4c\xe1\x04\x8a\xb6\
\x74\x67\xc9\x0a\x2f\xb0\x7f\x5e\xc6\x12\x4d\xad\xca\xf8\x00\x3f\
\x63\x5e\xe7\x42\x45\xd4\xdc\xaa\xb0\xfa\x70\xde\x9d\xc4\xbb\x64\
\x28\xd8\x0c\x8c\xed\x9f\x37\x01\x2d\xc9\x44\xf2\x4d\xb6\x92\x8a\
\xb4\x77\x18\xc7\x06\x16\xed\x98\xf7\x08\x47\x7d\x80\x58\x50\x0c\
\x76\x98\x6a\xc2\x62\x0c\x09\xc8\x36\xf1\x8f\xe4\xf7\x91\x3a\x34\
\xf9\x65\xfa\xc2\x26\x8f\xe2\x66\x54\x51\xf2\x1b\x42\x7a\xd1\xf4\
\xd7\xc5\xc3\x88\x7d\x7e\xc2\x04\xff\x63\x0f\x4d\x7e\xb1\xe9\xc0\
\x4c\x14\x08\x12\x9a\xbe\x3b\xbf\xe7\x6f\xc3\x5d\xa8\x68\x12\x18\
\x24\x92\xee\x04\xde\xe8\x15\x4d\x7c\xce\xe0\x70\x2b\xa4\xe5\x34\
\x7d\x3f\xd0\x9d\xbe\x87\xf2\xb0\x5e\x40\xec\xfa\xd4\xa4\x0f\xf7\
\x61\x80\x12\xc5\x98\xa5\x46\x01\xa5\xb7\x96\xd3\x5c\xee\x3f\x84\
\x76\x7a\x01\x39\x78\xc1\x05\x24\x4a\xf0\x0a\x85\x92\x25\x2b\x2d\
\x12\x0c\xe1\x5e\xac\x43\x91\xb8\x88\x00\xc9\xcf\xe2\x43\x7c\xc5\
\x9a\x1e\x9f\x2c\x83\x57\xa8\x83\xab\x5e\xa1\x4c\x62\x18\x87\x65\
\x40\x56\x7e\x97\x82\x6b\x71\x0b\x6e\xc7\xe5\x96\x90\x11\xb6\x31\
\xfc\x89\xe3\xf8\x11\xbf\x22\xa1\x38\xc9\xad\xee\x0c\xb6\x1f\x5c\
\xf5\x12\x18\x25\xea\x94\x18\x22\x4d\x4c\x5a\xf8\xec\x43\x0d\x7d\
\x04\x70\x8e\x68\xd0\x52\x23\xb6\xc0\xe8\xca\x21\xfd\x9a\xd7\x58\
\x93\xe0\x45\x3c\x19\x93\x7e\x13\x89\x10\x02\xdd\x89\x7c\x20\x9f\
\x15\x5e\xc4\x0f\x76\x2e\xe1\x55\xc2\x43\x55\x19\x4d\x46\xa5\x06\
\xc8\x0a\xe0\x05\x68\x06\xfb\xbf\x21\x7c\x95\x70\xe8\x12\x5e\x25\
\x44\x11\xbe\x0c\x49\xee\x97\x11\x54\x00\x5c\x2c\x7f\x58\x48\x26\
\x85\x2f\x43\x0e\x5d\xf2\xcb\x90\x6e\x19\xff\x3a\x27\xa9\x63\x50\
\xea\xec\x32\x83\x69\xf1\xaf\x73\x0e\x35\xb1\x46\xf9\x1b\xf7\x82\
\xd8\x72\x5d\xe0\x36\xb0\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\
\x60\x82\
\x00\x00\x22\xc0\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x80\x00\x00\x00\x80\x08\x06\x00\x00\x00\xc3\x3e\x61\xcb\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\
\x01\x42\x28\x9b\x78\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x20\x00\x49\x44\
\x41\x54\x78\x9c\xed\x9d\x7f\x8c\x24\xc7\x75\xdf\x3f\x55\xd5\x3d\
\x3f\xf7\xf7\xed\xde\x0f\xf2\x48\xde\x51\xfc\xa5\x55\x22\x45\xa2\
\x45\x8b\x11\x15\x52\x52\x00\x39\x8a\x11\x27\x40\x64\xe4\x8f\x04\
\x31\x0c\x44\x06\xe2\xfc\x13\x04\x31\x90\x08\xf1\xf1\x6c\x18\x49\
\xe0\x58\x0a\xe4\x38\x4e\xac\x58\x86\x60\x28\x8e\x0d\x41\x06\x44\
\x47\x91\x25\x38\xd6\x09\xb4\xec\x88\xa2\x49\x59\xe4\xf1\xf7\x8f\
\x3b\xde\xdd\xde\xde\xde\xee\xce\xef\x9e\x9e\xee\xaa\xca\x1f\xdd\
\x33\xd3\x3d\x3b\xb3\x33\xb3\xdb\x7b\x77\x14\xf7\x3b\x68\xec\x76\
\x77\x75\x75\xd5\x7b\xaf\x5e\xbd\xf7\xea\x75\xb7\xb0\xd6\x72\x88\
\x77\x2e\x9c\x2c\x2a\x11\x02\x91\x45\x3d\x87\x98\x0e\xd6\xb2\xef\
\xd1\x2b\xa6\xd5\x00\x42\x20\xba\x97\x9c\x3d\x1b\x33\xfe\xcc\x7e\
\x9b\x71\x88\x3d\xe1\x6c\xf4\xe7\xcc\x99\x48\x10\x84\x98\x5e\x28\
\xa6\x12\x00\x01\xe2\xf1\xb3\x88\xd5\x55\xc4\xf9\x15\xc4\x89\x59\
\xc4\x83\xc0\xeb\xc5\x43\x0d\x70\x33\x70\xb7\x87\x7d\x1a\x58\xab\
\x63\x57\x37\xb0\xe7\xcf\x63\x1f\x3f\x83\xb5\x4c\x2e\x04\x13\x0b\
\x40\x97\xf9\x3c\x8a\x5c\x3d\x8a\xa4\x8a\x9a\x2f\x23\xdb\x79\xa4\
\x5b\x41\x34\x9c\x43\x21\xb8\x91\x98\x09\xb1\xc1\x02\xb6\xe0\x63\
\xaa\x4d\x0c\xf3\xe8\xf3\xd7\x30\x9c\xc3\x4c\x23\x04\x13\x0b\xc0\
\xd9\xb3\x48\x1e\x45\x3e\x74\x12\xd5\xe8\xe0\x52\x25\x17\x4a\x5c\
\xa7\x80\xa3\x3b\x48\x25\x0f\x05\xe0\x46\x42\x1b\xac\xca\x61\xc2\
\x36\xa1\x63\x08\x98\xa7\x33\x93\x23\xf8\xde\x25\x34\xe7\x30\x67\
\xce\x60\x26\xa9\x67\x52\x23\x50\xac\xae\x22\x38\x8a\x0c\xd6\xc9\
\x51\xa2\x40\x8e\xa2\x63\x29\x86\x9a\x7c\x4e\xa0\x8c\x40\xba\x80\
\x0e\x0f\x05\xe1\x20\xa1\x1c\x6c\x00\xb8\x02\xd3\xd1\x68\x47\xe1\
\xe3\xe0\xe1\xe3\x05\xdb\x88\xd5\xa3\xf8\xac\x62\x01\xc1\x04\x5a\
\x60\xac\x00\x08\x10\x16\x38\xbf\x82\x58\xad\xa2\xfc\x45\x5c\xe5\
\x53\xd2\x30\x87\x62\xa6\x60\x29\x1a\x17\xd7\x06\xa8\x40\x20\xc8\
\xed\xbf\x93\x87\x18\x0d\xa3\x63\x43\xcf\x45\x17\x34\x41\xa8\xf0\
\x30\x34\x14\x08\x7f\x11\x4d\x95\xf0\xfc\x4a\x34\xfa\x63\xde\xed\
\x2a\x04\x13\x6b\x80\x13\xb3\x88\x79\x17\x59\x6d\x92\xb3\x92\x22\
\x92\x19\x01\x0b\xff\xe0\x03\x7c\x7d\xdf\xbd\x3a\xc4\x9e\xf1\x95\
\x67\xf8\xa4\x95\x60\x0d\x01\x4d\xfc\xf9\x32\xfe\x89\x1c\x82\xac\
\x34\x40\x17\x8b\xaf\x23\xda\xef\x45\x16\x2d\xca\xd7\xe4\xb0\x14\
\xb5\x65\x06\xe0\xa5\x4b\xaf\x50\x6d\xd6\xf6\xde\x8b\x43\x4c\x8d\
\xf9\xf2\x1c\xf7\x9f\xbc\x17\x6d\x98\x91\x02\x1f\x41\xb3\x98\x43\
\xb5\xf3\xc8\xc5\x97\x10\x3c\x38\x59\x3d\x72\xd2\x1b\x5e\x9d\x41\
\xb8\x15\x84\x56\x48\x14\x4a\x82\xab\x62\x85\x7f\xc8\xfc\x1b\x8f\
\x2e\xcd\x95\x20\x27\xc1\x45\xa1\xb4\x8a\x3c\xb2\xab\x33\x93\xdb\
\x61\x13\x0b\x00\x40\xc3\x41\x28\x89\x30\x1a\xa9\x0d\x0a\x81\x9a\
\xb2\xdd\x87\xc8\x1a\x02\xa5\x0d\xca\xe8\xc8\x13\x9b\xd6\x1d\x9f\
\x4a\x00\x00\x3a\x3e\x42\x0a\x44\x1c\x11\x9c\xfa\xfa\x43\x64\x0b\
\x6b\x91\x42\x44\x3c\xe9\xf8\xd3\x7b\x60\x87\x0c\x7c\x87\xe3\x50\
\x00\xde\xe1\x38\x14\x80\x77\x38\x0e\x05\xe0\x1d\x8e\x43\x01\x78\
\x87\xe3\x50\x00\xde\xe1\xc8\x24\x23\xe8\xed\x88\x4e\xc7\xb0\xbe\
\xd5\x22\x0c\x0d\xc7\x8e\x94\x28\x15\x77\x27\x45\x76\x89\x73\xfb\
\xaf\x29\xcb\x2c\xbe\x5b\x4e\x00\x6e\x14\xa1\xaf\x6d\xb5\xf8\xfa\
\x93\x97\xf9\xe2\x57\x5f\x8e\x0e\x88\xc8\x85\xfe\xef\xbf\xf8\x30\
\xef\xbb\x7f\xa9\x5f\x4b\x26\x0d\x4a\x54\xb2\x9f\xb5\xd2\x03\x48\
\xdf\xcc\x64\x0a\xb0\x19\xfc\x8c\x8d\x36\xbb\xaf\xcd\xf4\xb7\x31\
\xbf\x56\x47\xb3\xb6\xd1\x8a\x18\x9f\x60\xca\x97\xbe\xf6\x5a\xaa\
\xce\x88\xea\x93\x6f\xc3\x7f\x89\x12\x76\x1f\xdb\xc0\xdd\xb2\x40\
\x26\x1a\x60\xcf\xb9\x89\xfb\xe8\xc5\xd8\x4b\xc7\x14\x90\x52\x50\
\xc8\xc9\x88\xb2\xa2\x2f\x01\xcf\xbe\xb8\xc9\xb3\x2f\x6d\xa5\xb4\
\xc0\x44\xed\x19\xa7\x2a\x26\x19\xf9\x37\x21\x41\x3b\x1b\x01\xb8\
\x81\x0d\x9f\x28\x83\x69\x22\x62\x5b\x2c\x22\xc5\x7c\x88\x78\xf0\
\xbb\x4f\xbc\xc6\x7b\xef\x5b\x1c\x5f\xc5\x34\x1c\xbb\x45\xb3\xef\
\x0f\x5e\x03\x64\xd4\xf1\xac\x89\x3d\xaa\x3e\x63\xe1\xbb\xcf\x6c\
\xf0\xea\x5b\x75\xde\x75\xc7\xcc\x34\x55\x4e\x88\x5b\xcb\x08\xcc\
\xc6\x06\xd8\x6d\x5e\x9e\xd6\x16\x18\xb1\x65\x35\x1b\xef\x9c\x99\
\x53\x3d\x89\x0e\x09\xcb\x17\xbf\xfa\x0a\xd9\xd9\x26\xc9\x6d\xef\
\x36\x40\xaf\x2d\xbd\xf6\xef\x1f\x37\xd7\x06\x48\xd6\x71\x83\x55\
\xe4\xf0\xb4\xd9\x38\x89\x46\x08\xce\x3d\xb5\xce\x73\xaf\x54\x58\
\xbd\x67\xfe\xc6\x36\xec\x06\x23\x23\x0d\x90\x9d\x54\xdf\xc8\xdf\
\xa8\xbe\x44\xa7\x2c\xff\xf5\xf7\x5f\x9c\x82\x06\x59\x6a\x89\xd1\
\x9b\x49\x6c\x59\xe0\x96\xd1\x00\x13\xdf\x2b\xa3\x8e\x47\x02\xb8\
\xb3\xae\x5e\x5f\x84\xe4\x87\x2f\x55\xf9\x93\x3f\x5f\xe3\xa3\x1f\
\x3a\x9e\xc9\x3d\x47\xb6\xe5\x06\xd2\x6f\x10\x19\x79\x01\xfb\xeb\
\xc0\x8d\xea\x7e\x92\xd0\xa3\x74\x80\xb5\xc9\x5c\x4a\xc1\xe7\xbe\
\x74\x9e\xf7\xdc\x3f\xcf\xca\x62\x21\x9b\x36\x64\x1d\x58\xda\x27\
\x32\x0a\x04\xed\xdc\x46\x19\x73\xc3\x0d\xbc\xec\x7f\xc6\xee\xdc\
\x06\xa7\x9f\xe1\x9d\x31\xa9\x9e\xd4\x5b\x9a\x5f\xf9\xcd\xe7\x30\
\xda\x8c\x57\xd1\x13\xb4\x25\xab\xc9\x2b\x2b\x11\xc8\x44\x00\x26\
\x21\xf6\xf8\x6d\xca\xf9\x70\x0c\xb1\x27\x23\xe3\x4e\x58\x1b\xc7\
\x06\xba\xf1\x01\x2b\xf8\xab\x97\x2b\xfc\xaf\xaf\xbf\xc9\x30\x41\
\x4f\x6d\x7b\xb2\x6f\x46\xd5\x35\x9e\x06\x59\xe0\x86\xdb\x00\xdb\
\xed\x45\x24\x86\xf9\x42\x75\xbf\x37\x9d\xf2\xfe\x3b\x03\x3e\xc3\
\xa7\x80\xae\x7b\xd0\xb5\x05\x22\x6e\xfe\xce\x57\x5f\xe7\xbd\x0f\
\x2c\xf2\xee\x77\x0d\xf7\x0a\xec\x9e\x63\xfc\xd1\x7d\x6a\xed\x79\
\x8c\x95\x2c\x14\xb6\xf6\x5a\xd1\x9e\x70\x00\x6b\x01\xa3\x25\xda\
\x0b\xf2\x6c\x36\x97\xd8\x68\xac\xb0\xdd\x9a\xdf\x9b\x15\xcc\x5e\
\x63\x04\x03\xbf\x9e\xaa\x1f\xe8\x8b\xe8\x3e\x53\x91\x86\x36\xf0\
\x2b\xff\xed\x79\xea\xad\xa0\xaf\x6d\x92\x6d\xd8\x87\x65\x5f\x69\
\x2d\xb0\xd1\x58\x61\xb3\x75\x04\x2f\x2c\x4c\xd8\x9f\x6c\x70\x00\
\x36\xc0\x4e\x42\x5b\x6b\xd0\x56\x70\xb5\x71\x3c\x52\x8f\x58\xae\
\xb7\x96\xd9\xf6\x16\x26\x52\xd5\x49\x62\x67\xe5\x4e\x75\xdb\xbd\
\xb3\x33\x71\x4f\x52\x2a\x56\x80\x15\xac\x5f\x6f\xf3\xd9\xdf\x7e\
\xb1\x5f\xc7\x1e\xd4\xf0\x60\xbf\xb6\xbd\x05\x36\x5b\xcb\x3d\x42\
\xae\x37\x8e\xa3\xad\xd8\x9d\x1a\x19\x4e\x01\x37\x20\x12\x18\x11\
\xfa\x5a\xf3\x28\xa1\x4e\xcf\x38\x8e\x0a\x76\x97\xf2\x7d\xcc\x77\
\x93\x08\xd5\x50\x0d\xd0\x3d\x24\x07\xd6\x09\x62\xe7\xe0\xc9\x67\
\x36\x78\xe2\x4f\xaf\x0c\x6d\xe3\x24\xbe\xfb\xa0\x9d\xe0\xca\x34\
\x0d\x42\xed\xb2\xd1\x38\xb6\xbb\x9d\xd4\x6b\xff\xfe\x71\x43\x96\
\x83\xeb\xfe\x2c\x4d\x7f\x36\x75\xcd\x6c\xbe\x4a\x29\x57\xdf\x21\
\xd5\xc3\x84\x67\x52\x42\xdb\x5d\x08\xbd\x63\x83\xa1\x2a\xe0\xe3\
\x0f\x1f\x8b\xf8\xbe\x43\x3e\x6c\x24\x14\x16\x7e\xeb\xf7\x5e\xe1\
\xf5\xb7\x1a\x93\x6b\xad\x5d\x7e\xc5\x5c\x9d\x99\x7c\x25\xd9\x53\
\x9a\x9d\x19\xea\xfe\xec\x90\x1a\x6e\xd5\x29\x60\x17\x42\x6b\xad\
\xd8\x68\x1e\x4d\x35\xdc\x51\x1d\x96\x4a\xd7\x52\x52\x1d\x18\x67\
\xa2\x51\xbb\x1b\xa1\xa7\x73\x29\x87\x13\xf1\x5f\xfd\xb3\x07\xf8\
\xcd\x5f\xfe\x20\x1f\xfe\xc0\x32\x42\x76\x1f\xb1\x17\xfd\x8e\x02\
\x9d\xd0\xf0\xf9\xdf\x7d\x29\xd5\x27\x33\x64\x1b\xa5\xd9\x02\xe3\
\xa6\xf6\x97\x4a\x1b\x38\xaa\x93\xa2\xdb\xf5\xd6\x51\x42\xad\x30\
\x76\xb8\x97\x95\x55\x24\xf0\xc0\x35\x40\xd5\x5f\xa0\x1f\x5c\xb1\
\x08\x61\x58\x2e\x5f\x01\x61\x7a\x8c\x30\x48\xde\xd8\xbc\x97\x4b\
\xb5\x53\x58\x2b\x46\x12\x6e\x5a\x42\xef\x5a\x8f\xed\xde\x3d\x0d\
\x63\x2d\x27\x4f\x14\xf9\x37\x3f\xbf\xca\xe7\x3e\xf3\x20\x77\x75\
\x57\x04\x2d\x89\x29\x41\xf0\xe2\x2b\x75\xbe\xf3\xbd\x6b\xd3\x09\
\x9e\x85\xcb\xb5\xbb\xb8\xb0\x79\x2f\x86\xe4\x3c\x1f\x72\xa4\x74\
\x25\x7e\x10\x3f\xbe\x9d\x91\xd4\x3a\xbb\xdb\x48\x59\xe0\xc0\x02\
\x41\x16\xd0\x56\x52\x6d\xcf\xa7\x24\x7b\xae\xb0\x89\xab\xda\x29\
\x49\x5e\xab\xdd\x4e\x5b\x17\xd9\x6e\x1d\xe1\x62\xf5\x54\x5f\xea\
\x19\x66\xf1\xef\xfd\x67\xac\xe9\x6d\xa3\x94\x68\xb2\xfc\xbb\x4e\
\x95\xf9\xec\x67\xde\xc7\x4f\x3c\x7a\x2c\x56\x02\x96\x9e\x36\x90\
\x82\x2f\x7d\xf5\x75\x82\x60\x82\x00\x91\x05\x6b\x05\x97\xaa\xa7\
\xa9\xb4\x96\x69\xeb\x22\x57\x6b\x27\x13\x71\x02\x70\x9d\x36\xf3\
\xc5\xeb\x29\xfa\xd5\xda\x8b\x68\x2b\x77\xd2\xd6\xee\xc9\xfe\x1c\
\x8a\x03\xd3\x00\xc6\x1a\xaa\xde\x3c\xc6\xf4\x9f\x1f\x15\x52\x33\
\x9b\xdf\x4a\x95\xab\xb5\xe7\xd9\x6a\x1d\xed\x95\xa9\xb5\x97\xb8\
\xde\x3c\x16\x8f\x98\x69\xb7\x3e\x71\x86\x06\xa7\x18\x3f\x87\x0e\
\x96\x71\x1d\xc9\x3f\xff\x27\xf7\xf2\xaf\x7f\xee\x01\x72\x8e\x8c\
\x8e\x5a\xc0\x1a\xd6\xae\xf9\xfc\xef\xff\x7b\x79\xe4\x00\xe8\x6b\
\x2d\xc3\x46\xf3\x28\xd5\xf6\x52\xef\xd8\x56\xeb\x28\xf5\xf6\x7c\
\x8a\x16\x33\xf9\x2d\x84\x0c\x7b\x57\x1a\x23\xa9\xb7\x13\x5a\xe0\
\x56\x35\x02\x87\x13\x5b\x50\xef\x2c\xa6\x08\x31\x9b\xdf\x8e\x55\
\x7f\x3c\x17\x6a\x97\xb5\xfa\xe9\xa8\x92\xf8\xa0\xab\x7c\xe6\x8b\
\xd7\xc6\x12\x75\xf8\x66\x31\xf1\x6f\x32\x9d\xb0\x13\x3b\x04\x2f\
\xfe\x3d\xf2\xc1\x65\x7e\xe1\xe7\x1e\x40\xa9\xee\x74\x26\x41\xc0\
\xef\xff\xd1\x5b\xf8\x81\x1e\x6b\x90\xce\x17\xae\xe1\x2a\x3f\xd5\
\xe0\xb5\xda\x69\xc2\xd0\x4d\x8c\x68\xc3\x6c\x6e\x3b\xd5\xa7\xba\
\xbf\xd4\xb7\x95\xc6\xb6\x7e\x7a\x1c\x98\x06\xa8\xfb\xf3\x68\xad\
\xe8\xcd\xfd\x52\x33\x53\x48\x8f\xfe\x2d\xef\x18\xa1\x76\xfa\x56\
\xb9\xb0\x9c\x98\x7f\x0d\x29\xc2\xa9\x46\xfe\x5e\x43\xd0\xc3\x68\
\x38\x8c\xd0\x36\x0a\x03\xf0\x63\xef\x5f\xe2\xe7\x7f\xe6\x5e\x84\
\x8c\x85\xc0\x42\xbd\xa9\xf9\xee\xf7\x37\xc7\x4e\x57\x52\x86\x1c\
\x9f\x7f\x35\x9e\xe7\xa3\x4d\x1b\x87\xad\xf6\xb1\x54\xb9\x72\x61\
\x0b\x21\xfa\xef\x77\xd2\x46\x51\xf7\x17\x86\x0a\x7c\x16\x38\x30\
\x2f\xa0\x31\xd0\xe8\x72\xae\x82\x40\xf7\xa4\x39\x34\x8a\x8a\x77\
\x94\x64\x97\x96\xca\x57\x28\xb8\x8d\x1e\xc1\x87\x6d\x59\xdb\x05\
\x3b\xfa\x32\x6c\x4b\x08\xdb\x47\x1f\x5e\xe1\xef\x7f\xe2\x24\xd0\
\x8f\x18\x7e\xeb\xc9\xab\x13\xd1\xa9\xe8\x34\x38\x52\xba\x9c\x3a\
\x56\xf5\x8e\x11\x1a\xd5\xab\x5f\x10\x52\xce\x6f\xa5\x88\xd9\xf4\
\x17\x86\x6a\xa5\x2c\x70\x20\x1a\x20\xb4\x8a\x8e\xce\xa7\x4a\xcc\
\x14\x36\x53\x64\xdf\x6e\x1e\x43\xeb\xfe\xed\x1d\x15\xb0\x54\xba\
\x3c\x76\xb4\xef\xab\x9d\x13\xd4\x35\x8c\xd0\x83\xbf\x9f\xfe\x7b\
\x27\x59\x39\x92\xa3\x2b\x22\xcf\xbf\x54\x63\x6d\xc3\x9b\x48\xe0\
\x16\xcb\x97\x71\x54\xd0\xbb\x9f\xd6\x92\xed\xd6\xb1\x94\x90\xcf\
\x14\xb6\xba\xc1\x47\xac\x80\x8e\xc9\xa3\x71\xfa\x65\x6e\x35\x23\
\x70\x10\x7e\xa7\x1c\x65\x57\xc6\x2d\xcd\x29\x0f\x49\xd0\x57\xd9\
\x46\xb0\xed\x1d\x4b\x5d\xb3\x50\x5a\x4b\xb8\x86\xd9\xfe\x7a\x76\
\x81\xb0\x3d\x22\x8e\xca\x1c\x4e\x69\x1c\x86\x6b\xb7\x9c\x2b\xf9\
\xd9\x7f\x74\xba\x7f\x0d\x86\x6f\x7d\x67\x7d\xe4\x54\x93\xb6\x8d\
\x0c\x73\xc5\xb5\x94\x86\xa9\x7a\xc7\x31\x46\x24\xb4\x40\x80\xab\
\x5a\x49\x2b\x92\x76\xa7\x74\xeb\x6b\x80\x2e\xa1\xbd\xb0\x98\x22\
\x64\xce\x6d\xa6\xf6\x6b\x9d\x23\x18\xd3\x0f\x0b\x4b\x15\x32\x97\
\xbf\x36\x92\x80\xd3\x6c\xe3\x97\xa6\xbb\x23\x9c\xe1\x53\xc0\xa0\
\xd6\x19\xf1\xfb\xe0\xdf\x58\xe4\xee\xbb\xca\x3d\x26\x9d\xfb\xf3\
\x8d\xd1\x82\x37\xf0\x9b\x2b\x5c\x45\xa9\xb0\x77\x4f\x6d\x1c\xea\
\x9d\xa5\x54\x99\x9c\xdb\x48\x09\x89\x17\x94\x77\x4c\x7d\x59\x20\
\x53\x2f\xa0\x4b\xe4\x76\x30\x93\x9a\x44\xf3\x6e\x3d\x45\xd4\x96\
\x3f\x97\xea\xdc\x42\x7e\x1d\x21\xc3\x7d\x8f\xf0\xc9\xad\xff\xd1\
\x23\x68\x9a\x44\x96\x8f\x3d\x72\x34\x36\xea\x04\x5b\x95\x0e\xd7\
\xb7\x3b\x13\xad\x52\x0a\xa9\x99\xcb\xaf\xa7\xee\xdb\xf2\x17\xe2\
\xf8\x47\xb4\xb9\x4e\x23\x75\xbe\x1d\x96\x77\xd4\x93\x05\x32\xb7\
\x01\x02\x9d\x43\x1b\xa7\xdf\x48\xa9\x71\x65\x7a\x7e\x6c\x75\xd2\
\x6b\xea\x85\xc2\xd6\x54\x84\xdf\x7f\xca\x78\x3c\x43\x0d\xed\xcb\
\xe4\xdb\x87\x7f\x7c\x99\x9c\x2b\xbb\x3d\xe5\xc2\xe5\xe6\xc4\xd7\
\x16\x07\xd6\xfd\xbd\x4e\x3a\x26\xe0\x4a\x0f\x84\xee\x0b\xb9\x71\
\x08\xc3\x5c\x66\xf6\x50\x17\x99\x47\x02\x7d\x5d\x4a\x9d\xcb\x39\
\xcd\x88\x51\xb1\x64\xb7\x83\x32\xda\xb8\xfd\x06\xc8\x90\x9c\x9a\
\x9c\x70\xfb\xd9\x06\x53\xb3\x86\xf6\x65\x0a\xf7\xb3\x58\x90\xdc\
\x77\xcf\x2c\x5d\x83\xe2\xcd\xb7\x9a\x13\x5f\x9b\x93\x0d\x84\xec\
\xe7\x16\x84\xc6\xc1\x0f\x4b\x7d\x11\x10\x86\x9c\x9b\xd6\x02\xbe\
\x29\xf5\x6d\x93\xa9\xb9\x34\x1c\x99\x0b\x80\xb6\x4e\x7c\xac\x2f\
\xc9\xa9\xd1\x1f\xa4\x47\x7f\xd1\xad\x44\xe3\x78\x0a\xc2\x4f\xbb\
\x75\xc3\xbf\x93\x4c\x03\x3b\x5c\x4f\x76\xdf\x4e\xdf\xd9\x7f\x7a\
\xe8\xc2\xa5\xd6\x70\xc1\x63\x88\xe6\x12\x86\xa2\x5b\x49\xdd\xdb\
\x0b\xd2\xae\xb3\x23\xbd\x34\x6d\x8d\x93\xb9\x11\x98\x69\x56\xb0\
\xc5\x12\x6a\x95\x6a\x5c\x57\xca\xbb\x08\xc2\x52\xaa\xe9\x85\x5c\
\x85\x54\x22\xee\x7e\xdb\xb2\xcf\x8a\xa6\x55\xad\xa7\xef\xea\x6b\
\xbc\x8b\x97\x5a\xa9\xfb\x8f\xab\xa9\xe0\x56\x69\xfa\xcb\xbd\xfd\
\x20\x28\x61\x8b\xfd\xf3\x51\x58\xb8\x5f\x93\x36\x2a\x33\xc6\x77\
\x91\x89\x00\x24\x2d\x52\x63\x9d\x54\x13\x23\xe3\xae\x8f\xc0\xb8\
\x24\x49\xe3\x28\x6f\xff\xfe\xfd\x1e\xaf\x19\x6e\x03\x4c\x57\xdb\
\xdc\x5c\x9f\x84\xeb\x1b\xed\x31\x63\x33\xed\x7b\x3a\x8e\x97\xda\
\x0f\xac\x9b\xba\x5a\xca\x20\xd5\x4a\x3d\x40\xdb\x2c\x90\x51\x52\
\x68\x1f\x83\x59\x3f\x52\xa4\x05\xc0\x58\x37\x75\x5e\x88\xce\x9e\
\xa5\x7a\x52\x42\x0f\xbf\x76\x84\x0d\x30\xcd\xfd\x6d\xfa\x5e\x79\
\x37\x5a\xbf\xdf\xed\xae\x49\x08\x3a\xa9\x7d\x63\xd2\x02\x20\x44\
\x90\xba\x42\x6b\xe7\xd6\xd4\x00\x69\x06\xa7\xab\x8c\x3a\x91\x90\
\xe2\x41\x01\x51\xc1\x44\x5d\x9a\x4e\x49\x8c\x2a\x9c\x54\xcf\x23\
\x6c\x80\x09\x5a\xd3\x2b\x21\x00\xd9\x2f\x5f\x9e\x51\x58\x31\x79\
\x43\x85\xea\xa4\x19\x6c\xdc\x54\x3f\x05\x61\xaa\xbc\xb5\x4e\x66\
\x11\xc0\x2e\x32\x7f\x32\xc8\x58\x35\x44\x8a\x13\xe7\x4d\x52\x03\
\xd8\x1d\x52\x9e\xaa\x37\xb9\x93\xf1\xab\x55\xec\x88\x39\x60\x5a\
\x02\x27\x9b\x55\x2e\x39\xc3\xeb\x1c\x75\xad\x08\xe3\xb4\x90\xa8\
\x16\x63\xdc\x54\x7a\xb9\x50\x61\xca\x3e\x8a\xa6\x80\x5b\x51\x03\
\x74\xa5\xde\xa6\x3b\xdb\xa3\xb1\x1d\x72\x8c\x38\xcf\x32\x63\x89\
\x9e\xa8\xba\x5d\xc2\xc1\x76\x97\x46\x0d\xb7\x19\xfa\x28\x97\x55\
\xca\x1e\x9a\x48\xb3\x0d\xec\x0f\xa6\x7a\x45\xa1\x61\xd1\x2b\x3b\
\xd1\x77\x60\xa6\x40\xe6\x6f\x08\x91\x22\x44\xdb\xfe\x67\x43\xb4\
\x75\x62\x63\x26\x3e\x2f\x03\xb4\x89\xce\x5b\x04\xda\x2a\xa4\x48\
\xab\xba\xe8\xdc\x14\xf7\x9f\xba\xc1\x8c\x5c\x50\x99\x36\xd7\x2e\
\x59\xba\x54\x52\xb1\x80\x4f\x56\x47\x34\x5d\xf6\xa5\x50\xc8\xb4\
\x36\x8c\xc2\xe5\xa2\x77\x4c\x0d\xd8\x53\x59\x20\x73\x2f\x00\x11\
\x40\xe2\xbb\x31\xa1\x51\x38\xa2\x6f\xec\x08\xd9\x01\x93\x38\xaf\
\x73\x38\xce\x4e\x01\x98\x04\xd3\xab\xc3\x3e\xb1\x47\x7b\x01\xd3\
\xdd\x7f\x63\xcb\xef\xed\x97\xcb\xce\x54\x31\x7a\xad\x73\xa9\xd2\
\x52\xa6\x0d\x62\x63\xbb\xf9\x14\x31\x06\xa6\xd3\x2c\x90\xf9\xa3\
\x61\x52\x86\x84\xba\x7f\x6e\xd0\x2d\x4c\x6a\x83\xe8\xbc\x3b\xa1\
\xaa\xcc\xa2\xe3\x69\x23\x70\xaf\xf7\x49\xda\x3c\x6f\x5e\x68\xf6\
\xfe\x3f\x7d\xba\x34\x95\x4b\x1b\x69\x80\xd1\x31\x13\x6d\xd5\x0e\
\xda\xdd\xa2\x02\xd0\x87\x10\x3b\x7d\xd7\xa4\x08\x28\x91\xb6\x7c\
\x03\x5d\xc0\x19\x88\x88\xf5\xea\xcd\xca\x40\x18\x36\xd7\x8f\xd0\
\x01\xbb\x11\x38\x65\xfd\xc7\xb8\x70\xa1\x15\x1d\x12\xb0\xfa\x9e\
\xb9\xf8\xd1\xb2\xc1\x0b\x87\xd7\x19\x86\xc5\xd4\xbe\x12\x9d\x54\
\x51\x63\xdc\xb4\x02\x10\xe1\x2d\xee\x05\x88\x9d\x81\x1f\x33\x10\
\xbd\x52\x4e\x13\xfc\xfe\xbe\x1f\x2c\x50\x28\xac\xa5\xeb\xeb\xfe\
\xb3\xab\xe5\x3f\x6a\x41\x7f\x32\x33\x7c\xe4\x14\x30\x05\x81\xad\
\x85\x8b\x17\xa3\x60\xce\xc9\xdb\x8b\xcc\xcd\x38\xa9\x0a\x46\x0a\
\x53\xdc\x74\x3f\x4c\xbf\x89\x4c\x39\x8d\x94\x1b\x69\xac\x93\xfe\
\xee\xd7\x2d\xaf\x01\x2c\x08\x82\x14\x65\xc3\xb0\x44\xc2\x26\xc4\
\x75\xb6\x81\x7e\x32\x85\x1f\x2c\x62\x4d\xf7\xe3\x74\x7b\xba\xeb\
\x58\x42\x8f\xbb\x3e\x7d\x74\xf2\x76\xac\x6f\xf8\x78\xed\x68\xbe\
\x7b\xe8\xa1\xc5\xde\xb5\x63\x6b\xb0\x80\x15\x74\x82\xb4\x00\xb8\
\xce\x76\x42\x7e\x2c\x61\x58\x1c\x88\x0b\x4c\x16\x33\x99\x06\xd9\
\xd9\x00\x31\xb1\x95\xd3\x48\x31\x33\xd0\x33\x51\xa3\xe3\x63\xca\
\xad\x23\x45\xd0\x8b\x08\x5a\xe3\x10\x98\x32\x8e\xaa\xef\xe1\xbe\
\x7b\x2f\x90\x85\x11\xf8\xca\xab\xd1\x6a\x5d\x21\x2f\x79\xe4\x23\
\xcb\xe3\x5d\xb4\x84\x40\x86\x7a\x26\x95\x14\xa3\x44\x80\x74\xea\
\x89\xc1\x24\x08\xc2\x99\xd4\xe5\x4a\x35\x6e\x61\x0d\xd0\x9d\x05\
\x64\x3b\xb2\x56\xbb\x01\x1f\x2b\x09\x75\x09\xa5\x9a\xbd\x42\x6e\
\x6e\x0b\xdf\xef\xa7\x84\xf9\xfe\x32\xaa\xb4\xbb\x00\x4c\xdd\xed\
\x61\xa3\x7f\x87\x7a\x9e\xce\x06\x18\x6c\xcb\xd3\x4f\x47\xb6\xcb\
\x23\x1f\x39\x42\xa1\x28\xc6\x5f\x9b\x38\xdd\xf1\x8f\xa4\x4e\x39\
\xb9\xad\xd4\xd5\xda\x94\xb0\x36\xf9\x4c\x45\x80\x50\xed\xcc\x35\
\x40\x36\xcb\xc1\x03\x4b\xa8\xce\x40\x36\x4b\x10\xcc\x60\x13\x24\
\x77\xdd\x74\xee\xbb\xe7\xdf\x86\x31\x92\xc1\xa5\xda\x7d\x65\xfe\
\x0e\x5b\x1a\x4e\xdc\x73\x14\x21\x07\xcb\x24\xb7\x64\x5b\x1a\xcd\
\x90\x17\x5e\x68\x90\xcb\x4b\x3e\xf6\xb7\x97\x27\x68\x51\xa2\x1e\
\xa3\xf0\xfc\xdb\x53\xf7\x75\x06\x68\x12\x04\xe9\x87\x69\x1d\xa7\
\x8e\x45\xf4\xb6\xfd\x85\x46\xfb\x38\x90\xc7\xc3\x95\xaa\xa5\x3a\
\x13\xea\xd9\xd4\x7e\x2e\xb7\x81\x48\xb8\x83\xc6\x38\x78\xfe\x6d\
\x43\x09\x3d\xfd\x6f\x77\x26\x8e\x13\x82\xe8\xf8\x20\xa1\xa3\x4d\
\x20\x7b\xdb\xb3\xcf\xd4\x30\xc6\xf2\x53\x3f\x75\x82\xc5\x85\x7c\
\xea\x5c\x7f\x53\xbd\x4d\x26\x7e\x1d\xff\x76\x6c\x42\xfd\x0b\x19\
\x52\xcc\x6d\xa6\xca\x18\x3d\x87\x48\xfc\x5c\xd5\x42\x22\x51\xf1\
\x26\x33\xca\xe7\xcd\xdc\x0d\x84\x68\x9e\xa7\xdd\x3f\x11\xea\x12\
\xc6\x3a\x88\x6e\xc4\x4f\x68\x0a\xf9\xcb\x78\xde\xa9\xde\x35\xed\
\xf6\x1d\x14\x0a\x57\x10\xc2\xf4\x42\x9f\x93\x43\x0c\xf9\x6f\x77\
\x48\xe4\xd0\xfb\xc8\xf8\x53\x88\xe3\xea\x79\xfa\xfb\x15\x4e\x9f\
\x2e\xf1\xf1\xc7\x8e\x0d\x29\x3b\xba\x3d\xd6\x0a\xda\xed\x3b\x52\
\xf7\x2e\xe5\xaf\x20\xa5\xa5\x3b\x1e\xad\x75\x30\xba\x8c\xe8\xb9\
\x94\x96\x5c\xae\x81\x1c\xe6\x62\xee\x13\x99\x08\xc0\x0e\x69\x14\
\x06\x25\xdb\x18\x1d\xfb\xb9\x56\x10\x74\x8e\x51\xc8\x77\xdd\x3d\
\x41\xa9\xb8\x86\xef\xdf\x89\x8d\x9f\x1d\xb4\x26\x4f\xdb\xbb\x93\
\x72\xe9\xe2\x14\x77\x9e\x80\xf1\x23\x4e\x8c\x12\x00\x35\x01\x91\
\x2f\x5f\xf1\x78\xed\xb5\x06\x9f\xf9\xb7\xef\x8e\x1f\x15\xdb\xb5\
\x05\x29\xb4\x5a\x77\x62\x12\x91\x50\x29\x35\xa5\xd2\x5a\xa2\x2d\
\x82\xb6\x7f\x34\x55\x9f\xa3\x7c\x94\x30\x1c\x44\x16\x7f\x76\x02\
\x30\xd0\xff\x7c\x7e\x9b\xb6\xd7\xcf\x96\x09\x3a\xcb\x14\xf3\xd7\
\x11\x22\x72\x9b\x84\xd0\x14\x0b\x6b\xb4\x5a\x27\x7b\x65\x3c\xef\
\x2e\x0a\xf9\x2a\xae\x33\xee\x53\xb4\x59\x8c\x84\xe1\xf3\xa8\x98\
\x80\xc8\xdf\xfc\xe3\x6b\xfc\xec\xcf\xdc\xcd\xc9\xdb\xca\x23\xdb\
\x32\xec\x68\x10\xce\xd2\xf2\xee\x4c\x1d\x2b\x16\xaf\xe2\x48\x03\
\xb1\xe6\xb1\x56\x11\x74\x8e\xa4\x84\x33\x9f\xaf\x20\xc5\xc1\x7c\
\xdd\x27\x13\x01\x10\x43\x46\x4d\x21\xb7\x4d\xc7\x3f\xd6\x77\x75\
\xac\xa2\xe3\xaf\x50\x2c\x5c\xeb\x95\x29\x17\xae\xd0\x6e\x1f\x4f\
\xb8\x43\x82\x5a\xfd\x01\x96\x16\x9e\x1d\xb2\x40\x34\x39\xa1\x77\
\x2f\x14\xed\x48\x21\x87\xb6\x7b\x1c\xa1\x37\x37\x3b\x9c\xbc\xbd\
\xc4\x8f\x7f\x70\x65\xaa\xf6\x18\xeb\x50\xad\xdf\x0f\x09\xd6\x4a\
\x19\x32\x5b\x58\xef\x4d\x3b\x00\x9e\xbf\x0c\x56\xa5\xca\x94\x72\
\x55\x0e\xea\xf3\x4e\xd9\x4e\x01\x03\x84\x2e\xe4\xb6\xf0\xda\x7d\
\x77\xaf\x13\x2c\x53\x2e\x6c\x41\xfc\xf0\xa3\x54\x9a\x85\x99\xd7\
\xd8\xae\x3d\xd0\x2b\x63\x74\x01\xbf\x7d\x82\x72\xef\x19\xba\x7d\
\x30\x7e\x97\x2b\xa2\x29\x00\x22\x43\x45\xa4\x8e\xef\x56\x47\xab\
\x65\xf8\xe4\x27\x4e\x0e\x1c\x1d\x8f\xa6\x77\x1c\x9d\x7a\x5c\x0e\
\x16\x67\xde\xc0\x91\x9a\x2e\x73\x05\x12\x7f\x60\xf4\x17\xf3\xdb\
\xf1\xdc\x9f\xfd\xfc\x0f\x59\x09\x40\x6a\xd4\x24\x1a\x5f\xa8\xe0\
\x77\x56\x7a\xf3\x3c\xc6\xc1\x8f\xa7\x82\x5e\x99\x7c\x85\x4e\xf1\
\x2a\x4d\xef\x78\xbc\xbf\xc9\x6c\xe9\x2a\x8c\xf8\x2e\xf5\x74\x64\
\x18\x21\x3c\x82\xe8\x83\xbb\x43\xa6\x81\x71\x1a\x20\x99\x05\x3c\
\x4d\x5b\xe6\xcb\x57\x09\x75\x19\xaf\x1d\xf9\xff\x33\xa5\x75\x4a\
\x85\x0a\x49\x8d\xd0\xf2\x97\xc0\xf4\x47\xbf\x90\x86\x72\xa1\x32\
\x60\xab\x64\x2b\x08\x19\x6a\x80\xe1\x0d\x2b\xe5\x2b\xb4\xbc\x7e\
\xe6\xab\xe7\x1f\x25\xef\xb6\x70\x54\xbb\x77\x6c\x61\xf6\x12\x41\
\x67\x1e\x37\xd7\x64\x71\xe6\x0d\x06\xbf\xe2\xb1\xdf\xd1\x3e\xec\
\xa8\x44\xb0\xd3\x08\xb4\x3d\xbd\xb0\xd7\x3b\xef\x76\xd7\xe5\xd9\
\x37\xd9\x12\x96\x4e\xa7\xcc\xc2\xcc\xe5\x9e\xbd\x21\x80\x40\xe7\
\x69\xb5\x57\x52\x7d\x2f\x15\x2a\x48\x11\xb5\xf6\x6d\xa4\x01\x06\
\xd2\xa4\x72\xdb\x78\xfe\x12\x98\xb8\x8c\x11\x34\x5a\xb7\xb3\x38\
\xf3\x66\xea\x39\xf8\x95\xc5\x97\x51\x32\x60\x94\x71\x36\x09\xac\
\x05\xad\x2d\x17\xdf\x6a\xd1\x6a\x05\x14\x8b\x8a\x62\xc9\xa1\x54\
\x74\x28\xe4\x15\xf9\x5c\x3c\xba\x44\x5a\xed\x27\x5b\x2e\xc4\x70\
\xcd\x33\xaa\x7f\x53\x95\x12\xb0\x3c\x77\x11\x6d\x5c\x94\xe8\x1b\
\x9c\xd6\x46\x34\xc1\x26\xc4\x4f\x18\xca\xb9\x6a\xca\x3e\x38\x08\
\x64\x63\x04\x0e\x99\x37\xfb\x6a\xcc\x32\x57\xda\xa0\xd6\xec\xbf\
\x72\x5d\xeb\x3c\x0d\xef\x18\x73\xe5\xbe\x41\xe8\xa8\xfe\x5c\x38\
\xac\x9e\x61\xb0\x16\xd6\xd6\x3d\x5e\x7e\x79\x9b\x97\x5f\xaf\xf1\
\xc6\x9b\x2d\xae\xac\x35\x08\x74\x14\x4e\xc2\xd8\xf8\xd5\x6e\xd1\
\xe3\x5b\x4a\x49\xfe\xda\xea\x02\x1f\x7d\xe4\x36\x8e\xae\x14\x86\
\x46\x82\x76\xb3\x01\xf6\xcc\xf8\x01\x28\x99\xee\x6b\xb5\x75\x14\
\xad\xf3\xa9\x2b\xe7\x4b\xd7\x71\x24\x30\x62\x4a\xca\x4a\x1f\x64\
\xaa\x01\x46\x35\xaa\x94\xab\x13\x04\x33\xb4\x3b\xfd\xf0\xa6\xdf\
\x59\x24\x70\xdb\xe4\x73\x8d\x1d\xe5\xc7\x75\x2e\x08\x0c\x7f\xf2\
\x9d\x2b\x7c\xed\x1b\x17\xd8\xda\xf6\x13\x8b\x11\x22\x4e\x34\x24\
\xfd\x7f\x1c\x63\xd1\xda\xf2\x83\xe7\xb6\xf8\xc1\x73\x5b\xcc\x96\
\x73\x2c\x2d\xe6\xa3\x93\x56\xf4\xb4\xc2\x30\x1b\x20\xdb\x89\x20\
\x8d\x76\x67\x06\x6f\xe0\x59\xc9\x62\xae\x41\x39\xdf\xc8\xe8\xce\
\xbb\x23\x13\x01\x50\x13\xb8\x28\x0b\xe5\xeb\x6c\x84\xa5\xd4\x0a\
\x98\xb1\xb9\x14\xc1\xc7\x75\xb7\xdd\x0e\xf9\xd6\xb7\x2f\xf1\xb5\
\x6f\x5c\xa4\x5a\xeb\x90\xb6\xe0\xe3\xa9\xc3\x0e\x1e\x23\x95\xba\
\xdd\x65\x76\xbd\x11\x50\x6f\x74\x76\x94\x95\x43\x5a\xb1\x5f\x8b\
\x64\x38\xa2\x7a\xb4\xc9\xa7\x6c\x11\xa5\x42\x16\xcb\x9b\x69\xad\
\x2a\x86\xfe\x9b\x09\x32\xd2\x00\x83\xcd\x1a\xba\x14\xc7\xd2\xcc\
\x3a\x9b\xf5\xdb\xb1\x16\xe6\x4a\x9b\xcc\x14\xaa\xa9\xb2\xa3\x08\
\x1d\x74\x34\x4f\x7c\xf3\x22\x4f\x7c\xeb\x4d\xea\x8d\x00\x8c\x20\
\xb6\x8e\x06\xca\x1a\x7a\x79\xd4\x96\x68\x54\x8b\x51\xed\x31\xd1\
\xf1\xf8\x6d\xe0\x7d\x95\x2c\x7a\xf1\x81\x2c\x18\x3f\xae\x8e\xb9\
\x62\x0d\x89\xa0\xea\x45\xdf\x29\x3c\x32\xb3\x81\x92\x30\x38\x1d\
\x1e\x8c\x10\x66\x6a\x03\x8c\x6f\x54\xde\xe9\x30\x57\xdc\x46\x60\
\x28\x17\x6b\xc0\xb0\xa9\x23\xbd\xe7\x79\x21\xff\xfe\xf3\x7f\xc9\
\xf3\x2f\x6e\xd1\x53\xeb\xd2\x0e\xcc\xdf\x36\x7d\x69\xca\xc6\x4b\
\x6a\x06\x9b\x3e\x1f\x27\x66\x44\xc7\x22\x61\x11\x46\xa0\x94\x24\
\x5d\xe1\xf4\x98\xe6\xca\xb9\x62\x2d\x7e\x0b\xad\xa4\xe0\x04\x24\
\x99\x3f\x24\x86\x95\x29\x32\xd2\x00\x93\x5b\xaa\x73\xc5\x6e\x98\
\x77\x50\xd9\xee\xec\x5d\xa5\xd6\xe1\x97\x7e\xf5\x29\xde\x78\xab\
\xb2\xc3\x35\xec\x5d\xd3\x7d\xeb\x56\x77\x2d\xba\x5b\xae\x27\x0c\
\xa2\xc7\xdc\xde\x4b\x80\xbb\x8f\xfd\xf6\x34\x40\x5c\xde\x0a\xac\
\x91\x08\x25\x87\xdf\x6e\x4a\x4c\xb3\xa8\x35\x57\xec\xda\x42\x83\
\x54\x39\x58\x3b\x20\xa3\x38\xc0\x08\xe6\x8c\x3b\x3a\xa2\x6f\xd6\
\x5a\x36\x36\xdb\xfc\xbb\xff\xf8\x5d\xae\x6e\x78\x7d\x75\x6f\x6d\
\x7f\xc4\xee\xa8\x28\x61\xf1\x25\x66\x84\x48\x63\xf4\x6a\x26\xc5\
\x74\x76\xda\x06\x58\x90\x56\x0c\x0d\x13\x4f\x82\xec\x18\x76\xf0\
\x06\x20\x1c\x50\x1c\x60\x1c\xc6\x11\x69\xbb\xea\xf3\x0b\xbf\xf4\
\x24\xdb\xf5\x4e\xe4\x06\x25\x13\xe3\xba\x73\x3b\x89\xef\xfe\x76\
\x99\xd9\x95\x01\x41\x9f\xf9\x29\x1b\xc0\xf6\x0b\x08\xd2\x02\x45\
\x64\x0b\x18\x2d\x10\xee\xc0\x4a\xe1\x04\xbc\xc8\x8a\xf1\x07\x3d\
\xe2\x07\x71\x30\xcb\xc1\x23\x31\xa6\x73\x22\x7a\x32\xe7\x0b\x5f\
\x7e\x8e\xed\x9a\xbf\xf3\x92\xa4\x7a\x1f\x64\xfe\x40\x4c\x7f\xf0\
\xab\xe0\x3d\x21\x12\x89\xff\x49\xd4\x67\xc0\xc9\x49\x94\x94\x48\
\x39\x7c\xa1\x68\x0f\x3d\x9a\xb0\x8e\x1b\xcb\xf4\x24\x32\x5a\x0d\
\xdc\x2d\x78\x32\x79\xe7\xac\xb5\xbc\xf2\xea\x36\x4f\x7e\x7f\x8d\
\x68\x94\x26\x46\x67\x77\xd4\xa7\xb2\x87\x6d\xbf\x8c\x95\x80\xe9\
\xcd\xe5\xe9\xdb\x26\xac\xbe\xae\x3d\x90\x50\xf9\xdd\xd3\xa7\x6f\
\x9f\xa3\xe0\x3a\xc3\xc3\xc4\x23\xe6\xae\xfd\xb1\x6e\xff\xf5\xc8\
\xf8\x5d\xd2\x4a\x61\xcd\x1e\x1e\xb0\x3a\x30\x1b\x60\x2f\x52\x1d\
\x6a\xc3\x37\xfe\xf4\x02\xb6\xcb\xc8\x2e\x6c\xe2\x9f\x2e\xf3\x7a\
\xc7\x13\x42\xd0\xd5\xf9\x3b\x98\xdf\x3d\x1d\x1b\x8a\x36\x0e\x41\
\x5b\xdb\x9f\x62\x04\x3c\xf4\xbe\x13\x38\x4a\x21\xe5\xa8\xb6\xdf\
\x42\x8c\x17\xdd\x30\x72\x24\x00\xc6\x62\xb5\xc1\xce\xcc\x63\xb9\
\xb6\xfb\xb5\x49\x1c\xe8\x6a\xe0\xb4\x9d\xb3\xd6\xf2\xcc\x0b\xd7\
\xfa\xbe\xbc\x48\x58\xf0\x10\x8f\xd8\x84\x5b\xd7\x53\x10\x5d\x21\
\x48\xbb\x74\x7d\xaf\xa0\xbb\x6f\xfb\x42\xd0\x3d\x6f\x22\xed\x52\
\x2a\xba\xfc\x9d\x47\xde\x85\x12\xc3\x32\x85\x86\xf4\x64\x6a\xce\
\x65\x25\x3c\x11\xf2\x6e\x94\x75\x6d\x2c\x86\x10\x63\x05\x46\xb9\
\x98\xad\x4d\x38\x7e\xd7\xd0\x74\xc7\xa1\xc8\x48\x03\x24\xd2\x97\
\xf7\x58\x87\xb5\xd1\x02\x70\xcb\xeb\xea\x31\x99\xf6\xd7\x7b\xbe\
\x3c\xd1\x27\xbc\x64\xc2\x90\xeb\xda\x20\xbd\x6e\x8b\xfe\xff\x5d\
\x46\x5b\x12\x36\x03\x7d\x21\x8b\x0b\xfd\xe3\x9f\x7c\x0f\xc7\x8f\
\xcd\x0c\x9d\xfb\x6f\xd6\x68\x8f\xe4\x75\xf8\x55\xae\x2a\xf0\xea\
\x35\x5e\x14\x10\xe0\x10\x38\x92\xd0\xd7\x98\xdc\x2c\x66\xdb\xc3\
\x9e\x9d\xf0\x1e\x99\xd9\x00\xd9\x18\x43\x3a\x31\xaa\x4d\xdf\xfd\
\xeb\x31\x3a\x31\x7a\xbb\xaf\xe7\xeb\x6a\x9f\x9e\x91\x97\xf4\x0a\
\x12\x5a\xa1\x9b\x53\x37\xc4\x05\x7c\xe8\xbd\xc7\xf8\xe9\x4f\xbe\
\x1b\xb5\xab\x2d\x33\xc9\x89\xdd\xa9\x30\xea\x6c\xfa\x19\x48\xd1\
\x3b\x26\xe2\x66\xf6\x22\x93\x42\x60\xad\xc0\x0b\x17\x68\x36\x17\
\xbc\xb7\xaa\xfc\x86\x30\xb4\x71\x68\x63\xe9\xe4\x3d\x42\xd7\x60\
\x56\xea\xd8\x4f\x83\x7d\x3c\x29\xe3\x23\x90\xd1\x5a\xc0\xa4\xec\
\x1f\x5d\xce\x62\x71\x1c\x97\xf7\x9c\x5e\xe6\xa9\xe7\xd6\x22\xe6\
\x19\xe8\x87\x73\x25\xdd\x4c\xa2\xb4\x6b\x47\x2a\x90\x83\xed\xae\
\x00\x0e\x4e\x07\x71\xc1\xa4\x96\x00\xfe\xe6\x83\xb7\x71\xf6\x5f\
\x3c\x8a\xeb\x4c\xee\xca\x8a\x5d\xf6\x76\xf4\xab\xcb\xc8\x5d\xcf\
\xf7\x35\x93\x65\x50\x20\xba\xb3\x96\xa0\xad\xe7\x68\x04\x4b\x08\
\xa1\xb4\x45\xfc\xb2\xb5\x5c\x33\xd0\x14\xd0\xb2\x06\xbf\x3d\x4b\
\x50\xdd\xc4\x78\x8f\xc5\xbd\x9d\xe0\x29\x97\x1b\x14\x07\x98\xc8\
\x91\x46\x60\xf9\xc8\x43\x77\xf0\xd4\xf3\x6b\xa4\x47\x70\x6c\xb1\
\x9b\xf8\x7f\x09\x29\x1d\xdf\xb5\x0d\x62\x77\x2e\xa5\xde\x53\x2a\
\x9f\x58\x40\xa2\xbf\x3f\xf1\xc8\xdd\xfc\xcb\x7f\xfa\x21\x0a\xb9\
\x4c\xc8\xd0\x6b\x4e\x8f\x81\x49\xe6\x0f\xbe\xf9\x83\x6e\xb9\xf8\
\x25\xd1\xc6\xf4\xde\x01\x88\xb5\x3d\x73\x45\x08\x41\x47\xcc\xd3\
\x34\x2b\x84\x26\x87\x14\x58\x6d\xf8\x35\xe0\x82\x90\xd4\x95\xa0\
\x0e\x34\x85\xc2\x73\x15\xc1\xfd\xb3\xe8\x3f\x1a\x98\xe0\x76\xc3\
\x01\xc7\x01\xa6\x9b\x18\xa4\x84\x9f\xfc\x5b\xf7\xf1\x7f\xbe\xfd\
\x1a\x2f\xbc\xb1\x19\x8f\xec\x38\x63\xb6\xc7\xef\xee\x70\x1f\x52\
\x77\x6f\x9e\xef\x6a\x8d\x21\xb1\x82\x38\x81\xf9\x23\x3f\x76\x07\
\xff\xf0\x13\xab\x74\x02\x4d\xb1\xe0\x20\xe5\xa4\x7e\xcb\xf8\x11\
\x1f\x73\x37\x7e\x0b\x49\x97\xa1\xb6\x77\xbe\xc7\x7c\x6b\x31\xa6\
\xfb\x40\x8d\xc1\x18\x83\x35\x36\xfe\xa6\x11\x58\x67\x9e\x8e\x3a\
\x81\x16\xe5\x5e\xfd\xc6\xd8\xdf\x91\x52\xfc\x50\x6b\xea\xd6\x52\
\x73\x25\x35\x65\x69\xfa\x01\xfe\x4c\x89\xe0\xf5\x55\xcc\x19\xb0\
\x67\x26\xe3\xff\x41\x64\x05\x8f\x27\xe3\xa8\x12\xda\x58\x2e\xad\
\xd7\xf8\xd8\x87\x4e\x71\xf1\x6a\x95\x66\x2b\xce\x10\x4a\xc6\xed\
\x7b\xc6\x60\xcf\x58\x48\x1b\x7c\xf1\xa1\xf4\x82\x8f\x01\x19\x59\
\xf7\x8b\x73\x05\xee\x3d\x75\x84\xf9\xb9\x32\x4f\x7c\xfb\x55\x20\
\x12\xbc\x85\x99\x22\x77\x9c\x98\xe5\xfe\x53\x4b\x9c\x3a\xb1\x30\
\xe0\x0a\x4e\x26\x1a\x49\xe6\x1b\x6d\xd0\x46\x63\x74\xcc\x58\x6b\
\x52\x02\x61\xac\xc5\x18\x83\xd1\x3a\x7a\x93\xa9\x36\x58\x63\x30\
\xc2\x85\xc2\x71\x6c\xfe\x38\xc8\x74\x12\xa9\xb0\xe6\x6b\x28\x79\
\xce\x6a\xea\x40\xd5\x85\xaa\xaf\x69\x98\x02\x9e\xdb\xa0\x53\xbc\
\x84\xfe\xde\x97\xb1\x62\x52\xee\x73\x03\x72\x02\x47\x21\x59\xfa\
\xf2\x7a\x9d\x67\x5e\x5a\xe7\xd5\x8b\x5b\xf8\x9d\xe8\xb9\x81\x8f\
\x7c\xe0\x14\x4f\x3d\x77\x99\xcd\xaa\x47\xdf\x8d\x83\x1e\x67\x93\
\x6e\x20\xf1\xf1\x54\x30\xb0\x3f\xf2\x85\x14\x2c\x2d\x14\x79\xe0\
\xd4\x32\x4b\xf3\x85\xc4\x6a\x5f\x7c\xa5\x81\xed\x9a\xc7\x76\xcd\
\xe3\xaf\x5e\xba\x46\x21\xef\x70\xef\x5d\x47\x78\xff\x03\xc7\xb9\
\x6d\x25\xfd\x84\xee\x28\x74\xe7\x7a\x6b\x2d\x3a\x0c\x09\x3a\x01\
\x61\x10\x10\x86\x01\x5a\x6b\x74\xef\xf3\xf3\xfd\x91\x1e\x09\x88\
\xc6\x58\x8b\xc8\xaf\xe0\xcc\xde\x81\x2a\x2c\x27\xe2\x1a\xc9\x36\
\x9a\xbf\x50\x4a\xfe\xa1\xb6\xd4\x05\x54\xad\xa5\x6a\x1d\xea\xf9\
\x80\x96\xdb\xc1\xbf\x92\x23\x3c\xff\x30\xe6\xcc\x63\x93\x8f\x7e\
\xb8\x09\xab\x81\x83\xf8\x7f\x3f\xbc\xcc\xb7\x9f\xba\xb0\xc3\xf0\
\x29\x14\x1c\x3e\xfc\xfe\x3b\xa9\xd6\x7d\x5e\xbb\xb4\xc5\xd5\xcd\
\x06\xa1\x36\xbd\x11\x96\xf6\xf9\x13\x42\x61\x00\x21\x10\x58\xf2\
\x39\x87\x85\xd9\x02\xf7\x9d\x3a\xc2\xd2\x42\x91\x41\x21\x1d\x25\
\xb2\xbe\xaf\x79\xee\xe5\x6b\x3c\xff\xea\x06\x9f\x78\xf8\x5d\xbc\
\xff\x81\xe3\x23\x4a\x26\x95\x8e\xc5\x58\x0d\xda\xa2\x3b\x9a\x4e\
\xbb\x43\xbb\xed\xd1\xf1\xdb\x04\x41\x80\x31\x91\x10\xd0\x7d\x77\
\xb1\xb1\xc8\xc2\x22\x6e\xf9\x24\xf9\x85\xbb\x90\x4e\x61\xe4\x3d\
\xac\xd1\x2f\x08\xa1\x7e\xdb\x0a\xea\x58\xaa\x02\xaa\xb2\x40\x2d\
\x17\xd0\xcc\x15\x68\x57\x1d\xc2\x4f\xaf\xa2\xe9\xeb\xbe\x89\x91\
\x51\x3e\xc0\xde\xdc\x1f\x10\x3c\xfd\xfc\x5a\x3c\xc0\x77\x96\x52\
\x2a\x1a\xb9\x4b\x0b\xb7\x11\x84\x86\x37\x2f\x57\x58\xdf\x6c\x10\
\x84\x86\x50\x5b\xb4\x36\x84\x46\x63\xb4\x45\x4a\x49\xb9\xe8\x32\
\x57\x2e\xb2\x30\x97\x63\x7e\xae\x40\xde\x55\x14\xf2\x2e\xae\xb3\
\xc7\x38\x85\x85\xa7\x9e\xbb\xc2\x83\xef\xbe\x6d\x4c\x39\x1b\xd7\
\x2d\x30\xc6\xa2\x83\x10\xbf\xed\xe1\x35\x9a\xb4\xfd\x0e\xa1\x15\
\x58\x91\x43\xa8\x1c\x4e\x71\x81\xfc\xec\x51\x72\x33\x2b\x13\x25\
\xa0\x5a\x63\x2e\x4a\x47\xfd\xba\x84\x0a\x9a\x2a\x92\x6a\x28\xa8\
\xe5\xa0\xe9\x15\x69\x7b\x10\xf0\x3c\x9a\xd5\xe9\x99\x0f\x07\xec\
\x05\x0c\x27\x76\xfa\xe8\xc7\x3e\x78\x9a\xaf\x3f\xf9\x6a\x34\xba\
\x47\x42\x90\x73\x25\xf7\x9d\x5a\xe6\xf4\xc9\x45\x42\x1d\x8d\x20\
\x00\x25\x05\x8e\x12\x48\x21\x30\x71\x0c\xbf\xff\xbc\xde\x24\x18\
\x5d\x36\xe7\x4a\x3e\xfe\xd0\xdd\x23\x8d\xdc\xe4\xe8\xef\x3e\x92\
\x8e\x36\x84\x41\x48\xd0\xf6\xf1\xdb\x1d\x66\xef\xfb\xbb\x53\xb4\
\x25\x0d\x6b\xcc\x35\x29\xe4\x67\x8d\x65\x53\x49\xaa\x46\x51\xc1\
\x52\x35\x79\x1a\xca\xc5\xbb\xa4\x08\x8e\xdf\x83\xfe\xd4\x6a\xef\
\x03\xaa\x53\xe3\x40\xbd\x80\x49\x14\xee\x7b\xef\x39\xc1\x1d\x47\
\x17\xf9\xe1\xab\xeb\xbc\xf0\xc6\x06\x1b\x95\xd6\xae\xf5\xe4\x1c\
\x87\x51\x5e\x5b\x56\x09\xd4\x2b\x8b\x65\xde\x7d\x6a\x85\xf7\xdd\
\x77\x9c\xf9\x99\x01\x43\x6c\xe8\x9e\x8d\x0c\x09\x2b\xa2\x59\x28\
\x16\x82\xd0\x4c\xb7\x4c\x9e\x84\xb5\xb6\x26\x95\xfc\xac\x85\xab\
\x40\x35\x0c\xa9\x1a\x43\x4d\x0a\x1a\x0b\x4d\xbc\x75\x8f\x60\x0b\
\xf4\xd6\x97\xb1\xe2\xf1\x1d\x5e\xe6\xc4\x38\xc0\x84\x90\x2e\xc6\
\x8f\xc6\xa5\xb9\x22\x8f\x7e\xe0\x14\x8f\x7e\xe0\x14\xd7\x2b\x4d\
\x5e\x78\xe3\x3a\x6f\xad\x57\xb9\x5e\xf1\xa8\xb7\xfc\x7d\xbd\x19\
\x6b\xec\xdd\x85\x60\xae\x94\xe7\xc8\x42\x91\xbb\x8e\x2f\xb0\x7a\
\xfa\x28\x47\xe6\x8b\x3b\x8b\xed\xb2\xd7\x7d\x2f\x81\xb0\x26\x4a\
\x4b\xd4\x16\x13\x1a\x90\x39\xf6\x04\x6b\x3d\x29\xc4\xe7\x10\x5c\
\xc0\x52\x55\x96\x8a\x81\xaa\xab\xa8\x6b\xf0\xd6\x9b\x74\x4e\x41\
\x78\xe1\x1c\xe6\xf1\x33\x58\x7b\x66\x6f\xa3\x1f\x32\xcc\x09\x9c\
\x26\x3a\xb6\x1b\x8e\x2d\xcc\x72\xec\xfd\xdd\xf4\x71\x41\x27\xd0\
\x6c\xd5\x3c\xae\x57\x5b\x6c\x56\x5a\x6c\xd5\x3d\xfc\x4e\x48\x27\
\x08\xe9\x04\x86\x40\x6b\x82\x40\x13\x84\x86\x4e\xa8\x09\xb5\xc6\
\x75\x1c\x5c\x25\xc9\xb9\x0a\xd7\x51\xe4\x1c\x89\xeb\x3a\xb8\xae\
\xa2\x98\x73\x58\x9c\x2d\xb0\xbc\x58\x66\x79\xbe\xc4\xd2\x5c\x31\
\x65\x23\xec\x19\x22\xb6\x62\xba\x96\xbe\x35\x08\x95\x1f\x77\xd5\
\x30\x84\x42\x8a\xdf\xb0\x96\x97\xa5\xa6\x66\x15\x55\x2c\xd5\xbc\
\xa2\xbe\x55\xc5\x2b\xe7\x23\xe6\x9f\x7b\x0c\xf3\xf8\x63\x74\x1d\
\xcf\x3d\x23\x9b\x50\xf0\x3e\xbc\x80\x71\xc8\xe7\x1c\x4e\x2c\xcf\
\x72\x62\x79\x76\x7c\xe1\x9b\x88\xc8\x0b\x88\x6c\x93\xc8\xcd\x33\
\xa8\xf2\xfc\xf8\x0b\xd3\x30\x12\xfe\x87\x85\x67\x81\xaa\x75\xa8\
\xe0\x53\x35\x05\xea\xc6\xd2\x2a\xe7\xf1\x57\x1e\x26\x38\xc7\x74\
\xc1\x9e\xdd\x90\x61\x0c\xf4\x10\xbd\xcf\xd3\xc4\x7e\xbf\x3b\x7b\
\x74\xfc\x45\x09\x08\xf8\x3d\x04\x7f\x06\x91\xda\xb7\x01\x55\x59\
\xa4\xd6\x16\xb4\x58\xc4\xdf\x5e\x27\x3c\x1f\x33\x9f\x0c\x98\x0f\
\x87\x02\x90\x09\xfa\x1f\xc4\x8c\x99\x6f\xa2\xe0\x4e\x6e\x76\x79\
\xfc\xc5\x31\x04\x3c\x61\x2d\x7f\x6c\x2d\x35\x2d\x23\x5f\xbf\x50\
\xa4\xd6\xa9\xd3\x9a\xcb\xe1\x5f\x59\x27\xfc\xf4\x83\x7b\xf3\xf5\
\x77\xc3\xc1\xbc\x75\xe0\x1d\x84\x6e\x00\xab\xab\xf6\xb5\xd6\xe8\
\x50\x23\xf2\xf3\x13\xf9\xf9\x31\xbe\x83\xe5\x2b\x02\x6a\x4a\x51\
\x51\x96\x8a\xee\x50\x37\x2d\x5a\xed\x3a\xfe\x15\x08\x0e\x82\xf9\
\x70\x28\x00\xd9\x20\x5e\xf8\xd1\x46\xa3\x75\x48\xa8\x43\xdc\xd9\
\xd1\xd1\xc3\x14\x04\x4f\xa3\xf8\xa2\x11\xd4\xac\xa5\x62\x2d\x15\
\x25\xa9\x89\x3c\xcd\x46\x81\x76\xa1\x4a\xb0\xf8\x7a\xcf\xcf\xcf\
\x94\xf9\x70\x28\x00\x99\xc0\x12\x2d\xe7\x1a\x1d\x6b\x00\xa3\xc9\
\x2d\xde\x35\xc9\xa5\xdf\x41\xf2\xeb\x56\x53\x95\x96\x8a\xe3\x44\
\xcc\xf7\x0d\x4d\xa7\x4e\xbb\xe0\x10\x00\xfa\x53\x9f\xda\x7b\xa0\
\x67\x1c\x0e\x6d\x80\x7d\xa2\x3b\xff\x6b\xa3\x09\x75\x48\x18\x04\
\x88\xc2\x0a\xd2\x1d\x1d\xdb\x8f\xf1\x84\xb0\x7c\x05\xa8\x22\xa9\
\x28\xa8\x84\x01\x35\x7c\x9a\xce\x11\xda\x14\xe9\xf0\xfc\xc1\x32\
\x1f\x0e\x05\x60\x5f\x48\xad\xf1\xc7\x06\x60\xa8\x43\xd4\xfc\x1d\
\xbb\x5d\x66\x84\xe0\x7f\x5a\xc3\x37\xad\x8a\xac\xfd\x00\xaa\x61\
\x40\x0d\x97\x06\x33\x78\x70\x63\x98\x0f\x87\x02\xb0\x7f\xc4\x49\
\x1d\xa1\x0e\xd1\x3a\xc4\xe0\xe2\x94\x87\xbf\x41\x0c\x08\x05\x7c\
\x01\xf8\x33\x6b\xa9\x49\x4b\xc5\x42\xd5\xca\x68\xe4\xdf\x68\xe6\
\xc3\xa1\x00\xec\x1b\x16\x8b\x89\x13\x3f\xb4\x36\x30\x73\x62\xe8\
\x7a\x3e\xd6\x7a\x48\xf1\x5f\xac\xe5\x59\x2c\x55\xc7\xa5\x22\x42\
\xaa\x56\x51\xb7\x9a\x26\x9a\x36\x09\xe6\x77\x13\x9b\x0e\x1a\x87\
\x46\xe0\x3e\x90\xf2\xff\xe3\xac\x1f\x51\x3e\x31\xac\x5c\x55\x48\
\xf1\x1f\x84\xe0\x2f\x85\x64\x5b\x18\xb6\xfd\x80\x8a\x2c\x50\x15\
\x01\x8d\x23\x2e\x1e\x47\xd3\x23\x7f\x92\x84\xce\x2c\x70\xa8\x01\
\xf6\x88\x41\xff\xdf\x58\x83\x71\xe7\x61\x20\xb1\xc3\x1a\x73\x4d\
\x29\xf9\x9f\x80\x0b\x26\xa4\x66\x14\x15\x14\xd5\x7c\x40\xbd\x53\
\x8f\xfc\xfc\xf0\x64\xb4\xa6\x7f\xa3\xd4\x7e\x12\x87\x02\xb0\x1f\
\x24\x74\xb4\x10\x82\xa0\x98\x4e\x1c\xb1\x46\x5f\x00\xf5\x6b\xd6\
\x46\x4b\xba\x08\x2a\xc6\x52\x73\x3a\xd4\xdb\x9a\xd6\x5c\x11\x7f\
\xfb\x08\x41\xe1\x79\xcc\xcd\x60\x3e\x1c\x0a\x40\x36\x10\x82\xd0\
\x99\x43\xab\x7e\xfe\xa0\xd1\xfa\x05\x95\x53\xff\xd9\x58\x36\xa5\
\xa6\x6a\x15\x15\x1d\x50\x13\x01\x0d\xb7\x4c\x0b\x0f\xff\x0a\x71\
\x78\xf7\xc1\x83\x09\xf2\x4c\x82\x43\x01\xd8\x27\x84\x10\x08\x29\
\x69\xa8\xbe\xe5\x6f\x74\xf8\x17\x52\x3a\x5f\xb0\x86\x6d\x01\x55\
\x2d\xa3\x25\x5d\x29\x68\x50\xc0\x0b\x3c\x3a\x2b\x0f\x13\x9c\xe7\
\xe0\x22\x7c\x93\xe2\x50\x00\xf6\x03\x11\xbd\x49\xc4\x13\x73\x84\
\xf1\xc7\x32\x8d\x0e\xbe\x26\xa5\xfb\x15\x01\x35\x24\x55\x11\x46\
\x39\x7c\xc5\x90\x46\x1d\xbc\x20\x4e\xe6\x38\x97\xf1\xaa\xde\x5e\
\x71\xe8\x05\xec\x03\xd1\xf3\x10\x8a\xed\x70\x06\x21\xac\x35\x3a\
\xf8\x82\x72\xdc\x3f\xb0\x92\x8a\xb1\x6c\x6b\xcb\xb6\xc9\x51\xc9\
\xf9\xd4\x59\xa0\x15\x78\x74\x2e\x40\x78\xee\x1c\xe6\xf1\x5b\x80\
\xf9\xb0\x07\x0d\x90\xcb\x63\xbd\x76\xe4\xa6\x48\x99\xf9\xb7\x8c\
\xdf\x36\x88\x1e\xd4\xb4\x54\x75\x09\x84\xd4\x26\x34\xbf\xaa\x5c\
\xf7\x07\x42\x53\x03\xaa\x42\x52\x73\xa0\xa6\xab\xb4\xc2\x23\x78\
\x05\x45\x70\x01\x34\xdd\x34\xae\x5b\x80\xf9\x30\xa5\x00\xcc\x84\
\xd8\x8e\x94\x93\xea\x82\x00\x00\x02\x31\x49\x44\x41\x54\xc1\x4a\
\x85\x01\xb4\xb5\x68\x80\xb9\x99\x1c\xf5\x66\x67\xcc\xd5\x3f\x42\
\x10\x71\x0a\x38\x92\xa6\xc9\xfb\xda\xda\x5f\x94\x52\xbd\x61\x2c\
\x35\x47\x52\x15\x82\x9a\x0e\xa9\x3b\x9a\x16\x1a\x1f\xe8\x34\xee\
\x41\x9f\xb9\x07\x23\x3e\x0a\xfb\xc9\xe1\xcb\x1a\x13\x0b\xc0\xf1\
\x06\x36\xb8\x1b\xab\xda\x98\x50\xa3\x0d\x04\xc6\xd2\x01\xb8\xf3\
\xc4\x64\x4f\xcf\xfc\xa8\xe1\x95\x6b\xbc\xe0\x55\xf8\xbc\x15\xac\
\x5b\x4b\xdd\x2a\xaa\x3a\x8c\x62\xfa\x2a\xc4\x73\x73\xb4\xc3\xa3\
\x84\x3c\x1f\xa5\x6e\xc7\xd1\xbd\x5b\x86\xf9\x00\x62\xdc\xf7\x79\
\xe3\x27\xf2\xc4\x6f\x3d\x8d\x3a\xe5\x92\xab\xfa\xcc\x4a\xc9\x82\
\x91\x2c\x0a\x58\xc0\x30\xa3\x14\xb9\x40\xe3\x38\x02\x61\xf6\x93\
\x11\x7a\x8b\x43\x82\xd5\x80\x30\x18\x2b\x08\xa5\xc4\x47\xe0\x69\
\x4b\x43\x49\xea\x46\x53\x57\x96\xa6\x54\x78\x81\x87\xbf\x9d\x23\
\x5c\x7c\xfd\xe6\xf9\xf8\x93\x60\x52\x0d\x60\xd7\xea\xd8\xc5\x3c\
\x86\x79\x3a\xc2\xc7\xc3\xe0\x5a\x09\x8e\xc0\x37\x02\x17\x8b\xd2\
\x20\x0e\xf8\xed\xe6\x37\x15\x5a\x83\x54\x44\xc9\xdf\x06\x2d\xc0\
\xd7\x21\x6d\xe5\xd2\x54\x96\xa6\x74\x68\x15\x3c\xda\xc5\x23\x74\
\x5e\xd6\xe8\xb5\x07\xd1\x9f\xbe\x89\x3e\xfe\x24\x18\x2b\x00\xdd\
\x47\x2e\x57\x37\xb0\xbc\x07\x9d\xdf\x26\xf0\x4b\xb4\x00\x8b\xa6\
\xd3\x96\xe4\x73\x01\x4a\x48\xa4\x0b\xe8\xce\x8f\xae\x06\x30\x0e\
\xd6\x18\xe8\xda\x40\xc2\x12\xa8\x3c\xbe\x6e\xe0\x4b\x45\x3b\x9c\
\xc1\xe7\x08\x01\x6f\xa2\xd7\xce\x61\xce\xdc\xe2\xcc\x87\x29\x34\
\xc0\xf9\xf3\x58\x56\x30\x0f\x9d\xa4\xe3\x77\xb0\x54\xd1\xa1\xc4\
\x77\x5c\x9c\x40\x23\x95\x45\x04\x90\xdd\xe3\x39\xb7\x22\x62\x56\
\x06\x1d\xac\x0a\x31\xee\x2c\xa1\x6e\x11\x76\x24\xc1\xb6\x22\x5c\
\x84\xb0\x71\x4f\xf4\x88\xf6\xe3\x67\xb2\x49\xdb\x3e\x68\x8c\xb5\
\x01\x7a\x05\x41\x3c\x7e\x16\xc1\xa3\xc8\xd5\xa3\x48\xaa\xa8\xf9\
\x32\xb2\x9d\x47\xba\x15\x44\xc3\xf9\xd1\x1d\xf9\x83\xe8\x84\xd8\
\xd9\x10\x5b\x98\xc5\x54\x9b\x98\xab\x15\xcc\x5f\x2f\xa2\x1f\x7b\
\x2c\x7e\x3f\xc9\x2d\x68\xec\x8d\xc2\xc4\x5e\x80\x25\x7a\xf1\xc0\
\xe3\x67\x31\xac\x62\xcf\xaf\x60\x4e\xe4\x10\x0f\x06\xf0\xfa\xec\
\x3b\x87\xf9\x00\x39\xe0\x76\x0f\xfb\x74\x00\x6b\x3e\x76\xb5\x81\
\x3d\xf7\x3d\xec\x63\x8f\x0d\x7d\xc5\xcf\x2d\x8d\x89\x35\x40\xef\
\x02\x81\xe8\x5e\x72\xf6\x6c\xcc\xf8\x33\x59\x37\xeb\x6d\x80\xb3\
\x70\x26\xed\xcf\xbf\x8d\xd8\xde\xc7\xd4\x02\x30\xb4\x92\x9b\xf9\
\xb2\xdb\x9b\x84\xb7\x8b\x8a\x1f\x87\xff\x0f\x31\xbc\xe8\x8a\x21\
\x13\xad\xfa\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\xe4\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x61\x49\x44\
\x41\x54\x78\xda\xc5\x97\x6b\x6c\x14\xd7\x15\xc7\xff\xe7\xce\xcc\
\xee\xec\xae\x1f\xeb\xc7\x62\x30\x26\x3c\x64\x67\x21\x24\xd0\x00\
\x01\x85\x2a\x12\x52\x24\x54\xe5\x5b\xd5\x82\x22\xd4\x36\x54\x6a\
\x9b\xb6\x28\xad\x08\x7d\x24\x6a\x25\x44\xd5\xa4\x1f\x92\xd0\x2a\
\x69\x28\x8a\x92\x3e\x92\xb6\x48\x45\x4d\xdb\x7c\x48\xa5\x56\x51\
\x9b\x84\x84\x36\x3c\x02\xa6\x84\x87\x03\x36\x60\x9b\x35\xbb\x6b\
\xf6\x35\xbb\x3b\x33\xf7\xde\xd3\x1b\x77\x65\x61\x84\x8d\x1b\x3e\
\xe4\x27\xfd\x74\xe6\xcb\xcc\xf9\xdf\x73\xe6\xc3\x0c\x31\x33\x6e\
\x0d\x22\xe0\xe3\x3f\x64\xd6\x01\xf6\xef\xdf\x6c\xf5\xa5\x06\xee\
\x8b\xda\x2d\x9b\x1c\x77\xfe\x7a\xd7\xed\xe9\x8e\xc4\x17\x74\xd8\
\x76\x1b\x05\xfe\x95\x62\xe8\x5d\xca\x48\xef\xd2\x7b\x7e\x79\x70\
\x5f\xc6\x6d\x79\x63\xc3\x86\x7f\xc8\x59\x07\x18\x1d\xfd\xc5\x5d\
\x7e\xf5\x4c\x79\x71\xef\xcf\x86\x70\x1d\x47\x8e\xac\x89\x3b\x55\
\xf5\x6d\x30\xed\x48\xba\x3d\x1d\x89\xb8\x83\x58\x32\x0a\x3b\x96\
\x82\x15\x6f\x07\x21\x0a\xe5\x87\xd0\x81\x42\x50\xae\xc1\x1b\xbf\
\x82\x7c\xe6\xc0\x55\x84\xea\xa7\xca\xab\xee\x5e\xf1\xc5\x8c\x77\
\xd3\x00\xe7\x07\xb6\x0f\x46\xb5\x58\x94\x2b\x1e\xd8\xbd\x72\xed\
\xbf\x77\xa0\x41\xff\xdb\xab\x1e\x24\xf0\xee\xb6\x68\x6a\x5e\xe7\
\xc2\x3b\x61\xb9\x0a\x60\x1f\x33\x42\x11\x13\xa6\x03\xc5\x8b\xe7\
\x90\x1b\x7c\x6b\x8c\x58\x7e\x77\xd9\xa6\xe1\x57\x66\x0c\x70\xec\
\xf0\xbd\xc5\xa5\x3d\x1b\x5b\x46\x47\x8e\xa2\x22\x33\x4f\xad\x58\
\x77\xf8\xb1\xe3\xef\xae\x7e\xd2\xd5\xf6\xf7\xe7\x75\x2d\x46\xb4\
\x35\x09\x80\xf1\xff\x21\x20\xab\xcd\x18\x3b\x7d\x00\xc5\xec\xd0\
\xb3\x77\xbb\xa3\x8f\x62\x13\xab\x1b\x06\x38\x7e\x68\x5d\x31\x3d\
\x6f\x7d\x8b\xd6\xc0\xe5\xcc\x19\x78\xe1\xd8\x99\xa4\xdb\x9b\xee\
\xec\xec\x06\x59\x35\xdc\x12\x9c\xc0\xc8\xc9\x53\x18\x38\x75\xf8\
\x6f\xb1\x52\xf6\x81\x0d\x3b\xa7\x86\xb0\x01\x03\x03\xda\x57\x60\
\xf2\x31\x37\xb5\x0c\x61\xb0\x34\x1d\x89\x02\xac\xab\x46\x60\x12\
\x86\x81\x1b\x95\x00\xe5\x80\x1c\x0b\xac\xeb\x33\x4c\xa8\x82\xee\
\x74\x1f\x8a\xa5\xda\xc6\x53\xf9\x63\x2f\x01\xd8\x3a\x35\x40\x03\
\xa5\xd4\xe4\x0d\x96\x00\x54\x48\x00\x4d\x6d\xae\xc3\x00\xb5\xd1\
\x8b\x08\xc7\x33\x90\xf9\x2c\x64\x39\x0b\xb2\x2c\x44\xda\x7b\x60\
\xb7\xce\x81\xdb\xb5\x08\x91\x8e\x36\xe0\xba\x49\x33\xaa\xe8\x5b\
\x7e\x07\x06\x07\xc7\x1e\x7a\xe1\xd1\x96\x13\x5f\xdb\x5d\x7a\x66\
\xea\x0a\xfe\xb5\xb6\xb8\xa8\x79\x55\x0b\x43\x81\x44\xa3\xab\x29\
\xdc\xc8\xc0\xc6\x60\x7c\x04\x85\x73\xef\x41\xd7\xab\x40\xa8\x41\
\x46\x0e\x19\xac\x19\x36\x4b\xa0\x41\xac\x67\x39\x9a\xd2\x6b\x41\
\xf6\x0d\x66\x51\x92\x78\xe1\x97\x7f\x2e\xcf\x8d\x89\xdb\xbe\xb1\
\xa7\x50\xb8\x66\x05\x0c\x25\x25\x88\x18\x9a\xc9\x54\x00\x44\x13\
\x01\x98\x25\x2a\x23\xef\xa3\x9e\x3f\x0f\x58\x80\x6f\xdb\x38\x31\
\x62\xe1\x7c\x86\x90\x29\xa0\x5a\xab\x2b\x50\x18\xc6\xbb\x13\x0a\
\x9f\x49\x87\xe8\x1a\x3e\x09\x3f\x3b\x84\x96\xe5\x1b\xe1\xb4\x36\
\xe3\x5a\x12\x2e\x21\xdd\x97\x6e\x3e\x72\xf4\xe4\x5e\x00\x0f\xc2\
\x20\xd0\x08\xa0\x95\x84\x32\xb2\x0a\xa1\xb5\x91\x43\xb0\xb1\x3c\
\x76\x14\x7e\x6d\x08\x14\x17\xb8\x5c\x14\x78\xf5\x90\x5b\x1f\x1c\
\x8f\xee\x26\xc7\x4d\xef\xd9\x97\x4f\xfc\xea\x4f\x85\x44\xcf\xdc\
\xc4\xa7\x4a\x22\xf6\xdc\xee\x37\x5d\xff\x9f\xe7\x6c\xa8\xba\x87\
\x52\xff\x5f\x21\x3d\x1f\xda\x0f\xa6\x78\xdf\xda\x5e\x5c\xcc\xf2\
\x67\x77\x7d\x99\xdc\xc9\x09\x10\xf3\xc4\x7e\xc9\x26\x30\xd1\xe4\
\xfb\x14\x56\x2f\x23\x0c\x2e\x98\xe6\x04\xdf\x63\xf4\x8f\x34\x15\
\xbb\x7b\xac\xf5\x0f\x3f\x7e\xe1\x03\x5c\xc3\x8f\x5e\xbc\x72\x1c\
\xc0\xb7\x9e\xdf\x91\xda\x35\x34\xee\xbc\xd1\x9e\xab\x2d\x5f\x91\
\xaa\x8b\xca\xc0\x41\x6a\xea\x5b\xc7\x60\x2d\x26\x57\x64\x01\x77\
\x2c\x99\x1b\x09\x6a\x99\x2f\x00\x78\x51\xc0\x50\xf7\x35\x94\x0a\
\x1a\x9a\xd4\x1c\x80\x8d\xb0\x08\x76\x53\x0b\x84\xcb\x88\xa5\x18\
\x4b\x17\xaa\xd6\x64\x4c\x6f\xc7\x34\x6c\x7b\x26\x9b\x5f\xbe\xc8\
\xfd\x74\xd1\x49\x5c\xf0\x94\x55\x0c\xaf\x5e\xbc\x54\xcf\x9c\xcb\
\xe9\xc0\x2f\x1b\x43\xa3\x36\xaa\xbb\xd3\xed\xba\xea\xf3\xe7\x27\
\x57\x50\xae\x28\xf2\x46\xfb\x11\x14\x86\xa1\x83\x3a\xb4\x09\xa2\
\x75\x00\x11\x6d\x42\x22\xb5\x0a\x89\x8e\x3b\xe1\xb4\x34\xa1\xef\
\x9e\x2a\x96\x74\xab\xaf\xbc\xf3\xbb\x85\x3f\xc6\x34\x6c\xd9\x99\
\xf1\x7a\x7b\x22\xdb\xca\x76\xec\x20\x80\x73\x41\x76\x70\xd0\x34\
\x1d\x35\xe6\x8d\x25\x63\x7d\x41\xca\xad\x14\x3d\x5e\x3c\x19\xa0\
\x56\x95\xc3\x7e\x39\x83\x6a\xee\x24\xca\xa3\x6f\xa1\x9a\x35\x7b\
\x2f\x5f\x80\xf2\xc7\xa1\x82\x02\xd8\x26\x44\x9a\x17\x21\xd6\xd6\
\x85\xee\x35\x15\xb4\xb6\xe8\x1f\x7c\xf8\xf6\xfd\x7d\x98\x86\x79\
\x49\xbc\x6b\xbb\x4e\x06\xc0\x98\xaa\x15\x33\xca\xaf\x8f\xea\xff\
\x39\x66\xcc\xc6\x2c\x5d\x29\x79\xcc\x93\xef\x80\x5f\xd7\x5b\x8e\
\x78\x5d\xaf\xfa\xe3\x6a\x61\xe8\x2b\x48\xc9\xd0\x2a\x07\x42\x96\
\x2d\x62\x76\x2c\x13\xc0\x01\xc5\x1c\x12\x6e\xa4\x95\x3b\xe7\xa4\
\x8a\xa9\x56\x9e\x07\x60\x00\x37\xa0\x6f\x4b\xa6\x3c\xfa\x5c\xe7\
\x98\x64\x4a\xda\xa4\x6b\xca\xbb\x2a\x85\xe3\x06\x00\x3c\xa3\x9b\
\xb0\x39\x5a\xf2\xb4\xbf\x6b\x17\x09\x1b\x86\xcf\x6d\x3d\x7d\x0c\
\xc0\x12\x4c\xc3\xcb\x3f\xe9\xc1\x97\x1e\x1b\xc6\xec\x21\xb0\x6a\
\x2f\x13\x26\x88\xc9\x4a\x46\x0a\xcb\x0d\x98\x55\x8d\xb5\x74\xa5\
\x54\x81\xd4\x88\xee\xdc\xc9\xda\xc6\x0c\xfc\x70\x5b\x17\x49\xc9\
\x42\x10\x68\xcf\xae\x1e\xf9\xcd\x9d\xb3\x0b\xf1\xc1\x6f\x53\xe6\
\x90\xb2\x66\x11\x6b\x00\x75\xe5\xe5\x02\x05\x04\x00\x5c\x63\x78\
\xa5\x2c\xa2\xf1\x88\x68\xac\xe0\x3a\xf6\x7e\x27\x49\x31\x48\x34\
\x5b\x92\xee\xef\x50\x94\x8c\x83\x0e\xe7\xdb\x44\xbe\x18\x0a\x00\
\x1a\xb3\x40\x91\xb5\x20\x1a\x41\x05\x92\x6a\x60\x76\x01\x04\x0d\
\xa3\xc6\xb0\x50\xb3\x23\xf1\x88\xf2\x61\x10\xb8\x8e\xaf\x3f\x5d\
\xe0\x87\x9e\xae\xf0\x5d\x1d\x3e\xf7\x24\x99\x13\x31\x81\x95\xf3\
\x7c\x1a\x2b\x5a\xd1\x9f\xef\xea\xc6\xcd\x38\xb1\x6f\xbe\xa3\x2d\
\xd1\xdb\x6c\xeb\x12\x3b\x76\x15\x42\x14\x00\x14\x8d\x57\x8d\xc3\
\x30\x75\x20\x67\x17\x3a\x9a\xe9\xc3\x46\x80\x1b\xd3\xf7\x3d\x66\
\xb6\x2d\xc0\xb6\xa8\x35\xae\xc5\xbd\x4b\x2c\x6b\x78\x8c\xdd\x97\
\x9f\xec\xc2\x74\x1c\xda\xdf\x23\x02\xc7\x5a\x16\x41\xb4\x4e\xba\
\x5e\x31\xf7\x96\xcc\x33\xaa\xb0\x44\x09\xc0\xe5\x46\x90\xe2\xe9\
\x8c\x5d\x68\x6b\xa6\x43\x30\xd8\x98\x86\xb3\xcf\x46\x89\x2d\x1b\
\x30\x21\xd8\x12\x7a\x45\x77\x55\x89\x68\x92\x8f\x0f\xd7\xad\xbd\
\x4f\x74\xeb\xf6\x16\x87\x37\x3f\x72\x01\x30\xfc\xfd\x37\xb7\x91\
\xeb\x88\x88\x9b\x88\xa5\x1c\xaf\x02\x11\xd4\x3d\x73\x5f\xc8\x80\
\x43\x40\x60\x2a\x13\xc3\x81\xd6\xce\x55\xdf\x75\xf2\x9e\xb4\x56\
\x2f\x0c\x4f\xcd\xf8\x51\x7a\xf6\xf9\x38\xb1\x6d\x1b\x2d\xc0\xfa\
\x28\x84\xc5\xb0\x04\xaa\x1c\xa7\x13\xc3\x55\x28\xa7\x5d\x28\xd4\
\x45\x53\x9c\x44\x67\x32\x66\x25\x50\xb2\xdb\xa3\x31\x17\xd5\x42\
\x2b\x94\x8a\x93\x52\x0e\x49\xe5\x40\x2a\x65\x6a\x84\xa4\x8c\x42\
\x4a\x7a\xed\xec\x1c\x3b\x73\x25\x9f\x79\xea\x2f\xf2\xfd\x19\x27\
\x60\x1a\x22\xfd\x70\x49\x9f\xfe\x75\x27\x2d\xdd\x9a\xe3\xc9\x37\
\xfc\x8f\x0b\x71\xcf\xed\x2e\x20\xea\x9a\xac\xa8\xa9\x16\x38\xf0\
\x00\x26\xb0\xaa\x86\xb0\x2d\x9f\x88\xc0\x20\x07\x0c\x45\x0c\x9b\
\x99\x43\xb0\x08\xf3\xf5\x36\xfb\xfc\x65\x8f\x56\xce\x57\xfd\x33\
\x7e\x96\x1f\x7f\x69\x11\xb9\xfa\x2a\xd2\x5f\x2d\x32\xa6\xe1\x3f\
\xaf\xdf\x4e\x20\x12\x60\x10\x98\x05\x69\x2d\xa0\x74\x84\x94\x8a\
\x41\xa9\x28\x49\xa9\x21\x95\x45\xa1\xb4\xcc\xb5\xa3\xa4\x15\x79\
\xbd\x3f\x6a\x85\xe5\xf1\xcc\xe3\xbf\x0f\x33\x30\x4c\x3b\x81\x33\
\x25\x81\xcd\xdb\x4d\xf3\x19\x60\xc7\x06\x88\x34\x18\x02\xcc\x1a\
\x5a\x03\x42\x49\x10\x42\x02\x87\x6c\x46\x48\x9a\x05\x2c\x61\x81\
\x1d\x79\x26\x97\x94\xa2\x3e\xec\x4d\x36\x9f\x32\x81\x8f\x49\xff\
\x9b\x2b\x09\x13\x31\x98\xa0\x14\x91\x39\x31\xa4\x12\x24\xe5\x47\
\x27\x17\x13\xc2\x16\x63\x79\xdb\x1e\x38\x35\xa2\x5a\x73\x61\x7e\
\xd3\x1f\x18\xb7\x1a\x60\x6a\x88\x77\x56\x13\xb4\x86\x69\x4e\x30\
\x5e\xd3\x9c\x22\x4e\x8c\xbc\x6c\x55\x8c\x9c\xbf\x22\x1f\x78\xc2\
\xaf\x03\x3c\xcd\xaf\xd9\x2d\x72\xfc\xe0\x1a\xa2\x70\xe2\xd3\xcc\
\xa8\x44\xcc\x8e\x8a\xe0\xe2\x25\x8a\x48\xd6\x15\xcf\xd3\x2b\xb7\
\xfb\x7a\x96\xff\x86\xb7\xce\xd0\x6b\x69\x92\xd9\x1c\x49\xdf\x67\
\x5b\x79\xdc\xfb\x08\xdf\xfc\xdf\xf0\x93\x44\xe0\x13\xe6\xbf\x92\
\x72\x1f\x2a\x41\x39\x0f\x72\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x07\x49\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x02\x73\x42\x49\x54\x08\x08\x55\xec\x46\x04\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\x01\xb7\
\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x06\xc8\x49\x44\x41\x54\
\x78\xda\x9d\x58\x5b\x68\x5c\x55\x14\x5d\xf7\xce\x64\x9a\x79\xf4\
\x61\xeb\x23\x99\x50\xaa\x28\xc5\x2a\x7e\x88\x4d\x40\x2d\xf4\xa3\
\x84\xfe\xf4\x85\x1f\x2a\x56\xff\x0a\x7e\xd8\x0f\xc1\x20\x55\xa4\
\x84\x52\x6a\x91\x08\xfe\x1b\x10\xd4\x68\x53\x7f\xea\xfb\x23\x54\
\x14\x83\xda\x07\x14\x15\x2b\x48\xc5\x42\xcd\xc3\xda\x58\xdb\x4e\
\xe6\x91\xcc\xdc\xed\x62\x71\x4e\xee\xc1\x69\x1a\xeb\xde\x9c\x99\
\xe4\xdc\xb3\xd7\x3a\xfb\x9c\xbd\xcf\xd9\x77\x22\xc3\x52\x72\x38\
\x8f\x2d\xb6\x09\x3d\x28\xab\x01\x93\x98\x00\x5b\x34\x8e\xe3\xfb\
\x6a\x58\x42\x6e\x48\x70\x68\x8d\xed\xc2\x76\xf4\xa3\x60\x00\x2c\
\x34\x83\x5a\x15\x63\xf8\x38\x3a\xf6\xf2\xcc\xff\x20\x38\x58\xb4\
\x01\x0c\xa0\x64\x30\x24\xf0\x9f\x1e\x3e\x66\xf3\x9f\xa8\x60\x28\
\x1a\x7a\x65\xf6\x26\x08\x0e\x64\x6c\x0f\x06\xd1\x95\x80\x8a\x16\
\xb5\xc9\x96\x88\x42\xf0\xd4\x0c\xb2\xc8\x50\x63\x29\xa6\x31\x18\
\x0d\xef\x6f\xfd\x27\x82\xc1\xb2\x1d\x43\xaf\x09\x78\x9e\x3a\x47\
\x9d\x47\x1e\x9d\x6c\x05\x00\x55\xd4\x50\x67\xeb\x40\x8e\xda\x41\
\x25\x11\x69\x71\x2a\xda\x35\x38\xb9\x24\xc1\xfe\x3e\xc2\x77\x27\
\x68\x0a\xb8\x4e\xe8\x5b\xb1\x16\x77\xa3\xe8\x66\x4b\x91\x2f\xd7\
\x70\x0e\x17\x70\x89\xf0\x9d\x22\xca\x82\xcf\xa6\xa2\x5d\x07\x4e\
\xde\x90\xe0\x95\xdd\x36\x6c\x9d\x2d\xcd\xbb\xca\xb6\x1e\x0f\xa1\
\x80\x4e\xea\x32\x3f\x4f\xc1\x37\x35\x62\x9e\x34\x27\xf1\x0b\xe1\
\x0b\xf2\x85\xcf\xeb\xd1\x9e\x83\x23\x8b\x12\xbc\xfc\x34\xde\x31\
\x19\xd7\x50\xe1\xbc\xfb\xb0\x1a\x45\xac\x20\x7c\x16\x91\x14\x30\
\x51\x98\x48\x1a\xa8\xb3\x5d\xc4\x37\xf4\xa5\x84\x3c\x3a\x34\x0e\
\xcf\x1c\x7a\xf7\xba\x04\x2f\xf5\xd9\x57\xd6\xc9\xa5\xc1\x2c\x0d\
\x1f\xc5\xbd\x34\x5a\xc5\x96\xa1\xc2\x47\x0c\xc5\xa8\x22\x70\x24\
\x55\x8e\x3e\x83\x71\x4e\xa3\xa8\xa5\xa2\x17\x9b\x5f\x3d\xd9\x46\
\xb0\xaf\x6c\xa7\xad\xbb\x45\x83\x59\x1a\xf6\x73\xfe\xb7\x61\x05\
\x0d\x62\xa9\x83\x67\xb3\x90\xc2\x69\x95\xfa\x2b\x3e\xe7\xa8\xa2\
\x96\x32\x9a\x8a\x36\x1e\x9e\x44\x48\xf0\x62\xc6\xbe\x45\xaf\x66\
\x8f\x16\x1e\xc3\x1a\x74\x63\xb9\x02\xd1\xc3\xc7\x82\xa7\x78\x0a\
\x17\xc2\x4d\x45\x5a\x9d\x76\x53\x38\x82\x8c\xf3\x82\x11\xf5\xf0\
\x6b\x2d\xc8\x73\x49\xb2\xc7\x7a\x5b\xe0\xda\x53\xb7\x12\xbe\x8c\
\x95\x0a\xc0\xec\x82\x66\xfc\x7f\xea\x4f\x35\x87\x65\xd4\x3c\x96\
\xd3\x66\x9b\xec\xe7\x49\x6b\xbd\xc9\x9e\xc0\x83\x17\x8a\x38\x97\
\x74\x35\xf9\xf0\x0a\x36\xe3\x01\xc1\x13\x4a\xe9\x14\xa7\x19\xeb\
\x24\xf4\xa2\x25\x55\x4c\xa1\xce\x98\x3a\x81\x2f\x68\x9b\x07\x6d\
\xa7\x71\xcf\xeb\xb3\xce\x83\x64\x20\xe9\x6a\x69\xbb\xd6\x61\x03\
\x6e\x77\xf0\x19\x47\x41\x12\x7f\x34\xb4\x29\xfd\x51\xcb\xc9\x93\
\x22\x36\xe2\x4e\xa2\x34\x48\x9a\x74\x25\x03\xce\x83\xe7\xd7\xd8\
\xf9\xa4\xc4\xad\x42\x05\xbb\xb1\x96\x9a\xf3\xc7\x00\x1b\xd2\xd5\
\x6f\x13\x7f\x42\x35\x9d\x0f\x0d\x22\x5c\xc0\x9b\x28\xa1\x00\x4e\
\xae\x12\xdd\xf9\xc6\x4c\x16\xb0\x9d\x56\x4a\xb4\x51\xf7\x63\x35\
\xb5\x03\x02\x17\xfc\x5b\x0a\xc4\x04\x19\xce\xef\xd9\x30\x63\xd0\
\xe2\xf8\x84\x63\xf3\x38\x40\x30\x1f\x57\x79\xdc\xc1\x25\xfe\x99\
\xfd\xf4\xb9\x84\x1d\x78\x2b\x06\x5a\x3b\xb8\x8a\xca\xcb\x3e\x3a\
\xb9\x3c\x5d\x00\xcd\xb1\x86\xab\xf8\x0b\x7f\xe2\x0f\x84\x62\xa8\
\x60\x06\xd3\xf8\x1d\x17\xb4\x78\xf2\x58\x0b\x9b\xc7\x66\x79\xd3\
\x04\x77\x67\x27\x90\xdd\x9b\xb7\x7e\x86\x1b\xbb\xba\x08\xbf\xda\
\x0d\x8d\xdc\xba\xc3\x1d\x76\xed\xd2\x50\x1e\xfb\xbd\x01\x6d\x12\
\x11\xe4\x98\x9c\xdd\x24\x57\x06\xf5\xef\xcd\xc7\xc9\x96\xa4\xc0\
\x00\xe5\xf0\xbb\xc8\x5e\x72\xc0\xfe\x58\x6b\x06\xe7\x69\x20\xea\
\x69\xe8\x54\x9d\x43\x24\xcd\x48\x45\x81\xf5\x68\x28\x58\x93\x42\
\xb2\x25\x4e\x36\x19\xb9\x49\xc1\xee\x18\x8d\xf4\x3a\x91\x36\xa9\
\x84\x0a\x09\x3c\xb1\x3c\x20\x81\x2c\xe4\x87\x0b\xeb\x1c\x77\x41\
\xf0\x20\xf2\xa6\x6c\xd2\x63\x82\x2f\xa2\x44\xf6\x26\x4d\x32\x69\
\xd4\x3b\xea\x39\xad\x72\x28\xec\x15\x7c\x16\xcb\x40\xf1\x04\x2e\
\xac\x57\xa1\xc8\xe7\x1d\x60\x6f\x4f\x6c\x65\xf2\x50\x0b\x2e\x76\
\x22\x25\x4e\x4a\xa0\xb9\x6a\x46\xa1\x28\x2c\x50\xd3\x13\x2f\x71\
\xe0\x47\x51\x98\x06\x2b\xc7\xd6\xa3\x8c\x44\x51\x0f\x22\xa7\xe6\
\x62\xbf\x2a\x0a\xc5\x04\x02\x71\xbd\x75\x3d\xf1\x1e\xc0\x5b\x13\
\xa7\xc4\xf1\x06\x6a\x4f\x56\x1e\xc0\x50\x0a\x56\x3e\x95\xd3\xb8\
\x48\x92\x16\xa3\xdb\x10\x88\x66\x7f\x8d\xc1\xbb\x92\x9e\xa7\x92\
\x52\x2c\xf7\x45\x42\x39\x6b\xf0\x9a\xe6\x6b\x48\xd1\x60\x06\x4c\
\xe1\x12\x2e\x23\x94\xbf\x71\x05\x15\x52\x94\x52\xe2\xd0\x3e\xc0\
\x8c\x6d\xd2\xd4\x59\x09\x2a\x1f\x7d\x07\x9b\xd7\xc9\x26\xe3\x25\
\xfa\x53\xfb\x6b\xee\xdb\x26\x63\x9b\x50\x37\xbb\x92\x94\x37\x05\
\xd2\x81\xa6\x93\x05\x58\xba\x7f\x01\xe1\xaa\xff\x6f\x82\x1e\xc8\
\x40\xf7\x58\x2b\xa5\x70\x9f\x19\x25\x4e\x9e\x2d\x08\xd3\xf6\xfe\
\xd4\x46\xda\x42\x05\xf2\x2c\xf5\x20\x26\xe7\x15\x25\x87\xaf\xe2\
\x24\x3a\x8a\x79\x9d\xb0\x75\x40\xb2\x78\xbf\xb7\xa4\x5e\x26\x5a\
\xec\x3d\x88\xc6\xbd\xc3\x3f\x2b\x18\x45\xe2\x06\x0b\x48\x05\x57\
\x67\x48\xd0\xde\xaf\xd1\x69\x1d\xf8\xbd\x96\x4e\x81\x3b\x1e\xdb\
\x71\xab\x42\x39\x70\x4e\x39\x9b\x04\x7e\x98\xae\x12\x01\xf1\x3b\
\x94\xb0\x3f\x2d\x02\x64\x4b\x8c\xb3\x44\x93\x07\x55\x3b\x1e\xbf\
\x5d\xb3\x31\xe8\x28\xb8\x40\xc7\x98\x38\xce\x0f\xed\x87\xee\x29\
\x01\xf1\x3b\x94\xb0\xdf\xc2\xcb\x93\x7a\x05\xe7\xa1\xfa\x08\x36\
\xf6\x76\x8d\x44\xf8\xc8\x10\x29\x8b\xbf\x44\x63\x81\x42\x7e\x28\
\x14\x0b\x28\x49\x43\x09\xfb\x2d\x2d\x91\x95\xdf\x9f\x39\x34\x03\
\x3e\xd4\x95\xb9\x9b\x57\xa6\x95\x9a\x3a\xbc\x9e\xc3\x3a\xac\xd4\
\xbc\x74\xd7\x2e\x64\xf7\x62\xe2\x17\x67\x7e\xe1\x7c\xfd\x0d\x87\
\x69\xaf\x5a\x90\x57\xe6\xc8\x4c\x0c\x8c\xcc\xd8\x10\x10\x6b\x63\
\xc6\x54\x37\xcf\xcb\x80\x33\x4a\xb7\xbb\x4d\xc2\xad\xd5\x58\x59\
\xd5\xf0\xb1\x43\x02\x6c\x68\x64\xc6\xd7\x45\x43\x98\x06\xdd\xca\
\x31\x92\x4e\xa8\x14\x9c\x13\x05\x8d\x04\x10\xd2\x84\xd0\x52\x8d\
\xf4\x85\xcb\x38\x7e\x40\x8e\x48\x94\x69\xa2\xc2\x11\xbc\x3f\x6b\
\x83\x5c\x37\x5d\xe1\x9f\xe0\x17\xcc\x6a\x2f\x44\xa2\x96\x2c\xaa\
\x7c\xae\xa6\x1b\x8e\xd3\xfb\x40\x25\xb0\x76\x60\xf0\xfd\xd9\xa0\
\xb2\x8b\x86\xa3\x53\x8c\x24\x65\xe6\x7b\x98\x40\x05\x75\x77\x8f\
\x49\xb5\x08\x16\x00\x9b\x5b\x14\xa9\xc0\xeb\x2a\x58\x84\x40\x78\
\xa2\x0d\xff\xab\xf8\x7d\xb2\x0c\x15\xbf\xf3\xba\xa7\x9e\xc2\x06\
\x14\x95\x46\x2a\xc1\xc2\xf2\xb7\xad\x36\x6d\xca\xe6\x2c\x86\xf9\
\x17\x2d\x54\xfc\x62\xe3\x91\xa0\xf8\xf5\x14\x2a\xdf\x13\x77\x83\
\xed\xc0\x23\x28\xa8\x08\xf4\x14\x69\x3c\x99\x54\xf0\xd2\x1a\xbe\
\xe6\xe2\x74\x28\xf6\x62\x95\xef\x47\xc2\xf2\x3d\x95\x27\xf4\x02\
\x92\xb8\xeb\x70\x03\xb6\xa1\x5b\x07\x5a\x5a\xa5\x8a\xc0\xc3\xbb\
\x91\x13\x0c\xf7\x1f\xfd\x38\xbd\x80\x8c\xb6\xbd\x80\xa4\x14\x7c\
\x85\x42\x27\x0d\x5d\x45\xd7\x8b\xad\x58\xa5\xca\xf3\x7a\x04\x73\
\xcc\xda\x4f\xf1\x1d\x9f\x2c\x73\xc5\x32\xf8\x0a\x35\xba\xf8\x2b\
\x94\x28\xfa\x70\xcc\xba\x6d\x21\x2f\x8d\xa9\x77\x1f\x1e\xc4\x2d\
\xae\x20\x8b\xdc\xc1\x70\x19\x67\xf0\x13\xd3\x2a\x42\x4e\xe0\x7a\
\x36\x85\x5d\xa3\x8b\xbe\x04\xa6\x14\x65\x52\xf4\x12\xc6\xa7\x90\
\x3e\x57\xa0\x84\x15\x54\xe0\x2a\xb5\xc2\x96\x09\x6a\xf0\x48\x91\
\x43\xf8\xa5\x5f\x63\x45\xc1\x17\xf1\x68\xd0\xba\xd2\x74\x0a\x92\
\xad\xad\x90\x17\xf8\xb4\xf1\x45\x7c\x74\xe9\x17\xf1\x54\x1e\x2f\
\xda\x40\x34\x60\x25\xc0\x16\x14\x6a\x61\x81\xa2\xbf\x2b\xc6\x9f\
\x12\x8e\xde\xc4\x4f\x09\x29\x09\x7f\x0c\x89\xb6\x5b\xbf\x6a\x93\
\xeb\xd5\x0f\xd5\x68\xcc\xf8\x63\xc8\xd1\x9b\xfa\x31\xa4\x9d\xc6\
\xfd\x9c\x13\x95\xd1\x63\x65\x9a\x4c\x62\xc2\xdc\xcf\x39\x47\x6b\
\x58\x42\xfe\x01\x6e\x27\xb7\x0a\x6b\xa5\x4a\xe0\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0b\x29\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\
\x01\xb7\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x0a\xa6\x49\x44\
\x41\x54\x78\xda\xd5\x5a\x4b\xaf\x1d\x47\x11\xfe\xba\x7b\xce\xe3\
\xda\xf7\xe5\xa7\x42\x44\xe2\x38\x01\x94\x84\x3c\xd8\x20\xe1\x48\
\x44\x20\x1e\x02\xf1\xb2\xb2\x82\x15\x62\x11\x84\x10\xff\x80\x0d\
\x0b\x1e\x62\xc7\x82\x15\x1b\x04\x62\x1b\x29\x42\x04\x10\x08\x64\
\x1e\x12\x6c\xc2\x22\x24\x0a\xe6\x26\x71\x72\x1d\xe7\x5e\x5f\xdb\
\xf7\xda\xf7\xdc\xf3\x98\x39\xd3\xdd\x74\xd5\xe9\x9e\x9a\x33\x73\
\xe2\x07\x81\x45\xda\x29\x57\x77\x9d\x39\x67\xbe\xaf\xaa\xba\xba\
\x66\x1c\xe5\xbd\xc7\xbb\x79\x68\xbc\xcb\x87\x7a\xe8\xf1\x8f\x1c\
\x7b\xf4\x91\x87\x7f\xf0\xd8\x23\x0f\x3f\xa5\x8d\xe9\xb2\x91\x44\
\x29\xfa\x8b\xe7\x46\x6b\x28\xad\x95\x31\x06\xda\x68\x18\xa5\x59\
\x2b\xcd\x73\x15\xfe\x83\x0e\x36\xd2\x4a\xcd\x89\x82\x0c\x2f\x33\
\x0f\x9f\x04\x9e\x3f\x71\xce\x05\x15\xb5\xf3\x70\x3e\x68\x1e\xc0\
\x68\x3c\xf2\x45\x31\x15\xd0\x80\xdd\x1f\x1c\xfc\xf5\xd9\x5f\x3e\
\xf7\xad\xec\xc4\xf1\x63\xdf\xee\x76\x3b\x4f\xff\xf1\xdc\x5f\xe0\
\xbc\x87\x8a\xa0\xb5\x9e\x81\xcc\x4c\x06\x02\xde\xe9\x74\x90\x05\
\x9d\x65\x66\x66\xcb\x74\x90\xa0\xf9\xba\x2c\xd8\x82\xd6\x51\x88\
\x20\x91\x61\xe2\x80\x82\x06\xff\x2a\x3b\x26\x31\x21\x02\xc2\xc9\
\xd1\x3c\xc8\x4c\x39\x26\xe6\xac\xc7\xeb\x6f\x6c\x62\xf3\x8d\x37\
\x70\xe8\xf0\x32\x7f\x6f\x34\x3c\xc0\xda\xda\x3a\xde\xf7\xc0\xe9\
\xcf\x9f\xba\xf7\x1e\x4b\x11\x38\x0f\xe0\x03\x88\x23\x79\x8f\x01\
\x10\x10\x5a\x13\xa8\xe4\x65\x5e\xd3\xe7\xf1\x33\x01\x1b\xd7\xb3\
\xcf\x52\x54\xd2\x9a\xaf\xa9\xd6\x24\x71\x4e\x36\x59\x57\xf7\x2b\
\x8a\x02\xaf\xbe\x76\x01\x57\xde\xba\x80\x4f\x7d\xf2\x13\xf8\xdb\
\xdf\x9f\xc7\xfe\xc1\x00\x1f\x7f\xf2\x09\xec\x5c\xb9\x8a\xcd\xad\
\x3d\x00\x28\x32\x00\x3d\xd4\x86\x8f\x51\x08\x0a\x92\x00\xe4\x99\
\x60\x53\xbe\xf2\x24\x47\x5e\x81\x57\x9e\x88\x93\xf7\x94\x8a\x6b\
\x0f\x95\x3e\x8c\x6b\xef\x89\x80\x4f\x6e\x92\xfb\x20\xe8\xb4\x06\
\xf8\x37\x76\x77\x77\xb1\xb9\xf9\x26\xa7\xd3\xca\xf2\x32\xce\x9d\
\x3b\x87\xbc\xf4\x30\x26\xc3\xc5\x8b\x17\xb1\xb1\xf1\x0a\x56\x8f\
\xbf\x17\x00\xba\x19\x6e\x36\x22\x28\x30\x19\x0f\x24\x12\x35\x0d\
\xb6\x63\x06\x3e\xb1\x66\x46\xc9\x19\x69\x9d\x48\x40\x9c\xd3\xb8\
\xce\x3a\x87\x4b\x6f\x5e\x0a\x04\xf6\x04\x42\x76\x08\x59\xbf\x83\
\x8e\xe9\xf2\x75\x97\xaf\x0d\xb0\x7a\xec\x3d\x48\x63\x21\x81\x94\
\x9b\x0c\xaa\xba\x8b\x78\x5c\x22\x90\xfc\x27\x60\xa2\x6a\x78\xf8\
\xd6\x11\x3d\x38\x38\xc0\x9b\x97\xde\x42\xda\xac\x72\xa5\x86\xce\
\x7a\x29\xbd\xa5\x70\x36\x09\x14\xf9\x18\xf9\x64\x12\x2f\x24\x51\
\x22\x31\x37\xf1\x76\x5a\x07\x0d\xd1\x5c\x8d\x9a\x5a\x25\x49\x36\
\x70\xfe\xd3\xb8\x7e\xe3\x06\x06\x83\xe1\xed\xd7\x7e\x63\xb0\xbc\
\xb2\x86\x2e\x15\x16\x00\x61\x92\xe1\x9b\x4f\x7f\x1d\x8f\x3d\xf6\
\x68\x2a\x99\x71\x53\x91\x8e\x1b\xab\x25\xba\x36\x87\x78\x48\x62\
\xc4\x76\x19\x29\x1a\x80\xb5\x16\xe7\xcf\xff\x1b\x2f\xbe\xf4\x22\
\xe0\xc1\x76\xd9\x30\x7e\x3e\x13\x94\x98\x52\xfa\x8d\x46\x23\xec\
\x5c\xdb\xc7\xf6\xce\x95\x19\x81\xd3\xf7\x9f\xc6\xd9\xb3\x5f\xa2\
\xa9\x54\x1a\x11\xf1\x20\x22\xd8\xf6\x3c\x61\x84\x9a\x47\x2f\x6b\
\x06\xee\x70\x30\x1c\x86\x0d\xba\x89\x95\xd5\x55\x9c\x39\xf3\x04\
\x64\xc8\xfe\x00\x24\x27\x9b\xfa\xf0\xe1\x43\xb8\xef\xd4\xbd\x78\
\xe6\xd9\x5f\xe3\x57\xbf\xf9\xed\x8c\x40\xc7\x74\xe8\x8b\xe4\x75\
\xb9\xb9\x88\x24\xb7\x26\x15\xd3\xa5\x06\xcf\x0b\xde\x26\x0b\xd0\
\x28\x6d\x89\x3c\x2f\x70\xed\xda\x2e\xf6\xf7\x07\xa0\xfc\x59\x59\
\x59\x8b\xdf\x63\xe8\x73\x58\x65\xe3\x57\xd4\xd8\x76\xf4\xe8\x3a\
\xd6\xd7\xd7\x66\x36\x3d\xb7\x07\x1c\x9c\xf3\xac\xd9\xd3\x8e\x75\
\x55\xa7\xbd\xf2\x9c\x46\xde\xcd\xaa\x91\xf3\xf1\x94\x4e\x55\x06\
\x54\xad\xe2\xad\x52\x95\xf2\x1e\xd3\x72\x8a\xa2\x28\x31\x1e\x8f\
\x70\xfd\xfa\x0d\x94\xa5\x15\x27\x09\x57\x89\x56\x3d\x4f\xb4\xd8\
\xe8\x10\x3d\x79\xe2\x04\xc2\x81\x1b\x23\xe4\xf9\xde\x89\x80\x94\
\x4c\x07\x06\xcb\x07\x8b\xd7\xfc\x6d\xa7\x98\x4c\xd0\x5c\x46\x64\
\x83\x47\x12\xde\x47\x7b\xfc\xe1\xa9\xb5\x01\x68\x89\xe9\x74\x4a\
\x2d\x01\x1f\x3e\x93\x71\x0e\x28\xf0\x89\x2e\xce\x16\xc0\x92\x66\
\xf1\x13\x22\x19\xab\x56\xaf\xdf\xc3\xc9\xe3\xc7\x99\xb8\x4f\x27\
\x35\x39\xd1\xd1\x24\x12\xa0\xb9\x75\x2e\x9d\x82\x6c\x60\xe0\x73\
\x7f\x10\x44\xc7\x3b\x47\xa2\x89\x64\x04\x4d\xc2\x84\xa0\x30\xc9\
\x27\x18\x1e\x0c\xe1\x41\xc0\x75\xe5\xee\x78\xd4\xc9\xa6\x97\xc1\
\xeb\x7a\xc6\x2f\x2d\xf5\x70\x64\xed\x08\xd9\x1b\xad\x06\x11\x70\
\x12\x01\x5a\x50\xff\xc1\x90\x9d\xaf\x6d\x5e\xca\x76\x1f\x73\x5e\
\x23\xe6\x10\x25\x0c\x4f\x6d\x39\x45\x69\x2d\x9c\xb3\x52\x81\xbc\
\xa7\x8d\xca\xe9\xa3\x75\x0d\x78\x7d\xa3\x62\xf1\xda\xd7\xaa\x7c\
\xbf\xdf\xa7\x53\x98\xfb\x31\xc7\xa9\x91\x2a\x99\x63\x12\x76\x2e\
\x85\x88\x51\x10\xcd\x73\x05\x68\x0f\x1e\x2e\x02\x66\x6c\x8e\xbf\
\xe4\xac\x23\xd0\xf1\x38\x15\x2f\x7a\x70\x24\xa8\xc4\xb1\x43\x52\
\xaf\x84\x56\x9a\x40\x6c\x02\xba\x6e\x46\xaf\xd7\xc7\x52\x48\x1d\
\x93\x19\x78\x72\x6e\x55\x5e\x63\x04\xe8\x8f\x95\x08\xd0\xe0\x0b\
\x1d\x37\x56\x16\xca\x57\x3e\x67\x30\xd3\x20\x36\x7e\x01\xc4\x6f\
\x86\x3c\x9d\xb0\x04\x94\xab\x4c\x31\x2d\x98\x10\xe7\xba\x34\x86\
\x73\xe9\x2d\x69\x24\x36\x69\x2f\x14\x3a\x59\x46\x9b\x95\xa2\xcf\
\x46\x86\x1d\x23\xc0\xf3\x19\x9b\xaa\x05\xc9\x2a\xef\x71\x33\x15\
\x84\x9d\x5b\xd2\x97\x64\xc7\x2b\x5d\x9d\xba\xd2\x5c\xc8\x98\xe4\
\x39\x1f\x4e\x5a\x9b\x58\x3c\x04\xa0\xb4\xd1\x6d\xbb\x34\x22\x3c\
\x88\x38\x83\x47\x6c\xe7\x13\x06\x5f\x3f\xd8\x62\x04\x6c\x7d\x0f\
\x58\x5b\x62\x32\x1e\xc3\x55\x27\x9e\xdc\x58\xd7\x4e\x66\x90\x56\
\xd2\xfa\x3a\x67\xa9\x34\xd2\x0f\x4b\x85\x49\xe9\x22\xc0\xdb\x73\
\xf1\x7e\x35\x34\x79\xbf\xdb\x85\x0c\xd9\xb0\xc9\xf3\x62\xe7\xb2\
\x3f\xbf\x89\xa7\xa5\x95\xd3\x55\xeb\x0a\x8c\x9f\x5d\xc0\x11\xf2\
\x72\x3e\xd0\xe7\x89\x8c\x54\x14\xd6\x32\x47\xfa\xbd\x06\x21\x19\
\xc2\x84\x6a\x7d\xed\x24\x26\x80\x8d\xb6\x44\x08\x31\x0d\x67\xe7\
\xf7\x80\x21\x20\xc9\xbb\x11\x50\x4b\x04\xb8\xac\x91\x34\x48\x37\
\x08\xc8\x29\xdb\x58\xa7\x1a\x10\x1d\xa5\x6b\xbf\x95\x92\xdd\xb1\
\xdd\xc5\x34\x96\x7d\xcc\x11\x91\x14\x4a\x3f\xaa\x8d\xa9\x80\xeb\
\x14\x01\xb4\xfb\x21\xad\x6a\x80\xdb\x44\x04\xd4\x2d\x48\x30\x0c\
\xc9\x7d\x79\x98\x02\xb7\xd9\x0c\x5c\xa5\x6b\x64\xf3\xca\x61\xe6\
\x7c\x3b\x02\xc9\xc3\x0a\x92\xe7\xf3\xad\xb5\x96\xf5\x02\xf0\xfb\
\x13\x9a\x4b\x94\x40\x32\xf7\x92\xa0\xd1\xa7\x25\x55\x2a\xf8\x04\
\xce\xa5\x9e\x35\x15\x16\xd4\x9e\x93\x81\xbe\x09\xd2\xf1\x70\xbc\
\xf6\x42\xa0\xf6\x0c\x2b\xc0\x65\xbd\x50\xb4\x12\xb0\x2f\xef\x68\
\x6c\xec\xf6\xeb\x0f\xf5\x6c\x4f\xf3\xc2\x02\x1b\x97\xe9\x2c\x49\
\xf5\x3f\x9d\xa8\x2c\x94\x12\x22\x96\x34\x9f\x37\x51\x93\xcd\xb2\
\x5e\xe9\x3b\x7c\xff\x8b\x7d\x00\x68\x46\xc0\x2c\x00\x0e\x89\x04\
\x24\x8d\xea\x44\x53\xba\x8c\xa6\x0a\xdd\x8c\x3e\x03\x74\xea\xa7\
\xf8\x33\x02\xa0\x70\x7e\xcb\x22\x2f\x69\x3d\x47\x80\x24\x11\x68\
\x10\xe1\x75\x14\x2e\x22\x2c\xfb\x63\x47\x0e\x89\x3f\x20\x04\x66\
\xc6\x2a\x75\xc0\x1a\xa8\xbf\xa1\x10\x89\xa4\x44\x78\x53\x59\x3c\
\x7f\x61\x0c\x23\x6f\x30\xaa\xf9\x64\x0a\x4c\x6d\x4a\x2b\x21\x00\
\x02\x95\x48\x08\x91\x96\x38\x2f\x44\x94\x4a\x1d\xb0\x44\x20\xe5\
\x77\x03\xac\x10\x49\xde\xd7\x75\xd0\x0d\x12\xce\x5b\xec\xec\x6c\
\xa3\x6b\xe4\x95\x0b\x13\x90\xeb\x64\x2f\x44\x2d\x35\x9e\xc1\xb1\
\x24\x42\x08\x73\x5f\x5a\x20\x96\x6f\x58\xc7\xb6\x52\xf7\xa0\xf5\
\x1a\xa0\x1a\x29\x24\xe0\xf5\x4d\xbd\x2e\x80\x1a\x4f\x6f\x50\x38\
\xfb\x78\x86\x8f\x3e\xb8\x42\xd7\x50\x65\xa9\xeb\xc6\x5c\x88\xa5\
\x34\xb2\xd6\x36\x84\x3b\xdc\xba\xe6\x03\xf7\x7b\xcf\x0d\xe4\x81\
\xa7\x46\xa0\x09\xbe\x0d\x9c\xd7\xa2\x55\x83\x08\x38\x8d\x08\x4c\
\x5d\x52\xd8\x55\x9a\xb7\xde\x7c\x40\x22\xd0\x94\x64\x8f\xbf\x35\
\x8b\x8e\xf5\x7c\xff\xc5\x11\x68\x97\xcd\x36\x68\x44\xad\xe7\x08\
\x82\xed\xc5\xd4\xbe\x1d\x70\xf6\xe2\xf6\xf6\x36\x86\xc3\x61\xfa\
\x5d\x21\x20\xdf\x61\x4f\xb7\xb5\x45\x19\xf5\xb5\x4b\x63\x28\x75\
\x3f\xe0\xa5\x99\x8b\xa3\x06\x1e\x8b\x4e\xe0\xda\x86\x06\x84\x50\
\xac\x5a\x1e\xb4\x51\x17\x7b\x7c\x77\xd2\xc7\xd6\xf0\x10\x0a\x7d\
\x0c\x7e\x39\xd6\xfc\x04\x9c\x52\xbb\x22\xc1\xb5\x5f\xe6\xd5\xe7\
\xa4\x3d\xaf\x3f\xf7\x59\x8f\xdf\x6d\x74\x71\xf2\xc3\x5f\xc3\x67\
\x3e\xf8\xe5\xb9\x08\x88\x56\x62\x53\x73\x11\x42\xa3\x4d\xf6\x55\
\xda\x39\x3b\x7b\xf6\x1d\x8d\xb2\x2a\xc7\xa7\xfa\x30\xae\x4c\x8f\
\xe2\xc2\x5e\x17\xb4\x1f\x81\x76\x8f\x24\x99\xd4\x68\x19\xe0\x45\
\x8b\x11\x7b\x13\x8f\x5e\xaf\x83\x41\x9e\x61\x54\x64\xc8\xf0\x0e\
\xc6\x60\xa2\xf1\x87\x0d\xae\x52\x61\xbe\x8a\xec\xc8\x83\xf8\xc7\
\x9e\x41\xa6\xe9\x99\x40\xe1\xa0\xe8\x61\x50\x18\xa8\x3a\x40\x85\
\xc5\xc3\xd7\x95\xb4\xcd\x98\x23\x01\x4c\xa6\x1e\x79\x19\x74\x90\
\xdd\x9d\x8b\x77\x46\x40\x1a\xb0\x59\xc8\x7b\x99\xc7\xd5\x61\xc6\
\xf6\x61\xae\x30\x2d\x81\xb1\xd3\xb5\xae\xd3\x45\x91\x37\x10\x8b\
\x19\x08\xd8\x34\xda\xe0\x67\x3a\x0f\x04\x8a\x52\xa3\x08\x37\xdb\
\xbb\xf4\x12\xb2\xc6\x5b\xe9\xb8\x10\x90\x5e\xa9\xd6\xbb\xce\x54\
\x41\xba\xc6\x63\xbd\x37\xc5\xe5\x01\x6d\x60\x17\x64\x8a\xae\xd6\
\x10\xc4\x02\xb7\x39\x13\xa0\x8b\x53\x68\xf1\xdc\x87\x7b\x20\x88\
\xe6\x7b\xed\x6f\xfd\x6b\x2e\x02\xd2\x6f\x33\x62\x21\xe6\xe4\xf1\
\x92\x73\xdb\xc1\x57\xeb\xbb\x96\x3d\x36\x77\x81\x9c\x08\x14\x44\
\xc0\x34\x3b\xcf\x06\xea\x5b\xa5\xd0\x7c\x79\x4d\xd6\x34\x9d\x14\
\x3e\xdc\x4b\x21\x2f\x72\x0c\xaf\x5e\x40\xd6\x7e\x02\x92\x1b\x8b\
\xb7\xa5\x81\xe4\x53\x91\x48\xc4\xf5\xdd\xeb\x0e\xe3\x8d\x20\xf9\
\x8c\x40\xa6\x6c\xfb\xd5\xa2\xb0\x69\x33\x69\xa5\x8e\xd8\x24\x95\
\xc4\x3e\xce\x11\x44\xc1\x1d\x6c\xc1\xbb\xb2\x99\x42\x40\xc4\x07\
\x07\x07\x0d\x5d\x95\x45\xa4\x07\x9d\xf4\xf6\x22\x96\xd6\xbb\x57\
\x15\x6c\x59\x60\x12\x08\xe4\x81\x40\xa7\xf5\xe6\x4d\xe1\xb6\x86\
\x78\xbf\x05\x3e\xad\x9c\x07\xf2\x82\xa2\x00\xa8\xf1\x36\x81\x16\
\x02\xce\x79\xc2\xd8\x24\x91\x00\x24\x22\x2c\x5e\xe6\x2c\xab\x7d\
\x8b\xad\xeb\x53\xe4\x45\x89\x8e\x49\x80\x05\xba\x4c\x16\x46\xa0\
\xad\x64\x21\xa4\xe2\xb9\x30\x2e\x14\x26\x41\x56\xcb\xab\x72\x12\
\x8f\x27\x13\x3e\xf1\x00\xc3\xdd\x1e\xe7\xb9\x4b\x4e\xf6\xf2\x8e\
\x34\xce\x9b\x72\x24\x10\x18\xe7\x85\x44\xa0\x4d\x01\xb7\xda\xc1\
\xad\x1d\xe0\x9b\x6b\x8e\x00\xa7\x4f\x9e\x07\xfb\x70\xbb\x22\xb0\
\xf7\xd6\xd6\xf6\xa9\xef\x7c\xf7\x87\x08\xff\xea\x57\x3f\xb4\x5a\
\x40\x8c\xd1\x7c\x70\x65\x59\x06\xa5\x83\xe6\x7f\x76\x55\xb8\x58\
\xde\x8d\x1b\xa3\xfb\xe0\x95\x41\x57\xab\x5a\x05\xba\xb3\xe1\xe5\
\xaf\x85\xe5\xd5\x3a\xcf\xde\x1f\xed\x6e\xe3\xea\xce\x65\x72\xfc\
\x0d\x22\xf0\x33\xef\xfd\x87\x5e\xf8\xe7\x4b\x20\x89\x23\xbd\xa0\
\x62\xb0\x9d\x4e\x16\xff\x69\x35\xae\xa3\xcd\x18\xd2\x06\xf9\xd2\
\x15\xec\x1f\x39\x09\xd3\xe9\xa1\xd3\x20\x7f\xfb\x34\xfc\xc2\x93\
\x59\xd6\x9e\x3b\xea\xd1\x44\x61\xb0\xf7\x2a\xec\x60\x40\xaf\xea\
\x7f\x4a\x04\x7e\x1c\x64\x2b\xc8\x57\x82\xf4\xeb\x9b\x3a\xbd\xb0\
\x0d\x19\x26\xa3\xd1\x76\xb0\x5a\xda\xeb\x95\x8f\x3f\x79\xa6\xe7\
\xd1\xcd\x8d\x00\x56\x77\x9c\xff\xed\xea\xe4\x85\x08\x47\xa0\x28\
\x0c\x2e\x6f\x6d\xbe\x50\xbc\xf6\x0a\xe1\xfe\xc5\xff\xec\xff\x95\
\x78\xe0\x1b\xbf\xdf\xec\x19\x77\xcf\xfa\x21\x85\x77\x3a\x04\x93\
\xac\x49\x4a\x07\x5c\x9f\x18\x6f\x1d\x3e\xf6\xfa\x4f\x3e\xfd\xe7\
\xb8\x07\x5a\xde\xd5\x00\xcc\x4d\x44\x2f\xd0\xfa\x9e\xaf\x3e\xb3\
\xaf\x3a\x06\x13\x8d\xc6\x49\xfc\xdf\xe6\x3e\x23\x17\xed\x11\x08\
\x78\x4c\x8b\x0e\x35\x8e\x9b\xf2\x48\x29\xa0\x3b\xb4\x16\x7d\x67\
\x32\xba\xf2\xda\xcb\xc5\xd1\x53\x0f\x0d\x73\xa5\xf1\x7f\x1c\xde\
\x4f\x76\x2f\xff\xe9\x47\x7b\x4a\x3d\x45\x38\xcb\x98\x42\xad\xfc\
\xd6\x34\x15\x0f\x37\xbc\xde\x96\x8c\xb4\x39\xf9\xfe\x15\xd3\x59\
\xea\xc2\x7b\xe3\xbd\x57\x80\x35\xe0\xa1\xe9\xe0\x70\x4a\x05\xad\
\x8d\x65\xad\x82\x36\x99\x85\xee\x94\xa4\x95\xe9\x5a\x64\x5d\xab\
\xb2\x9e\x55\x9d\x25\xa7\xb2\xae\x53\x9d\xbe\xd3\x4b\x6b\x56\xf7\
\x96\x9d\x59\xb9\xcb\xa9\xee\x21\x3f\x2a\xfa\x07\x83\x9f\x7f\xa1\
\x44\x1c\xff\x01\x5e\x39\xdf\x3d\x6a\x46\xfd\x26\x00\x00\x00\x00\
\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x05\x76\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\xf3\x49\x44\
\x41\x54\x78\xda\xed\x57\x5b\x6f\x54\x55\x18\x5d\xdf\xde\xe7\xcc\
\x99\x76\xa6\x94\x72\x1b\x2e\x4a\x2d\x8d\x09\x15\xd4\x49\x8c\x80\
\x0f\xde\x48\x15\xd2\x48\x19\x48\x4a\x79\x30\xa8\xf0\x20\x09\x4f\
\x3c\xa9\x31\x11\x8d\x0f\x90\xf4\x55\xf1\x07\x98\x18\xaf\x11\x31\
\x31\x51\x1f\xe4\x09\xe1\x41\x2c\xd1\x98\x46\x2a\x81\x70\x4b\x43\
\xa7\x73\x3d\x33\x73\xe6\x5c\x3e\xf7\xec\x73\x92\x99\xa6\x17\xb9\
\x4c\xa2\x0f\xae\xd3\x95\xef\xec\xbd\xa6\x59\xeb\x7c\xdf\x9e\xc9\
\x0c\x31\x33\xfe\x4d\x08\xc5\xff\x56\x00\x7a\x9d\x24\x0d\x91\x81\
\x08\x8b\xe8\xed\x0f\x40\xfb\x48\xe2\x16\xc6\x77\x6e\xd9\x79\x93\
\x86\x69\x07\x14\x16\xd4\x5f\x52\x7a\xdb\x3b\xe0\x62\x09\x80\xcd\
\xc3\x4f\x0f\xaf\x8c\x9b\xf1\x53\xb4\x8b\xde\x98\x4f\xdf\x3f\xb4\
\x7f\x65\x67\x47\xa7\xd6\xdb\x1b\x20\xda\xc9\x79\x39\x1c\x1d\x39\
\x1a\x5f\xdb\xb3\xf6\xb8\xea\xc4\xa7\x94\xa6\x18\x5a\x50\xe9\xa8\
\xe0\xd8\xe1\x63\xf1\xde\x54\x6f\x53\x6f\x5b\x00\x0b\x28\x14\x0b\
\xf0\x2d\x1f\x07\x32\x07\x28\xdd\x9f\x1e\x45\x2f\xce\xd3\x6e\xea\
\x43\x84\x42\xa9\x00\x24\x81\x23\xaf\x1e\xa1\x2d\x03\x5b\x46\xb1\
\x5e\xe9\x23\xd4\xdb\xb6\x00\x76\xd5\x46\xb9\x52\x86\xed\xd9\xd8\
\xfe\xcc\x76\x0c\x6e\x1d\x4c\x43\xe2\x1c\x80\x41\x10\x50\xaa\x96\
\x50\xae\x2a\x3d\xb0\x91\xd9\x95\x41\xe6\xd9\x4c\x1a\x0e\xce\xeb\
\x73\xd3\x96\x00\x35\xbb\x61\xa0\x8d\xf2\xd5\x3c\xfa\x1e\xee\xc3\
\xde\x17\xf6\xae\xb2\x92\xd6\xc7\x0d\xbd\xec\x28\xad\xa6\x42\xd4\
\xca\xc8\x55\x73\x18\x48\x0f\xe0\xd0\x9e\x43\x29\x2b\x66\xe9\x73\
\xd1\x8e\x00\xda\xa0\xe4\x94\x42\x33\x55\x3b\x96\x76\x20\x33\x98\
\xb1\x56\xac\x5c\x01\xbb\x6e\x87\xfb\x91\x5e\xac\x15\xd1\x99\xea\
\xc4\xc1\x91\x83\xf1\xd4\xb2\xd4\x5d\x9d\x8b\x59\x9f\x84\xb4\x87\
\x7a\xb0\x01\x33\x43\x6b\x86\xe0\x0a\x17\x22\x26\x20\x4c\x01\x69\
\x4a\x08\x43\xdd\x4b\x75\x0f\x19\xae\xa5\x5a\x93\x22\xc2\x2a\x59\
\xea\x7b\x72\x09\x67\xce\x9e\xc1\xe4\xd5\xc9\x71\x98\xc8\xf0\x17\
\x7c\x15\x8b\xc0\x98\xb7\x03\x9e\x0d\x87\x1c\x08\x8a\x0c\x49\x22\
\xb4\x8a\x42\xf8\x6a\x1d\xa8\x7b\xa1\x88\xf0\x35\x82\x75\xd5\xfb\
\xdb\xb6\x6e\x43\x22\x99\x48\x5f\xbc\x74\xf1\xbc\x7a\xa8\x57\xf8\
\x6b\xfe\xfe\x8e\x03\x90\x29\x50\xf5\xaa\xa8\xa0\xa2\x0d\xa4\x94\
\x10\x7e\x64\xe6\x6b\x93\xd0\x54\x44\xfb\x88\x9e\x9e\x45\xc8\x40\
\xad\x03\x89\xfe\x0d\xfd\x88\xc7\xe3\xa9\x5f\xfe\xbc\x70\x8a\x46\
\xe9\x3d\xfe\x8c\x4f\xdc\xd1\x08\xc4\x13\x72\x66\x93\xff\x08\x8a\
\x5c\x84\x8c\x4b\x08\x4b\x34\x47\x61\x48\x4d\x1d\x86\x66\x3f\xbd\
\x08\x34\xc3\xee\xf8\x51\xf5\x04\xec\xa2\x8d\x0b\x97\x7f\xe5\x8a\
\x5d\xf9\x12\x13\xfc\x32\x8f\x73\x7d\xf1\x00\x5b\xe5\x4c\x5f\xed\
\x21\xe4\xfd\x3c\x44\x87\xd0\x01\xa4\x25\xc3\x6a\xe8\xd9\x87\xa4\
\x96\xd6\x07\xda\x54\x53\x7a\xa1\xb1\x70\xa3\xb5\x2b\xc1\x2e\x63\
\xe2\xd6\x04\xa6\x8b\xd9\xdf\x10\xf0\x30\x7f\xc2\x57\x16\x1e\x81\
\x21\x50\xf1\x2a\x30\x62\x06\xc8\x24\x4d\x36\x18\x30\xa1\x2b\x4b\
\xd6\xb5\x81\x40\x5d\x8d\x3f\xf6\x59\x07\x21\x9f\x50\x0f\xea\x20\
\x8f\xc2\x40\x75\x1d\x40\x07\xea\x5f\xd2\x8f\x55\xc9\xd4\xa3\xd9\
\x5a\xf6\x0c\xed\xa3\x7e\xfe\x9c\xfd\xf9\x03\x08\xc2\xed\xfa\x6d\
\x78\xea\x82\x04\x20\x10\x56\x17\x4d\x04\x8a\x1c\x55\x4f\xb1\xae\
\xe8\x00\xd2\x51\x66\x8e\xd0\xe4\x0a\x6b\xfa\x65\x1f\xb0\x01\xaa\
\x92\x3a\x9c\x4f\xe1\xb9\xc7\x9f\x4f\x9c\xfc\xe6\x83\xc5\x0e\x21\
\x01\x9a\x00\x62\x8a\x96\x62\x3c\xaa\xb1\xe8\x3f\x44\x14\xc0\x8f\
\x82\x09\x68\xf8\x81\x0f\xdf\xf3\x31\x0b\x04\x58\x09\x0b\xc6\x83\
\x31\x9c\x9d\xfa\xf9\x8f\xab\xce\x95\xdd\xfa\xe9\x17\x0c\x20\x04\
\x10\xb6\x3c\x0a\xa1\xd9\x0c\x61\xb6\x04\xf0\x14\x65\x4b\x57\xfc\
\x68\xcf\xd0\xd4\x5a\xb2\xa7\x0b\x5e\x3c\x60\xbb\x54\xfe\x16\xe7\
\x78\xe4\xda\xf8\xb5\xfa\xe2\x9f\x03\xa4\x28\x23\x1a\x9a\x73\x43\
\xc8\xc8\xd0\x55\xa4\x96\x51\xb8\x5a\x6b\x8e\x6e\x39\xa1\x56\xaf\
\xd7\xbd\xa2\x7b\x9c\x3f\x0a\xde\xc5\x1c\x2c\x70\x06\xd0\x20\x35\
\xe7\xaf\x69\xb6\x84\x30\x23\xd3\x5a\x33\x48\x64\xaa\x69\x1a\x26\
\x5c\xe9\x03\x2e\xcd\x78\x45\xef\x35\x3e\xe9\x9f\xbe\xf3\xaf\x64\
\x24\x40\x20\xb4\xa2\x35\x4c\xa7\xe8\x84\x91\x30\x00\xab\xe5\x3c\
\x90\xa6\x46\xc2\x48\x20\x29\xba\x01\x16\x13\x28\xfa\x4f\xf2\x49\
\x4f\x9b\xdf\x45\x00\x02\x31\x01\x01\x66\xd3\x07\xba\xaa\x4b\x10\
\xbf\x90\x84\xe9\x99\x7a\x1d\xb2\xf9\x9a\x65\x62\x39\xc8\x36\x39\
\x97\xcf\x7d\x87\xdf\xbd\x34\x7f\xc8\x97\xf1\x0f\x30\xe6\x0b\x00\
\x8f\xc2\x68\x5e\xcb\x6c\xb3\x02\xb5\x19\xd7\xf5\x01\x93\xca\x14\
\xee\x39\xe1\x5b\x90\x5c\xc2\x1a\x7f\x1d\xb2\x53\x39\xd7\x29\x56\
\xc7\xf8\x84\xff\xf6\xbd\x7f\x2b\x66\x01\x6a\x04\xa8\x43\xd3\xf4\
\x4d\x20\x2f\x81\xdb\xa2\xe0\xde\xa8\x1f\xd2\x23\x2a\x11\x50\x02\
\x60\x03\x96\x63\x61\x9d\xbd\x1e\xb7\xae\x4f\xe5\x9d\x5c\x6d\x74\
\x8e\xf9\x3d\x75\xc0\x0d\x47\xd0\x95\xec\x82\x25\x12\x98\xae\x66\
\xff\x42\xce\xdd\x89\x4b\xc8\xd2\x03\x0d\xf3\x30\x60\xb7\xba\xe2\
\xb9\x24\xae\x67\x6f\x4e\x2a\x7d\x07\x8f\x35\x5b\x7e\x1f\x1d\x20\
\x90\x43\x48\x75\xad\x86\x48\x5a\x3c\x6d\x4f\xff\x88\x9f\xdc\x4d\
\xfc\x3e\x4f\x6a\xbd\x71\x15\x09\xab\x9d\x35\xa0\xa9\x18\x4f\xcd\
\x4c\xfd\x80\x73\xee\xe6\xa6\xf9\x7d\x06\x40\x40\x78\x6c\x60\x23\
\x0a\xdd\xb6\x5b\x28\xe5\xc7\xf8\xa8\xfb\x22\x9f\x66\x67\x96\x1e\
\xdf\x88\xfc\x74\xd9\xcd\x17\x72\x63\xfc\x96\xbb\x43\xeb\x2d\xb8\
\xf7\x11\x98\x28\x94\xfd\xd2\xa5\xec\xd2\x1b\x3d\xb5\x6b\x95\xc3\
\xfc\xa6\xf7\xd5\x1c\x9d\x95\x5e\x51\x7a\x49\xe9\xef\x28\xfd\x3e\
\x31\xe7\xc7\x29\x29\xf0\xec\xcd\xf9\xf5\x36\xe1\xff\x5f\xc7\x7f\
\x03\x1b\xd0\x4d\xac\x4b\x27\xdc\x0c\x00\x00\x00\x00\x49\x45\x4e\
\x44\xae\x42\x60\x82\
\x00\x00\x05\x54\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\xd1\x49\x44\
\x41\x54\x78\xda\xed\x97\x5b\x6c\x14\x55\x1c\xc6\xbf\xff\xec\x99\
\x9d\xdd\x99\x2e\x45\xb6\xed\x96\xd2\xb4\xdc\x1e\x0a\x52\x58\x40\
\x2a\x09\x09\x90\x40\x00\x2d\x02\x92\x52\x82\x21\xc1\xc4\x07\x09\
\x09\x0f\x26\x46\x34\x4a\x24\xf2\x80\x09\xbe\xe1\xed\x51\xd4\x27\
\x1f\xb4\x36\xc6\x07\x89\x97\x47\xde\x34\xc6\x44\x13\x11\x4d\x24\
\xc0\x12\x64\xb7\xbb\x3b\xdb\xd9\x99\x39\xe7\x38\xb7\x70\xd2\x2e\
\x97\xac\x6d\x62\x62\xdc\x93\x2f\x93\x99\xef\xec\xf9\x7e\xfb\xff\
\x9f\xdd\x9c\x25\x29\x25\xfe\xcd\x97\x16\xe8\xbf\x01\x40\x4f\x12\
\xa3\xe7\x29\xd5\x86\x3f\x7f\x00\xb4\x97\x76\x83\xe1\xf7\xe3\xc5\
\xe3\x7f\xd0\x78\x6b\x08\xed\x6b\xf1\xe7\x0f\x80\x9e\xa2\x53\x66\
\xd6\x9c\x38\xfd\xec\xe9\xfe\x46\xb3\xd1\x0f\x0f\x0b\x66\xfb\x99\
\x74\x66\xe2\xe4\xbe\x93\xf7\xf4\xd9\x3f\x0e\x2e\x52\x1a\x03\xf8\
\x70\xb0\x30\x38\x7e\xe2\xc8\x09\xb2\xba\x2c\x9c\xfd\xe0\x2c\x90\
\x9a\xe9\xf7\x2d\xea\x1b\x3f\x36\x7a\x8c\xb2\x0b\xb2\xb8\xf0\xfe\
\x05\x80\x80\x39\x03\xd0\x21\x1a\xc4\x00\x26\x46\x56\x8d\x14\xc7\
\xf6\x8e\x41\xea\x12\x35\xbb\xa6\xfc\xfd\xb4\x0c\x83\xf8\xb4\xb8\
\xbc\x58\xdc\xb3\x75\x0f\x38\x71\xd4\xed\x3a\x60\x00\x70\xe7\x04\
\x90\xf4\x13\xb8\x78\x60\xeb\x81\xc2\xc8\xe6\x11\xd8\xdc\x86\x98\
\x16\xe0\x82\x23\xf9\x74\x3b\x91\xc2\xdb\x3b\x37\xed\xec\x59\xbb\
\x6a\x2d\x6c\xcf\x06\xf7\x39\x88\xd3\x5c\x00\x54\x3f\x8d\xb4\x71\
\xe6\xe8\xe8\xd1\x4c\xcf\x40\x0f\xca\x8d\x32\x84\x14\xe0\x92\x43\
\x08\x11\x05\x18\x86\xf1\xd1\xe8\x96\x51\x23\xdf\x95\x47\x65\xba\
\x02\xe1\x8b\x48\x9a\xd0\x62\x80\x5a\xdb\x00\xaa\x9f\x85\x47\x0a\
\xe3\x07\x9f\x38\x48\xac\x83\xa1\xea\x54\x55\x78\x70\x95\x52\xa2\
\xab\xbb\x0b\x3b\x1e\xdf\x61\xb0\x34\x43\xad\x59\x83\xe0\x81\xef\
\xf2\x08\x80\x09\x16\x03\xa0\x2d\x80\xa4\xdf\x4b\x31\xb1\x72\x60\
\x65\x71\xfb\xe6\xed\x70\x75\x17\x4e\xd3\x89\xfa\x2a\x20\xa2\xf0\
\x68\x08\x81\x6d\x5b\xb6\xa1\x19\x8c\x69\x6f\x3a\x0e\xf7\x39\x84\
\x27\x22\xe9\x42\x6f\x1f\x80\x9e\xa6\xdd\xd0\x71\x71\xdd\xaa\x75\
\x85\xe1\xd5\xc3\xb0\x85\x0d\xe1\x0a\xf0\x60\x08\x12\x0a\x22\x1c\
\xaa\x15\x61\xf8\x5d\x00\xee\xc5\x10\x06\x8c\xf6\x00\xe8\x30\xbd\
\xcc\x2c\xfd\xf5\x8d\x2b\x36\x64\x96\xf4\x2d\x41\xcd\xa9\x81\xa7\
\x38\x84\x26\x42\xc5\x00\x5a\x08\x92\x84\x23\x0e\xe7\x62\x06\x44\
\x7c\xcf\x63\x48\xd2\x35\x48\x88\x16\x80\xd6\x7e\x0f\xd1\xc7\xa6\
\x65\x8d\x6d\x18\x5c\x4f\x56\xce\x8a\xc3\x19\x87\x60\x49\x68\x4a\
\xc4\xc2\xbd\xab\x90\xec\x8b\x18\x44\xc4\x95\x20\x22\x90\x4e\x90\
\x0f\xaa\x00\x3d\x43\x4b\xb1\x86\x26\xbb\x3a\xf2\xc3\x43\xdd\x43\
\x20\xa2\x28\x5c\xe8\x42\x2d\xc6\x54\x20\x47\x58\x91\x04\x82\x44\
\xa2\xe4\x39\x92\x96\xf0\xf8\x7d\x4c\x63\x2a\xed\x5e\x00\xe1\x6f\
\x74\x4f\x6f\xe1\xbb\x6e\xbd\x7b\xb0\x43\x58\x68\xba\xcd\x19\xbb\
\x3c\x1c\x92\x24\x88\x11\xa4\x26\xa3\x0a\x48\x26\x23\x00\x68\x88\
\x3c\x29\x03\x09\x79\xf7\x5e\x93\x1a\x08\x14\x5d\x1b\x6e\x03\x94\
\x0e\x0c\xf0\xfb\x57\x60\xd7\xda\x5d\xd9\xd2\x8d\x12\xbe\xb9\xf4\
\x35\x64\x56\x02\x26\x90\xca\xa5\x40\x26\x81\x2c\x82\x30\x04\x44\
\x46\x80\x1b\x1c\xc8\x20\xde\x54\xe9\x64\x15\x2d\x10\x05\x92\x51\
\x86\x92\x17\x8b\x79\x0c\x64\x6a\xf7\xaf\x80\xfc\x44\xf2\x9e\x17\
\x7b\xb6\xdc\xae\xdf\xf9\xdc\x1c\x36\x57\xfb\x37\x5c\x34\x29\xaa\
\x42\x32\x21\x09\x61\x49\xa8\x01\x05\xa1\x07\x4a\x25\x00\x22\x90\
\x1f\xc8\x4d\xe6\xcb\xf8\x19\x49\x02\x74\x7a\xf0\x79\xe0\xd6\x5b\
\xb7\xae\xc8\xcb\x7c\xbd\x2d\xea\x93\xb4\x82\xc9\x8e\x7c\x2e\x5c\
\x38\x16\x4b\xa4\x87\x00\xb3\x20\xb2\x81\x4c\xa5\xe8\x3e\x03\x35\
\x4f\x47\xb4\x01\x49\xd3\x1e\x7e\x20\x91\x3f\x48\x57\xbe\x27\xf6\
\x3b\xf6\xf4\x1b\xce\x22\xd7\x45\x2f\x85\xb3\x62\x29\x18\x05\x62\
\x40\x01\x58\xe1\x75\x56\x38\x83\x12\xb5\x71\x22\x92\xef\xf2\x33\
\x7e\xd5\x3f\x04\xd2\xee\xc0\xd4\xa0\x33\x3d\x5a\x40\xc1\xcc\x6a\
\x87\x39\x2b\x5c\x87\x02\xd6\x10\x7f\x0d\xb5\x87\xb4\xa0\x15\xc2\
\x9f\x44\x95\x6f\x42\x4a\xfb\xa5\xc3\xea\x84\xa5\x5b\xca\xa4\x50\
\x6a\x5f\xb0\x0c\x83\xc9\x4c\x20\xad\x42\xa1\xf2\x62\x00\xd2\xda\
\x3f\x13\xca\x77\xe4\x55\xfc\xe4\x17\xcb\xd5\xf2\x97\x24\x75\xb9\
\x48\xcf\x03\x02\x4a\x3c\x96\x2e\x74\x64\x2e\x77\x20\x57\x5b\xa0\
\x9e\x0b\x25\x12\x21\x40\x7b\x15\x50\x10\x93\xb2\x29\xcf\xf9\xa3\
\xf5\x4a\xf5\x9c\x3d\xe5\x78\x7d\xac\x1f\xe4\x11\xe0\x25\xbb\xdd\
\x01\xc8\x26\x38\x0d\x07\xce\xf7\x9e\x87\xeb\x5a\xe8\xc5\xf2\x43\
\xcd\x0d\x40\x81\xbc\xc9\x5f\x6d\x96\x9d\xc3\x37\x4a\xa5\xca\x12\
\x3e\x00\xc3\x35\x80\x69\x00\x36\x40\xf5\xb8\xc4\xde\x35\xf7\xb9\
\x00\x60\x0a\x37\x53\xd0\x5d\x3d\x04\x0c\x15\x01\x93\x6c\xbf\x05\
\xad\x10\xe7\xfd\xcf\x64\xd9\xdb\x78\xad\x74\xfd\xca\xc2\x6a\x17\
\x3a\x9b\x9d\x40\x1d\xa0\x1a\x21\x1c\xf8\x95\x7f\x81\xb2\xff\x18\
\x1a\xda\x6f\x9d\x5e\x1e\x39\x91\x03\x9a\x00\xb9\xf3\x50\x01\x05\
\x21\xaf\xe2\xb2\xb7\xa6\x54\x29\x7d\x45\x77\xd2\xb2\xd7\x5b\x0c\
\x2d\x06\x88\xfd\xb3\xf2\x0a\xbe\xf5\x1e\xbd\x5d\xbf\x7d\x49\x63\
\x86\x2c\x64\x7b\xa1\x85\x00\x72\x7e\x00\xd4\xbe\x78\xc5\xdb\x5d\
\x99\x2a\x9f\xaf\xfc\x55\xf7\x96\xa5\x96\x23\x9f\x31\x67\xfa\x2f\
\x78\xbb\xa6\x6a\x95\xf3\x53\xa6\xed\x2d\xeb\x0f\x7c\xc3\x9c\x37\
\x00\x15\xf4\x9a\x77\xca\xa9\x35\x8e\xfc\x78\xf3\xe7\xd2\xe2\x85\
\xc6\x9f\xd0\x31\x35\xc3\x7f\x29\xf0\xab\x81\x2f\x02\x3f\xd7\xea\
\xcf\xeb\x9f\x53\x22\x0a\xd7\x93\xed\xf8\xff\xff\x3b\xfe\x1b\xdc\
\xe5\x9d\xe5\x05\xbf\x9b\xcd\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x07\xc4\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x02\x73\x42\x49\x54\x08\x08\x55\xec\x46\x04\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\x01\xb7\
\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x43\x49\x44\x41\x54\
\x78\xda\x9d\x58\x5b\x6c\x1c\x45\x16\x3d\xdd\xd3\x33\x9e\x97\x4d\
\x88\x81\xb5\xc7\x42\x2c\x02\x85\x97\x78\x09\xdb\x08\x08\x0a\xda\
\xc8\x42\xbb\x82\x10\xe5\x83\x20\x1e\x7f\xfe\x23\x12\x91\x30\x4f\
\x45\xc8\x8a\xa2\x80\x56\xde\x8f\xfd\xe0\x67\xd7\x08\x04\x04\xe2\
\xec\x4f\x78\xee\x87\x37\xcb\xcb\xe2\x11\x22\x9e\x02\x0b\x14\x04\
\x52\xb0\x63\x21\xa2\x10\x67\xc6\x33\x93\x99\xee\xe2\x70\xba\xaa\
\x95\xc6\x93\x78\xb3\x75\x54\xe3\x19\x77\xdf\x73\xee\xad\xba\xb7\
\xaa\xba\x3d\x83\x95\xda\x53\x05\xac\x37\x6b\x31\x80\x8a\x3a\x30\
\x8f\x39\xb0\x7b\x33\xd8\xf7\x68\x7d\x25\xeb\xd3\x0a\xec\xec\x35\
\x1b\x71\x3b\x46\x50\x34\x00\xcc\xc9\x66\x71\x5f\xc2\x34\x5e\xf3\
\xf6\x3e\x7e\xe4\xff\x10\xd8\x51\x32\x63\x18\x43\xd9\x90\x38\x82\
\xfb\x74\xf4\x3e\xbb\xfb\x44\x15\x13\xde\xc4\xb6\xda\x19\x08\x6c\
\xcf\x98\x51\x8c\xa3\x2f\x02\x81\x90\x68\xb3\x47\x92\x10\x3d\x91\
\x41\x80\x0c\xe1\x0b\x58\xc0\xb8\x37\xf9\x44\xf8\x3f\x09\x8c\x57\
\xcc\x5e\x0c\x19\x11\xb7\x88\x13\x44\x0b\x05\xe4\xd9\x8b\x00\x96\
\x50\x47\x83\x3d\x8b\x1c\x91\x25\x28\x44\x59\x7c\xec\x6d\x1c\x9f\
\x5f\x51\xe0\x89\x61\xd2\xf7\x47\x68\x8b\xb8\x41\xea\x73\x70\x3e\
\x2e\x42\xc9\x7a\xcb\xa6\x58\x8e\xe3\x20\x0e\xe1\x67\xd2\xe7\x25\
\x14\x80\xd7\x0e\x7b\x1b\xb7\xef\x3f\xad\xc0\xb6\x7b\xcc\xa4\xc9\
\x87\xf2\x7b\x89\x7d\x0d\xae\xa3\xd7\x79\xa2\xcb\xf9\x29\xfa\xb6\
\xee\x68\x51\x66\x3f\xbe\x25\x7d\x51\xb1\xf0\x7a\xc3\x1b\xdd\xb1\
\xeb\x94\x02\x8f\xdf\x8b\x17\x8c\x8c\xeb\xa8\xd2\xef\x61\xac\xa6\
\xe7\x3d\xa4\x0f\xe0\x09\x80\x91\x84\x91\x48\x13\x0d\xf6\x9f\xf0\
\x3e\x63\x29\xa3\x80\xac\xee\xc3\x7d\x3b\x5f\xec\x28\xf0\xd8\xb0\
\x79\xc7\xe4\x39\x34\xa8\xd1\xf0\x26\x5c\x4a\xa3\x55\xec\x19\x02\
\x2e\x63\x24\x41\x48\x40\x22\x8c\xb4\x81\x4f\x31\x43\x37\x4a\x1a\
\x2a\x46\xb1\xee\xc9\xfd\xcb\x04\x1e\xad\x98\x03\xa6\x3f\xa4\x41\
\x8d\x86\x23\xf4\xff\x5c\xf4\xd0\xc0\x17\x2c\x3d\xbb\x49\x49\xc4\
\x58\x22\xbe\xc3\xbf\x79\x57\x49\x43\xe9\x1d\xf6\x06\x9f\x9a\x4f\
\x09\x3c\x9c\x31\x1f\x60\x28\xf6\x3e\xc4\x26\xf4\xa2\x1f\xdd\x4a\
\x44\x4b\xcf\x0e\x49\xc0\x49\xd8\x14\xe6\x80\x12\x0d\xda\x1d\xc6\
\x6e\x64\x6c\x14\xcc\xa8\x1b\xfe\x1a\x42\x91\xab\x45\xa3\x66\x28\
\x04\xc7\x9e\xb8\x95\xf4\x15\x9c\xa5\x04\x0c\x12\x64\x92\x5f\xd9\
\x14\x72\xe8\x22\x0a\xe8\xa6\xcd\x6d\xb2\x6f\x51\xd6\x0c\x45\xa3\
\x27\x45\xf0\x60\x09\x07\xa3\xbe\x36\x2f\x1e\xc3\x3a\x5c\x29\xfa\
\xcf\x71\x0d\x0a\x8a\xc0\x55\xac\x6d\xa9\x28\x42\x21\xce\xa9\x06\
\x73\xea\x23\xfc\x97\xb6\x05\x30\x69\x17\x70\xf1\xdf\x6a\x36\x82\
\x68\x2c\xea\x0b\x35\x5d\x17\xe0\x32\x9c\xc7\x5b\x02\x06\xfc\x1f\
\xcc\xa9\x62\x29\xe2\x96\x86\x65\x60\x3c\xea\x39\x45\x52\xc2\x20\
\xfe\x48\x96\x26\x45\xa3\xbe\x68\xcc\x0e\xd1\xd6\xde\x68\x8c\x3e\
\xa0\x49\xdc\x88\x1e\x9c\xad\x81\x00\x7f\xbd\x8b\xb7\xd0\xb0\xe4\
\xa9\x18\x52\x72\x94\xb0\x22\x79\x14\xb1\x5e\x3c\x2d\xb4\xe9\xf6\
\xd6\x5e\x80\x4c\xe6\x0e\x53\x8e\x34\x51\x57\x60\x35\x11\x97\x7e\
\x5c\x0f\xdf\xe0\x3b\x9a\x5c\x8a\xce\xed\x41\x84\xa8\x23\xa2\x45\
\x37\xb6\x69\xda\x0b\xf8\x03\x87\x78\x16\x59\xd0\xad\x32\x36\xe0\
\x59\x46\x10\x6e\xe0\x28\xaa\x2e\x87\x19\x64\xb7\xf5\xab\x6d\xd7\
\xa1\x63\xd8\x43\x74\x5c\x2a\xb5\x60\x1c\xc1\x02\x7e\xc4\x21\x39\
\x15\x10\x05\xac\x93\x5d\x9b\xe2\xe1\x1d\x80\xbf\xa5\x60\x46\x98\
\x6e\xfc\x57\x1f\xe9\x57\xdb\x35\xd2\x8b\x27\x4e\x68\xb2\x8c\x26\
\xf0\x45\x27\x05\xd5\x72\x5d\xf5\xec\x04\x72\x2c\xce\x7e\x5a\x85\
\x94\x37\x23\x5b\x0a\x7e\xb4\x3e\x2a\x86\x9a\x81\x0b\xa9\x5e\x4e\
\xb2\xbe\x25\x38\x91\xa3\x78\x06\xcf\xa1\x8a\x74\x6b\xa5\x05\x12\
\x89\x35\x9a\x05\x4a\x14\xa3\xf5\x7e\xb4\xd6\x50\x8b\x12\x58\x43\
\xda\xa6\xdb\x4e\x52\x8b\x75\x53\x9f\xfb\xb1\x03\x9f\xa5\x05\x88\
\x58\xe0\x84\xdb\x25\xd8\x73\x9c\x05\xd1\x83\xcc\x6b\xfd\x68\x20\
\xa6\x2a\xa1\x4c\xf5\x36\x1a\xbc\xe0\xd9\x21\xb2\xf3\x60\xd1\x66\
\x1c\xff\xc0\xb3\x27\xc5\xa1\xdc\x93\x40\x4b\x02\x92\x20\x56\xa1\
\x24\x09\x8a\x0c\x04\xa6\xa2\xa2\xb7\x8b\x9a\x7c\xa7\x61\x17\x16\
\x91\x11\x81\xa8\x55\x58\xa1\x16\xbd\x03\x38\x88\xcd\xb8\x4a\x02\
\x1a\x5a\xb9\xd4\x4a\x96\x43\x89\x50\xe0\xb8\x22\x40\x25\x30\x03\
\x71\x45\x96\x74\xc1\xb3\x30\x2c\xb3\x02\x7a\x51\x82\xa7\x09\x33\
\x6e\x35\x22\x16\x39\x1b\x83\xcc\xc0\xb2\x52\xb9\xa9\x0c\x6b\xcb\
\xc6\x59\x67\x78\xed\x17\x18\x02\x2e\x02\x83\x72\xba\xa0\x48\xfa\
\x13\x7e\x50\x96\x17\x59\xd9\xdd\xf1\xb6\x23\x99\xb6\xe2\x98\xc5\
\x26\x2c\xa1\xc6\x5e\x65\xbc\x11\xd4\x12\x86\x6e\x98\x24\x02\x58\
\xe8\xb2\xbb\xcd\xad\x97\x21\x09\x7e\xa6\x47\xc5\x04\x25\xfb\xd7\
\xd3\xd5\x88\x68\xc4\x54\x29\xfb\x84\x13\x81\x99\x37\x97\x80\xad\
\x2a\xd2\xb8\x99\x94\x3f\x4a\xdc\xe4\x77\xdc\x06\x71\x2f\xba\xed\
\xd5\x7c\x7c\x3d\x65\x7f\xdc\xfd\x9e\x0f\xcc\x9c\x04\xec\xa4\x38\
\x5d\x24\x39\x91\x13\x4d\x40\xb8\x19\x3a\x0b\xf7\xe3\xfa\xe4\x7c\
\x14\xa0\xc8\xee\x3b\x6a\x8b\x45\x27\x30\xc7\x08\xe2\x5b\x6b\x0a\
\x39\x91\x50\xd1\x64\x11\x02\x5a\xf8\xb2\x44\x2c\x72\x0b\xb6\xa0\
\x07\x6a\xba\x27\x87\x02\x7b\x20\x1b\x67\x1d\xa2\xea\x62\xfa\x2d\
\x02\xf9\x4b\xcd\x63\x34\x8c\xdc\x29\xce\xd6\xa4\x81\xaf\x09\x0c\
\x24\x71\x0e\x1e\xc1\x3a\x24\x4d\xff\xed\x82\x61\xcf\x02\xce\x92\
\x38\x4a\xb6\x1e\x1b\x81\xef\xcd\xb8\x50\x67\xd1\x8e\x8b\x43\x88\
\xd7\xf8\xbc\x50\xd0\xb1\xe5\xcf\x78\x49\xf4\x29\x01\x7b\x35\x2b\
\x6a\x42\x0c\x9f\x6b\xd0\xb4\x87\xcf\x04\x66\x9f\x59\x42\x91\xa3\
\xcd\x02\xba\x99\x39\xdf\x65\x25\xe8\xbd\x32\x3a\x50\x65\xf7\xd2\
\xf7\x3f\xe1\x77\xcd\xee\x01\xbe\x5c\x91\x80\x6c\x4f\xe0\x6b\x95\
\x2c\x40\xe6\x7d\xfe\xf3\x75\x33\x0d\x4d\xe3\x21\x2c\xaa\x6a\x15\
\x87\xdd\x6b\xe9\x1f\xf1\x17\x4c\x75\xa0\x87\xee\xb1\xf1\xb9\xcd\
\x93\x38\xc6\xfa\x09\xe2\x54\x9f\x7e\xbe\x4e\x21\xbc\x2a\x5f\xd9\
\xdf\x46\x33\x91\x10\x3d\xd1\x87\x9d\xd8\x8e\x55\xe8\xd4\x7c\xed\
\x61\x65\xc1\xd2\xd3\xfe\x4d\xcb\x66\x80\x57\xe2\x1d\xed\x15\xf3\
\x77\x94\x7d\x06\xfc\x09\x6e\x20\x6d\x0e\x6d\xde\xd0\xa5\x24\x1d\
\xc6\xa8\xc8\x3b\xb7\xa7\x93\x13\x12\x17\x46\x2b\x30\x87\x8f\x28\
\xab\x01\xaa\xe2\x55\xed\xc9\xbb\x8e\x98\x09\x7e\xd1\xc4\x4c\x6b\
\xf9\x6d\x11\x5d\xcc\x99\x07\xb0\x15\xdd\xa2\xe8\xdc\x5c\xd6\x88\
\x5c\x56\x75\xbc\x26\x26\x09\x4c\xec\x3a\x22\x01\xb6\x09\x2c\x40\
\x45\x35\x4b\xfd\x25\xad\xef\x57\xe0\x21\x5c\x4d\x93\xc8\x42\x32\
\x69\x6a\x41\xde\x27\x07\x97\x19\x7c\x81\x9c\x56\x5d\x32\xd2\x6d\
\x2b\xf0\x72\xcd\x8c\x7b\x3a\x5a\x15\xf0\x3a\xbe\x45\x0d\x4d\x6c\
\xe2\x8d\x34\x55\x8f\x4e\x09\x5d\x4f\xb6\xa5\x59\xfc\x4b\x47\x60\
\xcd\xc0\xf8\xcb\xb5\x44\x00\xf0\x26\xbd\x8f\x3d\x95\x56\xc0\x6c\
\x9f\x43\x15\x0d\x4d\x78\x4b\xd0\x08\xcb\x67\x07\x63\x07\x45\x10\
\x79\x83\x59\xf8\x4f\xcb\xe0\x81\x6c\x93\xbf\x3b\xfc\xde\x55\x81\
\x0e\xbf\x2d\xde\x1a\xe0\x6e\x5c\x86\x12\xf2\x6e\x81\xe8\x74\xfc\
\x95\x90\x26\x56\x36\x5f\x63\x92\xdf\x68\xa1\xc3\x2f\x06\x77\xa7\
\x0f\xbf\x92\xd0\xf1\x9d\x63\xaa\x2d\x7b\x03\x6e\x44\x51\x87\x40\
\x27\xe1\x2d\x3b\xc0\x93\x5e\xa8\xe3\x3d\x0e\x4e\x56\x4b\x86\xaf\
\xe3\xfb\xee\x65\xc7\x77\xb5\xcd\x7a\x00\x89\x94\xcd\x75\xc6\x70\
\x1b\xfa\xed\x52\xe6\x27\x12\x6c\x8e\xde\xde\x39\xc7\x74\xff\xd2\
\xdd\xa7\x07\x90\xa9\xce\x0f\x20\x92\xe0\x23\x14\xf2\x34\x24\x9a\
\x24\x18\xc2\xad\xac\x83\x1c\xd1\x41\x40\xc7\xb2\x37\xf0\x21\x7c\
\xfa\x1e\x88\x1e\x7c\x84\x9a\x3a\xf5\x23\x94\x24\x86\xb1\xd7\xf4\
\x9b\xa4\x2e\x0d\x2e\xc0\xe5\xb8\x16\x67\xdb\x03\x99\x67\x17\xe4\
\xa3\xf8\x14\x5f\xe1\x7b\x78\x14\x4f\x76\x8b\xc3\xd8\x38\x75\xfa\
\x87\x40\x49\x54\x28\x31\x44\x1a\x57\x42\xfa\xec\x41\x19\x3d\x04\
\xb0\x48\x54\xd9\x33\x96\x58\x03\xa3\xcc\x21\xfd\xca\x8f\xb1\x92\
\xe0\x83\xb8\x37\x6e\xfa\x24\xe2\xe0\x8a\x6d\xd9\x41\x5e\xe4\x0b\
\xac\xa4\xc9\xa9\xf0\x0c\x5e\x25\xdc\xc9\x57\x09\xde\x98\x29\x03\
\x26\x01\xac\x00\xbb\x85\xbe\x57\x0d\x5f\x25\xec\x39\x93\x57\x09\
\x89\x08\x5f\x86\x78\xb7\x9b\x11\x14\xb1\xec\x65\x88\xda\x92\x37\
\x6d\xf8\x32\x64\xcf\x19\xbf\x0c\x49\xcb\xd8\xd7\x39\x5e\x05\x03\
\xa6\x42\x93\x79\xcc\x19\xfb\x3a\x67\x4f\x7d\x25\xeb\x5f\x01\xa7\
\xd2\xc6\x24\x39\x1e\xf5\xa2\x00\x00\x00\x00\x49\x45\x4e\x44\xae\
\x42\x60\x82\
\x00\x00\x06\x9d\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x01\x73\x52\x47\x42\x00\xae\xce\x1c\xe9\x00\x00\x00\
\x06\x62\x4b\x47\x44\x00\xff\x00\xff\x00\xff\xa0\xbd\xa7\x93\x00\
\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\x01\
\x42\x28\x9b\x78\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xd8\x0c\x1e\
\x0d\x24\x2b\x12\x03\x72\xfa\x00\x00\x06\x1d\x49\x44\x41\x54\x58\
\xc3\xed\x97\x6f\x6c\x1c\x47\x15\xc0\x7f\xfb\xef\x76\x9d\xb3\x93\
\xb3\xe3\x18\xe3\x6b\xd2\xa8\x29\x69\x94\xd4\x82\x40\x09\x8a\x6d\
\xc0\xd0\x34\x8e\x23\x64\x55\xc6\x38\x50\x22\x35\x12\x1f\x1a\x89\
\x3f\x4d\x52\x24\x8a\x2a\x05\x11\xa5\xa9\x2d\x95\xb6\x08\x2a\x11\
\x10\x52\x90\x0c\xb2\xe4\x26\xa1\x11\xb8\x4e\x5b\xb7\x29\xa9\x5b\
\xd1\xb8\xa4\x55\xaa\x1a\x4c\x92\xba\x67\x7c\xf1\x25\xf6\xe5\xee\
\x6c\x9f\x77\xf7\x76\x76\xf8\x92\xdb\xdc\x05\xdb\xd8\x94\x6f\xf0\
\xa4\xf7\x61\xde\xdb\x37\xf3\xdb\x37\x33\x6f\x66\xe0\x7f\x5d\x94\
\xa5\x06\x6c\xdd\xba\x75\x83\xe7\x79\x2f\x9b\xa6\x19\x8d\x44\x22\
\x94\x94\x94\xe4\x5d\x03\x3d\x3d\x3d\x0d\x4b\xed\x4f\x5f\xca\xc7\
\x0d\x0d\x0d\x6b\x84\x10\x2f\x86\xc3\xe1\x54\x67\x67\x67\x34\x6f\
\xdf\xb2\x65\x0b\xbb\x76\xed\xaa\x9f\x2b\xe6\x85\x0c\x65\x33\x82\
\x8a\xb6\x72\x3e\xfc\x48\x00\x8d\x8d\x8d\xab\x84\x10\xa7\xa3\xd1\
\xa8\x57\x5f\x5f\xbf\x36\x1a\x8d\x16\x77\xa4\xeb\xf3\xa5\xf8\xcb\
\x39\xc9\x89\xa7\xaf\xd0\x33\xe1\xf2\xc8\xe3\xb7\x33\x56\xe8\x57\
\x17\x33\xf8\xb6\x6d\xdb\xca\x14\x45\xe9\xdd\xb0\x61\x43\xe5\xde\
\xbd\x7b\xab\x0d\xc3\x08\x57\x55\x55\x91\xd7\x05\x01\x14\xfe\x24\
\x24\x3f\x10\x92\x26\xc7\x67\x70\xcf\x30\x9f\x5b\x12\x40\x53\x53\
\x93\xa9\x28\xca\xef\x37\x6d\xda\x74\xf7\xa1\x43\x87\x22\x86\x61\
\x94\xd4\xd6\xd6\xfe\x6b\x2a\xe7\x01\x68\x2a\xe3\xfa\xee\x95\x3c\
\xe9\x48\x3e\xe9\xc3\xa4\xeb\xf3\xc2\x8e\x0b\xdc\xb9\x28\x80\x9d\
\x3b\x77\x6a\xaa\xaa\xfe\x6e\xdd\xba\x75\x8d\x1d\x1d\x1d\xa6\x65\
\x59\xfa\xc6\x8d\x1b\xa9\xab\xab\xc3\xf3\xbc\x40\x17\x02\xc8\xcb\
\x63\x51\x62\x8e\xe0\x5e\x1f\xb2\x8e\xcf\x89\x4f\x0d\x62\x2c\x08\
\xd0\xd2\xd2\xa2\x68\x9a\x76\xb4\xa6\xa6\xa6\xf5\xc8\x91\x23\x6a\
\x38\x1c\x56\x56\xac\x58\x41\x69\x69\x29\x63\x63\x63\x8b\x02\xe8\
\x9a\xe4\x27\x4f\x8c\xf1\xcd\x7c\xfb\xd9\x3b\x49\xb8\x3e\x0f\x4a\
\xa8\x15\x92\xbd\x0b\x02\x68\x9a\xd6\x51\x51\x51\xf1\xad\xc3\x87\
\x0f\x53\x5e\x5e\x0e\x80\xe7\x79\x24\x93\x49\x46\x46\x46\x70\x5d\
\x37\x50\x29\xe5\x9c\x00\x2a\xac\x75\x7d\xba\xf6\x0c\xf3\x70\xde\
\x76\x62\x23\xfd\x42\xf2\x9a\x2b\xd9\x5f\x35\x80\x1a\x44\x9d\x7e\
\x4c\x19\x50\x15\xea\x4a\x42\x12\xcb\x80\x67\x87\x23\x1c\x3c\x78\
\x90\xea\xea\xea\xa0\xc3\x5c\x2e\xc7\xe4\xe4\x24\x23\x23\x23\xac\
\x5e\xbd\x3a\xb0\x47\x22\x91\x39\x01\xa6\x1c\xda\x5c\xc9\xaf\x6c\
\x9f\x27\xeb\xcf\xf3\xe6\xc0\x66\xde\x02\xc8\xf9\x3c\x25\x25\xcf\
\x4b\xd8\x1a\x44\xd9\xc2\xac\x6b\x79\x62\x36\x08\x3e\x9a\xcb\xa1\
\x69\x1a\x9e\xe7\x21\xa5\xc4\xf7\x7d\x32\x99\x0c\x89\x44\x82\xeb\
\xd7\xaf\x93\x4e\xa7\x83\x6f\x3d\xcf\x9b\x13\xe0\xa1\x1a\xe4\x81\
\xcb\x7c\x47\x48\x1a\x6d\x9f\xc3\xc0\x76\x00\x1f\x5e\x04\x66\x7d\
\xc9\x36\xf5\xd0\x8f\x7f\xf4\x7a\x5b\xdb\x57\x65\xd6\xb3\x40\xe6\
\x02\x35\x0c\x83\x6c\x36\x4b\x32\x99\x64\x7c\x7c\x9c\x78\x3c\xce\
\x95\x2b\x57\x98\x98\x98\x20\x9d\x4e\x93\x4a\xa5\x02\x2d\x04\x38\
\x36\xc1\xcf\xbe\x77\x99\x60\x9b\x3c\x75\x07\xb6\x2d\x78\x26\x27\
\xb9\xaf\xf2\x75\xd6\x00\xbc\xf5\x69\x6c\x21\x39\x2f\x24\x9f\x55\
\x3d\x21\xeb\xf7\xed\xdb\x4f\xd6\xb3\xc0\x19\x0e\xd4\xf7\x7d\x3c\
\xcf\xe3\xd2\xa5\x4b\xc4\x62\x31\xe2\xf1\x38\x89\x44\x82\xc9\xc9\
\x49\x32\x99\x4c\x11\x80\x6d\xdb\x01\x80\x90\xb4\xa5\x73\xbc\xbd\
\xf9\x6d\x3e\x1f\x4c\x1d\xfc\xe1\x86\xef\x4b\x79\x9b\x0f\x7f\xf3\
\x61\x9d\xee\xba\x2e\xa3\xa3\xa3\x64\x85\xc5\xec\x87\x7f\x0c\xd2\
\x67\x57\xd5\xe0\x38\x0e\xf1\x78\x3c\xb0\x4d\x4f\x4f\x93\x4c\x26\
\xc9\x64\x32\x45\x53\x50\x08\x70\xcd\x61\xbd\x27\x79\x77\xc6\xe3\
\x20\x70\x1f\x40\xdf\xdd\x8c\xd4\x9e\x23\x25\xe0\x13\xf9\x18\x09\
\x63\x52\x52\xad\x3b\x8e\x43\x2c\x16\x43\xf1\x2c\xa6\xde\xeb\x0a\
\x3a\x4d\x6e\x6a\x41\x08\xc1\xf8\xf8\x78\x60\x9b\x99\x99\x09\x00\
\x52\xa9\x54\x60\xcf\x66\xb3\x01\xc0\xa3\xb7\x31\xd5\xfa\x3e\x7d\
\xae\xa4\xbd\x70\x3d\x48\x98\x90\x92\xca\xa0\x2d\x99\x01\xc2\xba\
\xeb\xba\xc4\x62\x31\x56\x09\x0b\x7f\xfa\x9d\x20\xe0\xda\xb5\x6b\
\xd8\xb6\x8d\x6d\xdb\x81\xcd\x71\x1c\x5c\xd7\x25\x97\xcb\xa1\x28\
\x4a\xd1\xee\xf8\x4f\x45\x77\x5d\x97\x44\x22\x41\xb8\xd2\xc2\xaa\
\xa4\x28\xdd\xa9\x54\x0a\xcb\xb2\x02\x9b\xef\xfb\x84\x42\x21\x0c\
\xc3\x20\x12\x89\xdc\xdc\xef\xaa\x1a\x14\xa4\x8e\x7f\x50\x76\x61\
\x9a\x1d\x21\x85\xf3\xb7\x1c\x4a\x95\x8a\xc2\x44\xc1\x19\x11\x06\
\x66\x74\xc7\x71\x70\x1c\x87\x59\xaf\x18\x20\xfd\x41\x9a\xd9\xd9\
\xd9\x22\x00\x21\x44\x00\x90\x2f\x4e\x37\x8a\x56\x00\xb0\xca\x64\
\x58\x9f\x61\x65\x58\xe7\xc1\xbc\x7f\xc7\x7b\xac\x8d\xdb\x44\x34\
\xf8\x7b\x01\x50\x54\x51\x18\xd7\x5d\xd7\x1d\x10\x42\xd4\x67\x3d\
\x0b\xb3\xe2\x26\x80\xb8\x28\x30\x4d\xb3\x28\x5d\x9e\xe7\x11\x0a\
\x85\xd0\x75\xbd\x08\xc0\x30\x8c\x00\x40\x53\x78\x6e\x85\xc1\x2f\
\xcf\x7f\x86\x0b\x81\x1f\xbe\x72\xc3\xf7\x6a\x41\x95\xbc\x4b\x85\
\x4b\x7a\x77\x77\x77\x03\xc0\x37\xda\xef\x97\x8a\x76\x73\xb0\xc2\
\x3f\xbf\x15\xe0\xd6\x29\x30\x4d\x33\x00\xd8\x53\xc9\x77\x0b\x63\
\x0e\x5c\xc6\x1a\x75\xd8\x67\x28\xbc\x34\xd1\x40\x0c\x60\xcb\x5f\
\xb0\x52\x39\x36\x6b\x0a\x9d\x41\xf9\xf2\xa4\xf1\x46\xfb\xa3\x5f\
\xab\xbb\x09\xf0\x3c\xcd\xcd\xcd\x2c\x5f\xbe\xbc\x68\xb1\xcd\x35\
\x05\x96\x65\x05\x00\x85\x72\x34\x8e\x12\xf3\xf8\xb9\xe6\x72\xbb\
\xa5\xf2\x40\xc1\xdf\x6f\x07\x4a\x54\x85\x97\x03\x80\x9e\x9e\x9e\
\xa2\x2b\x55\x7b\x7b\xfb\x33\xbd\xbd\xbd\x0f\xb7\xb5\xb5\x51\x5a\
\x5a\x5a\x04\xa0\xeb\x7a\x51\x86\x74\x5d\x9f\x13\xa0\xcc\xe4\xb9\
\x90\xa0\xd5\x52\xd9\x97\x3f\x07\x00\x0c\x95\x03\x8a\xc2\x07\x0a\
\xbc\x39\xef\x69\x68\xdb\xf6\xfe\x74\x3a\xfd\xeb\x93\x27\x4f\x22\
\xa5\xc4\xb2\x2c\x4c\xd3\x0c\x32\x90\xdf\xa2\xb6\x6d\xe3\x38\xce\
\x9c\x00\x3e\x8c\x84\x54\x76\x1f\x5b\xcf\x4f\xf3\xb6\xd6\xf7\xb9\
\x57\x53\xf8\x62\x48\xe1\xe9\xab\xf5\xf8\xf3\x02\x9c\x3a\x75\x4a\
\x0a\x21\x1e\xba\x7a\xf5\xea\x89\xee\xee\x6e\x54\x55\x0d\x20\x0c\
\xc3\x20\xbf\x7b\xf2\x3a\x17\xc0\xee\x95\x3c\xf2\xc3\x28\xbf\xcd\
\xb7\xbf\x7d\x91\x8f\x85\x54\x7e\xa3\xc0\x05\x4d\xe1\x17\xff\xf6\
\x46\xd4\xdb\xdb\x2b\xa4\x94\x0f\xc4\x62\xb1\x57\xba\xba\xba\x08\
\x85\x42\x41\x06\x0a\x07\xb7\x6d\x7b\x4e\x80\x42\x79\x7c\x8c\x35\
\xa6\x46\xbf\x0a\xcb\x4c\x95\xd6\x77\xee\x21\xb7\xa8\x3b\x61\x5f\
\x5f\x9f\xe3\xfb\xfe\xfd\x43\x43\x43\x83\xc7\x8f\x1f\x67\xd9\xb2\
\x65\xe8\xba\xbe\x68\x80\xd3\x53\x94\x77\x4d\xf2\x7d\x53\xe1\x5d\
\x15\x56\x86\x54\x9a\xfb\x6a\xb9\xb8\xa4\x5b\x71\x7f\x7f\xff\x94\
\x94\xb2\x79\x70\x70\xf0\xaf\x67\xcf\x9e\x45\x55\xd5\xa2\x35\x90\
\xcd\x66\xe7\x05\x90\x92\x2f\x68\x0a\x9d\x9a\xc2\x69\x53\xe5\x9e\
\x63\xeb\xf9\xf3\x92\xaf\xe5\x00\x67\xce\x9c\x99\x90\x52\x6e\x3f\
\x77\xee\xdc\xe8\xd0\xd0\x90\x5b\x98\x81\x05\x01\xe0\x15\x43\xe1\
\x8e\xfd\x1f\xe7\xeb\xb7\xbe\x09\x3e\xca\xd3\xec\x25\xd3\x34\x6f\
\xfb\x6f\x3c\xcd\xfe\x2f\xff\x04\xe2\xf7\x27\xdc\x8e\x78\x68\xe7\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x03\xee\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x03\x6b\x49\x44\
\x41\x54\x78\xda\xed\x97\xdf\x6b\x14\x57\x14\xc7\xbf\xe7\xce\x64\
\x77\xdd\xdd\xb4\xf9\xe1\x62\x24\xc1\x04\x5a\xd1\x4a\x1a\xa2\x68\
\xa3\x14\x84\x16\x61\xad\xda\xa4\x0a\x6b\x62\x5f\x8a\x52\x50\xfc\
\x07\xda\x50\x10\x9f\x54\xc8\xab\xc4\x7f\xa1\x08\xa5\x55\x1f\xfa\
\xd0\x97\x3e\xb5\x16\xf2\xe0\x4b\x4b\xa1\xa5\x54\xac\x29\x81\x26\
\xbb\xce\xdc\xd9\xcc\xcc\xbd\x77\x6e\x2f\x77\x16\x46\x84\x82\x74\
\x77\x92\x3e\xf4\x2c\x1f\xee\xee\xbe\x7c\x3f\x73\xce\x81\xdd\x4b\
\x5a\x6b\x6c\x67\x31\xc3\x7f\x5f\x80\x2e\x93\x43\xa7\xc8\xdd\x16\
\x01\x3a\x4f\x0e\xfe\xc4\xa3\x93\x6f\x9d\x5c\xa5\x33\x54\xdf\xfa\
\x0e\x08\xbc\x02\x60\xf2\xc2\xe9\x0b\xb5\xf2\x8e\xf2\x57\xf4\x3e\
\x7d\xb2\x2d\x3b\x10\x97\x63\x2c\x7e\xbc\x58\x1a\xad\x8d\xde\xa4\
\x59\xfa\x9c\xa6\xa9\xb0\xa5\x02\x1e\xf7\x50\x18\x28\xe0\xea\x47\
\x57\x69\xea\xf5\xa9\x79\xec\xc1\x0f\xd4\xa0\xf1\xad\x11\x20\x20\
\x08\x03\xf0\x4d\x8e\x98\x62\x34\xce\x36\x70\x62\xe6\xc4\x34\x22\
\x23\x31\x4b\xf5\xfc\x05\x8a\x40\x10\x05\xf0\x43\x1f\x3c\xe4\xf0\
\x42\x0f\x87\x67\x0e\xa3\xf1\x5e\x63\x57\x9f\xdb\x67\xf7\x22\x77\
\x01\x3f\x36\xe1\x11\x87\x1f\x65\xe7\xc8\xf8\x08\x16\x3e\x58\x28\
\x0d\xf4\x0f\x64\x7b\x91\x97\x40\x5b\xb6\xc1\x25\x07\x17\xdc\xca\
\x18\x6c\x37\x0a\xd5\x02\xe6\xce\xcc\xd1\xd8\xd8\xd8\x3c\x26\xd2\
\xbd\xc8\x45\x60\x53\x6d\xc2\x17\x26\x58\x5a\x52\x11\x61\x4f\xbb\
\x17\xc7\xdf\x3e\x8e\x03\xfb\x0f\x4c\x83\x8c\xc4\x59\xaa\xf7\x54\
\x80\x0a\x0c\x81\x0e\xc0\x35\x07\x57\x1d\x64\x8a\x91\xb0\x04\x22\
\xc0\xbe\xbd\xfb\x70\x64\xf2\xc8\x2e\xb7\x6a\xf6\x62\x9e\x3e\xed\
\x9d\x80\x4b\x68\x53\x1b\x7e\xe2\x5b\x78\xc2\xd3\xf7\x2a\xeb\x86\
\x1d\x49\xcc\x31\x34\x38\x84\x63\x6f\x1c\x2d\x55\xfa\xab\x37\x68\
\x81\xdd\xb5\x7b\xd1\x8b\x11\x70\x6d\x42\xc8\x84\x90\x39\xe1\xa7\
\xdd\x48\xb2\x6e\x58\x89\x28\xdd\x0d\x30\xe0\xd0\xf8\x41\xaa\x0d\
\xef\x6c\x60\x92\x56\xe8\x43\x9a\xc0\x3f\x94\xfb\x52\x1d\x70\x18\
\x58\xc9\x40\x0c\x48\x00\x9d\x68\x28\xa5\xa0\x91\x9e\x91\x8a\x00\
\x01\x38\xd2\x01\x8b\x19\x1c\xe1\x80\x04\x61\xa2\x3a\x81\x9d\xe5\
\xda\x9b\x1b\xd1\xc6\xb7\x74\x9e\x5e\xd3\x77\xb5\xfa\x77\x02\x2e\
\x61\xc5\x5f\x81\x54\xd2\x0a\x40\x1a\x62\x43\x04\x38\x91\x03\x37\
\x76\xc1\x22\x06\xdd\x36\x42\x81\x82\xe2\x46\x8e\x6b\xb0\x90\xe1\
\xe8\xcc\x31\xbc\x33\xfd\x6e\x65\xf9\xde\xed\x6e\x3a\x40\x40\xc5\
\xa0\x90\x22\xb2\xe1\xa9\xc4\x04\x4a\x05\x68\x58\x6c\x11\x50\xac\
\x16\xe1\xee\x29\xe0\xbb\xb5\xef\x7f\x7a\x1c\xfd\x3e\x67\x9f\xbe\
\x9b\x11\xa0\xac\xd3\x70\x69\x70\x90\x56\x82\xec\x3b\xb7\x83\x03\
\x54\x07\xfb\x21\x4b\x89\x0e\x7c\xfe\x00\x0f\x75\xe3\xc9\xa3\x27\
\x71\x57\x3b\x60\x03\x2b\x9d\x20\x61\x20\x1b\x9e\x7d\x76\x3a\x30\
\xc3\x30\x21\x8c\xe3\x58\x7a\xe2\xa6\xbe\x93\x5c\x47\x56\x5d\x8c\
\x80\x08\x28\x53\x1a\x18\xda\xf0\x2c\x98\xa5\x98\xdf\x04\x08\x47\
\x01\x82\x36\xa4\x27\x2f\xea\x65\x75\x1f\x2f\x54\x97\x23\x48\xec\
\xd2\x41\x76\x42\xc9\x62\xab\xe2\x56\x50\x60\x3b\xd0\xd4\xad\x9f\
\xe1\xc9\xd3\x7a\x59\xff\x06\x53\xbd\x13\x00\x01\xc2\xa0\x90\x91\
\xa4\x0c\xb1\x61\xc4\x81\xd2\xcd\x56\xf3\x6b\xfc\xa8\xce\xe9\xfb\
\x3a\x02\xb2\xea\xdd\x08\xb8\x41\x20\xed\x42\x0c\x90\x20\xec\x56\
\xa3\x58\x5f\x6b\x8a\xc8\xdb\x5c\xd2\xb7\xd4\x67\xe8\x54\x0e\x02\
\x0c\xf0\xad\x80\xa5\x28\x8a\xa8\x05\x23\x78\xba\xba\xda\xd2\xcd\
\xe4\x92\x5e\x52\x5f\xc2\x54\x7e\x02\xa0\x54\x20\x06\x5e\x35\xaf\
\x52\xb3\x8a\x3f\xd6\x57\x7f\x45\x53\xd4\xf5\x52\x3a\xef\xfc\x05\
\x3c\xc2\x08\xed\x46\xd8\x92\x7a\x8d\xaf\x7d\x83\x87\x72\x36\x9b\
\x77\xde\x7f\xc9\x12\xc2\x54\x69\x3f\x5a\x7f\x71\xd1\x7a\xd6\x5c\
\xd2\x8b\xa2\xfe\x7c\x78\xbe\x1d\xe8\xc3\x33\xae\xfd\x5f\xd6\xdb\
\x4f\x07\x43\xbf\x7d\x45\x5f\x93\x5f\xa0\x87\xf5\x52\x97\x53\x32\
\xa5\x73\xba\xc5\xfe\x7f\x3b\xfe\x1b\x05\x00\xcb\xb4\x1d\xc6\x21\
\xfd\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\x8c\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x02\x73\x42\x49\x54\x08\x08\x55\xec\x46\x04\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\x01\xb7\
\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x0b\x49\x44\x41\x54\
\x78\xda\x9d\x58\x5b\x68\x5c\x55\x14\x5d\x77\x5e\x99\xcc\x4c\xd3\
\xda\x58\x4d\x26\xf8\x42\xa9\x56\x29\xf8\x68\x22\xd6\x6a\xc4\x50\
\x8a\xa2\xb5\xf8\xa1\xe2\xe3\xcb\xfc\xe9\x87\x68\x7c\x22\x12\x8a\
\x54\x91\x54\x41\xfc\xd1\xc6\x9f\x6a\xb4\xa9\x1f\xb6\x56\xed\x47\
\xa8\x28\x8d\x8f\x3e\x50\x54\x54\xd4\x8a\x8f\x92\x07\x62\x95\x98\
\x49\x66\x26\xc9\xbd\xdb\x75\xf7\x6c\xce\xbd\x9d\xa9\x8d\xf5\x2c\
\xf6\x74\x9a\x39\x7b\xad\xbd\xf7\x39\xe7\x9e\x73\xae\x27\x58\xac\
\x3d\xdb\x8c\x1e\x59\x87\x0e\x14\xd5\x80\x71\x8c\x85\xe6\x8d\x62\
\xdf\x63\xe5\xc5\xbc\x4f\x2a\xb0\xa5\x55\x36\xe1\x66\xac\x47\x4e\
\x00\x48\xdc\xad\x66\xb3\x18\xc1\x1e\x6f\xd7\x13\xc7\xfe\x87\xc0\
\xd3\x79\xe9\x43\x1f\x0a\x02\x41\x00\xfb\x74\xf4\x09\x78\xee\x13\
\x25\x0c\x78\x03\x4f\xce\x9c\x82\xc0\xe6\xa4\xf4\xa2\x1f\x6d\x01\
\x42\xf8\xc4\x02\x2d\x30\x09\x12\x13\x49\xa4\x90\x24\x12\x0a\x4c\
\xa2\xdf\x1b\x7c\xca\xff\x4f\x02\xfd\x45\xd9\x85\x4e\x51\xe2\x79\
\x62\x8e\x98\x47\x33\xb2\xb4\x1c\xc2\xba\x94\x51\xa1\xa5\x91\x21\
\xd2\x04\x85\x28\x8b\x43\xde\xa6\xfe\xf1\x45\x05\x9e\xea\x22\x7d\
\x7b\x80\x05\x25\xae\x90\xfa\x74\x9c\x85\xf3\x91\xb7\x68\xd9\x34\
\x97\x69\x1c\xc1\x51\xfc\x41\xfa\xac\x0a\xa5\xc2\xdf\x26\xbc\x4d\
\x9b\x0f\x9e\x54\xe0\xc9\xbb\x64\x50\xb2\xbe\xc6\x3d\x4b\x5b\x89\
\x2b\x18\x75\x96\x68\xb2\x38\x95\x9e\xf2\xec\x41\x9b\xc6\x41\xfc\
\x40\xfa\x9c\xe6\xc2\xdf\x2b\x5e\xef\xd3\x43\xff\x2a\xf0\xc4\xdd\
\x78\x4d\xd4\xb9\x8c\x12\xe3\xee\xc2\x72\x46\xde\x42\xfa\x14\x3c\
\x05\x20\x2a\x21\x2a\x52\x45\x85\xf6\x3b\x3e\x61\x2e\x05\x16\x30\
\xad\xfd\x70\xcf\x96\xd7\x4f\x28\xf0\x78\x97\x7c\x24\xd9\xb0\x34\
\x33\x74\xbc\x1a\x17\xd1\x69\x19\x2d\x49\xc0\x66\x4c\xd8\x84\x50\
\x01\x13\x99\x65\xef\x2f\x30\xca\x30\xf2\x5a\x2a\x66\xd1\xfd\xcc\
\xc1\x06\x81\xc7\x8a\x72\x58\xda\x7d\x3a\xcc\xd0\x71\x3d\xe3\x5f\
\x81\x16\x3a\x24\x14\x46\x4f\x93\xb8\x84\x61\x96\xf8\x09\x7b\xd9\
\x2b\xaf\xa5\xf4\x26\xbc\x35\xcf\x8e\x1f\x27\xf0\x48\x52\x3e\x45\
\x67\x2d\x7a\x1f\xb7\xa2\x15\xed\x58\xa2\x13\xd1\xe8\x69\xb0\x0c\
\x4c\xc2\xa6\x30\x0b\x4a\x54\xe8\x37\x81\x1d\x48\x5a\x16\x9c\x51\
\x57\x3d\xe7\x43\x33\xd7\x16\xf4\x4a\xa7\x1f\xd6\x9e\xd8\x40\xfa\
\x22\x96\x22\x4d\xa4\x1c\x92\xee\x7f\xe9\x38\x48\xd7\x44\x34\x63\
\x09\x7d\x6e\x52\xff\x79\xca\x4a\x67\xd0\x1b\xcb\xe0\xa1\x3c\x8e\
\x04\x6d\x0b\xfc\x71\x0a\xdd\x58\xad\xf4\x29\x82\xcb\x49\xa3\x1f\
\xe1\x5f\x73\x88\x5a\x94\x85\x1f\xc2\xe6\x54\x05\xd3\x38\x80\x0f\
\xe8\xdb\x1c\xfa\x4e\xe2\x82\xad\x33\x96\x41\xd0\x17\xb4\xf9\x3a\
\x5c\xe7\x60\x15\xce\x30\xfa\xa4\x49\x24\x59\xdf\x21\xfc\xa8\x65\
\xaa\x07\xf3\x51\xcb\x68\x26\x79\xac\xc1\xb9\x64\xa9\x52\x34\x68\
\x0b\xfa\xac\x44\x0f\xb4\x06\x7d\x61\x0c\x55\x62\x2d\x5a\x70\x9a\
\xd1\x27\x95\x40\xab\x4f\xa7\xdd\x78\x9b\x9f\x6e\x6e\xc4\xe4\x28\
\x61\x22\x59\xe6\xd9\xa3\x3c\xf3\x58\x60\xd8\x0f\xb4\xaa\x80\xdc\
\x22\x85\x40\x07\xea\x12\x2c\x27\xd2\x46\xce\xe8\x8d\x5e\xb4\x04\
\x5f\xe2\x79\x7c\x05\xb6\x7a\x19\xcb\x36\x4d\x34\xe3\x4c\xac\xd6\
\xf5\x1f\x40\x0a\xb2\x51\x05\xfc\x8d\xac\xa2\xae\xcb\x2e\x26\xb9\
\x24\x2a\x80\x7b\x2c\x93\x9e\xa8\xe2\x4f\x0c\xe2\x55\x4c\xd7\x49\
\x10\x96\x31\x33\xa1\x44\xb7\xf6\x5f\x08\x47\xe7\x16\x20\xf9\x47\
\xb3\xbc\x1c\xa4\xc3\x01\x5e\x81\x4b\xd1\x86\xbc\x1b\xde\xa4\x93\
\xf8\x48\xe9\xe7\xd4\xf1\x37\xec\x67\xcf\x62\x24\x61\x16\xad\x71\
\x8f\xe3\x55\x42\x9a\xde\xde\xd9\x7b\x5f\x48\x04\x3d\x41\xce\xd7\
\x11\x38\x8f\xea\x05\x37\xeb\x49\xee\x5c\x49\xac\x56\x55\x1c\xc3\
\x0b\x78\x11\xd3\x75\x59\x24\x5d\x0e\x19\xac\xd4\x51\xe0\x40\xe7\
\x82\x9e\x44\xb0\x4e\xa8\x1b\x4a\xac\x24\x69\x35\xda\x4e\x14\x30\
\x01\x96\xd0\x09\x54\x68\xfb\xf1\x20\x0e\xd4\x49\xe8\xa8\xd1\x32\
\x58\x5d\xa3\x07\x99\xd7\x25\x82\x0e\x5f\xe9\xf3\x28\x50\x7d\x81\
\xee\x81\x51\x47\x6d\xc1\x46\xc1\xe8\xb5\x5c\x7f\x62\x6b\x2c\x0f\
\x13\xb0\xd2\x2e\x43\x5e\x25\x28\xd2\x91\x90\x22\x75\x88\x9c\x55\
\xdd\x03\x87\xbc\x4e\x80\x7f\x21\x28\x60\xe4\x84\x66\xf5\x31\x1e\
\xc5\x61\xd7\x2b\x11\xcb\x23\x6f\xfb\x9f\x14\x13\xd2\x51\x5b\x91\
\x79\x9b\x96\x0a\xdb\x1a\xe3\x02\xf3\x6e\x14\x94\x9c\xf0\x89\x29\
\xbc\x84\x57\x30\x6d\x39\x7b\x6e\x3c\x0a\xf0\x21\x21\x3a\x52\xb5\
\x0c\x04\x85\x86\xca\x47\xed\x28\x02\x8b\x5e\xf7\x66\x0d\x25\x83\
\x39\x9a\x8f\x66\x1c\xc4\xf7\xb8\x13\x97\x01\x31\x89\x25\xa8\xb1\
\xa2\x98\x12\x18\xa2\x98\x1b\x24\x7e\xc5\x2c\x66\x68\xdc\x8d\x49\
\x9d\x73\xf0\x90\x56\x4f\x6b\x91\x7f\x8c\x33\x25\xe3\x72\x21\xd8\
\x4a\x80\xeb\x2a\x70\xad\x71\xa6\x18\x4d\x94\xe9\x1a\xdc\xcd\x88\
\x83\xe3\xfc\xa7\x61\x3c\xe3\x29\x19\x53\x01\xfe\x29\x70\xba\x75\
\xcd\xcd\x8f\x8c\xad\xda\x94\x1b\xad\xa5\xb8\x0f\x57\x22\x6a\x62\
\xf8\x1b\x26\x30\xc6\x0c\x34\x1e\xdd\xc7\xfc\x48\x42\x3f\x2d\x46\
\x7b\xd2\xf8\x00\xff\x85\xdb\x27\x92\xb8\x0e\xf7\xa3\xc5\x11\x47\
\xf4\x3e\x4a\xe6\x2b\x61\x06\x1a\x23\x35\xa7\xd8\x39\x70\xa7\xb8\
\x24\x5c\xb3\xf5\x29\x48\x68\x21\x28\x46\x9c\xce\x29\xda\x8d\x78\
\x33\x4f\xe2\x2f\xb2\xb5\x58\x06\x09\x6f\x54\xd7\x2e\xdd\xbe\xb3\
\xa9\x17\x38\x19\x6b\xf6\xbc\xcf\x2a\x9a\x69\x4d\xb8\x01\x6f\xc4\
\xe9\x8d\x9a\x50\x86\x2f\x91\xb2\xb1\xf2\x46\x53\xb2\x4f\x66\x91\
\x0b\x2b\x7c\x04\xd7\x60\x0e\x4d\x26\x21\xb1\x22\x65\xf4\x1b\x0b\
\xa5\xab\xbc\x95\xb1\x5f\x0f\xd4\x57\xde\xe8\x03\x72\x7c\x6b\x0f\
\x4a\x32\xef\x4b\x6c\x2f\xcb\x08\x74\xe8\x8e\x32\xb1\x39\x5b\x42\
\x44\x34\xe0\xb6\xef\x32\x7a\xe2\x46\x0c\x37\xd2\x47\x9b\x27\x31\
\x85\x5f\x90\xd2\xd0\x64\x64\x7b\x39\x14\x7a\x47\xe3\xa3\x7d\x88\
\x6a\x24\x11\x2b\x94\xd2\x13\x6d\xd8\x82\xcd\x58\x06\x34\x16\xc7\
\xd1\xcf\xe1\x7d\x63\x13\x60\x77\x6d\x47\xdb\x2d\x25\xe8\xd6\xf7\
\x39\x26\x51\x76\x02\x0b\x90\x1a\x8c\xbe\x07\xdb\x70\x2d\x8e\x6f\
\x62\x30\x0f\x62\x0c\x07\xc8\xa4\x05\x2a\xc9\x3b\x2a\x30\x74\x4c\
\x06\xf8\x45\x07\x66\x44\xcf\xcd\xf3\x04\x5d\x68\x8c\x4d\x05\x56\
\xe0\x61\xf4\x61\x29\x70\xa2\xe8\xad\x2f\xbd\xe8\xbb\xc7\x98\x00\
\x19\x18\x3a\xa6\x02\x6c\x03\x0c\x5d\x17\xd2\x77\xd4\xe7\x51\xd0\
\x3d\xd0\xe6\x95\xe0\x72\x16\xa6\x13\x52\x4f\x6d\x60\x4f\x77\x70\
\x19\xc5\x57\x64\xd1\x29\x3e\x49\x56\x98\xc0\x9b\x33\xd2\xcf\xba\
\xe9\xa6\xfd\x2e\x7e\xc0\x8c\x8e\x85\x8a\xa8\xdd\x6b\x8f\xdf\x06\
\xd8\xef\xb6\x5b\x30\xbc\xb7\xf4\x08\xac\x23\xd0\xff\xe6\x8c\x13\
\x00\xbc\x41\xef\x90\x17\x2e\x27\xda\x1b\xac\x63\x09\x15\x7b\x30\
\x13\x56\x30\x89\x11\x8b\x15\x45\xa1\xe4\x15\x1c\xc5\x36\x63\xf0\
\x40\xb6\xc1\xba\xc3\xef\x1d\x45\xe8\xe1\x97\xc7\x17\x76\xb9\x13\
\xab\x18\x75\xd6\x3d\x14\x1a\x8f\xbf\xee\x6c\x4a\xd0\x87\x73\x7f\
\x90\xdf\xe8\xa1\x87\x5f\xac\xd9\x11\x3f\xfc\x9a\x84\x1e\xdf\xc3\
\x9a\x56\x69\x1b\xb1\x16\x39\x26\x9c\x72\x12\x5e\xc3\x01\x9e\xf4\
\x8a\x32\xf6\xe3\x2d\x52\x37\xd1\x12\x7a\x7c\xdf\x51\x77\x7c\xb7\
\x76\xbb\x5e\x40\x6a\xd7\xa7\x32\x73\xb8\x09\xed\x94\xc8\x44\xa7\
\x54\x13\x30\x7a\xeb\x39\x86\xdd\xf8\x1a\xd6\x4f\x2f\x20\xc3\x8d\
\x17\x10\x27\xc1\x2b\x14\xb2\x74\x24\xaa\x24\xe8\xc4\x06\x2c\x43\
\x86\x38\x81\x00\xc9\xa7\xf0\x1e\x3e\xe3\x2f\x4d\x76\x9a\x02\xaf\
\x50\xc3\x27\xbe\x42\x39\x89\x2e\xec\x92\x76\x71\xeb\x52\x70\x0e\
\x2e\xc6\x65\x38\xcd\xee\x68\x9e\x3d\x18\xfe\xc2\x17\xf8\x06\x3f\
\xc3\x43\x26\xda\x21\x26\xb0\x69\xf8\x64\x97\x40\x93\x28\x52\xa2\
\xd3\xee\x30\x26\xe4\xa3\x05\x05\xb4\x10\xc0\xdf\x44\x89\x96\x34\
\x62\x2d\x8c\xce\x1c\xd2\x2f\x76\x8d\x35\x09\x5e\xc4\xbd\x7e\x69\
\x53\x91\x18\x84\xb0\x33\x90\x83\x91\x4f\x0a\x2f\xe2\xc3\xfe\x29\
\xbc\x4a\xb8\x2d\x2f\x7d\x5e\x9f\x14\x00\x71\x80\x09\xd0\x0c\xfa\
\xbd\x24\x7c\x95\xb0\xf3\x54\x5e\x25\x38\x11\xbe\x0c\xf1\x6e\x96\
\xf5\xc8\xa1\xe1\x65\x88\xb6\x59\x6f\x44\xf8\x32\x64\xe7\x29\xbd\
\x0c\x69\x94\xb1\xd7\x39\x5e\x11\x1d\x52\xa4\xcb\x38\xc6\xc4\x5e\
\xe7\xec\x2c\x2f\xe6\xfd\x0f\x67\xf3\xcf\x7a\xd8\x2a\x61\x9b\x00\
\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x0a\x62\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x06\x00\x00\x00\x57\x02\xf9\x87\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\
\x01\xb7\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x09\xdf\x49\x44\
\x41\x54\x78\xda\xd5\x5a\x6b\x8c\x5d\x55\x15\xfe\xd6\xda\xe7\xde\
\x99\xb9\x33\x77\xa6\xcf\x61\x3a\xf6\x35\x13\xe8\x50\x81\x42\x6d\
\x29\x50\x8c\xd5\x04\x11\xd4\x60\x84\xc4\x98\x80\x8f\x00\x7f\xfc\
\xe9\x0f\x23\xf1\x0f\x10\x34\x3e\x7e\x1a\x83\x26\x60\xaa\x26\x44\
\x88\x21\xf2\x43\x85\x18\x50\x68\xc3\xab\xb6\x45\x69\xcb\xb4\x74\
\x98\x96\x76\x9c\xe9\xf4\x31\x8f\xce\xeb\xde\x73\xce\xde\xcb\x7d\
\xd7\xd9\x3d\x27\x93\xb6\xfa\xa7\xc9\xad\xfb\xde\xef\xae\xbd\xef\
\xd9\xe7\x9e\xf5\xed\xf5\xd8\xeb\x9c\x5c\x12\x11\xfc\x3f\xb7\x08\
\x57\xb0\x11\x88\x36\xff\xa1\x67\x63\x0b\xb7\x6e\x75\x94\xf6\x45\
\xcc\xc4\x60\x70\x04\x89\x38\x1a\xee\x2c\x77\xfd\xf3\xa5\xbb\xf6\
\x1d\x14\x5c\xb9\x55\xbb\x62\x16\xb8\xfe\xf9\x95\xbd\xdf\xb8\xee\
\x91\x97\xbb\xdb\x7a\x36\x7d\x7c\x7e\x08\x6f\x8e\xbf\x86\x9a\x9d\
\x83\x21\x46\xc9\x18\x6c\x5e\x71\x3b\x6e\x5a\xbe\x15\x95\x52\xe5\
\xc3\xfd\x93\xef\xdc\xfb\xd3\x2d\x3b\x87\x71\x05\x1a\x5f\x29\xe5\
\xbf\xbe\xfe\x9b\x87\x1f\xbb\xe5\x47\x9b\x6e\x59\x76\x2b\xd6\xb4\
\xf7\xa3\x6a\x96\xc0\x5a\x78\x08\xe0\x0c\xd6\xb6\x5f\x8b\xbe\xf6\
\x01\x7c\x7e\xd5\xfd\x1b\xee\xe9\x79\xe0\xd0\x0f\xf6\x3e\xd4\xd7\
\x7c\x02\xc1\x6d\xd6\x94\xfb\x5f\x18\x58\x72\x63\x75\x78\xf2\x28\
\x56\xb7\xad\xc7\xea\xca\x3a\xc0\x12\x9c\x75\x8a\x7a\x12\x63\x55\
\xeb\x3a\xf4\xb6\xad\xf3\x63\x01\x8b\x69\x6d\xe7\x65\x2f\x12\x88\
\x9a\xee\x42\xd7\xfe\x76\xf9\x0d\x1b\x3a\x36\x1e\xdc\xde\xbb\x03\
\x5b\x56\xde\x86\x9b\x56\x6e\x46\x1d\x33\x88\x31\x87\x44\x92\xe2\
\x42\x36\xf2\x24\xfa\x70\x62\xe6\x23\x1c\x9a\xd8\x8b\xc1\xe9\x7d\
\xf8\x60\x72\xdf\xa6\x97\xbe\xf8\xfe\x81\xa6\x06\xb1\x24\xb8\xf5\
\xe4\xf9\x13\x18\x6e\x3b\x8a\xa5\xd1\x32\xf4\x2d\x5b\x87\xe3\xfc\
\x0e\xe6\xec\xd4\x45\x73\x93\xf9\x14\x6f\x8e\xfe\x0d\x67\x6a\xa3\
\xf8\x78\xe6\x18\x5a\xa3\xea\xed\x00\x9a\x4b\xc0\x5a\xdb\x5f\x73\
\x75\xec\x19\x7b\x13\xc7\xbc\x0b\x6d\xeb\xfb\x14\x26\x93\x33\x97\
\x26\x1b\x25\x78\xe1\xc3\x67\x61\x0c\xc1\x30\xa3\x5c\x2e\xad\x6d\
\x7a\x1a\x95\x18\x9c\x98\x18\x69\x9a\xa0\x96\x9c\xc4\x64\x7c\x0e\
\xb1\x4b\x71\xa9\x96\xb2\x85\x75\x12\x4e\x14\x24\xf5\x04\x4d\x27\
\xe0\x04\x44\x16\x60\x08\x9c\x73\x1e\x72\x59\x02\x56\x1c\xc4\x0a\
\x9c\x06\xbf\x97\x42\xd4\x74\x02\xd6\x81\x18\x0e\x04\x82\xe3\x4c\
\xc9\x38\x4d\x01\xba\x14\x81\x34\xb7\x00\x89\x83\x33\xdc\x7c\x0b\
\x20\x75\x24\x04\x55\x9e\x2d\x65\x16\xb0\xe9\x65\xa6\x5a\x4d\xab\
\x24\xac\xfc\x2c\x6c\xf3\x2d\xe0\x15\x26\x56\x49\x00\x09\x1c\x1c\
\xea\x2e\xb9\x8c\xbb\x39\xdd\x07\x48\x2e\xc4\x01\x9a\x4e\x40\x15\
\x02\x91\xc6\x80\x50\xe6\x42\x89\xb5\x97\xb7\x80\x13\x10\x3c\x08\
\x80\x38\x5c\x15\x16\xd0\x0e\x29\x0f\x88\x08\x52\x75\x21\xba\x44\
\x0c\x58\xf8\x37\x9c\x12\xd0\x98\x69\xbe\x05\x60\x41\x2e\xac\xa8\
\x65\x52\x37\x49\x9c\xbd\x8c\x0b\xd9\x22\x88\xe1\xa0\xdd\x2b\x4d\
\xe0\x99\x7d\xcf\x94\x5e\x39\xfa\xca\x1d\xbb\x46\x76\x6d\x9c\x9a\
\x9f\x58\x0b\x0b\x26\x30\xb1\x00\x0c\xf2\x0d\x59\x89\xac\x4a\x90\
\x97\xf4\x19\x22\xc0\x11\x81\x45\x54\x29\x75\xa1\x8b\x6d\xa0\xca\
\x8b\x73\x70\xe0\x8c\x30\xdc\x8e\x6d\xbf\x5e\xf3\x63\x63\x08\x6c\
\x58\x22\x62\x98\x88\xc5\x30\x60\xfc\x98\x23\x46\x54\x32\xb2\xbc\
\xb2\xf4\xe3\x9b\x56\x6c\x3f\xbc\xe5\xc6\x2f\xbd\xb3\x03\x3b\xd2\
\xcb\x12\x78\xea\x8d\xa7\xb6\xd4\x5d\xfd\x39\x61\x19\xe8\x6d\xef\
\xc5\xd4\xdc\xa4\x5e\xd0\x7f\x40\x3d\x57\xc4\x83\x00\x72\x41\x7d\
\x15\x60\x10\x84\x05\x2e\xb8\x90\x73\x16\x20\x84\x39\x8b\x2d\x20\
\x4e\xb2\x39\xa4\x53\xee\xb0\xd6\xdd\xa1\x3d\x0f\xcb\x02\x38\x07\
\x30\x6b\xa0\x93\x6b\x80\xd0\xc1\xcb\x11\xd7\x17\x30\x3a\xf4\xaf\
\xc3\x2f\x9a\xa3\x0f\x3e\xd0\xf7\xe8\xfe\x8b\xaa\xd1\x87\x5f\x7e\
\x78\xe0\x74\xed\xf4\xdf\xab\xe5\xea\xc0\xca\xb6\x95\xe8\xae\x74\
\x43\xac\xea\x9e\xc9\x14\x70\xf9\x38\xc0\x89\xc2\xa9\x54\x68\xae\
\x4f\xd5\x55\x14\x59\x3f\x20\x71\x31\x74\x3d\x1a\x2f\xeb\xe1\x34\
\x86\x3c\x42\x86\x92\xf0\x7b\x56\x60\x1b\x52\x1a\xd2\xa1\x1a\x2d\
\x45\x47\xd4\x85\x12\xb5\x5e\x7f\x3e\x39\xfd\xfa\xaf\x8e\x3e\x31\
\xb0\x88\xc0\x93\x78\x92\x0f\x9f\x3e\xbc\xf3\xec\xec\xd9\xea\xf9\
\xda\x79\x55\x7e\x69\x79\x29\x6c\x62\xf5\x42\x08\xab\x26\x6e\x11\
\x02\x11\x3d\x96\x93\x4b\x6c\x82\xd4\x5a\xa4\xce\x65\x24\x1a\xfd\
\x80\xd8\xc5\xb9\x82\x22\xaa\x7c\x18\x07\xe8\x39\xe1\x5a\x68\x8c\
\xb3\x84\x50\xe1\x0e\x74\x78\x12\xf3\xc9\x0c\xa6\xeb\x53\xd5\xb1\
\xd9\xe1\x9d\x0d\x9d\xf3\x72\xba\xe5\x67\x2d\x37\xf4\x56\x7a\x0f\
\xf6\x77\xf6\xa3\x81\xad\x9f\xd8\x8a\x55\x5d\xd7\x60\xce\xce\xc0\
\xc1\x86\x94\x1d\x5e\x3a\x72\x70\xda\x77\x80\xc8\xa2\xa3\x23\xb5\
\x61\x8c\xd5\x47\x40\x14\xdc\xa7\xf8\x40\x4f\xcb\x2a\xac\x6d\xbb\
\x16\x86\x22\x30\x19\x2f\x39\x93\x01\xcc\x5e\xc2\x4b\x8a\x74\x1c\
\x79\xd9\x55\x5e\x82\x53\x33\x63\x88\xed\x34\x4e\x2e\x1c\xc5\x44\
\x32\x86\x09\x3b\x8a\xf3\xc9\xc4\x8d\xbf\xf9\xf4\xbb\x87\x22\x00\
\x9e\x5d\xc7\xb6\xf1\x99\x71\x54\xfc\xab\xca\x55\xac\xac\x2e\xc3\
\x1f\x8f\x3f\x87\xba\xad\x23\x8b\xd6\x45\x50\xe5\x38\x97\x14\x64\
\xf1\x1d\xe9\x24\x28\xd9\xd0\xd7\x36\xb6\x30\x82\xb1\xf9\x11\x25\
\xda\x78\x3b\x84\x98\x29\xa0\x63\x38\x42\x7f\xd7\x00\xe6\xe7\xeb\
\x78\xf5\xe8\x1b\x78\xef\xe4\x7b\x78\xf6\xbe\x5f\x62\x3a\x9d\xf0\
\x04\xce\x62\xd2\xa3\xd2\xd2\xb1\x0d\x40\x46\x60\x22\xcb\x36\xf8\
\x60\xfc\x03\x0c\x8e\x0e\xe2\xee\x8d\x9f\xc3\x6c\x7d\x0e\x60\x04\
\x2d\x14\x39\x19\x26\xca\xe1\x82\x14\xed\xa3\x20\x14\xb4\xa6\xc5\
\xa1\xac\x0a\xe6\x36\x13\x04\xa5\x33\x77\x29\x73\x2b\xae\x5b\x72\
\x03\xce\xf8\xe4\xb1\x73\xdf\x73\x38\x31\x35\x02\x84\x2d\xe5\xc0\
\xf8\x01\x1c\x73\xaf\xc3\x44\xac\xe5\x78\x4a\xf1\xda\x22\x0b\x39\
\x50\xf8\x55\xf5\xe9\xc9\x85\x29\x24\x5a\x51\x16\x8a\x07\x3f\x0a\
\x43\x42\x01\x56\xe5\x45\xfb\x85\xba\xa2\xb2\xb8\x69\x0c\x02\x42\
\xea\x75\xb9\x3b\x56\xcb\x5d\x58\xd3\xde\x87\x38\xb6\x18\x9b\x1d\
\xc7\xcf\xf7\xfc\x02\xe7\x16\x26\xb3\x54\x4c\xc5\x89\x75\x5b\x83\
\x85\x03\x49\x76\x1d\xb1\xa0\x82\x80\x04\xb8\x0c\xb1\x8d\x35\xe8\
\x74\xcc\x28\xa4\x20\xac\x76\x80\xfa\x4c\xd0\x4a\xfb\x19\x58\xa5\
\x46\x98\x1e\x0b\x53\xb4\xb1\x30\x7a\xdb\xd7\x62\x49\x79\x85\x0f\
\xca\x79\x9c\x3c\x3f\x82\xdf\x0d\xed\xc4\x64\x7d\x1a\x71\x6a\x3d\
\xd2\xdc\xba\x96\x04\x81\xbd\x2e\xa8\x16\x8d\x2e\xb8\xdb\xa2\x7d\
\x80\x20\x28\x08\x68\xe4\xe7\x2b\x20\x8b\x2d\x60\xb2\x6d\x4d\x2f\
\x60\x42\xfe\x37\x60\x88\xe4\x7e\x96\xaf\x7f\xc5\xb4\xa3\xbb\xad\
\x1b\x86\x4a\xb0\x36\x41\xd2\x48\xb1\x5e\x0e\x9e\x3d\x80\xa1\xa9\
\xc3\x48\x9c\xf3\x63\xa7\x32\x62\x86\x63\x07\xeb\x25\x3b\x57\xc4\
\x4e\x20\x9e\x7a\x02\x8e\x05\x1c\x5c\xce\x8f\x50\x10\xb0\x18\xce\
\x09\x78\x79\x62\x7c\x14\x6f\x0d\xef\x45\xa9\x1c\x79\x94\x54\x96\
\xa3\x32\x5a\x5a\xca\x68\x2b\xb7\xa2\xad\x54\x46\x67\xb9\x13\xa5\
\x52\x0b\x60\x33\x9d\x9d\x73\x6a\x15\x43\x0e\x60\x83\x8e\xa8\x82\
\x59\xbf\xaa\x47\xce\xbd\x8f\xba\x9b\x47\x11\x07\xd9\x0a\x46\xc6\
\xe4\xda\x49\xa8\x54\x99\x19\x4c\x0e\x44\x17\x3f\xaf\xe8\xac\xb4\
\xf9\x24\x50\x04\xbb\xf1\x3a\x17\x04\x18\xfb\x42\x7e\x54\x12\xbb\
\x07\x77\xe3\x9e\xfe\x7b\x51\xe7\x3a\x84\x24\x0f\x5e\xe2\x60\x01\
\xc7\xe0\x3a\x21\x4a\x18\xc6\x78\x30\x23\x0a\x96\x19\x4d\x8e\x61\
\x3c\x39\x89\x12\x17\xc7\xca\xc6\xa8\x52\xdd\xe5\xd5\xe8\x2d\xaf\
\xcf\x3d\x56\xf3\xbe\xb8\x7c\xc3\x4a\x1b\xd0\x62\x50\x6b\x26\x3d\
\x46\x42\x58\xde\x52\xc5\xa9\x78\x30\xc4\x4e\x46\x80\x48\xf6\xe6\
\xfb\x00\xf9\x86\xc7\xf1\x57\xcc\xe3\x2e\xd4\x01\x24\x1e\xa9\x92\
\x29\x50\xb4\xb0\x3a\x54\xa4\x52\x26\x90\x12\x24\x3c\xf4\x95\xfb\
\x71\x60\xe1\x6d\x94\x4c\x83\x94\x51\x02\x46\x8f\x13\x3e\xd9\x76\
\x1b\x9e\x7f\xed\x25\x9d\xaf\xf5\x4f\x03\x91\x1e\xf7\xd2\xa3\x71\
\x8e\xc9\xa4\xf1\xe3\x28\x48\x53\x32\xfa\xbd\x89\xbc\x8c\xd8\x8f\
\xf9\xd5\xbf\x7c\xe1\xf0\xdd\x02\x11\x56\x13\x2a\x0b\x7c\xcb\xe3\
\x1c\x80\x42\x69\xab\xb8\xa8\x2f\xea\x6a\x2a\x8b\x1d\x5a\xc7\xa2\
\xbe\x6a\x98\x3c\x58\x15\x28\x29\x8c\x5a\x01\xb0\x1a\x84\x61\x15\
\x3d\x8a\x7d\x40\x82\x59\x9c\x8a\xc2\x55\x8a\x1a\x2c\xff\xfe\x0c\
\x25\xee\xdb\xe1\x8c\xa2\x16\x92\xc7\x65\x14\x84\x5b\x00\xec\xca\
\xec\x7b\x19\x58\x45\xa8\x65\x0a\x42\x0a\xc9\x0a\x36\x26\x75\x9d\
\xc5\x24\x22\x03\x21\x35\x65\x50\x26\x28\x14\xfa\xf9\x9e\x10\x80\
\xfc\x78\x00\x54\xe5\xd7\x2c\xd1\xe6\x3f\x7d\xf9\xc8\xbf\x2f\x59\
\x8d\xca\x4f\x64\x84\x88\x3e\x8b\xef\x60\x33\x1c\xb6\x03\xd8\xa0\
\xe9\x5d\xf2\x7d\x09\x8b\x24\x37\x48\xd0\x76\x38\xb9\x99\x74\x35\
\x09\xa9\x4b\x40\x61\x43\x8b\xb8\x01\xb5\x80\x92\x01\x42\x35\xca\
\x14\xd6\x8f\xf6\x10\x61\x97\x7a\xb2\x7f\xab\xf4\x22\x1b\x07\xe3\
\xfa\xae\x81\x0c\x59\x27\x7b\x77\x7f\xf5\xf8\x21\xa5\xf1\xdf\xee\
\x07\xc2\x2f\xec\x0f\xf8\x9f\x8d\x1f\xe5\xa7\xc9\xe2\x66\x71\x00\
\x85\x7c\x4d\xc1\xe7\x0b\x4b\x64\x56\xa0\x0b\x8f\x54\x8a\xdd\x78\
\xf7\xb1\xef\x4f\x7e\xaf\xb9\x4f\xa7\x9d\xba\x52\x28\x0d\x34\x06\
\xb4\x9f\x5f\x80\x2e\xc4\x83\x81\x23\x0b\xe0\x82\x3b\x78\x10\xa4\
\xf9\x4f\xe6\x10\xca\x90\x80\x38\x8d\x61\x59\x4b\xe3\x8c\x54\xc8\
\x5a\x46\xd3\x94\x53\xc5\xd5\xdd\xa0\xdb\x6a\xd3\x1f\xaf\xe7\x11\
\x28\x4e\xa5\x96\x21\x89\xb5\xf9\x2e\x6b\xb3\xa7\x75\x61\x9a\x85\
\x4e\xa3\x10\xa0\x5e\x36\xdd\x02\x70\x79\xc1\xaa\x72\x21\x89\x11\
\xb3\x05\x87\x8a\xd4\x8b\x82\x67\x5c\x0b\xa7\x84\xf9\x44\xcd\x76\
\xa1\xa2\x09\x65\x34\xe6\xd3\x1a\x16\x38\x41\xb1\xbb\x5a\x2d\xd2\
\x16\xe2\xc4\x93\x9b\x55\xff\x37\x4a\x88\x94\x4a\xf3\x09\xd0\x62\
\x7f\x9a\xad\x2d\x60\x5e\xe2\xac\x48\xb3\x06\xf5\x34\xcd\x32\x11\
\x31\x2a\x69\x09\xd0\x9b\x7f\x02\x65\xb2\xf9\x16\xc8\x17\xd3\x43\
\x18\x98\x4b\xea\x98\x45\x8c\x52\x9a\x6a\xfe\x8f\x98\xf3\x9b\x9c\
\x9a\x8d\xd4\xff\x89\x24\x9b\x2f\x57\x83\x05\x0c\x1c\x5c\x71\xb7\
\x36\x5b\x5f\xc0\x9c\x8b\xf3\x1a\x28\x28\xaf\x41\x50\x27\x25\xa0\
\xd0\x00\x66\x72\x4d\x27\xc0\xcc\x43\xc2\x82\x9e\x6a\x15\x6b\x3a\
\xdb\x41\x91\xc1\xbb\xb5\x69\xa4\xec\x02\xa9\x22\x5b\xf5\x47\x3d\
\xb8\x86\xbb\x31\x99\x4e\x60\x5e\xe6\x20\xa5\x74\xa8\xe9\x04\x5c\
\xc9\xed\x5e\xd6\x5a\xc1\xaa\x25\xed\x58\xdd\x59\xc1\xda\x6a\x09\
\x6d\xa6\x17\x6f\x4f\x9e\x0d\x0c\xa1\x16\xb8\x73\xf9\x9d\xa8\xc6\
\xed\x18\x8b\x46\x61\x5c\xa4\xdf\xa5\x65\xda\xd3\xfc\x7d\xe0\x69\
\xec\x6f\xef\x2c\xfd\xa3\xa7\xab\x15\xbd\x5d\x25\x74\xb7\x33\xae\
\x6b\xef\x04\xd7\x1c\xd2\x5a\x02\x5b\x4b\x51\x45\x3b\xb6\x2d\xdf\
\x86\x92\x29\x83\x98\x01\x56\x37\x7a\x6b\xf2\xbb\x73\x07\x9b\x4d\
\x40\x8b\x82\xa4\x5a\xff\x5a\x47\x95\xe6\xd6\xaf\x28\x61\x9a\x09\
\x13\xb0\x68\x69\x2b\x41\xa2\xcc\xc6\xd5\x4a\x27\xa2\x28\x02\x47\
\x06\x14\x91\x07\x4f\x73\x82\x07\x1b\xe7\x36\x9b\x80\xb6\xb1\xc7\
\x16\x8e\x9f\x34\xb3\x37\xcf\xb4\xb8\xa1\x29\x06\xce\x49\x02\x29\
\x49\x8e\xce\x0e\x4f\xa0\x35\x82\x69\x61\xb4\x94\x5b\x0f\x78\x27\
\xdb\x76\xea\x87\x53\xc7\xaf\xaa\x3f\x7b\xbc\xf5\xc8\xf8\x47\x04\
\xda\x70\xdf\xef\x07\xb6\x9f\x41\x6d\xd3\xb4\xa9\xf5\x80\x41\x62\
\x48\x8e\xd7\x8f\xf3\x91\xda\x91\xb8\xda\xda\xf5\x3e\x4e\x9c\xfa\
\xf3\xe0\x13\x83\x69\x13\xfe\xec\x71\x75\xb6\xff\x00\xae\x28\x29\
\x62\xea\x92\x75\xb4\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\
\x82\
\x00\x00\x06\x77\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x01\x73\x52\x47\x42\x00\xae\xce\x1c\xe9\x00\x00\x00\
\x09\x70\x48\x59\x73\x00\x00\x1b\xaf\x00\x00\x1b\xaf\x01\x5e\x1a\
\x91\x1c\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xd9\x02\x15\x00\x2d\
\x1d\xa7\xce\x25\xbc\x00\x00\x00\x02\x62\x4b\x47\x44\x00\xff\x87\
\x8f\xcc\xbf\x00\x00\x05\xfb\x49\x44\x41\x54\x78\xda\xad\x97\x7b\
\x88\x5c\xd5\x1d\xc7\x3f\xe7\xde\x3b\xcf\xcc\x6e\x36\xc9\x6e\x32\
\xbb\x79\xd4\x38\x4d\x1a\x62\x96\xc4\xb7\x41\x50\x7c\xfd\x53\x15\
\xab\x88\x55\x6c\x0b\x82\xb4\x14\xda\x3f\x5a\x10\xda\x54\x0d\x8a\
\x51\x44\xb4\x55\xd4\x3f\x4c\x44\xc5\x17\xa8\xf8\x4e\x91\x88\x1a\
\x02\xe2\xa3\x35\x35\x69\x4c\x49\x93\x6d\xac\x8f\xdd\x31\xbb\xd9\
\xc7\xec\xec\x9d\x99\xfb\x38\xc7\xc3\xe1\xb2\x73\x19\xee\x0c\xb3\
\x69\xbf\x5f\xe6\xdc\x39\xe7\x1e\xbe\xdf\xf3\xfd\x9d\x7b\x2e\x33\
\x82\xae\x70\x1e\x03\xc3\xab\x7f\x3a\xb4\x35\x77\x9a\x97\x3d\x39\
\x31\x72\x70\xe4\xb5\xe9\xb7\xbf\xf1\xe8\x02\x5d\x19\x6c\x58\x5f\
\xba\xe7\xfc\xeb\xd6\xdb\xb9\x68\x7a\xc0\xb7\xfc\xfd\xf0\x7f\xb6\
\x8f\xbc\x3a\x2a\xff\x67\x83\xe1\xfe\x35\xb7\x9f\xf1\xab\x4d\xd9\
\x74\xcb\xb8\xd2\x26\x47\x3e\x9a\xdb\xb6\x77\xef\xe8\xa9\x1b\x9c\
\x99\x2f\xfd\x76\xe5\x1f\xd6\xf7\xe5\x5b\xc5\xa3\x6b\xc8\x77\x4c\
\xbe\xb3\xec\x4f\x8f\xed\x1f\x5d\xb8\xc1\x4a\xe7\xb2\x1b\xfb\xee\
\x1e\x5a\xdb\x93\x20\x1e\x47\xc0\x54\x20\x5e\x2e\x6d\xff\xf9\xd1\
\x05\x18\x0c\x71\xe1\xa5\x2b\xee\x5f\x7a\x4e\x0f\xa2\x45\x34\xd9\
\xcc\x63\xb6\xc1\xce\x0d\x3b\x6e\x29\x77\x65\x70\xd1\xf0\xaa\xfb\
\x8a\x3f\x5e\x2c\x44\x8b\x74\xe7\x24\x0d\x8e\x55\xeb\x7f\x5e\xf7\
\xe0\x43\x33\x1d\x0d\xd6\xaf\x5e\xb3\x7d\xf5\x2f\x96\xa4\x24\x21\
\x02\x47\x53\x10\x17\x0d\x35\x15\x56\xcb\x38\x84\x04\x7c\xc0\x38\
\x8b\xcb\xf9\x1d\x85\x5d\xfb\xea\x89\x06\x83\x99\xfe\x6d\xa7\xff\
\x7e\xb0\x10\x60\x53\x62\x09\x0d\xbe\xa6\x4c\x01\x1b\x50\x46\xa4\
\xaa\x47\x8b\x38\x4c\xf1\x0d\x59\x32\xb1\xf1\xac\xe6\x98\x1e\x3d\
\x8e\x36\x3f\x16\xde\x2b\x9f\x2b\xfb\x2d\x06\xc5\x55\xcb\x5e\xda\
\xbc\x35\x4f\x40\x91\x9f\x69\xa1\x0c\x92\x1a\x87\x79\x96\x1c\xc2\
\x08\xcd\xf1\x13\xce\xa6\x07\x0b\x5f\x8b\x3d\x4d\x15\xdb\x8c\xbb\
\x5c\xc3\x59\x14\x10\xd4\xf8\x9c\x3b\x99\x02\xf8\x58\x5e\x55\x3e\
\x09\x60\x45\xf2\x43\x62\xef\xd0\x56\x3d\x05\x97\x01\x16\x91\x26\
\xa7\x99\x61\xad\x11\x70\xcd\xb8\xc7\x06\xf2\xe4\x28\x90\x65\x80\
\x12\x73\xd1\x78\x2f\xe7\xd0\xab\xd9\xc7\x62\xce\xe6\x32\x63\xca\
\x05\xe2\xa9\x22\x00\xb6\x91\x4f\xf3\x2e\x9b\x72\x64\xf1\x09\x39\
\xca\x34\x79\x2c\x66\xf8\x27\xcf\x53\x46\xe1\x6b\x06\x78\x1c\x22\
\x4f\x01\x8f\xef\xf4\xf4\x3d\x48\x02\x7c\x66\x39\x48\x83\x12\x96\
\x6e\x6b\xec\xe3\x29\x3c\x00\xd4\x8f\xd8\x57\xfd\x32\x2a\xd1\xf2\
\x6d\xde\x0e\x49\x96\x95\x2c\xc5\x41\x19\xb1\x10\x48\x69\xda\xb1\
\x2d\x96\x78\x04\xd8\x48\xd2\xa4\x80\x06\x93\x4c\x23\x35\x1d\xd6\
\x90\x66\x4c\xf7\x2c\x44\x34\x57\xbc\x50\xbe\xd9\x18\xf4\x67\x6b\
\xc7\xc3\xa2\x42\x91\x67\x05\x8b\xc8\x61\xc5\x44\x93\xa0\x08\xa8\
\x53\xa5\x9e\x78\x5f\x50\xc1\x45\xab\x4d\x17\x56\x95\xe7\x1c\xa8\
\x9f\x2b\x8b\x18\xb8\x1c\x67\x90\x22\x2e\x0e\x42\x53\xb5\x1c\x34\
\x89\x29\x8b\xc9\x91\x6c\x9d\xc2\xe7\x04\x3e\x00\xd5\x3e\x7f\x0b\
\x1f\x3a\x20\x87\x80\x28\x98\xe2\x5b\xc6\x38\x83\x02\xff\x05\x63\
\x02\x44\x77\xa4\x69\xdb\x23\x45\x9e\x51\xe2\xe7\xcc\x2f\x19\x03\
\xf2\xf1\x33\x2b\x90\x1c\x24\xc7\x66\xa4\x36\xe9\x16\x16\x45\xc6\
\xf9\x57\xcb\xa8\x94\x60\x81\x70\x22\xe9\xd8\x8a\x5d\x3e\xe2\x0b\
\x06\x59\x46\x37\x58\xc1\x52\x3e\x9f\x5f\xce\xb9\x3c\xce\x95\x51\
\x04\x70\x00\x27\x56\xe9\x58\x51\x66\xf9\x8c\x1e\x06\xcd\x86\xb6\
\x47\x81\x14\x47\x70\x9b\x6f\x32\x76\x92\x67\x1d\xbb\x01\x02\x63\
\x20\x9c\x66\x79\x8c\x4d\xac\x37\xab\x99\xa7\x07\x9b\x24\x38\x9a\
\x65\x2a\x34\x91\xe6\x2e\xfa\xb1\x70\x61\xde\xc0\x7c\x92\x33\x00\
\xd1\x49\x76\xe8\x23\x8b\xa4\x89\x0c\x8a\x49\x23\x1e\xc7\x66\x4e\
\x27\x43\x9d\x3d\x10\x37\x10\xb4\xcf\xa0\xa2\x99\x13\xf4\xb3\x89\
\x21\x7a\x4c\xf1\x46\x39\xcc\x78\xe2\x6e\xc0\x1c\x87\x78\x26\xbe\
\x07\x22\xca\x9f\x94\x21\x8e\x09\x0e\x50\xe1\x34\x42\xbe\xe4\x18\
\x73\x24\xe1\x13\xf6\x73\x92\x3b\xa8\x12\x4f\x60\x5b\xc8\xce\x19\
\x22\x4c\xf3\x35\xa3\x80\xdb\x46\x1e\xc6\xb9\x2e\xbe\xac\x00\x2c\
\x10\xb6\xc0\x42\x44\x34\x68\xe9\x35\xf3\x55\x01\xc9\x2c\x09\x48\
\x4a\xed\x1b\x03\x52\x16\x76\x53\x2c\x12\x4e\xee\xd5\x51\xb8\x28\
\xba\x44\x94\xc0\xd1\x06\x58\xb1\xa3\x96\xea\x90\xc1\xa3\x01\x0b\
\x33\x20\x25\x88\x2c\x0c\x6e\x60\x37\x8f\xb2\xb2\x4d\x86\x90\x80\
\xae\xe1\x63\x12\x98\x12\x35\x33\x5c\x42\x9e\xf3\x78\x98\x25\x89\
\x19\x04\x6a\xc1\x09\x1c\x81\x1d\xcb\x30\x85\xcd\x22\xd6\x72\x73\
\x62\x06\x1b\x4e\xcd\xc0\x64\x30\x52\x7b\xf1\x90\x38\x3a\x89\x95\
\x90\xc1\x5a\xb8\x81\xb0\x2d\x6c\x1c\xa2\x67\x49\x1b\x7c\x4a\x85\
\x06\x39\x9c\x78\x86\xae\x13\x08\x8c\x1e\x42\x12\x1a\x03\xaa\x0a\
\x2b\x96\x21\xe4\x6e\x5e\xe7\x04\x6f\xe2\x27\x3c\x4b\x76\x17\xd2\
\x0e\x29\xb4\x41\x40\x0d\x1c\xe0\x50\x80\x30\x37\x42\x6c\x42\xc0\
\xe5\x21\x1e\x04\x44\xc2\x99\x4e\x32\x10\x11\xad\x58\xab\x50\x65\
\x26\x31\x06\x7b\x42\x2f\x48\x3b\xd8\x46\xde\x42\x76\x7c\x2f\x59\
\x10\x37\x6d\x91\xb5\xe6\xbf\xd5\xe1\x2d\xa4\x99\x1f\x7e\xa5\xde\
\x72\x69\x96\x89\x8e\x67\xda\x8a\x15\xc3\x26\xa5\xe9\xb4\xb4\x8e\
\x26\xf8\x81\x7a\x24\x5a\x50\x05\xf5\x47\xcf\x75\x11\x98\x14\x9d\
\xdf\x4b\x46\xda\x89\xea\x3c\xc0\x35\xac\xd6\xd7\x56\x5a\xd4\x08\
\x1f\xe0\xdf\xf3\x7b\x56\x9f\xcc\x8e\x05\x57\x4b\x61\x61\x6a\x87\
\x4c\xfe\xf1\x6d\x7a\x7d\xcc\x61\x9b\xa5\xac\xe3\x69\xae\x67\x23\
\x7f\x8d\xfa\x51\x8b\x64\x96\xc6\x6e\xf5\x6b\xc2\xd8\x43\x91\x39\
\x20\xc6\x82\x2b\x02\x47\x20\x9a\x06\x89\x36\xbd\xd4\xcd\xfa\xb3\
\x3c\xce\x30\x19\x1a\xbc\x82\x91\x36\x14\xd4\xa8\xe0\x3d\xa9\x6e\
\xa1\x41\x7c\xcf\x66\xd4\xd4\x13\x6a\x4b\xf0\x7a\x2d\xf4\xa0\xe3\
\x3e\xc8\xa8\xd6\x17\x33\x4c\x01\x87\xa3\xf3\xb5\xb7\xf1\x99\x64\
\xfa\x1f\xde\xe5\xea\x56\x6a\x09\x07\x73\xfa\x88\x7f\xad\xba\x38\
\xf8\xc0\x47\x75\xd8\x07\x19\x6d\xe7\x16\x1c\x02\x5c\x5e\x8b\xfa\
\x92\x19\x26\xca\xb5\x5f\xca\xf3\x79\xaf\xed\xc9\x9f\x63\xe6\xc3\
\xe0\x72\x79\x55\x78\x40\xb5\xcd\xa0\x22\x41\x5f\x73\x96\x5d\x7c\
\x41\x0a\x41\x95\x13\x8d\xca\x03\xc1\x46\xb5\x13\xbf\x8b\x3f\x81\
\x39\xcb\xbe\x89\xbb\x28\x29\x9a\x24\xba\x0e\x18\x03\x41\x2f\xd7\
\x72\x94\xbf\x01\x35\xa6\xa4\xfb\x46\x78\x1b\x23\x0b\xfa\x1b\x9b\
\xcb\x59\xb7\xb2\x4d\x15\x63\xe2\x86\xfd\xe4\x48\xcd\x97\xd0\x63\
\x9a\xca\x7e\xff\x36\xf5\x3e\x6d\x60\xd3\x06\x41\xe0\x7f\x6a\xef\
\x12\x0d\x71\x16\x99\xf8\x5a\xb2\x9a\x19\xf3\xdc\x28\x2a\x8c\x97\
\xab\xbf\x0b\x7f\xa3\x46\x38\x75\x64\x96\x67\xff\x92\xad\x65\x55\
\x46\xa5\x55\x4a\xb7\xcb\x75\xa8\x8d\x6a\x93\x2a\xa9\x25\x6e\xea\
\x3e\xab\x97\xff\x07\xd2\xa5\xcc\x33\x19\x2f\xad\x2d\x96\x6a\xf9\
\xc5\xaa\x57\xf5\x7a\xd9\x17\xed\x1f\xd2\x05\x44\xd7\x49\x7e\x60\
\x5f\x92\x1f\x76\x96\x63\x33\x21\x0f\xf9\xef\xd8\x5f\x4d\xd0\x0d\
\xbe\x07\xe9\x76\x4d\xcc\xd6\xca\x9d\x35\x00\x00\x00\x00\x49\x45\
\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\xbe\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x30\x00\x00\x00\x30\x08\x04\x00\x00\x00\xfd\x0b\x31\x0c\
\x00\x00\x00\x02\x73\x42\x49\x54\x08\x08\x55\xec\x46\x04\x00\x00\
\x00\x09\x70\x48\x59\x73\x00\x00\x05\x31\x00\x00\x05\x31\x01\xb7\
\xed\x28\x52\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\x65\
\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\x3d\x49\x44\x41\x54\
\x78\xda\x9d\x58\x6b\x68\x5c\xd5\x1a\x5d\x67\x66\x32\xef\xa6\xb1\
\xf5\x91\x4c\x10\xaf\x28\x3e\x51\x14\x9b\x80\x1a\xae\x42\x89\x17\
\x41\x6b\xf1\x87\x8a\x8f\x7f\x05\x11\x44\x04\x07\xf1\xcd\x28\x3e\
\x8a\xe4\x82\xfe\x94\x1b\xae\x17\xb5\xda\xd6\x1f\xb7\xd6\xfb\x80\
\x9b\x5b\x51\x8c\xaf\x56\x14\x95\x1a\x94\x8a\x42\xc9\x03\x35\x6a\
\x9a\x99\xc9\x24\x33\xe7\x7c\x2e\x16\x7b\xcf\xc9\x90\x69\x73\x7b\
\xf7\x62\x27\x33\x73\xce\xb7\xd6\xfe\xf6\xfe\xf6\xb7\xbf\x73\x02\
\xc3\x7a\x6d\x67\x0e\x5b\x6d\x04\x83\x28\xa9\x03\x33\x98\x06\x7b\
\x30\x89\x03\x0f\x2d\xad\x67\x7d\x42\x81\x67\x37\xdb\x76\xdc\x88\
\x51\xe4\x0d\x80\xad\x36\x83\x7a\x1d\x13\x78\x3b\xd8\xf7\xc8\xfc\
\xff\x21\xf0\x74\xc1\xca\x28\xa3\x68\x30\x44\xf0\x7f\x3d\x7d\x82\
\xdd\xff\x45\x15\x63\xc1\xd8\x63\xb5\x93\x10\x78\x2a\x69\x3b\x50\
\x41\x7f\x04\x02\x21\xd1\x62\x8f\x24\x21\x7a\x22\x89\x14\x92\x44\
\x42\xc0\x1c\x2a\xc1\xf8\x13\xe1\xff\x24\x50\x29\xd9\x3e\x0c\x99\
\x88\x9b\xc4\x0a\xd1\x44\x0e\x59\xf6\x3c\x80\x3a\x96\xd0\x60\xef\
\x41\x9a\xe8\x21\x28\x44\x59\x1c\x0a\xb6\x57\x66\xd6\x15\x78\x62\
\x98\xf4\x03\x11\x5a\x22\x6e\x90\xfa\x54\x9c\x89\x73\x50\x70\xa3\
\x65\x93\x2f\x8b\x38\x82\xa3\xf8\x99\xf4\x59\x09\xa5\xc0\x6b\xb3\
\xc1\xf6\xa7\x0e\x9e\x50\xe0\xb1\x3b\x6c\xdc\xb2\xa1\xc6\x5d\x67\
\x3f\x0f\x57\x20\x8f\x2c\x91\xf1\xe3\x14\x7d\x4b\x77\x34\x29\x73\
\x10\xdf\x92\x3e\x2f\x5f\x78\xbd\x11\xec\x78\x7a\xd7\x71\x05\x1e\
\xb9\x13\xaf\x9a\x8c\x97\x50\xe5\xb8\x87\xb1\x09\x05\xf4\x92\x3e\
\x85\x40\x00\x4c\x12\x26\x91\x65\x34\xd8\x7f\xc4\x87\xf4\xa5\x88\
\x1c\x7a\x74\x1f\xee\x7a\xf6\xb5\xae\x02\x0f\x0f\xdb\x7b\x96\xe5\
\xd4\xa0\x46\xc3\xab\x71\x01\x8d\xfa\xd8\x93\x04\x7c\xc4\xb0\x19\
\x21\x01\x27\x52\xe7\xdd\x9f\x63\x12\x59\x14\x34\x55\xf4\xe2\x9a\
\xe7\x0e\xae\x11\x78\xa8\x64\x9f\xda\x40\x48\x83\x1a\x0d\x47\x39\
\xfe\xd3\xd0\x4b\x83\x84\xe0\xe8\xd9\x6d\xb5\x84\x43\x9d\xf8\x0e\
\xff\xe6\x5d\x05\x4d\x65\x30\x1b\x6c\xd9\x39\xd3\x21\xf0\x60\xd2\
\x3e\xc2\x90\x46\x8f\x10\x37\x63\x33\x06\xb0\x41\x81\xe8\xe8\xd9\
\x21\x09\x78\x09\x17\xc2\x9c\x50\xa2\x41\xbb\x59\xec\x46\xd2\x79\
\xc1\x88\xba\xf2\xf9\x10\xf2\x5c\x2d\xda\x61\x43\x21\x38\xf7\xc4\
\x9f\x48\x5f\xc2\x46\x05\x60\xaa\x8d\x64\xfb\x5b\x4f\x07\xd2\xc8\
\x10\x39\x6c\xa0\xcd\x0d\xb2\x6f\x52\xd6\x86\xa2\x1d\xab\x3c\x78\
\xa0\x80\x23\x51\x7f\x8b\x17\x17\x70\x0d\x2e\x11\x7d\x8a\x48\xc8\
\x03\xbf\x63\xe3\x16\x7b\x11\x0a\xbf\xe1\xef\xf4\xba\x81\x45\x7c\
\x82\x77\x68\x9b\x03\x6d\xe7\x70\xee\x9f\x6b\xce\x83\xa8\x1c\xf5\
\x87\x5a\xae\xb3\x70\x21\x4e\x77\xf4\x49\x27\x41\x11\x9f\x1a\xd6\
\x80\xfe\xe0\x30\x5e\x60\xa7\x27\x28\x60\x0b\xfe\x40\x96\x65\x8a\
\x46\xfd\x51\xd9\x4d\xd1\xfd\x9b\xa3\x32\x67\x12\xcb\xc4\x55\xe8\
\xc5\x29\x8e\x3e\x29\x02\x8d\xdf\x21\x6e\x5e\xae\x8e\x71\x62\x01\
\xd0\x64\x65\x91\xc7\x56\xf1\x34\xd1\xe2\xb0\xef\xdf\x0c\x32\xc0\
\x6e\xb2\x62\xa4\x85\xba\x18\x9b\x88\x1e\x91\xff\x87\xb7\x55\xd9\
\x5b\xa4\xba\x0f\xdd\xdb\xa7\x78\x19\xbf\x49\x98\x43\xd2\xb2\xe7\
\x70\x06\xa7\x78\x8a\x1c\x1c\x56\x11\xdb\xf0\x32\x05\xc2\x6d\x86\
\x96\xf6\xe5\x30\x9d\xdc\xe0\x9c\x5f\x44\x1d\x35\xac\xc8\xb8\x5b\
\x5b\xc4\xdf\xf0\x81\xf6\x02\x10\xc8\xe3\x48\x32\x39\xae\xe2\x97\
\x58\xd1\xde\x09\x6e\xa2\xc0\xbd\x39\x1b\x65\xb8\xf1\xa7\x7e\xd2\
\x6f\x42\xca\xa7\x04\x17\x80\xd6\x95\xfe\x10\xfe\x8a\x9f\xd0\x92\
\x80\x21\x40\xda\x0b\xf0\x53\x1f\x06\x30\x0f\xed\xa0\xd1\x7b\x73\
\xa9\x68\xab\xe5\x43\xad\xc0\xd9\x54\x2f\xfa\xa8\x77\xf4\x2b\x1a\
\x5f\x67\xab\xe2\x35\x4c\x2a\x49\xac\x38\x0f\x12\x88\x24\xe0\x25\
\xce\xc3\xbb\xc8\xf0\x57\xe4\x83\xad\xa9\x68\x04\xbc\x40\x09\xfe\
\x9c\xa0\x51\xc6\x2d\x6b\x08\xe5\x53\x99\xaf\x6e\x5f\x90\xfe\x47\
\x2d\x64\x43\x02\xa1\xee\x37\x7f\x4a\xb0\xa7\xb9\x0a\x13\x3a\x3f\
\xf8\xfb\x48\x2a\x1a\x34\xd1\x17\x50\xa4\x7a\x8b\x66\x9c\x20\x42\
\xa2\xa4\x08\xd0\x03\xdf\xea\xd8\x87\x8f\x51\x93\x30\x05\x14\x02\
\x06\xd0\x02\x12\x90\x04\xd1\x47\xb6\x26\xed\xc8\x33\x98\xb2\x92\
\x36\xbd\x4b\x6a\x7e\xec\x19\x54\x9d\x0f\x09\xf8\x63\xea\x1b\xec\
\xc7\x4f\xee\x7c\xf3\x12\x2d\x8d\x53\x67\x41\xbc\x57\x94\x30\x16\
\xb5\x3a\x28\xa5\x6c\x50\x3b\x12\x05\x5d\x08\x1c\x0c\xef\x93\x20\
\x4b\x6c\x94\x40\x1d\xff\xc5\x94\xd2\x20\xe9\x63\x09\xa5\x85\x24\
\xd2\xb2\x34\x6f\xcd\x6f\x45\x86\xaf\x11\xf0\x1e\x18\x7f\xea\xdc\
\x50\x86\x9f\x31\x8b\x79\x0c\xe0\x7c\x1c\x66\xa6\x5c\x42\x24\xba\
\x08\x4c\x29\x14\xac\x62\x81\xbd\xa9\xc0\x8c\xbd\xf4\x0c\x1b\x60\
\x6d\x0f\xe0\x11\xc7\x4b\xd0\xce\x97\x0d\xe2\x17\xf6\x59\x2c\x92\
\xa4\x2e\xd4\xd8\x3d\x42\xe4\xd8\x45\xd5\x61\x1f\x73\x26\x6c\xc6\
\x5c\xf0\xc5\x95\x8f\xb5\x93\x41\x56\x7e\x5d\x81\x0a\xbb\x6f\xf2\
\xd1\x2f\x6b\xec\x73\x87\xfd\xa2\xfb\x6f\x33\x09\x9b\xd6\xcf\x6e\
\x51\x84\xb6\x79\x0a\x79\x6d\x3c\xd0\xe5\xbb\x71\x0f\x36\xc6\xb3\
\xac\x88\x67\x9a\xd6\xfc\x53\xc8\x53\x3b\x1c\xf3\xdf\xa6\xe9\x01\
\x44\xa7\x05\x8c\x25\x44\x91\x16\x81\x4f\x15\x5b\xf0\x3c\x46\x90\
\x74\xe4\x3d\xc8\xa8\x90\xc9\x20\xad\x93\xc2\x62\x7a\xf2\x54\x21\
\xaf\x62\x0f\x12\xd4\x5c\x68\x17\x57\xa6\x9d\x49\x0a\x11\xc4\xfb\
\xa0\x17\x65\x3c\x8a\x53\x45\x9f\x16\x7d\x4e\xf5\x86\x06\xe1\x2d\
\x89\x5f\xc9\x96\xf0\x1e\x04\x93\x7e\x3a\xa6\x14\x80\x14\x11\x48\
\x22\x8a\xac\x04\xe2\x36\xc2\x2c\x74\x1d\x32\x84\xae\x0a\x69\xc2\
\x10\xd7\x81\x5f\x68\x67\xe8\x0c\x9f\x4c\xd8\x01\xab\x43\x7b\xe0\
\x88\x76\x6e\xe4\x24\xdc\x18\x65\xde\xd9\x36\xa2\x82\xe7\xd0\x0f\
\x79\xe0\x44\x32\x12\x90\x2d\x39\xbe\x26\x9b\x3c\xa8\xdb\x81\xc4\
\x2b\x4b\x36\x01\x25\xdc\xa3\x38\xa6\xec\x22\x3f\x48\x1b\x8f\x71\
\x6d\xbb\x16\xaf\xe3\x7a\x2f\x20\x7f\x42\xa1\x45\x2c\xe0\x07\xb2\
\x29\xd4\x27\x5e\x59\xa2\x10\xf6\x9b\xe2\x22\x60\x0e\x5c\xf6\x12\
\xf4\x20\x8f\x02\x91\xa3\x71\xb7\xd6\x87\x27\xf1\x0c\xfa\xbd\x07\
\x9e\x9e\xf6\xff\x72\x6c\x06\xbc\x05\x9d\x68\x6f\xd9\x8b\x28\x26\
\x48\xf9\x19\xae\xd4\x92\xb5\x78\xc3\x4e\xad\x82\x3f\xee\xbb\xb7\
\x3f\xe2\x52\xbc\x84\x4f\x14\x10\x5e\x60\x9a\xdf\xb3\xd0\x04\x55\
\xb1\x5f\xb9\x78\xd7\xbc\x8d\xc1\xa5\xac\x09\xd5\xcd\x4d\x42\x19\
\xa7\x1d\x55\xdd\x9b\xa1\x17\x0f\xa0\x8c\xd3\x48\xa9\xf3\x83\xb6\
\x6f\x8b\x49\x02\x63\xbb\xe6\x7d\xb2\x1f\xc3\x1c\x94\xb4\xa6\xa8\
\x5f\x57\xa6\xa7\x84\x8c\x28\xd1\x45\x46\x01\xe9\x70\x19\x1e\xc7\
\xe5\x0a\x90\x06\x26\xf1\xa5\xb6\x1e\xdb\x1c\x59\xe1\x04\xde\xa8\
\x59\x25\x90\xa3\x39\xfc\x03\xdf\xa2\xa6\xb5\x90\x88\x7a\x74\x3c\
\xb8\xeb\x19\xdc\xa2\xdc\x3a\x85\x37\x55\x02\x6b\x05\x2a\x6f\xd4\
\xbc\x00\x5b\x30\x1e\x1c\x0a\xb4\x77\x53\x8c\x8f\x69\x54\xdd\x91\
\xd8\x14\x34\x61\x1a\xb3\x87\xb9\xa2\x51\x70\x67\xc3\x51\xfc\xc5\
\x31\x04\x20\xdb\x38\x3a\x8b\xdf\xdb\x4a\x50\xf1\xcb\xf2\x85\xb7\
\xdc\xce\x02\xac\xa0\x4d\xa6\x1a\xa9\x5b\xf9\x2b\x21\x2d\xac\x6c\
\xbe\xc6\x38\x3f\xd1\x42\xc5\x2f\xb6\xec\xee\x2c\x7e\x25\xa1\xf2\
\x9d\x59\x5f\x07\xc9\x36\x5c\x85\xbc\x8a\x40\x2f\x11\xac\x29\xe0\
\x45\xaf\xf3\xe1\x7d\xbc\xa9\xd4\xc2\xb8\x53\xf9\xbe\x7b\x4d\xf9\
\xae\x76\xab\x1e\x40\x22\x45\xf3\x12\x7d\xb8\x01\x03\x4a\x77\x71\
\x95\x2a\x01\x4f\xef\xee\x9c\x66\xb8\x7f\xe5\xef\xd3\x03\xc8\x9e\
\xee\x0f\x20\x92\xe0\x23\x14\xb2\x34\x24\x96\x49\x30\xc4\x5a\xbb\
\x4f\xb9\xa6\x8b\x00\xc9\x17\xf0\x4f\x7c\xcc\x2b\x19\x57\x2c\x83\
\x8f\x50\x7b\x8e\xff\x08\x25\x89\x61\xec\xb3\x01\x6b\xef\x4b\xc3\
\x59\xb8\x88\x61\x78\x8a\x2b\xc8\x02\x97\x90\x7f\xc5\xe7\x38\x8c\
\xef\xf9\x3d\x2d\x72\x5d\x9b\xc5\xf6\x3d\x27\x7e\x08\x94\x44\x89\
\x12\x43\xee\x19\xc6\x09\x85\xe8\x45\x11\xbd\x04\x70\x8c\xa8\xb2\
\x27\x1d\xb1\x26\x46\x91\x43\xfa\xf5\x1f\x63\x25\xc1\x07\xf1\xa0\
\x62\xfd\x12\x59\x05\x8b\x0f\x53\x0f\x4f\x3e\x67\x7c\x10\xdf\x13\
\x9e\xc4\xab\x84\x5b\x0a\x56\x0e\xca\x56\x04\xac\x0d\x38\x01\x76\
\x07\x7d\xae\x1a\x5f\x25\xec\x3d\x89\x57\x09\xb1\x08\x5f\x86\x04\
\x37\xda\x28\xf2\x58\xf3\x32\x44\xad\x1e\x4c\x18\x5f\x86\xec\x3d\
\xe9\x97\x21\x9d\x32\xee\x75\x4e\x50\xc2\xa0\x95\x68\x32\x83\x69\
\x73\xaf\x73\xf6\x2e\xad\x67\xfd\x3b\xb5\x7f\xb6\xdb\x8c\x50\x71\
\x5a\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x07\x6e\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x37\x5c\x00\x00\x37\x5c\
\x01\xcb\xc7\xa4\xb9\x00\x00\x00\x06\x62\x4b\x47\x44\x00\xff\x00\
\xff\x00\xff\xa0\xbd\xa7\x93\x00\x00\x06\xe0\x49\x44\x41\x54\x78\
\xda\xed\x56\x5b\x4f\x54\x57\x14\x5e\xfb\x9c\x39\x67\x6e\x32\xc3\
\x8c\xdc\x0d\x03\x2a\x97\xd8\x02\x5e\xe0\xc5\x68\xaa\xb5\x29\x91\
\x26\x35\x69\xd2\x18\xff\x80\x28\x62\x8d\x2f\x8d\xbe\x35\x6d\x53\
\x1f\x7c\xa8\xfa\x52\x63\x0b\xa6\x35\x7d\xe9\x83\xa9\x4d\xaa\xb5\
\x51\xeb\x8b\x51\xaa\x20\x2a\x6d\x6c\x01\x21\xca\xfd\x36\x30\x32\
\x03\x0c\xcc\x9c\xdd\x6f\xed\xcc\x9c\x50\x54\x7a\x79\x6b\xea\x82\
\xcd\x3e\x87\xbd\x67\x7f\xdf\xfa\xd6\x65\x0f\xbd\xb4\xff\xbd\x89\
\xc6\xc6\x03\x94\x4c\x26\xc9\x34\x4d\x9a\x9f\x9f\xa7\xce\xae\x4e\
\x31\x31\x3e\x4e\xba\xc3\x41\x52\x4a\x7a\xae\x49\x52\x7f\x84\x10\
\xb4\xb0\xb0\x40\xa5\xa5\xa5\xb4\x69\x53\xb5\x74\xb9\x5c\x34\x33\
\x33\x43\x6c\xb7\x6e\xde\xa2\x1f\x2e\x5f\xa6\xbf\x32\x07\x83\x6a\
\xba\x46\xd3\xd1\x69\x0a\x15\x86\x28\xc3\x97\x21\x35\xa1\x91\xd3\
\xe5\xa4\x8f\x3e\xfc\x98\x96\xb3\x1d\x6f\xbc\x4e\x96\x65\x51\x78\
\x32\x4c\x57\xaf\x5d\x15\x73\xb3\xb3\x64\x3a\x4d\xa9\x08\x0a\xa2\
\xec\x9c\x6c\x1a\x1b\x1d\x5b\x5e\x81\xca\xaa\x0a\xe5\x89\xae\xeb\
\xec\x8d\xf3\x69\x24\xe2\x8f\xc7\xe3\x52\x68\x82\x20\xc0\x9f\x55\
\xc0\xb3\x5c\xf4\x4c\xac\x00\x1c\x28\x0c\x85\x44\xed\x9b\xb5\x91\
\x23\xef\x1f\x8d\xbf\xf5\x76\x9d\x30\x4d\x43\x2e\x2c\x24\xc8\xed\
\x76\x53\x57\x67\x17\x0d\x0d\x0d\xbf\x58\x01\x96\xed\xce\xed\x56\
\x82\x19\xe7\xce\x7d\x75\xb1\xad\xad\x6d\xf3\xbd\xfb\xf7\x66\x9d\
\x4e\xa7\xc6\xe0\x9a\xa6\x31\x09\x1b\x70\xb1\x31\x71\x28\x28\xb7\
\x6f\xdf\x6e\x38\x4d\xe7\xef\xb9\x05\x39\x7b\xa4\x45\x8f\x4a\xcb\
\x4a\xf4\xcc\xcc\xcc\x64\xd2\x4a\x2a\xf0\xbc\xbc\x5c\x1a\x1e\x1e\
\x79\x3e\x81\x68\x34\x2a\x7c\xfe\x0c\x09\x29\x73\xae\x5c\xbd\x52\
\x93\x97\x9b\xef\xa9\x78\xb5\xd2\xad\x3b\x74\xa1\x6b\x4a\x15\xce\
\x0f\x56\x88\x01\x99\x90\x3d\x63\xa8\x10\x18\x0e\xd3\x1a\x1f\x1f\
\xaf\xa9\xaa\xaa\xba\x3e\x3d\x3d\xfd\x0e\x46\x5b\x22\x91\xd0\x4b\
\xca\xd6\x26\x4d\xc3\x24\x3c\x53\x4e\x4e\x0e\x8d\x8e\x8e\xd2\x52\
\xd3\x3d\x6e\xb7\x60\xa6\x00\xf3\xc7\xa2\xb1\x06\xc3\x30\x5c\xf1\
\xf8\xbc\x8c\xcf\xcd\x51\x24\x12\xa1\x8a\x8a\x0a\x9a\x98\x98\xa0\
\x70\x38\xcc\xde\xaa\x24\x9b\xc3\x1a\xc2\x44\x4f\x9f\x4e\x93\x2f\
\xc3\x47\xfe\x4c\xbf\xc0\x1e\x2b\x3f\xbf\x20\x73\x78\x64\x78\xf7\
\x7c\x7c\xbe\x3d\x3a\x1d\xed\x9e\x0a\x4f\xe9\x48\x70\xe9\x30\x90\
\xd0\xf8\xe1\x90\xcc\xce\xce\x2e\x21\xe0\xf5\x8a\x58\x2c\x46\x89\
\x85\x84\x3f\x10\x0c\x36\xae\x0c\xae\x74\x72\x55\xb0\x32\x75\x75\
\x75\xe2\xe0\xc1\x83\xa2\xa0\xa0\x40\xb4\xb7\xb7\x0b\x00\x0b\x84\
\x43\xc0\x6b\x01\xaf\x44\x30\x18\x10\x7b\xeb\xf7\x8a\x9d\x3b\x77\
\x52\x4f\x4f\x8f\x06\x99\xad\x55\xab\x56\xb9\x46\xc7\x46\x77\xcf\
\xc5\xe3\x3d\x91\xc8\xd4\x03\x80\x82\x84\x05\x7c\xfe\xb5\x08\xa1\
\x55\xe4\x6d\x02\x4e\xd3\x14\x00\x83\x4c\x49\x84\xcd\x7f\x20\x10\
\x08\x3a\xd9\xc3\x5d\xbb\x76\x89\xfa\xfa\x7a\x55\xa2\x20\x40\xa1\
\x50\x88\x40\x82\x89\xd9\x92\x36\x36\x36\xd2\x9a\x35\x6b\x78\x8f\
\xd8\xb8\x71\xa3\x1c\x18\xe8\xd7\x46\x46\x46\x64\x41\x7e\x81\x8e\
\x52\x7e\x17\x40\x91\xf0\xc4\xe4\x2d\x87\x43\xd7\x2c\x4b\x4a\x0c\
\xb2\xa0\xb6\x61\x98\x2a\xb4\x8a\x00\x16\xe1\x59\x9c\x13\x4d\x11\
\xc8\xc8\xc8\x70\x06\x83\x41\x3a\x72\xe4\x88\xe0\x04\x85\xb7\x3c\
\x14\x89\xe2\xe2\x62\xba\x7f\xff\x3e\x05\x02\x01\x3a\x74\xe8\x90\
\x02\x07\x08\xd6\x95\x67\xac\x94\xbc\x7e\xfd\xba\x06\x82\xd8\xbf\
\xca\x0a\x87\x27\xeb\xe6\xe7\xe3\xae\x68\x34\x76\x75\x21\xb1\x20\
\xd8\xa0\x06\x3b\xc0\x39\x05\x70\x0c\x01\x63\x2f\x61\x81\x15\x2b\
\x56\x34\x64\x67\x67\x39\x91\xb9\xc8\xde\x21\xb1\x75\xeb\x56\xb0\
\x35\x88\x8d\xf7\xe4\xe7\xe7\x53\x51\x51\x11\x6d\xde\xbc\x99\x4a\
\x4a\x4a\x6c\x29\x79\xcf\xe4\xe4\x24\x9d\x3a\x75\x4a\xf4\xf5\xf5\
\x49\xec\xe5\x50\x31\xa1\x24\xf2\xe8\xb5\xd8\x4c\x2c\xb4\xae\x7c\
\xdd\xc5\xc1\xa1\x41\x0b\xdb\x39\x84\xea\x3c\x0b\x64\x74\x4b\x5a\
\x22\x55\xdc\x01\x8f\xd7\xd3\xe0\xf3\xf9\x9d\x2c\x73\x77\x77\xb7\
\xe0\xac\x65\x12\x8e\x54\x57\x4c\x93\x80\x42\x4a\x42\x70\x67\x70\
\x24\xe3\x53\x3a\x7e\xfc\x38\xa1\x84\x09\xc6\x0e\x49\x78\xc9\x40\
\x8a\x44\x2c\x1a\xad\xee\xea\xea\xda\xe8\xf3\xf9\xbe\x4f\x24\x13\
\x71\x26\x07\x53\x67\xea\x00\x4f\x17\x77\x10\x32\x36\x94\x95\x95\
\x99\x9c\x94\xec\x45\x47\x47\x07\xa1\xbc\x68\xcb\x96\x2d\x8b\x95\
\xe0\x0f\xda\xcd\x0b\x64\x15\xf8\xcd\x9b\x37\xd5\xff\x00\xcc\x7b\
\x18\x5c\x91\xe0\x81\xea\x48\xc6\xe3\x73\xeb\x46\x46\x46\xb7\x83\
\xdf\x45\xac\x45\xd3\x0d\x4e\xc7\xb0\x09\x40\xd2\xfd\xf8\x80\xe9\
\xf7\xfb\x09\x09\x21\x30\xa8\xb7\xb7\x57\xc5\xb8\xa6\xa6\x86\x60\
\xe9\x7e\x60\x8f\x13\x27\x4e\xd0\xa5\x4b\x97\x18\x94\xcb\x94\x09\
\xa4\x07\x2b\xc1\x33\xab\xa5\xe7\xe5\xe5\x25\x00\x5a\x14\x0e\x4f\
\xec\x40\x5f\xf9\x1a\x6b\x2a\x0b\x1d\x8b\x1b\x1b\x1b\x00\x59\x7e\
\xd5\x64\x3c\x1e\x0f\x6d\xdb\xb6\x8d\xc3\xa0\x0e\x87\xd9\x4d\x08\
\xa6\xe6\xda\xda\x5a\x6a\x6d\x6d\xa5\xc1\xc1\x41\xf5\xbe\xd8\xd2\
\x5e\x32\x09\x01\x4b\xad\x7b\x01\xee\xc4\x3c\xa3\xce\x4b\x0d\xde\
\x59\x0a\x99\xdb\xb1\xcf\x0b\xc6\x12\x26\xf8\x96\x6b\x6e\x6e\x66\
\xef\xb9\x01\xd9\x0a\xc0\xec\x30\xa0\x6a\xa8\xa5\xa5\x85\x0e\x1f\
\x3e\x4c\x03\x03\x03\x76\xeb\xe6\x10\xc0\x04\xce\xe2\xcf\x24\xf1\
\xae\xa3\x59\x3d\x24\xa2\x3d\x18\x0f\x6c\xdc\x45\x21\x28\x45\x0e\
\x44\xe1\xb5\xc4\x21\x56\x79\x79\xb9\xbc\x71\xe3\x86\x44\xe7\x92\
\x5c\xdb\x63\x63\x63\x72\x6a\x6a\x4a\x3e\x7e\xfc\x58\xf6\xf7\xf7\
\x4b\x64\xbd\x44\x92\xaa\x35\xe4\x8c\x3c\x7f\xfe\xbc\x44\x79\xca\
\xd4\xa1\x56\x7a\x86\x53\x09\x94\x33\x3f\xb7\x80\xc8\x5a\xcc\x36\
\xe6\xd2\x1c\xc8\x02\x81\xfd\x5e\xaf\xc7\x28\x0c\x15\xd2\xd9\xe6\
\xb3\x62\xfd\xfa\xf5\x2a\xc3\xe1\x28\x2a\xc1\x20\xf4\x78\x3a\x79\
\xf2\x04\x75\x74\x3c\xa0\xea\xea\x1a\xf6\x8c\xbd\x55\xad\xb9\xb2\
\xb2\x92\x78\xff\xb5\x9f\xae\x49\xe4\x92\x4a\x42\x94\x35\x13\xd0\
\xa1\xde\x8f\xd8\xbb\x07\xd2\xf7\x2d\xf6\xfc\x99\x1c\x60\xf9\x50\
\x2a\x68\x2a\x26\xc1\x5b\x4a\xd7\x2b\xae\x07\x75\x2f\x9c\x3e\xfd\
\x19\xb5\xb6\xa9\x9b\x53\x35\x91\xfa\xbd\xfb\xb8\x44\xd5\x3e\x48\
\xcd\xdf\x0b\x24\x37\x24\xb4\x5f\x09\xaf\x2d\xa8\xa7\x83\xf4\x37\
\x00\xdf\x87\x73\x22\x4b\xc1\x97\x2a\x90\xcd\x0a\xe4\xe5\xe7\x19\
\x48\x1a\x06\x12\x45\x68\xbf\x08\x05\x2e\xa3\x71\x6a\x6a\xfa\x82\
\x7e\xf9\xb5\x03\xe4\x5c\x84\xfb\x9e\x9e\x3c\xe9\xc3\xed\x36\x02\
\xcf\xab\x88\xab\xe6\xc2\x85\x6f\xe5\xb1\x63\xc7\x84\x95\x4c\x72\
\x28\x2c\x84\x48\x47\x89\x9e\xf6\x7a\xbd\x0d\x44\x14\x03\x81\xa5\
\xe0\xcf\x2a\xc0\x92\x7a\xdc\x1e\x22\xfc\x72\xdd\x37\x35\x37\x11\
\x1a\x07\xee\x80\xbb\xf4\xa8\xa7\x9b\x1b\x10\x4b\x6e\x2b\xd3\x06\
\x35\x58\x81\xd5\xc5\xab\xe5\x99\xcf\xcf\x08\xbf\x2f\xc3\x92\x48\
\xca\x87\x0f\x7f\x63\xf0\x4f\xd0\x53\x3e\xe8\xec\xec\x54\x6d\xf6\
\x79\xe0\x4b\xab\xe0\x15\xd4\xfd\x9d\x0d\x1b\xaa\x3c\x78\x41\xfc\
\xbc\x04\x19\xd5\xed\xe5\x72\xab\x99\x63\xae\x36\x27\x52\x35\xcf\
\xad\x78\x76\x66\x96\xb8\x71\xc1\x90\x8c\x33\xa2\xf5\x4e\x5b\x02\
\xd2\x1f\xc5\xfb\xa7\xa9\xb0\x4a\x98\x5d\x92\xcb\x29\xa0\xe5\xe6\
\xe6\x6a\xb8\x92\xe1\x5d\x02\x3d\xc0\x2b\x18\xd8\x8d\xe1\x82\xec\
\xfc\x1d\x11\x0d\x84\x09\x28\x70\xbe\xc0\xe6\x8c\x39\x72\xe8\x06\
\x79\xbd\x2b\xb8\x22\xb4\x9f\x5b\x6e\x47\xb1\xf6\x1e\xb6\x7c\xc9\
\xe0\x50\x47\x42\xad\x17\x82\x2b\x02\x48\x3a\x95\xe9\xb0\x71\xdc\
\x6e\x4f\xda\xef\xde\x2b\x43\xc2\x49\x78\x9b\x6e\x3c\xa9\x79\x71\
\xf5\xb0\x47\x94\x6e\x32\x12\x5d\x4e\xcb\xc9\xce\x19\x06\xf8\x7e\
\x22\xfa\x8e\x37\x82\xac\xc4\x9a\x0a\xd7\x72\x26\x96\xbc\x97\x62\
\xac\xc1\xb0\xd4\xda\xdf\x33\xc9\xea\x21\x44\xbd\x08\x49\x67\xaa\
\xa3\x2a\xd9\xff\x33\x66\x7f\x4f\x43\xfd\x0a\x36\x3c\xfe\xa3\x81\
\x58\x8b\xac\xac\x2c\x41\x2f\xed\x5f\xd8\x1f\x39\x34\x0b\x23\x00\
\xd0\xd4\x90\x00\x00\x00\x22\x7a\x54\x58\x74\x53\x6f\x66\x74\x77\
\x61\x72\x65\x00\x00\x78\xda\x2b\x2f\x2f\xd7\xcb\xcc\xcb\x2e\x4e\
\x4e\x2c\x48\xd5\xcb\x2f\x4a\x07\x00\x36\xd8\x06\x58\x10\x53\xca\
\x5c\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x04\xef\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\x6c\x49\x44\
\x41\x54\x78\xda\xc5\x56\xdf\x6f\x1b\x45\x10\x9e\xfb\x6d\xc7\x76\
\x62\xb7\x76\x13\x0a\x11\x22\x05\xa9\xa2\xef\xbc\x20\xf1\x14\xde\
\xf8\x37\x80\x67\xd4\x97\x0a\x89\xf2\x04\xad\x54\xf8\x7f\x90\x8a\
\x04\xaa\x2a\xb5\x6f\x45\x34\x84\x22\x88\xd4\x22\x4c\x8c\x93\xda\
\x71\xb1\xef\xec\xbb\xdb\x5b\x66\x46\x1e\xfb\x7a\x77\xe6\x42\xa4\
\xd2\x4d\xd6\x33\xbb\x77\x37\xf3\xed\x37\xdf\xee\x9d\xad\xb5\x86\
\x97\xd9\xec\xb9\x35\xb0\xeb\x97\x09\x40\x5f\xfd\xe4\xea\xed\x44\
\xab\x5d\xb9\xf0\xce\xbb\xef\xc1\xce\x9b\x97\xc1\xb1\x2c\x80\x0c\
\x4b\x86\x81\x78\xb1\x9b\xa6\x01\xfc\x67\x48\xe7\x8b\x6c\xf1\x12\
\xcf\xc5\x51\x0c\x7b\x3f\xfd\x08\xf7\xef\xde\x01\x69\xad\xd6\xb9\
\x6f\xaf\x7f\x7e\xfd\xfd\x34\x00\xf0\xfd\xc9\xee\xc3\xbd\x87\xb0\
\xb9\xb9\x05\x17\x3a\x1d\x38\xdf\xb9\x00\xdb\xdb\xaf\x83\xe7\x3a\
\x85\xc8\x8d\xf9\x0f\x59\x4e\x9e\xf5\x19\x84\x01\xfe\x2c\x84\x7e\
\xff\x2f\x98\x06\x53\x90\x36\x48\x9e\xee\x66\x19\x80\x24\x49\xa0\
\x56\xab\x81\x63\xdb\xec\x9b\xa0\x79\x85\xbf\xf7\x4f\x8a\x92\x67\
\x18\x79\x7e\x60\xa4\x00\xbe\xd6\x6e\xa0\xd1\x1c\x33\x9d\xab\x10\
\x40\x73\xa3\x09\x9e\xe7\x2d\x6e\xb0\x2c\x03\xde\x7a\xb5\xc5\xbe\
\xce\x26\xe7\x44\xe2\x8a\xe5\x39\x61\x80\xc7\xc1\x34\xa4\x4b\xe5\
\x00\x68\x37\x34\x1a\x0d\xf1\xf9\x61\x0b\x19\x70\x6d\x0b\x56\xd5\
\x60\x35\x00\x89\x89\xc9\xa8\x43\xc2\x31\x53\xb9\x0a\x19\xc8\xc4\
\xd7\x08\x00\x6f\xb0\x25\x9a\x5c\x28\x2e\x83\x9e\x07\xa6\x84\x1a\
\x7f\xd0\xe5\x71\xac\x14\x8f\xd3\xf1\x95\x52\xe5\x00\x12\x8d\xb8\
\xf1\xc1\x9f\x1f\x1f\x43\x51\xd3\x99\x91\xd6\xe2\x31\x12\xb2\x3c\
\xd8\x3a\x57\x03\x95\xe4\x4a\x50\x0e\x80\x86\x11\x3e\xb9\xbd\xb9\
\xfe\xbc\xc8\x34\xff\xe7\xe8\x24\xa3\x19\xc8\x82\x0d\xee\xb3\x50\
\xd1\x8a\x4f\xa7\x81\x74\x53\x71\x02\x31\x75\x2b\x0d\xac\x00\x88\
\xac\x5e\x92\xb2\x5d\xfa\x31\x2e\x42\x69\xfd\xdf\x35\x10\x27\x0a\
\x22\xda\x8e\x91\x5a\x5d\x02\x59\xbd\xb8\x39\x06\x80\x35\xa0\x12\
\x7d\x86\x12\xe0\xd3\x51\xac\xa0\x77\x3c\x96\xa9\x32\x2d\x48\xed\
\xc5\xe5\xd6\x5a\xf7\x90\x4d\x55\x2e\x42\x9d\x01\xa0\x70\x4c\xf4\
\x35\x1b\x15\xd9\x57\xf9\x44\x99\x64\x3c\xbb\x60\x80\x1d\x8a\xc1\
\xc9\xd3\xf1\x75\x21\x03\x39\x0d\x68\x16\xa1\x51\xb2\x74\x9d\x06\
\x25\xe3\xa5\x06\xc8\x61\x0d\xa4\xe3\x27\xa7\xd1\xc0\xbd\xbb\xdf\
\x43\xaf\xd7\x83\xc0\xf7\x4b\xe8\x2f\x16\xa6\x30\x53\x5d\x5b\x83\
\x27\xbf\x3d\xca\x6a\xa0\xbc\x04\x4f\x7e\xfd\x85\x7a\xfa\x0d\x98\
\xb5\xc5\xa0\x56\x2b\xbe\xa4\x04\x38\xf9\x82\x5b\xc9\x49\xf8\xff\
\x7d\x19\x15\x6b\x40\xbf\x58\x06\xce\x5e\x82\x0f\x3f\xfe\x08\xde\
\xd8\xd9\x29\xaa\xe5\xca\x3a\x0f\x06\x03\xf8\xf4\xda\x35\x30\x4d\
\x13\xe3\x6a\xde\xd2\x9b\x9d\xce\xbf\x8b\x30\x8e\xe3\x5c\x60\xaf\
\xe2\xb1\x8a\xc7\xe3\xb1\x08\x2f\x2b\x30\x9a\x93\x2e\x73\xfc\x61\
\x53\xa9\x54\xc0\xb2\x2c\xde\x09\xb3\xd9\x2c\x1f\x5f\x00\x14\x09\
\x43\x5a\xfa\x04\xbb\xf1\xc5\x97\x74\xac\xca\xe7\x1b\xdc\xb8\x79\
\x93\x56\x28\xa0\xe8\x3e\xb2\xcb\x17\x0f\x83\x32\x89\x6f\xfa\xb2\
\xa2\xf9\x33\x00\x98\x07\xa5\xf6\xf4\xf8\x18\xa4\x0d\x4f\x4e\x28\
\x09\x01\xa0\x95\x91\xcf\xcf\x4b\xd7\xcb\x17\x82\x98\x53\x00\x28\
\xa0\x28\x9c\x4e\x29\x78\x16\x20\x51\x4b\xf3\x44\x2d\xdb\x28\x8a\
\x64\xe5\xc2\x02\x67\x15\x30\x9a\x80\x21\x23\xd5\x6a\x15\x6a\xf5\
\x3a\x0c\x07\x83\x02\x0d\x14\x20\xb4\x6c\xbb\x10\x40\x14\x47\x10\
\x04\x81\x24\x20\x2b\x4c\x90\xe5\x1e\x22\x28\x7b\x0e\x34\xa6\x18\
\x74\xaf\x01\x10\xe0\xa2\xa2\x38\x3e\x1d\x03\xe0\xba\x1c\x7c\x8a\
\x0f\xc5\x71\x24\xe5\x20\x2b\xc2\xa2\xd5\x4b\x09\x24\x39\x5f\x8f\
\x42\x64\x87\x45\xa8\xf9\x85\x64\xa0\xb5\x4d\x0b\x9e\x8d\x46\xd0\
\x58\x5f\x2f\x02\xa0\x7a\x60\xc0\x56\xf6\xc4\x0a\xfc\x00\x1c\xc7\
\x81\x31\x5a\x7f\x32\x61\x5d\x34\x9b\x4d\x14\xa2\x2f\x49\x85\xfe\
\x85\x0d\xc3\x10\x81\xd1\x7c\xb2\x10\xa8\x39\xdf\x9e\xed\x76\x1b\
\xfa\xfd\x3e\x18\xd8\x34\x36\x02\xc0\x83\xcb\x97\x2e\x7d\x50\xa9\
\xd6\xbe\xc1\x52\xb5\xd3\xfb\x55\xe8\xbe\xf5\xd5\x2d\x01\x45\x9d\
\xb6\x26\x05\xcf\x89\x50\xfc\x28\x0c\x59\x2b\x02\xc0\x32\x4d\x9e\
\xef\x76\xbb\x2c\x5e\x6c\x55\x4c\x1b\x08\x03\xc6\xa3\x83\x83\x3f\
\x37\x36\x36\xbe\xde\x7e\xe5\xe2\x67\x78\xc3\x1a\x8b\x30\x0a\x39\
\x91\x3d\xd7\x42\x6a\xc5\x44\xbd\xd0\x9f\x3e\x8c\x28\xb8\x68\x2a\
\x5d\x32\xd1\x90\x8c\x43\x34\xe7\xb1\x77\x05\x00\xdd\xf9\xf7\x68\
\x34\xfa\x0e\x95\xdf\xf2\x3c\xef\x22\x11\xf0\xf6\x95\x2b\xd6\x0f\
\x0f\x1e\xec\xb8\xae\xeb\xb9\x8e\xe3\xa2\x28\x5d\x04\xe3\x61\x12\
\x87\xca\x27\x87\x80\xe6\x2f\x38\x15\x22\x98\x30\xc2\x36\x1c\x0e\
\x7d\xdb\xb1\x0f\x0e\x0f\x0f\x67\x78\xd5\x58\xe6\x60\xba\x15\x3a\
\xf7\xd0\x9b\x61\xe7\x12\x70\x0c\x8c\xe5\xa3\xbb\x17\xcc\x66\x8f\
\xb1\x3b\x34\xfd\x47\xb7\x9b\x54\xaa\xd5\x10\x4f\xb5\x44\xd0\x23\
\x4b\x80\x40\x89\x15\x8d\xc0\x34\xd5\xb5\x5e\xaf\x1b\x78\xfa\x19\
\x84\xe7\x04\xcf\x88\xfd\xfd\xfd\xe4\xe8\xe8\xc8\x9d\x4c\x26\x14\
\xc7\xcc\x7f\x35\x70\xf2\x67\x94\xf7\x1f\xdf\x9a\xd2\x93\xfb\x43\
\xb7\xa7\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x06\xfa\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x01\x73\x52\x47\x42\x00\xae\xce\x1c\xe9\x00\x00\x00\
\x06\x62\x4b\x47\x44\x00\xff\x00\xff\x00\xff\xa0\xbd\xa7\x93\x00\
\x00\x00\x09\x70\x48\x59\x73\x00\x00\x0d\xd7\x00\x00\x0d\xd7\x01\
\x42\x28\x9b\x78\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xd8\x0c\x1e\
\x0d\x25\x1d\xc4\xa2\xd6\x22\x00\x00\x06\x7a\x49\x44\x41\x54\x58\
\xc3\xe5\x97\x7d\x6c\x14\x65\x1e\xc7\xbf\x33\xbb\xf3\xd2\xce\x76\
\xd9\x2d\x75\x29\x2c\xc5\x72\x96\xb6\x50\x31\x96\x3b\x6a\xfa\x72\
\x77\xad\x41\xf6\x20\xd0\x33\x08\xf4\x82\x9a\x98\x54\x45\xf1\xf4\
\x80\xbb\x78\x09\x67\xb8\xd2\x20\x96\x78\x39\x8d\x2f\x77\xc1\x9c\
\x17\x3d\x2a\xd6\xb4\xb5\x52\x63\x05\x2d\xa5\x21\xf4\x3c\x82\x39\
\x81\x22\xa5\x94\xa6\xdd\xdd\xdb\xda\x76\x5f\x67\x67\xbb\xbb\x33\
\xf3\xcc\xce\xfd\xc3\x8e\x2d\x72\x0a\x05\xfe\xba\x49\xbe\x7f\xcc\
\xf3\xfc\x9e\xe7\xf7\x79\x7e\xbf\xe7\x15\xf8\x7f\xff\xa8\x1b\x6d\
\x50\x5e\x5e\x5e\x4c\x08\xe9\xe6\x38\xce\x69\xb3\xd9\x90\x91\x91\
\x91\xae\xea\x6b\x6d\x6d\xad\xba\xd1\xfe\xcc\x37\x62\x5c\x55\x55\
\xb5\x48\xd3\xb4\xcf\x04\x41\x88\xec\xdf\xbf\xdf\x99\x2e\x2f\x2b\
\x2b\x43\x5d\x5d\x5d\xe5\x6c\x22\x70\xdd\x00\xd5\xd5\xd5\x77\x68\
\x9a\x76\xd4\xe9\x74\x92\xca\xca\xca\x7c\xa7\xd3\x39\xb3\x23\xb3\
\x19\xb7\x0d\x60\xd5\xaa\x55\x59\x9a\xa6\x75\x15\x17\x17\xe7\xd4\
\xd5\xd5\x09\x17\x2f\x5e\xcc\x70\x38\x1c\xb7\x04\x80\xfe\x21\x03\
\x97\xcb\xc5\x51\x14\xf5\x51\x49\x49\xc9\xdd\x8d\x8d\x8d\x36\x86\
\x61\x32\x96\x2f\x5f\xfe\xdd\x91\xdc\x8e\x08\xac\x5d\xbb\xd6\xa4\
\xeb\xfa\xa1\xc5\x8b\x17\x57\x37\x35\x35\x51\xaa\xaa\x52\xcb\x96\
\x2d\x83\xcd\x66\x83\xaa\xaa\x86\x1d\xc3\x30\xb7\x1e\xa0\xb6\xb6\
\x96\xd2\x75\xfd\x80\xc3\xe1\xd8\xb0\x6f\xdf\x3e\x08\x82\x00\x5d\
\xd7\x21\xcb\x32\x7c\x3e\x1f\xb2\xb3\xb3\x6f\x6f\x04\x4c\x26\x53\
\x93\xd5\x6a\xad\xdf\xbb\x77\x2f\xec\x76\x3b\x00\x80\x10\x82\x50\
\x28\x84\xd1\xd1\x51\x58\x2c\x16\xc3\x56\xd7\xf5\x9b\x07\x38\xfa\
\x07\xaa\x8f\xa6\x50\x91\xc1\xea\xe0\x19\xe0\xcd\x4b\x36\xec\xde\
\xbd\x1b\xb9\xb9\xb9\x86\xb1\xaa\xaa\x08\x06\x83\x18\x1d\x1d\x45\
\x5e\x5e\x9e\x51\x6e\xb3\xd9\x6e\x1e\x20\xa9\x71\x15\xb5\x2f\x25\
\x8c\x8a\x03\xaa\x0a\x93\xc9\x04\x42\x08\x74\x5d\x47\x2a\x95\x42\
\x34\x1a\xc5\xc4\xc4\x04\xc2\xe1\x30\x44\x51\x34\x6c\x09\x21\xb3\
\x07\x68\xdc\xf3\xc7\x93\xe7\xfa\xcf\x57\xc6\xc9\x31\x40\x9f\x39\
\xb1\x62\xb1\x18\xe2\xf1\x38\x64\x59\x06\x21\x04\x91\x48\x04\x81\
\x40\x00\xa2\x28\x22\x12\x89\xdc\x1a\x00\xa2\xe9\x95\xdb\xb7\xef\
\xc0\x60\x5b\x1f\x20\x5f\x32\x2a\x52\xec\x52\x10\x42\x30\x3c\x3c\
\x8c\x54\x2a\x05\x00\x90\x24\x09\xc1\x60\x10\xd1\x68\x74\x06\x40\
\x32\x99\x9c\x3d\x80\xa2\x28\xf0\x7a\xbd\x88\x6b\x3c\x12\xee\x4f\
\xbe\xed\xd4\xb1\x00\xb2\x2c\x63\x6c\x6c\xcc\x28\x8b\xc5\x62\x08\
\x85\x42\x88\x46\xa3\x33\x52\x70\x53\x00\xb2\x2c\xc3\xe3\xf1\x80\
\x22\x3c\xa4\xf3\xcd\x46\x45\xa8\xa4\x16\x9a\xa6\x61\x7c\x7c\xdc\
\x28\x9b\x9a\x9a\x32\x00\xa6\x47\x20\x1e\x8f\xcf\x7e\x27\x54\x14\
\x05\x1e\x8f\x07\x71\x8d\x47\x2a\xd6\x6f\xc8\xef\xf7\x63\x6c\x6c\
\x0c\xc9\x64\xd2\x90\x2c\xcb\x50\x14\x05\xaa\xaa\x82\xa2\x28\x43\
\xaa\xaa\x62\xde\x89\x13\xe8\x75\xb9\xce\xb6\x03\xf3\xaf\xe5\xa8\
\x1d\xc8\x3d\xe1\x72\x7d\xf5\x71\x7e\xfe\x9f\x3f\x9e\x76\x0a\xd3\
\x46\x0a\x08\x0f\x3e\x07\x86\x62\xb1\x18\x02\x81\x00\x78\x9e\x9f\
\x21\x96\x65\xc1\x30\x0c\x6c\x36\x9b\xa1\x89\x97\x5f\x46\x29\x27\
\xa3\xc4\x55\x76\x8f\xc9\xc2\x1d\xff\x00\x58\x30\xdd\xf9\x07\x40\
\x2e\x2d\xb0\x3d\xc5\x35\xa5\xf7\xe6\x95\x2f\xdb\x91\x00\x5e\x4d\
\x43\xd0\xb2\x2c\x43\x96\x65\x24\xae\x02\x10\x45\x11\x89\x44\x62\
\x86\x73\x8e\xe3\x0c\x00\xbb\xdd\x0e\xbb\xdd\x8e\xcc\xc3\x87\x61\
\x99\xb8\x80\x82\x15\x55\x60\x83\x29\x94\xbd\xb0\xb3\x48\xb7\x70\
\x3d\x7f\x05\x9c\x00\xf0\x1a\x30\x5f\x17\xd8\x9e\x95\xcf\x3f\xb3\
\x94\x8b\x52\xb8\xeb\xde\x2a\xfc\x68\xf3\xea\xe7\xa2\xc0\x9f\xd2\
\x11\xe8\xd3\x34\x0d\x71\xc2\x83\xcb\x86\x21\x4d\xd3\xc0\x71\xdc\
\x35\x01\xcc\x66\xb3\x01\x90\xea\xef\x87\xa3\xe8\x4e\x84\xbf\x99\
\x44\xd8\xef\x87\xea\x8e\xe0\x27\xcf\x6f\x2b\x12\x2d\xdc\xf1\xa7\
\x81\x8a\x98\xc0\xf6\xae\xdc\xf9\xc4\x52\x6d\x3c\x81\x70\x20\x88\
\x90\xfb\x3f\x98\x57\xb6\x02\x04\x70\x35\x00\xa0\x5b\x5a\x5a\xaa\
\xba\xbb\xbb\xa9\x38\xe1\x41\x99\x60\xe8\xea\xd0\xff\xaf\x14\x14\
\xbe\xf5\x16\xbe\x3c\x76\x1e\xb2\x69\x1c\x52\x24\x0c\x71\x72\x12\
\xf1\x0b\x63\x78\x60\xfb\x63\x4b\xb2\x72\x84\xbe\xb5\xcf\x3e\x5a\
\x18\x1f\x0a\x40\x9c\xf4\x43\x8a\x84\xa1\xda\x08\x8e\xef\x79\x65\
\x48\xbb\x02\x60\x4c\x86\x4d\x9b\x36\xf5\x01\xa8\x48\xff\xf3\x3c\
\x8f\x35\x6b\xd6\xc0\x6a\xb5\x1a\xb9\x94\x24\x09\x6e\xb7\x1b\x6e\
\xb7\x1b\xbb\x76\xed\xfa\x76\x26\x4b\x12\x3a\x1f\xa8\x41\xf5\xfa\
\x15\x98\xba\xac\x20\xa5\xa5\x90\x62\xcc\xc8\xb9\xaf\x00\xe1\x53\
\x97\xa1\xab\x04\x6c\x76\x36\xf8\xc5\x3c\xfe\x79\xa0\x6d\x48\x95\
\xe4\x9a\xad\x80\x6f\xc6\x56\xdc\xda\xda\x3a\xe3\x4a\xb5\x79\xf3\
\xe6\x57\xbb\xba\xba\x7e\xb3\x71\xe3\x46\xe3\xe0\x51\x55\xd5\x48\
\x01\xcf\xf3\x86\x2d\x37\x67\x0e\x86\x7e\xb1\x0e\xf4\xc1\x83\x83\
\x95\x5b\x7e\x5a\x24\xfd\x3b\x02\x80\x86\xf8\x95\x17\x74\x86\x00\
\xc2\x13\xb0\x45\x29\x9c\x78\xbd\x6d\x48\x91\xe4\x9a\x5f\x5f\x71\
\xfe\xbd\x17\x92\x64\x32\xb9\x43\x14\xc5\xb7\x3b\x3a\x3a\xa0\xeb\
\xfa\x77\x26\xe1\xd5\xcb\x33\xc9\x71\x98\x9a\x52\xb6\xf4\x75\xfc\
\x4b\xb7\xff\x78\x2e\xa6\x7c\x3e\x4c\x7c\xfa\x29\xbe\x39\xfc\x11\
\x32\xf9\x31\x9c\xfc\x5b\x37\x62\x92\xfc\xc8\x74\xe7\xdf\x0b\xd0\
\xd9\xd9\xa9\x6b\x9a\xb6\x75\x72\x72\xf2\xc3\x96\x96\x16\xd0\x34\
\x6d\x40\x30\x0c\x83\xf4\xea\x49\x0b\x92\x04\xda\xc2\x1f\xaa\x58\
\x5f\x4a\x85\xde\xed\x05\x3b\x3e\x8e\x4c\x4d\x83\x15\x40\xf4\xf0\
\x39\x94\xaf\x2b\x05\x9d\x95\xd1\xfc\xd2\x95\xd5\x71\x5d\x57\xb2\
\xae\xae\x2e\x4d\xd7\xf5\x2d\x1e\x8f\xa7\xa7\xb9\xb9\x19\x2c\xcb\
\x1a\x11\x98\xee\x3c\xe2\xf5\xc2\x79\xec\x28\x56\xd7\x55\x14\x51\
\xef\x9f\x82\x45\x26\xb0\xb2\x0c\x72\x1f\xae\x86\x95\x63\x90\x25\
\x13\x50\xef\x7d\x81\xd5\xbf\xfa\xf9\x12\xc6\x2a\x1c\x6f\x9c\x06\
\xf1\x83\x77\xc2\x23\x47\x8e\xc8\xa9\x54\xea\xc1\x81\x81\x81\x2f\
\xdb\xdb\xdb\x91\x99\x99\x09\xb3\xd9\x6c\x38\x17\x7d\x3e\xf4\x3e\
\xf9\x38\x1e\xaa\x2d\x87\xe5\xbd\x93\xc8\x4a\xaa\xb0\x72\x2c\x42\
\xf5\xbf\xc4\xc3\xdd\x67\xe1\xaf\xdf\x00\x2b\xcf\x21\x4b\x56\x61\
\xf9\x47\x0f\x6a\x1f\xdb\xb0\x84\x9b\x93\xd5\xb3\x2f\x33\xd3\x09\
\x00\xa6\xeb\xd9\xaf\x47\x46\x46\x94\xfc\xfc\xfc\x0e\x9f\xcf\x57\
\xab\x28\x4a\x8e\x20\x08\x58\xb4\x68\x11\x08\x21\xe8\xdb\xfd\x7b\
\xac\xbf\xff\x3e\x38\x0e\xb4\x81\x4b\x2a\xe0\x38\x16\x23\x4f\x3d\
\x8a\x3d\x07\x3b\x87\xe7\x05\xc5\x75\x47\x07\xdd\x3f\x2b\x7b\xe2\
\x91\xb9\x79\x67\xbe\x06\x27\x2b\x10\xce\x0e\xa2\xe0\xb7\x4f\xcf\
\xf5\x27\x34\x57\xa9\xd7\xfb\x17\xfa\x7a\x0f\x8d\xde\xde\xde\x80\
\xae\xeb\xab\x4f\x9f\x3e\xed\x1d\x18\x18\x50\xd2\x11\x98\x53\x50\
\x84\x4b\xa3\xe3\x60\x8b\x0b\xc1\x70\x1c\xdc\xdb\xea\xf1\xe2\x3b\
\xad\xc3\x73\x45\xa9\xe6\x43\xe0\x8b\x3b\xa2\xb1\x9a\xbd\x7f\x6f\
\x19\x1a\xd9\x56\x0f\x86\xe7\xc0\x16\x16\x60\x70\xd8\x03\xff\x85\
\x0b\x9f\x37\xdc\xc4\xd3\xec\x73\x8e\xe3\x16\xa6\x9f\x66\xf3\xcf\
\x9c\x81\xab\x62\x05\xee\x5a\xe8\xc4\x8b\x6f\xbe\x7d\x99\x44\xc4\
\xfb\xdf\x07\xbc\xe9\x36\x75\x80\x93\xb5\x66\xf5\x34\xfe\xee\xd9\
\xc2\xc1\x8b\x97\x70\xea\x50\xdb\x1b\x3a\xf0\x5c\x03\xa0\xdf\x92\
\x07\x66\x03\x80\x17\x0a\x16\xbc\xb6\x93\x67\xfb\x1f\x07\x16\x5e\
\xcb\x66\x2b\x4d\x2f\x68\x5d\xb9\xf2\x5c\x13\xcf\xbf\xd2\x30\x8b\
\x81\xdf\xb6\xef\xbf\x4e\x55\x19\x88\xae\x2b\x24\xc5\x00\x00\x00\
\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x06\xe0\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x1b\xaf\x00\x00\x1b\xaf\
\x01\x5e\x1a\x91\x1c\x00\x00\x00\x07\x74\x49\x4d\x45\x07\xd7\x0c\
\x1b\x16\x05\x11\x8e\x6b\xb0\xdd\x00\x00\x00\x06\x62\x4b\x47\x44\
\x00\xff\x00\xff\x00\xff\xa0\xbd\xa7\x93\x00\x00\x06\x6d\x49\x44\
\x41\x54\x78\xda\xcd\x57\x5b\x6c\x54\x55\x14\x5d\xf7\xde\x99\xb9\
\xf3\xe8\xf4\x01\x08\x04\x8a\x52\x3e\x4a\x55\x62\xa6\x10\xc4\x86\
\xa2\x12\x22\x90\x48\x48\x30\x8d\xa1\xbc\x0a\x82\x3c\x52\xa8\x06\
\x13\xd0\x0f\xe5\xcb\x98\x88\x06\x43\x0c\xef\xc4\x2f\xf8\x20\x24\
\x02\xf1\xc3\x47\x08\x2a\x4a\x30\x80\x96\xd2\x82\xb4\xb4\xbc\x9f\
\xe9\xcb\x4e\x87\x99\x7b\xe7\x3e\xdc\xfb\xf4\xe6\xdc\x19\x5b\x22\
\x1f\x10\xdd\xc9\xea\x39\x3d\x67\x9f\xbd\xd6\xde\xfb\xcc\x99\x0c\
\xfe\x6b\x53\xe0\x59\x2b\xcd\x8b\xc3\xe1\x90\x13\x8f\xeb\x41\x4d\
\x53\x95\xc7\x4c\xe4\x12\xac\x68\xd4\x55\x3a\x3b\x33\xbd\x7d\x7d\
\x66\x39\x2d\x49\x01\xbd\x34\x5a\x75\x75\x09\x65\xd4\xa8\x7d\xbd\
\x27\x4f\x26\xb2\xf7\xef\xab\xde\xa1\xfc\x20\x72\x1c\x7a\x4d\xce\
\x1f\xb2\x17\x9b\x30\xc1\x1d\x5e\x5d\xdd\x68\x36\x35\xad\x8c\x1e\
\x3c\xd8\x58\x4c\xcb\x01\x76\x48\xeb\xba\x1e\x28\x2d\xdd\x17\x98\
\x3d\x7b\xb2\x56\x55\x05\x55\x51\x06\x67\xf0\x38\xca\xad\x52\xe4\
\xc2\xc2\xca\xcc\xb5\x6b\x7b\x15\x5d\xaf\x86\x61\x64\x84\x80\xac\
\xaa\x46\x6e\x1d\x39\x92\x88\x57\x54\xc0\x34\x4d\x3c\x49\x73\x28\
\xb9\xd6\x63\xc7\x2a\x9f\x27\x4e\x00\x03\x02\x6c\xd7\xd5\x7a\x9a\
\x9b\x55\x3d\x99\x84\x8d\x27\x6b\xb6\x61\xa0\x8f\x5a\xcc\x9c\x20\
\x1b\xa8\x80\xeb\xaa\x0e\x00\x2b\x93\xc9\x13\xd0\x4d\xce\x6d\xe1\
\x30\x82\xe9\x34\x12\xba\xce\xad\x79\xb4\x2c\x5d\x17\x8d\x74\x36\
\x1b\x89\xa0\x9c\x62\x96\xe8\xba\x2f\x20\x9b\xe5\x84\x05\xa7\x14\
\x40\xe4\xaa\xcd\x9b\x39\x02\xfe\xb2\x6d\x38\x89\x04\x16\x55\x57\
\x23\x4d\x02\x7e\x3c\x74\x08\x65\xc9\x24\x8b\xf8\x57\xf2\x2b\xf1\
\x38\xe6\xd5\xd6\x22\x42\x02\x7e\x3b\x71\x02\x3d\xe7\xce\xa1\x50\
\xd3\x06\xf6\x4d\x93\xdb\x20\x38\x01\xef\x8f\xe3\x38\x2c\x80\x2b\
\x20\x11\xa5\xcb\x38\x8d\xc8\x15\x72\x8e\x46\xa3\x78\xb5\xa6\x06\
\xb7\x4a\x4a\x90\xe5\xfd\xa1\x21\xf6\x6e\x16\x17\xb3\x2f\x9f\x11\
\x67\xa7\xcd\x98\x81\x48\x55\x95\xf4\x71\xb8\x02\x1e\xa7\x14\x60\
\x3b\x8e\xdf\x02\x0f\x65\x45\x45\x50\x55\xb1\x0d\x97\xb2\xd2\xa9\
\x8c\x2f\xcd\x9f\x8f\xae\xd2\x52\xe9\x27\xe1\x91\x77\x8e\x1d\x2b\
\x7c\x42\xa1\x10\x13\x80\x8d\x63\x94\x91\x28\xe9\xcb\x15\xf0\x38\
\xa5\x00\xcb\x6f\x81\x54\xda\x7a\xe0\x00\x1e\xb4\xb7\xc3\xab\x90\
\x40\x30\x18\x44\xe5\xdc\xb9\x48\x4d\x9c\x08\xcb\x30\x64\x50\x9e\
\xa7\xca\xcb\x91\x98\x33\x07\x81\x40\x00\xb6\x6d\x33\x84\xf0\x07\
\x1d\x1d\x68\xdb\xbf\x3f\xaf\x02\xdc\x02\xe6\xf4\x2b\xe0\x5f\x42\
\x89\x6c\x2a\x85\x96\xbd\x7b\x91\x6a\x6b\x93\x22\x38\x20\x13\x3c\
\x37\x6b\x16\x9c\x29\x95\x50\x6c\x43\xc0\x9e\x9c\x40\xc5\xcc\x99\
\xd0\x34\x2d\x9f\xfc\xf2\x65\xb4\xec\xd9\x03\x33\x95\x1a\x24\xc0\
\xce\xbd\x84\x36\xa0\x88\x45\xc3\xe0\x0d\xff\xc6\x12\xce\xef\xd8\
\x81\x49\x6b\xd6\x20\x58\x56\x26\x2b\x21\xca\x3a\x7d\x06\x6e\x93\
\x18\xc0\x45\xe9\x8b\x55\xbc\xc6\xc4\x3c\x8a\xde\x1b\x1d\xed\xb8\
\xb0\x7b\x0f\x1c\x5a\xcb\x35\xdb\x13\xc0\x9c\x42\x80\xac\x00\x07\
\x30\x4d\x11\x44\x1a\xb9\xd0\x32\x2e\xee\xdc\x8e\x67\xd7\xd6\x43\
\x7d\xa6\x4c\x56\x82\x89\x46\x4f\x9d\x06\xcf\x64\xcf\x99\xdc\xb9\
\x76\x05\x97\x76\xef\x80\x63\x5a\xd4\xeb\x9c\x67\x94\xf6\xf4\xe2\
\x22\xe2\x73\x04\xa7\x7f\x07\x7c\x01\x7e\x1b\x8c\x0c\x5c\x33\x03\
\x35\x9b\x81\x92\xe9\x47\xfb\xce\xcf\xe1\x5e\x6d\x63\x02\x59\x09\
\xef\x82\xf2\x5c\x0a\xd7\x6e\x5e\x41\xc7\xae\x6d\x80\xd1\x0f\xc5\
\xca\x50\xcb\x34\xc4\xc7\x8d\x43\x64\xc4\x08\xb8\xe4\x77\x66\xeb\
\x56\x98\x19\x03\xd6\x3f\xdf\x01\x57\x55\xd0\x7d\xa1\x05\x4a\x38\
\x82\x50\x3c\x8e\x60\x38\x84\x80\x4e\xe5\x74\x07\x54\x2a\x06\x70\
\x7d\xd7\xa7\x78\x7a\xf5\x46\xb8\x63\x64\x3b\x58\x00\x43\x08\x8b\
\x27\xbb\x71\xf7\xf0\x7e\xe8\x31\x1d\x0a\x47\x4d\x1b\xe8\xbb\x7e\
\x19\x1d\x47\x0f\x23\x9d\x4c\x83\x2d\x18\x8b\x82\xb8\x78\x37\x4f\
\x80\xc2\x15\x48\xde\xb8\x8e\x4c\xff\x03\x68\x9a\x82\x48\x2c\x84\
\x58\x61\x04\x91\x02\x1d\xe1\x68\x08\x7a\x38\x08\x27\x12\xc2\xb1\
\x1f\xbe\x47\xd5\x92\x55\x92\x38\x57\xc4\xaf\xdf\x7e\x83\xe8\xd7\
\x5f\x51\xf5\x2c\x98\x59\xc0\xf0\xa0\x10\x34\xa2\xb3\x99\x88\xc9\
\x5d\x55\x70\x4a\x01\x42\x84\xea\x35\x1c\xec\x4c\x3d\xb6\x0d\xb8\
\x29\x03\x36\x1d\xb6\xfa\xc9\x5b\xd7\xd0\xf6\xda\x22\x54\xd7\x2c\
\x91\x6d\xc8\x05\x5b\xd9\xdc\x05\x68\xee\xba\x8f\x91\x47\xf7\x01\
\x60\x61\x10\xe0\x6d\xee\x10\x8f\x8a\x46\xe4\x39\x17\x5d\xcd\xfd\
\x96\x62\x75\xac\x21\xa0\xf9\x08\xf2\x18\xd2\x70\xe7\xf5\xe5\x78\
\xa5\xe1\x03\xc4\x62\x31\x78\x26\x6f\x3c\x67\xcf\x77\x80\x3f\x86\
\x2f\x2c\x5d\x87\xee\x37\xd6\x8a\x33\xc1\x40\x7e\x2c\x72\x17\x1c\
\xae\xa2\x0c\x16\xc0\x7d\x61\x75\x1a\xed\x69\x39\x22\x34\x0a\xd4\
\xb5\x60\x35\x5e\xde\xf0\x3e\x0a\x0a\x0a\x98\x50\x92\x0f\xbf\xd1\
\x88\xa7\x6e\x36\xf2\x5c\xb6\x83\xdf\x89\x44\x5d\x3d\x52\xb5\x0d\
\x7c\xd6\x8f\xc3\x50\x21\x7c\x1d\x75\x68\x01\xb2\x02\xc2\x91\x41\
\xe9\xa7\x16\xae\x27\xf2\xcd\x9c\x39\x93\x33\x38\x53\x22\x3f\x0b\
\xfb\x8b\x65\x70\xb6\xaf\xc0\xe8\x3b\x4d\xfc\x4a\x32\x39\xef\x89\
\x67\x7b\xca\x5b\x1b\xe0\xae\xd8\xc4\x31\xf2\x62\x2a\x94\xa1\x3b\
\x94\x00\x56\xc5\x9b\x14\x5f\x40\x0d\x68\x14\x60\x23\x91\x6f\x62\
\x72\x56\xce\x10\x24\xc5\x57\x4f\x0b\xf2\xb0\x6a\x0a\x28\x5f\xae\
\xc0\x98\x7b\xe7\x11\x0e\x87\xa5\x10\x9e\x4f\x7d\xbb\x01\x91\xfa\
\x0f\x45\x2c\x11\x93\xa1\x29\xc4\x85\x21\xef\x00\x11\xf8\x02\x62\
\xeb\x36\xa3\xba\xfe\x3d\x49\xce\x99\x71\xe0\x58\xdb\x29\x64\x3e\
\x5b\x82\xa0\x6b\x42\x0f\x01\x61\x42\x10\x26\xb2\xdb\x96\x53\x55\
\xfe\x18\x2c\x62\xd5\x7a\x0c\x7b\x77\x8b\x88\x09\x16\xf0\xf0\x3b\
\xc0\xff\xf9\x1b\x55\x8b\xeb\x44\x00\x32\x49\x1e\x6c\xf9\x05\xbd\
\x1f\x2f\x02\xb2\x26\x06\x99\x65\x22\xf9\xc9\x52\x44\x5b\x4f\x71\
\x0b\x58\x04\xb7\x4b\x9c\xab\xac\x59\x28\xdd\x14\x55\xe0\x61\x97\
\x10\xf2\xa3\x73\x7a\x65\x0d\xd0\xdf\x27\x9f\x57\xfb\xf7\xe3\xb8\
\xfd\x51\x2d\x6c\xc3\x14\x9f\xe7\xac\x05\xd0\x14\x19\x02\xcf\x6d\
\x1b\xe2\x25\xbd\xbb\x65\x31\x70\xee\x67\xf9\x55\xce\x31\xce\x50\
\x2c\x8e\x09\x86\x77\xd7\x86\x68\x81\x20\x92\x02\x7a\x5a\xce\xe3\
\xcc\xb2\x79\x50\x93\xbd\x48\x9f\xfc\x0e\xed\x9b\x16\xc2\x22\xb6\
\xac\x0d\xf9\xc8\xa4\x0d\x21\x40\xc0\xb4\x40\x7b\x04\x52\xd5\x41\
\xbe\x7c\x86\xcf\x9e\xad\x9b\x47\xb1\x9a\x44\x4c\xc7\xf5\xb2\xf7\
\xf9\x11\xc8\x6f\x81\x70\x12\x19\x3a\x04\x3e\xf8\xd3\xf4\xf1\x88\
\x84\x20\xfa\xad\x12\xbc\xf6\x09\x3f\xcd\x93\xcf\xfe\x96\xc5\x22\
\xbc\x91\x2a\xd1\xdc\xf0\xe6\x80\x38\x83\x63\xf9\x31\x21\x12\xcd\
\x6f\x01\xaf\xd9\x6a\xc1\x30\x37\x3a\xb2\x90\x1d\x05\x2c\xdb\x47\
\xd6\x62\x88\xcc\x05\x0c\x2f\x70\xda\x43\x86\xc1\xeb\xde\x3e\xfb\
\x5a\x02\x32\x86\x8c\x1b\x1d\x59\x44\xeb\x8a\xc3\x9c\xb2\x02\x2e\
\xd0\xad\xc7\xe2\x97\xe2\x93\xc6\x57\x68\xd1\x10\x34\xc7\xe2\x57\
\xcc\x7b\xc9\xfc\x51\x23\x28\x04\xae\x96\x45\x90\x99\x70\xdb\xf8\
\x99\x25\xa8\x84\xa0\x4d\x73\x8b\xce\xd0\xa8\xd3\x18\xf5\x12\xb0\
\xb5\x20\xac\x78\x09\x94\x0b\xf7\x2e\x31\xa7\x14\xa0\x00\x3d\xa1\
\x8b\x7f\x36\x74\xf4\xf6\x6c\xef\xe9\xea\x2c\xcf\xa6\xd3\xea\xa3\
\xff\x0c\x7b\x74\x0b\x45\xa2\x4e\x58\xbd\x71\x69\x74\xb2\xff\x1d\
\xe6\x44\xee\x75\x38\x3e\xd0\x8e\x12\xc2\x30\x6e\x2f\x9e\x80\x79\
\x65\xe7\xcc\x7b\x66\x02\x0e\xfe\x0f\xf6\x37\x83\x76\xd2\x44\xe2\
\x1d\x68\x05\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x08\x2d\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x07\xaa\x49\x44\
\x41\x54\x78\xda\xc5\x57\x5d\x6f\x5c\x57\x15\x5d\xf7\x9e\x7b\xef\
\x7c\xfa\xdb\x75\x6d\xc7\xad\xe3\x26\x4d\x49\xa9\x28\x52\x1c\x24\
\x1a\x37\xb4\xa1\x12\xa9\x14\x15\x21\x40\x3c\x57\x7d\xac\xda\x3f\
\x80\x68\x5e\x40\xed\x53\xcb\x13\xa8\xef\x08\xf1\x14\x09\x51\x14\
\x45\x6d\x5e\x22\x24\x2b\xd0\x96\xa4\x69\x1c\x35\x46\x76\x62\x3b\
\x26\xb1\xfc\x35\xf6\x78\x66\x3c\xf7\x8b\x75\x96\xae\xe7\x4e\x2c\
\xde\x78\xe0\xd8\xcb\x67\xcf\xb9\xfb\x9e\xbd\xce\xde\xeb\x9c\xe3\
\x71\xd2\x34\xc5\xff\xb3\x39\x2f\xbd\x72\xfe\xb9\x57\xcf\xce\xfc\
\xba\x5c\x2e\x0d\xc1\x71\xf4\x0b\xe8\x0f\x3b\x35\xd9\x6a\xb4\x5d\
\x42\x4d\x0f\xbb\x0d\x07\xea\xf4\xb6\x7e\x64\xe8\x1d\x00\x29\xad\
\x28\x8c\x92\x56\xab\x15\x81\xad\xd9\xda\xaf\xfd\xf9\x2f\x7f\xbd\
\xe8\xfc\xe8\xc2\xcf\xfe\xb6\x5b\xaf\x9f\xd9\xdf\x6f\xc3\x75\x5d\
\x18\x0b\xe3\xc2\xf7\x7d\xf8\x81\x8f\x80\xbd\xe7\x79\x5d\x30\xf4\
\x31\xb2\x5d\x4b\xce\x18\xbe\xe7\xe8\xdd\x2e\x6a\x36\x24\x7f\x1c\
\x30\xc5\x22\xb5\xb6\xb6\x8e\xbf\x5f\x9f\x45\xff\xe0\x08\x76\x6a\
\x9b\xe8\xeb\xef\xc7\xe0\xe0\xf0\x5d\x6f\x69\x79\xe5\x38\xb2\xc6\
\x49\xb2\xc9\x4c\x87\x8c\x4b\x32\xb9\xdd\x35\x2e\x88\x6c\x66\x9b\
\x43\x9f\xe5\xa7\xac\x3d\x78\xb0\x4a\x2c\xe3\x3b\xdf\x3e\x81\x5b\
\x73\xff\xc2\x60\x5f\x09\x9b\x1b\x6b\xd8\x6f\xc7\x27\x3c\x74\x35\
\xea\x81\x10\x7b\x21\x85\xc6\xf4\x31\xb7\xd3\xfc\xa9\xc6\x84\xfc\
\x9d\x54\xd0\xb3\x46\xb3\x89\xa5\xe5\x07\x60\xda\x11\x14\xca\x98\
\x9b\x5f\x42\xb1\xd2\x8b\x5a\xa3\x85\x62\x75\x40\x3e\x22\x90\x24\
\x09\xe2\x28\xec\x64\x21\x87\xd3\xb1\x1d\xc2\x38\xca\x48\x66\x3b\
\xb2\xf5\x9c\xe3\xdd\x7e\x7c\x0d\xdb\xb5\x1d\x6c\x6c\x6e\x8a\x57\
\x2e\x21\x17\x51\xd8\x56\x9f\xc4\x09\x4a\xe5\x22\xbc\x4a\xb9\xec\
\xfc\xe2\xe7\x6f\xe0\xb5\x73\xaf\xc0\x33\x26\x0f\x76\x30\x99\x84\
\x69\x6d\xf6\x12\x61\xb7\xe0\x72\x81\x26\x69\xca\xda\xd6\x70\xe3\
\xc6\x4d\x6c\x6e\x6d\x21\x4d\x92\xee\xc8\x9d\xac\x1c\xe4\xb7\xd9\
\x68\xe2\xf3\x9b\x73\xf0\xa8\x7e\xe7\xec\xcc\x0c\x9e\x78\x62\x04\
\xae\x82\x28\xb8\x82\x65\x04\xf4\x96\x48\x00\x5d\x81\x9d\xac\x04\
\x09\x6b\x19\x62\x63\x63\x03\xb5\xdd\x3d\x1c\x7d\xe6\x18\xa6\xba\
\xc4\x98\xe6\xb6\x7a\x63\x0c\xc6\x47\x47\x95\xf5\x7f\xdc\xf8\x25\
\x54\x82\x28\x8e\x35\xb0\x5a\x8b\x71\xf9\x66\x5d\xce\xd6\xdf\xd8\
\x12\x28\x3e\x94\x6e\x46\x13\x49\x63\x27\x4e\xac\xba\x13\xa5\x32\
\x64\x5a\x49\x84\xbe\x81\xde\xe3\x53\x11\xa7\x9c\xf4\xbe\x32\xc7\
\xb1\x20\xf0\x31\x31\xdc\x8b\xe3\x95\x12\x6a\xb5\xdd\x5c\x03\x51\
\x14\x23\x26\x89\x30\x4c\x50\x6f\x25\x7c\xc1\x06\x72\xd5\x7b\x5c\
\xb9\x56\x60\x18\x20\xd5\xe2\x15\x8c\xe4\x14\x3c\x49\x62\xfa\xca\
\x03\x46\xbe\x0a\x2e\x3f\x9b\xb3\x98\xbd\xb1\xb6\xef\xc1\x78\x45\
\x84\x24\x9e\x08\x31\xe7\xe9\x10\x88\x94\x81\x80\x11\xc6\x07\xac\
\xc0\x0c\x57\x0c\x06\x4c\x55\x06\xf2\x00\x65\x9a\x4d\xee\x82\xf1\
\x11\x87\x21\x1c\xc5\xb3\xe2\xa3\x03\xc4\x82\xb6\x74\x92\x13\x01\
\xb8\x72\x0f\xc5\x52\x51\x84\xfa\x4b\x12\x20\x62\x82\x3e\x1d\x02\
\x1a\x1c\xac\xb8\xf8\xf1\x8b\x15\xa9\x24\x4e\x13\xa5\x39\xb5\x24\
\x34\xa9\x2f\x1d\xb4\xdb\x6d\xec\xef\x47\xb4\xbd\x4e\x4d\xbb\x8e\
\x44\x01\x8a\xaf\x6d\xab\xb4\x17\x0b\x45\x1d\x6c\x29\x34\x48\xc1\
\xda\xd2\xc5\x79\x09\xc2\x30\x42\x18\x85\x48\x43\xe8\xa1\x03\x1d\
\x28\x59\x60\xf6\x90\x98\xb0\xdf\x6a\x29\x53\x3a\x05\xdd\xce\x73\
\x05\xd5\xe7\xac\xde\xdd\xdb\x2e\xf0\x3d\x91\x04\x12\x65\x8e\x24\
\x44\x2c\xee\x2a\x81\xf6\xeb\xc8\xc8\x30\x36\x1b\x0e\x3e\x5f\x61\
\x38\x89\x8d\xbd\xb1\x54\x08\x63\xc7\x24\x28\xa5\x3d\xf0\x0c\x7c\
\x93\x82\x8b\x52\xef\xf1\x81\x67\x7b\xfa\x59\x47\x51\x16\x99\x94\
\x08\x19\xa8\x4d\xb8\x4c\x7b\x84\x72\xc1\xc1\xc9\xb1\x42\x56\x02\
\x88\x80\x18\x12\x0a\xd4\x8a\x6c\x70\x8e\x25\x8e\x18\x1b\xd7\x8a\
\x3d\x65\xaf\x7a\xa2\x48\x71\x28\x84\x67\xf2\xbb\xc3\x73\x44\xd8\
\x18\x95\x00\xec\x28\xde\x90\x48\xd1\x4e\x7d\xc4\x0c\x9e\x2a\xf5\
\xa6\x73\x6e\x50\xf4\x1d\x0d\x68\x12\x9f\x69\x2d\x05\xc0\x68\x1f\
\xd5\x2e\x31\xe5\x69\x35\xaa\x2d\xe8\x63\x58\x53\xa6\xd5\x10\x1e\
\xe1\x1b\x29\xdf\x23\x01\xcf\xce\xe1\xec\x23\xae\xaf\x61\x68\x60\
\x00\x03\x03\xfd\x5a\x54\x48\xb1\x6e\x6d\x6d\xe3\xd1\xfa\x36\xbc\
\xde\x31\xce\x21\x92\x22\x94\x95\x40\x7b\x5c\xce\xc3\x3d\x2e\x5e\
\xfb\x16\xe0\xe4\x47\xab\x9c\x65\xb3\xa7\x4f\xe6\x6b\x3f\xe7\xcf\
\x55\xc6\x8d\x75\xd9\x3d\xc3\x4f\x93\x64\x70\xf0\x4c\xe2\x2b\x97\
\xcb\x38\x72\x64\x1c\xab\xab\xab\xd2\x9b\xeb\x0e\x70\x1e\x93\x67\
\xc0\x75\x34\xa9\x02\xe7\x2b\x3f\x7c\x1f\x88\x64\x7e\x43\xe6\xe2\
\xe3\x4d\xb7\xa2\x67\x7d\x7d\x7d\x87\x77\xc5\x63\x17\xdd\xd8\xd8\
\x18\x76\x76\x76\xb0\xb8\xb0\x80\x6a\x8f\x7c\x45\xa0\x73\x9d\x6e\
\x37\x81\xeb\x8b\xad\xac\xb6\xd9\x69\x98\x95\xa1\x18\x78\x28\x04\
\x06\x45\xdf\x95\xad\x32\xf8\x44\xda\x80\xd3\x6a\x52\xc4\x23\x3a\
\xff\x9b\x5f\x7d\x85\x60\x7c\x5c\xe0\x8e\x11\x89\xf6\xfd\xfb\x5a\
\xb1\xff\xd4\x53\xe8\xe9\xe9\x11\xd1\x3a\xef\x02\x65\x54\x4c\x25\
\x20\x0a\x05\x74\x8e\x1c\x70\x9b\x4b\x8c\xfb\x44\x3b\x06\x42\x22\
\x4e\x88\xd8\x61\x6f\x01\xf9\x82\x68\x6e\xad\xa2\x54\x2a\x69\x7f\
\x37\xae\x5d\x13\x81\x9d\xab\x57\xd1\x5a\x5c\x14\x81\xc6\xad\x5b\
\xa8\x7f\xf9\x25\x76\x89\xd6\xfc\xbc\x32\x31\x31\x31\x81\xdb\x1c\
\x77\xac\x7e\xf2\x03\xc4\xae\x2c\xc5\x93\xfd\x5e\x26\x42\xa3\x2c\
\x80\xf0\x29\xeb\x82\x56\x6d\x50\x2a\x18\x2b\x3e\x89\xd0\xe5\xf6\
\x7a\xd8\xd8\x43\x30\xfa\x24\x52\xaa\x3a\x5a\x5b\x43\xc4\x14\x3b\
\xf4\xdb\xb9\x72\x05\xc1\xe4\x24\xa2\x87\x0f\xf5\xd9\xa1\xc8\xc3\
\xf5\x75\x04\xc7\x8e\x89\xc4\xd4\xd4\x14\x0f\xb5\x4f\x33\x02\xd9\
\xbe\xed\x2f\x1b\xfc\xe0\xb9\x8a\x52\x43\xd1\x29\x6d\xda\x5e\xae\
\x91\xed\x19\xf7\xb1\xeb\x7a\xf1\xde\x3d\x14\x0a\x05\xad\x14\x14\
\x5e\xf9\xc2\x05\xd4\x2f\x5d\x42\xcc\xa0\x29\x03\xb6\xe6\xe6\x6c\
\x60\x11\x28\xbe\xf0\x02\x4a\xd3\xd3\x5d\x7a\x18\xc5\xce\xf6\xb6\
\x08\x28\xf8\x01\x91\xff\xde\x74\x01\x11\xee\x63\x7e\x6b\x8f\x1e\
\x69\x3f\xf3\x28\xd7\x76\x93\xea\x5f\x7f\x1d\x9b\xef\xbe\xab\x95\
\x27\x1c\x37\xdc\x01\xe5\x53\xa7\x50\x7d\xf3\x4d\x5e\xdb\x6d\x2d\
\xee\x40\x1b\x7b\x7b\x75\x11\xe8\xb4\xad\xbd\x18\xff\x5c\x69\xc1\
\x64\x0a\xf7\x3c\x57\xa1\xb4\x72\x7e\x2e\x16\x6c\x09\x7c\x09\xb0\
\x18\xb8\xa8\x35\x13\x6c\xfc\x7b\x49\xdb\xae\x5a\xad\xca\x67\xfb\
\xe2\x45\xec\x7d\xf6\x59\x37\x73\xd4\xbf\xf8\x02\xc9\xf0\x30\x06\
\xde\x7a\x4b\xf3\x92\xac\xdd\x0d\xda\x92\x5e\xe6\x23\xc4\x48\xd1\
\x0a\x75\xd5\xea\x34\x8b\xd2\x58\x64\xa2\x24\xd1\xe4\x31\x1c\xb2\
\x6f\x23\x26\x89\x84\xfe\x6e\xa1\x6a\x2f\x27\xad\x28\xb1\x93\xbe\
\xf7\x1e\x5a\x97\x2f\xc3\x00\x6a\x9e\xd5\x00\x77\x80\x6d\x9b\xef\
\xbf\x0f\xde\x62\x18\x7c\xfb\x6d\xf9\xd7\xf7\xf6\x50\x2a\x97\xe0\
\x02\xf9\x05\x61\x9c\x14\xc3\x15\x0f\x43\x65\x47\x37\x23\x6d\xf5\
\x43\x15\x83\xc1\xaa\xe1\x55\xea\xa0\x52\x34\x28\xfb\x8e\x4e\xcd\
\xb1\x23\x13\xd8\xdd\xdd\x55\x19\xc2\x46\x03\xe9\xd2\x92\x0d\x2e\
\xf4\x31\xd0\xd8\x27\x9f\xa0\x7a\xfe\x3c\xdc\x6c\x2c\xba\x7b\xb7\
\x53\xb2\x95\x95\x07\xdc\x3d\x15\x65\xc0\x5e\xc5\xaa\x71\x95\x69\
\x3d\x35\x99\x9f\x62\xc4\xa1\x13\x51\x63\xc2\xc1\x81\x33\xc9\x55\
\xf2\x84\x53\xdf\xfb\xf1\xc7\x68\xbc\xf3\x0e\x82\x73\xe7\x50\x61\
\xba\xc1\xe7\x83\x1f\x7e\x08\xc3\x6d\x6a\xdb\xe0\x07\x1f\x48\x07\
\xcd\x66\x13\x8b\x8b\x14\x70\xb1\x08\xe7\xc5\xd3\x2f\xdf\x3f\xf1\
\xec\xf1\xa7\x7f\xf8\xea\x59\x48\x5c\x59\x20\xdb\x14\xb4\xf3\xbf\
\xa1\xae\x5f\xa9\x1f\x19\x09\x5b\xfb\x90\x13\x2e\x2f\x2d\xe0\x7b\
\xa7\x4f\xeb\xc8\x2d\x16\x75\xf7\x77\x2f\x40\x3d\x9b\x2d\x97\xfe\
\x45\xbf\xf2\xe9\x55\xac\x6f\x6c\xe3\xeb\xb9\x6f\xda\x5e\xbb\x1d\
\xfe\xee\xeb\xdb\x77\x7e\x43\xa8\x74\xd9\xea\x74\xe7\xfb\x04\x6d\
\x7d\x43\xe2\xa4\x84\x07\x4f\x37\xa7\xbe\x21\x65\xc7\x37\xc1\xec\
\xd9\x6f\x56\x2f\xcf\x9c\x51\x29\x99\x66\xbd\xcf\xe0\x02\x6b\xae\
\xb1\x7a\xbd\x8e\x3f\xfc\xf1\x4f\xb8\x7d\xe7\x2e\xfa\xfa\x87\x92\
\xad\xed\xed\xdf\xeb\xcb\xe9\xf3\xdf\xfd\xfe\x20\x80\x5e\xfc\x0f\
\x6d\xfd\xe1\xf2\xd4\x4f\x7f\xf2\xc6\xaf\x66\x66\xce\x9c\x39\x7a\
\xf4\x68\x70\x98\xc0\xc2\xc2\xc2\xfc\x47\x1f\xfd\xf6\xd2\x9d\x6f\
\xe6\xaf\x1d\x99\x7c\x76\x0e\x40\x7d\xee\xc6\xec\xba\x08\x40\x4d\
\xab\x37\xec\xfc\x0c\x5e\xd6\x1b\xd9\x82\x6c\xb7\x0b\x0e\xf2\x96\
\x12\x3e\x0f\xa6\xe7\xa7\xa7\xa7\x5f\x3a\x79\xf2\xe4\x33\xbd\xbd\
\xbd\xc5\x65\xb6\xd9\xd9\xd9\x7b\x2b\x2b\x2b\x37\x01\x5c\x27\x36\
\x89\x90\x71\x63\xb0\x89\x80\xc3\x06\x4d\xa8\x20\x41\x1e\x5c\x08\
\x32\x14\x0e\xf7\x87\xc8\x3a\x39\xd4\xfc\x6c\xce\x3d\x62\x27\xeb\
\xeb\xc4\x2e\x04\xd9\xcd\xff\x00\xe2\xdc\x63\x00\xf6\xad\x94\x67\
\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x01\xf0\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x03\x00\x00\x00\x44\xa4\x8a\xc6\
\x00\x00\x00\x03\x73\x42\x49\x54\x08\x08\x08\xdb\xe1\x4f\xe0\x00\
\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\x01\
\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\x74\
\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\x70\
\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x00\xa8\x50\x4c\x54\
\x45\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x89\x89\x89\x87\x87\x87\x87\x87\x87\x62\x64\x60\x74\x76\x73\x7a\
\x7b\x78\x88\x88\x88\x8e\x90\x8d\x94\x96\x93\x98\x98\x98\xc6\xc6\
\xc6\xc7\xc7\xc7\xd6\xd6\xd5\xdd\xdd\xdd\xe4\xe5\xe4\xe6\xe6\xe6\
\xf9\xf9\xf9\xfa\xfa\xfa\xff\xff\xff\x2b\x53\x2d\x8e\x00\x00\x00\
\x28\x74\x52\x4e\x53\x00\x01\x02\x03\x05\x07\x0a\x0c\x0d\x10\x11\
\x15\x16\x19\x1a\x1b\x1d\x1f\x21\x24\x25\x26\x27\x29\x2b\x2c\x2d\
\x31\x33\x36\x39\x3c\x3e\x42\x44\x46\x49\x5f\x64\xd1\x46\xaf\x83\
\x51\x00\x00\x00\x86\x49\x44\x41\x54\x78\xda\xed\x92\x31\x0e\xc2\
\x40\x0c\x04\x6f\xed\x8b\x50\xc2\x3b\x80\x82\xff\x3f\x85\x02\x78\
\x48\x94\x70\xbe\xc5\x97\x82\x22\x4a\xe4\x1a\xc1\xca\x8d\xb5\x23\
\x5b\x5a\x1b\x29\xd0\x1f\xf8\x00\x67\xe4\x1d\xb3\xf0\xe1\xc0\xa9\
\x87\xee\x00\xc6\xf1\x89\x74\xe9\x33\x64\xd3\xaf\x2c\xe3\x1d\xe9\
\x7a\xc8\x98\x27\x52\xe4\xb8\x26\x58\xa6\x5b\x03\xba\xb6\x6e\x1e\
\x36\x66\xbc\x7e\x06\x08\x83\x0a\xa3\x0e\x8f\x15\x9d\xfb\x7b\xbe\
\x5a\x54\x5c\x2a\x50\xc0\x7b\x92\xc6\x6a\xd5\x65\xd5\x01\xb8\xe7\
\xa5\xda\x49\x53\xe2\xe2\x14\x33\x5b\xa0\x37\xa5\x5f\x6c\x21\xec\
\x21\x57\x8e\x00\x00\x00\x00\x49\x45\x4e\x44\xae\x42\x60\x82\
\x00\x00\x05\x35\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x00\x20\x00\x00\x00\x20\x08\x06\x00\x00\x00\x73\x7a\x7a\xf4\
\x00\x00\x00\x04\x73\x42\x49\x54\x08\x08\x08\x08\x7c\x08\x64\x88\
\x00\x00\x00\x09\x70\x48\x59\x73\x00\x00\x03\x76\x00\x00\x03\x76\
\x01\x7d\xd5\x82\xcc\x00\x00\x00\x19\x74\x45\x58\x74\x53\x6f\x66\
\x74\x77\x61\x72\x65\x00\x77\x77\x77\x2e\x69\x6e\x6b\x73\x63\x61\
\x70\x65\x2e\x6f\x72\x67\x9b\xee\x3c\x1a\x00\x00\x04\xb2\x49\x44\
\x41\x54\x78\xda\xed\x97\x6b\x4c\xd5\x75\x18\xc7\x1f\x5f\x94\x4c\
\xb9\x48\x71\x87\xc3\xfd\x1a\x72\x7d\xe1\x65\xac\x74\xc9\x4d\x42\
\x06\x0e\x08\x03\x6a\x59\x09\xa2\x66\x8a\xcd\x0c\x61\x98\xf3\x90\
\xc4\xc6\xf4\x80\xa4\x34\x90\x19\x88\x42\x82\x2c\x32\xad\x16\x57\
\xa5\x04\x14\x13\x4c\x70\xdc\x1c\xb8\x10\x45\xe7\xa4\x97\xdf\x9e\
\x67\xda\x7f\x1e\x61\xe7\xa0\xb2\xd5\x0b\x5e\x7c\xb6\xdf\x7e\xcf\
\xf3\xfd\x3e\xdf\xff\xf9\x9d\xff\xff\x7f\x0e\x01\xf8\x4f\x99\x0b\
\xf0\xff\x0e\x70\x92\xc8\xf0\xb4\xa5\x65\xc3\x59\x7f\xff\x1b\xd5\
\x06\x06\xce\x33\x35\x3d\x4d\xe4\xf4\x83\xab\x6b\x6f\xbd\xab\x6b\
\x0b\xaf\x8d\x9e\x2b\x80\x0c\xff\x8e\xa8\xb9\xce\xca\x1c\x8d\x51\
\x21\xe0\xf5\x60\x0d\x91\xa3\xbe\xe1\xd2\x23\xbd\x0d\x2b\x97\xa2\
\xde\xdb\x13\xe2\x21\x5e\xcf\x14\x40\x04\x4c\xf3\x29\x83\x97\x30\
\x56\xa0\xc6\x64\x4d\x15\xce\xbd\xe6\x08\xde\x1b\x62\x9c\x74\x84\
\x76\x92\x9e\x9f\x16\x3b\xe3\x41\xd9\x37\xb8\x7f\xea\x5b\x88\xc7\
\x49\x1d\x21\xa6\x1d\x7e\x9c\x05\x55\x2c\x1c\x55\xef\xc0\x64\x56\
\x16\x84\x07\x55\x15\x38\xe3\x69\x0f\xae\x0d\x95\x13\x4d\x39\x8e\
\xa3\x44\x2e\x15\x5c\x3b\xe3\xe5\x80\x7b\x47\x34\x98\xcc\xcc\xc4\
\xdf\xfb\xf6\x61\xe2\x44\x09\xc4\x4b\x3c\xc5\x5b\x6f\x80\x63\x44\
\xf5\x95\x2c\x18\xf8\xf4\x3d\x8c\xa7\x6f\xc7\xed\xed\x8f\x49\x4f\
\xc7\x44\x79\x29\xbe\xf7\x50\x81\x7b\x86\x65\xe0\xbf\x9a\x22\x22\
\xb7\x02\xa2\x91\x3a\x0e\x78\xbb\x28\x5f\xd1\x08\x77\x33\x32\x70\
\xe7\x78\x31\xc4\x53\xbc\xf5\x06\x28\x23\xba\x5c\x65\x61\x84\xfe\
\x4d\x49\x18\x4a\x49\xd1\x26\x35\x15\x63\x25\x85\xa8\x71\xb1\xc5\
\x01\xa2\x51\x0d\x91\x7b\x1e\x91\xc7\x4e\xa2\xb1\xc3\xbc\x77\x4b\
\xb3\x7f\x8a\x66\x38\x2d\x0d\xf7\xeb\xaa\x71\xd2\x6c\x21\xc4\x5b\
\x6f\x80\x52\x22\xc7\x12\xa2\xc1\x6a\x3b\x53\xfc\xb9\x21\x1e\x3d\
\x89\x89\xda\x24\x27\x63\xe4\xd0\x57\x28\xe4\x81\x3b\x78\xf0\x06\
\xa2\xf1\xdd\x4e\xd6\xe8\xcf\xdf\x8b\xee\xa4\xa4\x29\xfd\x7f\x1d\
\x39\xc0\x81\xad\x21\x9e\xe2\xad\x37\x80\x50\xc4\x8d\xc5\x7c\x9e\
\x27\x6c\x17\xa1\x67\x7d\x34\x2e\x47\x6b\xd3\x19\x13\x83\xbe\xbc\
\x6c\x64\x3a\x5a\x20\xdd\xc1\x1c\xdd\x5f\x66\xa0\x9d\xf7\x9e\xee\
\x1b\xc8\xfa\x04\xd5\xce\x56\x10\x2f\xf1\x7c\xa6\xdb\x90\x45\x4e\
\x5f\xb3\xb0\xc2\xc6\x04\x57\x93\x57\xe3\x62\x70\xb0\xc2\xef\xcc\
\xf9\xd0\x50\x5c\xc9\xde\x86\x4b\x59\x5b\xd1\x1c\x12\x22\x7b\x4a\
\xbd\x3d\x2c\x0c\xd7\x37\xbf\x83\x4a\x07\x33\x88\x87\x78\x3d\xd7\
\x83\xe8\x10\x91\x73\x21\xd1\xf0\x31\x6b\x13\xfc\xb1\x6e\x15\xda\
\x96\x2f\x57\xb8\xc0\x34\x05\x05\xa1\x91\x69\x7d\xbc\x77\x25\x21\
\x01\xbd\x9f\x67\x60\x50\xa3\x46\x05\x7f\x3a\xa2\x15\x8f\x17\x7a\
\x14\xe7\xb3\xc1\x41\xa2\x9b\x65\x56\xc6\xe8\x8a\x7d\x1d\xad\xbe\
\xbe\x8f\x08\x0c\x44\x67\x54\x14\xba\x53\x52\x71\x6d\xd3\x66\x74\
\x6d\xdc\x88\x5f\x57\xac\x40\x53\xb0\x1b\x8e\x5a\x1a\x41\x34\xa2\
\x9d\x95\x77\x01\x9b\xb9\xe4\xb3\x61\xa9\x84\x78\x37\x1c\x2d\x7c\
\xb5\x2d\x7c\xe5\xe7\x54\x2a\xd4\xce\x9b\x87\x5a\x22\x08\xad\xab\
\x3c\x50\xc2\xc3\xa5\x57\x34\xb3\xf6\x32\xca\x65\xb3\x3c\x36\x2d\
\xb6\x34\x46\x5b\xb0\x27\xce\x12\x4d\x07\xd7\xbc\x20\x3d\xd2\x9b\
\x3b\x5b\x01\x72\x88\x9c\xf7\xb3\xe1\x61\x2b\x13\x74\x84\x7a\xa3\
\x89\x25\x42\x23\xd3\x20\x3c\x5a\x2b\xfb\x1d\x61\x3e\x38\x6c\xbd\
\x08\xa2\xc9\x79\xd1\x23\x10\x03\xb5\x7c\x91\xd8\xb0\x2b\xdc\x0f\
\x1d\x44\x10\xda\x99\x8b\xcc\x05\x41\xd6\x8f\xf6\x94\x7a\x57\x44\
\x00\x0e\x59\x9b\x42\xb4\xe2\xf1\x5c\x01\xf6\x12\x39\x31\x43\x85\
\x36\xaf\xa0\x3b\x22\x10\xdd\x44\x0a\x57\x65\x08\xf3\x73\x78\x00\
\x7e\x09\x0f\x94\xb5\x52\x53\x88\x5c\x8a\x42\xdb\x57\x21\x1e\xcc\
\xb3\xdd\x86\xd9\x44\x8e\x7b\x58\xa8\x61\x83\xde\xc8\x65\xe8\x27\
\xd2\xa2\x8f\x69\x8d\x0c\x42\x80\x8d\x19\xfc\x99\xf3\x6b\xde\xc0\
\x0d\xa9\x3d\x45\x6f\xcc\x9b\xd0\xa8\x2c\x21\x5e\xe2\x39\xa3\x00\
\xbb\x8c\xe7\xbb\xb1\x60\x50\x84\xfd\x6c\x70\x8b\x48\x8b\x51\xa6\
\x33\x26\x04\x2b\xed\xac\xb0\x92\xe8\x5e\x10\xd1\xfd\x15\xbc\xbe\
\xb4\x36\x5c\x6a\x53\xfa\xfb\xe3\x22\xa1\xb1\xb7\x45\x8e\xa1\xe1\
\x50\x91\x9f\x9f\xbb\xde\x00\x59\xe6\x26\xbd\x79\x4b\xbc\x71\x73\
\x5d\x14\xee\x11\x69\x31\xc1\x5c\x8b\x7d\x0b\x61\x2a\x1b\xac\x26\
\xba\xbb\x95\xc8\x53\x08\xe6\x20\xe1\xbc\x77\x3d\x36\x52\x7a\xa6\
\xe8\x46\x92\xe2\x50\x9b\x10\x8f\x02\x77\xf7\x9e\x19\x04\x30\x6e\
\xfa\xc2\xd3\x01\x7d\x9b\xd7\xe3\xe1\xfc\x97\xf1\x90\x48\x61\x20\
\x3e\x0a\xf1\x2a\x5b\x44\x10\xdd\xe1\xc1\xca\xd5\xc8\x3a\x8c\x03\
\xad\x53\xd9\x61\xe0\xed\x68\x2d\x8d\x78\xf4\x7d\xbc\x01\x05\x1e\
\xee\xc8\x35\x35\xfd\x51\x5f\x00\x39\x7f\x43\x3e\x82\x66\xf5\x82\
\x05\xe8\xdb\xf2\xa1\x12\x62\x38\x61\x2d\x52\xed\xed\x10\x45\x34\
\xfe\xe4\xf0\x27\x43\xac\xe1\x5a\x1a\xf7\x48\xaf\x32\x7c\xcb\x47\
\x50\x2f\x5c\x00\xf1\x14\x6f\x3d\x01\xb4\x43\x88\x50\xd2\x8f\x24\
\xc5\x63\x97\x83\x0a\xf1\x44\x63\xdb\x88\xdc\xa6\xd3\x08\x52\x93\
\x9e\x2c\xee\x1d\x49\x8c\x13\xad\xae\xe1\x4a\x00\x9d\x21\xf6\xf0\
\x6f\x41\xf5\x62\x57\xbc\x4f\x74\x6b\xfb\x0c\x9e\x6e\xd2\xf3\x01\
\xd1\x68\xe5\xb2\x25\xa8\xf4\xf5\xd1\x35\x5c\x09\xa0\x33\xc4\x6e\
\x7b\x8b\xdf\x76\x9a\x18\x5e\xff\x4c\x79\xa0\xe8\x47\x7a\xcb\xbd\
\xbc\xfa\xab\x7c\x7c\xda\xc4\x63\xee\x9f\xd1\x5c\x00\x5d\xfc\x03\
\x49\x23\xfe\xa5\xd2\xee\x5c\xf6\x00\x00\x00\x00\x49\x45\x4e\x44\
\xae\x42\x60\x82\
"
qt_resource_name = "\
\x00\x05\
\x00\x4f\xa6\x53\
\x00\x49\
\x00\x63\x00\x6f\x00\x6e\x00\x73\
\x00\x0d\
\x0c\xd2\xbf\xe7\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x72\x00\x65\x00\x64\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x05\xe2\x59\x27\
\x00\x6c\
\x00\x6f\x00\x67\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x02\x30\x8b\xe7\
\x00\x6c\
\x00\x69\x00\x73\x00\x74\x00\x2d\x00\x72\x00\x65\x00\x6d\x00\x6f\x00\x76\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x0a\x9a\x06\xa7\
\x00\x70\
\x00\x6c\x00\x61\x00\x79\x00\x65\x00\x72\x00\x5f\x00\x73\x00\x74\x00\x6f\x00\x70\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x09\
\x09\xf6\xbe\xc7\
\x00\x6d\
\x00\x75\x00\x73\x00\x69\x00\x63\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0d\
\x03\xd2\xbe\x67\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x75\x00\x6e\x00\x64\x00\x6f\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x10\
\x03\x05\x50\x67\
\x00\x70\
\x00\x6c\x00\x61\x00\x79\x00\x65\x00\x72\x00\x5f\x00\x70\x00\x61\x00\x75\x00\x73\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0e\
\x04\x44\x30\x87\
\x00\x43\
\x00\x6f\x00\x6c\x00\x6c\x00\x65\x00\x63\x00\x74\x00\x69\x00\x6f\x00\x6e\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x16\
\x0d\x69\x49\xe7\
\x00\x61\
\x00\x72\x00\x72\x00\x6f\x00\x77\x00\x2d\x00\x72\x00\x69\x00\x67\x00\x68\x00\x74\x00\x2d\x00\x64\x00\x6f\x00\x75\x00\x62\x00\x6c\
\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x15\
\x06\x6f\x74\x07\
\x00\x61\
\x00\x72\x00\x72\x00\x6f\x00\x77\x00\x2d\x00\x6c\x00\x65\x00\x66\x00\x74\x00\x2d\x00\x64\x00\x6f\x00\x75\x00\x62\x00\x6c\x00\x65\
\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x0d\x0e\x0f\x67\
\x00\x70\
\x00\x6c\x00\x61\x00\x79\x00\x65\x00\x72\x00\x5f\x00\x6e\x00\x65\x00\x78\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x15\
\x04\x57\xa1\xc7\
\x00\x61\
\x00\x75\x00\x64\x00\x69\x00\x6f\x00\x2d\x00\x76\x00\x6f\x00\x6c\x00\x75\x00\x6d\x00\x65\x00\x2d\x00\x68\x00\x69\x00\x67\x00\x68\
\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x0f\x22\x64\xc7\
\x00\x61\
\x00\x72\x00\x72\x00\x6f\x00\x77\x00\x2d\x00\x72\x00\x69\x00\x67\x00\x68\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x10\
\x07\x02\x48\x27\
\x00\x70\
\x00\x6c\x00\x61\x00\x79\x00\x65\x00\x72\x00\x5f\x00\x73\x00\x74\x00\x61\x00\x72\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0c\
\x09\xc6\x19\x27\
\x00\x6c\
\x00\x69\x00\x73\x00\x74\x00\x2d\x00\x61\x00\x64\x00\x64\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x06\x2f\x58\x67\
\x00\x72\
\x00\x6f\x00\x6c\x00\x6c\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x09\x30\x07\x07\
\x00\x70\
\x00\x6c\x00\x61\x00\x79\x00\x65\x00\x72\x00\x5f\x00\x70\x00\x72\x00\x65\x00\x76\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x1e\
\x00\xae\x2b\x47\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x63\x00\x6c\x00\x65\x00\x61\x00\x72\x00\x2d\x00\x6c\x00\x6f\x00\x63\x00\x61\x00\x74\x00\x69\
\x00\x6f\x00\x6e\x00\x62\x00\x61\x00\x72\x00\x2d\x00\x6c\x00\x74\x00\x72\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x11\
\x0f\xe3\xd5\x67\
\x00\x64\
\x00\x6f\x00\x63\x00\x75\x00\x6d\x00\x65\x00\x6e\x00\x74\x00\x2d\x00\x73\x00\x61\x00\x76\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\
\x00\x16\
\x02\x78\xcb\xa7\
\x00\x61\
\x00\x75\x00\x64\x00\x69\x00\x6f\x00\x2d\x00\x76\x00\x6f\x00\x6c\x00\x75\x00\x6d\x00\x65\x00\x2d\x00\x6d\x00\x75\x00\x74\x00\x65\
\x00\x64\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x08\
\x0f\x07\x5a\xc7\
\x00\x65\
\x00\x78\x00\x69\x00\x74\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x13\
\x0b\x16\x3a\xe7\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x63\x00\x6c\x00\x65\x00\x61\x00\x72\x00\x2d\x00\x6c\x00\x69\x00\x73\x00\x74\x00\x2e\x00\x70\
\x00\x6e\x00\x67\
\x00\x0f\
\x08\xe0\xe9\x07\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x72\x00\x65\x00\x6e\x00\x61\x00\x6d\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
\x00\x0f\
\x0c\x42\xa9\xc7\
\x00\x65\
\x00\x64\x00\x69\x00\x74\x00\x2d\x00\x64\x00\x65\x00\x6c\x00\x65\x00\x74\x00\x65\x00\x2e\x00\x70\x00\x6e\x00\x67\
"
qt_resource_struct = "\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\
\x00\x00\x00\x00\x00\x02\x00\x00\x00\x18\x00\x00\x00\x02\
\x00\x00\x02\x66\x00\x00\x00\x00\x00\x01\x00\x00\xaa\x62\
\x00\x00\x00\x46\x00\x00\x00\x00\x00\x01\x00\x00\x22\x39\
\x00\x00\x02\xd0\x00\x00\x00\x00\x00\x01\x00\x00\xb6\xc7\
\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x01\x00\x00\x5a\x88\
\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x01\x00\x00\x52\xa0\
\x00\x00\x00\xec\x00\x00\x00\x00\x00\x01\x00\x00\x61\xd5\
\x00\x00\x01\x94\x00\x00\x00\x00\x00\x01\x00\x00\x7f\x9c\
\x00\x00\x00\x30\x00\x00\x00\x00\x00\x01\x00\x00\x07\xd2\
\x00\x00\x02\x2c\x00\x00\x00\x00\x00\x01\x00\x00\x9c\x25\
\x00\x00\x01\x40\x00\x00\x00\x00\x00\x01\x00\x00\x72\x7c\
\x00\x00\x01\xe8\x00\x00\x00\x00\x00\x01\x00\x00\x8a\x2f\
\x00\x00\x03\x44\x00\x00\x00\x00\x00\x01\x00\x00\xcc\xda\
\x00\x00\x02\x42\x00\x00\x00\x00\x00\x01\x00\x00\xa2\xa0\
\x00\x00\x02\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x91\xbf\
\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x01\x00\x00\x2f\xdc\
\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x01\x00\x00\x28\x75\
\x00\x00\x03\x18\x00\x00\x00\x00\x00\x01\x00\x00\xc4\xa9\
\x00\x00\x03\x68\x00\x00\x00\x00\x00\x01\x00\x00\xce\xce\
\x00\x00\x00\x10\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\
\x00\x00\x01\x70\x00\x00\x00\x00\x00\x01\x00\x00\x77\xd4\
\x00\x00\x01\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x6d\x02\
\x00\x00\x03\x02\x00\x00\x00\x00\x00\x01\x00\x00\xbd\xc5\
\x00\x00\x01\xc4\x00\x00\x00\x00\x00\x01\x00\x00\x86\x3d\
\x00\x00\x02\xa8\x00\x00\x00\x00\x00\x01\x00\x00\xb1\xd4\
"
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
qInitResources()
| [
"Dhananjay Singh"
] | Dhananjay Singh |
310ef3f7f502ac9fca2d6fc43f37500bd8a533f7 | 3e4c3b6a6ba770fa18e9f072b1cfb58207f96b30 | /openaddr/compat.py | ec93ded08da55c579f23fc715124f0d6f8c05740 | [
"ISC"
] | permissive | cbmeeks/machine | 931b53657db3bb0b960006ccc6abd67fd41d704a | 39652f0614597e2b56973ded9f61a1a2a208da2e | refs/heads/master | 2020-12-26T00:46:01.112727 | 2016-07-31T03:41:06 | 2016-07-31T03:41:06 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,599 | py | import sys
import io
PY2 = (sys.version_info[0] == 2)
if PY2:
import unicodecsv, subprocess32, uritemplate
unicodecsv.field_size_limit(sys.maxsize)
check_output = subprocess32.check_output
CalledProcessError = subprocess32.CalledProcessError
TimeoutExpired = subprocess32.TimeoutExpired
csvIO = io.BytesIO
def csvreader(file, encoding=None, **kwargs):
''' Pass encoding to unicodecsv
'''
if encoding is not None:
kwargs['encoding'] = encoding
if 'delimiter' in kwargs:
kwargs['delimiter'] = str(kwargs['delimiter'])
return unicodecsv.reader(file, **kwargs)
def csvwriter(file, encoding=None, **kwargs):
''' Pass encoding to unicodecsv
'''
if encoding is not None:
kwargs['encoding'] = encoding
return unicodecsv.writer(file, **kwargs)
def csvDictReader(file, encoding=None, delimiter=None, **kwargs):
''' Pass encoding to unicodecsv
'''
# Python2 unicodecsv requires this be not unicode
if delimiter is not None:
kwargs['delimiter'] = delimiter.encode('ascii')
if encoding is not None:
kwargs['encoding'] = encoding
return unicodecsv.DictReader(file, **kwargs)
def csvDictWriter(file, fieldnames, encoding=None, delimiter=None, **kwargs):
''' Pass encoding to unicodecsv
'''
# Python2 unicodecsv requires this be not unicode
if delimiter is not None:
kwargs['delimiter'] = delimiter.encode('ascii')
if encoding is not None:
kwargs['encoding'] = encoding
return unicodecsv.DictWriter(file, fieldnames, **kwargs)
def csvopen(filename, mode='r', encoding=None):
''' Discard encoding
'''
return io.FileIO(filename, mode=mode)
def expand_uri(template, args):
'''
'''
new_args = {k: v for (k, v) in args.items() if not hasattr(v, 'encode')}
new_args.update({k: v.encode('utf8') for (k, v) in args.items() if hasattr(v, 'encode')})
return uritemplate.expand(template, new_args)
from future import standard_library
standard_library.install_aliases()
else:
import csv, subprocess
from uritemplate import expand as expand_uri
standard_library = None
check_output = subprocess.check_output
CalledProcessError = subprocess.CalledProcessError
TimeoutExpired = subprocess.TimeoutExpired
csvIO = io.StringIO
def csvreader(file, encoding=None, **kwargs):
''' Discard encoding
'''
if 'delimiter' in kwargs:
kwargs['delimiter'] = str(kwargs['delimiter'])
return csv.reader(file, **kwargs)
def csvwriter(file, encoding=None, **kwargs):
''' Discard encoding
'''
return csv.writer(file, **kwargs)
def csvDictReader(file, encoding=None, **kwargs):
''' Discard encoding
'''
return csv.DictReader(file, **kwargs)
def csvDictWriter(file, fieldnames, encoding=None, **kwargs):
''' Discard encoding
'''
return csv.DictWriter(file, fieldnames, **kwargs)
def csvopen(filename, mode='r', encoding=None):
''' Pass encoding to io.open
'''
return io.open(filename, mode=mode, encoding=encoding)
try:
import cairo
except ImportError:
# http://stackoverflow.com/questions/11491268/install-pycairo-in-virtualenv
import cairocffi as cairo
| [
"mike@teczno.com"
] | mike@teczno.com |
d680686b38adb8e9cdfc5bf3e14016b01354af3a | d1c6de4e0d4aafbe1e7d15a02487494f86bf9b7e | /알고리즘문제/내려가기.py | 1515a653c108bd21017b437c35fc3fc9e25479c1 | [] | no_license | kdm604/TIL | d2ce2122e0b828a595530ac2a405a4661cf60205 | 554bbd8e884f4e7fbebdefbfa22a1a5eee0fa452 | refs/heads/master | 2023-01-11T21:41:57.845549 | 2020-03-24T08:55:10 | 2020-03-24T08:55:10 | 195,938,033 | 0 | 0 | null | 2023-01-05T01:14:37 | 2019-07-09T05:23:00 | Python | UTF-8 | Python | false | false | 903 | py | import sys
N = int(input())
ans_max = [[0 for _ in range(3)]for _ in range(2)]
ans_min = [[0 for _ in range(3)]for _ in range(2)]
for i in range(1, N+1):
arr = list(map(int, sys.stdin.readline().split()))
ans_max[i % 2][0] = max(ans_max[(i -1)%2][0], ans_max[(i-1) %2][1]) + arr[0]
ans_max[i % 2][1] = max(ans_max[(i - 1) % 2][0], ans_max[(i - 1) % 2][1], ans_max[(i - 1) % 2][2]) + arr[1]
ans_max[i % 2][2] = max(ans_max[(i - 1) % 2][1], ans_max[(i - 1) % 2][2]) + arr[2]
ans_min[i % 2][0] = min(ans_min[(i - 1) % 2][0], ans_min[(i - 1) % 2][1]) + arr[0]
ans_min[i % 2][1] = min(ans_min[(i - 1) % 2][0], ans_min[(i - 1) % 2][1], ans_min[(i - 1) % 2][2]) + arr[1]
ans_min[i % 2][2] = min(ans_min[(i - 1) % 2][1], ans_min[(i - 1) % 2][2]) + arr[2]
print(max(ans_max[N%2][0], ans_max[N%2][1], ans_max[N%2][2]))
print(min(ans_min[N%2][0], ans_min[N%2][1], ans_min[N%2][2])) | [
"kdm604@naver.com"
] | kdm604@naver.com |
08565882106288aee36851f122b7b9773fb09e3b | 97f8c4be1f7ab792da23abc317f7daff70048fdf | /lumm_pytorch/pytorch_hub.py | 8856d07dc50ee1788e0153276be0bfd6dfe255a0 | [] | no_license | Lummetry/-archived-VaporPlusBenchmark | 1b1156c926bc85da6161836259badaf602f178fb | 52621c5290eb5ec714b5df747280753eb677000f | refs/heads/main | 2023-03-04T18:36:39.994378 | 2021-02-18T15:16:01 | 2021-02-18T15:16:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,891 | py | """
Copyright 2019 Lummetry.AI (Knowledge Investment Group SRL). All Rights Reserved.
* NOTICE: All information contained herein is, and remains
* the property of Knowledge Investment Group SRL.
* The intellectual and technical concepts contained
* herein are proprietary to Knowledge Investment Group SRL
* and may be covered by Romanian and Foreign Patents,
* patents in process, and are protected by trade secret or copyright law.
* Dissemination of this information or reproduction of this material
* is strictly forbidden unless prior written permission is obtained
* from Knowledge Investment Group SRL.
@copyright: Lummetry.AI
@author: Lummetry.AI
@project:
@description:
"""
import os
import sys
sys.path.append(os.path.join(os.getcwd(), 'third_party', 'pytorch', 'yolov3'))
import torch as th
from lumm_pytorch import utils
THH_YOLOV3 = ('ultralytics/yolov3', 'yolov3')
THH_YOLOV3SPP = ('ultralytics/yolov3', 'yolov3_spp')
THH_YOLOV3TINY = ('ultralytics/yolov3', 'yolov3_tiny')
# THH_YOLOV5 = ('ultralytics/yolov5', 'yolov5')
THH_YOLOV5S = ('ultralytics/yolov5', 'yolov5s')
THH_YOLOV5M = ('ultralytics/yolov5', 'yolov5m')
THH_YOLOV5L = ('ultralytics/yolov5', 'yolov5l')
THH_YOLOV5X = ('ultralytics/yolov5', 'yolov5x')
MODELS = [THH_YOLOV3, THH_YOLOV3SPP, THH_YOLOV3TINY,
THH_YOLOV5S, THH_YOLOV5M, THH_YOLOV5L, THH_YOLOV5X]
DEVICE = th.device('cuda:0' if th.cuda.is_available() else 'cpu')
def get_pytorchhub_model(log, repo_or_dir, model_name):
model = th.hub.load(
repo_or_dir=repo_or_dir,
model=model_name,
pretrained=True,
# force_reload=True
).to(DEVICE)
return model
def load_onnx_model(log, model_name):
log.p('Loading onnx model {}...'.format(model_name))
model, ort_sess = utils.load_onnx_model(
log=log,
model_name=model_name,
full_path=False
)
log.p('Done', show_time=True)
return model, ort_sess
| [
"alexandru.purdila@lummetry.ai"
] | alexandru.purdila@lummetry.ai |
c01a817cc4d0aa8b0231ede0e301752fcd445a84 | d3c510930a88a85c853180b9069e2fab846598e5 | /tinkerforge/bricklet_lcd_16x2.py | 9f7bbf11461be88a5c4a4980d4888b346856ca93 | [] | no_license | kaechm/sauerklaud | caca80d63fe148221e7d7a8e7a0432e05f0df3f7 | f71e99ee16a624cb95ffda5e046c8f97236dd407 | refs/heads/master | 2021-01-13T10:07:24.922608 | 2016-11-06T10:24:27 | 2016-11-06T10:24:27 | 72,924,117 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,959 | py | # -*- coding: utf-8 -*-
#############################################################
# This file was automatically generated on 2016-09-08. #
# #
# Python Bindings Version 2.1.10 #
# #
# If you have a bugfix for this file and want to commit it, #
# please fix the bug in the generator. You can find a link #
# to the generators git repository on tinkerforge.com #
#############################################################
try:
from collections import namedtuple
except ImportError:
try:
from .ip_connection import namedtuple
except ValueError:
from ip_connection import namedtuple
try:
from .ip_connection import Device, IPConnection, Error
except ValueError:
from ip_connection import Device, IPConnection, Error
GetConfig = namedtuple('Config', ['cursor', 'blinking'])
GetIdentity = namedtuple('Identity', ['uid', 'connected_uid', 'position', 'hardware_version', 'firmware_version', 'device_identifier'])
class BrickletLCD16x2(Device):
"""
16x2 character alphanumeric display with blue backlight
"""
DEVICE_IDENTIFIER = 211
DEVICE_DISPLAY_NAME = 'LCD 16x2 Bricklet'
CALLBACK_BUTTON_PRESSED = 9
CALLBACK_BUTTON_RELEASED = 10
FUNCTION_WRITE_LINE = 1
FUNCTION_CLEAR_DISPLAY = 2
FUNCTION_BACKLIGHT_ON = 3
FUNCTION_BACKLIGHT_OFF = 4
FUNCTION_IS_BACKLIGHT_ON = 5
FUNCTION_SET_CONFIG = 6
FUNCTION_GET_CONFIG = 7
FUNCTION_IS_BUTTON_PRESSED = 8
FUNCTION_SET_CUSTOM_CHARACTER = 11
FUNCTION_GET_CUSTOM_CHARACTER = 12
FUNCTION_GET_IDENTITY = 255
def __init__(self, uid, ipcon):
"""
Creates an object with the unique device ID *uid* and adds it to
the IP Connection *ipcon*.
"""
Device.__init__(self, uid, ipcon)
self.api_version = (2, 0, 0)
self.response_expected[BrickletLCD16x2.FUNCTION_WRITE_LINE] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_CLEAR_DISPLAY] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_BACKLIGHT_ON] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_BACKLIGHT_OFF] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_IS_BACKLIGHT_ON] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_TRUE
self.response_expected[BrickletLCD16x2.FUNCTION_SET_CONFIG] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_GET_CONFIG] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_TRUE
self.response_expected[BrickletLCD16x2.FUNCTION_IS_BUTTON_PRESSED] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_TRUE
self.response_expected[BrickletLCD16x2.CALLBACK_BUTTON_PRESSED] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_FALSE
self.response_expected[BrickletLCD16x2.CALLBACK_BUTTON_RELEASED] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_SET_CUSTOM_CHARACTER] = BrickletLCD16x2.RESPONSE_EXPECTED_FALSE
self.response_expected[BrickletLCD16x2.FUNCTION_GET_CUSTOM_CHARACTER] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_TRUE
self.response_expected[BrickletLCD16x2.FUNCTION_GET_IDENTITY] = BrickletLCD16x2.RESPONSE_EXPECTED_ALWAYS_TRUE
self.callback_formats[BrickletLCD16x2.CALLBACK_BUTTON_PRESSED] = 'B'
self.callback_formats[BrickletLCD16x2.CALLBACK_BUTTON_RELEASED] = 'B'
def write_line(self, line, position, text):
"""
Writes text to a specific line (0 to 1) with a specific position
(0 to 15). The text can have a maximum of 16 characters.
For example: (0, 5, "Hello") will write *Hello* in the middle of the
first line of the display.
The display uses a special charset that includes all ASCII characters except
backslash and tilde. The LCD charset also includes several other non-ASCII characters, see
the `charset specification <https://github.com/Tinkerforge/lcd-16x2-bricklet/raw/master/datasheets/standard_charset.pdf>`__
for details. The Unicode example above shows how to specify non-ASCII characters
and how to translate from Unicode to the LCD charset.
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_WRITE_LINE, (line, position, text), 'B B 16s', '')
def clear_display(self):
"""
Deletes all characters from the display.
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_CLEAR_DISPLAY, (), '', '')
def backlight_on(self):
"""
Turns the backlight on.
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_BACKLIGHT_ON, (), '', '')
def backlight_off(self):
"""
Turns the backlight off.
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_BACKLIGHT_OFF, (), '', '')
def is_backlight_on(self):
"""
Returns *true* if the backlight is on and *false* otherwise.
"""
return self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_IS_BACKLIGHT_ON, (), '', '?')
def set_config(self, cursor, blinking):
"""
Configures if the cursor (shown as "_") should be visible and if it
should be blinking (shown as a blinking block). The cursor position
is one character behind the the last text written with
:func:`WriteLine`.
The default is (false, false).
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_SET_CONFIG, (cursor, blinking), '? ?', '')
def get_config(self):
"""
Returns the configuration as set by :func:`SetConfig`.
"""
return GetConfig(*self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_GET_CONFIG, (), '', '? ?'))
def is_button_pressed(self, button):
"""
Returns *true* if the button (0 to 2) is pressed.
If you want to react on button presses and releases it is recommended to use the
:func:`ButtonPressed` and :func:`ButtonReleased` callbacks.
"""
return self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_IS_BUTTON_PRESSED, (button,), 'B', '?')
def set_custom_character(self, index, character):
"""
The LCD 16x2 Bricklet can store up to 8 custom characters. The characters
consist of 5x8 pixels and can be addressed with the index 0-7. To describe
the pixels, the first 5 bits of 8 bytes are used. For example, to make
a custom character "H", you should transfer the following:
* ``character[0] = 0b00010001`` (decimal value 17)
* ``character[1] = 0b00010001`` (decimal value 17)
* ``character[2] = 0b00010001`` (decimal value 17)
* ``character[3] = 0b00011111`` (decimal value 31)
* ``character[4] = 0b00010001`` (decimal value 17)
* ``character[5] = 0b00010001`` (decimal value 17)
* ``character[6] = 0b00010001`` (decimal value 17)
* ``character[7] = 0b00000000`` (decimal value 0)
The characters can later be written with :func:`WriteLine` by using the
characters with the byte representation 8 to 15.
You can play around with the custom characters in Brick Viewer since
version 2.0.1.
Custom characters are stored by the LCD in RAM, so they have to be set
after each startup.
.. versionadded:: 2.0.1$nbsp;(Plugin)
"""
self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_SET_CUSTOM_CHARACTER, (index, character), 'B 8B', '')
def get_custom_character(self, index):
"""
Returns the custom character for a given index, as set with
:func:`SetCustomCharacter`.
.. versionadded:: 2.0.1$nbsp;(Plugin)
"""
return self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_GET_CUSTOM_CHARACTER, (index,), 'B', '8B')
def get_identity(self):
"""
Returns the UID, the UID where the Bricklet is connected to,
the position, the hardware and firmware version as well as the
device identifier.
The position can be 'a', 'b', 'c' or 'd'.
The device identifier numbers can be found :ref:`here <device_identifier>`.
|device_identifier_constant|
"""
return GetIdentity(*self.ipcon.send_request(self, BrickletLCD16x2.FUNCTION_GET_IDENTITY, (), '', '8s 8s c 3B 3B H'))
def register_callback(self, id, callback):
"""
Registers a callback with ID *id* to the function *callback*.
"""
self.registered_callbacks[id] = callback
LCD16x2 = BrickletLCD16x2 # for backward compatibility
| [
"g4lp@pc192-168-2-192.speedport_w_724v_typ_a_05011603_00_009"
] | g4lp@pc192-168-2-192.speedport_w_724v_typ_a_05011603_00_009 |
9be9229a0c8ca43f2503e6ca2946175bc68be236 | 009738b17c73bd6e89e9c31d85c5d8b5d7e8c490 | /Assignment12/MyCodeForHW12Q2.py | a189d9ce6a85325931d6cec8ec419cfd9ed7bf80 | [] | no_license | yifanlee1128/PythonProject_Coursework_Risk | a2d769bcd95ad1859df137c87f7138ea0a32cd83 | 217d9c224f48667f7b810576ff1fb98a149bcaa6 | refs/heads/master | 2021-01-07T13:20:03.057157 | 2020-02-19T19:31:05 | 2020-02-19T19:31:05 | 241,706,178 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 559 | py | import pandas as pd
import numpy as np
data=pd.read_csv("C:/Users/liyf4/Desktop/2013 Dow Jones Implieds key.csv",encoding = "ISO-8859-1")
data_of_vol=data["Implied Vol"].values[1:-2]
data_of_vol=[float(str[:-1])*0.01 for str in data_of_vol]
portfolio_vol=float(data["Implied Vol"].values[-1][:-1])*0.01
data_of_weight=data["Weight"].values[1:-2]
list_v=[i*j for i,j in zip(data_of_vol,data_of_weight)]
list_v_square=[i**2 for i in list_v]
rho_average=(portfolio_vol**2-np.sum(list_v_square))/(np.sum(list_v)**2-np.sum(list_v_square))
print(rho_average) | [
"60717725+yifanlee1128@users.noreply.github.com"
] | 60717725+yifanlee1128@users.noreply.github.com |
58c642aac27152fd5d272ddc9d15b1ee224c4e90 | 31f7307b7fe5e088126968f9445913cc70b630f4 | /app/database.py | 9abbce885b1e016ad0b44056837e22418e1ca385 | [] | no_license | Jbawi/Bug-Tracker | 233db0e42be99b7f2a1369ac5d8040973065ecc8 | d82ed2cfa187009452fb38656e5dd3b0205355dc | refs/heads/master | 2023-03-22T13:34:50.819408 | 2021-03-10T11:20:08 | 2021-03-10T11:20:08 | 346,312,170 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,416 | py | #--------------------------------------
# WEB 2019/2020
# Aufgabe P2 / Anwendungsrahmen
#--------------------------------------
import os
import os.path
import codecs
import json
from . import dataid
from . import storage
#----------------------------------------------------------
class Database_cl(object):
#----------------------------------------------------------
#-------------------------------------------------------
def __init__(self, currDir_spl):
#-------------------------------------------------------
self.maxId_o = dict()
self.maxId_o["bugs"] = dataid.DataId_cl(currDir_spl, "bugs")
self.maxId_o["components"] = dataid.DataId_cl(currDir_spl, "components")
self.maxId_o["devs"] = dataid.DataId_cl(currDir_spl, "devs")
self.maxId_o["projects"] = dataid.DataId_cl(currDir_spl, "projects")
self.maxId_o["catCause"] = dataid.DataId_cl(currDir_spl, "catCause")
self.maxId_o["catError"] = dataid.DataId_cl(currDir_spl, "catError")
self.types_o = {
'bugs': {
'storage': storage.Storage_cl('bugs', currDir_spl, self.maxId_o['bugs']),
'defaults': {
"description": "",
"discoverer_id": "",
"foundAtDate": "",
"qs_id": "1",
"category": "",
"se_id": "",
"solution": "",
"solvedAtDate": "",
"causeOfError": "",
"bugStatus": "1"
}
},
'components': {
'storage': storage.Storage_cl('components', currDir_spl, self.maxId_o['components']),
'defaults': {
"project_id": "",
"title": ""
}
},
'devs': {
'storage': storage.Storage_cl('devs', currDir_spl, self.maxId_o['devs']),
'defaults': {
"name": "",
"role": ""
}
},
'projects': {
'storage': storage.Storage_cl('projects', currDir_spl, self.maxId_o['projects']),
'defaults': {
"name": "",
"description": ""
}
},
'catCause': {
'storage': storage.Storage_cl('catCause', currDir_spl, self.maxId_o['catCause']),
'defaults': {
"type": ""
}
},
'catError': {
'storage': storage.Storage_cl('catError', currDir_spl, self.maxId_o['catCause']),
'defaults': {
"type": ""
}
}
}
#-------------------------------------------------------
def getStorage_px(self, type_spl):
#-------------------------------------------------------
storage_o = None
if type_spl in self.types_o:
storage_o = self.types_o[type_spl]['storage']
return storage_o
#-------------------------------------------------------
def getDefaults_px(self, type_spl):
#-------------------------------------------------------
defaults_o = None
if type_spl in self.types_o:
defaults_o = self.types_o[type_spl]['defaults']
return defaults_o
# EOF | [
"jbawi87@gmail.com"
] | jbawi87@gmail.com |
bed2261f1d7845cdf4ff8dea7f2dcbf2d777fb6e | f2a6134878d693b1fb5a26e5b2b50b82a085e3f6 | /testing-sikuli v1/Tryout/Melihat_statistik_tryout.sikuli/Melihat_statistik_tryout.py | a4f2f33324bad74f75df69828b0705ec2d1ccbd8 | [] | no_license | kekoa-/testing-sikuli | 22a900ab4efee7b0e76db0bc70c9fab88345746c | bb4f53a6928c3a9eb9e47167ddc1d56951364a70 | refs/heads/master | 2021-01-15T21:20:41.437740 | 2014-12-29T17:58:10 | 2014-12-29T17:58:10 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 209 | py | find("1400018263527.png")
click("1400018263527.png")
wait("1400018306822.png",10)
click("1419477877473.png")
r = Region(Region(106,176,1133,209))
r.click("1400020279840.png")
assert exists("1419478036326.png") | [
"hadiyannr@gmail.com"
] | hadiyannr@gmail.com |
8df0dee6f8ff3eafaf9656e8b71a50a8800b416a | 77e2b7abe2b964f95a1d34b86448b4521e39cc8d | /circuit_graph/_imports_.py | eb386bac311e6208db1cfe52fe5fc905ba36ac34 | [] | no_license | katwinkl3/circuit_graph | 774b6410409c214ac356884643bdeb112bcfe698 | 782cf70efa89a2e0fd22b71b8a604b8cf12089ae | refs/heads/master | 2023-04-08T14:42:33.644512 | 2021-04-03T13:16:24 | 2021-04-03T13:16:24 | 341,521,958 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 125 | py | from .CircuitGraph import CircuitGraph
from .CircuitMap import CircuitMap
__all__ = [
"CircuitGraph",
"CircuitMap"
] | [
"kat-sun@hotmail.com"
] | kat-sun@hotmail.com |
8f3cc002c398732246f1e2d85326681bd76a8411 | c5a8f6dd4e5ebc43f02923704325620f0787b2f4 | /visual-experiments/rectangular_visualizer.py | 657afe5661a8fb7256dba49930c2c02daf9a6eec | [] | no_license | alex-berman/tforms | 50098501d19de75632426423d02025162bbc94e6 | 046476001609dfa8192c2e373a040d4129975ab6 | refs/heads/master | 2021-01-01T20:00:00.381901 | 2014-03-16T13:44:09 | 2014-03-16T13:44:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 936 | py | import visualizer
from visualizer import File, run
from vector import DirectionalVector, Vector2d
import math
class Chunk:
def peer_position(self):
return Visualizer.bearing_to_border_position(
self.peer.bearing, self.visualizer.width, self.visualizer.height)
class Segment(visualizer.Segment, Chunk):
pass
class Peer(visualizer.Peer):
pass
class Visualizer(visualizer.Visualizer):
@staticmethod
def bearing_to_border_position(bearing, width, height):
radius = math.sqrt(width*width + height*height) / 2
midpoint = Vector2d(width/2, height/2)
circle_position = midpoint + DirectionalVector(bearing - 2*math.pi/4, radius)
return circle_position
def pan_segment(self, segment):
relative_x = segment.pan
space_y = 3
space_x = (relative_x - 0.5) * 5
self.orchestra.place_segment(segment.id, space_x, space_y, segment.duration)
| [
"alex@nimations.com"
] | alex@nimations.com |
ff3e6ea7c91c38a3b654ddc1814e68de5875b33c | f115cc6d4b0d59941dc3cc62b848fc4cfb00fad3 | /Python/multiprocessing.py | bd709fbed4f7301449a8d9b71ccfdec5c7f955e7 | [
"MIT"
] | permissive | jbrdge/Recipes | c3c98f5b09d4327326c395f9580a325002ff5c23 | 7ab1d0843e2fad89105c4bc9bc7afbf1ed0a72e2 | refs/heads/master | 2023-06-20T10:12:09.947689 | 2021-07-18T00:07:28 | 2021-07-18T00:07:28 | 294,727,027 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,611 | py | #!/usr/bin/env python
# Attribution: https://medium.com/python-in-plain-english/pandas-and-multiprocessing-how-to-create-dataframes-in-a-parallel-way-72f9b18ea72f
import pandas
import psutil
import time
import os
from pathlib import Path
from multiprocessing import Pool
def get_files(directory,pattern):
'''
Get the files of a directory
'''
for path in Path(directory).rglob(pattern):
yield path.absolute()
def process_file(filename):
''''
Read an xls file, retun a dataframe
''''
return pandas.read_excel(filename,index_col=None)
def pd_wrapper(directory,pattern,processes=-1):
# Decide how many proccesses will be created
sum_size = 0
if processes <=0:
num_cpus = psutil.cpu_count(logical=False)
else:
num_cpus = processes
files = []
# Get files based on pattern and their sum of size
for file in get_files(directory=directory,pattern=pattern):
sum_size =sum_size + os.path.getsize(file)
files.append(file)
print('files:%s,size:%s bytes, procs:%s'%(len(files),sum_size,num_cpus))
# Create the pool
process_pool = Pool(processes=num_cpus)
start = time.time()
# Start processes in the pool
dfs = process_pool.map(process_file, files)
# Concat dataframes to one dataframe
data = pandas.concat(dfs, ignore_index=True)
end = time.time()
print('Completed in: %s sec'%(end - start))
return data
if __name__ == '__main__':
#control how many processes you have at once with processes
df = pd_wrapper(directory='./xls',pattern='*.xls',processes=-1)
print(df.count) | [
"jbrecken@email.arizona.edu"
] | jbrecken@email.arizona.edu |
8ae8c908984599026a33d1976972cde96a8680b9 | 6ab2bd811d01d20e3d1c925783d9209f44f97c8a | /oauth2.py | 00600191978b24f0447f5b1ff86c6832105ca279 | [] | no_license | navinfeb15/login | 572a6072ac125932cabf6ec93a7f06287ad44f5b | bf2730b25a6deca2629114135719c660e0ae585c | refs/heads/master | 2023-06-05T08:47:28.935476 | 2021-06-13T13:51:44 | 2021-06-13T13:51:44 | 374,637,476 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 553 | py | from fastapi import Depends, HTTPException, status
from routers import token as tk #Had to rename this...
from fastapi.security import OAuth2PasswordBearer
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
return tk.verify_token(token,credentials_exception)
#returns token data
| [
"navinfeb15@gmail.com"
] | navinfeb15@gmail.com |
1329ed32a5a2e51bdfe4a44278835b79160a7c32 | 6ef0024faee92348be3d29a4b70a5b680649250c | /preprocess.py | 471d6ca82a3f96ca6dda8747c76f3d3cd20c5db3 | [] | no_license | SantiJavi/ecg-proyecto | c705e4a94169ea4268426890b7f74bec2471ca56 | d8e7d0da8bc364d7815f0429e1ca1299a90e0e63 | refs/heads/main | 2023-07-25T23:19:43.113958 | 2021-09-09T03:23:41 | 2021-09-09T03:23:41 | 404,571,356 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,949 | py | import wfdb
import numpy as np
import pandas as pd
from glob import glob
import argparse
import os
#coje los archivos .hea y luego lee el id del paciente
#sexo,edad y demas datos, luego los pone en un data set y los ordena andemas de mandarlos a un csv
def gen_reference_csv(data_dir, reference_csv):
if not os.path.exists(reference_csv):
recordpaths = glob(os.path.join(data_dir, '*.hea'))
results = []
for recordpath in recordpaths:
patient_id = recordpath.split('/')[-1][:-4]
_, meta_data = wfdb.rdsamp(recordpath[:-4])
sample_rate = meta_data['fs']
signal_len = meta_data['sig_len']
age = meta_data['comments'][0]
sex = meta_data['comments'][1]
dx = meta_data['comments'][2]
age = age[5:] if age.startswith('Age: ') else np.NaN
sex = sex[5:] if sex.startswith('Sex: ') else 'Unknown'
dx = dx[4:] if dx.startswith('Dx: ') else ''
results.append([patient_id, sample_rate, signal_len, age, sex, dx])
df = pd.DataFrame(data=results, columns=['patient_id', 'sample_rate', 'signal_len', 'age', 'sex', 'dx'])
df.sort_values('patient_id').to_csv(reference_csv, index=None)
# Clasifica y etiqueta las arritmias segun el archivo .hea
#Esto lo hace para cada uno de los registros de la base CPSC
def gen_label_csv(label_csv, reference_csv, dx_dict, classes):
if not os.path.exists(label_csv):
results = []
df_reference = pd.read_csv(reference_csv)
for _, row in df_reference.iterrows():
patient_id = row['patient_id']
dxs = [dx_dict.get(code, '') for code in row['dx'].split(',')]
labels = [0] * 9
for idx, label in enumerate(classes):
if label in dxs:
labels[idx] = 1
results.append([patient_id] + labels)
df = pd.DataFrame(data=results, columns=['patient_id'] + classes)
n = len(df)
folds = np.zeros(n, dtype=np.int8)
for i in range(10):
start = int(n * i / 10)
end = int(n * (i + 1) / 10)
folds[start:end] = i + 1
df['fold'] = np.random.permutation(folds)
columns = df.columns
df['keep'] = df[classes].sum(axis=1)
df = df[df['keep'] > 0]
df[columns].to_csv(label_csv, index=None)
if __name__ == "__main__":
leads = ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']
dx_dict = {
#diagnosticos, segun el numero se puede clasifica a la enfermedad.
#en cada archivo .hea podemos ver que enfermedad es la que posee el paciente.
'426783006': 'SNR', # Normal sinus rhythm
'164889003': 'AF', # Atrial fibrillation
'270492004': 'IAVB', # First-degree atrioventricular block
'164909002': 'LBBB', # Left bundle branch block
'713427006': 'RBBB', # Complete right bundle branch block
'59118001': 'RBBB', # Right bundle branch block
'284470004': 'PAC', # Premature atrial contraction
'63593006': 'PAC', # Supraventricular premature beats
'164884008': 'PVC', # Ventricular ectopics
'429622005': 'STD', # ST-segment depression
'164931005': 'STE', # ST-segment elevation
}
classes = ['SNR', 'AF', 'IAVB', 'LBBB', 'RBBB', 'PAC', 'PVC', 'STD', 'STE']
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', type=str, default='data/CPSC', help='Directory to dataset')
args = parser.parse_args()
data_dir = args.data_dir
reference_csv = os.path.join(data_dir, 'reference.csv')
label_csv = os.path.join(data_dir, 'labels.csv')
#extraigo caracteritsicas de mas detalle del ecg
gen_reference_csv(data_dir, reference_csv)
#genero un archivo en el cual ya etiqueto con un 1 en la enfermedad de cada paciente
gen_label_csv(label_csv, reference_csv, dx_dict, classes)
| [
"sjcastro@uce.edu.ec"
] | sjcastro@uce.edu.ec |
44c7962d4d2b9a256518489e2d091e8d0f0f2e8e | d204428c0ce8229d97013dae9a5a68a709aa763e | /day10_MongoDB.py | 1492cb93b580808eb3f158de2f0612b57e24c51b | [] | no_license | cellname/learn | 82d39e4c42537713d67c18bbab21f49852f17c3e | df870d179e31051f0547f3d1a1c05ea26b1aad04 | refs/heads/master | 2021-04-13T03:09:25.738245 | 2020-03-22T06:34:26 | 2020-03-22T06:34:26 | 249,131,932 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 863 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : running_fish
# @Time : 2020/3/17 0017 下午 14:57
# @File : day10_MongoDB.py
# @Software : PyCharm
import pymongo
# 1、创建MongoDB的链接对象
client = pymongo.MongoClient(host='0.0.0.0', port=27017)
# 也可以这样创建
client = pymongo.MongoClient('mongodb://localhost:27017/')
# 2、指定数据库：调用client的test属性即可返回test数据库
db = client.test
db = client['test']
# 3、指定集合
collection = db.students
collection = db['students']
# 4、插入数据
student = {
'id': '1002',
'name': 'Bob',
'age': '20',
'gender': 'male',
}
result = collection.insert_one(student)
print(result.text())
# 断开连接，将关闭连接池汇总的所有基础套接字，如果再次使用此实例，它将自动重新打开
client.close()
| [
"5743899+new_fish_learn_python@user.noreply.gitee.com"
] | 5743899+new_fish_learn_python@user.noreply.gitee.com |
600399fb77ccd17be8f7420da188bbbf179f2362 | 67fda80224efebe6ffe8994c5df2036667175713 | /servicecatalog_puppet/workflow/launch/do_describe_provisioning_parameters_test.py | 684a8b42793d9c85b1127e7c330f061e6779e0f3 | [
"Apache-2.0"
] | permissive | jordan-evans/aws-service-catalog-puppet | d2a4874c13ac215f4322a7bd5001e2a5647d395a | 1445e110d631a283483e8f403f4a59fe7ff7590e | refs/heads/master | 2021-12-03T20:34:50.543759 | 2021-11-18T20:53:15 | 2021-11-18T20:53:15 | 196,200,076 | 0 | 0 | Apache-2.0 | 2019-07-10T12:20:18 | 2019-07-10T12:20:17 | null | UTF-8 | Python | false | false | 2,052 | py | # Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
from unittest import skip
from servicecatalog_puppet.workflow import tasks_unit_tests_helper
class DoDescribeProvisioningParametersTest(tasks_unit_tests_helper.PuppetTaskUnitTest):
manifest_file_path = "manifest_file_path"
puppet_account_id = "puppet_account_id"
region = "region"
product_id = "product_id"
version_id = "version_id"
portfolio = "portfolio"
def setUp(self) -> None:
from servicecatalog_puppet.workflow.launch import (
do_describe_provisioning_parameters,
)
self.module = do_describe_provisioning_parameters
self.sut = self.module.DoDescribeProvisioningParameters(
manifest_file_path=self.manifest_file_path,
puppet_account_id=self.puppet_account_id,
region=self.region,
product_id=self.product_id,
version_id=self.version_id,
portfolio=self.portfolio,
)
self.wire_up_mocks()
def test_params_for_results_display(self):
# setup
expected_result = {
"puppet_account_id": self.puppet_account_id,
"portfolio": self.portfolio,
"region": self.region,
"product_id": self.product_id,
"version_id": self.version_id,
}
# exercise
actual_result = self.sut.params_for_results_display()
# verify
self.assertEqual(expected_result, actual_result)
def test_api_calls_used(self):
# setup
expected_result = [
f"servicecatalog.describe_provisioning_parameters_{self.puppet_account_id}_{self.region}",
]
# exercise
actual_result = self.sut.api_calls_used()
# verify
self.assertEqual(expected_result, actual_result)
@skip
def test_run(self):
# setup
# exercise
actual_result = self.sut.run()
# verify
raise NotImplementedError()
| [
"noreply@github.com"
] | jordan-evans.noreply@github.com |
042476a02c8bf29a0201454a2168abe364601a48 | a67d999deafb7d3dac60ad95f66234fe3e79030e | /Python/Advanted/src/chauthoi/myGUItest1.py | 3a9a1c4fe3d7059a5e5b5415c33d5c352348e5ae | [] | no_license | tielse/Example_Python | 1282728a3e38725a48f30a1c49a688b5262be485 | 0bc31f86f16ef98cf3b7ad8a524c27978e47775f | refs/heads/master | 2021-01-02T22:36:58.866922 | 2017-08-04T15:25:17 | 2017-08-04T15:25:17 | 99,355,643 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 140 | py | #!/usr/bin/env python 2.7
import Tkinter
from Tkinter import *
Widget=Label(None,text='Hello Python')
Widget.pack()
Widget.mainloop() | [
"you@example.com"
] | you@example.com |
7a15d93ffe5208e8afe7da36fd5f11f27c9fd337 | 59e8a041435b70f1dfb2464ccef298c69cf8466e | /058_Length_of_Last_Word/tests.py | 22dd861ca481516c780a5c55fa2454e7d4fdcbd3 | [] | no_license | sallowdish/LeetCode | f0aa6c5be864711c75a3583f320ce967d50c55d3 | d12ca00f30a1784802f42f8e76f782d7b72e95a6 | refs/heads/master | 2021-01-21T04:32:02.351940 | 2016-06-25T00:12:22 | 2016-06-25T00:12:22 | 33,152,440 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,072 | py | #!/usr/bin/python3
from unittest import TestCase, main
from sol1 import Solution
def split(n):
l = []
for i in n:
l.append(list(i))
return l
class Test(TestCase):
sol = None
def setUp(self):
self.sol = Solution()
def test0(self):
n = ""
self.assertEqual(self.sol.lengthOfLastWord(n) ,0)
def test1(self):
n = " "
self.assertEqual(self.sol.lengthOfLastWord(n) ,0)
def test2(self):
n = " a"
self.assertEqual(self.sol.lengthOfLastWord(n) ,1)
def test3(self):
n = " ab"
self.assertEqual(self.sol.lengthOfLastWord(n) ,2)
def test4(self):
n = " aVb "
self.assertEqual(self.sol.lengthOfLastWord(n) ,3)
def test5(self):
n = " ab IUHB POQPEQJ83894e2"
self.assertEqual(self.sol.lengthOfLastWord(n) ,len("POQPEQJ83894e2"))
if __name__ == "__main__":
# logging.basicConfig( stream=sys.stderr )
# logging.getLogger( "Test.testSomething" ).setLevel( logging.DEBUG )
main()
| [
"zhrud21@gmail.com"
] | zhrud21@gmail.com |
2f3a3e5c95abddb49fbd99320b8d4b3b4c3e2feb | 3f143ae8d040f9a70fa1c452fc80ea8900d502bd | /habu/lib/vhosts.py | 34d5b23bc9b402028e7b41e6394f5b5c11e6a01f | [
"BSD-3-Clause"
] | permissive | alma4rebi/habu | 138dd9b2ebbd138d576575f6997ef8004154bb97 | 4a4d15e03234177fc42bb2d134b6ef4718ebeaaa | refs/heads/master | 2021-01-25T14:22:36.787030 | 2018-02-02T16:54:30 | 2018-02-02T16:54:30 | 123,688,009 | 1 | 0 | BSD-3-Clause | 2018-03-03T12:02:15 | 2018-03-03T12:02:15 | null | UTF-8 | Python | false | false | 1,758 | py | import ipaddress
#from habu.lib.ip2asn import ip2asn
import json
import logging
import socket
import sys
from pprint import pprint
import click
import requests
import requests_cache
from bs4 import BeautifulSoup
def get_vhosts(ip, first=1, no_cache=False):
"""Returns a list of webs hosted on IP (checks bing.com)
>>> 'www.bing.com' in vhosts(204.79.197.200)
True
"""
if not no_cache:
requests_cache.install_cache('/tmp/habu_requests_cache')
url = "http://www.bing.com/search?q=ip:{ip}&first={first}".format(ip=ip, first=first)
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
vhosts = set()
for h2 in soup.find_all('h2'):
for link in h2.find_all('a'):
href = link.get('href')
if href.startswith('http://') or href.startswith('https://'):
vhost = href.split('/')[2]
vhosts.add(vhost)
return list(vhosts)
@click.command()
@click.argument('host')
@click.option('-c', 'no_cache', is_flag=True, default=False, help='Disable cache')
@click.option('-p', 'pages', default=10, help='Pages count')
@click.option('-f', 'first', default=1, help='First result to get')
def cmd_vhosts(host, no_cache, pages, first):
try:
resolved = socket.gethostbyname(host)
except Exception:
logging.error('Invalid IP address or hostname')
sys.exit(1)
if host != resolved:
print(host, '->', resolved, file=sys.stderr)
vhosts = []
for num in range(pages):
#print("results", first+num*10)
vhosts += get_vhosts(resolved, no_cache=no_cache, first=first+num*10)
vhosts = list(set(vhosts))
pprint(vhosts)
if __name__ == '__main__':
cmd_vhosts()
| [
"fabian@portantier.com"
] | fabian@portantier.com |
e4a1172546b1d3cf225552bd164c2fd0e3c8286f | d174f8486444d937be2025098f961fb91f9ccead | /Python/Frameworks/Django/djangoTemplate/djangoTemplate/views.py | 197f93c536da210d815735221a123e61df03c52b | [] | no_license | gitchrisadams/LibraryCommonTasks2 | 1170c723b166f2e98bd6a533fb2835dced5d8b85 | 53962aa620293fb2b5118914fba46d0c7b6d6f8c | refs/heads/master | 2021-01-19T11:55:30.444346 | 2020-04-14T12:26:57 | 2020-04-14T12:26:57 | 88,003,142 | 2 | 0 | null | 2020-04-06T21:47:34 | 2017-04-12T02:57:21 | Python | UTF-8 | Python | false | false | 101 | py | from django.http import HttpResponse
def welcome(request):
return HttpResponse("Hello Django!")
| [
"chrismichaeladams@gmail.com"
] | chrismichaeladams@gmail.com |
dcf94f3467263d06f0cdc6a6fd45814921ae79cf | 1e9c9f2a9639db7cdb032aae69cb4d99aef1d3a5 | /hackerEarth/practice/dataStructures/advancedDataStructures/segmentTrees/researchOnNumbers.py | cd843193b38d663316dbb8d7bec57cc27e97e182 | [
"MIT"
] | permissive | sagarnikam123/learnNPractice | f0da3f8acf653e56c591353ab342765a6831698c | 1b3b0cb2cff2f478006626a4c37a99102acbb628 | refs/heads/master | 2023-02-04T11:21:18.211654 | 2023-01-24T14:47:52 | 2023-01-24T14:47:52 | 61,184,927 | 2 | 1 | MIT | 2022-03-06T11:07:18 | 2016-06-15T06:57:19 | Python | UTF-8 | Python | false | false | 2,349 | py | # Research on Numbers
#######################################################################################################################
#
# Bob is studying in a research institute. He is currently researching on integer sequences. He has already done
# some research on famous fibonacci sequence. Now he is trying to investigate patterns
# in a general recursive sequence (Ai)
# Sequence (Ai) is
# Ai = Bi (for i <= k)
# Ai = C1 * Ai-1 + C2 * Ai-2 +.......+ Ck*Ai-k (for i > k)
#
# But while calculating the sequence he realizes that values are growing very fast. So to keep the values small
# he calculates values modulo 109+7 (1000000007) . So that each term of sequence will be less than 109+7.
# While he is busy with his work, his girlfriend is disturbing him a lot. He wants to make her busy with some task.
# He gives her the task of sorting all the terms from Al to Ar of his sequence. She is very quick so he gives
# her same task Q times (of course with different l and r). Since sorting is very boring task so she asks you
# to complete the task.
# You will be given two numbers l and r and you are expected to output all the terms from Al to Ar in non
# decreasing order. But to avoid such a large output, if there are more than 100 terms
# in the output print only first 100.
#
# Input :
# First line contains T, the number of test cases. First line of each test case contains two space separated
# integers Q and k. Next line contains array B of length k. 3rd line contains array C of length k.
# Each of next Q lines contains two space separated integers l and r.
#
# Output :
# For each test case output Q lines. Each line contains terms from Al to Ar in non decreasing order.
# If more than 100 terms are there to output,print only first 100
#
# Constraints :
# 1 <= T <= 3
# 1 <= Q <= 100
# 1 <= k <= 5
# 1 <= Bj,Cj <= 50
# 1 <= l,r <= 10^6
# l <= r
#
# SAMPLE INPUT
# 2
# 4 3
# 1 2 3
# 2 1 1
# 1 5
# 6 8
# 8 9
# 6 9
# 3 4
# 4 5 7 9
# 2 2 1 3
# 2 7
# 10 12
# 100 101
#
# SAMPLE OUTPUT
# 1 2 3 9 23
# 58 148 377
# 377 960
# 58 148 377 960
# 5 7 9 49 138 404
# 9964 29126 85073
# 483689722 905484679
#
#######################################################################################################################
| [
"sagarnikam123@gmail.com"
] | sagarnikam123@gmail.com |
754228404a4867783ce2c258b778937f7d12303a | 9ad076be27c054b5dba0d324bd9f15837f7df1ce | /apollo_agent/Lib/apscheduler/triggers/cron/expressions.py | f6b6f4da64b11450d35feb14238c1215b71b84d8 | [] | no_license | ganji-apollo/ControlTower | 2ac2decb0f620317a6bd72abc42f0b8de77aae43 | 0bf7e95bca36a58db0015f3a5393a3442d73b33c | refs/heads/master | 2021-01-19T09:44:36.362336 | 2013-09-02T07:10:23 | 2013-09-02T07:10:23 | 12,320,615 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,208 | py | """
This module contains the expressions applicable for CronTrigger's fields.
"""
from calendar import monthrange
import re
from apscheduler.util import asint
__all__ = ('AllExpression', 'RangeExpression', 'WeekdayRangeExpression',
'WeekdayPositionExpression', 'LastDayOfMonthExpression')
WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']
class AllExpression(object):
value_re = re.compile(r'\*(?:/(?P<step>\d+))?$')
def __init__(self, step=None):
self.step = asint(step)
if self.step == 0:
raise ValueError('Increment must be higher than 0')
def get_next_value(self, date, field):
start = field.get_value(date)
minval = field.get_min(date)
maxval = field.get_max(date)
start = max(start, minval)
if not self.step:
next = start
else:
distance_to_next = (self.step - (start - minval)) % self.step
next = start + distance_to_next
if next <= maxval:
return next
def __str__(self):
if self.step:
return '*/%d' % self.step
return '*'
def __repr__(self):
return "%s(%s)" % (self.__class__.__name__, self.step)
class RangeExpression(AllExpression):
value_re = re.compile(
r'(?P<first>\d+)(?:-(?P<last>\d+))?(?:/(?P<step>\d+))?$')
def __init__(self, first, last=None, step=None):
AllExpression.__init__(self, step)
first = asint(first)
last = asint(last)
if last is None and step is None:
last = first
if last is not None and first > last:
raise ValueError('The minimum value in a range must not be '
'higher than the maximum')
self.first = first
self.last = last
def get_next_value(self, date, field):
start = field.get_value(date)
minval = field.get_min(date)
maxval = field.get_max(date)
# Apply range limits
minval = max(minval, self.first)
if self.last is not None:
maxval = min(maxval, self.last)
start = max(start, minval)
if not self.step:
next = start
else:
distance_to_next = (self.step - (start - minval)) % self.step
next = start + distance_to_next
if next <= maxval:
return next
def __str__(self):
if self.last != self.first and self.last is not None:
range = '%d-%d' % (self.first, self.last)
else:
range = str(self.first)
if self.step:
return '%s/%d' % (range, self.step)
return range
def __repr__(self):
args = [str(self.first)]
if self.last != self.first and self.last is not None or self.step:
args.append(str(self.last))
if self.step:
args.append(str(self.step))
return "%s(%s)" % (self.__class__.__name__, ', '.join(args))
class WeekdayRangeExpression(RangeExpression):
value_re = re.compile(r'(?P<first>[a-z]+)(?:-(?P<last>[a-z]+))?',
re.IGNORECASE)
def __init__(self, first, last=None):
try:
first_num = WEEKDAYS.index(first.lower())
except ValueError:
raise ValueError('Invalid weekday name "%s"' % first)
if last:
try:
last_num = WEEKDAYS.index(last.lower())
except ValueError:
raise ValueError('Invalid weekday name "%s"' % last)
else:
last_num = None
RangeExpression.__init__(self, first_num, last_num)
def __str__(self):
if self.last != self.first and self.last is not None:
return '%s-%s' % (WEEKDAYS[self.first], WEEKDAYS[self.last])
return WEEKDAYS[self.first]
def __repr__(self):
args = ["'%s'" % WEEKDAYS[self.first]]
if self.last != self.first and self.last is not None:
args.append("'%s'" % WEEKDAYS[self.last])
return "%s(%s)" % (self.__class__.__name__, ', '.join(args))
class WeekdayPositionExpression(AllExpression):
options = ['1st', '2nd', '3rd', '4th', '5th', 'last']
value_re = re.compile(r'(?P<option_name>%s) +(?P<weekday_name>(?:\d+|\w+))'
% '|'.join(options), re.IGNORECASE)
def __init__(self, option_name, weekday_name):
try:
self.option_num = self.options.index(option_name.lower())
except ValueError:
raise ValueError('Invalid weekday position "%s"' % option_name)
try:
self.weekday = WEEKDAYS.index(weekday_name.lower())
except ValueError:
raise ValueError('Invalid weekday name "%s"' % weekday_name)
def get_next_value(self, date, field):
# Figure out the weekday of the month's first day and the number
# of days in that month
first_day_wday, last_day = monthrange(date.year, date.month)
# Calculate which day of the month is the first of the target weekdays
first_hit_day = self.weekday - first_day_wday + 1
if first_hit_day <= 0:
first_hit_day += 7
# Calculate what day of the month the target weekday would be
if self.option_num < 5:
target_day = first_hit_day + self.option_num * 7
else:
target_day = first_hit_day + ((last_day - first_hit_day) / 7) * 7
if target_day <= last_day and target_day >= date.day:
return target_day
def __str__(self):
return '%s %s' % (self.options[self.option_num],
WEEKDAYS[self.weekday])
def __repr__(self):
return "%s('%s', '%s')" % (self.__class__.__name__,
self.options[self.option_num],
WEEKDAYS[self.weekday])
class LastDayOfMonthExpression(AllExpression):
value_re = re.compile(r'last', re.IGNORECASE)
def __init__(self):
pass
def get_next_value(self, date, field):
return monthrange(date.year, date.month)[1]
def __str__(self):
return 'last'
def __repr__(self):
return "%s()" % self.__class__.__name__
| [
"mangweiqi@ganji.com"
] | mangweiqi@ganji.com |
f7bebef6d49e2dc5bd78ac72ec84d248b8d73dec | b473cd3def86bb2a79a36d7b9639e6e36507266a | /python/image_utilities/HSCcolorcutouts.py | dfced32e1393482da231de30068d8b12bed195a1 | [] | no_license | eduardrusu/zMstarPDF | 4393a9085e0c72a3d91c154b975af94ee9c69214 | 0ebc596666505a624cd947ad00c5b971f89b9bcd | refs/heads/master | 2020-12-24T13:21:25.488825 | 2020-10-27T06:39:00 | 2020-10-27T06:39:00 | 31,794,803 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,805 | py | # Given a folder with .fits RGB images and the input list for DAS Cutout, it produces a color-combined RGB using Humvi (https://github.com/drphilmarshall/HumVI/blob/master/examples/Examples.ipynb )
# run as python HSCcolorcutouts.py /Volumes/LaCieSubaru/Gaia/cutout0/ /Volumes/LaCieSubaru/Gaia/DelchambreHSC5arcsecunique_cutout0.cat
#from astropy.io import fits
import numpy as np
import os
import sys
import glob
import humvi
from IPython.display import Image
from astropy.io import fits
imgpath = str(sys.argv[1])
cat = str(sys.argv[2])
os.chdir(imgpath)
files = glob.glob('*.fits')
'''
The input DAS Cutout catalogue is designed to ask for grizy for each object, in case some of the objects are missing some of the gri frames. The first part of the name of the output images produced by DAS Cutout is the line number in the input list.
'''
list = np.zeros(len(files))
for i in range(len(files)):
list[i] = int(files[i].split('-')[0])
list=np.sort(list)
imcat = np.genfromtxt(cat,usecols=[1,2,3,4],unpack=True,dtype='string')
imgnr = len(imcat[0]) + 1 # image ID starts at 2
pos_g = 2
pos_r = 3
pos_i = 4
pos_z = 5
pos_y = 6
while pos_y <= imgnr:
print pos_y,'/',imgnr
pos = [pos_g,pos_r,pos_i,pos_z,pos_y]
#print pos
inside = np.in1d(pos, list)
color = ''
colorcount = 0
if inside[0] == True:
color += 'g'
if colorcount < 3: colorcount += 1
if inside[1] == True:
color += 'r'
if colorcount < 3: colorcount += 1
if inside[2] == True:
color += 'i'
if colorcount < 3: colorcount += 1
if inside[3] == True:
if colorcount < 3:
color += 'z'
colorcount += 1
if inside[4] == True:
if colorcount < 3:
color += 'y'
colorcount += 1
out = imgpath + imcat[1][pos_g - 2].replace(':','') + imcat[2][pos_g - 2].replace(':','') + '_' + imcat[3][pos_g - 2] + '_' + color + '.png'
if colorcount == 1:
bfile = ''
gfile = ''
rfile = ''
here = False
i = 0
while here == False:
if int(files[i].split('-')[0]) in pos:
bfile, gfile, rfile, outfile = files[i], files[i], files[i], out
scales, offset, Q, alpha, masklevel, saturation = (1.0,1.0,1.0), 0.5, 1.0, 0.1, -1.0, 'white'
humvi.compose(rfile, gfile, bfile, scales=scales, Q=Q, alpha=alpha, masklevel=masklevel, saturation=saturation, offset=offset, backsub=False, vb=True, outfile=outfile)
Image(filename=outfile,width=400)
here = True
i += 1
if colorcount == 2:
bfile = ''
gfile = ''
rfile = ''
here1 = False
here2 = False
i = 0
while here1 == False or here2 == False:
if int(files[i].split('-')[0]) in pos:
if here1 == False:
bfile = files[i]
here1 = True
else:
here2 = True
rfile = files[i]
i += 1
im1 = fits.open(bfile)
im2 = fits.open(rfile)
data = im1[1].data
data = (im1[1].data + im2[1].data)/2.0
im1.writeto('tmp.fits',clobber=True)
gfile, outfile = 'tmp.fits', out
scales, offset, Q, alpha, masklevel, saturation = (1.0,1.0,1.0), 0.0, 2.0, 0.1, -1.0, 'white'
humvi.compose(rfile, gfile, bfile, scales=scales, Q=Q, alpha=alpha, masklevel=masklevel, saturation=saturation, offset=offset, backsub=False, vb=True, outfile=outfile)
Image(filename=outfile,width=400)
if colorcount == 3:
bfile = ''
gfile = ''
rfile = ''
here1 = False
here2 = False
here3 = False
i = 0
while here1 == False or here2 == False or here3 == False:
if int(files[i].split('-')[0]) in pos:
if here1 == False:
bfile = files[i]
here1 = True
else:
if here1 == True and here2 == False:
here2 = True
gfile = files[i]
else:
if here1 == True and here2 == True:
here3 = True
rfile = files[i]
i += 1
outfile = out
scales, offset, Q, alpha, masklevel, saturation = (1.0,1.0,1.0), 0.0, 2.0, 0.1, -1.0, 'white'
humvi.compose(rfile, gfile, bfile, scales=scales, Q=Q, alpha=alpha, masklevel=masklevel, saturation=saturation, offset=offset, backsub=False, vb=True, outfile=outfile)
Image(filename=outfile,width=400)
pos_g += 5
pos_r += 5
pos_i += 5
pos_z += 5
pos_y += 5
print colorcount, out
os.system("rm -f tmp.fits")
| [
"cerusu@ucdavis.edu"
] | cerusu@ucdavis.edu |
7d2526935703ed532664be1345c34ffb8c84a299 | cb44a41b72fe6e2320f87b4535d650014b7642f5 | /.PyCharm2018.1/system/python_stubs/1921134460/_codecs_cn.py | 5cd411eb497b6705d7bf2ad244f7f7f97d83fc11 | [] | no_license | tommy1008/FYP-1 | 07a9dd2cf1bcab5d9ee3bfc2497052bb94eac729 | 0ec0803dddd7549c97813de522adcc8696acdebb | refs/heads/master | 2020-04-08T00:52:10.056590 | 2018-11-23T19:05:48 | 2018-11-23T19:05:48 | 158,871,204 | 0 | 0 | null | 2018-11-23T19:32:13 | 2018-11-23T19:32:12 | null | UTF-8 | Python | false | false | 552 | py | # encoding: utf-8
# module _codecs_cn
# from /usr/lib/python3.6/lib-dynload/_codecs_cn.cpython-36m-x86_64-linux-gnu.so
# by generator 1.145
# no doc
# no imports
# functions
def getcodec(*args, **kwargs): # real signature unknown
pass
# no classes
# variables with complex values
__loader__ = None # (!) real value is ''
__map_gb18030ext = None # (!) real value is ''
__map_gb2312 = None # (!) real value is ''
__map_gbcommon = None # (!) real value is ''
__map_gbkext = None # (!) real value is ''
__spec__ = None # (!) real value is ''
| [
"wongchiho74@gmail.com"
] | wongchiho74@gmail.com |
e15fb2885acc270033d88bc4a0c9365dfc7cbefc | 2248999b704f597983df836ed1f240989d6b4b70 | /torch_implementation/bw_ro_rigid_grid_search.py | ad715bc87a4a394987a1d19496112aeec6d5eea4 | [] | no_license | sgtrouge/ROCNN | 03b2a70d998fb496d13ebadbb794bfc6848de437 | 8cd976bd16b5812b3a92dd87dbe8f3376854b5bd | refs/heads/master | 2021-01-18T08:58:32.494165 | 2015-10-17T17:09:18 | 2015-10-17T17:09:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,814 | py | import os
# this version is for grid search in rorigid, so that unneccessary search are ommited
modelName = "lenetF"
pbs_file = '''
#!/bin/bash
#PBS -N %s
#PBS -M jiaxuan@umich.edu
#PBS -m abe
#PBS -V
#PBS -j oe
#PBS -l nodes=5:xe
#PBS -l mem=20g
#PBS -l walltime=10:00:00
#### End PBS preamble
# Put your job commands after this line
cd ''' + os.path.dirname(os.path.realpath(__file__)) + '''
th trainOnMnistRot.lua %s -model ''' + modelName + '''
echo "process complete"
'''
def torchModel(modelName=modelName,newLoss=False):
saveFN = '/u/sciteam/wang12/scratch/torch_logs/'+modelName+'/log%d'
command = "--val --full --save %s -r %f --coefL2 %f -b %d -m %f -t 5 -lrd %f"
if newLoss:
command = command + ' --rpLoss "variance/sum(w^2)"'
lrs = [1e-1,1e-2,1e-3,1e-4];
batchSizes = [400]
wds = [5e-1,5e-2,5e-3,0];
lrds = [5e-5,5e-4,5e-3,5e-2]
mus = [0,0.5,0.9];
# archetectural changes: manually set
# filterSizes = [5,10,15,20,25];
# nFilters = [20,50,80];
# poolSizes = [2,3,4];
index = 1
for lr in lrs:
for bs in batchSizes:
for wd in wds:
for mu in mus:
for lrd in lrds:
name = '%s%d' % (modelName,index)
with open(name+'.pbs', 'w') as f:
f.write(pbs_file % (name,command%(saveFN%index,lr,wd,bs,mu,lrd)))
index = index + 1
def DSNSetting(modelName="LearningCurve",newLoss=False):
# for learning curve
saveFN = '/u/sciteam/wang12/scratch/torch_logs/'+modelName+'/log%d'
command = '--val --save %s -r %f --coefL2 %f --rp %f -b %d -t 5 -lrd %f --trsize %d --tesize %d'
if newLoss:
command = command + ' --rpLoss "variance/sum(w^2)"'
index = 1
notches = [100,200,400,800,2500,4000,7000]
lr = 0.01; wd = 0.005; rp = 0; bs = 100; lrd = 5e-5; # based on the best model setting
for n in notches:
name = '%s%d' % (modelName,n)
with open(name+'.pbs', 'w') as f:
f.write(pbs_file % (name,command%(saveFN%index,lr,wd,rp,bs,lrd,n,2000)))
index = index + 1
def genOld():
path = 'pbsFiles/old_loss/'
owd = os.getcwd()
os.system('mkdir -p ' + path)
os.chdir(path)
os.system('echo generate pbs files in: ; pwd')
# produce files
torchModel()
DSNSetting(modelName="LC")
# change back path
os.chdir(owd)
def genNew():
path = 'pbsFiles/new_loss/'
owd = os.getcwd()
os.system('mkdir -p ' + path)
os.chdir(path)
os.system('echo generate pbs files in: ; pwd')
# produce files
torchModel(modelName=modelName,newLoss=True)
DSNSetting(modelName="LC",newLoss=True)
# change back path
os.chdir(owd)
if __name__ == '__main__':
genOld()
genNew()
| [
"jiaxuan@v2.eecs.umich.edu"
] | jiaxuan@v2.eecs.umich.edu |
cbc152ff2c377ce8b1c5fb367828aa0aacb3c16e | ccd1d4e750a9a32f6e7f07e29429c8070ff8cb4e | /SQLiteClassGenerator.py | 51febac5af40c935c3a458df37c1feffbc1c1268 | [
"MIT"
] | permissive | zeyu2001/SQLiteClassGenerator | 0a6d122004ae441495ae100c04041dd3630b2190 | 8db3f2af7a62de9b55fad46d4434e3942f4c7e45 | refs/heads/master | 2020-04-05T08:38:50.185531 | 2019-01-18T16:39:02 | 2019-01-18T16:39:02 | 156,722,948 | 2 | 0 | null | 2019-01-18T16:39:03 | 2018-11-08T14:55:55 | Python | UTF-8 | Python | false | false | 11,332 | py | class Attribute:
def __init__(self, attr_name, attr_type, constraint=None, primary_key=False, foreign_key=False):
self._attr_name = attr_name
self._attr_type = attr_type
self._constraint = constraint
self._primary_key = primary_key
self._foreign_key = foreign_key
'''
__str__(): to return a string containing the attr_name, attr_type and contraint separated by a blank space
'''
def __str__(self):
return '{} {} {}'.format(self._attr_name, self._attr_type, self._constraint)
'''
get_self_str(): [helper function] to return a string:
# if attr_type is not an integer or float: return "'{self._attribute_name}'"
# if attr_type is an integer or float: return "{self._attribute_name}"
'''
def get_attr_name(self):
return self._attr_name
def get_self_str(self):
if self._attr_type == 'INTEGER' or self._attr_type == 'FLOAT':
return '{' + 'self._{}'.format(self._attr_name) + '}'
else:
return "\\'{" + 'self._{}'.format(self._attr_name) + "}\\'"
'''
get_equal_str(): [helper function] to return a string:
# if attr_type is not an integer or float: return "attr_name = '{self._attribute_name}'"
# if attr_type is an integer or float: return "attr_name = {self._attribute_name}"
'''
def get_equal_str(self):
return '{} = {}'.format(self._attr_name, self.get_self_str())
# Number = Attribute('Number', 'FLOAT', 'NOT NULL')
# print(Number)
# print(Attribute('Number', 'FLOAT', 'NOT NULL').get_self_str())
# print(Attribute('Text', 'TEXT', 'NOT NULL').get_self_str())
# print(Attribute('Number', 'FLOAT', 'NOT NULL').get_equal_str())
# print(Attribute('Text', 'TEXT', 'NOT NULL').get_equal_str())
class SQLiteClass:
def __init__(self, class_name, attr_list):
self._class_name = class_name
self._attr_list = attr_list
def get_class_name(self):
return self._class_name
def get_attr_list(self):
return self._attr_list
'''
generate_tuple_string(attr_list, operation): [helper function] to return a string:
# attr_list is a list of Attribute objects
# there are 3 basic kinds of operations: attr_name, self_attr_name, equal_statement
# If operation == "attr_name": the function should return a string in the format of "attr_name1, attr_name2, ..."
# If operation == "self_str": the function should return a string in the format of "{self._attr_name1}, '{self._attr_name2}', ..."
# If operation == "equal_str": the function should return a string in the format of "attr_name1 = {self._attr_name1}, attr_name2 = '{self._attr_name2}', ..."
'''
@staticmethod
def generate_tuple_string(attr_list, operation):
if operation == 'attr_name':
result = ''
for attr in attr_list:
result += '{}, '.format(attr.get_attr_name())
return result[:-2]
if operation == 'self_str':
result = ''
for attr in attr_list:
result += '{}, '.format(attr.get_self_str())
return result[:-2]
if operation == 'equal_str':
result = ''
for attr in attr_list:
result += '{}, '.format(attr.get_equal_str())
return result[:-2]
'''
generate_line(num_of_tabs, content): [helper function] to return a string containing the following 3 parts:
[begin with a string of the num_of_tabs times (4 white spaces)], [content in the middle], [end with a "\n"]
'''
@staticmethod
def generate_line(number_of_tabs, content):
return number_of_tabs * '{:^4}'.format(' ') + content + '\n'
'''
generate_sql_line(content): [helper function] to return a string containing the following 3 parts:
[begin with "result += \'"], [content in the middle], [end with "\\n\""]
'''
@staticmethod
def generate_sql_line(content):
return 'result += \'' + content + '\\n\''
'''
The Generated SQLite class should contain the following, you may refer to the sample in SQLiteOOP.py:
a. initializer, mutator, accessor and dummy __str__() functions
b. SQLite functions such as create_table(), create_new_record(), update_record() and delete_record()
'''
def __str__(self):
define = 'class {}({}):\n'.format(self.get_class_name(), 'object')
result = ''
# INITIALIZER
init = '{:>4}'.format(' ') + 'def __init__(self'
for attr in self.get_attr_list():
init += ', {}'.format(str(attr.get_attr_name()))
init += '):\n'
for attr in self.get_attr_list():
init += self.generate_line(2, 'self._{a} = {a}'.format(a=attr.get_attr_name()))
init += '\n'
result += define + init
# MUTATOR FUNCTIONS
mutators = ''
for attr in self.get_attr_list():
mutators += self.generate_line(1, 'def set_{a}(self, new_{a}):'.format(a=attr.get_attr_name()))
mutators += self.generate_line(2, 'self._{a} = {b}'.format(a=attr.get_attr_name(),
b='new_{}'.format(attr.get_attr_name())))
mutators += '\n'
result += mutators
# ACCESSOR FUNCTIONS
accessors = ''
for attr in self.get_attr_list():
accessors += '{:>4}'.format(' ') + 'def get_{a}(self, new_{a}):\n'.format(a=attr.get_attr_name())
accessors += '{:>8}'.format(' ') + 'return {}'.format(attr.get_attr_name()) + '\n'
accessors += '\n'
result += accessors
result +='\n'
# DUMMY STRING FUNCTION
result += self.generate_line(1, 'def __str__(self):')
result += self.generate_line(2, 'result = \'\'')
result += '\n'
result += self.generate_line(2, 'return result')
result += '\n'
# SQLITE - CREATE TABLE
result += self.generate_line(1, '@staticmethod')
result += self.generate_line(1, 'def create_table():')
result += self.generate_line(2, 'result = \'\'')
result += self.generate_line(2, self.generate_sql_line('CREATE TABLE {}'.format(self.get_class_name())))
primary_key = []
foreign_key = []
for attr in self.get_attr_list():
result += self.generate_line(2, self.generate_sql_line(str(attr)))
if attr._primary_key:
primary_key += [attr]
if attr._foreign_key:
foreign_key += [attr]
result += self.generate_line(
2, self.generate_sql_line('PRIMARY KEY ({})'.format(self.generate_tuple_string(primary_key, 'attr_name'))))
for attr in foreign_key:
result += self.generate_line(
2, self.generate_sql_line('FOREIGN KEY ({}) REFERENCES {}'.format( \
attr.get_attr_name(), attr._foreign_key)))
result += self.generate_line(2, 'return result')
result += '\n'
# SQLITE - CREATE NEW RECORD
result += self.generate_line(1, 'def create_new_record(self):')
result += self.generate_line(2, 'result = \'\'')
result += self.generate_line(2, self.generate_sql_line('INSERT INTO {}'.format(self.get_class_name())))
result += self.generate_line(2, self.generate_sql_line('({})'.format(
self.generate_tuple_string(self.get_attr_list(), 'attr_name'))))
result += self.generate_line(2, self.generate_sql_line('VALUES'))
result += self.generate_line(2, self.generate_sql_line('({})'.format(
self.generate_tuple_string(self.get_attr_list(), 'self_str'))))[:-1] + '.format(self=self)' + '\n'
result += self.generate_line(2, 'return result')
result += '\n'
# SQLITE - UPDATE RECORD BASED ON PRIMARY KEY
result += self.generate_line(1, 'def update_record(self):')
result += self.generate_line(2, 'result = \'\'')
result += self.generate_line(2, self.generate_sql_line('UPDATE {} SET'.format(self.get_class_name())))
result += self.generate_line(2, self.generate_sql_line('({}).format(self=self)'.format(
self.generate_tuple_string(self.get_attr_list(), 'equal_str'))))
result += self.generate_line(2, self.generate_sql_line('WHERE'))
result += self.generate_line(2, self.generate_sql_line('({})'.format(
self.generate_tuple_string(primary_key, 'equal_str'))))[:-1] + '.format(self=self)' + '\n'
result += self.generate_line(2, 'return result')
result += '\n'
return result
'''
SQLiteClass1 = SQLiteClass('VenueBooking', [Attribute('VenueName', 'TEXT', 'NOT NULL', True),
Attribute('VenueAddress', 'TEXT', 'NOT NULL'),
Attribute('Postal', 'INTEGER',
'NOT NULL CHECK (Postal > 99999 AND Postal < 1000000)'),
Attribute('BookingID', 'TEXT', 'NOT NULL', True, 'Booking (BookingID)')])
# print(SQLiteClass.generate_tuple_string(SQLiteClass._attr_list, 'attr_name'))
# print(SQLiteClass.generate_tuple_string(SQLiteClass._attr_list, 'self_str'))
# print(SQLiteClass.generate_tuple_string(SQLiteClass._attr_list, 'equal_str'))
print(SQLiteClass1)
'''
class SQLiteClassGenerator():
def __init__(self):
self._class_list = []
def read_file(self, file_name):
SQLiteClassList = []
'''SQlite Class Name;Class Attribute;Type;Constraint;Primary Key;Foreign Key'''
with open(file_name, 'r') as f:
line = f.readline()[:-1]
line = f.readline()[:-1]
class_name = None
info_list = []
attr_list = []
while line:
if line[0] != ';':
if class_name:
SQLiteClassList.append(SQLiteClass(class_name, attr_list))
attr_list = []
info_list = []
info_list = line.split(';')
class_name, attr_name, attr_type, constraint, primary_key, foreign_key = \
info_list[0], info_list[1], info_list[2], info_list[3], info_list[4], info_list[5]
attr_list.append(Attribute(attr_name, attr_type, constraint, primary_key, foreign_key))
else:
info_list = line.split(';')
attr_name, attr_type, constraint, primary_key, foreign_key = \
info_list[1], info_list[2], info_list[3], info_list[4], info_list[5]
attr_list.append(Attribute(attr_name, attr_type, constraint, primary_key, foreign_key))
line = f.readline()[:-1]
SQLiteClassList.append(SQLiteClass(class_name, attr_list))
f.close()
self._class_list = SQLiteClassList
return self._class_list
def generate(self):
with open('SQLiteOOP.py', 'w') as f:
result = ''
for clss in self._class_list:
result += str(clss)
f.write(result)
SQLiteClassGenerator = SQLiteClassGenerator()
SQLiteClassList = SQLiteClassGenerator.read_file('class_info.csv')
SQLiteClassGenerator.generate()
| [
"noreply@github.com"
] | zeyu2001.noreply@github.com |
61bdf96e9e66babc6af5fbb50dce07eacb4d3e7e | b804260baffde6044d0da699ebd01eefd5524897 | /tests/loss/test_loss.py | db2c74e8c2f0e1a7ffec9783b81e8edcb95589ba | [
"MIT"
] | permissive | pfnet/pynif3d | d8112e659c3158cd87f4f88ebb77c653c2a0eb7c | da3680cce7e8fc4c194f13a1528cddbad9a18ab0 | refs/heads/main | 2023-07-15T06:27:27.849842 | 2021-08-18T07:15:13 | 2021-08-18T07:15:13 | 397,141,414 | 72 | 5 | MIT | 2021-08-18T07:15:14 | 2021-08-17T06:53:45 | Python | UTF-8 | Python | false | false | 533 | py | from unittest import TestCase
import torch
from pynif3d.loss import eikonal_loss
class TestLoss(TestCase):
def test_eikonal_loss(self):
x = torch.as_tensor(
[
[0.2936261892, -1.0289776325, 0.1445489526],
[-0.2577984035, -0.7820385098, 0.3506951332],
[-0.4243153632, 0.8669579029, -0.6295363903],
]
)
loss = float(eikonal_loss(x))
expected_loss = 0.0135356029
self.assertAlmostEqual(loss, expected_loss, places=5)
| [
"mihaimorariu@gmail.com"
] | mihaimorariu@gmail.com |
9e8273af96aa7b21ecca5538c893e911279e291f | 80b19c9ad3883cbb56a9a6a04872243b60a515a5 | /cocoon_app/env/bin/wheel | d9d40e07ce3c0229fcbfa3c7c25231e113a1ea04 | [] | no_license | williampiat3/cocoon | a4c515bd8e8cef8c1a2a6221e987a0f7e1df46e3 | b2158c4a4ed5729a95ea73a89feca09464ea0963 | refs/heads/master | 2021-03-30T10:32:47.797701 | 2018-11-14T07:32:18 | 2018-11-14T07:32:18 | 120,182,572 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 260 | #!/home/will/Documents/Documents/GitHub/cocoon_app/env/bin/python2
# -*- coding: utf-8 -*-
import re
import sys
from wheel.tool import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
sys.exit(main())
| [
"william.piat3@gmail.com"
] | william.piat3@gmail.com | |
11bd6da065d09904d501ff44088ec65e4c7c2cb0 | 61aa1e8c457ceacdf24c2b1e70cade491d365166 | /ex38.py | 18cb87182fa304fed286cb682ac1b95f4ec25178 | [] | no_license | muokicaleb/lpthw | 429ddb7f9d8c129f40355646ea4bdc02fd707e9e | a0f4317fd4477d638d6056ff6c3f9e8aae993d57 | refs/heads/main | 2023-07-02T08:51:24.905912 | 2021-08-03T16:55:52 | 2021-08-03T16:55:52 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 582 | py | ten_things = "Apples Oranges Crows Telephone Light Sugar"
print("Wait there are not 10 things in that list. Let's fix that.")
stuff = ten_things.split(' ')
more_stuff = ["Day", "Night", "Song", "Frisbee", "Corn", "Banana", "Girl", "Boy"]
while len(stuff) != 10:
next_one = more_stuff.pop()
print("Adding: ", next_one)
stuff.append(next_one)
print(f"There are {len(stuff)} items now.")
print("There we go: ", stuff)
print("Let's do some things with stuff.")
print(stuff[1])
print(stuff[-1])
print(stuff.pop())
print(' '.join(stuff))
print('#'.join(stuff[3:5]))
| [
"tiffmeg.tiff@gmail.com"
] | tiffmeg.tiff@gmail.com |
2378f8d8a1233963c7c3a70c82d7be0a4a9465a1 | 6c301828547a46e9b6a3bac59f9b43215460a3be | /nativecompile.py | ae6a0695f5bf250b3c7ac7a4ea833f270582af2c | [
"Apache-2.0"
] | permissive | jimktrains/microwave | 727c97263823bd36bdb47c040c21f23ea103a3e8 | aef41f6b57e3171ca22c12422c0a05e17cc002c6 | refs/heads/master | 2021-01-21T06:24:52.003430 | 2011-03-08T12:33:51 | 2011-03-08T12:33:51 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,449 | py | #/usr/bin/python
import httplib, urllib, fileinput, sys, re
print "Reading Developement HTML"
prefix = './'
codes = open(prefix+'native.html','r').read()
compile_regex = r'START_JS(.*?)END_JS'
js = ''
for match in re.finditer(compile_regex, codes, re.DOTALL):
print "Found script compile block"
includetext = match.group(1)
for include in re.finditer(r'src=[\"\'](.*)[\"\']', includetext):
fn = include.group(1)
js += "//File: "+fn+ '\n\n\n'
js += open(prefix+fn,'r').read() + '\n\n\n'
html = codes.replace(match.group(0),'')
print "Writing concatenated JS"
open(prefix+'microwave.native.js','w').write(js)
#exit();
html = html.replace('<!--RELEASE','')
html = html.replace('RELEASE-->','')
html = html.replace('<!---->','')
print "Writing compiled HTML"
open(prefix+'native.out.html','w').write(html)
print "Querying Closure Compiler REST API for compressed JS"
params = urllib.urlencode([
('js_code', js),
('compilation_level', 'SIMPLE_OPTIMIZATIONS'),
('output_format', 'text'),
('output_info', 'compiled_code'),
])
# Always use the following value for the Content-type header.
headers = { "Content-type": "application/x-www-form-urlencoded" }
conn = httplib.HTTPConnection('closure-compiler.appspot.com')
conn.request('POST', '/compile', params, headers)
response = conn.getresponse()
data = response.read()#.replace('\n','')
print "Writing compressed JS"
open(prefix+'native.min.js','w').write(data) | [
"antimatter15@gmail.com"
] | antimatter15@gmail.com |
5487c1cb6bb38746c5c180179f3a0d29d57ec77b | 647fbcfef485397b29409d2f88885386941255bd | /conftest.py | b16fc318215681665065ad8e7d3689318ba52d4c | [] | no_license | SofyaTavrovskaya/simple_rabbitmq_testing_tool | 350eff7a167e8a248c6cf3c77b5ddf52084cba7e | d848667f186a18d06225929ed23bfc92ba8428a2 | refs/heads/master | 2022-12-11T02:00:17.312285 | 2020-01-28T13:04:06 | 2020-01-28T13:04:06 | 235,360,095 | 0 | 0 | null | 2022-12-08T03:30:57 | 2020-01-21T14:21:23 | Python | UTF-8 | Python | false | false | 1,726 | py | import pika
import pytest
import configparser
@pytest.fixture(scope="session")
def connect_to_rabbit(config_parser):
credentials = pika.PlainCredentials(config_parser["user_name"], config_parser["password"])
parameters = pika.ConnectionParameters(host=config_parser["host"], port=int(config_parser["port"]),
virtual_host=config_parser["virtual_host"], credentials=credentials)
connection = pika.BlockingConnection(parameters)
channel = connection.channel()
channel.exchange_declare(exchange='test_exchange', exchange_type='topic')
channel.queue_declare(queue='test_queue', durable=True)
channel.queue_bind(exchange='test_exchange', queue="test_queue", routing_key="direct.routing.key")
yield channel
channel.queue_unbind(queue='test_queue', exchange='test_exchange', routing_key='direct.routing.key')
channel.queue_delete(queue='test_queue', if_unused=False, if_empty=False)
channel.exchange_delete(exchange='direct_exchange', if_unused=False)
channel.close()
connection.close()
@pytest.fixture(scope="session")
def config_parser():
config = configparser.ConfigParser()
config.read('./fixtures/config.ini')
config_dict = {'user_name': config['credentials']['username'],
'password': config['credentials']['password'],
'messages': config['messages']['number_of_messages'],
'host': config['credentials']['host'],
'port': config['credentials']['port'],
'virtual_host': config['credentials']['virtual_host'],
'messages_text': config['messages']['messages_text']
}
yield config_dict
| [
"tavrovskayasofya87@gmail.com"
] | tavrovskayasofya87@gmail.com |
aa1e133119e7b23ada8aae5c4c7225bd464e97b1 | e7c89dddef16d357a90290642d8a14547333b78a | /collatz.py | 773507618146a91317ce0586c9a7e013e24cf5da | [] | no_license | chacychavez/kattis | 6fce12fd9fe178706994848e09bace526a17c800 | 5c1ed7683b6082f6cbf894ba7241c02b29b50890 | refs/heads/master | 2021-01-14T20:34:03.955158 | 2020-02-26T14:12:10 | 2020-02-26T14:12:10 | 242,750,739 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 686 | py | '''
Problem: Collatz Conjecture
'''
def first(n, visited):
while n > 1:
n = 3 * n + 1 if n % 2 == 1 else n // 2
visited.append(n)
def second(n, visited):
counter = 0
if n not in visited:
while n > 1:
counter += 1
n = 3 * n + 1 if n % 2 == 1 else n // 2
if n in visited:
return n, counter, n
return n, counter, n
while(True):
_a, _b = [int(x) for x in input().split()]
a, b = _a, _b
if(a == 0 and b == 0):
break
else:
visited = [a]
same = 0
first(a, visited)
b, counter, same = second(b, visited)
print(_a, "needs", visited.index(same), "steps,", _b, "needs", counter, "steps, they meet at", same) | [
"cyrus@insynchq.com"
] | cyrus@insynchq.com |
75f86cfb2964f955c6eb729325f89b994094d90b | 4e27edeea65ccbf56751ce8d2dc77a7133b0acd4 | /manage.py | 67c6cd2430e82991dd181c57036a89165333e071 | [] | no_license | TheFifthMan/whitehat | f1e6faf39c7e56d79ac462de4de847ebd531ecb1 | 944ff548ec18b2c306af63a53baff9940fdbec84 | refs/heads/master | 2020-04-08T18:40:27.924936 | 2018-11-29T06:37:13 | 2018-11-29T06:37:13 | 159,619,222 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 540 | py | #!/usr/bin/env python
import os
import sys
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'whitehat.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
| [
"John.Wen@ehealth.com"
] | John.Wen@ehealth.com |
2b560c0be5539d378c447bdcf446426e172d37d0 | 55522f9aeedbdbc62e95e04eff4b99334e9c7ad0 | /tests/bfdpie_test.py | a0c4d91ea0ef62b32590bd26e2ab5c879fd64a97 | [
"MIT"
] | permissive | cz172638/bfdpie | b4f8d1ca2dad8de4d11e31fedb7ef7bfac422f23 | 5d3c8522271114c4f9672f007325a6ab1916dfd7 | refs/heads/master | 2020-04-07T11:15:00.421639 | 2016-04-06T20:51:13 | 2016-04-06T20:51:13 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 14,301 | py | import unittest
from bfdpie import *
class Test(unittest.TestCase):
def test_arch_i686(self):
# 8048579: 89 e5 mov %esp,%ebp
# 804857b: 53 push %ebx
# 804857c: bb 4c 96 04 08 mov $0x804964c,%ebx
# 8048581: 52 push %edx
b = Binary()
dis = b.disassemble(
b"\x89\xe5" +
b"\x53" +
b"\xbb\x4c\x96\x04\x08" +
b"\x52"
,arch=ARCH_I686
)
self.assertTrue(str(dis[0]) == "mov ebp,esp")
self.assertTrue(str(dis[1]) == "push ebx")
self.assertTrue(str(dis[2]) == "mov ebx,0x804964c")
self.assertTrue(str(dis[3]) == "push edx")
def test_arch_x86_64(self):
# 4006aa: ba 00 04 00 00 mov $0x400,%edx
# 4006af: 48 89 c6 mov %rax,%rsi
# 4006b2: bf 00 00 00 00 mov $0x0,%edi
# 4006b7: b8 00 00 00 00 mov $0x0,%eax
b = Binary()
dis = b.disassemble(
b"\xba\x00\x04\x00\x00" +
b"\x48\x89\xc6" +
b"\xbf\x00\x00\x00\x00" +
b"\xb8\x00\x00\x00\x00",
ARCH_X86_64
)
self.assertTrue(str(dis[0]) == "mov edx,0x400")
self.assertTrue(str(dis[1]) == "mov rsi,rax")
self.assertTrue(str(dis[2]) == "mov edi,0x0")
self.assertTrue(str(dis[3]) == "mov eax,0x0")
def test_arch_armel(self):
# 84c0: e92d4800 push {fp, lr}
# 84c4: e28db004 add fp, sp, #4
# 84c8: e24dd020 sub sp, sp, #32
# 84cc: e24b3024 sub r3, fp, #36 ; 0x24
b = Binary()
dis = b.disassemble(
b"\x00\x48\x2d\xe9" +
b"\x04\xb0\x8d\xe2" +
b"\x20\xd0\x4d\xe2" +
b"\x24\x30\x4b\xe2",
ARCH_ARMEL
)
self.assertTrue(str(dis[0]) == "push {fp, lr}")
self.assertTrue(str(dis[1]) == "add fp, sp, #4")
self.assertTrue(str(dis[2]) == "sub sp, sp, #32")
self.assertTrue(str(dis[3]) == "sub r3, fp, #36 ; 0x24")
def test_arch_armel_thumb(self):
# 84ce: db00 lsls r3, r3, #3
# 84d0: 0020 movs r0, #0
# 84d2: 111c adds r1, r2, #0
# 84d4: 1a1c adds r2, r3, #0
b = Binary()
dis = b.disassemble(
b"\xdb\x00" +
b"\x00\x20" +
b"\x11\x1c" +
b"\x1a\x1c",
ARCH_ARMEL_THUMB
)
self.assertTrue(str(dis[0]) == "lsls r3, r3, #3")
self.assertTrue(str(dis[1]) == "movs r0, #0")
self.assertTrue(str(dis[2]) == "adds r1, r2, #0")
self.assertTrue(str(dis[3]) == "adds r2, r3, #0")
def test_arch_armeb(self):
# 84c0: e92d4800 push {fp, lr}
# 84c4: e28db004 add fp, sp, #4
# 84c8: e24dd020 sub sp, sp, #32
# 84cc: e24b3024 sub r3, fp, #36 ; 0x24
b = Binary()
dis = b.disassemble(
b"\xe9\x2d\x48\x00" +
b"\xe2\x8d\xb0\x04" +
b"\xe2\x4d\xd0\x20" +
b"\xe2\x4b\x30\x24",
ARCH_ARMEB
)
self.assertTrue(str(dis[0]) == "push {fp, lr}")
self.assertTrue(str(dis[1]) == "add fp, sp, #4")
self.assertTrue(str(dis[2]) == "sub sp, sp, #32")
self.assertTrue(str(dis[3]) == "sub r3, fp, #36 ; 0x24")
def test_arch_armeb_thumb(self):
# 84ce: 00db lsls r3, r3, #3
# 84d0: 2000 movs r0, #0
# 84d2: 1c11 adds r1, r2, #0
# 84d4: 1c1a adds r2, r3, #0
b = Binary()
dis = b.disassemble(
b"\x00\xdb" +
b"\x20\x00" +
b"\x1c\x11" +
b"\x1c\x1a",
ARCH_ARMEB_THUMB
)
self.assertTrue(str(dis[0]) == "lsls r3, r3, #3")
self.assertTrue(str(dis[1]) == "movs r0, #0")
self.assertTrue(str(dis[2]) == "adds r1, r2, #0")
self.assertTrue(str(dis[3]) == "adds r2, r3, #0")
def test_arch_mips(self):
# 4009d8: 8fbf001c lw ra,28(sp)
# 4009dc: 00000000 nop
# 4009e0: 03e00008 jr ra
# 4009e4: 27bd0020 addiu sp,sp,32
b = Binary()
dis = b.disassemble(
b"\x8f\xbf\x00\x1c" +
b"\x00\x00\x00\x00" +
b"\x03\xe0\x00\x08" +
b"\x27\xbd\x00\x20",
ARCH_MIPS
)
self.assertTrue(str(dis[0]) == "lw ra,28(sp)")
self.assertTrue(str(dis[1]) == "nop")
self.assertTrue(str(dis[2]) == "jr ra")
self.assertTrue(str(dis[3]) == "addiu sp,sp,32")
def test_arch_mipsel(self):
# 4009d8: 1c00bf8f lw ra,28(sp)
# 4009dc: 00000000 nop
# 4009e0: 0800e003 jr ra
# 4009e4: 2000bd27 addiu sp,sp,32
b = Binary()
dis = b.disassemble(
b"\x1c\x00\xbf\x8f" +
b"\x00\x00\x00\x00" +
b"\x08\x00\xe0\x03" +
b"\x20\x00\xbd\x27",
ARCH_MIPSEL
)
self.assertTrue(str(dis[0]) == "lw ra,28(sp)")
self.assertTrue(str(dis[1]) == "nop")
self.assertTrue(str(dis[2]) == "jr ra")
self.assertTrue(str(dis[3]) == "addiu sp,sp,32")
def test_arch_mips64(self):
# 120000918: 3c1c0002 lui gp,0x2
# 12000091c: 279c843c addiu gp,gp,-31684
# 120000920: 039fe02d daddu gp,gp,ra
# 120000924: df998068 ld t9,-32664(gp)
b = Binary()
dis = b.disassemble(
b"\x3c\x1c\x00\x02" +
b"\x27\x9c\x84\x3c" +
b"\x03\x9f\xe0\x2d" +
b"\xdf\x99\x80\x68",
ARCH_MIPS64
)
self.assertTrue(str(dis[0]) == "lui gp,0x2")
self.assertTrue(str(dis[1]) == "addiu gp,gp,-31684")
self.assertTrue(str(dis[2]) == "daddu gp,gp,ra")
self.assertTrue(str(dis[3]) == "ld t9,-32664(gp)")
def test_arch_mips64el(self):
# 120000918: 02001c3c lui gp,0x2
# 12000091c: 3c849c27 addiu gp,gp,-31684
# 120000920: 2de09f03 daddu gp,gp,ra
# 120000924: 688099df ld t9,-32664(gp)
b = Binary()
dis = b.disassemble(
b"\x02\x00\x1c\x3c" +
b"\x3c\x84\x9c\x27" +
b"\x2d\xe0\x9f\x03" +
b"\x68\x80\x99\xdf",
ARCH_MIPS64EL
)
self.assertTrue(str(dis[0]) == "lui gp,0x2")
self.assertTrue(str(dis[1]) == "addiu gp,gp,-31684")
self.assertTrue(str(dis[2]) == "daddu gp,gp,ra")
self.assertTrue(str(dis[3]) == "ld t9,-32664(gp)")
def test_arch_ppc32(self):
# 1000058c: 80 01 00 14 lwz r0,20(r1)
# 10000590: 38 21 00 10 addi r1,r1,16
# 10000594: 7c 08 03 a6 mtlr r0
# 10000598: 4e 80 00 20 blr
b = Binary()
dis = b.disassemble(
b"\x80\x01\x00\x14" +
b"\x38\x21\x00\x10" +
b"\x7c\x08\x03\xa6" +
b"\x4e\x80\x00\x20",
ARCH_PPC32
)
self.assertTrue(str(dis[0]) == "lwz r0,20(r1)")
self.assertTrue(str(dis[1]) == "addi r1,r1,16")
self.assertTrue(str(dis[2]) == "mtlr r0")
self.assertTrue(str(dis[3]) == "blr")
def test_arch_ppc64(self):
# 100007d4: 38 21 00 70 addi r1,r1,112
# 100007d8: e8 01 00 10 ld r0,16(r1)
# 100007dc: 7c 08 03 a6 mtlr r0
# 100007e0: 4e 80 00 20 blr
b = Binary()
dis = b.disassemble(
b"\x38\x21\x00\x70" +
b"\xe8\x01\x00\x10" +
b"\x7c\x08\x03\xa6" +
b"\x4e\x80\x00\x20",
ARCH_PPC64
)
self.assertTrue(str(dis[0]) == "addi r1,r1,112")
self.assertTrue(str(dis[1]) == "ld r0,16(r1)")
self.assertTrue(str(dis[2]) == "mtlr r0")
self.assertTrue(str(dis[3]) == "blr")
def test_arch_sparc(self):
# 105e4: 9d e3 bf 98 save %sp, -104, %sp
# 105ec: 01 00 00 00 nop
# 105f0: 81 c7 e0 08 ret
# 105f4: 81 e8 00 00 restore
b = Binary()
dis = b.disassemble(
b"\x9d\xe3\xbf\x98" +
b"\x01\x00\x00\x00" +
b"\x81\xc7\xe0\x08" +
b"\x81\xe8\x00\x00",
ARCH_SPARC
)
self.assertTrue(str(dis[0]) == "save %sp, -104, %sp")
self.assertTrue(str(dis[1]) == "nop")
self.assertTrue(str(dis[2]) == "ret")
self.assertTrue(str(dis[3]) == "restore")
def test_arch_sparc64(self):
# 1007a0: 9f c0 40 00 call %g1
# 1007a4: ba 07 7f f8 add %i5, -8, %i5
# 1007a8: c2 5f 40 00 ldx [ %i5 ], %g1
# 1007ac: 80 a0 7f ff cmp %g1, -1
b = Binary()
dis = b.disassemble(
b"\x9f\xc0\x40\x00" +
b"\xba\x07\x7f\xf8" +
b"\xc2\x5f\x40\x00" +
b"\x80\xa0\x7f\xff",
ARCH_SPARC64
)
self.assertTrue(str(dis[0]) == "call %g1")
self.assertTrue(str(dis[1]) == "add %i5, -8, %i5")
self.assertTrue(str(dis[2]) == "ldx [ %i5 ], %g1")
self.assertTrue(str(dis[3]) == "cmp %g1, -1")
def test_arch_sh4(self):
# 400618: 26 4f lds.l @r15+,pr
# 40061a: 0b 00 rts
# 40061c: f6 68 mov.l @r15+,r8
# 40061e: 09 00 nop
b = Binary()
dis = b.disassemble(
b"\x26\x4f" +
b"\x0b\x00" +
b"\xf6\x68" +
b"\x09\x00",
ARCH_SH4
)
self.assertTrue(str(dis[0]) == "lds.l @r15+,pr")
self.assertTrue(str(dis[1]) == "rts")
self.assertTrue(str(dis[2]) == "mov.l @r15+,r8")
self.assertTrue(str(dis[3]) == "nop")
def test_arch_sh4eb(self):
# 400618: 4f 26 lds.l @r15+,pr
# 40061a: 00 0b rts
# 40061c: 68 f6 mov.l @r15+,r8
# 40061e: 00 09 nop
b = Binary()
dis = b.disassemble(
b"\x4f\x26" +
b"\x00\x0b" +
b"\x68\xf6" +
b"\x00\x09",
ARCH_SH4EB
)
self.assertTrue(str(dis[0]) == "lds.l @r15+,pr")
self.assertTrue(str(dis[1]) == "rts")
self.assertTrue(str(dis[2]) == "mov.l @r15+,r8")
self.assertTrue(str(dis[3]) == "nop")
def test_arch_aarch64(self):
# 400624: a9bf7bfd stp x29, x30, [sp,#-16]!
# 400628: 910003fd mov x29, sp
# 40062c: a8c17bfd ldp x29, x30, [sp],#16
# 400630: d65f03c0 ret
b = Binary()
dis = b.disassemble(
b"\xfd\x7b\xbf\xa9" +
b"\xfd\x03\x00\x91" +
b"\xfd\x7b\xc1\xa8" +
b"\xc0\x03\x5f\xd6",
ARCH_AARCH64
)
self.assertTrue(str(dis[0]) == "stp x29, x30, [sp,#-16]!")
self.assertTrue(str(dis[1]) == "mov x29, sp")
self.assertTrue(str(dis[2]) == "ldp x29, x30, [sp],#16")
self.assertTrue(str(dis[3]) == "ret")
def test_arch_alpha(self):
# 1200007e8: 3e 15 c2 43 subq sp,0x10,sp
# 1200007ec: 00 00 5e b7 stq ra,0(sp)
# 1200007f0: 08 00 be b7 stq gp,8(sp)
# 1200007f4: 00 00 fe 2f unop
b = Binary()
dis = b.disassemble(
b"\x3e\x15\xc2\x43" +
b"\x00\x00\x5e\xb7" +
b"\x08\x00\xbe\xb7" +
b"\x00\x00\xfe\x2f",
ARCH_ALPHA
)
self.assertTrue(str(dis[0]) == "subq sp,0x10,sp")
self.assertTrue(str(dis[1]) == "stq ra,0(sp)")
self.assertTrue(str(dis[2]) == "stq gp,8(sp)")
self.assertTrue(str(dis[3]) == "unop")
def test_arch_crisv32(self):
# 80610: 6e0e move.d [$sp+],$r0
# 80612: 31b6 move $r1,$srp
# 80614: 6e1e move.d [$sp+],$r1
# 80616: f0b9 ret
b = Binary()
dis = b.disassemble(
b"\x6e\x0e" +
b"\x31\xb6" +
b"\x6e\x1e" +
b"\xf0\xb9",
ARCH_CRISV32
)
self.assertTrue(str(dis[0]) == "move.d [$sp+],$r0")
self.assertTrue(str(dis[1]) == "move $r1,$srp")
self.assertTrue(str(dis[2]) == "move.d [$sp+],$r1")
self.assertTrue(str(dis[3]) == "ret")
def test_arch_s390x(self):
# 80000724: e3 40 f1 10 00 04 lg %r4,272(%r15)
# 8000072a: eb cf f1 00 00 04 lmg %r12,%r15,256(%r15)
# 80000730: 07 f4 br %r4
# 80000732: 07 07 nopr %r7
b = Binary()
dis = b.disassemble(
b"\xe3\x40\xf1\x10\x00\x04" +
b"\xeb\xcf\xf1\x00\x00\x04" +
b"\x07\xf4" +
b"\x07\x07",
ARCH_S390X
)
self.assertTrue(str(dis[0]) == "lg %r4,272(%r15)")
self.assertTrue(str(dis[1]) == "lmg %r12,%r15,256(%r15)")
self.assertTrue(str(dis[2]) == "br %r4")
self.assertTrue(str(dis[3]) == "nopr %r7")
def test_arch_microblaze(self):
# 10000628: 3021ffe0 addik r1, r1, -32
# 1000062c: fa81001c swi r20, r1, 28
# 10000630: f9e10000 swi r15, r1, 0
# 10000634: 96808000 mfs r20, rpc
b = Binary()
dis = b.disassemble(
b"\x30\x21\xff\xe0" +
b"\xfa\x81\x00\x1c" +
b"\xf9\xe1\x00\x00" +
b"\x96\x80\x80\x00",
ARCH_MICROBLAZE
)
self.assertTrue(str(dis[0]) == "addik r1, r1, -32")
self.assertTrue(str(dis[1]) == "swi r20, r1, 28")
self.assertTrue(str(dis[2]) == "swi r15, r1, 0")
self.assertTrue(str(dis[3]) == "mfs r20, rpc")
def test_arch_microblazeel(self):
# 10000628: e03021ff addik r1, r1, -32
# 1000062c: 1cfa8100 swi r20, r1, 28
# 10000630: 00f9e100 swi r15, r1, 0
# 10000634: 00968080 mfs r20, rpc
b = Binary()
dis = b.disassemble(
b"\xe0\xff\x21\x30" +
b"\x1c\x00\x81\xfa" +
b"\x00\x00\xe1\xf9" +
b"\x00\x80\x80\x96",
ARCH_MICROBLAZEEL
)
self.assertTrue(str(dis[0]) == "addik r1, r1, -32")
self.assertTrue(str(dis[1]) == "swi r20, r1, 28")
self.assertTrue(str(dis[2]) == "swi r15, r1, 0")
self.assertTrue(str(dis[3]) == "mfs r20, rpc")
def test_loading(self):
b = Binary()
self.assertTrue(b.file_type == "elf")
self.assertTrue(str(b.arch) == "Arch<name:X86_64, bits:64, little_endian:1>")
if __name__ == "__main__":
unittest.main()
| [
"luka.malisha@gmail.com"
] | luka.malisha@gmail.com |
dd8d59ea3be4096021a871f18982bf59f13d66c6 | ec4a0c01214afeee1c69d9b3fb564ff6fd279d90 | /django_termosite/termosite/from_rasp/data_analyse.py | 61a242b378d57ba70d11e9db8042b182a23ee1a1 | [] | no_license | alexcnr/termodj | a24bcd80cf658ea50d19aa02dd407e32379caad9 | 74769051df241a784974953966c296836d1c3c03 | refs/heads/master | 2023-08-11T02:30:06.207893 | 2021-10-04T14:52:55 | 2021-10-04T14:52:55 | 412,997,772 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 38 | py | from serial_rasb_ard import d
print(d) | [
"54246135+alexcnr@users.noreply.github.com"
] | 54246135+alexcnr@users.noreply.github.com |
1b4972c56701c6145e833481d3454ceb0bfc240a | 62980875b6e08d0099b1662fa3148ae29986fb64 | /BeautifulSoup/6_bs4.py | 898014028b10426db05bb94eb1a9f99b419b19ca | [] | no_license | kogkuemryong/Python_WebScraping- | 9db659c9a11c2677074fcac7f7029ec8541cb4f5 | 51cf7e7e71ce7c90b68f70daa43785671350dfb5 | refs/heads/master | 2022-12-12T17:01:27.142178 | 2020-09-08T16:48:19 | 2020-09-08T16:48:19 | 293,404,930 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,019 | py | import requests
from bs4 import BeautifulSoup
url ='https://comic.naver.com/webtoon/weekday.nhn'
res = requests.get(url) # url 를 읽음
res.raise_for_status() # 문제가 생기면 프로그램 종료를 시켜줌
soup = BeautifulSoup(res.text, 'lxml') # 텍스트 형태로 가져온 데이터를 lxml를 통해서
# BeautifulSoup 객체로 만든 것이다.
'''
해당 웹페이지를 잘 알 때 사용
print(soup.title) # <title>네이버 만화 > 요일별 웹툰 > 전체웹툰</title>
print(soup.title.get_text()) # 글자만 빼옴 / 네이버 만화 > 요일별 웹툰 > 전체웹툰
print(soup.a) # soup 전체에서 첫번째 a element 출력
print(soup.a.attrs) # a element의 속성 정보를 출력
print(soup.a['href']) # a element의 href 속성 '값' 정보를 출력`
'''
# print(soup.find('a', attrs={'class' :'Nbtn_upload'})) # class = 'Nbtn_upload' 인 a element를 찾아줘
# print(soup.find(attrs={'class' :'Nbtn_upload'})) # class = 'Nbtn_upload'인 어떤 element 를 찾아줘
# print(soup.find('li', attrs={'class':'rank01'}))
# rank1 = soup.find('li', attrs={'class':'rank01'})
# print(rank1.a.get_text()) # 글자만
# print (rank1.next_sibling) # 아무것도 출력 안됨
# rank2 = rank1.next_sibling.next_sibling # 형제 관계로 넘어가게 해준다.
# rank3 = rank2.next_sibling.next_sibling
# rank4 = rank3.next_sibling.next_sibling
# print(rank4.get_text())
# rank2 = rank3.previous_sibling.previous_sibling # 이전으로 가기
# print(rank1.parent) # 부모로 가기
# rank2 = rank1.find_next_sibling('li')
# print(rank2.a.get_text()) # next.sibling 을 여러번 사용하게 될 때 대신하여 유용하게 사용.
#
# rank3 = rank2.find_next_sibling('li')
# print(rank3.a.get_text())
#
# rank2 = rank3.find_previous_sibling('li')
# print(rank2.a.get_text())
# print (rank1.find_next_siblings('li'))
webtooon = soup.find('a' , text = '인생존망-43화 : 너 뽀뽀하려고 그랬지!!!')
print(webtooon)
| [
"rmafud93@naver.com"
] | rmafud93@naver.com |
2520da0ffe6d528d917b6d76d7e86d7767ae8d15 | 8f4488494507da4cb6f15073b8aa2e6f97fabb35 | /test/integration/local/test_tensorflow.py | c85f8f5d446253c4b38bdc7e634c6851379fd0e4 | [
"Apache-2.0"
] | permissive | aws/sagemaker-training-toolkit | 025966a1216aeb78b58f7abab19c6ccb01b0897d | e4a765e699e16c5849bbdfd789edbfc9820fdd77 | refs/heads/master | 2023-08-21T12:33:59.831391 | 2023-08-08T16:46:40 | 2023-08-08T16:46:40 | 212,439,434 | 415 | 110 | Apache-2.0 | 2023-09-07T19:58:23 | 2019-10-02T20:54:32 | Python | UTF-8 | Python | false | false | 1,528 | py | # Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You
# may not use this file except in compliance with the License. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompanying this file. This file 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 __future__ import absolute_import
import subprocess
import sys
import pytest
from sagemaker.estimator import Estimator
@pytest.fixture(scope="module", autouse=True)
def container():
try:
command = (
"docker run --name sagemaker-training-toolkit-test "
"sagemaker-training-toolkit-test:tensorflow train"
)
proc = subprocess.Popen(command.split(), stdout=sys.stdout, stderr=subprocess.STDOUT)
yield proc.pid
finally:
subprocess.check_call("docker rm -f sagemaker-training-toolkit-test".split())
def test_tensorflow_exceptions(capsys):
with pytest.raises(Exception):
estimator = Estimator(
image_uri="sagemaker-training-toolkit-test:tensorflow",
role="SageMakerRole",
instance_count=1,
instance_type="local",
)
estimator.fit()
stdout = capsys.readouterr().out
assert "XlaRuntimeError" in stdout
| [
"noreply@github.com"
] | aws.noreply@github.com |
53d75c85300f310c890f51624a78fbc5b2dfc791 | 112e792b80f0ba5f0989a297156d1554e18034d9 | /tests/test_check_query_params.py | 90286d96ac1974449fa7de5504efec9ccc26a4ca | [] | no_license | VNG-Realisatie/vng-api-common | ba4537c230f47f0b0ba305eccc289eef09be56f2 | 609c931b3f8b640aa6dff6d02cfb799745f25eb5 | refs/heads/master | 2023-06-26T22:52:50.419762 | 2023-06-20T11:20:53 | 2023-06-20T11:20:53 | 136,349,326 | 4 | 14 | null | 2023-09-01T14:26:58 | 2018-06-06T15:31:27 | Python | UTF-8 | Python | false | false | 1,467 | py | import pytest
from rest_framework.exceptions import ValidationError
from rest_framework.filters import OrderingFilter
from rest_framework.test import APIRequestFactory
from testapp.viewsets import GroupViewSet as _GroupViewSet
from vng_api_common.viewsets import CheckQueryParamsMixin
class CustomOrderingFilter(OrderingFilter):
ordering_param = "custom_ordering"
class GroupViewSet(CheckQueryParamsMixin, _GroupViewSet):
filter_backends = (OrderingFilter,)
def test_check_query_params_regular_ordering_filter():
factory = APIRequestFactory()
request = factory.get("/foo", format="json")
request.query_params = {"ordering": "datum"}
GroupViewSet()._check_query_params(request)
def test_check_query_params_subclassed_ordering_filter():
GroupViewSet.filter_backends = (CustomOrderingFilter,)
factory = APIRequestFactory()
request = factory.get("/foo", format="json")
# Should be possible to use custom ordering_param name
request.query_params = {"custom_ordering": "datum"}
GroupViewSet()._check_query_params(request)
def test_check_query_params_not_allowed():
GroupViewSet.filter_backends = (CustomOrderingFilter,)
factory = APIRequestFactory()
request = factory.get("/foo", format="json")
# Incorrect parameters should still be blocked
request.query_params = {"incorrect_param": "datum"}
with pytest.raises(ValidationError):
GroupViewSet()._check_query_params(request)
| [
"steven@maykinmedia.nl"
] | steven@maykinmedia.nl |
d6c452436e739d39d34f29427587d1d50df4a58d | 0ff59fc21b75bdc03ed4b1258f5d4adf77032ab4 | /dbinterface/models.py | dc8800ccc75b8f089834a709b75867b847d9d740 | [
"MIT"
] | permissive | rohithb/oneeightyone | ff40fef731fdffc46d65d9d2c8bcac89bd15f981 | c626ae1a8d91ac5650a9af7b9050c3522f0cde71 | refs/heads/master | 2021-01-20T11:45:42.438644 | 2017-01-29T05:40:00 | 2017-01-29T05:40:00 | 49,711,979 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,348 | py | from __future__ import unicode_literals
from django.db import models
class Countrynew(models.Model):
code = models.CharField(db_column='Code', verbose_name='Code', max_length=3) # Field name made lowercase.
name = models.CharField(db_column='Name',verbose_name='Name', max_length=52) # Field name made lowercase.
continent = models.CharField(db_column='Continent',verbose_name='Continent', max_length=13) # Field name made lowercase.
region = models.CharField(db_column='Region',verbose_name='Region', max_length=26) # Field name made lowercase.
surfacearea = models.FloatField(db_column='SurfaceArea', verbose_name='Surface Area') # Field name made lowercase.
yearofindependence = models.SmallIntegerField(db_column='YearOfIndependence',verbose_name='Year of Independence', blank=True, null=True) # Field name made lowercase.
population = models.IntegerField(db_column='Population', verbose_name='Population') # Field name made lowercase.
lifeexpectancy = models.FloatField(db_column='LifeExpectancy', verbose_name='Life Expectancy', blank=True, null=True) # Field name made lowercase.
gnp = models.FloatField(db_column='GNP', verbose_name='GNP', blank=True, null=True) # Field name made lowercase.
gnpold = models.FloatField(db_column='GNPOld', verbose_name='Old GNP', blank=True, null=True) # Field name made lowercase.
localname = models.CharField(db_column='LocalName', verbose_name='Local Name', max_length=45) # Field name made lowercase.
governmentform = models.CharField(db_column='GovernmentForm', verbose_name='Government Form', max_length=45) # Field name made lowercase.
headofstate = models.CharField(db_column='HeadOfState', verbose_name='Head of State', max_length=60, blank=True, null=True) # Field name made lowercase.
capitalcity = models.CharField(db_column='CapitalCity', verbose_name='Capital City', max_length=35) # Field name made lowercase.
capitalcitypopulation = models.IntegerField(db_column='CapitalCityPopulation', verbose_name='Capital City Population') # Field name made lowercase.
officiallanguage = models.CharField(db_column='OfficialLanguage', verbose_name='Official Language', max_length=30) # Field name made lowercase.
class Meta:
managed = False
db_table = 'countryNew'
verbose_name ='Countries'
| [
"rohith@linways.com"
] | rohith@linways.com |
e09d17676c7f1abd39e59fdf0a408d5e7b6e323e | 21876da55b29c80e49048b67ac952a6e41b37a3b | /createApiCase/TestCase/test_autoApiData.py | b5d3f320f536b0c14e7a190debf86caaa3fff066 | [] | no_license | wxfgithubone/OperationExcel | fb5a39a696fdd36f9a732217e71d9d8f100a94b9 | 678ea5a1bc2a31b144344b76850c5a55d0e71a08 | refs/heads/main | 2023-06-21T19:35:02.377049 | 2021-07-19T06:17:07 | 2021-07-19T06:17:07 | 336,494,655 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,317 | py | #!/usr/bin/env python3
# -*-coding:utf-8 -*-
"""
@Author: 王小飞
@File : test_autoApiData.py
@Time : 2021/1/15 15:12
@Tool : PyCharm
"""
import pytest
import allure
import sys
sys.path.append(r'E:\Desktop\ParsSwagger\createApiCase\TestCase')
from commonApi import CommonApi
from gainApiDta import GainApiData, header
api = GainApiData(file_name="erp-api.xls", sheet="01.公共模块")
@allure.epic("admin接口自动化项目")
class TestCommonApi:
@pytest.mark.parametrize("model_name, api_name, path, method, payload", api.return_api_message())
def test_case_one(self, model_name, api_name, path, method, payload):
if payload == "File":
pass
else:
resp = CommonApi().request_to_send(
method=method, url=path, body=payload.replace("'", '"'), header=header, param_id=api.return_id()
)
if "message" in resp.json():
print(resp.json())
assert resp.json()['message'] == 'success'
else:
assert resp.status_code == 200
allure.dynamic.story(model_name), allure.dynamic.title(api_name)
allure.dynamic.description("代码生成，暂无描述！"), allure.dynamic.severity("blocker")
if __name__ == '__main__':
pytest.main(['-v', '-s'])
| [
"wangxiaofei@hp.com"
] | wangxiaofei@hp.com |
6cf8ec73a5c5a72f0d0480549b3dc39c53453f42 | 230d18677d12f87edb3ef8bf646f14ccbf63a230 | /psp_nas/feat_engine/expansion.py | e4f76a4cc603f78d708810a0e5fef814af820bfb | [] | no_license | moguizhizi/PSP | bd8e4ddd5f26630f73879d36fb4ff09d886e3189 | 233e9937b7a17c9b7938a15aebcc727d5510c740 | refs/heads/master | 2023-06-26T11:19:20.644251 | 2021-07-30T07:24:02 | 2021-07-30T07:24:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,158 | py | import copy
import scipy as sp
import numpy as np
import pandas as pd
from sparsesvd import sparsesvd
from scipy.sparse.linalg import svds
from sklearn.preprocessing import OneHotEncoder
from sklearn.svm import LinearSVC
from sklearn.linear_model import logistic
from sklearn.calibration import CalibratedClassifierCV
from utils import *
def svd_feature(edge_df=None, meta_info=None, num_feature=64, **kwargs):
num_nodes = meta_info['num_nodes']
adj_matrix = np.zeros((num_nodes, num_nodes))
adj_matrix[edge_df['src_idx'], edge_df['dst_idx']] = 1.0
sparse_adj_matrix = sp.sparse.csc_matrix(adj_matrix)
# ut, s, vt = sparsesvd(sparse_adj_matrix, num_feature)
# svd_feats = np.dot(ut.T, np.diag(s))
u, s, vt = svds(sparse_adj_matrix, num_feature)
svd_feats = np.dot(u, np.diag(s))
return pd.DataFrame(svd_feats)
def edge_weights_feature(edge_df=None, meta_info=None, **kwargs):
num_nodes = meta_info['num_nodes']
edge_weights = np.zeros((num_nodes, num_nodes))
edge_weights[edge_df['src_idx'], edge_df['dst_idx']] = edge_df['edge_weight']
return pd.DataFrame(edge_weights)
def normalize_feature(feat_df=None, **kwargs):
x_feat = feat_df.drop('node_index', axis=1).to_numpy().astype(dtype=np.float64)
inv_x_rowsum = np.power(x_feat.sum(axis=1), -1).flatten()
inv_x_rowsum[np.isinf(inv_x_rowsum)] = 0.
x_diag_mat = np.diag(inv_x_rowsum)
normalized_x = x_diag_mat.dot(x_feat)
return pd.DataFrame(normalized_x)
class SVM:
def __init__(self, **kwargs):
self.name = "SVM"
self._model = CalibratedClassifierCV(LinearSVC(C=1.0, max_iter=500, class_weight=None, random_state=666))
def fit(self, x_train, y_train):
self._model.fit(x_train, y_train)
def predict(self, x_test):
return self._model.predict_proba(x_test)
class LR:
def __init__(self, **kwargs):
self.name = "LR"
self._model = logistic.LogisticRegression(C=1.0, solver="liblinear", multi_class="auto",
class_weight=None, max_iter=100, random_state=666)
def fit(self, x_train, y_train):
self._model.fit(x_train, y_train)
def predict(self, x_test):
return self._model.predict_proba(x_test)
def prepredict_feature(
feat_df=None, meta_info=None, train_indices=None, val_indices=None, train_label=None, test_indices=None, use_ohe=False,
**kwargs
):
fea_table = feat_df.set_index(keys="node_index")
test_indices = copy.deepcopy(test_indices)
if val_indices is not None:
test_indices += val_indices
if len(train_indices) == 20 * meta_info['num_class']:
test_indices = list(set(range(0, meta_info['num_nodes'])).difference(set(train_indices)))
train_label = train_label.set_index('node_index').loc[train_indices][['label']]
x_train, y_train = fea_table.loc[train_indices].to_numpy(), train_label.to_numpy()
x_test = fea_table.loc[test_indices].to_numpy()
lr = LR()
lr.fit(x_train, y_train)
if use_ohe:
ohe = OneHotEncoder(handle_unknown="ignore").fit(y_train.reshape(-1, 1))
x_train_feat, x_test_feat = ohe.transform(np.argmax(lr.predict(x_train), axis=1).reshape(-1, 1)).toarray(), \
ohe.transform(np.argmax(lr.predict(x_test), axis=1).reshape(-1, 1)).toarray()
else:
x_train_feat, x_test_feat = lr.predict(x_train), \
lr.predict(x_test)
pre_feat = np.concatenate([x_train_feat, x_test_feat], axis=0)
get_logger().info(f"prepredict: {pre_feat[:20]}")
total_indices = np.concatenate([train_indices, test_indices], axis=0)
return pd.DataFrame(data=pre_feat, index=total_indices)
def lpa_feature(
edge_df=None, meta_info=None,
train_label=None, train_indices=None, val_indices=None, test_indices=None,
use_ohe=False, max_iter=100, tol=1e-3,
**kwargs
):
test_indices = copy.deepcopy(test_indices)
if val_indices is not None:
test_indices += val_indices
if len(train_indices) == 20 * meta_info['num_class']:
test_indices = list(set(range(0, meta_info['num_nodes'])).difference(set(train_indices)))
train_label = train_label.set_index('node_index').loc[train_indices][['label']].to_numpy()
train_label = train_label.reshape(-1)
edges = edge_df.to_numpy()
edge_index = edges[:, :2].astype(np.int).transpose() # transpose to (2, num_edges)
edge_weight = edges[:, 2].astype(np.float)
num_nodes = meta_info['num_nodes']
total_indices = np.concatenate([train_indices, test_indices], axis=0)
adj = sp.sparse.coo_matrix((edge_weight, edge_index), shape=(num_nodes, num_nodes)).tocsr()
adj = adj[total_indices] # reorder
adj = adj[:, total_indices]
row_sum = np.array(adj.sum(axis=1), dtype=np.float)
d_inv = np.power(row_sum, -1).flatten()
d_inv[np.isinf(d_inv)] = 0.
normal_adj = sp.sparse.diags(d_inv).dot(adj).tocsr().transpose()
n_class = meta_info['num_class']
Pll = normal_adj[:len(train_indices), :len(train_indices)].copy()
Plu = normal_adj[:len(train_indices), len(train_indices):].copy()
Pul = normal_adj[len(train_indices):, :len(train_indices)].copy()
Puu = normal_adj[len(train_indices):, len(train_indices):].copy()
label_mat = np.eye(n_class)[train_label]
label_mat_prob = label_mat.copy()
# print("Pul shape {}, label_mat shape {}".format(Pul.shape, label_mat_prob.shape))
Pul_dot_lable_mat = Pul.dot(label_mat)
unlabel_mat = np.zeros(shape=(len(test_indices), n_class))
iter, changed = 0, np.inf
while iter < max_iter and changed > tol:
iter += 1
pre_unlabel_mat = unlabel_mat
unlabel_mat = Puu.dot(unlabel_mat) + Pul_dot_lable_mat
label_mat_prob = Pll.dot(label_mat_prob) + Plu.dot(pre_unlabel_mat)
changed = np.abs(pre_unlabel_mat - unlabel_mat).sum()
# preds = np.argmax(np.array(unlabel_mat), axis=1)
# unlabel_mat = np.eye(n_class)[preds]
total_indices = np.concatenate([train_indices, test_indices], axis=0)
if use_ohe:
ohe = OneHotEncoder(handle_unknown="ignore").fit(train_label.reshape(-1, 1))
label_mat_ohe = ohe.transform(np.argmax(label_mat_prob, axis=1).reshape(-1, 1)).toarray()
unlabel_mat_ohe = ohe.transform(np.argmax(unlabel_mat, axis=1).reshape(-1, 1)).toarray()
lu_mat_ohe = np.concatenate([label_mat_ohe, unlabel_mat_ohe], axis=0)
return pd.DataFrame(data=lu_mat_ohe, index=total_indices)
else:
unlabel_mat_prob = unlabel_mat
lu_mat_prob = np.concatenate([label_mat_prob, unlabel_mat_prob], axis=0)
get_logger().info(f"lpa: {lu_mat_prob[-20:]}")
return pd.DataFrame(data=lu_mat_prob, index=total_indices)
def degree_bins_feature(
meta_info=None, feat_df=None, edge_df=None, degree_series=None,
**kwargs
):
is_undirected = meta_info['is_undirected']
if is_undirected:
degree = feat_df['node_index'].map(edge_df.groupby('src_idx').size().to_dict())
degree.fillna(0, inplace=True)
else:
out_degree = feat_df['node_index'].map(edge_df.groupby('src_idx').size().to_dict())
in_degree = feat_df['node_index'].map(edge_df.groupby('dst_idx').size().to_dict())
out_degree.fillna(0, inplace=True)
in_degree.fillna(0, inplace=True)
degree = in_degree + out_degree
degree_series = degree
bins = int(max(30, degree_series.nunique() / 10))
degree_counts = degree_series.value_counts().reset_index()
degree_counts = degree_counts.rename(columns={'index': 'degree', 'node_index': 'nums'})
degree_counts = degree_counts.sort_values('degree')
min_nums = degree_series.shape[0] / bins
k = 0
cum_nums = 0
bins_dict = {}
for i, j in zip(degree_counts['degree'], degree_counts['nums']):
cum_nums += j
bins_dict[i] = k
if cum_nums >= min_nums:
k += 1
cum_nums = 0
degree_bins = degree_series.map(bins_dict)
return pd.concat([degree_series, degree_bins], axis=1)
# TODO: maybe asister's neighbour bin 2
| [
"njuwwj@126.com"
] | njuwwj@126.com |
538432edd63d9503879fed091c2da849b88aeb19 | d7ccb4225f623139995a7039f0981e89bf6365a4 | /.history/mall/settings_20211011171802.py | d6ac69d215da3f819a7996e8f1d92e8ab5d563bf | [] | no_license | tonnymuchui/django-mall | 64fd4abc3725c1bd0a3dcf20b93b490fe9307b37 | 55c083d8433be3c77adc61939cd197902de4ce76 | refs/heads/master | 2023-08-23T04:59:20.418732 | 2021-10-13T15:59:37 | 2021-10-13T15:59:37 | 415,668,388 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,642 | py | """
Django settings for mall project.
Generated by 'django-admin startproject' using Django 3.2.5.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""
import os
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
TEMPLATE_DIR = os.path.join(BASE_DIR,"templates")
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'django-insecure-#l0ij4e$3v@&xi3i#y$19f#_@z(yv+5yw$kc+02!-)g%ny%oi8'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'category',
'accounts',
'store',
'carts'
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'mall.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [TEMPLATE_DIR,],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
'category.context_processors.menu_links',
'cart.cont'
],
},
},
]
WSGI_APPLICATION = 'mall.wsgi.application'
AUTH_USER_MODEL = 'accounts.Account'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR /'static'
STATICFILES_DIRS = [
'mall/static',
]
# media files configuration
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR /'media'
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
| [
"tonykanyingah@gmail.com"
] | tonykanyingah@gmail.com |
0b00f8ad510a7896d7e3e0cd5a71c3a07cce56b3 | 2361d46b4c985fb8b61358f8c6a90ba6fef462c6 | /aluno/src/aluno/settings.py | 05c0e52e3e2a0a818601dc1104be28e7887bc05f | [] | no_license | brunobannwart/sistemaciapd | 60d9aa5babeee23268650b205691728d0cf0e135 | 9dfc2575d7ef12cfa2a7fe5f5506656e4b9c069b | refs/heads/master | 2022-12-29T16:04:19.197709 | 2020-10-21T16:30:05 | 2020-10-21T16:30:05 | 265,300,124 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,501 | py | """
Django settings for aluno project.
Generated by 'django-admin startproject' using Django 3.0.6.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.0/ref/settings/
"""
import os
from decouple import config
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.0/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = config('SECRET_KEY')
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = config('DEBUG', default=True, cast=bool)
ALLOWED_HOSTS = ['127.0.0.1', 'localhost']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'core_aluno',
'curriculos',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'aluno.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'aluno.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.0/ref/settings/#databases
#DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.sqlite3',
# 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
# }
#}
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': config('DB_NAME'),
'USER': config('DB_USER'),
'PASSWORD': config('DB_PASSWORD'),
'HOST': config('DB_HOST'),
'PORT': config('DB_PORT'),
}
}
AUTHENTICATION_BACKENDS = [
'aluno.backend.LoginBackend',
]
# Password validation
# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/
LANGUAGE_CODE = 'pt-br'
TIME_ZONE = 'America/Sao_Paulo'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.0/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
# STATICFILES_DIRS = [
# os.path.join(BASE_DIR, 'static')
# ]
MEDIA_ROOT = os.path.join(BASE_DIR, '..', '..', 'media')
MEDIA_URL = '/media/'
| [
"bbannwart@yahoo.com.br"
] | bbannwart@yahoo.com.br |
2ea6a54e6d5e934338510fc52ec20c0e4d55851c | ce6cb09c21470d1981f1b459293d353407c8392e | /docs/jnpr_healthbot_swagger/swagger_client/models/rule_schema_formula1_or.py | 71314684086751f0563ed538b08bac277bdc9834 | [
"Apache-2.0"
] | permissive | minefuto/healthbot-py-client | c4be4c9c3153ef64b37e5344bf84154e93e7b521 | bb81452c974456af44299aebf32a73abeda8a943 | refs/heads/master | 2022-12-04T07:47:04.722993 | 2020-05-13T14:04:07 | 2020-05-13T14:04:07 | 290,145,286 | 0 | 0 | Apache-2.0 | 2020-08-25T07:27:54 | 2020-08-25T07:27:53 | null | UTF-8 | Python | false | false | 5,021 | py | # coding: utf-8
"""
Healthbot APIs
API interface for Healthbot application # noqa: E501
OpenAPI spec version: 1.0.0
Contact: healthbot-hackers@juniper.net
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
class RuleSchemaFormula1Or(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'left_vector': 'str',
'right_vector': 'str'
}
attribute_map = {
'left_vector': 'left-vector',
'right_vector': 'right-vector'
}
def __init__(self, left_vector=None, right_vector=None): # noqa: E501
"""RuleSchemaFormula1Or - a model defined in Swagger""" # noqa: E501
self._left_vector = None
self._right_vector = None
self.discriminator = None
self.left_vector = left_vector
self.right_vector = right_vector
@property
def left_vector(self):
"""Gets the left_vector of this RuleSchemaFormula1Or. # noqa: E501
Vector name. Pattern for giving vector name is @[a-z][a-zA-Z0-9_-]* # noqa: E501
:return: The left_vector of this RuleSchemaFormula1Or. # noqa: E501
:rtype: str
"""
return self._left_vector
@left_vector.setter
def left_vector(self, left_vector):
"""Sets the left_vector of this RuleSchemaFormula1Or.
Vector name. Pattern for giving vector name is @[a-z][a-zA-Z0-9_-]* # noqa: E501
:param left_vector: The left_vector of this RuleSchemaFormula1Or. # noqa: E501
:type: str
"""
if left_vector is None:
raise ValueError("Invalid value for `left_vector`, must not be `None`") # noqa: E501
if left_vector is not None and not re.search(r'^@[a-z][a-zA-Z0-9_-]*$', left_vector): # noqa: E501
raise ValueError(r"Invalid value for `left_vector`, must be a follow pattern or equal to `/^@[a-z][a-zA-Z0-9_-]*$/`") # noqa: E501
self._left_vector = left_vector
@property
def right_vector(self):
"""Gets the right_vector of this RuleSchemaFormula1Or. # noqa: E501
Vector name. Pattern for giving vector name is @[a-z][a-zA-Z0-9_-]* # noqa: E501
:return: The right_vector of this RuleSchemaFormula1Or. # noqa: E501
:rtype: str
"""
return self._right_vector
@right_vector.setter
def right_vector(self, right_vector):
"""Sets the right_vector of this RuleSchemaFormula1Or.
Vector name. Pattern for giving vector name is @[a-z][a-zA-Z0-9_-]* # noqa: E501
:param right_vector: The right_vector of this RuleSchemaFormula1Or. # noqa: E501
:type: str
"""
if right_vector is None:
raise ValueError("Invalid value for `right_vector`, must not be `None`") # noqa: E501
if right_vector is not None and not re.search(r'^@[a-z][a-zA-Z0-9_-]*$', right_vector): # noqa: E501
raise ValueError(r"Invalid value for `right_vector`, must be a follow pattern or equal to `/^@[a-z][a-zA-Z0-9_-]*$/`") # noqa: E501
self._right_vector = right_vector
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(RuleSchemaFormula1Or, dict):
for key, value in self.items():
result[key] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, RuleSchemaFormula1Or):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| [
"nitinkr@juniper.net"
] | nitinkr@juniper.net |
88c4ea3f8b97f2787635007c1c54b574599d7e87 | 7d3018f3042af128574a387e10350f38330a3a75 | /waffles/manage.py | f174f1a0c69913656cac8f03519dc6201474affe | [
"Zlib",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | IonTeLOS/waffles | 1b59976f0fd1bc898295483e6b8fe6d7d793160c | 2e77dd65afffbbf1545e9ced2296dcbd0ab3c8e4 | refs/heads/main | 2023-06-30T10:14:10.139356 | 2021-08-08T15:49:56 | 2021-08-08T15:49:56 | 380,561,604 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,829 | py | import logging
from argparse import Namespace
from typing import Tuple
from PyQt5.QtWidgets import QApplication, QWidget
from waffles import ROOT_DIR, __app_name__
from waffles.api.abstract.context import ApplicationContext
from waffles.api.http import HttpClient
from waffles.commons.internet import InternetChecker
from waffles.context import generate_i18n, DEFAULT_I18N_KEY, new_qt_application
from waffles.view.core import gems
from waffles.view.core.controller import GenericSoftwareManager
from waffles.view.core.downloader import AdaptableFileDownloader
from waffles.view.qt.prepare import PreparePanel
from waffles.view.qt.settings import SettingsWindow
from waffles.view.qt.window import ManageWindow
from waffles.view.util import resource, util
from waffles.view.util.cache import CacheCleaner, DefaultMemoryCacheFactory
from waffles.view.util.disk import DefaultDiskCacheLoaderFactory
def new_manage_panel(app_args: Namespace, app_config: dict, logger: logging.Logger) -> Tuple[QApplication, QWidget]:
i18n = generate_i18n(app_config, resource.get_path('locale'))
cache_cleaner = CacheCleaner()
cache_factory = DefaultMemoryCacheFactory(expiration_time=int(app_config['memory_cache']['data_expiration']), cleaner=cache_cleaner)
icon_cache = cache_factory.new(int(app_config['memory_cache']['icon_expiration']))
http_client = HttpClient(logger)
context = ApplicationContext(i18n=i18n,
http_client=http_client,
download_icons=bool(app_config['download']['icons']),
app_root_dir=ROOT_DIR,
cache_factory=cache_factory,
disk_loader_factory=DefaultDiskCacheLoaderFactory(logger),
logger=logger,
distro=util.get_distro(),
file_downloader=AdaptableFileDownloader(logger, bool(app_config['download']['multithreaded']),
i18n, http_client, app_config['download']['multithreaded_client']),
app_name=__app_name__,
internet_checker=InternetChecker(offline=app_args.offline))
managers = gems.load_managers(context=context, locale=i18n.current_key, config=app_config, default_locale=DEFAULT_I18N_KEY)
if app_args.reset:
util.clean_app_files(managers)
exit(0)
manager = GenericSoftwareManager(managers, context=context, config=app_config)
app = new_qt_application(app_config=app_config, logger=logger, quit_on_last_closed=True)
if app_args.settings: # only settings window
manager.cache_available_managers()
return app, SettingsWindow(manager=manager, i18n=i18n, screen_size=app.primaryScreen().size(), window=None)
else:
manage_window = ManageWindow(i18n=i18n,
manager=manager,
icon_cache=icon_cache,
screen_size=app.primaryScreen().size(),
config=app_config,
context=context,
http_client=http_client,
icon=util.get_default_icon()[1],
logger=logger)
prepare = PreparePanel(screen_size=app.primaryScreen().size(),
context=context,
manager=manager,
i18n=i18n,
manage_window=manage_window,
app_config=app_config)
cache_cleaner.start()
return app, prepare
| [
"teloslinux@protonmail.com"
] | teloslinux@protonmail.com |
579abfde10cc079437bacf7c8f84380010aae32d | 6f5c58ecebbc386fec0b8df00af1415ca7707472 | /test/suite/test_suites.py | 9a642cb665cf3c331408d9be4470ec6d85f32806 | [] | no_license | zhangrui90158/interface_framework | ee20cbc41dc388d1a712e050fb02ec77c032dba1 | 8773e394cd02d7260825b6466e9254aa4a2f23f8 | refs/heads/master | 2020-06-20T13:30:43.989042 | 2019-09-05T07:22:05 | 2019-09-05T07:22:05 | 197,131,956 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 226 | py | import unittest
smoke_sutie = unittest.TestSuite()
# smoke_sutie.addTest([PasswordWithJsonTestCase('test_test'),PasswordWithJsonTestCase('test_weak_password')])
def get_sutie(sutie_name):
return globals().get(sutie_name) | [
"qiulijun@yiqiniu.com"
] | qiulijun@yiqiniu.com |
b3a0d916d7333f18aa24e4c62f35ff6da6eede16 | 22a9682300cc8549495b85a7d3261644815aa8f1 | /Trabalho7/transformacao/primeiraTransformacao.py | 8dbef7a492b73a0a9de99f51799b93a46360a408 | [] | no_license | thiagomartendal/TrabalhosCG | 894029ee67a1ab2863dc8d965a0fcd3d83c84a9f | fa6e52640a53f4c2bbbd3edb3b1b4fc883ea8f02 | refs/heads/master | 2023-01-07T21:45:54.964178 | 2020-11-01T20:40:00 | 2020-11-01T20:40:00 | 292,715,507 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,831 | py | from numpy import matmul
from math import radians, cos, sin
from objeto.estruturaPonto import *
from transformacao.projecao import *
class PrimeiraTransformacao:
# Construtor
def __init__(self, objetos, window, coordenadasV):
self.__objetos = objetos
self.__window = window
self.__coordenadasV = coordenadasV
self.__coordenadasW = self.__window.coordenadas3D()
# Calculo da transformada de viewport
def transformadaViewport(self):
xwmin = self.__coordenadasW[0]
ywmin = self.__coordenadasW[1]
xwmax = self.__coordenadasW[2]
ywmax = self.__coordenadasW[3]
xvmin = self.__coordenadasV[0]
yvmin = self.__coordenadasV[1]
xvmax = self.__coordenadasV[2]
yvmax = self.__coordenadasV[3]
for objeto in self.__objetos:
pontos = []
for p in objeto.getPontosFixos():
xw = p.X()
yw = p.Y()
xv = ((xw-xwmin)/(xwmax-xwmin))*(xvmax-xvmin)
yv = (1-((yw-ywmin)/(ywmax-ywmin)))*(yvmax-yvmin)
pontos.append(EstruturaPonto(xv, yv))
objeto.setPontos(pontos)
# Operação de zoomIn na window
def zoomIn(self):
qnt = [100, 100]
self.__window.setX1(self.__coordenadasW[0] + qnt[0]/2)
self.__window.setX2(self.__coordenadasW[2] - qnt[0]/2)
self.__window.setY1(self.__coordenadasW[1] + qnt[1]/2)
self.__window.setY2(self.__coordenadasW[3] - qnt[1]/2)
# tamanho da window <= 0
largura, altura = self.__window.getSize()
if (largura <= 0) or (altura <= 0): self.zoomOut()
# Operação de zoomOut na window
def zoomOut(self):
qnt = [100, 100]
self.__window.setX1(self.__coordenadasW[0] - qnt[0]/2)
self.__window.setX2(self.__coordenadasW[2] + qnt[0]/2)
self.__window.setY1(self.__coordenadasW[1] - qnt[1]/2)
self.__window.setY2(self.__coordenadasW[3] + qnt[1]/2)
# Move a window para cima
def up(self):
participacao = self.__participacaoEixo(0, -1, 0, 100)
self.__mover(participacao)
# Move a window para baixo
def down(self):
participacao = self.__participacaoEixo(0, 1, 0, 100)
self.__mover(participacao)
# Move a window para esquerda
def left(self):
participacao = self.__participacaoEixo(1, 0, 0, 100)
self.__mover(participacao)
# Move a window para direita
def right(self):
participacao = self.__participacaoEixo(-1, 0, 0, 100)
self.__mover(participacao)
# Move a window para dentro
def forward(self):
participacao = self.__participacaoEixo(0, 0, 1, 100)
self.__mover(participacao)
# Move a window para fora
def back(self):
participacao = self.__participacaoEixo(0, 0, -1, 100)
self.__mover(participacao)
# move a window
def __mover(self, participacao):
x, y, z = participacao
self.__window.setX1(self.__coordenadasW[0] + x)
self.__window.setX2(self.__coordenadasW[2] + x)
self.__window.setY1(self.__coordenadasW[1] + y)
self.__window.setY2(self.__coordenadasW[3] + y)
self.__window.setZ( self.__coordenadasW[4] + z)
# Vetor com a participacao de cada eixo no movimento
def __participacaoEixo(self, x, y, z, qtd):
proj = Projecao(self.__window)
x *= qtd
y *= qtd
z *= qtd
matQtd = [x, y, z, 1]
mrx = proj.gerarMatrizRotacaoX(self.__window.getAnguloX())
mry = proj.gerarMatrizRotacaoY(self.__window.getAnguloY())
mrz = proj.gerarMatrizRotacaoZ(self.__window.getAnguloZ())
mresult = proj.calcularMatrizResultante([mrx, mry, mrz])
participacao = matmul(matQtd, mresult)
return participacao[:-1]
| [
"noreply@github.com"
] | thiagomartendal.noreply@github.com |
e1e3ac00fa17603eadd4d1332895f4e1309659cc | bf35bb20d444da65cb511f22f54c95f2d89fb188 | /Garen/pycharm/privacy/venv/Scripts/easy_install-3.6-script.py | bed935dcbbe878c706e10fab223ec212e1831653 | [] | no_license | faraby7/Video-Conference-Chatting | 79194889a005e68f93266edec182df45e42cb075 | 8206e328dbb53f107a44408448ffad2160cda533 | refs/heads/master | 2022-11-27T07:25:12.431983 | 2018-09-22T12:58:06 | 2018-09-22T12:58:06 | 149,877,579 | 1 | 1 | null | 2022-11-22T05:47:08 | 2018-09-22T13:05:47 | Python | UTF-8 | Python | false | false | 460 | py | #!C:\Users\famille\PycharmProjects\privacy\venv\Scripts\python.exe
# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==39.1.0','console_scripts','easy_install-3.6'
__requires__ = 'setuptools==39.1.0'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('setuptools==39.1.0', 'console_scripts', 'easy_install-3.6')()
)
| [
"yusuf.faraby@gmail.com"
] | yusuf.faraby@gmail.com |
4c0d4d4150b62d2151f73bd99f474cc1fcdc41af | e01dde12be71c40065a9d6d2b1451f837c42a41e | /py_trees_ros_viewer/viewer.py | 754f696ee24634ae00238eb788ed5305d7f1e131 | [
"BSD-3-Clause"
] | permissive | neelj09/py_trees_ros_viewer | 29336ce5a7f7592ffb67c0170b42902d16fea5d3 | 1fbd7877fa4bcb53119b3111db26ce87ec8ccebd | refs/heads/master | 2022-04-09T00:48:10.260221 | 2019-08-10T02:54:03 | 2019-08-10T02:54:03 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,833 | py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# License: BSD
# https://github.com/splintered-reality/py_trees_ros_viewer/raw/devel/LICENSE
#
##############################################################################
# Documentation
##############################################################################
"""
A qt-javascript application for viewing executing or replaying py_trees
"""
##############################################################################
# Imports
##############################################################################
import functools
import json
import signal
import sys
import time
import PyQt5.QtCore as qt_core
import PyQt5.QtWidgets as qt_widgets
from . import console
from . import trees
from . import main_window
##############################################################################
# Helpers
##############################################################################
def send_tree_response(reply):
console.logdebug("reply: '{}' [viewer]".format(reply))
@qt_core.pyqtSlot()
def send_tree(web_view_page, demo_trees, unused_checked):
send_tree.index = 0 if send_tree.index == 2 else send_tree.index + 1
demo_trees[send_tree.index]['timestamp'] = time.time()
console.logdebug("send: tree '{}' [{}][viewer]".format(
send_tree.index, demo_trees[send_tree.index]['timestamp'])
)
web_view_page.runJavaScript(
"render_tree({tree: '%s'});" % json.dumps(demo_trees[send_tree.index]),
send_tree_response
)
send_tree.index = 0
##############################################################################
# Main
##############################################################################
def main():
# logging
console.log_level = console.LogLevel.DEBUG
# the players
app = qt_widgets.QApplication(sys.argv)
demo_trees = trees.create_demo_tree_list()
window = main_window.MainWindow(
default_tree=demo_trees[0]
)
# sig interrupt handling
# use a timer to get out of the gui thread and
# permit python a chance to catch the signal
# https://stackoverflow.com/questions/4938723/what-is-the-correct-way-to-make-my-pyqt-application-quit-when-killed-from-the-co
def on_shutdown(unused_signal, unused_frame):
console.logdebug("received interrupt signal [viewer]")
window.close()
signal.signal(signal.SIGINT, on_shutdown)
timer = qt_core.QTimer()
timer.timeout.connect(lambda: None)
timer.start(250)
# sigslots
window.ui.send_button.clicked.connect(
functools.partial(
send_tree,
window.ui.web_view_group_box.ui.web_engine_view.page(),
demo_trees
)
)
# qt bringup
window.show()
result = app.exec_()
# shutdown
sys.exit(result)
| [
"d.stonier@gmail.com"
] | d.stonier@gmail.com |
9705d620dc0a9a41a510ea6109e257d983d08169 | 9d6a0a02f61076dc28eafe241501fe9fa7855ae0 | /send and yeild.py | a1466db39db1c6a2f6debf5f6adf34a84169c787 | [] | no_license | yyqlk/magical-python | 6edc977a02957fe8eebd7f594966db05c92358ca | 7c433b4fc42171a0df8e231764b9aa13521d0e26 | refs/heads/master | 2020-04-02T15:58:19.191283 | 2019-02-04T10:43:15 | 2019-02-04T10:43:15 | 154,592,093 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,874 | py | # AUTHOR : YYQLK
"""send和yield的运用，相当于简单的协程，下面是两个简单的实现，计数器和生产者消费者模型"""
#一个计数器,可以实现计算了sum函数执行了多少次
def count():
i = 0
while True:
i = yield i + 1
print(i)
def sum(s):
n = 0
s.send(None)
while n < 5:
n = s.send(n)
print("执行{}次".format(n))
s = count()
sum(s)
# 输出：
# 0
# 执行1次
# 1
# 执行2次
# 2
# 执行3次
# 3
# 执行4次
# 4
# 执行5次
#第二个，生产者消费者模型
def consumer():
r = ''
while True:
n = yield r
if not n:
return
print('[消费者]:收到 %s号产品'%n)
r = '收到'
def produce(c):
c.send(None) # 启动生成器，相当把生成器打开，在程序上体现为直接进去到yield循环
n = 0
while n < 5:
n += 1
print('[生产]: 生产%s号产品' %n)
r = c.send(n)
print('[生产]:消费者是否收到： %s' %r)
c.close()
c = consumer()
produce(c)
#send（None）相当如启动该函数，遇到send函数，将参数发送到yeild，作为yield的返回值。
#往下执行，再次遇到yield结束，将yield返回值接受回来
# 输出：
# [生产]: 生产1号产品
# [消费者]:收到 1号产品
# [生产]:消费者是否收到： 收到
# [生产]: 生产2号产品
# [消费者]:收到 2号产品
# [生产]:消费者是否收到： 收到
# [生产]: 生产3号产品
# [消费者]:收到 3号产品
# [生产]:消费者是否收到： 收到
# [生产]: 生产4号产品
# [消费者]:收到 4号产品
# [生产]:消费者是否收到： 收到
# [生产]: 生产5号产品
# [消费者]:收到 5号产品
# [生产]:消费者是否收到： 收到
| [
"799331030@qq.com"
] | 799331030@qq.com |
15bd7e332a59184de848af3cc92208ff3dcc0330 | 7d1e9acf94a5e4533d3ef5828b568e89c29519a3 | /11-Message Box/MessageBox.py | a6e635c724e37df0204a8b500c9173b5d056455a | [] | no_license | abuzarrizvi/Python-GUI-s-With-TKinter | c960e3629589d25b72f6720caebb552352e77976 | d5c7843cdd3203294762ae92b6503ecb55d083f1 | refs/heads/master | 2020-07-06T03:17:56.798236 | 2019-08-23T10:56:41 | 2019-08-23T10:56:41 | 202,871,347 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 592 | py | from tkinter import *
from PIL import ImageTk, Image
from tkinter import messagebox
root = Tk()
root.title('Learn To Code at Github.com')
root.iconbitmap('Martz90-Circle-Camera.ico')
#showinfo, showwarning, showerror, askquestion, askokcancel, askyesno
def popup():
response = messagebox.showerror("This is my Popup!", "Hello World!")
Label(root, text=response).pack()
#if response == "yes":
# Label(root, text="You Clicked Yes! ").pack()
#else:
# Label(root, text="You Clicked No! ").pack()
Button(root, text="Popup", command=popup).pack()
root.mainloop()
| [
"noreply@github.com"
] | abuzarrizvi.noreply@github.com |
5c816ea3b43efb15eed77e5f997bf84df00e6672 | 0128e4de4bfc974dc9e0ad9c6d33e0f19d345734 | /cl_pets/cl_pets/spiders/myspider.py | 3520582e5dbc56d0307079e82ee3801de77847fc | [] | no_license | cmj123/python_scrapy | 187070189c4adde6353a8486fe6e85b9a6b2cc8c | 4dde3b636c659725e85f985e77efce62812818dc | refs/heads/master | 2022-11-25T14:28:23.304550 | 2020-07-29T19:00:21 | 2020-07-29T19:00:21 | 283,002,629 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 532 | py | # //td[@class='views-field views-field-title active']//a
# Import key libraries
import scrapy
# Class
class MySpider(scrapy.Spider):
name = "cl_pets"
start_urls = ['https://www.towardssustainability.be/en/Investment-Product']
def parse(self, response):
for product in response.xpath("//td[@class='views-field views-field-title active']"):
yield{
'Product':product.xpath("a/text()").extract_first(),
'Link':product.xpath("a").extract_first()
} | [
"esuabomdijemeni@Esuaboms-MacBook-Pro.local"
] | esuabomdijemeni@Esuaboms-MacBook-Pro.local |
8c44c2f023c5906c198d917549801e94d4c42331 | c6d2fdd1e52d401006b4bcbfef343f18fc52bac0 | /sg_unattached.py | a168be9bfe52621761efbf8d3bdd314c018dd98e | [] | no_license | pmsaheb/AWS_Assesments | 1b30a981b2aafe24241916ea696563bca2b3fc0f | 797ebc854b66edc1ba7fb8fca1f822d52bffbf23 | refs/heads/master | 2020-12-26T16:41:29.034330 | 2018-11-08T08:11:50 | 2018-11-08T08:11:50 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 519 | py | import boto3
ec2 = boto3.client('ec2')
instance = ec2.describe_instances()['Reservations']
sg = ec2.describe_security_groups()['SecurityGroups']
for i in sg:
sg_name = i['GroupName']
if instance[0]['Instances'][0]['State']['Name'] != 'terminated':
ins = instance[0]['Instances'][0]['SecurityGroups'][0]['GroupName']
if sg_name not in ins:
print sg_name
#for i in keys
#print instance[0]['Instances'][0]['State']['Name']
#print instance[0]['Instances'][0]['SecurityGroups'][0]['GroupName']
| [
"subani.prasad@gmail.com"
] | subani.prasad@gmail.com |
9ef9bdf999aaafc0e596dd0c36c107fa4fbe24e3 | 7e6a67e6b3d0c92b9ffc4bb875619fbddee75a0e | /example-project/examplesite/urls.py | a1fdfb454819a095f30d98b0d4e50d39a9e927d9 | [] | no_license | brianbtrfld/Django | df4966c9662bdc908787beac26881fdb7e654b61 | 99df07fc08304e229da0ad0e162094ec905b17e3 | refs/heads/master | 2023-02-21T07:53:42.492489 | 2021-01-27T22:31:04 | 2021-01-27T22:31:04 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 805 | py | """examplesite URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('polls/', include('polls.urls')),
path('admin/', admin.site.urls),
]
| [
"brian@butter-field.net"
] | brian@butter-field.net |
728c81d8394209a41c9c13be78e81117b4680432 | 250e692078234b0e3ef22ad20ab7168f807d1d5f | /diagonal_matrix.py | 08b03ebc30dd750a07341d1b062de7ee30082f1c | [] | no_license | AnTznimalz/python_prepro | 694338609985971c5e6eaf8ec463c2a5c62dd836 | bdc1e49fa03704bebcf2ab69a4c1600e4cd46a74 | refs/heads/master | 2022-06-22T23:47:28.396580 | 2020-05-07T15:07:56 | 2020-05-07T15:07:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 342 | py | """ Diagonal Matrix"""
def mat():
""" Func. mat for calculate matrix """
dim = int(input())
box = list()
a, b = 0, 0
for n in range(dim):
lst = input().split()
box.append(lst)
lst = []
for i in range(dim):
a += int(box[i][i])
b += int(box[i][dim-i-1])
print(abs(a-b))
mat()
| [
"thuchpunapivitcholachat@gmail.com"
] | thuchpunapivitcholachat@gmail.com |
1dd2cfd0ea53c0f5de9893ba1150ef19c9446ed7 | 7ae0722e038fca98497882c51904a8bd13e07171 | /week03/movie_scraping.py | 427e0a4a992cf57dbcdabf82ad8df9495ec9c028 | [] | no_license | HarimJ/web_proj | f4ba3ed57abade2184f84bcfefd277c2a07663ce | 21e80d81c056749d9dfeb859abafe1b55cd8cbff | refs/heads/master | 2022-12-22T02:33:33.233433 | 2020-09-24T22:44:19 | 2020-09-24T22:44:19 | 288,736,037 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,008 | py | import requests
from bs4 import BeautifulSoup
# 타겟 URL을 읽어서 HTML를 받아오고,
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36'}
data = requests.get('https://movie.naver.com/movie/sdb/rank/rmovie.nhn?sel=pnt&date=20200716',headers=headers)
# 다른 방법
#url = 'https://movie.naver.com/movie/sdb/rank/rmovie.nhn?sel=pnt&date=20200716'
#data = requests.get(url,headers=headers)
# HTML을 BeautifulSoup이라는 라이브러리를 활용해 검색하기 용이한 상태로 만듦
# soup이라는 변수에 "파싱 용이해진 html"이 담긴 상태가 됨
# 이제 코딩을 통해 필요한 부분을 추출하면 된다.
soup = BeautifulSoup(data.text, 'html.parser')
#parser : 내가 원하는 방식으로 변형 해주는 것 (파싱)
#############################
# (입맛에 맞게 코딩)
#############################
# select를 이용해서, tr들을 불러오기
movies = soup.select('#old_content > table > tbody > tr')
# movies (tr들) 의 반복문을 돌리기
for movie in movies:
#태그 안의 텍스트를 찍고 싶을 땐 → 태그.text
#태그 안의 속성을 찍고 싶을 땐 → 태그['속성']
# movie 안에 a 가 있으면,
rank = movie.select_one('td.ac > img')
title = movie.select_one('td.title > div > a')
score = movie.select_one('td.point')
# a_tag = movie.select_one('td.title > div > a[href = "주토피아"]')
# a의 text를 찍어본다.
# print(a_tag.text) <- if문 안했을때는 왜 작동하지 않는지 ? : 맨 처음 찾은 애가 text 형태가 아니여서 나오지 않는다 (못찾아서)
'#old_content > table > tbody > tr:nth-child(2) > td.title > div > a'
# copy selector 로 파싱한거 (위)
if rank is not None:
print(rank['alt'], title.text, score.text)
#print(title.text)
#print(title['title']) 로해도 제목이 나온다.
#print(score.text) | [
"58238503+HarimJ@users.noreply.github.com"
] | 58238503+HarimJ@users.noreply.github.com |
30c60f0f95d1c5080c397608a327130a749128b9 | 98200ddbba7481f4bfcdb6e61845faf71dc03f51 | /Another/image_gen.py | f039f044f7838b005e5d510c3647abeab2fba732 | [] | no_license | thick130/Shoes_recommend | 01d8bf931dcf95cf309849da12e5c58f97632e8e | b953aa0958d7c6209c5da5f533597d47de368896 | refs/heads/master | 2020-03-14T21:26:31.277692 | 2018-12-07T10:03:30 | 2018-12-07T10:03:30 | 131,796,138 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,383 | py | import multiprocessing, os, time
from keras.preprocessing.image import ImageDataGenerator
''' SETTING '''
INPUT_DIR = 'C:/Users/KHJ/PycharmProjects/Shoes_tf/img2/' # your image data directory/
OUTPUT_DIR = 'C:/Users/KHJ/PycharmProjects/Shoes_tf/gen_img/' # output images data directory/
IMAGE_FORMAT = 'jpeg' # output image format (jpeg, png)
FILE_NAME = 'pre' # output image file name pre***.jpeg
IMAGE_SIZE = (299, 299) # output image size
P_NUM = multiprocessing.cpu_count() # number of core
END_POINT = 10 # Number of images to be generated per image
# batch_size = Number of images in 1 label
# The batch size is calculated automatically.
# Set image modify
# See keras api documentation
# https://keras.io/preprocessing/image/
train_data = ImageDataGenerator(
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.1,
zoom_range=0.1,
channel_shift_range=0.1,
fill_mode='nearest',
horizontal_flip=False,
vertical_flip=False,
rescale=None,
preprocessing_function=None)
''' Execution '''
def check_start():
global labels
labels = os.listdir(INPUT_DIR)
global labels_cnt
labels_cnt = len(labels)
no_image = []
try:
if not (os.path.isdir(INPUT_DIR)):
print("Error : Not a directory.")
print(INPUT_DIR)
return False
else:
if not (labels):
print('\nError : Input directory is empty.')
print(INPUT_DIR)
return False
else:
for name in labels:
if (len(os.walk(INPUT_DIR + name).__next__()[2]) == 0):
no_image.append(name)
if (no_image):
print('\nError : There are no images in the sub directory.')
for name in no_image:
print('- ' + name)
return False
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
except:
print('\nError : It is not the root images directory.')
print("Check the 'INPUT_DIR' and images directory structure.")
print(INPUT_DIR)
return False
exit()
else:
return True
def ready_dir():
# looking for labels
try:
print('\nLooking for labels ...')
for folder_name in labels:
print(folder_name)
os.mkdir(OUTPUT_DIR + folder_name)
print('\n%d Labels' % labels_cnt)
print('... Completed ...\n')
except:
print('Error : Failed to find and create label.')
exit()
def gen(folder_name):
i = 0
batch_cnt = len(os.walk(INPUT_DIR + folder_name).__next__()[2])
print('- ' + folder_name + ' start ...')
try:
for name in train_data.flow_from_directory(
directory=INPUT_DIR,
target_size=IMAGE_SIZE,
batch_size=batch_cnt,
save_to_dir=OUTPUT_DIR + folder_name,
save_format=IMAGE_FORMAT,
save_prefix=folder_name,
classes=[folder_name]):
i += 1
if i > END_POINT:
print('-- ' + folder_name + ' end ...')
break
except Exception as e:
print('\nError : Image generate error !')
print(e)
exit()
def gen_run():
if P_NUM > labels_cnt:
core = labels_cnt
else:
core = P_NUM
try:
p = multiprocessing.Pool(core)
p.map_async(gen, labels).get()
except Exception as e:
print('\nError : Process execution error !')
print(e)
exit()
def check_end():
new_labels = os.listdir(OUTPUT_DIR)
if (labels == new_labels):
print('\nAll images generated !')
else:
error_dir = list(set(labels) - set(new_labels))
print('\nError : Some images were not generated. Please check the Input/Output directory.')
for dir in error_dir:
print(dir)
if __name__ == '__main__':
start_time = time.time()
if (check_start()):
ready_dir()
gen_run()
check_end()
running_time = time.time() - start_time
print('RUNNING TIME : %.2f sec' % running_time)
else:
exit() | [
"dr_moms@naver.com"
] | dr_moms@naver.com |
fc32cea9c83b3dc402ab49fd5e934718e734f48c | 5b221c2809d82cf13a2b24a56589943315cdb381 | /2018/2018-29.py | e953d3c14398aab0d4b63f6a0705c7cf5486abfc | [] | no_license | Bruce-V/CS-BM25 | c2cd797e9be2fc55af9c8944882fd55109ebee61 | 2401f0ddb24c1712b13c0c96e13565f60d48705d | refs/heads/main | 2023-01-04T23:29:20.906427 | 2020-11-09T08:44:22 | 2020-11-09T08:44:22 | 259,228,835 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 10,714 | py | # Copyright 2020 zicheng Zhang(18551701375@163.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import pymongo
import re
from math import log
myclient =pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["pubmed"]
mywords = mydb["freqwords3"] #pubmed中所有的词频、化学词、关键词和主题词表
mytopic=mydb["topics2018"]#pubmed中的主题词相关文献列表
mypapers=mydb["papers"]#pubmed中文献信息表
mytopicdb=myclient["cs2018_29"]
mydata=mytopicdb["cs2018_score_29"]#按词表长度改进过后的2次排序表
mycount = mytopicdb["cs2018_score_29_related"]#聚类后对应与主题相关联的文献
def sortsecond(myfreq,mydata,yuzhi):
k = 0
k1=1.2
k2=1.2
b1=0.75
b2=0.75
idf_esophageal = log((29138919 - 32358 + 0.5) / (32358 + 0.5), 10)
idf_egfr = log((29138919 - 48503 + 0.5) / (48503 + 0.5), 10)
idf_ele_1 = log((13670358 - 0 + 0.5) / (0 + 0.5), 10)
idf_ele_2 = log((13670358 - 0 + 0.5) / (0 + 0.5), 10)
idf_ele_3 = log((13670358 - 37086 + 0.5) / (37086 + 0.5), 10)
idf_ele_4 = log((13670358 - 7893 + 0.5) / (7893 + 0.5), 10)
idf_ele_5 = log((13670358 - 0 + 0.5) / (0 + 0.5), 10)
idf_eleM_1 = log((25389659 - 46906 + 0.5) / (46906 + 0.5), 10)
idf_eleM_2 = log((25389659 - 9290 + 0.5) / (9290+ 0.5), 10)
idf_eleM_3 = log((25389659 - 0 + 0.5) / (0 + 0.5), 10)
idf_eleM_4 = log((25389659 - 0 + 0.5) / (0 + 0.5), 10)
idf_eleM_5 = log((25389659 - 17437618 + 0.5) / (17437618 + 0.5), 10)
idf_eleM_6 = log((25389659 - 8002162 + 0.5) / (8002162 + 0.5), 10)
idf_eleM_7 = log((25389659 - 2842020 + 0.5) / (2842020 + 0.5), 10)
idf_eleM_8 = log((25389659 - 0 + 0.5) / (0 + 0.5), 10)
idf_eleM_9 = log((25389659 - 4785026 + 0.5) / (4785026 + 0.5), 10)
idf_eleK_1 = log((5435471 - 13963 + 0.5) / (13963 + 0.5), 10)
idf_eleK_2 = log((5435471 - 6390 + 0.5) / (6390 + 0.5), 10)
idf_eleK_3 = log((5435471 - 0 + 0.5) / (0 + 0.5), 10)
for x in myfreq.find({}, {'PMID', 'wordfreq', 'ChemicalNameList', 'MeshHeadingNameList', 'KeywordsList'},
no_cursor_timeout=True):
ss1 = 0
ss2 = 0
ss4 = 0
gx = 0
gx1 = 0
gx2 = 0
gx3 = 0
gx4=0
len_freq=0
esophageal_score=0
egfr_score = 0
if int(x['PMID']) <= 27868941:
cop = re.compile("[^\u4e00-\u9fa5^a-z^A-Z^0-9]") # 匹配不是中文、大小写、数字的其他字符
ChemicalNameList = x['ChemicalNameList']
MeshHeadingNameList = x['MeshHeadingNameList']
KeywordsList = x['KeywordsList']
wordfreq = x['wordfreq']
esophageal = [True for x in wordfreq.items() if 'esophageal' in x]
# ---------------摘要统计-------------------#
for key in wordfreq:
len_freq = len_freq + wordfreq[key]
for key in wordfreq:
key1 = cop.sub('', key)
if 'esophageal' in key1:
esophageal_score = esophageal_score + wordfreq[key]
for key in wordfreq:
key1 = cop.sub('', key)
if 'egfr' == key1:
egfr_score = egfr_score + wordfreq[key]
bm25_esophageal_score = (((k1+1)*esophageal_score)/((k1*(b1+(1-b1)*(len_freq/85)))+esophageal_score))
bm25_egfr_score = (((k1 + 1) * egfr_score) / ((k1 * (b1 + (1 - b1) * (len_freq / 85))) + egfr_score))
bm25_ab_score =idf_esophageal*bm25_esophageal_score+idf_egfr*bm25_egfr_score
idf_para=[{str(esophageal_score):idf_esophageal},{str(egfr_score):idf_egfr}]
# ---------------共现分析摘要-------------------#
if len(esophageal) != 0 and esophageal[0]:
for key in wordfreq:
key = cop.sub('', key)
if 'egfr' == key:
gx = idf_egfr
# ---------------共现分析化学-------------------#
if len(esophageal) != 0 and esophageal[0]:
for ele in ChemicalNameList:
if 'EGFR' in ele['NameOfSubstance']:
gx = idf_egfr
break
# ---------------共现分析关键字-------------------#
if len(esophageal) != 0 and esophageal[0]:
for eleK in KeywordsList:
if 'egfr' in str(eleK).lower():
gx = idf_egfr
break
# ---------------共现分析医学主题词-------------------#
if len(esophageal) != 0 and esophageal[0]:
for eleM in MeshHeadingNameList:
if 'EGFR' in eleM['MeshHeadingName']:
gx = idf_egfr
break
for ele in ChemicalNameList:
if 'Esophageal Neoplasms' == ele['NameOfSubstance']:
ss1 = ss1 + idf_ele_1
break
for ele in ChemicalNameList:
if 'Rare Diseases' == ele['NameOfSubstance']:
ss1 = ss1 + idf_ele_2
break
for ele in ChemicalNameList:
if 'ErbB Receptors' == ele['NameOfSubstance']:
ss1 = ss1 + idf_ele_3
break
for ele in ChemicalNameList:
if 'EGFR' == ele['NameOfSubstance']:
ss1 = ss1 + idf_ele_4
break
for eleM in MeshHeadingNameList:
if 'Esophageal Neoplasms' == eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_1
break
for eleM in MeshHeadingNameList:
if 'Rare Diseases' == eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_2
break
for eleM in MeshHeadingNameList:
if 'EGFR' == eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_3
break
for eleM in MeshHeadingNameList:
if 'ErbB Receptors' == eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_4
break
for eleM in MeshHeadingNameList:
if re.findall(r'(Human|Humans)', eleM['MeshHeadingName']):
ss2 = ss2 + idf_eleM_5
break
for eleM in MeshHeadingNameList:
if 'Male' in eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_6
break
for eleM in MeshHeadingNameList:
if 'Aged' == eleM['MeshHeadingName']:
ss2 = ss2 + idf_eleM_7
break
for eleM in MeshHeadingNameList:
if re.findall(r'(Adult|Adults)', eleM['MeshHeadingName']):
ss2 = ss2 + idf_eleM_9
break
for eleK in KeywordsList:
if 'esophageal' in str(eleK).lower():
ss4 = ss4 + idf_eleK_1
break
for eleK in KeywordsList:
if 'egfr' in str(eleK).lower():
ss4 = ss4 + idf_eleK_2
break
total_gx=gx1+gx2+gx3+gx+gx4
cmk_len=len(ChemicalNameList) + len(MeshHeadingNameList) + len(KeywordsList)
bm25_cmk_len=ss1 + ss2 + ss4
bm25_cmk_score = (((k2 + 1) * bm25_cmk_len) / ((k2 * (b2 + (1 - b2) * (cmk_len / 13))) + bm25_cmk_len))
bm25_score=bm25_ab_score+bm25_cmk_score+total_gx
if(bm25_score>yuzhi):
mydict = {"PMID": x['PMID'],"ab_score":bm25_ab_score,"idf_para":idf_para,
"cmk_len":cmk_len,"cmk_freq":bm25_cmk_len,"bm25_cmk_score":bm25_cmk_score,"gx":total_gx,"bm25_score":bm25_score,
"ChemicalNameList":x['ChemicalNameList'],"MeshHeadingNameList":x['MeshHeadingNameList'],"KeywordsList":x['KeywordsList']}
y = mydata.insert_one(mydict)
k=k+1
print(str(y) + '---------' + str(k))
def count(mysort,mycount,topic):
for x in mysort.find({}, {'PMID', 'ab_score','idf_para', 'cmk_len', 'cmk_freq', 'bm25_cmk_score','gx','bm25_score',
'ChemicalNameList', 'MeshHeadingNameList', 'KeywordsList'}):
kk = 0
for y in mytopic.find({"topic": topic}, {'PMID', 'relate'}):
if x['PMID'] == y['PMID']:
mydict = {"PMID": x['PMID'], "related": y['relate'], "ab_score":x["ab_score"],"idf_para":x['idf_para'],
"cmk_len": x['cmk_len'], "cmk_freq": x['cmk_freq'],'bm25_cmk_score':x['bm25_cmk_score'],'gx':x['gx'],
"bm25_score": x['bm25_score'],
"ChemicalNameList": x['ChemicalNameList'], "MeshHeadingNameList": x['MeshHeadingNameList'],
"KeywordsList": x['KeywordsList']}
ss = mycount.insert_one(mydict)
print(ss)
kk = kk + 1
if (kk == 0):
mydict = {"PMID": x['PMID'], "related": -1, "ab_score": x["ab_score"], "idf_para": x['idf_para'],
"cmk_len": x['cmk_len'], "cmk_freq": x['cmk_freq'], 'bm25_cmk_score': x['bm25_cmk_score'],
'gx': x['gx'],
"bm25_score": x['bm25_score'],
"ChemicalNameList": x['ChemicalNameList'], "MeshHeadingNameList": x['MeshHeadingNameList'],
"KeywordsList": x['KeywordsList']}
ss = mycount.insert_one(mydict)
print(ss)
if __name__ == '__main__':
sortsecond(mywords,mydata,7)
count(mydata,mycount,"29")
| [
"1714624946@qq.com"
] | 1714624946@qq.com |
2beb1f616a83a5c13a520bc827faceffac12cedc | 5864e86954a221d52d4fa83a607c71bacf201c5a | /eve/devtools/script/networkdatamonitor.py | ad91d9153d462512bd7775ae06745daf165a0b2d | [] | no_license | connoryang/1v1dec | e9a2303a01e5a26bf14159112b112be81a6560fd | 404f2cebf13b311e754d45206008918881496370 | refs/heads/master | 2021-05-04T02:34:59.627529 | 2016-10-19T08:56:26 | 2016-10-19T08:56:26 | 71,334,417 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,749 | py | #Embedded file name: e:\jenkins\workspace\client_SERENITY\branches\release\SERENITY\eve\devtools\script\networkdatamonitor.py
import operator
import carbonui.const as uiconst
from carbonui.primitives.container import Container
from eve.client.script.ui.control.buttons import Button
from eve.client.script.ui.control.eveLabel import Label
from eve.client.script.ui.control.eveWindow import Window
import log
import uthread2
import util
PROPS = [('Packets out', 'packets_out', 0),
('Packets in', 'packets_in', 0),
('Kilobytes out', 'bytes_out', 1),
('Kilobytes in', 'bytes_in', 1)]
class NetworkDataMonitor(Window):
default_caption = 'Network Data Monitor'
default_windowID = 'networkdatamonitor'
default_minSize = (400, 300)
refreshDelay = 0.5
def ApplyAttributes(self, attributes):
self._ready = False
Window.ApplyAttributes(self, attributes)
self.Reset()
self.SetTopparentHeight(4)
self.settingsContainer = Container(parent=self.sr.main, align=uiconst.TOBOTTOM, height=16, padding=8)
Button(parent=self.settingsContainer, label='Reset', align=uiconst.CENTER, func=self.Reset)
container = Container(parent=self.sr.main, align=uiconst.TOALL, padding=8)
statusHeader = ' '
for tme in self.intvals:
statusHeader += '<t><right>%s' % util.FmtDate(long(tme * 10000), 'ss')
statusHeader += '<t><right>total'
self.statusLabels = []
txt = Label(parent=container, align=uiconst.TOPLEFT, text=statusHeader, tabs=[80,
130,
180,
230,
280,
330,
380], state=uiconst.UI_DISABLED)
for i in xrange(7):
statusLabel = Label(parent=container, text='', top=(i + 1) * txt.height + 1, align=uiconst.TOPLEFT, tabs=[80,
130,
180,
230,
280,
330,
380], state=uiconst.UI_DISABLED)
self.statusLabels.append(statusLabel)
self.PopulateLabels()
uthread2.StartTasklet(self.Refresh)
def Reset(self, *args):
self.intvals = [5000,
10000,
15000,
30000,
60000]
self.counter = [[],
[],
[],
[],
[],
[]]
self.ticker = 0
self.packets_outTotal = 0
self.packets_inTotal = 0
self.bytes_outTotal = 0
self.bytes_inTotal = 0
self.laststats = {}
self.lastresetstats = sm.GetService('machoNet').GetConnectionProperties()
def Refresh(self):
while not self.destroyed:
uthread2.Sleep(self.refreshDelay)
self.PopulateLabels()
def PopulateLabels(self, *args):
self.ticker += self.intvals[0]
if self.ticker > self.intvals[-1]:
self.ticker = self.intvals[0]
stats = sm.GetService('machoNet').GetConnectionProperties()
if self.laststats == {}:
self.laststats = stats
if self.lastresetstats != {}:
for key in stats.iterkeys():
stats[key] = stats[key] - self.lastresetstats[key]
for i in xrange(len(self.counter) - 1):
self.counter[i].append([ stats[key] - self.laststats[key] for header, key, K in PROPS ])
self.counter[i] = self.counter[i][-(self.intvals[i] / 1000):]
self.counter[-1].append([ stats[key] - self.laststats[key] for header, key, K in PROPS ])
if not self.display:
self.laststats = stats
return
valueIdx = 0
for header, key, K in PROPS:
statusstr = '%s' % header
for intvals in self.counter:
value = reduce(operator.add, [ intval[valueIdx] for intval in intvals ], 0)
if not value:
statusstr += '<t><right>-'
else:
statusstr += '<t><right>%s' % [value, '%.1f' % (value / 1024.0)][K]
self.statusLabels[valueIdx].text = statusstr
valueIdx += 1
self.statusLabels[valueIdx].text = 'Outstanding<t><right>%s' % stats['calls_outstanding']
valueIdx += 1
self.statusLabels[valueIdx].text = 'Blocking Calls<t><right>%s' % stats['blocking_calls']
valueIdx += 1
block_time = stats['blocking_call_times']
if block_time >= 0:
secs = util.SecsFromBlueTimeDelta(block_time)
self.statusLabels[valueIdx].text = 'Blocking time<t><right>%sH<t><right>%sM<t><right>%sS' % util.HoursMinsSecsFromSecs(secs)
elif not hasattr(self, 'warnedBlockingTimeNegative'):
self.warnedBlockingTimeNegative = True
log.LogTraceback('Blocking time is negative?')
self.laststats = stats
| [
"le02005@163.com"
] | le02005@163.com |
11297a63b6c776b7bc4dd49d2b1fa0ad4699fc53 | f8d3f814067415485bb439d7fe92dc2bbe22a048 | /models/research/object_detection/models/faster_rcnn_inception_v2_feature_extractor.py | 60e98f2b2ba3619347c6f61da69b7f71c6f59039 | [
"Apache-2.0"
] | permissive | gmonkman/python | 2f9ab8f159c01f6235c86cb0cd52062cd3fdedd3 | 9123aa6baf538b662143b9098d963d55165e8409 | refs/heads/master | 2023-04-09T15:53:29.746676 | 2022-11-26T20:35:21 | 2022-11-26T20:35:21 | 60,254,898 | 0 | 2 | null | 2023-03-24T22:58:39 | 2016-06-02T10:25:27 | Python | UTF-8 | Python | false | false | 12,152 | py | # Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Inception V2 Faster R-CNN implementation.
See "Rethinking the Inception Architecture for Computer Vision"
https://arxiv.org/abs/1512.00567
"""
import tensorflow as tf
from object_detection.meta_architectures import faster_rcnn_meta_arch
from slim.nets import inception_v2
slim = tf.contrib.slim
def _batch_norm_arg_scope(list_ops,
use_batch_norm=True,
batch_norm_decay=0.9997,
batch_norm_epsilon=0.001,
batch_norm_scale=False,
train_batch_norm=False):
"""Slim arg scope for InceptionV2 batch norm."""
if use_batch_norm:
batch_norm_params = {
'is_training': train_batch_norm,
'scale': batch_norm_scale,
'decay': batch_norm_decay,
'epsilon': batch_norm_epsilon
}
normalizer_fn = slim.batch_norm
else:
normalizer_fn = None
batch_norm_params = None
return slim.arg_scope(list_ops,
normalizer_fn=normalizer_fn,
normalizer_params=batch_norm_params)
class FasterRCNNInceptionV2FeatureExtractor(
faster_rcnn_meta_arch.FasterRCNNFeatureExtractor):
"""Faster R-CNN Inception V2 feature extractor implementation."""
def __init__(self,
is_training,
first_stage_features_stride,
batch_norm_trainable=False,
reuse_weights=None,
weight_decay=0.0,
depth_multiplier=1.0,
min_depth=16):
"""Constructor.
Args:
is_training: See base class.
first_stage_features_stride: See base class.
batch_norm_trainable: See base class.
reuse_weights: See base class.
weight_decay: See base class.
depth_multiplier: float depth multiplier for feature extractor.
min_depth: minimum feature extractor depth.
Raises:
ValueError: If `first_stage_features_stride` is not 8 or 16.
"""
if first_stage_features_stride != 8 and first_stage_features_stride != 16:
raise ValueError('`first_stage_features_stride` must be 8 or 16.')
self._depth_multiplier = depth_multiplier
self._min_depth = min_depth
super(FasterRCNNInceptionV2FeatureExtractor, self).__init__(
is_training, first_stage_features_stride, batch_norm_trainable,
reuse_weights, weight_decay)
def preprocess(self, resized_inputs):
"""Faster R-CNN Inception V2 preprocessing.
Maps pixel values to the range [-1, 1].
Args:
resized_inputs: a [batch, height, width, channels] float tensor
representing a batch of images.
Returns:
preprocessed_inputs: a [batch, height, width, channels] float tensor
representing a batch of images.
"""
return (2.0 / 255.0) * resized_inputs - 1.0
def _extract_proposal_features(self, preprocessed_inputs, scope):
"""Extracts first stage RPN features.
Args:
preprocessed_inputs: A [batch, height, width, channels] float32 tensor
representing a batch of images.
scope: A scope name.
Returns:
rpn_feature_map: A tensor with shape [batch, height, width, depth]
activations: A dictionary mapping feature extractor tensor names to
tensors
Raises:
InvalidArgumentError: If the spatial size of `preprocessed_inputs`
(height or width) is less than 33.
ValueError: If the created network is missing the required activation.
"""
preprocessed_inputs.get_shape().assert_has_rank(4)
shape_assert = tf.Assert(
tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),
tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),
['image size must at least be 33 in both height and width.'])
with tf.control_dependencies([shape_assert]):
with tf.variable_scope('InceptionV2',
reuse=self._reuse_weights) as scope:
with _batch_norm_arg_scope([slim.conv2d, slim.separable_conv2d],
batch_norm_scale=True,
train_batch_norm=self._train_batch_norm):
_, activations = inception_v2.inception_v2_base(
preprocessed_inputs,
final_endpoint='Mixed_4e',
min_depth=self._min_depth,
depth_multiplier=self._depth_multiplier,
scope=scope)
return activations['Mixed_4e'], activations
def _extract_box_classifier_features(self, proposal_feature_maps, scope):
"""Extracts second stage box classifier features.
Args:
proposal_feature_maps: A 4-D float tensor with shape
[batch_size * self.max_num_proposals, crop_height, crop_width, depth]
representing the feature map cropped to each proposal.
scope: A scope name (unused).
Returns:
proposal_classifier_features: A 4-D float tensor with shape
[batch_size * self.max_num_proposals, height, width, depth]
representing box classifier features for each proposal.
"""
net = proposal_feature_maps
depth = lambda d: max(int(d * self._depth_multiplier), self._min_depth)
trunc_normal = lambda stddev: tf.truncated_normal_initializer(0.0, stddev)
data_format = 'NHWC'
concat_dim = 3 if data_format == 'NHWC' else 1
with tf.variable_scope('InceptionV2', reuse=self._reuse_weights):
with slim.arg_scope(
[slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding='SAME',
data_format=data_format):
with _batch_norm_arg_scope([slim.conv2d, slim.separable_conv2d],
batch_norm_scale=True,
train_batch_norm=self._train_batch_norm):
with tf.variable_scope('Mixed_5a'):
with tf.variable_scope('Branch_0'):
branch_0 = slim.conv2d(
net, depth(128), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_0 = slim.conv2d(branch_0, depth(192), [3, 3], stride=2,
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_1'):
branch_1 = slim.conv2d(
net, depth(192), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_1 = slim.conv2d(branch_1, depth(256), [3, 3],
scope='Conv2d_0b_3x3')
branch_1 = slim.conv2d(branch_1, depth(256), [3, 3], stride=2,
scope='Conv2d_1a_3x3')
with tf.variable_scope('Branch_2'):
branch_2 = slim.max_pool2d(net, [3, 3], stride=2,
scope='MaxPool_1a_3x3')
net = tf.concat([branch_0, branch_1, branch_2], concat_dim)
with tf.variable_scope('Mixed_5b'):
with tf.variable_scope('Branch_0'):
branch_0 = slim.conv2d(net, depth(352), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = slim.conv2d(
net, depth(192), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_1 = slim.conv2d(branch_1, depth(320), [3, 3],
scope='Conv2d_0b_3x3')
with tf.variable_scope('Branch_2'):
branch_2 = slim.conv2d(
net, depth(160), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
scope='Conv2d_0c_3x3')
with tf.variable_scope('Branch_3'):
branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
branch_3 = slim.conv2d(
branch_3, depth(128), [1, 1],
weights_initializer=trunc_normal(0.1),
scope='Conv2d_0b_1x1')
net = tf.concat([branch_0, branch_1, branch_2, branch_3],
concat_dim)
with tf.variable_scope('Mixed_5c'):
with tf.variable_scope('Branch_0'):
branch_0 = slim.conv2d(net, depth(352), [1, 1],
scope='Conv2d_0a_1x1')
with tf.variable_scope('Branch_1'):
branch_1 = slim.conv2d(
net, depth(192), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_1 = slim.conv2d(branch_1, depth(320), [3, 3],
scope='Conv2d_0b_3x3')
with tf.variable_scope('Branch_2'):
branch_2 = slim.conv2d(
net, depth(192), [1, 1],
weights_initializer=trunc_normal(0.09),
scope='Conv2d_0a_1x1')
branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
scope='Conv2d_0b_3x3')
branch_2 = slim.conv2d(branch_2, depth(224), [3, 3],
scope='Conv2d_0c_3x3')
with tf.variable_scope('Branch_3'):
branch_3 = slim.max_pool2d(net, [3, 3], scope='MaxPool_0a_3x3')
branch_3 = slim.conv2d(
branch_3, depth(128), [1, 1],
weights_initializer=trunc_normal(0.1),
scope='Conv2d_0b_1x1')
proposal_classifier_features = tf.concat(
[branch_0, branch_1, branch_2, branch_3], concat_dim)
return proposal_classifier_features
| [
"gmonkman@mistymountains.biz"
] | gmonkman@mistymountains.biz |
1c82c00eb253b8915ab1485ac5635af15f024a5a | 87b101f5a3828671a454f15798c9fc2bc28abbc1 | /master/admin.py | 7807aae8ee9fc75d5176cc273bac768d68793f9b | [] | no_license | RupeshKurlekar/biocare | 6f5bcdf3647b3f865ba6a1473355a7eef04d6ff5 | b63849983a592fd6a1f654191020fd86aa0787ae | refs/heads/master | 2023-05-11T00:18:40.384397 | 2021-06-04T05:28:32 | 2021-06-04T05:28:32 | 370,355,502 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 307 | py | from django.contrib import admin
from .models import TicketStatus, ReportStatus, Priority, BodyPart, BodyPartView
# Register your models here.
admin.site.register(ReportStatus)
admin.site.register(TicketStatus)
admin.site.register(Priority)
admin.site.register(BodyPart)
admin.site.register(BodyPartView)
| [
"rupeshkurlekar07@gmail.com"
] | rupeshkurlekar07@gmail.com |
3e3fa24bb242e68bd2148c3982eaedf610738f1e | 8fa938eddcc75eb7dff1f2055c49cb3817a00c63 | /Basic - Part1/ex124.py | a5b7b3c3bf10bb3195275eca92ec3fbbf51c9665 | [] | no_license | jayhebe/w3resource_exercises | f27109759d112b0611574aa70eb378ace447c2a0 | b29aa7c806f6021a8988e83bb9f674522a41380d | refs/heads/master | 2020-05-07T09:23:24.039271 | 2020-01-30T15:05:06 | 2020-01-30T15:05:06 | 180,374,062 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 78 | py | x = 1
y = 1
z = 1
if x == y == z:
print("All variables have same value!")
| [
"jayhebe1983@sina.com"
] | jayhebe1983@sina.com |
27df6e067a907b38a2c32693caec733f6b0dc418 | 1f2d35ad6c85608900594bd095326e3d9ad0bdcf | /thirdWeek/process/p4_advfork.py | bdcebc146384015f8edbae3789d30183b016c677 | [] | no_license | xk-coco/geekbangtrain | ca4289076d140a12a7c14087d636f3a380cdf378 | eac3c5bb7081f78f27a00f8bead52108b9d11795 | refs/heads/master | 2022-12-24T22:00:51.964289 | 2020-10-09T05:26:50 | 2020-10-09T05:26:50 | 282,388,292 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 401 | py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/8/12 8:10
# @File : p4_advfork.py
from multiprocessing import Process
import time
import os
def run():
print("子进程开启")
time.sleep(2)
print("子进程结束")
if __name__ == '__main__':
print("父进程开启")
p = Process(target=run)
p.start()
p.join() # 阻塞
print("父进程结束")
| [
"xk1990coco@163.com"
] | xk1990coco@163.com |
14fefeb4b1f6be741c57dca2aa5f3de8935fd767 | f092a66d502719a7c725fb2fbc0c59af69e304d5 | /heat/common/client.py | 5a63f3e288fd3c1fc6ae79f82f91269231aaa765 | [
"Apache-2.0"
] | permissive | blomquisg/heat | 371fbd84d9ef385baadb4f63c67e204dc16afd3e | fc413d93278706cc8e62f3033fdaf4815fc32784 | refs/heads/master | 2021-01-25T10:06:29.931419 | 2012-03-14T02:02:53 | 2012-03-14T02:02:53 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 21,833 | py | # vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2010-2011 OpenStack, LLC
# All Rights Reserved.
#
# 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.
# HTTPSClientAuthConnection code comes courtesy of ActiveState website:
# http://code.activestate.com/recipes/
# 577548-https-httplib-client-connection-with-certificate-v/
import collections
import errno
import functools
import httplib
import logging
import os
import urllib
import urlparse
try:
from eventlet.green import socket, ssl
except ImportError:
import socket
import ssl
try:
import sendfile
SENDFILE_SUPPORTED = True
except ImportError:
SENDFILE_SUPPORTED = False
from heat.common import auth
from heat.common import exception, utils
# common chunk size for get and put
CHUNKSIZE = 65536
def handle_unauthorized(func):
"""
Wrap a function to re-authenticate and retry.
"""
@functools.wraps(func)
def wrapped(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except exception.NotAuthorized:
self._authenticate(force_reauth=True)
return func(self, *args, **kwargs)
return wrapped
def handle_redirects(func):
"""
Wrap the _do_request function to handle HTTP redirects.
"""
MAX_REDIRECTS = 5
@functools.wraps(func)
def wrapped(self, method, url, body, headers):
for _ in xrange(MAX_REDIRECTS):
try:
return func(self, method, url, body, headers)
except exception.RedirectException as redirect:
if redirect.url is None:
raise exception.InvalidRedirect()
url = redirect.url
raise exception.MaxRedirectsExceeded(redirects=MAX_REDIRECTS)
return wrapped
class ImageBodyIterator(object):
"""
A class that acts as an iterator over an image file's
chunks of data. This is returned as part of the result
tuple from `heat.client.Client.get_image`
"""
def __init__(self, source):
"""
Constructs the object from a readable image source
(such as an HTTPResponse or file-like object)
"""
self.source = source
def __iter__(self):
"""
Exposes an iterator over the chunks of data in the
image file.
"""
while True:
chunk = self.source.read(CHUNKSIZE)
if chunk:
yield chunk
else:
break
class SendFileIterator:
"""
Emulate iterator pattern over sendfile, in order to allow
send progress be followed by wrapping the iteration.
"""
def __init__(self, connection, body):
self.connection = connection
self.body = body
self.offset = 0
self.sending = True
def __iter__(self):
class OfLength:
def __init__(self, len):
self.len = len
def __len__(self):
return self.len
while self.sending:
sent = sendfile.sendfile(self.connection.sock.fileno(),
self.body.fileno(),
self.offset,
CHUNKSIZE)
self.sending = (sent != 0)
self.offset += sent
yield OfLength(sent)
class HTTPSClientAuthConnection(httplib.HTTPSConnection):
"""
Class to make a HTTPS connection, with support for
full client-based SSL Authentication
:see http://code.activestate.com/recipes/
577548-https-httplib-client-connection-with-certificate-v/
"""
def __init__(self, host, port, key_file, cert_file,
ca_file, timeout=None, insecure=False):
httplib.HTTPSConnection.__init__(self, host, port, key_file=key_file,
cert_file=cert_file)
self.key_file = key_file
self.cert_file = cert_file
self.ca_file = ca_file
self.timeout = timeout
self.insecure = insecure
def connect(self):
"""
Connect to a host on a given (SSL) port.
If ca_file is pointing somewhere, use it to check Server Certificate.
Redefined/copied and extended from httplib.py:1105 (Python 2.6.x).
This is needed to pass cert_reqs=ssl.CERT_REQUIRED as parameter to
ssl.wrap_socket(), which forces SSL to check server certificate against
our client certificate.
"""
sock = socket.create_connection((self.host, self.port), self.timeout)
if self._tunnel_host:
self.sock = sock
self._tunnel()
# Check CA file unless 'insecure' is specificed
if self.insecure is True:
self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
cert_reqs=ssl.CERT_NONE)
else:
self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
ca_certs=self.ca_file,
cert_reqs=ssl.CERT_REQUIRED)
class BaseClient(object):
"""A base client class"""
DEFAULT_PORT = 80
DEFAULT_DOC_ROOT = None
# Standard CA file locations for Debian/Ubuntu, RedHat/Fedora,
# Suse, FreeBSD/OpenBSD
DEFAULT_CA_FILE_PATH = '/etc/ssl/certs/ca-certificates.crt:'\
'/etc/pki/tls/certs/ca-bundle.crt:'\
'/etc/ssl/ca-bundle.pem:'\
'/etc/ssl/cert.pem'
OK_RESPONSE_CODES = (
httplib.OK,
httplib.CREATED,
httplib.ACCEPTED,
httplib.NO_CONTENT,
)
REDIRECT_RESPONSE_CODES = (
httplib.MOVED_PERMANENTLY,
httplib.FOUND,
httplib.SEE_OTHER,
httplib.USE_PROXY,
httplib.TEMPORARY_REDIRECT,
)
def __init__(self, host, port=None, use_ssl=False, auth_tok=None,
creds=None, doc_root=None, key_file=None,
cert_file=None, ca_file=None, insecure=False,
configure_via_auth=True):
"""
Creates a new client to some service.
:param host: The host where service resides
:param port: The port where service resides
:param use_ssl: Should we use HTTPS?
:param auth_tok: The auth token to pass to the server
:param creds: The credentials to pass to the auth plugin
:param doc_root: Prefix for all URLs we request from host
:param key_file: Optional PEM-formatted file that contains the private
key.
If use_ssl is True, and this param is None (the
default), then an environ variable
heat_CLIENT_KEY_FILE is looked for. If no such
environ variable is found, ClientConnectionError
will be raised.
:param cert_file: Optional PEM-formatted certificate chain file.
If use_ssl is True, and this param is None (the
default), then an environ variable
heat_CLIENT_CERT_FILE is looked for. If no such
environ variable is found, ClientConnectionError
will be raised.
:param ca_file: Optional CA cert file to use in SSL connections
If use_ssl is True, and this param is None (the
default), then an environ variable
heat_CLIENT_CA_FILE is looked for.
:param insecure: Optional. If set then the server's certificate
will not be verified.
"""
self.host = host
self.port = port or self.DEFAULT_PORT
self.use_ssl = use_ssl
self.auth_tok = auth_tok
self.creds = creds or {}
self.connection = None
self.configure_via_auth = configure_via_auth
# doc_root can be a nullstring, which is valid, and why we
# cannot simply do doc_root or self.DEFAULT_DOC_ROOT below.
self.doc_root = (doc_root if doc_root is not None
else self.DEFAULT_DOC_ROOT)
self.auth_plugin = self.make_auth_plugin(self.creds)
self.key_file = key_file
self.cert_file = cert_file
self.ca_file = ca_file
self.insecure = insecure
self.connect_kwargs = self.get_connect_kwargs()
def get_connect_kwargs(self):
connect_kwargs = {}
if self.use_ssl:
if self.key_file is None:
self.key_file = os.environ.get('heat_CLIENT_KEY_FILE')
if self.cert_file is None:
self.cert_file = os.environ.get('heat_CLIENT_CERT_FILE')
if self.ca_file is None:
self.ca_file = os.environ.get('heat_CLIENT_CA_FILE')
# Check that key_file/cert_file are either both set or both unset
if self.cert_file is not None and self.key_file is None:
msg = _("You have selected to use SSL in connecting, "
"and you have supplied a cert, "
"however you have failed to supply either a "
"key_file parameter or set the "
"heat_CLIENT_KEY_FILE environ variable")
raise exception.ClientConnectionError(msg)
if self.key_file is not None and self.cert_file is None:
msg = _("You have selected to use SSL in connecting, "
"and you have supplied a key, "
"however you have failed to supply either a "
"cert_file parameter or set the "
"heat_CLIENT_CERT_FILE environ variable")
raise exception.ClientConnectionError(msg)
if (self.key_file is not None and
not os.path.exists(self.key_file)):
msg = _("The key file you specified %s does not "
"exist") % self.key_file
raise exception.ClientConnectionError(msg)
connect_kwargs['key_file'] = self.key_file
if (self.cert_file is not None and
not os.path.exists(self.cert_file)):
msg = _("The cert file you specified %s does not "
"exist") % self.cert_file
raise exception.ClientConnectionError(msg)
connect_kwargs['cert_file'] = self.cert_file
if (self.ca_file is not None and
not os.path.exists(self.ca_file)):
msg = _("The CA file you specified %s does not "
"exist") % self.ca_file
raise exception.ClientConnectionError(msg)
if self.ca_file is None:
for ca in self.DEFAULT_CA_FILE_PATH.split(":"):
if os.path.exists(ca):
self.ca_file = ca
break
connect_kwargs['ca_file'] = self.ca_file
connect_kwargs['insecure'] = self.insecure
return connect_kwargs
def set_auth_token(self, auth_tok):
"""
Updates the authentication token for this client connection.
"""
# FIXME(sirp): Nova image/heat.py currently calls this. Since this
# method isn't really doing anything useful[1], we should go ahead and
# rip it out, first in Nova, then here. Steps:
#
# 1. Change auth_tok in heat to auth_token
# 2. Change image/heat.py in Nova to use client.auth_token
# 3. Remove this method
#
# [1] http://mail.python.org/pipermail/tutor/2003-October/025932.html
self.auth_tok = auth_tok
def configure_from_url(self, url):
"""
Setups the connection based on the given url.
The form is:
<http|https>://<host>:port/doc_root
"""
parsed = urlparse.urlparse(url)
self.use_ssl = parsed.scheme == 'https'
self.host = parsed.hostname
self.port = parsed.port or 80
self.doc_root = parsed.path
# ensure connection kwargs are re-evaluated after the service catalog
# publicURL is parsed for potential SSL usage
self.connect_kwargs = self.get_connect_kwargs()
def make_auth_plugin(self, creds):
"""
Returns an instantiated authentication plugin.
"""
strategy = creds.get('strategy', 'noauth')
plugin = auth.get_plugin_from_strategy(strategy, creds)
return plugin
def get_connection_type(self):
"""
Returns the proper connection type
"""
if self.use_ssl:
return HTTPSClientAuthConnection
else:
return httplib.HTTPConnection
def _authenticate(self, force_reauth=False):
"""
Use the authentication plugin to authenticate and set the auth token.
:param force_reauth: For re-authentication to bypass cache.
"""
auth_plugin = self.auth_plugin
if not auth_plugin.is_authenticated or force_reauth:
auth_plugin.authenticate()
self.auth_tok = auth_plugin.auth_token
management_url = auth_plugin.management_url
if management_url and self.configure_via_auth:
self.configure_from_url(management_url)
@handle_unauthorized
def do_request(self, method, action, body=None, headers=None,
params=None):
"""
Make a request, returning an HTTP response object.
:param method: HTTP verb (GET, POST, PUT, etc.)
:param action: Requested path to append to self.doc_root
:param body: Data to send in the body of the request
:param headers: Headers to send with the request
:param params: Key/value pairs to use in query string
:returns: HTTP response object
"""
if not self.auth_tok:
self._authenticate()
url = self._construct_url(action, params)
return self._do_request(method=method, url=url, body=body,
headers=headers)
def _construct_url(self, action, params=None):
"""
Create a URL object we can use to pass to _do_request().
"""
path = '/'.join([self.doc_root or '', action.lstrip('/')])
scheme = "https" if self.use_ssl else "http"
netloc = "%s:%d" % (self.host, self.port)
if isinstance(params, dict):
for (key, value) in params.items():
if value is None:
del params[key]
query = urllib.urlencode(params)
else:
query = None
return urlparse.ParseResult(scheme, netloc, path, '', query, '')
@handle_redirects
def _do_request(self, method, url, body, headers):
"""
Connects to the server and issues a request. Handles converting
any returned HTTP error status codes to OpenStack/heat exceptions
and closing the server connection. Returns the result data, or
raises an appropriate exception.
:param method: HTTP method ("GET", "POST", "PUT", etc...)
:param url: urlparse.ParsedResult object with URL information
:param body: data to send (as string, filelike or iterable),
or None (default)
:param headers: mapping of key/value pairs to add as headers
:note
If the body param has a read attribute, and method is either
POST or PUT, this method will automatically conduct a chunked-transfer
encoding and use the body as a file object or iterable, transferring
chunks of data using the connection's send() method. This allows large
objects to be transferred efficiently without buffering the entire
body in memory.
"""
if url.query:
path = url.path + "?" + url.query
else:
path = url.path
try:
connection_type = self.get_connection_type()
headers = headers or {}
if 'x-auth-token' not in headers and self.auth_tok:
headers['x-auth-token'] = self.auth_tok
c = connection_type(url.hostname, url.port, **self.connect_kwargs)
def _pushing(method):
return method.lower() in ('post', 'put')
def _simple(body):
return body is None or isinstance(body, basestring)
def _filelike(body):
return hasattr(body, 'read')
def _sendbody(connection, iter):
connection.endheaders()
for sent in iter:
# iterator has done the heavy lifting
pass
def _chunkbody(connection, iter):
connection.putheader('Transfer-Encoding', 'chunked')
connection.endheaders()
for chunk in iter:
connection.send('%x\r\n%s\r\n' % (len(chunk), chunk))
connection.send('0\r\n\r\n')
# Do a simple request or a chunked request, depending
# on whether the body param is file-like or iterable and
# the method is PUT or POST
#
if not _pushing(method) or _simple(body):
# Simple request...
c.request(method, path, body, headers)
elif _filelike(body) or self._iterable(body):
c.putrequest(method, path)
for header, value in headers.items():
c.putheader(header, value)
iter = self.image_iterator(c, headers, body)
if self._sendable(body):
# send actual file without copying into userspace
_sendbody(c, iter)
else:
# otherwise iterate and chunk
_chunkbody(c, iter)
else:
raise TypeError('Unsupported image type: %s' % body.__class__)
res = c.getresponse()
status_code = self.get_status_code(res)
if status_code in self.OK_RESPONSE_CODES:
return res
elif status_code in self.REDIRECT_RESPONSE_CODES:
raise exception.RedirectException(res.getheader('Location'))
elif status_code == httplib.UNAUTHORIZED:
raise exception.NotAuthorized(res.read())
elif status_code == httplib.FORBIDDEN:
raise exception.NotAuthorized(res.read())
elif status_code == httplib.NOT_FOUND:
raise exception.NotFound(res.read())
elif status_code == httplib.CONFLICT:
raise exception.Duplicate(res.read())
elif status_code == httplib.BAD_REQUEST:
raise exception.Invalid(res.read())
elif status_code == httplib.MULTIPLE_CHOICES:
raise exception.MultipleChoices(body=res.read())
elif status_code == httplib.INTERNAL_SERVER_ERROR:
raise Exception("Internal Server error: %s" % res.read())
else:
raise Exception("Unknown error occurred! %s" % res.read())
except (socket.error, IOError), e:
raise exception.ClientConnectionError(e)
def _seekable(self, body):
# pipes are not seekable, avoids sendfile() failure on e.g.
# cat /path/to/image | heat add ...
# or where add command is launched via popen
try:
os.lseek(body.fileno(), 0, os.SEEK_SET)
return True
except OSError as e:
return (e.errno != errno.ESPIPE)
def _sendable(self, body):
return (SENDFILE_SUPPORTED and
hasattr(body, 'fileno') and
self._seekable(body) and
not self.use_ssl)
def _iterable(self, body):
return isinstance(body, collections.Iterable)
def image_iterator(self, connection, headers, body):
if self._sendable(body):
return SendFileIterator(connection, body)
elif self._iterable(body):
return utils.chunkreadable(body)
else:
return ImageBodyIterator(body)
def get_status_code(self, response):
"""
Returns the integer status code from the response, which
can be either a Webob.Response (used in testing) or httplib.Response
"""
if hasattr(response, 'status_int'):
return response.status_int
else:
return response.status
def _extract_params(self, actual_params, allowed_params):
"""
Extract a subset of keys from a dictionary. The filters key
will also be extracted, and each of its values will be returned
as an individual param.
:param actual_params: dict of keys to filter
:param allowed_params: list of keys that 'actual_params' will be
reduced to
:retval subset of 'params' dict
"""
result = {}
for param in actual_params:
if param in allowed_params:
result[param] = actual_params[param]
elif 'Parameters.member.' in param:
result[param] = actual_params[param]
return result
| [
"asalkeld@redhat.com"
] | asalkeld@redhat.com |
3b5330ea0aa6a4a8d96e5804f4c85d8878f67ed5 | d5440edcfc66496937e98c557ab9c33946234808 | /lifting line theory basic.py | 750e9c9edd03ecebdd25e481ebf6dc7a98950762 | [] | no_license | geoffreynyaga/lifting-line-theory | 4df7fb1baca79b9e3dfb19f5ec6c4ba86fa8fe69 | 352e1379863adf25c5f3e4966e16ae67d38f97ba | refs/heads/master | 2022-08-30T04:18:23.725361 | 2020-02-14T18:55:28 | 2020-02-14T18:55:28 | 99,334,542 | 2 | 0 | null | 2022-06-22T01:09:44 | 2017-08-04T10:58:33 | Python | UTF-8 | Python | false | false | 2,355 | py | # coding: utf-8
__author__ = "Geoffrey Nyaga"
import numpy as np # type: ignore
import math
import matplotlib.pylab as plt # type: ignore
N: int = 9 # (number of segments - 1)
S: float = 24.39 # wing area m^2
AR: float = 7.8 # Aspect ratio
taper: float = 0.45 # Taper ratio
alpha_twist: float = -2.0 # Twist angle (deg)
i_w: float = 1.0 # wing setting angle (deg)
a_2d: float = 6.8754 # lift curve slope (1/rad)
alpha_0: float = -4.2 # zero-lift angle of attack (deg)
b = math.sqrt(AR * S) # wing span (m)
MAC = S / b # Mean Aerodynamic Chord (m)
Croot = (1.5 * (1 + taper) * MAC) / (1 + taper + taper ** 2) # root chord (m)
# theta = np.arange(math.pi/(2*N), math.pi/2, math.pi/(2*(N)))
theta = np.linspace((math.pi / (2 * N)), (math.pi / 2), N, endpoint=True)
# alpha =np.arange(i_w+alpha_twist,i_w ,-alpha_twist/(N))
alpha = np.linspace(i_w + alpha_twist, i_w, N)
z = (b / 2) * np.cos(theta)
c = Croot * (1 - (1 - taper) * np.cos(theta)) # Mean Aerodynamics
mu = c * a_2d / (4 * b)
LHS = mu * (np.array(alpha) - alpha_0) / 57.3 # .reshape((N-1),1)# Left Hand Side
RHS = []
for i in range(1, 2 * N + 1, 2):
RHS_iter = np.sin(i * theta) * (
1 + (mu * i) / (np.sin(list(theta)))
) # .reshape(1,N)
# print(RHS_iter,"RHS_iter shape")
RHS.append(RHS_iter)
test = np.asarray(RHS)
x = np.transpose(test)
inv_RHS = np.linalg.inv(x)
ans = np.matmul(inv_RHS, LHS)
mynum = np.divide((4 * b), c)
test = (np.sin((1) * theta)) * ans[0] * mynum
test1 = (np.sin((3) * theta)) * ans[1] * mynum
test2 = (np.sin((5) * theta)) * ans[2] * mynum
test3 = (np.sin((7) * theta)) * ans[3] * mynum
test4 = (np.sin((9) * theta)) * ans[4] * mynum
test5 = (np.sin((11) * theta)) * ans[5] * mynum
test6 = (np.sin((13) * theta)) * ans[6] * mynum
test7 = (np.sin((15) * theta)) * ans[7] * mynum
test8 = (np.sin((17) * theta)) * ans[8] * mynum
CL = test + test1 + test2 + test3 + test4 + test5 + test6 + test7 + test8
CL1 = np.append(0, CL)
y_s = [b / 2, z[0], z[1], z[2], z[3], z[4], z[5], z[6], z[7], z[8]]
plt.plot(y_s, CL1, marker="o")
plt.title("Lifting Line Theory\n Elliptical Lift distribution")
plt.xlabel("Semi-span location (m)")
plt.ylabel("Lift coefficient")
plt.grid()
plt.show()
CL_wing = (
math.pi * AR * ans[0]
) # USE THIS CL WITH CRUISE SPEED TO CALCULATE THE ACCURATE LIFT!!!!!!!!!!
print(CL_wing, "CL_wing")
| [
"geoffreynyagak@gmail.com"
] | geoffreynyagak@gmail.com |
ff54639667d43e2a8ef0b80917c081381a5370b5 | 5471de6fd11cc36e8ad9c05ea25d13ae568ad060 | /ClassesAndInstances/Lab Vet.py | 0661e0116a2ab4a17184311b5b09a71a094a3404 | [] | no_license | olgayordanova/PythonOOP | 75bbf9a20c612be7212de7bed59edccef1e02304 | 2d177d17bf50335b17f6246198b1cf85719de1df | refs/heads/main | 2023-03-30T18:59:56.751037 | 2021-04-03T19:48:37 | 2021-04-03T19:48:37 | 333,202,583 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,327 | py | class Vet:
animals =[]
space =5
def __init__(self, name):
self.name =name
self.animals = []
def register_animal(self,animal_name):
if len(Vet.animals)<Vet.space:
self.animals.append(animal_name)
Vet.animals.append ( animal_name )
return f"{animal_name} registered in the clinic"
else:
return f"Not enough space"
def unregister_animal(self, animal_name):
if animal_name in self.animals:
self.animals.remove ( animal_name )
Vet.animals.remove ( animal_name )
return f"{animal_name} unregistered successfully"
else:
return f"{animal_name} not in the clinic"
def info(self):
return f"{self.name} has {len(self.animals)} animals. {Vet.space-len(Vet.animals)} space left in clinic"
peter = Vet("Peter")
george = Vet("George")
print(peter.register_animal("Tom"))
print(george.register_animal("Cory"))
print(peter.register_animal("Fishy"))
print(peter.register_animal("Bobby"))
print(george.register_animal("Kay"))
print(george.unregister_animal("Cory"))
print(peter.register_animal("Silky"))
print(peter.unregister_animal("Molly"))
print(peter.unregister_animal("Tom"))
print(peter.info())
print(george.info())
| [
"noreply@github.com"
] | olgayordanova.noreply@github.com |
b64de9e7ecf43d9d88891e76c90bb9beb1989549 | 09ef17b5787d4560f202d25051dd2ee96cc0a28e | /preprocessing/generate_black_and_white_images.py | 12ac8fe858b1345462dc599495bc6bb650de409e | [] | no_license | brown532/Deep-Learning-Project-2 | 528b4ea9d949143b03db8a75114aa13b471efdb5 | a3a6ee75cf0352016beaace603d91ae99c8b3c91 | refs/heads/main | 2023-03-31T14:10:41.652632 | 2021-04-09T08:46:07 | 2021-04-09T08:46:07 | 345,087,135 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 545 | py | import numpy as np
x = np.load('Flickr30k.npy')
from PIL import Image
from matplotlib import pyplot as plt
new_image=0
element=0
totall = len(x)
b_w_images=[]
for indx,x_ in enumerate(x):
if (indx % 200) == 0:
print(str(indx)+" of "+str(totall))
new_image = Image.fromarray(np.uint8(x_*255),'RGB').convert('L')
new_image = np.asarray(new_image)/255
b_w_images.append(new_image)
b_w_images = np.asarray(b_w_images)
b_w_images = np.expand_dims(b_w_images,axis=-1)
np.save("Flickr30kblackandwhite1dim",b_w_images) | [
"brownyogum@gmail.com"
] | brownyogum@gmail.com |
7aa02b00c8bf10e109efcb424771f2067151bbb1 | 8b105075a8283a2643d53639f8b562f4ff7fe00b | /lista_ex5.2.py/exercicio2.py | 97b153690b0b24d4af16057526594d4031c71984 | [] | no_license | robinson-85/mentoria_exercises | 38733ddd03b9a683ec8051f6346f8e411088b2b8 | 52c4a024e692814427cf85498a68911c32d1be2a | refs/heads/main | 2023-01-20T22:36:55.856957 | 2020-11-28T19:57:11 | 2020-11-28T19:57:11 | 305,476,011 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 177 | py | ''' 2. Escreva um programa que exiba na tela a quantidade de números ímpares
existentes entre dois números que o usuário digitar (testar inclusive os números
digitados).''' | [
"robinpaulista@yahoo.com.br"
] | robinpaulista@yahoo.com.br |
b8728bf275bb2ca91a768945aac95810d2f474eb | 55647a80c8b412af9df0ba3f50595cc2f29c25e6 | /res/scripts/client/gui/shared/gui_items/dossier/achievements/Achieved.py | abf5a6ed09d5c5dab3a8ed8390af41b1ca9fb8d5 | [] | no_license | cnsuhao/WOT-0.9.17-CT | 0035eb6070fb4fab8d8ee9f8bbc676c10d511cfb | d1f932d8cabaf8aa21708622e87f83c8d24d6451 | refs/heads/master | 2021-06-08T18:11:07.039293 | 2016-11-19T19:12:37 | 2016-11-19T19:12:37 | null | 0 | 0 | null | null | null | null | WINDOWS-1250 | Python | false | false | 668 | py | # 2016.11.19 19:52:48 Střední Evropa (běžný čas)
# Embedded file name: scripts/client/gui/shared/gui_items/dossier/achievements/Achieved.py
from abstract import RegularAchievement
from gui.shared.gui_items.dossier.achievements import validators
class Achieved(RegularAchievement):
@classmethod
def checkIsValid(cls, block, name, dossier):
return validators.alreadyAchieved(cls, name, block, dossier)
# okay decompyling c:\Users\PC\wotsources\files\originals\res\scripts\client\gui\shared\gui_items\dossier\achievements\Achieved.pyc
# decompiled 1 files: 1 okay, 0 failed, 0 verify failed
# 2016.11.19 19:52:48 Střední Evropa (běžný čas)
| [
"info@webium.sk"
] | info@webium.sk |
495e16465ad10c57be4aaff3c8331f108c5e50b0 | 52aaf4b050cf9ea9866521e10b1fdfd5a3a72060 | /Spot.py | 65bd5e08e35405cef2da3737685eec44657e9941 | [] | no_license | MatthewR2D2/PythonAIPathViz | 2860e36992872532577386f2d2a779d018bd649f | 24092eb259aa49a6b46d3b3d5041e7baf0a5b63b | refs/heads/master | 2022-07-18T15:36:04.678530 | 2020-05-20T01:11:24 | 2020-05-20T01:11:24 | 265,399,128 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,310 | py | import pygame
class spot:
def __init__(self, x, y, screen, row, cols, w, h):
self.i = x
self.j = y
self.f = 0
self.g = 0
self.neighbors = []
self.previous = None
self.obs = False
self.closed = False
self.value = 1
self.screen = screen
self.row = row
self.cols = cols
self.w = w
self.h = h
def show(self, color, st):
if self.closed == False :
pygame.draw.rect(self.screen, color, (self.i * self.w, self.j * self.h, self.w, self.h), st)
pygame.display.update()
def path(self, color, st):
pygame.draw.rect(self.screen, color, (self.i * self.w, self.j * self.h, self.w, self.h), st)
pygame.display.update()
def addNeighbors(self, grid):
i = self.i
j = self.j
if i < self.cols-1 and grid[self.i + 1][j].obs == False:
self.neighbors.append(grid[self.i + 1][j])
if i > 0 and grid[self.i - 1][j].obs == False:
self.neighbors.append(grid[self.i - 1][j])
if j < self.row-1 and grid[self.i][j + 1].obs == False:
self.neighbors.append(grid[self.i][j + 1])
if j > 0 and grid[self.i][j - 1].obs == False:
self.neighbors.append(grid[self.i][j - 1])
| [
"matthew.c.r.millar@gmail.com"
] | matthew.c.r.millar@gmail.com |
7993b07468bb433eabfddbe67c791a5e60c93ad9 | b25fe0d0e401ef3a0ba52751326a427d575ce2bc | /Tests/test_SearchIO_hmmer3_tab_index.py | 13eba93d20c8affba28d326795f5c30e031705ed | [
"LicenseRef-scancode-biopython"
] | permissive | szymczakpau/biopython | 9fd8385396073d43f4758c60f45aace9aa032e17 | 6f997cd1ea7daf89f0b70854401da4cde35d6a00 | refs/heads/master | 2021-01-26T04:40:40.853772 | 2020-02-26T16:36:28 | 2020-02-26T16:36:28 | 243,308,366 | 0 | 0 | NOASSERTION | 2020-02-26T16:20:02 | 2020-02-26T16:20:00 | null | UTF-8 | Python | false | false | 4,499 | py | # Copyright 2012 by Wibowo Arindrarto. All rights reserved.
# This code is part of the Biopython distribution and governed by its
# license. Please see the LICENSE file that should have been included
# as part of this package.
"""Tests for SearchIO hmmer3-tab indexing."""
import os
import unittest
from search_tests_common import CheckRaw, CheckIndex
class Hmmer3TabRawCases(CheckRaw):
fmt = 'hmmer3-tab'
def test_hmmer3tab_30_multiple_first(self):
"""Test hmmer3-tab raw string retrieval, HMMER 3.0, multiple queries, first (tab_30_hmmscan_001.out)"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_001.out')
raw = """Globin PF00042.17 gi|4885477|ref|NP_005359.1| - 6e-21 74.6 0.3 9.2e-21 74.0 0.2 1.3 1 0 0 1 1 1 1 Globin
"""
self.check_raw(filename, "gi|4885477|ref|NP_005359.1|", raw)
def test_hmmer3tab_30_multiple_middle(self):
"""Test hmmer3-tab raw string retrieval, HMMER 3.0, multiple queries, middle (tab_30_hmmscan_001.out)"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_001.out')
raw = """Ig_3 PF13927.1 gi|126362951:116-221 - 1.4e-09 38.2 0.4 2.1e-09 37.6 0.3 1.3 1 0 0 1 1 1 1 Immunoglobulin domain
Ig_2 PF13895.1 gi|126362951:116-221 - 3.5e-05 23.7 0.1 4.3e-05 23.4 0.1 1.1 1 0 0 1 1 1 1 Immunoglobulin domain
"""
self.check_raw(filename, "gi|126362951:116-221", raw)
def test_hmmer3tab_30_multiple_last(self):
"""Test hmmer3-tab raw string retrieval, HMMER 3.0, multiple queries, last (tab_30_hmmscan_001.out)"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_001.out')
raw = """Pou PF00157.12 gi|125490392|ref|NP_038661.2| - 7e-37 124.8 0.5 1.4e-36 123.9 0.3 1.5 1 0 0 1 1 1 1 Pou domain - N-terminal to homeobox domain
Homeobox PF00046.24 gi|125490392|ref|NP_038661.2| - 2.1e-18 65.5 1.1 4.1e-18 64.6 0.7 1.5 1 0 0 1 1 1 1 Homeobox domain
HTH_31 PF13560.1 gi|125490392|ref|NP_038661.2| - 0.012 15.6 0.0 0.16 12.0 0.0 2.2 2 0 0 2 2 2 0 Helix-turn-helix domain
Homeobox_KN PF05920.6 gi|125490392|ref|NP_038661.2| - 0.039 13.5 0.0 0.095 12.3 0.0 1.6 1 0 0 1 1 1 0 Homeobox KN domain
DUF521 PF04412.8 gi|125490392|ref|NP_038661.2| - 0.14 10.5 0.1 0.26 9.6 0.1 1.4 1 0 0 1 1 1 0 Protein of unknown function (DUF521)
"""
self.check_raw(filename, "gi|125490392|ref|NP_038661.2|", raw)
def test_hmmer3tab_30_single(self):
"""Test hmmer3-tab raw string retrieval, HMMER 3.0, single query (tab_30_hmmscan_004.out)"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_004.out')
raw = """Ig_3 PF13927.1 gi|126362951:116-221 - 1.4e-09 38.2 0.4 2.1e-09 37.6 0.3 1.3 1 0 0 1 1 1 1 Immunoglobulin domain
Ig_2 PF13895.1 gi|126362951:116-221 - 3.5e-05 23.7 0.1 4.3e-05 23.4 0.1 1.1 1 0 0 1 1 1 1 Immunoglobulin domain
"""
self.check_raw(filename, "gi|126362951:116-221", raw)
class Hmmer3TabIndexCases(CheckIndex):
fmt = 'hmmer3-tab'
def test_hmmer3tab_30_hmmscan_001(self):
"""Test hmmer3-tab indexing, HMMER 3.0, multiple queries"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_001.out')
self.check_index(filename, self.fmt)
def test_hmmer3tab_30_hmmscan_002(self):
"""Test hmmer3-tab indexing, HMMER 3.0, single query, no hits"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_002.out')
self.check_index(filename, self.fmt)
def test_hmmer3tab_30_hmmscan_003(self):
"""Test hmmer3-tab indexing, HMMER 3.0, single query, multiple hits"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_003.out')
self.check_index(filename, self.fmt)
def test_hmmer3tab_30_hmmscan_004(self):
"""Test hmmer3-tab indexing, HMMER 3.0, single query, no alignments"""
filename = os.path.join('Hmmer', 'tab_30_hmmscan_004.out')
self.check_index(filename, self.fmt)
if __name__ == "__main__":
runner = unittest.TextTestRunner(verbosity = 2)
unittest.main(testRunner=runner)
| [
"bow@bow.web.id"
] | bow@bow.web.id |
4f0f723276d090c0f5ab216aa7b4a3c44a56cf96 | 554cad7a6495a940fc3b9e0cd0963ccd4f556ec6 | /Keras/train_test_run_model.py | a2770830b6950aff7b31fa76fde81d76d95475e0 | [] | no_license | ChrisNosowsky/MachineLearning | da8b274cc7ee64fed93689b49f6e01e7b45b3700 | 223209377f0aa2fc3fc4d9a8fb233789454598ee | refs/heads/master | 2020-06-19T06:38:43.951775 | 2019-08-15T20:35:33 | 2019-08-15T20:35:33 | 196,600,089 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 573 | py | import words_to_sequence as wts
import neural_network_model as nnm
#Build training and test sets, set aside 10000 points to validate
x_val = wts.one_hot_results[:10000]
x_test = wts.one_hot_results[10000:20000]
x_train = wts.one_hot_results[20000:40000]
y_val = wts.one_hot_labels[:10000]
y_test = wts.one_hot_labels[10000:20000]
y_train = wts.one_hot_labels[20000:40000]
history = nnm.model.fit(x_train,
y_train,
epochs=20,
batch_size=128,
validation_data=(x_test, y_test))
| [
"noreply@github.com"
] | ChrisNosowsky.noreply@github.com |
5912f6955fb5ae6ae6c4764ea42b7cb0e5bab0c7 | f712b369740d222de6c3cee308c00370cab6b9c9 | /opencv-knn-ocr.py | b55439d58f5dc1d19bcb16a97822dd278645e695 | [] | no_license | wilkenshuang/Practice | 8958297ffff4be491663d79b75ec26013bba46cc | d88c4a0423553bdb0a15a3b28c1f2e9d4f255585 | refs/heads/master | 2021-01-01T17:54:13.943244 | 2018-06-28T02:55:22 | 2018-06-28T02:55:22 | 98,194,615 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,500 | py | # -*- coding: utf-8 -*-
"""
@author: wilkenshuang
"""
import cv2
import numpy as np
import time
def ExtractData(filename):
image=cv2.imread(filename)
gray=cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)
cells=[np.hsplit(row,100) for row in np.vsplit(gray,50)]
ImgMatrix=np.zeros((5000,400))
for i in range(50):
for j in range(100):
img=cells[i][j].flatten()
ImgMatrix[i*50+j,:]=img
ImgMatrix=ImgMatrix.astype('float32')
ImgLabel=np.repeat(np.arange(10),500).astype('float32')
ImgLabel=ImgLabel.reshape((len(ImgLabel),1))
return ImgMatrix,ImgLabel
def updataKNN(knn,train,trainLabel,newData=None,newDataLabel=None):
if newData!=None and newDataLabel!=None:
print(train.shape,newData.shape)
newData=newData.reshape(-1,400).astype('float32')
train=np.vstack((train,newData))
trainLabel=np.hstack((trainLabel,newDataLabel))
knn.train(train,cv2.ml.ROW_SAMPLE,trainLabel)
return knn,train,trainLabel
def findRoi(frame,threshValue):
rois=[]
gray=cv2.cvtColor(frame,cv2.COLOR_RGB2GRAY)
#gray=frame
gray2=cv2.dilate(gray,None,iterations=2)
gray2=cv2.erode(gray2,None,iterations=2)
edges=cv2.absdiff(gray,gray2)
x=cv2.Sobel(edges,cv2.CV_16S,1,0)
y=cv2.Sobel(edges,cv2.CV_16S,0,1)
absx=cv2.convertScaleAbs(x)
absy=cv2.convertScaleAbs(y)
dst=cv2.addWeighted(absx,0.5,absy,0.5,0)
ret,ddst=cv2.threshold(dst,threshValue,255,cv2.THRESH_BINARY)
im,contours,hierarchy=cv2.findContours(ddst,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
for i in contours:
x,y,w,h=cv2.boundingRect(i)
if w>10 and h>20:
rois.append((x,y,w,h))
return rois,edges
def findDigit(knn,roi,threshValue):
ret,th=cv2.threshold(roi,threshValue,255,cv2.THRESH_BINARY)
th=np.resize(th,(20,20))
output=np.reshape(th,(-1,400)).astype('float32')
ret,results,neighours,dist=knn.findNearest(output,3)
return int(results[0][0]),th
def concatenate(images):
n=len(images)
output=np.zeros(20*20*n).reshape((-1,20))
for i in range(n):
output[20*i:20*(i+1),:]=images[i]
return output
start=time.clock()
knn=cv2.ml.KNearest_create()
filename='C:\Anaconda_working\digits.png'
TrainData,Labels=ExtractData(filename)
knn.train(TrainData,cv2.ml.ROW_SAMPLE,Labels)
cap = cv2.VideoCapture(0)
width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
videoFrame = cv2.VideoWriter('frame.avi',cv2.VideoWriter_fourcc('M','J','P','G'),25,(int(width),int(height)),True)
count=0
while True:
ret,frame=cap.read()
threshValue=50
rois, edges = findRoi(frame, threshValue)
digits=[]
for i in rois:
x,y,w,h=i
digit,th=findDigit(knn,edges[x:x+w,y:y+h],threshValue)
digits.append(np.resize(th,(20,20)))
cv2.rectangle(frame,(x,y),(x+w,y+h),(153,153,0),1)
cv2.putText(frame, str(digit), (x,y), cv2.FONT_HERSHEY_SIMPLEX, 1, (127,0,255), 2)
newEdges=cv2.cvtColor(edges,cv2.COLOR_GRAY2BGR)
newFrame = np.hstack((frame,newEdges))
cv2.imshow('frame',newFrame)
k=cv2.waitKey(0)
if k == 27:
break
elif k==ord('c'):
Nd=len(digits)
output=concatenate(digits)
showDigits = cv2.resize(output,(60,60*Nd))
cv2.imshow('digits', showDigits)
cv2.imwrite(str(count)+'.png', showDigits)
count += 1
if cv2.waitKey(0) & 0xff == ord('e'):
pass
print('input the digits(separate by space):')
numbers = input().split(' ')
Nn = len(numbers)
if Nd != Nn:
print('update KNN fail!')
continue
try:
for i in range(Nn):
numbers[i] = int(numbers[i])
except:
continue
knn, TrainData, Labels = updataKNN(knn, TrainData, Labels, output, numbers)
print('update KNN, Done!')
print('Numbers of trained images:',len(TrainData))
print('Numbers of trained image labels', len(Labels))
cap.release()
cv2.destroyAllWindows()
#width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
#height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
#videoFrame = cv2.VideoWriter('frame.avi',cv2.VideoWriter_fourcc('M','J','P','G'),25,(int(width),int(height)),True)
#ret,frame=cap.read()
end=time.clock()
print('Process time: %s s' %(end-start))
| [
"noreply@github.com"
] | wilkenshuang.noreply@github.com |
56d480f90230149990dc1b7b61736e123cda06ab | 1159aa5c10bb2acfa9aebcb0c622bbc552b2cecb | /05_if_acl.py | a55fb183c423fcf64788d6863e0c5c67ed85d09a | [] | no_license | MaxStarX/DevNet | 41ee72c916f92400fdf06971246063677795290b | 86bfd72ab5975dad51c47164444edbe3b2e5f3a6 | refs/heads/master | 2020-11-24T23:24:50.474211 | 2019-12-16T12:58:41 | 2019-12-16T12:58:41 | 228,385,465 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 274 | py | aclNum = int(input("What is the IPv4 ACL number? "))
if aclNum >= 1 and aclNum <= 99:
print ("The is a standart IPv4 ACL.")
elif aclNum >= 100 and aclNum <= 199:
print ("This is a extended IPv4 ACL.")
else:
print ("This is not a standart or extended IPv4 ACL.")
| [
"56589181+MaxStarX@users.noreply.github.com"
] | 56589181+MaxStarX@users.noreply.github.com |
8e016fba1b6edee0b7e20a24d68a7c920a9f86ce | 4adc69ccec096285af3882ad659cbd13eaa273f4 | /libs/djadmin/middleware.py | 6a2b47bb2de0f3f777e9f5c17e7986efa4723223 | [] | no_license | biddyweb/icruits | 8d2b56e4e9c00641f5af0885732788e1ae29e658 | eb72e4e89f153dd9d076e84f9c522a582a5e167f | refs/heads/master | 2020-03-28T07:41:35.085813 | 2018-05-26T19:03:37 | 2018-05-26T19:03:37 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,315 | py | from distutils.version import StrictVersion as Version
import django
from django.conf import settings
from django.contrib.admin.sites import AdminSite
from django.utils.functional import SimpleLazyObject
from libs.djadmin.colors import colors
from libs.djadmin.models import DjadminModelSetting
from libs.djadmin.signals import get_register_model_with_mixin, handle_djadmin_field_data
from libs.djadmin.util import get_user_agent
if Version(django.get_version()) >= Version('1.10.0'):
from django.utils.deprecation import MiddlewareMixin as object
class DJMiddleware(object):
def process_request(self, request):
request.user_agent = SimpleLazyObject(lambda: get_user_agent(request))
ALLOW_FORGET_PASSWORD_ADMIN = getattr(settings, 'ALLOW_FORGET_PASSWORD_ADMIN', False)
ADMIN_COLOR_THEME = getattr(settings, 'ADMIN_COLOR_THEME', 'cyan').lower()
ADMIN_HEADER_TITLE = getattr(settings, 'ADMIN_HEADER_TITLE', 'Django administrator')
ADMIN_COLOR_THEME_CODE = colors[ADMIN_COLOR_THEME]["base"]
AdminSite.site_header = ADMIN_HEADER_TITLE
request.ADMIN_COLOR_THEME = ADMIN_COLOR_THEME
request.ALLOW_FORGET_PASSWORD_ADMIN = ALLOW_FORGET_PASSWORD_ADMIN
request.ADMIN_COLOR_THEME_CODE = ADMIN_COLOR_THEME_CODE
| [
"alekw3@gmail.com"
] | alekw3@gmail.com |
8051de40984a9a2acb43e21095fbc3aae7026551 | 53fab060fa262e5d5026e0807d93c75fb81e67b9 | /backup/user_118/ch23_2020_03_11_11_23_45_741474.py | c6ecc8ea4e87cf6cff5cef2378d5c6e336252e92 | [] | no_license | gabriellaec/desoft-analise-exercicios | b77c6999424c5ce7e44086a12589a0ad43d6adca | 01940ab0897aa6005764fc220b900e4d6161d36b | refs/heads/main | 2023-01-31T17:19:42.050628 | 2020-12-16T05:21:31 | 2020-12-16T05:21:31 | 306,735,108 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 203 | py | def velocidade(c):
v=(c-80)*5
return v
x = float(input('Qual a velocidade? '))
y=velocidade(x)
if y == 0:
print('Não foi multado')
else:
print ('Foi multado em R$ '' {0:.2f}'.format (y)) | [
"you@example.com"
] | you@example.com |
2a95186a275ba5b454302db60d76436dd3e073de | 116fb74041a20530d03027f4f155e48f49c68491 | /09.py | 4772901d3d9b97c5f1c272186167ed1e3b6a3f0c | [] | no_license | isaacmarquetti/EstruturaDeDecisao | 4e9701c0f3091979a61f90e783be960c03aef3d0 | 48d3a7e21f8f20e6db11601d6e2f5d6012afc92e | refs/heads/master | 2023-08-28T03:37:54.148400 | 2021-11-03T02:52:14 | 2021-11-03T02:52:14 | 423,044,854 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 694 | py | """
Faça um Programa que leia três números e mostre-os
em ordem decrescente.
"""
num1 = int(input("Digite o 1º número: "))
num2 = int(input("Digite o 2º número: "))
num3 = int(input("Digite o 3º número: "))
if num1 >= num2 and num1 >= num3:
if num2 >= num3:
print(f'A ordem é: {num1}, {num2} e {num3}')
else:
print(f'A ordem é: {num1}, {num3} e {num2}')
elif num2 >= num3:
if num1 >= num3:
print(f'A ordem é: {num2}, {num1} e {num3}')
else:
print(f'A ordem é: {num2}, {num3} e {num1}')
else:
if num1 >= num2:
print(f'A ordem é: {num3}, {num1} e {num2}')
else:
print(f'A ordem é: {num3}, {num2} e {num1}')
| [
"isaac.marquetti@gmail.com"
] | isaac.marquetti@gmail.com |
b76eebcce6d333ab9eeb6a635d645bcff821d353 | cd4bbecc3f713b0c25508d0c5674d9e103db5df4 | /toontown/estate/FlowerCollection.py | ae519a6213959a49508db54bc4af3e2794d78be4 | [] | no_license | peppythegod/ToontownOnline | dce0351cfa1ad8c476e035aa3947fdf53de916a6 | 2e5a106f3027714d301f284721382cb956cd87a0 | refs/heads/master | 2020-04-20T05:05:22.934339 | 2020-01-02T18:05:28 | 2020-01-02T18:05:28 | 168,646,608 | 11 | 2 | null | null | null | null | UTF-8 | Python | false | false | 2,443 | py | import GardenGlobals
from direct.directnotify import DirectNotifyGlobal
import FlowerBase
class FlowerCollection:
notify = DirectNotifyGlobal.directNotify.newCategory('FlowerCollection')
def __init__(self):
self.flowerlist = []
def __len__(self):
return len(self.flowerlist)
def getFlower(self):
return self.flowerlist
def makeFromNetLists(self, speciesList, varietyList):
self.flowerlist = []
for (species, variety) in zip(speciesList, varietyList):
self.flowerlist.append(FlowerBase.FlowerBase(species, variety))
def getNetLists(self):
speciesList = []
varietyList = []
for flower in self.flowerlist:
speciesList.append(flower.getSpecies())
varietyList.append(flower.getVariety())
return [speciesList, varietyList]
def hasFlower(self, species, variety):
for flower in self.flowerlist:
if flower.getSpecies() == species and flower.getVariety(
) == variety:
return 1
continue
return 0
def hasSpecies(self, species):
for flower in self.flowerlist:
if flower.getSpecies() == species:
return 1
continue
return 0
def getInitialVariety(self, species):
retVal = 100000
for flower in self.flowerlist:
if flower.getSpecies() == species:
if flower.getVariety() < retVal:
retVal = flower.getVariety()
flower.getVariety() < retVal
if retVal == 100000:
retVal = 0
return retVal
def _FlowerCollection__collect(self, newFlower, updateCollection):
for flower in self.flowerlist:
if flower.getVariety() == newFlower.getVariety(
) and flower.getSpecies() == newFlower.getSpecies():
return GardenGlobals.COLLECT_NO_UPDATE
continue
if updateCollection:
self.flowerlist.append(newFlower)
return GardenGlobals.COLLECT_NEW_ENTRY
def collectFlower(self, newFlower):
return self._FlowerCollection__collect(newFlower, updateCollection=1)
def __str__(self):
numFlower = len(self.flowerlist)
txt = 'Flower Collection (%s flowers):' % numFlower
for flower in self.flowerlist:
txt += '\n' + str(flower)
return txt
| [
"47166977+peppythegod@users.noreply.github.com"
] | 47166977+peppythegod@users.noreply.github.com |
78d177d3b84b2926431f2f0274ad527d3fec739c | 6f8bcfde1cffc126c93602780b16ecc46c699c13 | /bom-python/projects/gaming/generated/mysql/py/ent/GameApp.py | 2a00e1589f80ab23d56efd0cd90072bcbb975036 | [] | no_license | drawcode/bom | e7e267f042cee29797c73a598c9eeb494c0645d0 | e6f36da68bc4d8669dfdfae04ae03e268bfaf3d5 | refs/heads/master | 2021-01-15T12:25:12.894121 | 2014-02-24T00:12:26 | 2014-02-24T00:12:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,185 | py | import math
import BaseEntity
from BaseEntity import *
class GameAppResult(object):
def __init__(self):
self.page = 1
self.page_size = 10
self.total_rows = 0
self.total_pages = int(math.ceil(self.total_rows / self.page_size))
self.data = []
def to_dict_obj(self):
return self.to_dict(self)
def to_dict(self, obj, classkey=None):
if isinstance(obj, dict):
for k in obj.keys():
obj[k] = self.to_dict(obj[k], classkey)
return obj
elif hasattr(obj, "__iter__"):
return [self.to_dict(v, classkey) for v in obj]
elif hasattr(obj, "__dict__"):
data = dict([(key, self.to_dict(value, classkey))
for key, value in obj.__dict__.iteritems()
if not callable(value) and not key.startswith('_')])
if classkey is not None and hasattr(obj, "__class__"):
data[classkey] = obj.__class__.__name__
return data
else:
return obj
def from_dict(self, d):
if isinstance(d, dict):
n = {}
for item in d:
if isinstance(d[item], dict):
n[item] = self.to_obj(d[item])
elif isinstance(d[item], (list, tuple)):
n[item] = [self.to_obj(elem) for elem in d[item]]
else:
n[item] = d[item]
return type('obj_from_dict', (object,), n)
else:
return d
def dict_to_obj(self, d):
if isinstance(d, list):
d = [self.dict_to_obj(x) for x in d]
if not isinstance(d, dict):
return d
class C(object):
pass
o = C()
for k in d:
o.__dict__[k] = self.dict_to_obj(d[k])
return o
class GameApp(BaseEntity):
def __init__(self):
super(GameApp, self).__init__()
#self.__dict__.update(entries)
self.game_id = None
self.app_id = None
def to_dict_obj(self):
return self.to_dict(self)
def to_dict(self, obj, classkey=None):
if isinstance(obj, dict):
for k in obj.keys():
obj[k] = self.to_dict(obj[k], classkey)
return obj
elif hasattr(obj, "__iter__"):
return [self.to_dict(v, classkey) for v in obj]
elif hasattr(obj, "__dict__"):
data = dict([(key, self.to_dict(value, classkey))
for key, value in obj.__dict__.iteritems()
if not callable(value) and not key.startswith('_')])
if classkey is not None and hasattr(obj, "__class__"):
data[classkey] = obj.__class__.__name__
return data
else:
return obj
def from_dict(self, d):
if isinstance(d, dict):
n = {}
for item in d:
if isinstance(d[item], dict):
n[item] = self.to_obj(d[item])
elif isinstance(d[item], (list, tuple)):
n[item] = [self.to_obj(elem) for elem in d[item]]
else:
n[item] = d[item]
return type('obj_from_dict', (object,), n)
else:
return d
def dict_to_obj(self, d):
if isinstance(d, list):
d = [self.dict_to_obj(x) for x in d]
if not isinstance(d, dict):
return d
class C(object):
pass
o = C()
for k in d:
o.__dict__[k] = self.dict_to_obj(d[k])
return o
| [
"ryan@drawlabs.com"
] | ryan@drawlabs.com |
e36f1af6b59137638c59627cd2a5e71a94660d4c | e9c46be1ffe007bec7c5d1489570a4878fb610c3 | /reverse.py | f2abdd3e3ba322a07216a4fc693c3a5530e35549 | [] | no_license | Navi-nk/Python | a0919cf22b69274ce642885eeacddab88687e851 | 26ea8d48039d1a81a4f850d34fa858175e0c8ef8 | refs/heads/master | 2020-09-21T06:57:57.021480 | 2017-04-06T16:59:46 | 2017-04-06T16:59:46 | 66,935,930 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 140 | py | #This is my first python program
a=19
b=10
print ('Before')
print (a);print(b);
a,b = b,a
print ('After')
print (a);print(b);
| [
"noreply@github.com"
] | Navi-nk.noreply@github.com |
4201cdc49a58fd1595f8fa239c937a83651701b5 | 2694ecac31848e5444362573931d51ca711e0e37 | /kerasapi/techercode2.py | 605380a25f8d3634eb80bbe9c63e59e8d5cd7c7a | [] | no_license | heqi8826/test | 8782b605c6173b5e28c74c1cc446dfd06b91ac1d | 55069c6d1bc42eba8e85b6c2c546604c2365cb43 | refs/heads/master | 2020-07-02T15:32:17.865389 | 2019-09-16T14:27:38 | 2019-09-16T14:27:38 | 201,573,524 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,483 | py | import tensorflow as tf
from tensorflow.keras import datasets, layers, optimizers, Sequential, metrics
from tensorflow import keras
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def preprocess(x, y):
# [0~255] => [-1~1]
x = 2 * tf.cast(x, dtype=tf.float32) / 255. - 1.
y = tf.cast(y, dtype=tf.int32)
return x, y
batchsz = 128
# [50k, 32, 32, 3], [10k, 1]
(x, y), (x_val, y_val) = datasets.cifar10.load_data()
y = tf.squeeze(y)
y_val = tf.squeeze(y_val)
y = tf.one_hot(y, depth=10) # [50k, 10]
y_val = tf.one_hot(y_val, depth=10) # [10k, 10]
print('datasets:', x.shape, y.shape, x_val.shape, y_val.shape, x.min(), x.max())
train_db = tf.data.Dataset.from_tensor_slices((x, y))
train_db = train_db.map(preprocess).shuffle(10000).batch(batchsz)
test_db = tf.data.Dataset.from_tensor_slices((x_val, y_val))
test_db = test_db.map(preprocess).batch(batchsz)
sample = next(iter(train_db))
print('batch:', sample[0].shape, sample[1].shape)
class MyDense(layers.Layer):
# to replace standard layers.Dense()
def __init__(self, inp_dim, outp_dim):
super(MyDense, self).__init__()
self.kernel = self.add_variable('w', [inp_dim, outp_dim])
# self.bias = self.add_variable('b', [outp_dim])
def call(self, inputs, training=None):
x = inputs @ self.kernel
return x
class MyNetwork(keras.Model):
def __init__(self):
super(MyNetwork, self).__init__()
self.fc1 = MyDense(32 * 32 * 3, 256)
self.fc2 = MyDense(256, 128)
self.fc3 = MyDense(128, 64)
self.fc4 = MyDense(64, 32)
self.fc5 = MyDense(32, 10)
def call(self, inputs, training=None):
"""
:param inputs: [b, 32, 32, 3]
:param training:
:return:
"""
x = tf.reshape(inputs, [-1, 32 * 32 * 3])
# [b, 32*32*3] => [b, 256]
x = self.fc1(x)
x = tf.nn.relu(x)
# [b, 256] => [b, 128]
x = self.fc2(x)
x = tf.nn.relu(x)
# [b, 128] => [b, 64]
x = self.fc3(x)
x = tf.nn.relu(x)
# [b, 64] => [b, 32]
x = self.fc4(x)
x = tf.nn.relu(x)
# [b, 32] => [b, 10]
x = self.fc5(x)
return x
network = MyNetwork()
network.compile(optimizer=optimizers.Adam(lr=1e-3),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
network.fit(train_db, epochs=15, validation_data=test_db, validation_freq=1)
| [
"heqi8826@gmail.com"
] | heqi8826@gmail.com |
08ae1b25e6599f0c9bc73c5bdaee4926c2141dd0 | a512f88f91619ff23ea7f93a6246821637130760 | /mapping.try.three/proteome.tester.mapping.13.07.24.py | a744d0290196ee8da2917eb8d782e83d7ec4651c | [] | no_license | jdorenstein/scripts | daaf5f0bbbb89f29d6d3f27afb0d50c9f2a11f51 | 081c7a8b4fcceeb9590eb04bec5a61c24a3708b0 | refs/heads/master | 2021-01-01T18:56:11.291080 | 2013-08-09T17:55:08 | 2013-08-09T17:55:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,827 | py | import os
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.Alphabet import IUPAC
#this program takes a fasta file as an input and creates two files (cgs.in.proteome.fa) and (cgs.not.in.proteome.fa). This program is a new version of map.uniprot.to.ensembl.uses.conversion.db.13.07.23.py that creates a dictionary (using the .longest.peptide) of each uniprot id to the longest protein (for the gene)
###IOin###
##ask the user for the location of the desired fasta cgs input file
mapping_db_in = open('/Users/ionchannel/research/tools/db/mapping/DROME_7227_idmapping_selected.tab','r')
longest_peptide_in = open('/Users/ionchannel/research/tools/db/blast/13.proteomes/old.databases/130723/longest.peptide.fastas/proteome.drosophila.melanogaster.longest.peptide.fa', 'r')
###Parse 2###
##create a list 'longest_peptide_list' that contains the ensembl id of each entry in the longest peptide fasta
#declare variables
longest_peptide_list = []
#parse the fasta file for each header. remove the 'drosophila-' prefix. append to longest_peptide_list
for seq_record in SeqIO.parse('/Users/ionchannel/research/tools/db/blast/13.proteomes/old.databases/130723/longest.peptide.fastas/proteome.drosophila.melanogaster.longest.peptide.fa', 'fasta'):
header = seq_record.id
header_edited = header[11:]
longest_peptide_list.append(header_edited)
###Parse 3###
##create a dictionary of the mappping database UniProtID as the key, and the ensembl info as the entry. In addition, the script uses the longest peptide list to sort pick the protein id that is the longest
#declare variables
mapping_dict = {}
print longest_peptide_list
for line in mapping_db_in:
#split the line on tabs. frmt: 0[UniprotID] ... 21[Ensembl id's] . note: when there are multiple ensembl id's, they are seperated by ';' and a space
lineSplit = line.split('\t')
#test to see if ';' is in lineSplit[21]
if ';' in lineSplit[21]:
longest_match = ''
#split the line on ';'. then, for each entry, check to see if it is in the longest peptide fasta list.
list_of_matches = lineSplit[21].split('; ')
match_count = 0
for item in list_of_matches:
#if the item is in the longest_peptide_list, then append it to longest_match and add one to match_count
if item in longest_peptide_list:
match_count = match_count + 1
longest_match = longest_match + item + ' '
mapping_dict[lineSplit[0]] = [longest_match, match_count]
match_count = 0
#if longest_match == '':
# print lineSplit[0]
else:
mapping_dict[lineSplit[0]] = [lineSplit[21], 1]
#for key in mapping_dict.keys():
# if mapping_dict[key][1] > 1:
# print mapping_dict[key]
#print '-----------'
#for key in mapping_dict.keys():
# if mapping_dict[key][1] == 1:
# print mapping_dict[key]
mapping_db_in.close()
| [
"ionchannel@Erics-iMac.local"
] | ionchannel@Erics-iMac.local |
d980277f489b1ccd0ca023a20aa7ee3ba7ce2fc7 | 84ceadd0ac283e66f26d427255d69969c7ca1855 | /day3_taskG/venv/bin/easy_install-3.6 | 75609ef14db86db431568a6e0d4400ab4e73849c | [] | no_license | alexdoka/ansibletrain | e63cd97ddbc0c29e2d0968481a884bc8c345fdbd | 3ece6944714225c31e563568815a3f6c014de397 | refs/heads/master | 2022-04-04T02:35:55.125690 | 2020-01-31T07:14:19 | 2020-01-31T07:14:19 | 236,964,817 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 454 | 6 | #!/home/doka/ansible/ansibletrain/day3_taskG/venv/bin/python
# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==40.8.0','console_scripts','easy_install-3.6'
__requires__ = 'setuptools==40.8.0'
import re
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(
load_entry_point('setuptools==40.8.0', 'console_scripts', 'easy_install-3.6')()
)
| [
"alex.doka@gmail.com"
] | alex.doka@gmail.com |
07f78ca85f0e89e9f37f2876ce84948af929709d | eb68caae1b85171c3b38cfe59c43e9a6f64c4a19 | /Lab11/delete-aws-queue.py | 2119961d5508e940aa1180378518fd810086fbe3 | [] | no_license | andreRBarata/CloudComputing | dd23bec1ad5d571e5c69faec825ae4fd0653e5d8 | a8d0d20e997881edf62ff8f35c075ff237be571c | refs/heads/master | 2021-01-10T13:46:38.930118 | 2015-12-09T12:15:06 | 2015-12-09T12:15:06 | 43,004,925 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 979 | py | # This script created a queue
#
# Author - Paul Doyle Nov 2015
#
#
import httplib
import boto.sqs
import boto.sqs.queue
from boto.sqs.message import Message
from boto.sqs.connection import SQSConnection
from boto.exception import SQSError
import sys
keys = httplib.HTTPConnection("ec2-52-30-7-5.eu-west-1.compute.amazonaws.com:81")
keys.request("GET", "/key")
r1 = keys.getresponse().read().split(":")
# Get the keys from a specific url and then use them to connect to AWS Service
access_key_id = r1[0]
secret_access_key = r1[1]
# Set up a connection to the AWS service.
conn = boto.sqs.connect_to_region(
"eu-west-1",
aws_access_key_id=access_key_id,
aws_secret_access_key=secret_access_key
)
# Get a list of the queues that exists and then print the list out
# Do not use / or " in the name
q = conn.get_queue("C13765235-%s" % sys.argv[1])
if (q != None):
r = conn.delete_queue(
q
)
print("queue %s is now deleted" % q.id)
else:
print("queue is not found")
| [
"andre.quina.barata@gmail.com"
] | andre.quina.barata@gmail.com |
81c3485eaa48a8e81c2e9bda88b080374f7e64e7 | e165bc8b6aa6686b1722557774bc236a3b538e3e | /ShortExerciseGPUs/test/benchmarkCartesianVectorsCUDAv3.py | d67205e1ace7272267e121a5499bc14b593964d5 | [] | no_license | cms-physics-object-school/ShortExerciseProgrammingGPUs | 064df6702eb68b815168bdabfc79f3788e4a61ab | 7577f1500d563c916abe00d1cf8edd3de22c06b0 | refs/heads/master | 2020-07-22T19:10:04.136378 | 2019-09-17T05:33:18 | 2019-09-17T05:33:18 | 207,300,332 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 646 | py | import FWCore.ParameterSet.Config as cms
process = cms.Process("PRINT")
process.options = cms.untracked.PSet(
numberOfThreads = cms.untracked.uint32( 1 ),
numberOfStreams = cms.untracked.uint32( 1 ),
wantSummary = cms.untracked.bool( True )
)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring("file:cylindricalVectors.root"),
)
process.convertToCartesianVectors = cms.EDProducer('ConvertToCartesianVectorsCUDAv3',
input = cms.InputTag('generateCylindricalVectors')
)
process.path = cms.Path(process.convertToCartesianVectors)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32( -1 )
)
| [
"andrea.bocci@cern.ch"
] | andrea.bocci@cern.ch |
cc462bc85d0d716ae2e44775a9e09ff96c2e6614 | d9f52125601ec26f79202f0e912891b31b60ffc4 | /오전반/30-days-of-code/Day_06/Day_06_YNY.py | 463f620727b012c7231ca35c7a30dd8078ae48fe | [] | no_license | YoungGaLee/2020_Python_coding-study | 5a4f36a39021c89ac773a3a7878c44bf8b0b811f | b876aabc747709afa21035c3afa7e3f7ee01b26a | refs/heads/master | 2022-12-12T13:34:44.729245 | 2020-09-07T04:07:48 | 2020-09-07T04:07:48 | 280,745,587 | 4 | 4 | null | 2020-07-22T03:27:22 | 2020-07-18T21:51:40 | Python | UTF-8 | Python | false | false | 268 | py | n=int(input())
q_odd=[]
q_even=[]
for i in range (n):
q=str(input())
for j in range(len(q)):
if j%2==0:
q_odd.append(q[j])
if j%2==1:
q_even.append(q[j])
print("".join(q_odd) ,"".join(q_even))
q_odd,q_even=[],[]
| [
"noreply@github.com"
] | YoungGaLee.noreply@github.com |
2aacf7a42a5e5ba680eac760fa60e5e5c13abc8f | 3d69b7fe8fa95fcd6dbab25885f2e3e42bc891d6 | /src/nlp/classification/tf1/bert/run_squad.py | 37118c6db8065cbadf118ecc3b0a13473347453d | [
"Apache-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | wu-uw/OpenCompetition | ac652d066f667dc2b3061947af5ea0425643a1b5 | 9aa9d7a50ada1deb653d295dd8a7fe46321b9094 | refs/heads/master | 2021-01-03T04:59:28.987099 | 2020-03-02T07:49:11 | 2020-03-02T07:49:11 | 239,932,371 | 0 | 0 | Apache-2.0 | 2020-03-02T07:49:12 | 2020-02-12T05:12:02 | Python | UTF-8 | Python | false | false | 51,567 | py | # coding=utf-8
# Copyright 2018 The Google AI Language Team Authors.
#
# 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.
"""Run BERT on SQuAD 1.1 and SQuAD 2.0."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
import json
import math
import os
import random
import modeling
import optimization
import tokenization
import six
import tensorflow as tf
flags = tf.flags
FLAGS = flags.FLAGS
# Required parameters
flags.DEFINE_string(
"bert_config_file", None,
"The config json file corresponding to the pre-trained BERT model. "
"This specifies the model architecture.")
flags.DEFINE_string("vocab_file", None,
"The vocabulary file that the BERT model was trained on.")
flags.DEFINE_string(
"output_dir", None,
"The output directory where the model checkpoints will be written.")
# Other parameters
flags.DEFINE_string("train_file", None,
"SQuAD json for training. E.g., train-v1.1.json")
flags.DEFINE_string(
"predict_file", None,
"SQuAD json for predictions. E.g., dev-v1.1.json or test-v1.1.json")
flags.DEFINE_string(
"init_checkpoint", None,
"Initial checkpoint (usually from a pre-trained BERT model).")
flags.DEFINE_bool(
"do_lower_case", True,
"Whether to lower case the input text. Should be True for uncased "
"models and False for cased models.")
flags.DEFINE_integer(
"max_seq_length", 384,
"The maximum total input sequence length after WordPiece tokenization. "
"Sequences longer than this will be truncated, and sequences shorter "
"than this will be padded.")
flags.DEFINE_integer(
"doc_stride", 128,
"When splitting up a long document into chunks, how much stride to "
"take between chunks.")
flags.DEFINE_integer(
"max_query_length", 64,
"The maximum number of tokens for the question. Questions longer than "
"this will be truncated to this length.")
flags.DEFINE_bool("do_train", False, "Whether to run training.")
flags.DEFINE_bool("do_predict", False, "Whether to run eval on the dev set.")
flags.DEFINE_integer("train_batch_size", 32, "Total batch size for training.")
flags.DEFINE_integer("predict_batch_size", 8,
"Total batch size for predictions.")
flags.DEFINE_float(
"learning_rate",
5e-5,
"The initial learning rate for Adam.")
flags.DEFINE_float("num_train_epochs", 3.0,
"Total number of training epochs to perform.")
flags.DEFINE_float(
"warmup_proportion", 0.1,
"Proportion of training to perform linear learning rate warmup for. "
"E.g., 0.1 = 10% of training.")
flags.DEFINE_integer("save_checkpoints_steps", 1000,
"How often to save the model checkpoint.")
flags.DEFINE_integer("iterations_per_loop", 1000,
"How many steps to make in each estimator call.")
flags.DEFINE_integer(
"n_best_size", 20,
"The total number of n-best predictions to generate in the "
"nbest_predictions.json output file.")
flags.DEFINE_integer(
"max_answer_length", 30,
"The maximum length of an answer that can be generated. This is needed "
"because the start and end predictions are not conditioned on one another.")
flags.DEFINE_bool("use_tpu", False, "Whether to use TPU or GPU/CPU.")
tf.flags.DEFINE_string(
"tpu_name", None,
"The Cloud TPU to use for training. This should be either the name "
"used when creating the Cloud TPU, or a grpc://ip.address.of.tpu:8470 "
"url.")
tf.flags.DEFINE_string(
"tpu_zone", None,
"[Optional] GCE zone where the Cloud TPU is located in. If not "
"specified, we will attempt to automatically detect the GCE project from "
"metadata.")
tf.flags.DEFINE_string(
"gcp_project", None,
"[Optional] Project name for the Cloud TPU-enabled project. If not "
"specified, we will attempt to automatically detect the GCE project from "
"metadata.")
tf.flags.DEFINE_string("master", None, "[Optional] TensorFlow master URL.")
flags.DEFINE_integer(
"num_tpu_cores", 8,
"Only used if `use_tpu` is True. Total number of TPU cores to use.")
flags.DEFINE_bool(
"verbose_logging", False,
"If true, all of the warnings related to data processing will be printed. "
"A number of warnings are expected for a normal SQuAD evaluation.")
flags.DEFINE_bool(
"version_2_with_negative", False,
"If true, the SQuAD examples contain some that do not have an answer.")
flags.DEFINE_float(
"null_score_diff_threshold", 0.0,
"If null_score - best_non_null is greater than the threshold predict null.")
class SquadExample(object):
"""A single training/test example for simple sequence classification.
For examples without an answer, the start and end position are -1.
"""
def __init__(self,
qas_id,
question_text,
doc_tokens,
orig_answer_text=None,
start_position=None,
end_position=None,
is_impossible=False):
self.qas_id = qas_id
self.question_text = question_text
self.doc_tokens = doc_tokens
self.orig_answer_text = orig_answer_text
self.start_position = start_position
self.end_position = end_position
self.is_impossible = is_impossible
def __str__(self):
return self.__repr__()
def __repr__(self):
s = ""
s += "qas_id: %s" % (tokenization.printable_text(self.qas_id))
s += ", question_text: %s" % (
tokenization.printable_text(self.question_text))
s += ", doc_tokens: [%s]" % (" ".join(self.doc_tokens))
if self.start_position:
s += ", start_position: %d" % (self.start_position)
if self.start_position:
s += ", end_position: %d" % (self.end_position)
if self.start_position:
s += ", is_impossible: %r" % (self.is_impossible)
return s
class InputFeatures(object):
"""A single set of features of data."""
def __init__(self,
unique_id,
example_index,
doc_span_index,
tokens,
token_to_orig_map,
token_is_max_context,
input_ids,
input_mask,
segment_ids,
start_position=None,
end_position=None,
is_impossible=None):
self.unique_id = unique_id
self.example_index = example_index
self.doc_span_index = doc_span_index
self.tokens = tokens
self.token_to_orig_map = token_to_orig_map
self.token_is_max_context = token_is_max_context
self.input_ids = input_ids
self.input_mask = input_mask
self.segment_ids = segment_ids
self.start_position = start_position
self.end_position = end_position
self.is_impossible = is_impossible
def read_squad_examples(input_file, is_training):
"""Read a SQuAD json file into a list of SquadExample."""
with tf.gfile.Open(input_file, "r") as reader:
input_data = json.load(reader)["data"]
def is_whitespace(c):
if c == " " or c == "\t" or c == "\r" or c == "\n" or ord(c) == 0x202F:
return True
return False
examples = []
for entry in input_data:
for paragraph in entry["paragraphs"]:
paragraph_text = paragraph["context"]
doc_tokens = []
char_to_word_offset = []
prev_is_whitespace = True
for c in paragraph_text:
if is_whitespace(c):
prev_is_whitespace = True
else:
if prev_is_whitespace:
doc_tokens.append(c)
else:
doc_tokens[-1] += c
prev_is_whitespace = False
char_to_word_offset.append(len(doc_tokens) - 1)
for qa in paragraph["qas"]:
qas_id = qa["id"]
question_text = qa["question"]
start_position = None
end_position = None
orig_answer_text = None
is_impossible = False
if is_training:
if FLAGS.version_2_with_negative:
is_impossible = qa["is_impossible"]
if (len(qa["answers"]) != 1) and (not is_impossible):
raise ValueError(
"For training, each question should have exactly 1 answer.")
if not is_impossible:
answer = qa["answers"][0]
orig_answer_text = answer["text"]
answer_offset = answer["answer_start"]
answer_length = len(orig_answer_text)
start_position = char_to_word_offset[answer_offset]
end_position = char_to_word_offset[answer_offset +
answer_length - 1]
# Only add answers where the text can be exactly recovered from the
# document. If this CAN'T happen it's likely due to weird Unicode
# stuff so we will just skip the example.
#
# Note that this means for training mode, every example is NOT
# guaranteed to be preserved.
actual_text = " ".join(
doc_tokens[start_position:(end_position + 1)])
cleaned_answer_text = " ".join(
tokenization.whitespace_tokenize(orig_answer_text))
if actual_text.find(cleaned_answer_text) == -1:
tf.logging.warning(
"Could not find answer: '%s' vs. '%s'",
actual_text,
cleaned_answer_text)
continue
else:
start_position = -1
end_position = -1
orig_answer_text = ""
example = SquadExample(
qas_id=qas_id,
question_text=question_text,
doc_tokens=doc_tokens,
orig_answer_text=orig_answer_text,
start_position=start_position,
end_position=end_position,
is_impossible=is_impossible)
examples.append(example)
return examples
def convert_examples_to_features(examples, tokenizer, max_seq_length,
doc_stride, max_query_length, is_training,
output_fn):
"""Loads a data file into a list of `InputBatch`s."""
unique_id = 1000000000
for (example_index, example) in enumerate(examples):
query_tokens = tokenizer.tokenize(example.question_text)
if len(query_tokens) > max_query_length:
query_tokens = query_tokens[0:max_query_length]
tok_to_orig_index = []
orig_to_tok_index = []
all_doc_tokens = []
for (i, token) in enumerate(example.doc_tokens):
orig_to_tok_index.append(len(all_doc_tokens))
sub_tokens = tokenizer.tokenize(token)
for sub_token in sub_tokens:
tok_to_orig_index.append(i)
all_doc_tokens.append(sub_token)
tok_start_position = None
tok_end_position = None
if is_training and example.is_impossible:
tok_start_position = -1
tok_end_position = -1
if is_training and not example.is_impossible:
tok_start_position = orig_to_tok_index[example.start_position]
if example.end_position < len(example.doc_tokens) - 1:
tok_end_position = orig_to_tok_index[example.end_position + 1] - 1
else:
tok_end_position = len(all_doc_tokens) - 1
(tok_start_position, tok_end_position) = _improve_answer_span(
all_doc_tokens, tok_start_position, tok_end_position, tokenizer,
example.orig_answer_text)
# The -3 accounts for [CLS], [SEP] and [SEP]
max_tokens_for_doc = max_seq_length - len(query_tokens) - 3
# We can have documents that are longer than the maximum sequence length.
# To deal with this we do a sliding window approach, where we take chunks
# of the up to our max length with a stride of `doc_stride`.
_DocSpan = collections.namedtuple( # pylint: disable=invalid-name
"DocSpan", ["start", "length"])
doc_spans = []
start_offset = 0
while start_offset < len(all_doc_tokens):
length = len(all_doc_tokens) - start_offset
if length > max_tokens_for_doc:
length = max_tokens_for_doc
doc_spans.append(_DocSpan(start=start_offset, length=length))
if start_offset + length == len(all_doc_tokens):
break
start_offset += min(length, doc_stride)
for (doc_span_index, doc_span) in enumerate(doc_spans):
tokens = []
token_to_orig_map = {}
token_is_max_context = {}
segment_ids = []
tokens.append("[CLS]")
segment_ids.append(0)
for token in query_tokens:
tokens.append(token)
segment_ids.append(0)
tokens.append("[SEP]")
segment_ids.append(0)
for i in range(doc_span.length):
split_token_index = doc_span.start + i
token_to_orig_map[len(
tokens)] = tok_to_orig_index[split_token_index]
is_max_context = _check_is_max_context(
doc_spans, doc_span_index, split_token_index)
token_is_max_context[len(tokens)] = is_max_context
tokens.append(all_doc_tokens[split_token_index])
segment_ids.append(1)
tokens.append("[SEP]")
segment_ids.append(1)
input_ids = tokenizer.convert_tokens_to_ids(tokens)
# The mask has 1 for real tokens and 0 for padding tokens. Only real
# tokens are attended to.
input_mask = [1] * len(input_ids)
# Zero-pad up to the sequence length.
while len(input_ids) < max_seq_length:
input_ids.append(0)
input_mask.append(0)
segment_ids.append(0)
assert len(input_ids) == max_seq_length
assert len(input_mask) == max_seq_length
assert len(segment_ids) == max_seq_length
start_position = None
end_position = None
if is_training and not example.is_impossible:
# For training, if our document chunk does not contain an annotation
# we throw it out, since there is nothing to predict.
doc_start = doc_span.start
doc_end = doc_span.start + doc_span.length - 1
out_of_span = False
if not (tok_start_position >= doc_start and
tok_end_position <= doc_end):
out_of_span = True
if out_of_span:
start_position = 0
end_position = 0
else:
doc_offset = len(query_tokens) + 2
start_position = tok_start_position - doc_start + doc_offset
end_position = tok_end_position - doc_start + doc_offset
if is_training and example.is_impossible:
start_position = 0
end_position = 0
if example_index < 20:
tf.logging.info("*** Example ***")
tf.logging.info("unique_id: %s" % (unique_id))
tf.logging.info("example_index: %s" % (example_index))
tf.logging.info("doc_span_index: %s" % (doc_span_index))
tf.logging.info("tokens: %s" % " ".join(
[tokenization.printable_text(x) for x in tokens]))
tf.logging.info("token_to_orig_map: %s" % " ".join(
["%d:%d" % (x, y) for (x, y) in six.iteritems(token_to_orig_map)]))
tf.logging.info("token_is_max_context: %s" % " ".join([
"%d:%s" % (x, y) for (x, y) in six.iteritems(token_is_max_context)
]))
tf.logging.info("input_ids: %s" %
" ".join([str(x) for x in input_ids]))
tf.logging.info(
"input_mask: %s" % " ".join([str(x) for x in input_mask]))
tf.logging.info("segment_ids: %s" %
" ".join([str(x) for x in segment_ids]))
if is_training and example.is_impossible:
tf.logging.info("impossible example")
if is_training and not example.is_impossible:
answer_text = " ".join(
tokens[start_position:(end_position + 1)])
tf.logging.info("start_position: %d" % (start_position))
tf.logging.info("end_position: %d" % (end_position))
tf.logging.info("answer: %s" %
(tokenization.printable_text(answer_text)))
feature = InputFeatures(
unique_id=unique_id,
example_index=example_index,
doc_span_index=doc_span_index,
tokens=tokens,
token_to_orig_map=token_to_orig_map,
token_is_max_context=token_is_max_context,
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids,
start_position=start_position,
end_position=end_position,
is_impossible=example.is_impossible)
# Run callback
output_fn(feature)
unique_id += 1
def _improve_answer_span(doc_tokens, input_start, input_end, tokenizer,
orig_answer_text):
"""Returns tokenized answer spans that better match the annotated answer."""
# The SQuAD annotations are character based. We first project them to
# whitespace-tokenized words. But then after WordPiece tokenization, we can
# often find a "better match". For example:
#
# Question: What year was John Smith born?
# Context: The leader was John Smith (1895-1943).
# Answer: 1895
#
# The original whitespace-tokenized answer will be "(1895-1943).". However
# after tokenization, our tokens will be "( 1895 - 1943 ) .". So we can match
# the exact answer, 1895.
#
# However, this is not always possible. Consider the following:
#
# Question: What country is the top exporter of electornics?
# Context: The Japanese electronics industry is the lagest in the world.
# Answer: Japan
#
# In this case, the annotator chose "Japan" as a character sub-span of
# the word "Japanese". Since our WordPiece tokenizer does not split
# "Japanese", we just use "Japanese" as the annotation. This is fairly rare
# in SQuAD, but does happen.
tok_answer_text = " ".join(tokenizer.tokenize(orig_answer_text))
for new_start in range(input_start, input_end + 1):
for new_end in range(input_end, new_start - 1, -1):
text_span = " ".join(doc_tokens[new_start:(new_end + 1)])
if text_span == tok_answer_text:
return (new_start, new_end)
return (input_start, input_end)
def _check_is_max_context(doc_spans, cur_span_index, position):
"""Check if this is the 'max context' doc span for the token."""
# Because of the sliding window approach taken to scoring documents, a single
# token can appear in multiple documents. E.g.
# Doc: the man went to the store and bought a gallon of milk
# Span A: the man went to the
# Span B: to the store and bought
# Span C: and bought a gallon of
# ...
#
# Now the word 'bought' will have two scores from spans B and C. We only
# want to consider the score with "maximum context", which we define as
# the *minimum* of its left and right context (the *sum* of left and
# right context will always be the same, of course).
#
# In the example the maximum context for 'bought' would be span C since
# it has 1 left context and 3 right context, while span B has 4 left context
# and 0 right context.
best_score = None
best_span_index = None
for (span_index, doc_span) in enumerate(doc_spans):
end = doc_span.start + doc_span.length - 1
if position < doc_span.start:
continue
if position > end:
continue
num_left_context = position - doc_span.start
num_right_context = end - position
score = min(num_left_context, num_right_context) + \
0.01 * doc_span.length
if best_score is None or score > best_score:
best_score = score
best_span_index = span_index
return cur_span_index == best_span_index
def create_model(bert_config, is_training, input_ids, input_mask, segment_ids,
use_one_hot_embeddings):
"""Creates a classification model."""
model = modeling.BertModel(
config=bert_config,
is_training=is_training,
input_ids=input_ids,
input_mask=input_mask,
token_type_ids=segment_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
final_hidden = model.get_sequence_output()
final_hidden_shape = modeling.get_shape_list(final_hidden, expected_rank=3)
batch_size = final_hidden_shape[0]
seq_length = final_hidden_shape[1]
hidden_size = final_hidden_shape[2]
output_weights = tf.get_variable(
"cls/squad/output_weights", [2, hidden_size],
initializer=tf.truncated_normal_initializer(stddev=0.02))
output_bias = tf.get_variable(
"cls/squad/output_bias", [2], initializer=tf.zeros_initializer())
final_hidden_matrix = tf.reshape(final_hidden,
[batch_size * seq_length, hidden_size])
logits = tf.matmul(final_hidden_matrix, output_weights, transpose_b=True)
logits = tf.nn.bias_add(logits, output_bias)
logits = tf.reshape(logits, [batch_size, seq_length, 2])
logits = tf.transpose(logits, [2, 0, 1])
unstacked_logits = tf.unstack(logits, axis=0)
(start_logits, end_logits) = (unstacked_logits[0], unstacked_logits[1])
return (start_logits, end_logits)
def model_fn_builder(bert_config, init_checkpoint, learning_rate,
num_train_steps, num_warmup_steps, use_tpu,
use_one_hot_embeddings):
"""Returns `model_fn` closure for TPUEstimator."""
def model_fn(features, labels, mode, params): # pylint: disable=unused-argument
"""The `model_fn` for TPUEstimator."""
tf.logging.info("*** Features ***")
for name in sorted(features.keys()):
tf.logging.info(
" name = %s, shape = %s" %
(name, features[name].shape))
unique_ids = features["unique_ids"]
input_ids = features["input_ids"]
input_mask = features["input_mask"]
segment_ids = features["segment_ids"]
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
(start_logits, end_logits) = create_model(
bert_config=bert_config,
is_training=is_training,
input_ids=input_ids,
input_mask=input_mask,
segment_ids=segment_ids,
use_one_hot_embeddings=use_one_hot_embeddings)
tvars = tf.trainable_variables()
initialized_variable_names = {}
scaffold_fn = None
if init_checkpoint:
(assignment_map, initialized_variable_names
) = modeling.get_assignment_map_from_checkpoint(tvars, init_checkpoint)
if use_tpu:
def tpu_scaffold():
tf.train.init_from_checkpoint(
init_checkpoint, assignment_map)
return tf.train.Scaffold()
scaffold_fn = tpu_scaffold
else:
tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
tf.logging.info("**** Trainable Variables ****")
for var in tvars:
init_string = ""
if var.name in initialized_variable_names:
init_string = ", *INIT_FROM_CKPT*"
tf.logging.info(" name = %s, shape = %s%s", var.name, var.shape,
init_string)
output_spec = None
if mode == tf.estimator.ModeKeys.TRAIN:
seq_length = modeling.get_shape_list(input_ids)[1]
def compute_loss(logits, positions):
one_hot_positions = tf.one_hot(
positions, depth=seq_length, dtype=tf.float32)
log_probs = tf.nn.log_softmax(logits, axis=-1)
loss = -tf.reduce_mean(
tf.reduce_sum(one_hot_positions * log_probs, axis=-1))
return loss
start_positions = features["start_positions"]
end_positions = features["end_positions"]
start_loss = compute_loss(start_logits, start_positions)
end_loss = compute_loss(end_logits, end_positions)
total_loss = (start_loss + end_loss) / 2.0
train_op = optimization.create_optimizer(
total_loss, learning_rate, num_train_steps, num_warmup_steps, use_tpu)
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode,
loss=total_loss,
train_op=train_op,
scaffold_fn=scaffold_fn)
elif mode == tf.estimator.ModeKeys.PREDICT:
predictions = {
"unique_ids": unique_ids,
"start_logits": start_logits,
"end_logits": end_logits,
}
output_spec = tf.contrib.tpu.TPUEstimatorSpec(
mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)
else:
raise ValueError(
"Only TRAIN and PREDICT modes are supported: %s" % (mode))
return output_spec
return model_fn
def input_fn_builder(input_file, seq_length, is_training, drop_remainder):
"""Creates an `input_fn` closure to be passed to TPUEstimator."""
name_to_features = {
"unique_ids": tf.FixedLenFeature([], tf.int64),
"input_ids": tf.FixedLenFeature([seq_length], tf.int64),
"input_mask": tf.FixedLenFeature([seq_length], tf.int64),
"segment_ids": tf.FixedLenFeature([seq_length], tf.int64),
}
if is_training:
name_to_features["start_positions"] = tf.FixedLenFeature([], tf.int64)
name_to_features["end_positions"] = tf.FixedLenFeature([], tf.int64)
def _decode_record(record, name_to_features):
"""Decodes a record to a TensorFlow example."""
example = tf.parse_single_example(record, name_to_features)
# tf.Example only supports tf.int64, but the TPU only supports tf.int32.
# So cast all int64 to int32.
for name in list(example.keys()):
t = example[name]
if t.dtype == tf.int64:
t = tf.to_int32(t)
example[name] = t
return example
def input_fn(params):
"""The actual input function."""
batch_size = params["batch_size"]
# For training, we want a lot of parallel reading and shuffling.
# For eval, we want no shuffling and parallel reading doesn't matter.
d = tf.data.TFRecordDataset(input_file)
if is_training:
d = d.repeat()
d = d.shuffle(buffer_size=100)
d = d.apply(
tf.contrib.data.map_and_batch(
lambda record: _decode_record(record, name_to_features),
batch_size=batch_size,
drop_remainder=drop_remainder))
return d
return input_fn
RawResult = collections.namedtuple("RawResult",
["unique_id", "start_logits", "end_logits"])
def write_predictions(all_examples, all_features, all_results, n_best_size,
max_answer_length, do_lower_case, output_prediction_file,
output_nbest_file, output_null_log_odds_file):
"""Write final predictions to the json file and log-odds of null if needed."""
tf.logging.info("Writing predictions to: %s" % (output_prediction_file))
tf.logging.info("Writing nbest to: %s" % (output_nbest_file))
example_index_to_features = collections.defaultdict(list)
for feature in all_features:
example_index_to_features[feature.example_index].append(feature)
unique_id_to_result = {}
for result in all_results:
unique_id_to_result[result.unique_id] = result
_PrelimPrediction = collections.namedtuple( # pylint: disable=invalid-name
"PrelimPrediction",
["feature_index", "start_index", "end_index", "start_logit", "end_logit"])
all_predictions = collections.OrderedDict()
all_nbest_json = collections.OrderedDict()
scores_diff_json = collections.OrderedDict()
for (example_index, example) in enumerate(all_examples):
features = example_index_to_features[example_index]
prelim_predictions = []
# keep track of the minimum score of null start+end of position 0
score_null = 1000000 # large and positive
min_null_feature_index = 0 # the paragraph slice with min mull score
null_start_logit = 0 # the start logit at the slice with min null score
null_end_logit = 0 # the end logit at the slice with min null score
for (feature_index, feature) in enumerate(features):
result = unique_id_to_result[feature.unique_id]
start_indexes = _get_best_indexes(result.start_logits, n_best_size)
end_indexes = _get_best_indexes(result.end_logits, n_best_size)
# if we could have irrelevant answers, get the min score of
# irrelevant
if FLAGS.version_2_with_negative:
feature_null_score = result.start_logits[0] + \
result.end_logits[0]
if feature_null_score < score_null:
score_null = feature_null_score
min_null_feature_index = feature_index
null_start_logit = result.start_logits[0]
null_end_logit = result.end_logits[0]
for start_index in start_indexes:
for end_index in end_indexes:
# We could hypothetically create invalid predictions, e.g., predict
# that the start of the span is in the question. We throw out all
# invalid predictions.
if start_index >= len(feature.tokens):
continue
if end_index >= len(feature.tokens):
continue
if start_index not in feature.token_to_orig_map:
continue
if end_index not in feature.token_to_orig_map:
continue
if not feature.token_is_max_context.get(
start_index, False):
continue
if end_index < start_index:
continue
length = end_index - start_index + 1
if length > max_answer_length:
continue
prelim_predictions.append(
_PrelimPrediction(
feature_index=feature_index,
start_index=start_index,
end_index=end_index,
start_logit=result.start_logits[start_index],
end_logit=result.end_logits[end_index]))
if FLAGS.version_2_with_negative:
prelim_predictions.append(
_PrelimPrediction(
feature_index=min_null_feature_index,
start_index=0,
end_index=0,
start_logit=null_start_logit,
end_logit=null_end_logit))
prelim_predictions = sorted(
prelim_predictions,
key=lambda x: (x.start_logit + x.end_logit),
reverse=True)
_NbestPrediction = collections.namedtuple( # pylint: disable=invalid-name
"NbestPrediction", ["text", "start_logit", "end_logit"])
seen_predictions = {}
nbest = []
for pred in prelim_predictions:
if len(nbest) >= n_best_size:
break
feature = features[pred.feature_index]
if pred.start_index > 0: # this is a non-null prediction
tok_tokens = feature.tokens[pred.start_index:(
pred.end_index + 1)]
orig_doc_start = feature.token_to_orig_map[pred.start_index]
orig_doc_end = feature.token_to_orig_map[pred.end_index]
orig_tokens = example.doc_tokens[orig_doc_start:(
orig_doc_end + 1)]
tok_text = " ".join(tok_tokens)
# De-tokenize WordPieces that have been split off.
tok_text = tok_text.replace(" ##", "")
tok_text = tok_text.replace("##", "")
# Clean whitespace
tok_text = tok_text.strip()
tok_text = " ".join(tok_text.split())
orig_text = " ".join(orig_tokens)
final_text = get_final_text(tok_text, orig_text, do_lower_case)
if final_text in seen_predictions:
continue
seen_predictions[final_text] = True
else:
final_text = ""
seen_predictions[final_text] = True
nbest.append(
_NbestPrediction(
text=final_text,
start_logit=pred.start_logit,
end_logit=pred.end_logit))
# if we didn't inlude the empty option in the n-best, inlcude it
if FLAGS.version_2_with_negative:
if "" not in seen_predictions:
nbest.append(
_NbestPrediction(
text="", start_logit=null_start_logit,
end_logit=null_end_logit))
# In very rare edge cases we could have no valid predictions. So we
# just create a nonce prediction in this case to avoid failure.
if not nbest:
nbest.append(
_NbestPrediction(text="empty", start_logit=0.0, end_logit=0.0))
assert len(nbest) >= 1
total_scores = []
best_non_null_entry = None
for entry in nbest:
total_scores.append(entry.start_logit + entry.end_logit)
if not best_non_null_entry:
if entry.text:
best_non_null_entry = entry
probs = _compute_softmax(total_scores)
nbest_json = []
for (i, entry) in enumerate(nbest):
output = collections.OrderedDict()
output["text"] = entry.text
output["probability"] = probs[i]
output["start_logit"] = entry.start_logit
output["end_logit"] = entry.end_logit
nbest_json.append(output)
assert len(nbest_json) >= 1
if not FLAGS.version_2_with_negative:
all_predictions[example.qas_id] = nbest_json[0]["text"]
else:
# predict "" iff the null score - the score of best non-null >
# threshold
score_diff = score_null - best_non_null_entry.start_logit - (
best_non_null_entry.end_logit)
scores_diff_json[example.qas_id] = score_diff
if score_diff > FLAGS.null_score_diff_threshold:
all_predictions[example.qas_id] = ""
else:
all_predictions[example.qas_id] = best_non_null_entry.text
all_nbest_json[example.qas_id] = nbest_json
with tf.gfile.GFile(output_prediction_file, "w") as writer:
writer.write(json.dumps(all_predictions, indent=4) + "\n")
with tf.gfile.GFile(output_nbest_file, "w") as writer:
writer.write(json.dumps(all_nbest_json, indent=4) + "\n")
if FLAGS.version_2_with_negative:
with tf.gfile.GFile(output_null_log_odds_file, "w") as writer:
writer.write(json.dumps(scores_diff_json, indent=4) + "\n")
def get_final_text(pred_text, orig_text, do_lower_case):
"""Project the tokenized prediction back to the original text."""
# When we created the data, we kept track of the alignment between original
# (whitespace tokenized) tokens and our WordPiece tokenized tokens. So
# now `orig_text` contains the span of our original text corresponding to the
# span that we predicted.
#
# However, `orig_text` may contain extra characters that we don't want in
# our prediction.
#
# For example, let's say:
# pred_text = steve smith
# orig_text = Steve Smith's
#
# We don't want to return `orig_text` because it contains the extra "'s".
#
# We don't want to return `pred_text` because it's already been normalized
# (the SQuAD eval script also does punctuation stripping/lower casing but
# our tokenizer does additional normalization like stripping accent
# characters).
#
# What we really want to return is "Steve Smith".
#
# Therefore, we have to apply a semi-complicated alignment heruistic between
# `pred_text` and `orig_text` to get a character-to-charcter alignment. This
# can fail in certain cases in which case we just return `orig_text`.
def _strip_spaces(text):
ns_chars = []
ns_to_s_map = collections.OrderedDict()
for (i, c) in enumerate(text):
if c == " ":
continue
ns_to_s_map[len(ns_chars)] = i
ns_chars.append(c)
ns_text = "".join(ns_chars)
return (ns_text, ns_to_s_map)
# We first tokenize `orig_text`, strip whitespace from the result
# and `pred_text`, and check if they are the same length. If they are
# NOT the same length, the heuristic has failed. If they are the same
# length, we assume the characters are one-to-one aligned.
tokenizer = tokenization.BasicTokenizer(do_lower_case=do_lower_case)
tok_text = " ".join(tokenizer.tokenize(orig_text))
start_position = tok_text.find(pred_text)
if start_position == -1:
if FLAGS.verbose_logging:
tf.logging.info(
"Unable to find text: '%s' in '%s'" % (pred_text, orig_text))
return orig_text
end_position = start_position + len(pred_text) - 1
(orig_ns_text, orig_ns_to_s_map) = _strip_spaces(orig_text)
(tok_ns_text, tok_ns_to_s_map) = _strip_spaces(tok_text)
if len(orig_ns_text) != len(tok_ns_text):
if FLAGS.verbose_logging:
tf.logging.info(
"Length not equal after stripping spaces: '%s' vs '%s'",
orig_ns_text,
tok_ns_text)
return orig_text
# We then project the characters in `pred_text` back to `orig_text` using
# the character-to-character alignment.
tok_s_to_ns_map = {}
for (i, tok_index) in six.iteritems(tok_ns_to_s_map):
tok_s_to_ns_map[tok_index] = i
orig_start_position = None
if start_position in tok_s_to_ns_map:
ns_start_position = tok_s_to_ns_map[start_position]
if ns_start_position in orig_ns_to_s_map:
orig_start_position = orig_ns_to_s_map[ns_start_position]
if orig_start_position is None:
if FLAGS.verbose_logging:
tf.logging.info("Couldn't map start position")
return orig_text
orig_end_position = None
if end_position in tok_s_to_ns_map:
ns_end_position = tok_s_to_ns_map[end_position]
if ns_end_position in orig_ns_to_s_map:
orig_end_position = orig_ns_to_s_map[ns_end_position]
if orig_end_position is None:
if FLAGS.verbose_logging:
tf.logging.info("Couldn't map end position")
return orig_text
output_text = orig_text[orig_start_position:(orig_end_position + 1)]
return output_text
def _get_best_indexes(logits, n_best_size):
"""Get the n-best logits from a list."""
index_and_score = sorted(
enumerate(logits),
key=lambda x: x[1],
reverse=True)
best_indexes = []
for i in range(len(index_and_score)):
if i >= n_best_size:
break
best_indexes.append(index_and_score[i][0])
return best_indexes
def _compute_softmax(scores):
"""Compute softmax probability over raw logits."""
if not scores:
return []
max_score = None
for score in scores:
if max_score is None or score > max_score:
max_score = score
exp_scores = []
total_sum = 0.0
for score in scores:
x = math.exp(score - max_score)
exp_scores.append(x)
total_sum += x
probs = []
for score in exp_scores:
probs.append(score / total_sum)
return probs
class FeatureWriter(object):
"""Writes InputFeature to TF example file."""
def __init__(self, filename, is_training):
self.filename = filename
self.is_training = is_training
self.num_features = 0
self._writer = tf.python_io.TFRecordWriter(filename)
def process_feature(self, feature):
"""Write a InputFeature to the TFRecordWriter as a tf.train.Example."""
self.num_features += 1
def create_int_feature(values):
feature = tf.train.Feature(
int64_list=tf.train.Int64List(value=list(values)))
return feature
features = collections.OrderedDict()
features["unique_ids"] = create_int_feature([feature.unique_id])
features["input_ids"] = create_int_feature(feature.input_ids)
features["input_mask"] = create_int_feature(feature.input_mask)
features["segment_ids"] = create_int_feature(feature.segment_ids)
if self.is_training:
features["start_positions"] = create_int_feature(
[feature.start_position])
features["end_positions"] = create_int_feature(
[feature.end_position])
impossible = 0
if feature.is_impossible:
impossible = 1
features["is_impossible"] = create_int_feature([impossible])
tf_example = tf.train.Example(
features=tf.train.Features(
feature=features))
self._writer.write(tf_example.SerializeToString())
def close(self):
self._writer.close()
def validate_flags_or_throw(bert_config):
"""Validate the input FLAGS or throw an exception."""
tokenization.validate_case_matches_checkpoint(FLAGS.do_lower_case,
FLAGS.init_checkpoint)
if not FLAGS.do_train and not FLAGS.do_predict:
raise ValueError(
"At least one of `do_train` or `do_predict` must be True.")
if FLAGS.do_train:
if not FLAGS.train_file:
raise ValueError(
"If `do_train` is True, then `train_file` must be specified.")
if FLAGS.do_predict:
if not FLAGS.predict_file:
raise ValueError(
"If `do_predict` is True, then `predict_file` must be specified.")
if FLAGS.max_seq_length > bert_config.max_position_embeddings:
raise ValueError(
"Cannot use sequence length %d because the BERT model "
"was only trained up to sequence length %d" %
(FLAGS.max_seq_length, bert_config.max_position_embeddings))
if FLAGS.max_seq_length <= FLAGS.max_query_length + 3:
raise ValueError(
"The max_seq_length (%d) must be greater than max_query_length "
"(%d) + 3" % (FLAGS.max_seq_length, FLAGS.max_query_length))
def main(_):
tf.logging.set_verbosity(tf.logging.INFO)
bert_config = modeling.BertConfig.from_json_file(FLAGS.bert_config_file)
validate_flags_or_throw(bert_config)
tf.gfile.MakeDirs(FLAGS.output_dir)
tokenizer = tokenization.FullTokenizer(
vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)
tpu_cluster_resolver = None
if FLAGS.use_tpu and FLAGS.tpu_name:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
FLAGS.tpu_name, zone=FLAGS.tpu_zone, project=FLAGS.gcp_project)
is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
master=FLAGS.master,
model_dir=FLAGS.output_dir,
save_checkpoints_steps=FLAGS.save_checkpoints_steps,
tpu_config=tf.contrib.tpu.TPUConfig(
iterations_per_loop=FLAGS.iterations_per_loop,
num_shards=FLAGS.num_tpu_cores,
per_host_input_for_training=is_per_host))
train_examples = None
num_train_steps = None
num_warmup_steps = None
if FLAGS.do_train:
train_examples = read_squad_examples(
input_file=FLAGS.train_file, is_training=True)
num_train_steps = int(
len(train_examples) /
FLAGS.train_batch_size *
FLAGS.num_train_epochs)
num_warmup_steps = int(num_train_steps * FLAGS.warmup_proportion)
# Pre-shuffle the input to avoid having to make a very large shuffle
# buffer in in the `input_fn`.
rng = random.Random(12345)
rng.shuffle(train_examples)
model_fn = model_fn_builder(
bert_config=bert_config,
init_checkpoint=FLAGS.init_checkpoint,
learning_rate=FLAGS.learning_rate,
num_train_steps=num_train_steps,
num_warmup_steps=num_warmup_steps,
use_tpu=FLAGS.use_tpu,
use_one_hot_embeddings=FLAGS.use_tpu)
# If TPU is not available, this will fall back to normal Estimator on CPU
# or GPU.
estimator = tf.contrib.tpu.TPUEstimator(
use_tpu=FLAGS.use_tpu,
model_fn=model_fn,
config=run_config,
train_batch_size=FLAGS.train_batch_size,
predict_batch_size=FLAGS.predict_batch_size)
if FLAGS.do_train:
# We write to a temporary file to avoid storing very large constant tensors
# in memory.
train_writer = FeatureWriter(
filename=os.path.join(FLAGS.output_dir, "train.tf_record"),
is_training=True)
convert_examples_to_features(
examples=train_examples,
tokenizer=tokenizer,
max_seq_length=FLAGS.max_seq_length,
doc_stride=FLAGS.doc_stride,
max_query_length=FLAGS.max_query_length,
is_training=True,
output_fn=train_writer.process_feature)
train_writer.close()
tf.logging.info("***** Running training *****")
tf.logging.info(" Num orig examples = %d", len(train_examples))
tf.logging.info(" Num split examples = %d", train_writer.num_features)
tf.logging.info(" Batch size = %d", FLAGS.train_batch_size)
tf.logging.info(" Num steps = %d", num_train_steps)
del train_examples
train_input_fn = input_fn_builder(
input_file=train_writer.filename,
seq_length=FLAGS.max_seq_length,
is_training=True,
drop_remainder=True)
estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)
if FLAGS.do_predict:
eval_examples = read_squad_examples(
input_file=FLAGS.predict_file, is_training=False)
eval_writer = FeatureWriter(
filename=os.path.join(FLAGS.output_dir, "eval.tf_record"),
is_training=False)
eval_features = []
def append_feature(feature):
eval_features.append(feature)
eval_writer.process_feature(feature)
convert_examples_to_features(
examples=eval_examples,
tokenizer=tokenizer,
max_seq_length=FLAGS.max_seq_length,
doc_stride=FLAGS.doc_stride,
max_query_length=FLAGS.max_query_length,
is_training=False,
output_fn=append_feature)
eval_writer.close()
tf.logging.info("***** Running predictions *****")
tf.logging.info(" Num orig examples = %d", len(eval_examples))
tf.logging.info(" Num split examples = %d", len(eval_features))
tf.logging.info(" Batch size = %d", FLAGS.predict_batch_size)
all_results = []
predict_input_fn = input_fn_builder(
input_file=eval_writer.filename,
seq_length=FLAGS.max_seq_length,
is_training=False,
drop_remainder=False)
# If running eval on the TPU, you will need to specify the number of
# steps.
all_results = []
for result in estimator.predict(
predict_input_fn, yield_single_examples=True):
if len(all_results) % 1000 == 0:
tf.logging.info("Processing example: %d" % (len(all_results)))
unique_id = int(result["unique_ids"])
start_logits = [float(x) for x in result["start_logits"].flat]
end_logits = [float(x) for x in result["end_logits"].flat]
all_results.append(
RawResult(
unique_id=unique_id,
start_logits=start_logits,
end_logits=end_logits))
output_prediction_file = os.path.join(
FLAGS.output_dir, "predictions.json")
output_nbest_file = os.path.join(
FLAGS.output_dir, "nbest_predictions.json")
output_null_log_odds_file = os.path.join(
FLAGS.output_dir, "null_odds.json")
write_predictions(eval_examples, eval_features, all_results,
FLAGS.n_best_size, FLAGS.max_answer_length,
FLAGS.do_lower_case, output_prediction_file,
output_nbest_file, output_null_log_odds_file)
if __name__ == "__main__":
flags.mark_flag_as_required("vocab_file")
flags.mark_flag_as_required("bert_config_file")
flags.mark_flag_as_required("output_dir")
tf.app.run()
| [
"ran.wang.math@gmail.com"
] | ran.wang.math@gmail.com |
889810d825a849fe217e00d4aa042eb97edeef7d | 4a149a549d0dd414e70ee5f7f1a26761a6eb62f0 | /model/fcn.py | b147656a0abcbae8081ec3ea2c44947751e9a669 | [
"MIT"
] | permissive | Deeachain/LakeSegmentation-keras | 6f59bd719471b79a8ed6e0f1293db09a94a3140b | 58901893b5ba324112bb43211a068f8a6946c5ef | refs/heads/master | 2022-07-05T19:42:46.263338 | 2020-05-21T09:48:06 | 2020-05-21T09:48:06 | 265,810,606 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,229 | py | from keras.models import Model
from keras.layers import Input
from keras.layers.core import Lambda, Activation
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPooling2D
from keras.layers.merge import Add
from keras.layers.normalization import BatchNormalization
from keras.optimizers import Adam,SGD
from keras import backend as K
from keras.utils.vis_utils import plot_model
import numpy as np
import tensorflow as tf
def mean_iou(y_true, y_pred):
prec = []
for t in np.arange(0.5, 1.0, 0.05):
y_pred_ = tf.to_int32(y_pred > t)
score, up_opt = tf.metrics.mean_iou(y_true, y_pred_, 2)
K.get_session().run(tf.local_variables_initializer())
with tf.control_dependencies([up_opt]):
score = tf.identity(score)
prec.append(score)
return K.mean(K.stack(prec), axis=0)
def dice_coef(y_true, y_pred):
return (2. * K.sum(y_true * y_pred) + 1.) / (K.sum(y_true) + K.sum(y_pred) + 1.)
def fcn_8s(num_classes, input_shape, lr_init, lr_decay, vgg_weight_path=None):
img_input = Input(input_shape)
# Block 1
x = Conv2D(64, (3, 3), padding='same', name='block1_conv1')(img_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Block 2
x = Conv2D(128, (3, 3), padding='same', name='block2_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, (3, 3), padding='same', name='block2_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Block 3
x = Conv2D(256, (3, 3), padding='same', name='block3_conv1')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(256, (3, 3), padding='same', name='block3_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
block_3_out = MaxPooling2D()(x)
# Block 4
x = Conv2D(512, (3, 3), padding='same', name='block4_conv1')(block_3_out)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block4_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
block_4_out = MaxPooling2D()(x)
# Block 5
x = Conv2D(512, (3, 3), padding='same', name='block5_conv1')(block_4_out)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv2')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(512, (3, 3), padding='same', name='block5_conv3')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D()(x)
# Load pretrained weights.
if vgg_weight_path is not None:
vgg16 = Model(img_input, x)
vgg16.load_weights(vgg_weight_path, by_name=True)
# Convolutinalized fully connected layer.
x = Conv2D(4096, (7, 7), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(4096, (1, 1), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# Classifying layers.
x = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(x)
x = BatchNormalization()(x)
block_3_out = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(block_3_out)
block_3_out = BatchNormalization()(block_3_out)
block_4_out = Conv2D(num_classes, (1, 1), strides=(1, 1), activation='linear')(block_4_out)
block_4_out = BatchNormalization()(block_4_out)
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 2, x.shape[2] * 2)))(x)
x = Add()([x, block_4_out])
x = Activation('relu')(x)
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 2, x.shape[2] * 2)))(x)
x = Add()([x, block_3_out])
x = Activation('relu')(x)
x = Lambda(lambda x: tf.image.resize_images(x, (x.shape[1] * 8, x.shape[2] * 8)))(x)
x = Activation('softmax')(x)
model = Model(img_input, x)
# model.compile(optimizer=Adam(lr=lr_init, decay=lr_decay),
model.compile(optimizer=SGD(lr=lr_init, decay=lr_decay, momentum=0.9),
# loss='categorical_crossentropy',
loss='binary_crossentropy',
metrics=[dice_coef,mean_iou])
return model
if __name__ == "__main__":
model = fcn_8s(input_shape=(512, 512, 3), num_classes=2,
lr_init=0.001, lr_decay=0.001,
# vgg_weight_path='E:/Model weights/VGG16_VGG19_and ResNet50/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5')
vgg_weight_path = '/media/ding/学习/Model weights/VGG16_VGG19_and ResNet50/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5')
# model.eval()
model.summary()
plot_model(model, to_file='fcn_model.png', show_shapes=True) | [
"deeachain@gmail.com"
] | deeachain@gmail.com |
81a8f7309966861e6a73d3cea111f8f0f441759e | 153d5ff918a33afb1e73fefab9e774672cf4f129 | /auth_demo_stripe/wsgi.py | 06be555707e70f63105bf12ae7bbb1f7f8d691c1 | [] | no_license | meganduffy/auth_demo_stripe | a67700e406fab62091ab52bbb72b0eede89c1f72 | 74c6e1d2af19221d78c4eb813513e5f1d36c3abe | refs/heads/master | 2021-01-17T10:01:22.309264 | 2017-03-06T11:44:39 | 2017-03-06T11:44:39 | 84,001,104 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 410 | py | """
WSGI config for auth_demo_stripe project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "auth_demo_stripe.settings")
application = get_wsgi_application()
| [
"meganemilyduffy@gmail.com"
] | meganemilyduffy@gmail.com |
9b587f16f5f979403d3f6ce169fc6dba709a6f15 | 734c367429c22d239da36f439fd15d7b558ba283 | /interface.py | 5045631b71bf5f0545fca353c66f68decbb46118 | [] | no_license | Hvendrix/Laba1Python | 25f2629c3dfe5166671ae3ab0b2a0d202a5a9639 | 0a762c671474f116a81b0475f464954822a9ed92 | refs/heads/master | 2022-06-27T23:21:00.231971 | 2020-05-13T09:45:33 | 2020-05-13T09:45:33 | 263,587,904 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 8,889 | py | # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file './interface.ui'
#
# Created by: PyQt5 UI code generator 5.9.2
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1163, 852)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName("verticalLayout")
self.tabWidget = QtWidgets.QTabWidget(self.centralwidget)
self.tabWidget.setStyleSheet("background-color: rgb(186, 247, 247);\n"
"")
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setStyleSheet("background-color: rgb(36, 88, 122);")
self.tab.setObjectName("tab")
self.gridLayout = QtWidgets.QGridLayout(self.tab)
self.gridLayout.setObjectName("gridLayout")
self.label_4 = QtWidgets.QLabel(self.tab)
self.label_4.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.label_4.setObjectName("label_4")
self.gridLayout.addWidget(self.label_4, 4, 1, 1, 1)
self.amountSpinBox = QtWidgets.QSpinBox(self.tab)
self.amountSpinBox.setStyleSheet("\n"
"background-color: #FFA200;")
self.amountSpinBox.setMinimum(1)
self.amountSpinBox.setObjectName("amountSpinBox")
self.gridLayout.addWidget(self.amountSpinBox, 4, 0, 1, 1)
self.OperTypeBox = QtWidgets.QComboBox(self.tab)
self.OperTypeBox.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.OperTypeBox.setObjectName("OperTypeBox")
self.gridLayout.addWidget(self.OperTypeBox, 5, 0, 1, 1)
self.label_2 = QtWidgets.QLabel(self.tab)
self.label_2.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 0, 0, 1, 1)
self.NameBox = QtWidgets.QComboBox(self.tab)
self.NameBox.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.NameBox.setObjectName("NameBox")
self.gridLayout.addWidget(self.NameBox, 0, 1, 1, 1)
self.amountOnStoreTxt = QtWidgets.QLabel(self.tab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.amountOnStoreTxt.sizePolicy().hasHeightForWidth())
self.amountOnStoreTxt.setSizePolicy(sizePolicy)
self.amountOnStoreTxt.setMinimumSize(QtCore.QSize(100, 0))
self.amountOnStoreTxt.setStyleSheet("\n"
"background-color: #FFA200;")
self.amountOnStoreTxt.setObjectName("amountOnStoreTxt")
self.gridLayout.addWidget(self.amountOnStoreTxt, 3, 3, 1, 1)
self.tableWidget = QtWidgets.QTableWidget(self.tab)
self.tableWidget.setMinimumSize(QtCore.QSize(0, 0))
self.tableWidget.setMaximumSize(QtCore.QSize(16777215, 60))
self.tableWidget.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.tableWidget.setRowCount(1)
self.tableWidget.setColumnCount(5)
self.tableWidget.setObjectName("tableWidget")
self.gridLayout.addWidget(self.tableWidget, 1, 0, 1, 5)
self.oneCashTxt = QtWidgets.QLabel(self.tab)
self.oneCashTxt.setStyleSheet("\n"
"background-color: #FFA200;")
self.oneCashTxt.setObjectName("oneCashTxt")
self.gridLayout.addWidget(self.oneCashTxt, 4, 2, 1, 1)
self.nextBtn = QtWidgets.QPushButton(self.tab)
self.nextBtn.setStyleSheet("\n"
"background-color: #FFA200;")
self.nextBtn.setObjectName("nextBtn")
self.gridLayout.addWidget(self.nextBtn, 6, 0, 1, 1)
self.GoodsNameBox = QtWidgets.QComboBox(self.tab)
self.GoodsNameBox.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.GoodsNameBox.setObjectName("GoodsNameBox")
self.gridLayout.addWidget(self.GoodsNameBox, 3, 1, 1, 1)
self.loadBtn = QtWidgets.QPushButton(self.tab)
self.loadBtn.setObjectName("loadBtn")
self.gridLayout.addWidget(self.loadBtn, 6, 3, 1, 1)
self.delBtn = QtWidgets.QPushButton(self.tab)
self.delBtn.setObjectName("delBtn")
self.gridLayout.addWidget(self.delBtn, 6, 4, 1, 1)
self.label = QtWidgets.QLabel(self.tab)
self.label.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.label.setObjectName("label")
self.gridLayout.addWidget(self.label, 3, 0, 1, 1)
self.label_3 = QtWidgets.QLabel(self.tab)
self.label_3.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 3, 2, 1, 1)
self.label_5 = QtWidgets.QLabel(self.tab)
self.label_5.setStyleSheet("\n"
"background-color: rgb(101, 166, 209);")
self.label_5.setObjectName("label_5")
self.gridLayout.addWidget(self.label_5, 4, 3, 1, 1)
self.manyCashTxt = QtWidgets.QLabel(self.tab)
self.manyCashTxt.setStyleSheet("\n"
"background-color: #FFA200;")
self.manyCashTxt.setObjectName("manyCashTxt")
self.gridLayout.addWidget(self.manyCashTxt, 4, 4, 1, 1)
self.warningTxt = QtWidgets.QLabel(self.tab)
self.warningTxt.setStyleSheet("color: rgb(204, 0, 0);\n"
"\n"
"background-color: rgb(101, 166, 209);")
self.warningTxt.setObjectName("warningTxt")
self.gridLayout.addWidget(self.warningTxt, 5, 1, 2, 1)
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.gridLayout_2 = QtWidgets.QGridLayout(self.tab_2)
self.gridLayout_2.setObjectName("gridLayout_2")
self.allOrdersTable = QtWidgets.QTableWidget(self.tab_2)
self.allOrdersTable.setObjectName("allOrdersTable")
self.allOrdersTable.setColumnCount(0)
self.allOrdersTable.setRowCount(0)
self.gridLayout_2.addWidget(self.allOrdersTable, 0, 0, 1, 1)
self.tabWidget.addTab(self.tab_2, "")
self.verticalLayout.addWidget(self.tabWidget)
self.label_6 = QtWidgets.QLabel(self.centralwidget)
self.label_6.setObjectName("label_6")
self.verticalLayout.addWidget(self.label_6)
self.allPrice = QtWidgets.QLabel(self.centralwidget)
self.allPrice.setText("")
self.allPrice.setObjectName("allPrice")
self.verticalLayout.addWidget(self.allPrice)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1163, 28))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(1)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.label_4.setText(_translate("MainWindow", "Цена за одну штуку"))
self.label_2.setText(_translate("MainWindow", "Введите Имя"))
self.amountOnStoreTxt.setText(_translate("MainWindow", "0"))
self.oneCashTxt.setText(_translate("MainWindow", "0"))
self.nextBtn.setText(_translate("MainWindow", "Продолжить"))
self.loadBtn.setText(_translate("MainWindow", "Load"))
self.delBtn.setText(_translate("MainWindow", "Удалить данные"))
self.label.setText(_translate("MainWindow", "Название товара:"))
self.label_3.setText(_translate("MainWindow", "Количество на складе:"))
self.label_5.setText(_translate("MainWindow", "Цена за все:"))
self.manyCashTxt.setText(_translate("MainWindow", "0"))
self.warningTxt.setText(_translate("MainWindow", "<html><head/><body><p><span style=\" font-weight:600; color:#cc0000;\"><br/></span></p></body></html>"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Оформление заказа"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("MainWindow", "Все заказы"))
self.label_6.setText(_translate("MainWindow", "Общая цена всех заказов:"))
| [
"hvendrix@gmail.com"
] | hvendrix@gmail.com |
3c659ac8a526bfbd6dfbb2790f5df442d5282cca | 60191b0af68fd154bcb8cd56dafe44611fe6914e | /pennylane/numpy/tensor.py | 03ec407671e0fefcf67ea426290da0140f7a18eb | [
"Apache-2.0"
] | permissive | pangara/pennylane | 4bef999cfbf480e6f83b497afc2310735404c18d | 927c4c67a1e1f9c79a5d7d4e89c496fac418657f | refs/heads/master | 2023-09-04T17:26:40.921980 | 2021-11-15T14:56:09 | 2021-11-15T14:56:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 11,370 | py | # Copyright 2018-2021 Xanadu Quantum Technologies Inc.
# 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.
"""
This module provides the PennyLane :class:`~.tensor` class.
"""
import numpy as onp
from autograd import numpy as _np
from autograd.extend import primitive, defvjp
from autograd.tracer import Box
from autograd.numpy.numpy_boxes import ArrayBox
from autograd.numpy.numpy_vspaces import ComplexArrayVSpace, ArrayVSpace
from autograd.core import VSpace
__doc__ = "NumPy with automatic differentiation support, provided by Autograd and PennyLane."
# Hotfix since _np.asarray doesn't have a gradient rule defined.
@primitive
def asarray(vals, *args, **kwargs):
"""Gradient supporting autograd asarray"""
if isinstance(vals, (onp.ndarray, _np.ndarray)):
return _np.asarray(vals, *args, **kwargs)
return _np.array(vals, *args, **kwargs)
def asarray_gradmaker(ans, *args, **kwargs):
"""Gradient maker for asarray"""
del ans, args, kwargs
return lambda g: g
defvjp(asarray, asarray_gradmaker, argnums=(0,))
class tensor(_np.ndarray):
"""Constructs a PennyLane tensor for use with Autograd QNodes.
The ``tensor`` class is a subclass of ``numpy.ndarray``,
providing the same multidimensional, homogeneous data-structure
of fixed-size items, with an additional flag to indicate to PennyLane
whether the contained data is differentiable or not.
.. warning::
PennyLane ``tensor`` objects are only used as part of the Autograd QNode
interface. If using another machine learning library such as PyTorch or
TensorFlow, use their built-in ``tf.Variable`` and ``torch.tensor`` classes
instead.
.. warning::
Tensors should be constructed using standard array construction functions
provided as part of PennyLane's NumPy implementation, including
``np.array``, ``np.zeros`` or ``np.empty``.
The parameters given here refer to a low-level class
for instantiating tensors.
Args:
input_array (array_like): Any data structure in any form that can be converted to
an array. This includes lists, lists of tuples, tuples, tuples of tuples,
tuples of lists and ndarrays.
requires_grad (bool): whether the tensor supports differentiation
**Example**
The trainability of a tensor can be set on construction via the
``requires_grad`` keyword argument,
>>> from pennylane import numpy as np
>>> x = np.array([0, 1, 2], requires_grad=True)
>>> x
tensor([0, 1, 2], requires_grad=True)
or in-place by modifying the ``requires_grad`` attribute:
>>> x.requires_grad = False
tensor([0, 1, 2], requires_grad=False)
Since tensors are subclasses of ``np.ndarray``, they can be provided as arguments
to any PennyLane-wrapped NumPy function:
>>> np.sin(x)
tensor([0. , 0.84147098, 0.90929743], requires_grad=True)
When composing functions of multiple tensors, if at least one input tensor is differentiable,
then the output will also be differentiable:
>>> x = np.array([0, 1, 2], requires_grad=False)
>>> y = np.zeros([3], requires_grad=True)
>>> np.vstack([x, y])
tensor([[0., 1., 2.],
[0., 0., 0.]], requires_grad=True)
"""
def __new__(cls, input_array, *args, requires_grad=True, **kwargs):
obj = asarray(input_array, *args, **kwargs)
if isinstance(obj, onp.ndarray):
obj = obj.view(cls)
obj.requires_grad = requires_grad
return obj
def __array_finalize__(self, obj):
# pylint: disable=attribute-defined-outside-init
if obj is None: # pragma: no cover
return
self.requires_grad = getattr(obj, "requires_grad", None)
def __repr__(self):
string = super().__repr__()
return string[:-1] + ", requires_grad={})".format(self.requires_grad)
def __array_wrap__(self, obj):
out_arr = tensor(obj, requires_grad=self.requires_grad)
return super().__array_wrap__(out_arr)
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
# pylint: disable=no-member,attribute-defined-outside-init
# unwrap any outputs the ufunc might have
outputs = [i.view(onp.ndarray) for i in kwargs.get("out", ())]
if outputs:
# Insert the unwrapped outputs into the keyword
# args dictionary, to be passed to ndarray.__array_ufunc__
outputs = tuple(outputs)
kwargs["out"] = outputs
else:
# If the ufunc has no ouputs, we simply
# create a tuple containing None for all potential outputs.
outputs = (None,) * ufunc.nout
# unwrap the input arguments to the ufunc
args = [i.unwrap() if hasattr(i, "unwrap") else i for i in inputs]
# call the ndarray.__array_ufunc__ method to compute the result
# of the vectorized ufunc
res = super().__array_ufunc__(ufunc, method, *args, **kwargs)
if ufunc.nout == 1:
res = (res,)
# construct a list of ufunc outputs to return
ufunc_output = [
(onp.asarray(result) if output is None else output)
for result, output in zip(res, outputs)
]
# if any of the inputs were trainable, the output is also trainable
requires_grad = any(
isinstance(x, onp.ndarray) and getattr(x, "requires_grad", True) for x in inputs
)
# Iterate through the ufunc outputs and convert each to a PennyLane tensor.
# We also correctly set the requires_grad attribute.
for i in range(len(ufunc_output)): # pylint: disable=consider-using-enumerate
ufunc_output[i] = tensor(ufunc_output[i], requires_grad=requires_grad)
if len(ufunc_output) == 1:
# the ufunc has a single output so return a single tensor
return ufunc_output[0]
# otherwise we must return a tuple of tensors
return tuple(ufunc_output)
def __getitem__(self, *args, **kwargs):
item = super().__getitem__(*args, **kwargs)
if not isinstance(item, tensor):
item = tensor(item, requires_grad=self.requires_grad)
return item
def __hash__(self):
if self.ndim == 0:
# Allowing hashing if the tensor is a scalar.
# We hash both the scalar value *and* the differentiability information,
# to match the behaviour of PyTorch.
return hash((self.item(), self.requires_grad))
raise TypeError("unhashable type: 'numpy.tensor'")
def __reduce__(self):
# Called when pickling the object.
# Numpy ndarray uses __reduce__ instead of __getstate__ to prepare an object for
# pickling. self.requires_grad needs to be included in the tuple returned by
# __reduce__ in order to be preserved in the unpickled object.
reduced_obj = super().__reduce__()
# The last (2nd) element of this tuple holds the data. Add requires_grad to this:
full_reduced_data = reduced_obj[2] + (self.requires_grad,)
return (reduced_obj[0], reduced_obj[1], full_reduced_data)
def __setstate__(self, reduced_obj) -> None:
# Called when unpickling the object.
# Set self.requires_grad with the last element in the tuple returned by __reduce__:
# pylint: disable=attribute-defined-outside-init
self.requires_grad = reduced_obj[-1]
# And call parent's __setstate__ without this element:
super().__setstate__(reduced_obj[:-1])
def unwrap(self):
"""Converts the tensor to a standard, non-differentiable NumPy ndarray or Python scalar if
the tensor is 0-dimensional.
All information regarding differentiability of the tensor will be lost.
.. warning::
The returned array is a new view onto the **same data**. That is,
the tensor and the returned ``ndarray`` share the same underlying storage.
Changes to the tensor object will be reflected within the returned array,
and vice versa.
**Example**
>>> from pennylane import numpy as np
>>> x = np.array([1, 2], requires_grad=True)
>>> x
tensor([1, 2], requires_grad=True)
>>> x.unwrap()
array([1, 2])
Zero dimensional array are converted to Python scalars:
>>> x = np.array(1.543, requires_grad=False)
>>> x.unwrap()
1.543
>>> type(x.unwrap())
float
The underlying data is **not** copied:
>>> x = np.array([1, 2], requires_grad=True)
>>> y = x.unwrap()
>>> x[0] = 5
>>> y
array([5, 2])
>>> y[1] = 7
>>> x
tensor([5, 7], requires_grad=True)
To create a copy, the ``copy()`` method can be used:
>>> x = np.array([1, 2], requires_grad=True)
>>> y = x.unwrap().copy()
>>> x[0] = 5
>>> y
array([1, 2])
"""
if self.ndim == 0:
return self.view(onp.ndarray).item()
return self.view(onp.ndarray)
def numpy(self):
"""Converts the tensor to a standard, non-differentiable NumPy ndarray or Python scalar if
the tensor is 0-dimensional.
This method is an alias for :meth:`~.unwrap`. See :meth:`~.unwrap` for more details.
"""
return self.unwrap()
class NonDifferentiableError(Exception):
"""Exception raised if attempting to differentiate non-trainable
:class:`~.tensor` using Autograd."""
def tensor_to_arraybox(x, *args):
"""Convert a :class:`~.tensor` to an Autograd ``ArrayBox``.
Args:
x (array_like): Any data structure in any form that can be converted to
an array. This includes lists, lists of tuples, tuples, tuples of tuples,
tuples of lists and ndarrays.
Returns:
autograd.numpy.numpy_boxes.ArrayBox: Autograd ArrayBox instance of the array
Raises:
NonDifferentiableError: if the provided tensor is non-differentiable
"""
if isinstance(x, tensor):
if x.requires_grad:
return ArrayBox(x, *args)
raise NonDifferentiableError(
"{} is non-differentiable. Set the requires_grad attribute to True.".format(x)
)
return ArrayBox(x, *args)
Box.type_mappings[tensor] = tensor_to_arraybox
VSpace.mappings[tensor] = lambda x: ComplexArrayVSpace(x) if onp.iscomplexobj(x) else ArrayVSpace(x)
| [
"noreply@github.com"
] | pangara.noreply@github.com |
15e88c17de45964869546640b4a7a7f3994023b8 | 04d3806c96472eebf0204c2d274ad4f530ee383f | /src/pytorch-project/networks/MyModel.py | fdf714a69d3d71b054a203a02c27fa8f1fdf5a3d | [
"MIT"
] | permissive | zyongbei/ADNI_Data_processing | 3080b73a44f721fb9fc70dcb0e5a171c7817fd96 | 454462d3913d77e3bc4de2b9725b456301c7b351 | refs/heads/master | 2023-01-19T00:03:03.051512 | 2020-11-18T16:50:54 | 2020-11-18T16:50:54 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 9,203 | py |
import os
import sys
import pickle
import errno
import random
import numpy as np
import torch
import torchvision
import torch.nn.functional as F
from torch import nn
from torch import optim
from torch.utils.data.dataset import Dataset
from torch.utils.data import Dataset, DataLoader
from torchvision.datasets import DatasetFolder
from torchvision import transforms
from torchsummary import summary
import matplotlib.pyplot as plt
# for pickle load
# sys.path.append('/home/karim/workspace/vscode/ADNI_Data_processing/src/data-processing/') # labri Machine
sys.path.append('/home/karim/workspace/vscode-python/ADNI_codesources/kaderghal/src/data-processing/') # home machine
# root_path = '/home/karim/workspace/ADNI_workspace/results/ADNI_des/F_28P_F1_MS2_MB10D/HIPP/3D/AD-NC/' # labri machine
root_path = '/home/karim/workspace/ADNI_workspace/results/ADNI_des/F_28P_F1_MS2_MB10D/HIPP/3D/AD-NC/' # Home machine
# 1 pickle loader (load one sample)
def pickle_loader(path_file):
dir_name = os.path.dirname(path_file)
with open(path_file, 'rb') as f:
model_adni = pickle.load(f)
return model_adni
# to check if the file type is allowed
def has_file_allowed_extension(filename, extensions):
return filename.lower().endswith(extensions)
def is_image_file(filename):
return has_file_allowed_extension(filename, ADNI_MODEL_EXTENSIONS)
# function
def make_dataset(dir, class_to_idx, extensions=None, is_valid_file=None):
images = []
dir = os.path.expanduser(dir)
if not ((extensions is None) ^ (is_valid_file is None)):
raise ValueError("Both extensions and is_valid_file cannot be None or not None at the same time")
if extensions is not None:
def is_valid_file(x):
return has_file_allowed_extension(x, extensions)
for target in sorted(class_to_idx.keys()):
d = os.path.join(dir, target)
if not os.path.isdir(d):
continue
for root, _, fnames in sorted(os.walk(d)):
for fname in sorted(fnames):
path = os.path.join(root, fname)
if is_valid_file(path):
item = (path, class_to_idx[target])
images.append(item)
return images
# Class Datafolder
class Dataset_ADNI_Folder(DatasetFolder):
# Methodes
def __init__(self, root, loader, extensions=None, transform=None, target_transform=None, is_valid_file=None):
self.root = root
classes, class_to_idx = self._find_classes(self.root)
samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file)
if len(samples) == 0:
raise (RuntimeError("Found 0 files in subfolders of: " + self.root + "\n"
"Supported extensions are: " + ",".join(extensions)))
self.loader = loader
self.extensions = extensions
self.classes = classes
self.class_to_idx = class_to_idx
self.samples = samples
self.transform = transforms.Compose([transforms.ToTensor()])
self.targets = [s[1] for s in samples]
# __getitem__
def __getitem__(self, index):
path, target = self.samples[index]
sample = self.loader(path)
# if self.transform is not None:
# sample = self.transform(sample)
# if self.target_transform is not None:
# target = self.target_transform(target)
# sample is objet instance from HippModel (L, R, V, Label)
return (sample.hippLeft, sample.hippRight, sample.hippMetaDataVector, target)
# __len__
def __len__(self):
return len(self.samples)
# _find_classes
def _find_classes(self, dir):
if sys.version_info >= (3, 5):
# Faster and available in Python 3.5 and above
classes = [d.name for d in os.scandir(dir) if d.is_dir()]
else:
classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))]
classes.sort()
class_to_idx = {classes[i]: i for i in range(len(classes))}
return classes, class_to_idx
# one stream network
class OneStreamNet(nn.Module):
def __init__(self):
super(OneStreamNet, self).__init__()
self.conv1 = nn.Conv3d(1, 32, kernel_size=3 ,stride=1, padding=0)
self.conv2 = nn.Conv3d(32, 64, kernel_size=3 ,stride=1, padding=0)
self.pool1 = nn.MaxPool3d(kernel_size=(3,3,3), stride=2, padding=0)
self.pool2 = nn.MaxPool3d(kernel_size=(3,3,3), stride=2, padding=0)
self.relu1 = nn.ReLU(inplace=True)
self.relu2 = nn.ReLU(inplace=True)
# Defining the fully connected layers
self.fc1 = nn.Linear(30000, 1024)
self.fc2 = nn.Linear(1024, 2)
def forward(self, x):
# x = x.view(32,28,28,28)
# x = x.view(x.size(0), -1)
x = self.conv1(x)
x = self.pool1(x)
x = self.relu1(x)
x = self.conv2(x)
x = self.pool2(x)
x = self.relu2(x)
x = self.fc1(x)
x = self.fc2(x)
return x
# Network
class Net(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 64, 7)
self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(64, 128, 5)
self.conv3 = nn.Conv2d(128, 256, 5)
self.linear1 = nn.Linear(2304, 512)
self.linear2 = nn.Linear(512, 2)
def forward(self, data):
res = []
for i in range(2): # Siamese nets; sharing weights
x = data[i]
x = self.conv1(x)
x = F.relu(x)
x = self.pool1(x)
x = self.conv2(x)
x = F.relu(x)
x = self.conv3(x)
x = F.relu(x)
x = x.view(x.shape[0], -1)
x = self.linear1(x)
res.append(F.relu(x))
res = torch.abs(res[1] - res[0])
res = self.linear2(res)
return res
# Train function
def train(model, device, train_loader, epoch, optimizer):
pass
# Test function
def test(model, device, test_loader):
pass
#---------------------------------------------------------------
# _________________________ Main ___________________________
#---------------------------------------------------------------
def main():
# Training params
num_workers = 1
num_classes = 2
save_frequency = 2
batch_size = 1
lr = 0.001
num_epochs = 1
weight_decay = 0.0001
# dataset folder loader
train_data = Dataset_ADNI_Folder(root=root_path + 'train/', loader=pickle_loader, extensions='.pkl', transform=None)
valid_data = Dataset_ADNI_Folder(root=root_path + 'valid/', loader=pickle_loader, extensions='.pkl', transform=None)
test_data = Dataset_ADNI_Folder(root=root_path + 'test/' , loader=pickle_loader, extensions='.pkl', transform=None)
# dataloader
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers)
valid_loader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, shuffle=True, num_workers=num_workers)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=True, num_workers=num_workers)
# select device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print("device: {}".format(device))
model = OneStreamNet().to(device)
summary(model, (1, 28, 28, 28))
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
# Train the model
total_step = len(train_loader)
loss_list = []
acc_list = []
# for epoch in range(num_epochs):
# # for i, (images, labels) in enumerate(train_loader):
# for i, (d1, d2, v, labels) in enumerate(train_loader):
# print(i)
# # Run the forward pass
# d1 = torch.unsqueeze(d1, 0).to(device, dtype=torch.float)
# outputs = model(d1)
# loss = criterion(outputs, labels)
# loss_list.append(loss.item())
# # Backprop and perform Adam optimisation
# optimizer.zero_grad()
# loss.backward()
# optimizer.step()
# # Track the accuracy
# total = labels.size(0)
# _, predicted = torch.max(outputs.data, 1)
# correct = (predicted == labels).sum().item()
# acc_list.append(correct / total)
# if (i + 1) % 100 == 0:
# print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}, Accuracy: {:.2f}%'
# .format(epoch + 1, num_epochs, i + 1, total_step, loss.item(),
# (correct / total) * 100))
# for epoch in range(num_epochs):
# train(model, device, train_loader, epoch, optimizer)
# test(model, device, test_loader)
# if epoch & save_frequency == 0:
# torch.save(model, 'siamese_{:03}.pt'.format(epoch))
# __start__
if __name__ == '__main__':
main() | [
"aderghal.karim@gmail.com"
] | aderghal.karim@gmail.com |
59838aa6774d3008438de4f849c0fdf288720307 | a458b7ce4d6b08cc3d0aef0ebca2f1a30a20993b | /eco/migrations/0005_auto_20190415_1532.py | 34f9250f00b5b2662e23756601217f8856b31f4d | [] | no_license | aclayton001/diy2.0 | daaf338b56abc47131faecc9ab1f1b245a8d331e | 2fc381e3d481b117a9ac3e1df3084ad657f7a421 | refs/heads/master | 2020-05-20T08:52:53.848418 | 2019-05-07T21:56:54 | 2019-05-07T21:56:54 | 185,483,401 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 786 | py | # Generated by Django 2.1.7 on 2019-04-15 15:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('eco', '0004_auto_20190414_0014'),
]
operations = [
migrations.CreateModel(
name='Author',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('last_name', models.CharField(max_length=256)),
('first_name', models.CharField(max_length=256)),
],
),
migrations.AddField(
model_name='article',
name='diy_files',
field=models.FileField(default='settings.MEDIA_ROOT/kit.jpg', upload_to='kit/%Y/%m/%D'),
),
]
| [
"aclayton001@outlook.com"
] | aclayton001@outlook.com |
26c1bf3393e74fe359f62019bcd01a096dc2a25a | f662aa3ce7896ca0283cae38df8ef824c1b80c9a | /examples/larson_hue.py | e59f5ae5199f37f0ab3c97b555d030f940ee0d49 | [
"MIT"
] | permissive | pimoroni/plasma | bd7ddebbc60ae7cc9c2561408b52fc46bf810672 | 7857c44255285aac061a9064dd033fd63bbbda29 | refs/heads/master | 2023-02-10T13:27:17.565867 | 2023-01-30T17:27:28 | 2023-01-30T17:27:28 | 155,544,928 | 12 | 9 | MIT | 2021-11-06T04:14:19 | 2018-10-31T11:17:40 | Python | UTF-8 | Python | false | false | 1,548 | py | #!/usr/bin/env python3
import math
import time
import colorsys
from plasma import auto
NUM_PIXELS = 10 * 4
FALLOFF = 1.9
SCAN_SPEED = 4
plasma = auto(default=f"GPIO:14:15:pixel_count={NUM_PIXELS}")
if plasma.get_pixel_count() == 1:
raise RuntimeError("Uh, you can't larson scan *one* pixel!?")
plasma.set_clear_on_exit()
start_time = time.time()
while True:
delta = (time.time() - start_time)
# Offset is a sine wave derived from the time delta
# we use this to animate both the hue and larson scan
# so they are kept in sync with each other
offset = (math.sin(delta * SCAN_SPEED) + 1) / 2
# Use offset to pick the right colour from the hue wheel
hue = int(round(offset * 360))
# Maximum number basex on NUM_PIXELS
max_val = plasma.get_pixel_count() - 1
# Now we generate a value from 0 to max_val
offset = int(round(offset * max_val))
for x in range(plasma.get_pixel_count()):
sat = 1.0
val = max_val - (abs(offset - x) * FALLOFF)
val /= float(max_val) # Convert to 0.0 to 1.0
val = max(val, 0.0) # Ditch negative values
xhue = hue # Grab hue for this pixel
xhue += (1 - val) * 10 # Use the val offset to give a slight colour trail variation
xhue %= 360 # Clamp to 0-359
xhue /= 360.0 # Convert to 0.0 to 1.0
r, g, b = [int(c * 255) for c in colorsys.hsv_to_rgb(xhue, sat, val)]
plasma.set_pixel(x, r, g, b, val)
plasma.show()
time.sleep(0.001)
| [
"phil@gadgetoid.com"
] | phil@gadgetoid.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.