content stringlengths 5 1.05M |
|---|
import os
import shutil
import pytest
from PrognosAIs import Pipeline
CONFIG_FILE = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "test_data", "test_config.yaml"
)
CONFIG_FILE_CUSTOM = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "test_data", "test_config_custom_functions.yaml"
)
OUTPUT_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "output")
def test_init():
pipeline = Pipeline.Pipeline(CONFIG_FILE)
output_folder = pipeline.output_folder
shutil.rmtree(output_folder)
def test_run_pipeline():
pipeline = Pipeline.Pipeline(CONFIG_FILE)
pipeline.start_local_pipeline()
output_folder = pipeline.output_folder
shutil.rmtree(output_folder)
def test_run_pipeline_preprocess_only():
pipeline = Pipeline.Pipeline(CONFIG_FILE, train=False)
pipeline.start_local_pipeline()
output_folder = pipeline.output_folder
assert os.path.exists(os.path.join(output_folder, "Samples"))
assert not os.path.exists(os.path.join(output_folder, "MODEL"))
shutil.rmtree(output_folder)
def test_run_pipeline_custom_functions():
pipeline = Pipeline.Pipeline(CONFIG_FILE_CUSTOM)
pipeline.start_local_pipeline()
output_folder = pipeline.output_folder
shutil.rmtree(output_folder)
|
from pyzbar import pyzbar
import cv2
img_path = 'xx.TIF'
img = cv2.imread(img_path)
barcodes = pyzbar.decode(img)
for barcode in barcodes:
(x, y, w, h) = barcode.rect
# cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2)
barcodeData = barcode.data.decode("utf-8")
barcodeType = barcode.type
# text = "{} ({})".format(barcodeData, barcodeType)
# cv2.putText(img, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
# print("[INFO] found {} barcode {}".format(barcodeType, barcodeData))
cv2.imwrite("new_img.jpg", img) |
NO_RESULTS_TEXT = '//div[@id="content"]//div[@class="row result"]/div/text()'
|
from typing import Any
from pathlib import Path
import inspect
import rootpath
import os
def obj_module_path(obj: Any) -> str:
"""Get a module path for any given object"""
fp = Path(inspect.getfile(obj))
rp = Path(rootpath.detect())
local_path = str(fp.relative_to(rp))
clean_path = os.path.splitext(local_path)[0]
module_path = clean_path.replace("/", ".")
return module_path
|
import sublime
import sublime_plugin
import re
import logging
import hyperhelpcore as hh
def log(*args):
print("[PythonDocs]", *args)
def plugin_loaded():
hh.initialize()
class PythonDocsOpen(sublime_plugin.TextCommand):
pkg = "PythonDocs"
pkg_info = None
def run(self, _: None, topic: str = None):
if self.pkg_info is None:
self.pkg_info = hh.core.load_help_index(
"Packages/%s/help/hyperhelp.json" % self.pkg
)
log(self.pkg_info)
if self.pkg_info is None:
log("PythonDocs hasn't been correctly loaded by HyperHelp")
return
topic = topic or self.get_topic()
topic_exists = hh.core.lookup_help_topic(self.pkg_info, topic)
if topic_exists:
return sublime.run_command(
"hyperhelp_topic", {"package": self.pkg, "topic": topic}
)
sublime.run_command("hyperhelp_index", {"package": self.pkg})
window = self.view.window()
if window is None:
return
window.run_command("insert", {"characters": topic})
def get_topic(self) -> str:
"""Uses the word under the cursor as topic.
Extends the word to the left if possible:
pathlib.Pa|th -> pathlib.Path
path|lib.Path -> pathlib
(foo / "readme.txt").exp|anduser -> expanduser
"""
view = self.view
selection = view.sel()[0]
extend = selection.empty()
selection = view.word(selection)
while extend and view.substr(selection.begin() - 1) == ".":
extended = selection.cover(view.word(selection.begin() - 2))
if not re.match(r"^\w[\w\d_]+\.", self.view.substr(extended)):
break
selection = extended
topic = self.view.substr(selection)
return topic
# For testing
# pathlib.Path
# pathlib.Path("~/foo").expanduser()
# pathlib.Path.expanduser
|
import pandas as pd
# Load PUMS records
df_pums_persons = pd.read_csv(r'R:\SyntheticPopulation_2018\group_quarters\input_files\seed_persons_gq.csv')
df_pums_households = pd.read_csv(r'R:\SyntheticPopulation_2018\group_quarters\input_files\seed_households_gq.csv')
# Load block group level group quarters data from OFM
df_ofm_bg = pd.read_csv(r'R:\SyntheticPopulation_2018\group_quarters\input_files\ofm_bg_gq_2018.csv')
# Calculate distributions for each PUMA
# Classify by income
df_pums_persons['income_group'] = "inc_missing"
df_pums_persons.loc[df_pums_persons['PINCP'] < 10000, "income_group"] = 'inc_under_10'
df_pums_persons.loc[(df_pums_persons['PINCP'] <25000) & (df_pums_persons['PINCP'] >= 10000), "income_group"] = 'inc_10_25'
df_pums_persons.loc[(df_pums_persons['PINCP'] <50000) & (df_pums_persons['PINCP'] >= 25000), "income_group"] = 'inc_25_50'
df_pums_persons.loc[df_pums_persons['PINCP'] > 50000, "income_group"] = 'inc_over_50'
# Classify by age
df_pums_persons['age_group'] = "age_missing"
df_pums_persons.loc[df_pums_persons['AGEP'] < 18, "age_group"] = 'age_0_17'
df_pums_persons.loc[(df_pums_persons['AGEP'] <25) & (df_pums_persons['AGEP'] >= 18), "age_group"] = 'age_18_24'
df_pums_persons.loc[(df_pums_persons['AGEP'] <35) & (df_pums_persons['AGEP'] >= 25), "age_group"] = 'age_25_34'
df_pums_persons.loc[(df_pums_persons['AGEP'] <45) & (df_pums_persons['AGEP'] >= 35), "age_group"] = 'age_35_45'
df_pums_persons.loc[(df_pums_persons['AGEP'] <55) & (df_pums_persons['AGEP'] >= 45), "age_group"] = 'age_45_54'
df_pums_persons.loc[(df_pums_persons['AGEP'] <65) & (df_pums_persons['AGEP'] >= 55), "age_group"] = 'age_55_64'
df_pums_persons.loc[(df_pums_persons['AGEP'] <75) & (df_pums_persons['AGEP'] >= 65), "age_group"] = 'age_65_74'
df_pums_persons.loc[df_pums_persons['AGEP'] >= 75, "age_group"] = 'age_over_75'
# Classify by worker type
df_pums_persons['worker_status'] = 'nonworker'
df_pums_persons.loc[df_pums_persons['ESR'].isin([1,2,4,5]), "worker_status"] = 'worker'
# CLassify by gender
df_pums_persons['sex_category'] = 'female'
df_pums_persons.loc[df_pums_persons['SEX'] == 1, 'sex_category'] = 'male'
# CLassify by school status
df_pums_persons['school_category'] = 'nonstudent'
df_pums_persons.loc[df_pums_persons['SCH'].isin([2,3]), 'school_category'] = 'student'
agg_cols = ['age_group','income_group','worker_status','sex_category','school_category']
# Get total pums records by PUMA to calcualte shares across agg categories
df = df_pums_persons.groupby('PUMA').count()
df.rename(columns={'REGION': 'puma_tot_gq_pop'}, inplace=True)
for col in agg_cols:
_df = df_pums_persons.groupby([col,'PUMA']).count()[['REGION']].reset_index()
_df.rename(columns={'REGION':col+'_puma_tot'}, inplace=True)
_df = _df.pivot_table(index='PUMA',columns=col, values=col+'_puma_tot', aggfunc='sum').fillna(0).reset_index()
df = df.merge(_df, on='PUMA')
df = df.merge(df_ofm_bg[['PUMA','GQ2018','GEOID10','block_group_id']], on='PUMA')
df['GQ2018_hh'] = df['GQ2018'].copy().astype('int')
df['GQ2018_pop'] = df['GQ2018'].copy().astype('int')
# Add the state ID to the block_group_id field
df['block_group_id'] = '53' + df['block_group_id'].astype('str')
df.to_csv(r'R:\SyntheticPopulation_2018\group_quarters\input_files\bg_gq_control_targets.csv', index=False) |
# Demo Python Numbers - Complex
'''
Python Numbers
There are three numeric types in Python:
* int
* float
* complex
Variables of numeric types are created when you assign a value to them.
To verify the type of any object in Python, use the type() function.
'''
# Complex numbers are written with a "j" as the imaginary part:
x = 3+5j
y = 5j
z = -5j
print(type(x))
print(type(y))
print(type(z)) |
from string import Template
# language=bash
download_command = Template(
"""
curl -L -s -o xz.tar.gz "https://tukaani.org/xz/xz-${version}.tar.gz"
"""
)
# language=bash
extract_command = Template(
"""
rm -rf "xz-${target}"
tar xf xz.tar.gz
mv "xz-${version}" "xz-${target}"
"""
)
# language=bash
make_command = Template(
"""
pushd ./xz-${target} >/dev/null
./configure \
CFLAGS="${cflags}" \
MACOSX_DEPLOYMENT_TARGET="${deployment_target}" \
--disable-debug \
--disable-dependency-tracking \
--disable-silent-rules \
--disable-shared \
--disable-xz \
--disable-xzdec \
--disable-lzmadec \
--disable-lzmainfo \
--disable-lzma-links \
--disable-scripts \
--disable-doc \
--host="${host}" \
--prefix="${install_path}"
make MACOSX_DEPLOYMENT_TARGET="${deployment_target}" install
popd >/dev/null
"""
)
# language=bash
build_universal_and_install_command = Template(
"""
lipo -create -output "${install_lib_path}/liblzma.a" "${arm64_lib_path}/liblzma.a" "${x86_64_lib_path}/liblzma.a"
cp -r "${arm64_include_path}"/* "${install_include_path}"
"""
)
|
crypto_list = ["bitcoin", "ethereum", "monero"]
print(crypto_list)
crypto = crypto_list[-2]
print(crypto)
|
import pytest
from aioarango.collection import StandardCollection
from aioarango.database import StandardDatabase, TransactionDatabase
from aioarango.exceptions import (
TransactionAbortError,
TransactionCommitError,
TransactionExecuteError,
TransactionInitError,
TransactionStatusError,
)
from aioarango.graph import Graph
from tests.helpers import extract
pytestmark = pytest.mark.asyncio
async def test_transaction_execute_raw(
db: StandardDatabase, col: StandardCollection, docs
):
# Test execute raw transaction
doc = docs[0]
key = doc["_key"]
result = await db.execute_transaction(
command=f"""
function (params) {{
var db = require('internal').db;
db.{col.name}.save({{'_key': params.key, 'val': 1}});
return true;
}}
""",
params={"key": key},
write=[col.name],
read=[col.name],
sync=False,
timeout=1000,
max_size=100000,
allow_implicit=True,
intermediate_commit_count=10,
intermediate_commit_size=10000,
)
assert result is True
assert col.has(doc, check_rev=False) and (await col.get(key))["val"] == 1
# Test execute invalid transaction
with pytest.raises(TransactionExecuteError) as err:
await db.execute_transaction(command="INVALID COMMAND")
assert err.value.error_code == 10
async def test_transaction_init(
db: StandardDatabase, bad_db: StandardDatabase, col: StandardCollection, username
):
txn_db = await db.begin_transaction()
assert isinstance(txn_db, TransactionDatabase)
assert txn_db.username == username
assert txn_db.context == "transaction"
assert txn_db.db_name == db.name
assert txn_db.name == db.name
assert txn_db.transaction_id is not None
assert repr(txn_db) == f"<TransactionDatabase {db.name}>"
txn_col = txn_db.collection(col.name)
assert txn_col.username == username
assert txn_col.context == "transaction"
assert txn_col.db_name == db.name
txn_aql = txn_db.aql
assert txn_aql.username == username
assert txn_aql.context == "transaction"
assert txn_aql.db_name == db.name
with pytest.raises(TransactionInitError) as err:
await bad_db.begin_transaction()
assert err.value.error_code in {11, 1228}
async def test_transaction_status(db: StandardDatabase, col: StandardCollection, docs):
txn_db = await db.begin_transaction(read=col.name)
assert await txn_db.transaction_status() == "running"
await txn_db.commit_transaction()
assert await txn_db.transaction_status() == "committed"
txn_db = await db.begin_transaction(read=col.name)
assert await txn_db.transaction_status() == "running"
await txn_db.abort_transaction()
assert await txn_db.transaction_status() == "aborted"
# Test transaction_status with an illegal transaction ID
txn_db._executor._id = "illegal"
with pytest.raises(TransactionStatusError) as err:
await txn_db.transaction_status()
assert err.value.error_code in {10, 1655}
async def test_transaction_commit(db: StandardDatabase, col: StandardCollection, docs):
txn_db = await db.begin_transaction(
read=col.name,
write=col.name,
exclusive=[],
sync=True,
allow_implicit=False,
lock_timeout=1000,
max_size=10000,
)
txn_col = txn_db.collection(col.name)
assert "_rev" in await txn_col.insert(docs[0])
assert "_rev" in await txn_col.delete(docs[0])
assert "_rev" in await txn_col.insert(docs[1])
assert "_rev" in await txn_col.delete(docs[1])
assert "_rev" in await txn_col.insert(docs[2])
await txn_db.commit_transaction()
assert extract("_key", [doc async for doc in await col.all()]) == [docs[2]["_key"]]
assert await txn_db.transaction_status() == "committed"
# Test commit_transaction with an illegal transaction ID
txn_db._executor._id = "illegal"
with pytest.raises(TransactionCommitError) as err:
await txn_db.commit_transaction()
assert err.value.error_code in {10, 1655}
async def test_transaction_abort(db: StandardDatabase, col: StandardCollection, docs):
txn_db = await db.begin_transaction(write=col.name)
txn_col = txn_db.collection(col.name)
assert "_rev" in await txn_col.insert(docs[0])
assert "_rev" in await txn_col.delete(docs[0])
assert "_rev" in await txn_col.insert(docs[1])
assert "_rev" in await txn_col.delete(docs[1])
assert "_rev" in await txn_col.insert(docs[2])
await txn_db.abort_transaction()
assert extract("_key", [doc async for doc in await col.all()]) == []
assert await txn_db.transaction_status() == "aborted"
txn_db._executor._id = "illegal"
with pytest.raises(TransactionAbortError) as err:
await txn_db.abort_transaction()
assert err.value.error_code in {10, 1655}
async def test_transaction_graph(db: StandardDatabase, graph: Graph, fvcol, fvdocs):
col_names = [
c["name"] for c in await db.collections() if c["name"].startswith("test")
]
txn_db = await db.begin_transaction(write=col_names)
vcol = txn_db.graph(graph.name).vertex_collection(fvcol.name)
await vcol.insert(fvdocs[0])
assert await vcol.count() == 1
await vcol.delete(fvdocs[0])
assert await vcol.count() == 0
await txn_db.commit_transaction()
|
import os
os.path.dirname(os.path.abspath(__file__)+'/../../')
from QNetbots.core_bot_api.matrix_bot_api import MatrixBotAPI
from QNetbots.core_bot_api.mregex_handler import MRegexHandler
from QNetbots.core_bot_api.mcommand_handler import MCommandHandler
class Bot(object):
def __init__(self, USERNAME,PASSWORD,SERVER):
self.bot = MatrixBotAPI(USERNAME,PASSWORD,SERVER)
def add_handler(self, handler):
self.bot.add_handler(handler)
def add_general_listener(self,handler):
self.bot.add_general_listener(handler)
def start_polling(self):
self.bot.start_polling()
def add_handlers(self, handlers):
for handler in handlers:
self.bot.add_handler(handler)
@staticmethod
def create_regex_base(regex, callback_f):
return MRegexHandler(regex, callback_f)
@staticmethod
def create_command(command, callback_f):
return MCommandHandler(command, callback_f)
|
print(int(input())%9) |
# noinspection PyUnresolvedReferences
import pypi_org.data.audit # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.downloads # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.languages # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.licenses # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.maintainers # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.package # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.releases # noqa: F401
# noinspection PyUnresolvedReferences
import pypi_org.data.users # noqa: F401
|
import json
from enum import Enum
import requests
class AIxResource:
__url = "https://api.aixsolutionsgroup.com/v1/"
class RequestMethod(Enum):
GET = "GET"
POST = "POST"
PATCH = "PATCH"
DELETE = "DELETE"
def __init__(self, api_key):
"""
Initializes the AIx Resource.
:param api_key: Your API key. To get an API key, go to api.aixsolutionsgroup.com. Sign in / sign up
and then click on the "API KEYS" tab.
"""
if type(api_key) is not str:
raise Exception("API key must be a string.")
self.api_key = api_key
def _get_headers(self):
"""
Get the headers with the appropriate authentication parameters
:return: The headers
"""
return {
'APIKey': self.api_key
}
def _request(self, payload, endpoint, request_method, files=None, headers=None):
"""
Makes a POST request.
:param payload: the payload containing the parameters
:param endpoint: the desired endpoint
:param request_method: the method (e.g. POST, GET, PATCH, DELETE)
:param files: files to send. only used when changing a profile image
:param headers: headers for the request. only specified when changing a profile image
:return:
"""
if headers is None:
headers = self._get_headers()
if files is None:
r = requests.request(
request_method.value,
url=self.__url + endpoint,
data=json.dumps(payload),
headers=headers
)
else:
r = requests.request(
request_method.value,
url=self.__url + endpoint,
data=payload,
files=files,
headers=headers
)
try:
json_content = json.loads(r.content)
except json.decoder.JSONDecodeError:
return r
return json_content
def compose(
self,
prompt: str,
response_length: int = 64,
temperature: float = 0.7,
top_p: float = 1.0,
stop_sequence: str = str()
):
"""
Sends a prompt to be completed by the GPT engine.
:param prompt: A string that prompts the AI. The AI will complete it.
:param response_length: Valid values 64 to 2048. The maximum number of tokens to generate. Requests can use up
to 2048 tokens shared between prompt and completion. (One token is roughly 4 characters for normal English
text.)
:param temperature: Valid values 0.00 to 1.00. Controls randomness. Lowering results in less random completions.
As the temperature approaches zero, the model will become deterministic and repetitive.
:param top_p: Valid values 0.00 to 1.00. Controls diversity via nucleus sampling: 0.5 means half of all
likelihood-weighted options are considered.
:param stop_sequence: A sequence where the API will stop generating further tokens. The returned text will not
contain the stop sequence.
:return:
:compute_time: The time taken to compute the response
:model: GPT-J-6B (Will vary in the future when we add more NLP models)
:text: The response by the AI
:prompt: The value you provided
:token_max_length: The value you provided
:temperature: The value you provided
:top_p: The value you provided
:stop_sequence: The value you provided
"""
assert type(response_length) is int
assert type(temperature) is float
assert type(top_p) is float
assert type(prompt) is str
assert type(stop_sequence) is str
return self._request(
payload={
"prompt": prompt,
"response_length": response_length,
"temperature": temperature,
"top_p": top_p,
"stop_sequence": stop_sequence
},
endpoint="compose",
request_method=self.RequestMethod.POST
)
|
import string
from typing import Text, Dict, List, Optional, Set
import streamlit
LANGUAGES = {
"en": "English",
"de": "Deutsch"
}
LANGUAGE = streamlit.sidebar.selectbox(
"🌍 Language",
list(LANGUAGES.keys()),
format_func=lambda lang: LANGUAGES[lang]
)
SHOW_SOURCE_LINK_TEXT = {
"en": "Show link to Source Code Repository",
"de": "Link zu Quelltext-Verzeichnis einblenden"
}
SOURCE_CODE_REPO_URL = "https://gitlab.com/schorfma/streamlit-hangman"
SELF_HOSTING_INFO_TEXT = {
"en": f"Host your own Hangman interface using <{SOURCE_CODE_REPO_URL}>",
"de": f"Hoste deine eigene Galgenraten-Oberfläche mit <{SOURCE_CODE_REPO_URL}>"
}
if streamlit.sidebar.checkbox(
SHOW_SOURCE_LINK_TEXT[LANGUAGE]
):
streamlit.info(
SELF_HOSTING_INFO_TEXT[LANGUAGE]
)
TITLE_TEXT = {
"en": "Streamlit Hangman",
"de": "Streamlit Galgenraten"
}
streamlit.title(
TITLE_TEXT[LANGUAGE]
)
INSTRUCTIONS_TEXT = {
"en": (
"1. Write your secret word into the input within the sidebar on the left.\n"
"2. Don't forget to hide the sidebar before sharing this page in the browser.\n"
"3. Happy Hangman playing!"
),
"de": (
"1. Schreibe dein geheimes Wort in das Eingabefeld in der Seitenleiste links.\n"
"2. Vergiss nicht die Seitenleiste wieder vor dem Teilen dieser Seite zu schließen\n"
"3. Viel Spaß beim Galgenraten!"
)
}
streamlit.markdown(
INSTRUCTIONS_TEXT[LANGUAGE]
)
ALPHABET: List[Text] = [
letter
for letter in string.ascii_uppercase
]
LETTER_PLACEHOLDER = "☐"
SPACE_CHARACTER = " "
SECRET_TEXT_INPUT_TEXT = {
"en": "Input the Secret word or words",
"de": "Gib das geheime Wort oder mehrere geheime Wörter ein"
}
SECRET_TEXT = streamlit.sidebar.text_input(
SECRET_TEXT_INPUT_TEXT[LANGUAGE]
).upper()
SECRET_TEXT = "".join(
[
character
if character in ALPHABET else " "
for character in SECRET_TEXT
]
)
MAX_WRONG_GUESSES_TEXT = {
"en": "Maximum number of wrong guesses",
"de": "Maximale Anzahl an falsch geratenen Buchstaben"
}
MAX_WRONG_GUESSES_DEFAULT = 6
MAX_WRONG_GUESSES = streamlit.sidebar.slider(
MAX_WRONG_GUESSES_TEXT[LANGUAGE],
value=MAX_WRONG_GUESSES_DEFAULT,
min_value=4,
max_value=10
)
SHOW_HANGMAN_IMAGES_TEXT = {
"en": "Show Hangman Images",
"de": "Galgenraten-Bilder anzeigen"
}
if MAX_WRONG_GUESSES == MAX_WRONG_GUESSES_DEFAULT:
SHOW_HANGMAN_IMAGES = streamlit.sidebar.checkbox(
SHOW_HANGMAN_IMAGES_TEXT[LANGUAGE],
value=True
)
else:
SHOW_HANGMAN_IMAGES = False
streamlit.sidebar.markdown(
f"~~{SHOW_HANGMAN_IMAGES_TEXT[LANGUAGE]}~~"
)
if SECRET_TEXT:
GUESSED_LETTERS_TEXT = {
"en": "Type letters to guess",
"de": "Gib Buchstaben zum Erraten ein"
}
GUESSED_LETTERS: Set[Text] = set(
streamlit.text_input(
GUESSED_LETTERS_TEXT[LANGUAGE]
)
)
GUESS_ALPHABET: Dict[Text, Optional[bool]] = {
letter: None
for letter in ALPHABET
}
for guessed_letter in [
guessed_letter.upper()
for guessed_letter in list(GUESSED_LETTERS)
if guessed_letter.upper() in ALPHABET
]:
GUESS_ALPHABET[guessed_letter] = bool(guessed_letter in SECRET_TEXT)
ALPHABET_LETTERS_STATUS_TEXT = {
"en": "Show status for the letters of the Alphabet",
"de": "Status der Buchstaben des Alphabets zeigen"
}
if streamlit.checkbox(ALPHABET_LETTERS_STATUS_TEXT[LANGUAGE]):
streamlit.write(GUESS_ALPHABET)
UNCOVERED_SECRET_TEXT: List[Text] = [
character if GUESS_ALPHABET.get(character) or character == SPACE_CHARACTER else LETTER_PLACEHOLDER
for character in SECRET_TEXT
]
WRONG_GUESSES = len(
[
value
for value in GUESS_ALPHABET.values()
if value == False
]
)
HANGMAN_IMAGES = [
"images/Hangman-0.png",
"images/Hangman-1.png",
"images/Hangman-2.png",
"images/Hangman-3.png",
"images/Hangman-4.png",
"images/Hangman-5.png",
"images/Hangman-6.png",
]
HANGMAN_IMAGES_SOURCE = [
"https://commons.wikimedia.org/wiki/File:Hangman-0.png",
"https://commons.wikimedia.org/wiki/File:Hangman-1.png",
"https://commons.wikimedia.org/wiki/File:Hangman-2.png",
"https://commons.wikimedia.org/wiki/File:Hangman-3.png",
"https://commons.wikimedia.org/wiki/File:Hangman-4.png",
"https://commons.wikimedia.org/wiki/File:Hangman-5.png",
"https://commons.wikimedia.org/wiki/File:Hangman-6.png"
]
if SHOW_HANGMAN_IMAGES:
streamlit.image(
HANGMAN_IMAGES[
min(
WRONG_GUESSES,
MAX_WRONG_GUESSES_DEFAULT
)
]
)
IMAGE_LICENSE_LINK = "[Creative Commons Attribution-Share Alike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/deed.en)"
IMAGE_AUTHOR_LINK = "[Demi](https://en.wikipedia.org/wiki/User:Demi)"
IMAGE_SOURCE_TEXT = {
"en": (
f"* Image License: {IMAGE_LICENSE_LINK}\n"
f"* Image Author: User {IMAGE_AUTHOR_LINK} on English Wikipedia\n"
f"* Image Source: <{HANGMAN_IMAGES_SOURCE[min(WRONG_GUESSES, MAX_WRONG_GUESSES_DEFAULT)]}>"
),
"de": (
f"* Bildlizenz: {IMAGE_LICENSE_LINK}\n"
f"* Bildautor: Benutzer {IMAGE_AUTHOR_LINK} auf der englischen Wikipedia\n"
f"* Bildquelle: <{HANGMAN_IMAGES_SOURCE[min(WRONG_GUESSES, MAX_WRONG_GUESSES_DEFAULT)]}>"
)
}
streamlit.info(
IMAGE_SOURCE_TEXT[LANGUAGE]
)
streamlit.markdown(
f"# `{''.join(UNCOVERED_SECRET_TEXT)}`"
)
WRONGLY_GUESSED_LETTERS_TEXT = {
"en": "Wrongly guessed letters",
"de": "Falsch geratene Buchstaben"
}
streamlit.subheader(
f"{WRONGLY_GUESSED_LETTERS_TEXT[LANGUAGE]}: `{WRONG_GUESSES}`/ `{MAX_WRONG_GUESSES}`"
)
GAME_OVER_TEXT = {
"en": "Game Over!",
"de": "Spiel verloren!"
}
GAME_WON_TEXT = {
"en": "Game Won!",
"de": "Spiel gewonnen!"
}
GAME_UNDECIDED_TEXT = {
"en": "Game is not decided, yet",
"de": "Spiel ist noch nicht entschieden"
}
if WRONG_GUESSES >= MAX_WRONG_GUESSES:
streamlit.error(
f"### {GAME_OVER_TEXT[LANGUAGE]}"
)
elif LETTER_PLACEHOLDER not in UNCOVERED_SECRET_TEXT:
streamlit.success(
f"### {GAME_WON_TEXT[LANGUAGE]}"
)
else:
streamlit.info(
f"### {GAME_UNDECIDED_TEXT[LANGUAGE]}"
)
|
""" Implement tasks for invoke.
"""
import os
import sys
import subprocess
from invoke import task
this_dir = os.path.dirname(__file__)
def call(*cmd):
sys.exit(subprocess.call(cmd, cwd=this_dir))
def get_node_exe():
node_exe = 'nodejs'
try:
subprocess.check_output([node_exe, '--version'])
except Exception:
node_exe = 'node'
return node_exe
@task
def lint(ctx):
""" Test for style errors using JSHint. """
call
ret_code = subprocess.call(['jshint', 'bsdf.js'], cwd=this_dir, shell=True)
if ret_code == 0:
print('No style errors found')
sys.exit(ret_code)
@task
def test_shared(ctx):
""" Run BSDF tests on JS using the shared test service. """
sys.path.insert(0, os.path.join(this_dir, '..', '_tools'))
import testservice
exe = get_node_exe()
testservice.main(this_dir, exe, 'testservice_runner.js', '{fname1}', '{fname2}',
excludes=['roundfloatisnotint'])
@task
def test_unit(ctx):
""" Run unit tests for JS BSDF implementation. """
exe = get_node_exe()
call(exe, 'test_unit.js')
|
from .factory import make_airflow_dag, make_airflow_dag_containerized
__all__ = ['make_airflow_dag', 'make_airflow_dag_containerized']
|
import uuid
from .parser import Token, Node
def to_dot(ast):
result = [
'strict digraph "AST" {',
'size="16,14"; ratio = fill;'
]
_escape = lambda s: s.replace('"', r'\"')
def format_node(node, uid):
if isinstance(node, Token):
label = '{} [{}]'.format(*map(_escape, (node.name, node.value)))
elif isinstance(node, Node):
label = '{}'.format(*map(_escape, (node.name,)))
else:
raise ValueError("Can't format node {}".format(node))
return '"{}" [label="{}"];'.format(uid, label)
def walk(node, uid):
result.append(format_node(node, uid))
if isinstance(node, Node):
for i in node.items:
child_uid = uuid.uuid4().hex
walk(i, child_uid)
result.append('"{}" -> "{}";'.format(uid, child_uid))
uid = uuid.uuid4().hex
walk(ast, uid)
result.append('}')
return '\n'.join(result)
|
import random
from unittest import TestCase, mock
from faker import Faker
from pyeti.eti_django.db import LOCKS, lock
fake = Faker()
srandom = random.SystemRandom()
class LockTests(TestCase):
def setUp(self):
transaction_patcher = mock.patch('pyeti.eti_django.db.transaction')
self.__transaction = transaction_patcher.start()
self.addCleanup(transaction_patcher.stop)
connection_patcher = mock.patch('pyeti.eti_django.db.connection')
self.__connection = connection_patcher.start()
self.addCleanup(connection_patcher.stop)
self.__model = mock.Mock()
self.__db_table = fake.word()
self.__model._meta.db_table = self.__db_table
self.__lock = srandom.choice(LOCKS)
def test_raises_with_invalid_lock_type(self):
with self.assertRaises(ValueError):
with lock(self.__model, fake.word()):
'hello'
def test_starts_a_new_transaction(self):
with lock(self.__model, self.__lock):
'hello'
self.__transaction.atomic.assert_called_once_with()
def test_locks_the_table(self):
cursor = mock.Mock()
self.__connection.cursor = mock.Mock(return_value=cursor)
with lock(self.__model, self.__lock):
'hello'
cursor.execute.assert_called_once_with(
'LOCK TABLE %s IN %s MODE' % (self.__db_table, self.__lock)
)
def test_runs_the_context(self):
method = mock.Mock()
with lock(self.__model, self.__lock):
method()
method.assert_called_once_with()
|
psuedo_code = """
If the list is empty or has one item, it is sorted by definition.
This is our base case.
"""
###
print "merge sort"
count = 0
def merge_sort(alist):
"""list -> list
sorted from least to greatest
"""
#print("Splitting ", alist)
global count
#splitting list section
if len(alist) > 1:
mid = len(alist) // 2
lefthalf = alist[:mid]
righthalf = alist[mid:]
merge_sort(lefthalf)
merge_sort(righthalf)
#merging splices section
i=0 #should be called first_value
j=0 #should be called second_value
k=0 #rebuilding list
while i<len(lefthalf) and j<len(righthalf):
count += 1
if lefthalf[i]<righthalf[j]:
alist[k]=lefthalf[i]
i=i+1
else:
alist[k]=righthalf[j]
j=j+1
print "alist[k]", alist[k]
k=k+1
while i<len(lefthalf):
count += 1
alist[k]=lefthalf[i]
i=i+1
k=k+1
while j<len(righthalf):
count += 1
alist[k]=righthalf[j]
j=j+1
k=k+1
#helper print statement
#print("Merging ", alist)
return alist, count
alist = [18, 18, 12, 12, 3, 1, 2, 10, 13, 17]
ls2 = range(20,10,-1)
#merge_sort(alist)
merge_sort(ls2)
#print(alist)
print("iterations {}".format(count)) |
"""Contains the functions and classes for specific and exact calculations"""
import numpy as np
import matplotlib.pyplot as plt
plt.clf()
plt.cla()
plt.close()
class Hamiltonian:
'''
This is a simple class to calculate the hamiltonian for a spin configuration
:param J: The ferromagnetic constant for the material, defaults to -2
:type J: int, optional
:param mu: magnetic constant for energy calcualation, defaults to 1.1
:type mu: int, optional
:param k: The Boltzmann constant, defaults to 1
:type k: float, optional
:param state: The state that is being analyzed, defaults to [1,-1,1,-1]
:type state: list, optional
'''
def __init__(self,J = -2,mu=1.1,k=1,state=[1,-1,1,-1]):
"""Constructor method
"""
self.energy = 0
self.state = state
self.j = J
self.mu = mu
self.k = k
self.initialize()
self.spin_energy()
def initialize(self,list):
"""Initializes itself using a list. Note, all lists should be in the format of a sequential list where 1 is spin up and -1 is spin down
:param list: A list of spin orientations
:type list: list
"""
for i in list:
self.state.append(i)
def reset(self):
"""Resets the object to default settings
"""
self.state.clear()
self.energy = 0
def spin_energy(self):
"""Calculates the spin energy using the Ising model
:rtype: float
"""
for i in range(len(self.state)-1):
self.energy+=(self.state[i]*self.state[i+1])
self.energy+=self.state[0]*self.state[-1]
self.energy*= -self.j/self.k
for j in self.state:
self.energy+=(self.mu*j)
return self.energy
def magnetization(spin_config):
"""Computes the magnetization alone of some spin configuration. Note, all lists should be in the format of a sequential list where 1 is spin up and -1 is spin down
:param spin_config: A list of spin orientations
:type list: list
:return: The computed magnetization for a spin configuration of listed spin states
:rtype: int
"""
magnet = 0
for i in spin_config:
magnet+=i
return magnet
class spin_config_1D:
'''
This is a simple class to calculate the energy distribution for all configurations of size n
:param boltz: The boltzmann constant for your calculations, defaults to 1
:type boltz: int or float
:param J: The ferromagnetic constant for your calculations, defaults to -2
:type J: int or float
:param mu: The magnetization constant for your calculations, defaults to 1.1
:type mu: int or float
:param temp: The temperature your spin lattice is held in (in kelvin), defaults to 373K (100 degrees Celsius)
:type temp: int or float
:param n: The size of lattice you're testing
:type n: int
'''
def __init__(self,boltz=1,J=-2,mu=1.1,temp=373,n=8):
self.energies = []
self.size = n
self.magnetizations = []
self.probabilities = []
self.boltzmann = []
self.states = []
self.k = boltz
self.j = J
self.mu = mu
self.T = temp
self.avg_eng = 0
self.avg_mag = 0
self.heat_capacity = 0
self.mag_sus = 0
self.calc(self.size)
def calc(self,n):
"""Calculates the energies for all configurations of size n and puts them in an array, along with average energy, average magnetization, heat capacity, and magnetic susceptibility, along with the probabilities, and all the states
:param n: The number of sites on the spin configurations that you want to test
:type n: int
"""
self.generate_state(n)
#Generates the states
self.energy_generation()
#Generates the energies of each state
self.magnetic_generation()
#Generates the magnetizations of each state
self.boltzmann_distribution()
#Generates the boltzmann distribution
self.probabilities_generation()
#Generates the probabiliites, now normalized
self.averages()
#Computes average energy and magnetization
self.heat_capacity_calculator()
#Computes heat capacity
self.magnetic_sus_calculator()
#Computes magnetic suscpetibility
def reset(self):
"""Resets the configuration to all default values and default constants
"""
self.energies = []
self.size = 8
self.magnetizations = []
self.probabilities = []
self.boltzmann = []
self.states = []
self.k = 1
self.j = -2
self.mu = 1.1
self.T = 323
self.avg_eng = 0
self.avg_mag = 0
self.heat_capacity = 0
self.mag_sus = 0
def clean(self):
"""Resets the configuration to all default values but maintains the constants
"""
self.energies = []
self.magnetizations = []
self.probabilities = []
self.boltzmann = []
self.states = []
self.avg_eng = 0
self.avg_mag = 0
self.heat_capacity = 0
self.mag_sus = 0
def temp(self,temp):
"""Modifies the temperature alone
:param temp: The temperature you want to set your state at
"""
self.T = temp
self.calc(self.size)
def ferro(self,pref):
"""Modifies the ferromagnetic preference alone
:param pref: The J value do you want to set your state at
"""
self.j = pref
self.calc(self.size)
def boltz(self,k):
"""Modifies the boltzmann constant alone
:param k: The k value do you want to set your state at
"""
self.k = k
self.calc(self.size)
def mag(self,mu):
"""Modifies the magnetic preference alone
:param mu: The mu value do you want to set your state at
"""
self.mu = mu
self.calc(self.size)
def num_states(self,size):
"""Modifies the number of states alone
:param size: The number of states in the new lattice
"""
self.size = size
self.calc(self.size)
def __repr__(self):
string = "States: "+str(self.states)+'\n'
string+="Energies: "+str(self.energies)+'\n'
string+="Magnetizations: "+str(self.magnetizations)+'\n'
string+="Probabilities: "+str(self.probabilities)+'\n'
string+="Average Energy: "+str(self.avg_eng)+'\n'
string+="Average Magnetization: "+str(self.avg_mag)+'\n'
string+="Heat Capcity: "+str(self.heat_capacity)+'\n'
string+="Magnetic Susceptibility: "+str(self.heat_capacity)+'\n'
string+="Constants\n"
string+="\tBoltzmann Constant is: "+str(self.k)+'\n'
string+="\tJ is: "+str(self.j)+'\n'
string+="\tmu is: "+str(self.mu)+'\n'
string+="\tTemperature is: "+str(self.T)
return string
def __str__(self):
string = "States: "+str(self.states)+'\n'
string+="Energies: "+str(self.energies)+'\n'
string+="Magnetizations: "+str(self.magnetizations)+'\n'
string+="Probabilities: "+str(self.probabilities)+'\n'
string+="Average Energy: "+str(self.avg_eng)+'\n'
string+="Average Magnetization: "+str(self.avg_mag)+'\n'
string+="Heat Capcity: "+str(self.heat_capacity)+'\n'
string+="Magnetic Susceptibility: "+str(self.heat_capacity)+'\n'
string+="Constants\n"
string+="\tBoltzmann Constant is: "+str(self.k)+'\n'
string+="\tJ is: "+str(self.j)+'\n'
string+="\tmu is: "+str(self.mu)+'\n'
string+="\tTemperature is: "+str(self.T)
return string
def constants(self,boltz,pref,mu,temp):
"""Modifies the all the constants together
:param boltz: Set your boltzmann constant at
:param pref: Set your ferromagnetic preferentiabiility
:param mu: Set your magnetic constant
:param temp: Set your temperature
"""
self.k = boltz
self.j = pref
self.mu = mu
self.T = temp
def energy_generation(self):
"""Takes all states and calculates the energy in each states and stores it in a list
"""
for j in self.states:
energy = 0
for i in range(len(j)-1):
energy+=(j[i]*j[i+1])
energy+=j[-1]*j[0]
energy *= -self.j/self.k
for k in j:
energy+=(self.mu*k)
self.energies.append(energy)
def magnetic_generation(self):
"""Takes all states and calculates the magentization and stores it in a list
"""
for j in self.states:
magnet = 0
for i in j:
magnet+=i
self.magnetizations.append(magnet)
def boltzmann_distribution(self):
"""Calculates the unnormalized probability distribution using each state's energy
"""
for i in self.energies:
self.boltzmann.append(np.exp(-i/(self.k*self.T)))
def probabilities_generation(self):
"""Takes the boltzmann distribution and normalizes it
"""
norm = sum(self.boltzmann)
for j in range(len(self.boltzmann)):
self.probabilities.append(self.boltzmann[j]/norm)
def averages(self):
"""Computes weighted average energy and magnetization using the energy and probabilities list
"""
for i in range(len(self.energies)):
self.avg_eng+=self.energies[i]*self.probabilities[i]
for i in range(len(self.magnetizations)):
self.avg_mag+=self.magnetizations[i]*self.probabilities[i]
def heat_capacity_calculator(self):
"""Calculates the heat capacity using the calculation based on the energies
"""
copy_energy=[]
E = 0
for i in self.energies:
copy_energy.append(i**2)
for i in range(len(copy_energy)):
E+=copy_energy[i]*self.probabilities[i]
self.heat_capacity = (E - np.power(self.avg_eng,2))/(self.k*self.T*self.T)
def magnetic_sus_calculator(self):
"""Calculates the magnetic susceptibility using the calculation based on the energies
"""
copy_mag=[]
M = 0
for i in range(len(self.magnetizations)):
copy_mag.append(self.magnetizations[i]**2)
for i in range(len(copy_mag)):
M+=copy_mag[i]*self.probabilities[i]
self.mag_sus = (M - np.power(self.avg_mag,2))/(self.k*self.T)
def generate_state(self,n=8):
"""Generates every possible lattice state for n lattice sites
:param n: Size of the lattice
:type n: int
"""
self.clean()
for i in range(2**n):
binary = bin(i)
state = [char for char in binary]
state.remove('0')
state.remove('b')
for j in range(len(state)):
state[j] = int(state[j])
if state[j]==0:
state[j]=-1
while len(state)<n:
state.insert(0,-1)
self.states.append(state)
def generate_plot(self,tmin=.1,tmax=10,step=0.1,J = -2, mu = 1.1, k = 1, n=8):
"""
Generates the plot for average energy, average magnetizatoin, heat capacity, and magnetic susceptibility over various temperatures.
:param tmin: minimum temperature, defaults to .s1K
:type tmin: float
:param tmax: max temperature, defaults to 10K
:type tmax: float
:param step: Every interval over which a datapoint is measured, defaults to a step of 0.1
:type step: float
:param J: Ferromagnetic constant, defaults to -2
:type J: int or float
:param mu: Magnetization constant, defaults to 1.1
:type mu: int or float
:param k: Boltzmann constant
:type k: int or float
:param n: The number of states in the lattice
:type n: int
"""
t_current = self.T
temps = []
average_energy = []
average_magnetization=[]
heat_cap=[]
mag_sus=[]
for i in range(int((tmax-tmin)/step)):
temps.append(tmin+i*step)
self.constants(k,J,mu,tmin+i*step)
self.calc(n)
average_energy.append(self.avg_eng)
average_magnetization.append(self.avg_mag)
heat_cap.append(self.heat_capacity)
mag_sus.append(self.mag_sus)
plt.plot(temps,average_energy,'r-',temps,average_magnetization,'b-',temps,heat_cap,'g-',temps,mag_sus,'y-')
plt.legend(["Average Energy", "Average Magnetization", "Heat Capacity", "Magnetic Susceptibility"],loc='best')
plt.xlabel("Temperature (K)")
plt.show()
self.T = t_current
def spin_energy(J = -2, mu = 1.1, k = 1, state = [1,-1,1,-1]):
"""Computes the energy of some spin configuration. Note, all lists should be in the format of a sequential list where 1 is spin up and -1 is spin down
:param J: Ferromagnetic constant, defaults to -2
:type J: int or float
:param mu: Magnetic constant, defaults to 1.1
:type mu: int or float
:param k: The boltzmann constant, defaults to 1
:type k: int or float
:param state: the list of states in the lattice: defaults to [1,-1,1,-1]
:type state: list
:return: The computed energy for a spin configuration of listed spin states
:rtype: float
"""
energy = 0
for i in range(len(state)-1):
energy+=(state[i]*state[i+1])
energy+=state[0]*state[-1]
energy*= -J/k
for j in state:
energy+=(mu*j)
return energy
if __name__ == "__main__":
# Do something if this file is invoked on its own
generator = spin_config_1D(n=2)
print(generator)
|
from __future__ import unicode_literals, division, absolute_import
from flexget import plugin
from flexget import validator
class Magnets(object):
"""Removes magnet urls form the urls list. Rejects entries that have nothing but magnet urls."""
schema = {'type': 'boolean'}
@plugin.priority(0)
def on_task_urlrewrite(self, task, config):
if config is not False:
return
for entry in task.accepted:
if 'urls' in entry:
entry['urls'] = filter(lambda url: not url.startswith('magnet:'), entry['urls'])
if entry['url'].startswith('magnet:'):
if entry.get('urls'):
entry['url'] = entry['urls'][0]
else:
entry.reject('Magnet urls not allowed.', remember=True)
plugin.register_plugin(Magnets, 'magnets', api_ver=2)
|
# Copyright 2015 The Bazel 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.
def _impl(ctx):
outjar = ctx.outputs.jar
java_runtime = ctx.attr._jdk[java_common.JavaRuntimeInfo]
jar_exe_path = "%s/bin/jar" % java_runtime.java_home
cmd = [
"mkdir readme && touch readme/README && %s cf %s readme/README" % (jar_exe_path, outjar.path),
]
ctx.actions.run_shell(
outputs = [outjar],
progress_message = "Generating minimal jar for %s" % ctx.attr.name,
command = ";\n".join(cmd),
tools = java_runtime.files,
)
minimal_jar = rule(
attrs = {
"_jdk": attr.label(
default = Label("@bazel_tools//tools/jdk:current_java_runtime"),
providers = [java_common.JavaRuntimeInfo],
),
},
implementation = _impl,
outputs = {"jar": "%{name}.jar"},
)
|
from sanic.blueprints import * |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim: ai ts=4 sts=4 et sw=4 nu
from django.views.debug import get_safe_settings
class SafeSettings(object):
"""
Map attributes to values in the safe settings dict
"""
def __init__(self):
self._settings = get_safe_settings()
def __getattr__(self, name):
try:
return self._settings[name.upper()]
except KeyError:
raise AttributeError
settings_obj = SafeSettings()
def settings(request):
return {'settings': settings_obj}
|
#!/usr/bin/env python3
import time
import math
from datetime import datetime
from time import sleep
import numpy as np
import random
import cv2
import os
import argparse
import torch
import sys
sys.path.append('./Eval')
sys.path.append('./')
from env import Engine
from utils_env import get_view,safe_path,cut_frame,point2traj,get_gripper_pos,backup_code
class Engine43(Engine):
def __init__(self, worker_id, opti, p_id, taskId=5, maxSteps=15, n_dmps=3, cReward=True):
super(Engine43,self).__init__(opti, wid=worker_id, p_id=p_id, maxSteps=maxSteps, taskId=taskId, n_dmps=n_dmps, cReward=cReward,robot_model=None)
self.opti = opti
self.height = 0
def init_obj(self):
self.obj_file = os.path.join(self.urdf_dir,"objmodels/nut.urdf")
self.obj_position = [0.3637 + 0.06, -0.06, 0.35]
self.obj_scaling = 2
self.obj_orientation = self.p.getQuaternionFromEuler([math.pi/2+0.2, -math.pi/2, -0.3])
self.obj_id = self.p.loadURDF(fileName=self.obj_file, basePosition=self.obj_position,baseOrientation=self.obj_orientation,
globalScaling=self.obj_scaling)#,physicsClientId=self.physical_id
texture_path = os.path.join(self.resources_dir,'textures/sun_textures')
texture_file = os.path.join(texture_path,random.sample(os.listdir(texture_path),1)[0])
#textid = self.p.loadTexture(texture_file)
#self.p.changeVisualShape (self.obj_id, -1, textureUniqueId=textid)
self.p.changeVisualShape(self.obj_id, -1, rgbaColor=[0.,0.,0.5, 1])
def reset_obj(self):
self.p.resetBasePositionAndOrientation(self.obj_id, self.obj_position, self.obj_orientation)
def init_motion(self):
self.data_q = np.load (os.path.join(self.robot_recordings_dir,"47-4/q.npy"))
self.data_gripper = np.load (self.configs_dir + '/init/gripper.npy')
self.robot.setJointValue(self.data_q[0],gripper=self.data_gripper[0])
def init_grasp(self):
self.robot.gripperControl(0)
qlist = np.load( os.path.join(self.robot_recordings_dir, "47-4/q.npy"))
glist = np.load( os.path.join(self.robot_recordings_dir, "47-4/gripper.npy"))
num_q = len(qlist[0])
self.fix_orn = np.load (os.path.join (self.configs_dir, 'init', 'orn.npy'))
self.null_q = qlist[180]
self.robot.setJointValue(qlist[40],glist[40])
self.p.resetBasePositionAndOrientation(self.obj_id, self.obj_position, self.obj_orientation)
for i in range(40,180,1):
glist[i] = min(130,glist[i])
self.robot.jointPositionControl(qlist[i],gripper=glist[i])
pos = self.robot.getEndEffectorPos()
pos[0] += -.1
pos[2] += .1
orn = self.robot.getEndEffectorOrn()
for i in range(109):
self.robot.positionControl(pos,orn,null_pose=self.null_q,gripperPos=130)
cur_joint = self.robot.getJointValue()
cur_pos = self.robot.getEndEffectorPos()
cur_orn = self.robot.getEndEffectorOrn()
pos_diff = np.random.uniform(-0.1,0.1,size=(2,))
cur_pos[:2] = cur_pos[:2] + pos_diff
cur_pos[2] += 0.00
for i in range(19):
self.robot.positionControl(cur_pos,cur_orn,null_pose=cur_joint,gripperPos=130)
self.start_pos = self.p.getLinkState (self.robotId, 7)[0]
self.height = self.p.getBasePositionAndOrientation(self.obj_id)[0][2]
def get_success(self,seg=None):
obj_pos = np.array(self.p.getBasePositionAndOrientation(self.obj_id)[0])
if obj_pos[2] < self.height - 0.05:
return True
else:
return False
|
# -*- coding: utf-8 -*-
import BaseHTTPServer
import cgi
import json
import os, subprocess
import sys
from BaseHTTPServer import HTTPServer
from datetime import datetime
import mxnet as mx
import numpy as np
import time
from config_util import parse_args, parse_contexts, generate_file_path
from create_desc_json import get_duration_wave
from label_util import LabelUtil
from log_util import LogUtil
from stt_bucketing_module import STTBucketingModule
from stt_datagenerator import DataGenerator
from stt_io_bucketingiter import BucketSTTIter
from stt_io_iter import STTIter
from stt_metric import EvalSTTMetric
from ctc_beam_search_decoder import ctc_beam_search_decoder_log
# os.environ['MXNET_ENGINE_TYPE'] = "NaiveEngine"
os.environ['MXNET_ENGINE_TYPE'] = "ThreadedEnginePerDevice"
os.environ['MXNET_ENABLE_GPU_P2P'] = "0"
class WHCS:
width = 0
height = 0
channel = 0
stride = 0
class ConfigLogger(object):
def __init__(self, log):
self.__log = log
def __call__(self, config):
self.__log.info("Config:")
config.write(self)
def write(self, data):
# stripping the data makes the output nicer and avoids empty lines
line = data.strip()
self.__log.info(line)
from main import load_labelutil
def load_data(args, wav_file):
mode = args.config.get('common', 'mode')
if mode not in ['train', 'predict', 'load']:
raise Exception('mode must be the one of the followings - train,predict,load')
batch_size = args.config.getint('common', 'batch_size')
whcs = WHCS()
whcs.width = args.config.getint('data', 'width')
whcs.height = args.config.getint('data', 'height')
whcs.channel = args.config.getint('data', 'channel')
whcs.stride = args.config.getint('data', 'stride')
save_dir = 'checkpoints'
model_name = args.config.get('common', 'prefix')
is_bi_graphemes = args.config.getboolean('common', 'is_bi_graphemes')
overwrite_meta_files = args.config.getboolean('train', 'overwrite_meta_files')
overwrite_bi_graphemes_dictionary = args.config.getboolean('train', 'overwrite_bi_graphemes_dictionary')
max_duration = args.config.getfloat('data', 'max_duration')
max_freq = args.config.getint('data', 'max_freq')
language = args.config.get('data', 'language')
log = LogUtil().getlogger()
labelUtil = LabelUtil()
# test_json = "resources/d.json"
datagen = DataGenerator(save_dir=save_dir, model_name=model_name, max_freq=max_freq)
datagen.train_audio_paths = [wav_file]
datagen.train_durations = [get_duration_wave(wav_file)]
datagen.train_texts = ["1 1"]
datagen.count = 1
# datagen.load_train_data(test_json, max_duration=max_duration)
labelutil = load_labelutil(labelUtil, is_bi_graphemes, language="zh")
args.config.set('arch', 'n_classes', str(labelUtil.get_count()))
datagen.get_meta_from_file(
np.loadtxt(generate_file_path(save_dir, model_name, 'feats_mean')),
np.loadtxt(generate_file_path(save_dir, model_name, 'feats_std')))
is_batchnorm = args.config.getboolean('arch', 'is_batchnorm')
if batch_size == 1 and is_batchnorm and (mode == 'train' or mode == 'load'):
raise Warning('batch size 1 is too small for is_batchnorm')
max_t_count = datagen.get_max_seq_length(partition="test")
max_label_length = \
datagen.get_max_label_length(partition="test", is_bi_graphemes=is_bi_graphemes)
args.config.set('arch', 'max_t_count', str(max_t_count))
args.config.set('arch', 'max_label_length', str(max_label_length))
from importlib import import_module
prepare_data_template = import_module(args.config.get('arch', 'arch_file'))
init_states = prepare_data_template.prepare_data(args)
sort_by_duration = (mode == "train")
is_bucketing = args.config.getboolean('arch', 'is_bucketing')
save_feature_as_csvfile = args.config.getboolean('train', 'save_feature_as_csvfile')
if is_bucketing:
buckets = json.loads(args.config.get('arch', 'buckets'))
data_loaded = BucketSTTIter(partition="train",
count=datagen.count,
datagen=datagen,
batch_size=batch_size,
num_label=max_label_length,
init_states=init_states,
seq_length=max_t_count,
width=whcs.width,
height=whcs.height,
sort_by_duration=sort_by_duration,
is_bi_graphemes=is_bi_graphemes,
buckets=buckets,
save_feature_as_csvfile=save_feature_as_csvfile)
else:
data_loaded = STTIter(partition="train",
count=datagen.count,
datagen=datagen,
batch_size=batch_size,
num_label=max_label_length,
init_states=init_states,
seq_length=max_t_count,
width=whcs.width,
height=whcs.height,
sort_by_duration=sort_by_duration,
is_bi_graphemes=is_bi_graphemes,
save_feature_as_csvfile=save_feature_as_csvfile)
return data_loaded, args
class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
# Simple HTTP request handler with POST commands.
def do_POST(self):
# print self.headers['Content-Type']
# print self.rfile
form = cgi.FieldStorage(
fp=self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers['Content-Type'],
})
filename = form['file'].filename
otherNet.log.info("filename is: " + str(filename))
output_file_pre = otherNet.args.config.get("common", "wav_dir")
part1, part2 = filename.rsplit(".", 1)
if filename.endswith(".speex"):
data = form['file'].file.read()
open("./" + filename, "wb").write(data)
command = "./SpeexDecode " + filename + " " + part1 + ".wav"
os.system(command)
data = open(part1 + ".wav", 'rb').read()
open("./lolol.wav", "wb").write(data)
elif filename.endswith(".amr"):
data = form['file'].file.read()
open(output_file_pre + filename, "wb").write(data)
# command = "ffmpeg -y -i " + output_file_pre + part1 + ".amr -acodec pcm_s16le -ar 16000 -ac 1 -b 256 " + output_file_pre + part1 + ".wav"
subprocess.call(
["ffmpeg", "-y", "-i", output_file_pre + part1 + ".amr", "-acodec", "pcm_s16le", "-ar", "16000", "-ac",
"1", output_file_pre + part1 + ".wav"], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, shell=False)
# otherNet.log.info(command)
# os.system(command)
elif filename.lower().endswith(".wav"):
data = form['file'].file
# import soundfile as sf
# audio, sr1 = sf.read(data, dtype='float32')
open(output_file_pre + part1 + ".wav", "wb").write(data.read())
# create_desc_json.ai_2_word_single(output_file_pre + part1 + ".wav")
otherNet.log.info("start")
trans_res = otherNet.getTrans(output_file_pre + part1 + ".wav")
otherNet.log.info("end")
content = bytes(u"没有检测到语音，请重新录制".encode("utf-8"))
if trans_res:
content = bytes(trans_res.encode("utf-8"))
self.send_response(200)
self.send_header("Content-type", "text/plain; charset=utf-8")
self.send_header("Content-Length", len(content))
self.end_headers()
self.wfile.write(content)
def load_model(args):
# load model from model_name prefix and epoch of model_num_epoch with gpu contexts of contexts
is_start_from_batch = args.config.getboolean('load', 'is_start_from_batch')
from importlib import import_module
symbol_template = import_module(args.config.get('arch', 'arch_file'))
model_file = args.config.get('common', 'model_file')
model_name = os.path.splitext(model_file)[0]
model_num_epoch = int(model_name[-4:])
model_path = 'checkpoints/' + str(model_name[:-5])
bucketing_arch = symbol_template.BucketingArch(args)
model_loaded = bucketing_arch.get_sym_gen()
return model_loaded, model_num_epoch, model_path
class Net(object):
def __init__(self):
if len(sys.argv) <= 1:
raise Exception('cfg file path must be provided. ' +
'ex)python main.py --configfile examplecfg.cfg')
self.args = parse_args(sys.argv[1])
# set parameters from cfg file
# give random seed
self.random_seed = self.args.config.getint('common', 'random_seed')
self.mx_random_seed = self.args.config.getint('common', 'mx_random_seed')
# random seed for shuffling data list
if self.random_seed != -1:
np.random.seed(self.random_seed)
# set mx.random.seed to give seed for parameter initialization
if self.mx_random_seed != -1:
mx.random.seed(self.mx_random_seed)
else:
mx.random.seed(hash(datetime.now()))
# set log file name
self.log_filename = self.args.config.get('common', 'log_filename')
self.log = LogUtil(filename=self.log_filename).getlogger()
# set parameters from data section(common)
self.mode = self.args.config.get('common', 'mode')
# get meta file where character to number conversions are defined
self.contexts = parse_contexts(self.args)
self.num_gpu = len(self.contexts)
self.batch_size = self.args.config.getint('common', 'batch_size')
# check the number of gpus is positive divisor of the batch size for data parallel
self.is_batchnorm = self.args.config.getboolean('arch', 'is_batchnorm')
self.is_bucketing = self.args.config.getboolean('arch', 'is_bucketing')
# log current config
self.config_logger = ConfigLogger(self.log)
self.config_logger(self.args.config)
default_bucket_key = 1600
self.args.config.set('arch', 'max_t_count', str(default_bucket_key))
self.args.config.set('arch', 'max_label_length', str(100))
self.labelUtil = LabelUtil()
is_bi_graphemes = self.args.config.getboolean('common', 'is_bi_graphemes')
load_labelutil(self.labelUtil, is_bi_graphemes, language="zh")
self.args.config.set('arch', 'n_classes', str(self.labelUtil.get_count()))
self.max_t_count = self.args.config.getint('arch', 'max_t_count')
# self.load_optimizer_states = self.args.config.getboolean('load', 'load_optimizer_states')
# load model
self.model_loaded, self.model_num_epoch, self.model_path = load_model(self.args)
self.model = STTBucketingModule(
sym_gen=self.model_loaded,
default_bucket_key=default_bucket_key,
context=self.contexts
)
from importlib import import_module
prepare_data_template = import_module(self.args.config.get('arch', 'arch_file'))
init_states = prepare_data_template.prepare_data(self.args)
width = self.args.config.getint('data', 'width')
height = self.args.config.getint('data', 'height')
self.model.bind(data_shapes=[('data', (self.batch_size, default_bucket_key, width * height))] + init_states,
label_shapes=[
('label', (self.batch_size, self.args.config.getint('arch', 'max_label_length')))],
for_training=True)
_, self.arg_params, self.aux_params = mx.model.load_checkpoint(self.model_path, self.model_num_epoch)
self.model.set_params(self.arg_params, self.aux_params, allow_extra=True, allow_missing=True)
try:
from swig_wrapper import Scorer
vocab_list = [chars.encode("utf-8") for chars in self.labelUtil.byList]
self.log.info("vacab_list len is %d" % len(vocab_list))
_ext_scorer = Scorer(0.26, 0.1, self.args.config.get('common', 'kenlm'), vocab_list)
lm_char_based = _ext_scorer.is_character_based()
lm_max_order = _ext_scorer.get_max_order()
lm_dict_size = _ext_scorer.get_dict_size()
self.log.info("language model: "
"is_character_based = %d," % lm_char_based +
" max_order = %d," % lm_max_order +
" dict_size = %d" % lm_dict_size)
self.scorer = _ext_scorer
# self.eval_metric = EvalSTTMetric(batch_size=self.batch_size, num_gpu=self.num_gpu, is_logging=True,
# scorer=_ext_scorer)
except ImportError:
import kenlm
km = kenlm.Model(self.args.config.get('common', 'kenlm'))
self.scorer = km.score
# self.eval_metric = EvalSTTMetric(batch_size=self.batch_size, num_gpu=self.num_gpu, is_logging=True,
# scorer=km.score)
def getTrans(self, wav_file):
self.data_train, self.args = load_data(self.args, wav_file)
# self.model.set_params(self.arg_params, self.aux_params)
# backward_t358_l1_batchnorm_moving_var
model_loaded = self.model
max_t_count = self.args.config.getint('arch', 'max_t_count')
for nbatch, data_batch in enumerate(self.data_train):
st = time.time()
model_loaded.forward(data_batch, is_train=False)
probs = model_loaded.get_outputs()[0].asnumpy()
self.log.info("forward cost %.2f" % (time.time() - st))
beam_size = 5
from stt_metric import ctc_beam_decode
st = time.time()
results = ctc_beam_decode(scorer=self.scorer, beam_size=beam_size, vocab=self.labelUtil.byList, probs=probs)
self.log.info("decode cost %.2f, result is:\n%s" % (time.time()-st, "\n".join(results)))
return "\n".join(results)
otherNet = Net()
if __name__ == '__main__':
server = HTTPServer(('', 8089), SimpleHTTPRequestHandler)
otherNet.log.info('Started httpserver on port')
# Wait forever for incoming htto requests
server.serve_forever()
|
import pytest
import os
import uuid
import random
import numpy as np
from rafiki.constants import UserType, ModelAccessRight
from rafiki.client import Client
from rafiki.config import SUPERADMIN_EMAIL
superadmin_email = SUPERADMIN_EMAIL
superadmin_password = os.environ['SUPERADMIN_PASSWORD']
# Details for mocks
DATASET_TRAIN_FILE_PATH = 'test/data/dataset_train.csv'
DATASET_VAL_FILE_PATH = 'test/data/dataset_val.csv'
MODEL_FILE_PATH = 'test/data/Model.py'
MODEL_CLASS = 'Model'
####################################
# General
####################################
@pytest.fixture(scope='session', autouse=True)
def global_setup():
random.seed(0)
np.random.seed(0)
def gen():
return str(uuid.uuid4())
def gen_email():
return f'{uuid.uuid4()}@rafiki'
####################################
# Users
####################################
@pytest.fixture(scope='module')
def superadmin():
client = Client()
client.login(superadmin_email, superadmin_password)
return client
def make_admin(**kwargs):
return make_user(UserType.ADMIN, **kwargs)
def make_app_dev(**kwargs):
return make_user(UserType.APP_DEVELOPER, **kwargs)
def make_model_dev(**kwargs):
return make_user(UserType.MODEL_DEVELOPER, **kwargs)
# Make a client logged in as new user with a specific user type
def make_user(user_type, email=None, password=None):
email = email or gen_email()
password = password or gen()
client = Client()
client.login(superadmin_email, superadmin_password)
client.create_user(email, password, user_type)
client.login(email, password)
return client
####################################
# Models
####################################
def make_private_model(**kwargs):
return make_model(access_right=ModelAccessRight.PRIVATE, **kwargs)
def make_model(task=None, access_right=ModelAccessRight.PUBLIC):
model_dev = make_model_dev()
task = task or gen()
name = gen()
model_file_path = MODEL_FILE_PATH
model_class = MODEL_CLASS
dependencies = {}
model = model_dev.create_model(name, task, model_file_path, model_class, dependencies, access_right=access_right)
model_id = model['id']
return model_id |
#!/usr/bin/python3.4
#Client authentification
#coding: utf8
import os
from getpass import getpass
import hashlib
import socket
TCP_IP = '127.0.0.1'
TCP_PORT=6262
BUFFER_SIZE=100
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((TCP_IP, TCP_PORT))
s.listen(1)
s, addr = s.accept()
print ("Connection adresse:",addr)
DROIT=""
############################################################################################
## Fonction qui renvoie une liste de liste de la forme : [[user1,mdp1],[user2,mdp2]] ##
def lecture_fichier(fichier) :
f = open(fichier,'r')
fo = f.read(1024)
fo=fo.rstrip()
l = fo.split(';')
for i in range(len(l)) :
l[i] = l[i].split(':')
return l
###########################################################################################
def LOGIN():
tout = True
session = True
metier = True
verrouille = True
while tout :
user = ''
time=4
while metier:
service=s.recv(30)
service=service.decode()
print (service)
if service == "Medecin":
DROIT="M"
l=lecture_fichier("passwordMed.txt")
metier = False
s.send(b"1")
elif service == "Infirmier":
DROIT="INF"
l=lecture_fichier("passwordInf.txt")
metier = False
s.send(b"2")
elif service == "Interne":
DROIT="I"
l=lecture_fichier("passwordInt.txt")
metier = False
s.send(b"3")
else:
s.send(b"0")
while session and user != 'retour':
user= s.recv(20)
user=user.decode()
print ("user",user)
if user == "retour" :
metier = True
s.send(b"return")
print ("Boucle retour")
break
else :
for i in range(len(l)):
if user == l[i][0]:
s.send(b"1")
session = False
tout = False
print ( "j'ai trouvé",user)
if session == True:
s.send(b"0")
print ( "je n'ai pas trouvé",user)
while verrouille and tout == False :
verif=s.recv(20)
print (verif.decode())
time-=1
Timeline="Reste "+str(time)+" essai"
Timeline=Timeline.encode()
s.send(Timeline)
if time == 0:
#s.send(b"0")
print("plus d'essai")
tout = True
metier=True
session=True
break
else:
saisie = s.recv(30)
saisie=saisie.decode()
hash_mdp = hashlib.sha256(saisie.encode()).hexdigest()
for i in range(len(l)):
if user == l[i][0]:
if hash_mdp == l[i][1]:
verrouille=False
s.send(b"1")
else:
s.send(b"0")
s.close()
LOGIN()
print("Fin serveur")
|
"""
Django settings for {{ cookiecutter.project_name }} project.
"""
from os.path import abspath, basename, dirname, join, normpath
from sys import path
import environ
########## PATH CONFIGURATION
BASE_DIR = dirname(dirname(__file__) + "../../../")
# Absolute filesystem path to the config directory:
CONFIG_ROOT = dirname(dirname(abspath(__file__)))
# Absolute filesystem path to the project directory:
PROJECT_ROOT = dirname(CONFIG_ROOT)
env = environ.Env()
READ_DOT_ENV_FILE = env.bool("DJANGO_READ_DOT_ENV_FILE", default=True)
if READ_DOT_ENV_FILE:
# OS environment variables take precedence over variables from .env
env.read_env(env_file=join(PROJECT_ROOT, '.env'))
# Absolute filesystem path to the django repo directory:
DJANGO_ROOT = dirname(PROJECT_ROOT)
# Project name:
PROJECT_NAME = basename(PROJECT_ROOT).capitalize()
# Project folder:
PROJECT_FOLDER = basename(PROJECT_ROOT)
# Project domain:
PROJECT_DOMAIN = "%s.com" % PROJECT_NAME.lower()
# Add our project to our pythonpath, this way we don"t need to type our project
# name in our dotted import paths:
path.append(CONFIG_ROOT)
########## END PATH CONFIGURATION
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/
########## DEBUG CONFIGURATION
# https://docs.djangoproject.com/en/dev/ref/settings/#debug
DEBUG = STAGING = env.bool("DJANGO_DEBUG", False)
########## END DEBUG CONFIGURATION
ADMINS = (
("""{{cookiecutter.author_name}}""", "{{cookiecutter.email}}"),
)
MANAGERS = ADMINS
ADMIN_URL = env.str("DJANGO_ADMIN_URL", "admin")
DATABASES = {
'default': env.db("DATABASE_URL", default="mysql://root:root@localhost:3306/{{ cookiecutter.project_name.lower() }}")
}
DATABASES['default']['ATOMIC_REQUESTS'] = True
DATABASES["default"]["CONN_MAX_AGE"] = env.int("CONN_MAX_AGE", default=60)
DATABASES["default"]["OPTIONS"] = {
"init_command": "SET default_storage_engine=InnoDB",
"charset": "utf8mb4",
"use_unicode": True,
}
EMAIL_BACKEND = env.str("EMAIL_BACKEND", "django.core.mail.backends.console.EmailBackend")
EMAIL_HOST = env.str("EMAIL_HOST", "")
EMAIL_HOST_USER = env.str("EMAIL_HOST_USER", "")
EMAIL_HOST_PASSWORD = env.str("EMAIL_HOST_PASSWORD", "")
EMAIL_USE_TLS = env.bool("EMAIL_USE_TLS", False)
EMAIL_PORT = env.int("EMAIL_PORT", 25)
DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = env.list("DJANGO_ALLOWED_HOSTS", default=["*"])
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# In a Windows environment this must be set to your system time zone.
TIME_ZONE = "{{ cookiecutter.timezone }}"
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = "{{cookiecutter.languages.strip().split(",")[0]}}"
SITE_ID = 1
# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True
# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale.
USE_L10N = True
# If you set this to False, Django will not use timezone-aware datetimes.
USE_TZ = True
# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/var/www/example.com/media/"
MEDIA_ROOT = normpath(join(PROJECT_ROOT, "media"))
# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash.
# Examples: "http://example.com/media/", "http://media.example.com/"
MEDIA_URL = "/media/"
# Absolute path to the directory static files should be collected to.
# Don"t put anything in this directory yourself; store your static files
# in apps" "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/var/www/example.com/static/"
STATIC_ROOT = normpath(join(PROJECT_ROOT, "assets"))
# URL prefix for static files.
# Example: "http://example.com/static/", "http://static.example.com/"
STATIC_URL = "/static/"
# Additional locations of static files
STATICFILES_DIRS = (
# Put strings here, like "/home/html/static" or "C:/www/django/static".
# Always use forward slashes, even on Windows.
# Don"t forget to use absolute paths, not relative paths.
normpath(join(PROJECT_ROOT, "static")),
)
# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
"django.contrib.staticfiles.finders.FileSystemFinder",
"django.contrib.staticfiles.finders.AppDirectoriesFinder",
"compressor.finders.CompressorFinder",
)
# Make this unique, and don"t share it with anybody.
SECRET_KEY = env('DJANGO_SECRET_KEY', default="")
# List of callables that know how to import templates from various sources.
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": (normpath(join(PROJECT_ROOT, "templates")),),
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
"django.template.context_processors.i18n",
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.template.context_processors.media",
"django.template.context_processors.csrf",
"django.template.context_processors.tz",
{% if cookiecutter.cms_package == "django-cms" %}
"sekizai.context_processors.sekizai",
{% endif %}
"django.template.context_processors.static",
{% if cookiecutter.cms_package == "django-cms" %}
"cms.context_processors.cms_settings"
{% endif %}
]
},
},
]
MIDDLEWARE = [
{% if cookiecutter.django_cors == "y" or cookiecutter.django_cors == "Y" %}
'corsheaders.middleware.CorsMiddleware',
{% endif %}
{% if cookiecutter.cms_package == "django-cms" %}
"cms.middleware.utils.ApphookReloadMiddleware",
{% endif %}
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.locale.LocaleMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
{% if cookiecutter.cms_package == "django-cms" %}
"cms.middleware.user.CurrentUserMiddleware",
"cms.middleware.page.CurrentPageMiddleware",
"cms.middleware.toolbar.ToolbarMiddleware",
"cms.middleware.language.LanguageCookieMiddleware",
{% endif %}
{% if cookiecutter.cms_package == "wagtail" %}
"wagtail.contrib.redirects.middleware.RedirectMiddleware",
{% endif %}
"kn_defaults.logging.middlewares.KnLogging",
]
ROOT_URLCONF = "{{ cookiecutter.project_name }}.urls"
# Python dotted path to the WSGI application used by Django"s runserver.
WSGI_APPLICATION = "{{ cookiecutter.project_name }}.wsgi.application"
INSTALLED_APPS = [
"user.apps.UsersConfig",
{% if cookiecutter.cms_package == "django-cms" %}
# Django CMS admin style
"djangocms_admin_style",
{% endif %}
{% if cookiecutter.cms_package == "wagtail" %}
"home",
"search",
"wagtail.contrib.forms",
"wagtail.contrib.redirects",
"wagtail.embeds",
"wagtail.sites",
"wagtail.users",
"wagtail.snippets",
"wagtail.documents",
"wagtail.images",
"wagtail.search",
"wagtail.admin",
"wagtail.core",
"modelcluster",
"taggit",
{% endif %}
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.admin",
"django.contrib.sites",
"django.contrib.sitemaps",
"django.contrib.staticfiles",
"django.contrib.messages",
"kn_defaults.logging",
"rest_framework",
"rest_framework.authtoken",
"djvue",
{% if cookiecutter.cms_package == "django-cms" %}
# Django CMS
"cms",
"menus",
"sekizai",
"treebeard",
"djangocms_text_ckeditor",
{% endif %}
{% if cookiecutter.django_filer == "y" or cookiecutter.django_filer == "Y" %}
# Django filer
"filer",
"easy_thumbnails",
{% endif %}
"compressor",
{% if cookiecutter.s3 == "y" or cookiecutter.s3 == "Y" %}
"storages",
{% endif %}
{% if cookiecutter.django_cors == "y" or cookiecutter.django_cors == "Y" %}
'corsheaders',
{% endif %}
]
AUTH_USER_MODEL = "user.User"
LOGIN_REDIRECT_URL = "user:redirect"
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",
},
]
# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
KN_LOG_FILE_PATH = join(DJANGO_ROOT, "logs/log.log")
from kn_defaults.logging.defaults import BASE_LOGGING
LOGGING = BASE_LOGGING
KN_LOGGING_URL_PATTERNS = []
LOCALE_PATHS = (normpath(join(PROJECT_ROOT, "locale")),)
# Dummy gettext function
gettext = lambda s: s
LANGUAGES = [
{% for language in cookiecutter.languages.strip().split(",") -%}
("{{ language|trim }}", gettext("{{ language|trim }}")),
{% endfor %}
]
{% if cookiecutter.cms_package == "django-cms" %}
# Django CMS configurations
CMS_TEMPLATES = (
("single_page.html", gettext("Single page")),
)
CMS_LANGUAGES = {
## Customize this
"default": {
"public": True,
"hide_untranslated": False,
"redirect_on_fallback": True,
},
1: [{% for language in cookiecutter.languages.strip().split(",") %}
{
"public": True,
"code": "{{ language|trim }}",
"hide_untranslated": False,
"name": gettext("{{ language|trim }}"),
"redirect_on_fallback": True,
},
{% endfor %}
],
}
CMS_PERMISSION = True
CMS_PLACEHOLDER_CONF = {}
{% endif %}
{% if cookiecutter.cms_package == "wagtail" %}
# Wagtail settings
WAGTAIL_SITE_NAME = PROJECT_NAME
# Base URL to use when referring to full URLs within the Wagtail admin backend -
# e.g. in notification emails. Don"t include "/admin" or a trailing slash
BASE_URL = "http://%s" % PROJECT_DOMAIN
{% endif %}
{% if cookiecutter.django_filer == "y" or cookiecutter.django_filer == "Y" %}
THUMBNAIL_PROCESSORS = (
"easy_thumbnails.processors.colorspace",
"easy_thumbnails.processors.autocrop",
"filer.thumbnail_processors.scale_and_crop_with_subject_location",
"easy_thumbnails.processors.filters"
)
{% endif %}
# Analytics
GOOGLE_ANALYTICS = env.str("GOOGLE_ANALYTICS", default="")
CACHE_ENGINES = {
{% if cookiecutter.redis == "y" or cookiecutter.redis == "Y" %}
"redis": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": f'redis://{env.str("REDIS_HOST", default="localhost")}:{env.int("REDIS_PORT", default=6379)}/0',
},
{% endif %}
"dummy": {
"BACKEND": "django.core.cache.backends.dummy.DummyCache",
}
}
CACHES = {
"default": CACHE_ENGINES[env.str("CACHE", default="dummy")]
}
{% if cookiecutter.redis == "y" or cookiecutter.redis == "Y" %}
########## REDIS QUEUE CONFIGURATION
# https://github.com/ui/django-rq#support-for-django-redis-and-django-redis-cache
RQ_QUEUES = {
'default': {
'HOST': env.str("REDIS_HOST", default="localhost"),
'PORT': env.int("REDIS_PORT", default=6379),
'DB': 0,
'PASSWORD': env.str("REDIS_PASSWORD", default=""),
'DEFAULT_TIMEOUT': 86400 * 7,
}
}
RQ = {
'DEFAULT_RESULT_TTL': 86400 * 7,
}
RQ_SHOW_ADMIN_LINK = True
########## END REDIS QUEUE CONFIGURATION
{% endif %}
REST_FRAMEWORK = {
"DEFAULT_AUTHENTICATION_CLASSES": (
"rest_framework.authentication.SessionAuthentication",
"rest_framework.authentication.TokenAuthentication",
),
"DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.LimitOffsetPagination",
"PAGE_SIZE": 10
}
SENTRY_DSN = env.str("SENTRY_DSN", "")
|
# coding: utf-8
from .github import GithubApi
from .repository import RepositoryApi
|
import tornado.web
import tornado.gen
import json
import logging
from mickey.basehandler import BaseHandler
from mickey.groups import GroupMgrMgr
import mickey.redis
class OpenAttachKeepAliveHandler(BaseHandler):
@tornado.web.asynchronous
@tornado.gen.coroutine
def post(self):
data = json.loads(self.request.body.decode("utf-8"))
groupid = data.get("id", "")
device = data.get("device", "")
if not groupid:
logging.error("keep alive failed without groupid")
self.set_status(403)
self.finish()
return
if device:
kp_key = GroupMgrMgr.get_kpalive_key(device, self.p_userid, groupid)
mickey.redis.write_to_redis(kp_key, "OK", expire = 120)
GroupMgrMgr.keepalive_attacher(groupid, self.p_userid)
self.set_status(200)
self.finish()
|
#
# PySNMP MIB module A3COM-HUAWEI-DOT11-QOS-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/A3COM-HUAWEI-DOT11-QOS-MIB
# Produced by pysmi-0.3.4 at Mon Apr 29 16:49:38 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
H3cDot11RadioScopeType, h3cDot11, H3cDot11RadioElementIndex, H3cDot11ObjectIDType, H3cDot11QosAcType = mibBuilder.importSymbols("A3COM-HUAWEI-DOT11-REF-MIB", "H3cDot11RadioScopeType", "h3cDot11", "H3cDot11RadioElementIndex", "H3cDot11ObjectIDType", "H3cDot11QosAcType")
OctetString, ObjectIdentifier, Integer = mibBuilder.importSymbols("ASN1", "OctetString", "ObjectIdentifier", "Integer")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
SingleValueConstraint, ValueRangeConstraint, ConstraintsIntersection, ConstraintsUnion, ValueSizeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "SingleValueConstraint", "ValueRangeConstraint", "ConstraintsIntersection", "ConstraintsUnion", "ValueSizeConstraint")
NotificationGroup, ModuleCompliance = mibBuilder.importSymbols("SNMPv2-CONF", "NotificationGroup", "ModuleCompliance")
Bits, MibIdentifier, Integer32, Unsigned32, ObjectIdentity, TimeTicks, IpAddress, Counter32, iso, NotificationType, Gauge32, ModuleIdentity, Counter64, MibScalar, MibTable, MibTableRow, MibTableColumn = mibBuilder.importSymbols("SNMPv2-SMI", "Bits", "MibIdentifier", "Integer32", "Unsigned32", "ObjectIdentity", "TimeTicks", "IpAddress", "Counter32", "iso", "NotificationType", "Gauge32", "ModuleIdentity", "Counter64", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn")
TruthValue, DisplayString, TextualConvention = mibBuilder.importSymbols("SNMPv2-TC", "TruthValue", "DisplayString", "TextualConvention")
h3cDot11QoS = ModuleIdentity((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9))
h3cDot11QoS.setRevisions(('2008-07-23 12:00',))
if mibBuilder.loadTexts: h3cDot11QoS.setLastUpdated('200807231200Z')
if mibBuilder.loadTexts: h3cDot11QoS.setOrganization('Hangzhou H3C Technologies Co., Ltd.')
class H3cDot11WMMSVPMapAC(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5))
namedValues = NamedValues(("acbk", 1), ("acbe", 2), ("acvi", 3), ("acvo", 4), ("disable", 5))
class H3cDot11WMMCACPolicy(TextualConvention, Integer32):
status = 'current'
subtypeSpec = Integer32.subtypeSpec + ConstraintsUnion(SingleValueConstraint(1, 2))
namedValues = NamedValues(("channelUtilization", 1), ("userNumber", 2))
h3cDot11WmmCfgGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1))
h3cDot11RadioWmmCfgTable = MibTable((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1), )
if mibBuilder.loadTexts: h3cDot11RadioWmmCfgTable.setStatus('current')
h3cDot11RadioWmmCfgEntry = MibTableRow((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1), ).setIndexNames((0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11WmmRadioIndex"))
if mibBuilder.loadTexts: h3cDot11RadioWmmCfgEntry.setStatus('current')
h3cDot11WmmRadioIndex = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 1), H3cDot11RadioElementIndex())
if mibBuilder.loadTexts: h3cDot11WmmRadioIndex.setStatus('current')
h3cDot11RadioWmmEnabled = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 2), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmEnabled.setStatus('current')
h3cDot11RadioSVPMapToAC = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 3), H3cDot11WMMSVPMapAC()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioSVPMapToAC.setStatus('current')
h3cDot11RadioCacPolicy = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 4), H3cDot11WMMCACPolicy()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioCacPolicy.setStatus('current')
h3cDot11RadioCacChlUtlValue = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 5), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 100))).setUnits('percent').setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioCacChlUtlValue.setStatus('current')
h3cDot11RadioCacUserNum = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 1, 1, 6), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 64))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioCacUserNum.setStatus('current')
h3cDot11RadioWmmEdcaCfgTable = MibTable((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2), )
if mibBuilder.loadTexts: h3cDot11RadioWmmEdcaCfgTable.setStatus('current')
h3cDot11RadioWmmEdcaCfgEntry = MibTableRow((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1), ).setIndexNames((0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11WmmRadioIndex"), (0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11RadioWmmAC"))
if mibBuilder.loadTexts: h3cDot11RadioWmmEdcaCfgEntry.setStatus('current')
h3cDot11RadioWmmAC = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 1), H3cDot11QosAcType())
if mibBuilder.loadTexts: h3cDot11RadioWmmAC.setStatus('current')
h3cDot11RadioWmmAifsn = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmAifsn.setStatus('current')
h3cDot11RadioWmmEcwMin = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 3), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmEcwMin.setStatus('current')
h3cDot11RadioWmmEcwMax = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 4), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmEcwMax.setStatus('current')
h3cDot11RadioWmmTxoplimit = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 5), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmTxoplimit.setStatus('current')
h3cDot11RadioWmmNoAck = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 2, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RadioWmmNoAck.setStatus('current')
h3cDot11StationWmmEdcaTable = MibTable((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3), )
if mibBuilder.loadTexts: h3cDot11StationWmmEdcaTable.setStatus('current')
h3cDot11StationWmmEdcaEntry = MibTableRow((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1), ).setIndexNames((0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11WmmRadioIndex"), (0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11StationWmmAC"))
if mibBuilder.loadTexts: h3cDot11StationWmmEdcaEntry.setStatus('current')
h3cDot11StationWmmAC = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 1), H3cDot11QosAcType())
if mibBuilder.loadTexts: h3cDot11StationWmmAC.setStatus('current')
h3cDot11StationWmmAifsn = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 2), Integer32().subtype(subtypeSpec=ValueRangeConstraint(2, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11StationWmmAifsn.setStatus('current')
h3cDot11StationWmmEcwMin = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 3), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11StationWmmEcwMin.setStatus('current')
h3cDot11StationWmmEcwMax = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 4), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11StationWmmEcwMax.setStatus('current')
h3cDot11StationWmmTxoplimit = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 5), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11StationWmmTxoplimit.setStatus('current')
h3cDot11StationWmmCacEnabled = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 3, 1, 6), TruthValue()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11StationWmmCacEnabled.setStatus('current')
h3cDot11WmmResetGroup = MibIdentifier((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 4))
h3cDot11WmmResetRadioByAP = MibScalar((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 4, 1), Integer32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11WmmResetRadioByAP.setStatus('current')
h3cDot11WmmResetStationByAP = MibScalar((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 4, 2), Integer32()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11WmmResetStationByAP.setStatus('current')
h3cDot11RadioWmmEdcaCfg2Table = MibTable((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5), )
if mibBuilder.loadTexts: h3cDot11RadioWmmEdcaCfg2Table.setStatus('current')
h3cDot11RadioWmmEdcaCfg2Entry = MibTableRow((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1), ).setIndexNames((0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11WMMAPSerialID"), (0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11WMMRdId"), (0, "A3COM-HUAWEI-DOT11-QOS-MIB", "h3cDot11RdWmmAC"))
if mibBuilder.loadTexts: h3cDot11RadioWmmEdcaCfg2Entry.setStatus('current')
h3cDot11WMMAPSerialID = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 1), H3cDot11ObjectIDType())
if mibBuilder.loadTexts: h3cDot11WMMAPSerialID.setStatus('current')
h3cDot11WMMRdId = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 2), H3cDot11RadioScopeType())
if mibBuilder.loadTexts: h3cDot11WMMRdId.setStatus('current')
h3cDot11RdWmmAC = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 3), H3cDot11QosAcType())
if mibBuilder.loadTexts: h3cDot11RdWmmAC.setStatus('current')
h3cDot11RdWmmAifsn = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 4), Integer32().subtype(subtypeSpec=ValueRangeConstraint(1, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RdWmmAifsn.setStatus('current')
h3cDot11RdWmmEcwMin = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 5), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RdWmmEcwMin.setStatus('current')
h3cDot11RdWmmEcwMax = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 6), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 15))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RdWmmEcwMax.setStatus('current')
h3cDot11RdWmmTxoplimit = MibTableColumn((1, 3, 6, 1, 4, 1, 43, 45, 1, 10, 2, 75, 9, 1, 5, 1, 7), Integer32().subtype(subtypeSpec=ValueRangeConstraint(0, 65535))).setMaxAccess("readwrite")
if mibBuilder.loadTexts: h3cDot11RdWmmTxoplimit.setStatus('current')
mibBuilder.exportSymbols("A3COM-HUAWEI-DOT11-QOS-MIB", h3cDot11RadioWmmEdcaCfgEntry=h3cDot11RadioWmmEdcaCfgEntry, h3cDot11StationWmmEdcaEntry=h3cDot11StationWmmEdcaEntry, h3cDot11StationWmmTxoplimit=h3cDot11StationWmmTxoplimit, h3cDot11WmmResetStationByAP=h3cDot11WmmResetStationByAP, h3cDot11RadioWmmEdcaCfg2Entry=h3cDot11RadioWmmEdcaCfg2Entry, H3cDot11WMMCACPolicy=H3cDot11WMMCACPolicy, h3cDot11StationWmmEdcaTable=h3cDot11StationWmmEdcaTable, h3cDot11WmmCfgGroup=h3cDot11WmmCfgGroup, h3cDot11RadioWmmAC=h3cDot11RadioWmmAC, h3cDot11WmmRadioIndex=h3cDot11WmmRadioIndex, h3cDot11StationWmmEcwMax=h3cDot11StationWmmEcwMax, h3cDot11RadioCacChlUtlValue=h3cDot11RadioCacChlUtlValue, h3cDot11RadioWmmEdcaCfg2Table=h3cDot11RadioWmmEdcaCfg2Table, h3cDot11RadioWmmEnabled=h3cDot11RadioWmmEnabled, h3cDot11RadioCacPolicy=h3cDot11RadioCacPolicy, h3cDot11WMMAPSerialID=h3cDot11WMMAPSerialID, h3cDot11RadioWmmNoAck=h3cDot11RadioWmmNoAck, H3cDot11WMMSVPMapAC=H3cDot11WMMSVPMapAC, h3cDot11RadioWmmAifsn=h3cDot11RadioWmmAifsn, h3cDot11RadioWmmTxoplimit=h3cDot11RadioWmmTxoplimit, h3cDot11RdWmmEcwMin=h3cDot11RdWmmEcwMin, h3cDot11RadioCacUserNum=h3cDot11RadioCacUserNum, h3cDot11WmmResetRadioByAP=h3cDot11WmmResetRadioByAP, h3cDot11RdWmmAC=h3cDot11RdWmmAC, h3cDot11RdWmmEcwMax=h3cDot11RdWmmEcwMax, h3cDot11RdWmmAifsn=h3cDot11RdWmmAifsn, h3cDot11RdWmmTxoplimit=h3cDot11RdWmmTxoplimit, h3cDot11RadioWmmCfgEntry=h3cDot11RadioWmmCfgEntry, h3cDot11RadioWmmCfgTable=h3cDot11RadioWmmCfgTable, h3cDot11RadioWmmEcwMax=h3cDot11RadioWmmEcwMax, h3cDot11WmmResetGroup=h3cDot11WmmResetGroup, h3cDot11RadioSVPMapToAC=h3cDot11RadioSVPMapToAC, h3cDot11StationWmmAifsn=h3cDot11StationWmmAifsn, h3cDot11StationWmmAC=h3cDot11StationWmmAC, h3cDot11WMMRdId=h3cDot11WMMRdId, h3cDot11StationWmmEcwMin=h3cDot11StationWmmEcwMin, h3cDot11QoS=h3cDot11QoS, h3cDot11RadioWmmEdcaCfgTable=h3cDot11RadioWmmEdcaCfgTable, h3cDot11StationWmmCacEnabled=h3cDot11StationWmmCacEnabled, h3cDot11RadioWmmEcwMin=h3cDot11RadioWmmEcwMin, PYSNMP_MODULE_ID=h3cDot11QoS)
|
"""
Convert json lines txt to csv with relevant columns
"""
import os
import argparse
import glob
from utils import read_tweets
RAW_TWEET_DIR = 'raw_tweet'
CSV_TWEET_DIR = 'out'
# maybe create os dir
if not os.path.exists(CSV_TWEET_DIR):
os.makedirs(CSV_TWEET_DIR)
def tocsv(lang_detection,include_current,data_path=RAW_TWEET_DIR,out_path=CSV_TWEET_DIR):
"""
convert json to csv
"""
lst = []
raw_files = glob.glob(data_path + "/gn_tweet_*.txt")
raw_files.sort(key=os.path.getmtime)
#
csv_files = [name[:-4].replace(out_path + "/","") for name in glob.glob(out_path + "/gn_tweet_*utc.csv")]
print(csv_files)
# include current scrape
raw_files = raw_files if include_current else raw_files[:-1]
try:
print('Start process...')
for filename in raw_files:
# get file name
json_vs_csv = filename.split("/")
name = json_vs_csv[-1].split(".")[0] # i just want the file name without extension
if name not in csv_files: # if csv do not exists
# to csv
print(name)
if read_tweets(filename):
lst.append(name)
else:
print(name, "has been already processed")
except Exception as e:
print('Process aborted', e)
finally:
print('...End process')
return lst
if __name__ == '__main__':
# cli inputs
parser = argparse.ArgumentParser()
parser.add_argument('--lang_detection', required=False, type=bool, default=False,
help='detect lang of tweets?')
parser.add_argument('--include_current', required=False, type=bool, default=False,
help='include current scrape?')
args = parser.parse_args()
##############################################################################
# unpack
lang_detection = args.lang_detection # to-do
include_current = args.include_current
#
tweet_csv = ", ".join(tocsv(lang_detection,include_current))
print('CSV tweets {}'.format(tweet_csv))
|
# Copyright (C) 2009-2016, Quentin "mefyl" Hocquet
#
# This software is provided "as is" without warranty of any kind,
# either expressed or implied, including but not limited to the
# implied warranties of fitness for a particular purpose.
#
# See the LICENSE file for more information.
from .. import Builder, Node, Path, node
class Bison:
def __init__(self, bison = 'bison'):
self.__bison = bison
def plug(self, toolkit):
toolkit.hook_bin_src_add(self.hook_bin_src)
def hook_bin_src(self, src):
if isinstance(src, BisonSource):
builder = BisonCompiler(src, self)
return builder.cc()
def compile(self, path, dst):
return '%s --defines --report=all -Dparse.error=verbose -Dlr.default-reductions=consistent --xml %s -o %s' % (self.__bison, path, dst)
class BisonSource(Node):
def __init__(self, path):
Node.__init__(self, path)
Node.extensions['y'] = BisonSource
Node.extensions['yy'] = BisonSource
class BisonCompiler(Builder):
name = 'Bison compilation'
def __init__(self, source, bison):
self.__source = source
self.__bison = bison
base_path = source.name()
grammar_cc_path = Path(base_path)
grammar_cc_path.extension = 'cc'
self.__grammar_cc = node(grammar_cc_path)
grammar_hh_path = Path(base_path)
grammar_hh_path.extension = 'hh'
self.__grammar_hh = node(grammar_hh_path)
for base in ['location', 'position', 'stack']:
path = base_path.dirname() / ('%s.hh' % base)
self.__dict__['_BisonCompiler__%s' % base] = node(path)
self.__grammar_hh = node(grammar_hh_path)
Builder.__init__(self, [source],
[self.__grammar_cc,
self.__grammar_hh,
self.__location,
self.__position,
self.__stack,
])
def execute(self):
return self.cmd('Bison %s' % self.__source,
self.__bison.compile(self.__source.path(),
self.__grammar_cc.path()))
def cc(self):
return self.__grammar_cc
|
"""
DB abstraction for Daoliproxy
"""
from daoliproxy.db.api import *
|
"""
The implementation of the `isqlite` command-line tool.
"""
import collections
import importlib
import shutil
import sqlite3
import sys
import tempfile
import traceback
import click
import sqliteparser
from tabulate import tabulate
from . import Database, Schema, migrations
# Help strings used in multiple places.
HELP_AUTO_TIMESTAMP_CREATE = (
"Automatically populate `created_at` and `last_updated_at` columns with current "
+ "time."
)
HELP_AUTO_TIMESTAMP_UPDATE = (
"Automatically populate `last_updated_at` column with current time."
)
HELP_COLUMNS = "Only display these columns in the results."
HELP_DESC = (
"When combined with --order-by, order the results in descending rather than "
+ "ascending order."
)
HELP_HIDE = "Hide these columns in the results."
HELP_LIMIT = "Limit the number of rows returned from the database."
HELP_NO_CONFIRM = "Do not prompt for confirmation."
HELP_NO_RENAME = "Don't rename columns, only add or remove them."
HELP_OFFSET = "Offset a query with --limit."
HELP_ORDER_BY = "Order the results by one or more columns."
HELP_PAGE = (
"Select the page of results to show, "
+ "if the table is too wide to display in one screen."
)
HELP_PLAIN_FOREIGN_KEYS = (
"By default, isqlite will pretty-print foreign key columns with the first "
+ "TEXT column of the foreign key table. Pass this flag if you would rather just "
+ "see the foreign key values themselves."
)
@click.group()
def cli():
pass
@cli.command(name="add-column")
@click.argument("db_path")
@click.argument("table")
@click.argument("column")
def main_add_column(db_path, table, column):
"""
Add a column to a table.
"""
with Database(db_path) as db:
db.add_column(table, column)
print(f"Column added to table {table!r}.")
@cli.command(name="alter-column")
@click.argument("db_path")
@click.argument("table")
@click.argument("column")
def main_alter_column(db_path, table, column):
"""
Alter a column's definition.
"""
with Database(db_path) as db:
column_name, column_def = column.split(maxsplit=1)
db.alter_column(table, column_name, column_def)
print(f"Column {column_name!r} altered in table {table!r}.")
@cli.command(name="count")
@click.argument("db_path")
@click.argument("table")
@click.option("-w", "--where", default="")
@click.option(
"--distinct",
default=None,
help="Only count rows with distinct values of this column.",
)
def main_count(db_path, table, *, where, distinct):
"""
Count the number of rows that match the criteria.
"""
with Database(db_path) as db:
print(db.count(table, where=where, distinct=distinct))
@cli.command(name="create")
@click.argument("db_path")
@click.argument("table")
@click.argument("payload", nargs=-1)
@click.option(
"--auto-timestamp/--no-auto-timestamp",
default=True,
help=HELP_AUTO_TIMESTAMP_CREATE,
)
def main_create(db_path, table, payload, *, auto_timestamp=True):
"""
Create a new row non-interactively.
PAYLOAD should be a list of space-separated key-value pairs, e.g.
isqlite create --db db.sqlite3 my_table a=1 b=2
"""
_create(db_path, table, payload, auto_timestamp=auto_timestamp)
@cli.command(name="insert")
@click.argument("db_path")
@click.argument("table")
@click.argument("payload", nargs=-1)
@click.option(
"--auto-timestamp/--no-auto-timestamp",
default=True,
help=HELP_AUTO_TIMESTAMP_CREATE,
)
def main_insert(db_path, table, payload, *, auto_timestamp=True):
"""
Alias for 'create'.
"""
_create(db_path, table, payload, auto_timestamp=auto_timestamp)
def _create(db_path, table, payload, *, auto_timestamp):
if not payload:
report_error_and_exit("payload must not be empty")
payload_as_map = {}
for key_value in payload:
key, value = key_value.split("=", maxsplit=1)
payload_as_map[key] = value
if auto_timestamp:
auto_timestamp_columns = ["created_at", "last_updated_at"]
else:
auto_timestamp_columns = []
with Database(db_path) as db:
pk = db.insert(
table, payload_as_map, auto_timestamp_columns=auto_timestamp_columns
)
print(f"Row {pk} created.")
@cli.command(name="create-table")
@click.argument("db_path")
@click.argument("table")
@click.argument("columns", nargs=-1)
def main_create_table(db_path, table, columns):
"""
Create a table.
"""
with Database(db_path) as db:
db.create_table(table, columns)
print(f"Table {table!r} created.")
@cli.command(name="delete")
@click.argument("db_path")
@click.argument("table")
@click.argument("pk", type=int, required=False, default=None)
@click.option("-w", "--where", default="")
@click.option(
"--no-confirm",
is_flag=True,
default=False,
help=HELP_NO_CONFIRM,
)
def main_delete(db_path, table, pk, *, where, no_confirm):
"""
Delete a row.
"""
with Database(db_path) as db:
if pk is not None:
row = db.get_by_pk(table, pk, get_related=True)
for key, value in row.items():
if isinstance(value, collections.OrderedDict):
row[key] = get_column_as_string(value)
if row is None:
print(f"Row {pk} not found in table {table!r}.")
sys.exit(1)
prettyprint_row(row)
if not no_confirm:
print()
if not click.confirm("Are you sure you wish to delete this record?"):
print()
print("Operation aborted.")
sys.exit(1)
db.delete_by_pk(table, pk)
print()
print(f"Row {pk} deleted from table {table!r}.")
else:
if not no_confirm:
n = db.count(table, where=where)
if not where:
msg = f"Are you sure you wish to delete ALL {pluralize(n, 'row')} from {table!r}?"
else:
msg = f"Are you sure you wish to delete {pluralize(n, 'row')} from {table!r}?"
if not click.confirm(msg):
print()
print("Operation aborted.")
sys.exit(1)
# `Database.delete` doesn't accept a blank `where` parameter for safety
# reasons, so we use an explicit WHERE clause that will match every row.
if not where:
where = "1"
db.delete(table, where=where)
print()
print(f"{pluralize(n, 'row')} from table {table!r} deleted.")
@cli.command(name="diff")
@click.argument("db_path")
@click.argument("schema_path")
@click.option("--table", default=None)
@click.option(
"--no-rename",
is_flag=True,
default=False,
help=HELP_NO_RENAME,
)
def main_diff(db_path, schema_path, table):
"""
Diff the database against the Python schema.
"""
schema = get_schema_from_path(schema_path)
with Database(db_path, readonly=True) as db:
_diff(db, schema, table)
def _diff(db, schema, table, *, detect_renaming=True):
diff = db.diff(schema, table=table, detect_renaming=detect_renaming)
if not diff:
print("Nothing to migrate: database matches schema.")
return None
tables_created = 0
tables_dropped = 0
columns_dropped = 0
printed = False
grouped_diff = group_diff_by_table(diff)
for table, table_diff in sorted(grouped_diff.items(), key=lambda kv: kv[0]):
if printed:
print()
else:
printed = True
print(f"Table {blue(table)}")
for op in table_diff:
if isinstance(op, migrations.DropColumnMigration):
columns_dropped += 1
elif isinstance(op, migrations.DropTableMigration):
tables_dropped += 1
elif isinstance(op, migrations.CreateTableMigration):
tables_created += 1
print(f"- {op}")
print()
print()
print("Summary")
print(f"- {blue(pluralize(len(grouped_diff), 'table'))} affected.")
print(f"- {blue(pluralize(len(diff), 'operation'))} in total.")
if tables_created > 0:
print(f"- {blue(pluralize(tables_created, 'table'))} created.")
if tables_dropped > 0:
print(f"- {red(pluralize(tables_dropped, 'table'))} dropped.")
if columns_dropped > 0:
print(f"- {red(pluralize(columns_dropped, 'column'))} dropped.")
return (diff, tables_dropped or columns_dropped)
@cli.command(name="drop-column")
@click.argument("db_path")
@click.argument("table")
@click.argument("column")
@click.option(
"--no-confirm",
is_flag=True,
default=False,
help=HELP_NO_CONFIRM,
)
def main_drop_column(db_path, table, column, *, no_confirm):
"""
Drop a column from a table.
"""
if not no_confirm:
with Database(db_path) as db:
count = db.count(table)
print(
f"WARNING: Table {table!r} contains {pluralize(count, 'row')} of data."
)
print()
if not click.confirm("Are you sure you wish to drop this column?"):
print()
print("Operation aborted.")
sys.exit(1)
with Database(db_path) as db:
db.drop_column(table, column)
print()
print(f"Column {column!r} dropped from table {table!r}.")
@cli.command(name="drop-table")
@click.argument("db_path")
@click.argument("table")
@click.option(
"--no-confirm",
is_flag=True,
default=False,
help=HELP_NO_CONFIRM,
)
def main_drop_table(db_path, table, *, no_confirm):
"""
Drop a table from the database.
"""
with Database(db_path) as db:
if not no_confirm:
count = db.count(table)
print(
f"WARNING: Table {table!r} contains {pluralize(count, 'row')} of data."
)
print()
if not click.confirm("Are you sure you wish to drop this table?"):
print()
print("Operation aborted.")
sys.exit(1)
db.drop_table(table)
print()
print(f"Table {table!r} dropped from the database.")
@cli.command(name="get")
@click.argument("db_path")
@click.argument("table")
@click.argument("pk", type=int)
@click.option(
"--plain-foreign-keys", is_flag=True, default=False, help=HELP_PLAIN_FOREIGN_KEYS
)
def main_get(db_path, table, pk, *, plain_foreign_keys):
"""
Fetch a single row.
"""
with Database(db_path, readonly=True) as db:
row = db.get_by_pk(table, pk, get_related=not plain_foreign_keys)
if row is None:
report_error_and_exit(f"row {pk} not found in table {table!r}.")
if not plain_foreign_keys:
for key, value in row.items():
if isinstance(value, collections.OrderedDict):
row[key] = get_column_as_string(value)
prettyprint_row(row)
@cli.command(name="icreate")
@click.argument("db_path")
@click.argument("table")
@click.option(
"--auto-timestamp/--no-auto-timestamp",
default=True,
help=HELP_AUTO_TIMESTAMP_CREATE,
)
def main_icreate(db_path, table, *, auto_timestamp=True):
"""
Interactively insert a new row into the table.
"""
if auto_timestamp:
auto_timestamp_columns = ["created_at", "last_updated_at"]
else:
auto_timestamp_columns = []
with Database(db_path) as db:
payload = _prompt_for_table(db, table, None, auto_timestamp=auto_timestamp)
pk = db.insert(table, payload, auto_timestamp_columns=auto_timestamp_columns)
print(f"Row {pk} created.")
@cli.command(name="iupdate")
@click.argument("db_path")
@click.argument("table")
@click.argument("pk", type=int)
@click.option(
"--auto-timestamp/--no-auto-timestamp",
default=True,
help=HELP_AUTO_TIMESTAMP_UPDATE,
)
def main_iupdate(db_path, table, pk, *, auto_timestamp=True):
"""
Interactively update a row in the table.
"""
if auto_timestamp:
auto_timestamp_columns = ["last_updated_at"]
else:
auto_timestamp_columns = []
with Database(db_path) as db:
row = db.get_by_pk(table, pk)
if row is None:
report_error_and_exit(f"row {pk} not found in table {table!r}.")
print(
"Enter a blank line to leave a row unchanged. Enter NULL to set a row blank."
)
print()
payload = _prompt_for_table(db, table, row, auto_timestamp=auto_timestamp)
db.update_by_pk(
table, pk, payload, auto_timestamp_columns=auto_timestamp_columns
)
print(f"Row {row['id']} updated.")
def _prompt_for_table(db, table, row, *, auto_timestamp):
updating = bool(row is not None)
payload = {}
for column in db.schema[table].columns:
# Skip primary key columns as they will be filled in automatically.
if any(
isinstance(constraint, sqliteparser.ast.PrimaryKeyConstraint)
for constraint in column.definition.constraints
):
continue
# If auto timestamp support is enabled, skip `created_at` and
# `last_updated_at` columns.
if auto_timestamp and column.name in ("created_at", "last_updated_at"):
continue
required = any(
isinstance(constraint, sqliteparser.ast.NotNullConstraint)
for constraint in column.definition.constraints
)
prompt_builder = [column.name, " (", column.definition.type]
if required:
prompt_builder.append(", required")
if not updating and column.definition.default:
prompt_builder.append(", default ")
if isinstance(column.definition.default, sqliteparser.ast.String):
prompt_builder.append(repr(column.definition.default.value))
elif isinstance(column.definition.default, sqliteparser.ast.Integer):
prompt_builder.append(repr(column.definition.default.value))
else:
prompt_builder.append(repr(column.definition.default.value))
prompt_builder.append(")")
if row is not None:
prompt_builder.append(" - currently ")
prompt_builder.append(repr(row[column.name]))
prompt_builder.append("? ")
value = input("".join(prompt_builder)).strip()
if not value:
continue
if value == "NULL":
value = None if column.definition.type != "TEXT" else ""
payload[column.name] = value
return payload
@cli.command(name="list")
@click.argument("db_path")
@click.argument("table")
@click.option("-w", "--where", default="")
@click.option("-s", "--search")
@click.option("--columns", multiple=True, default=[], help=HELP_COLUMNS)
@click.option("--hide", multiple=True, default=[], help=HELP_HIDE)
@click.option("-p", "--page", default=1, help=HELP_PAGE)
@click.option("--limit", default=None, help=HELP_LIMIT)
@click.option("--offset", default=None, help=HELP_OFFSET)
@click.option("--order-by", multiple=True, default=[], help=HELP_ORDER_BY)
@click.option("--desc", is_flag=True, default=False, help=HELP_DESC)
@click.option(
"--plain-foreign-keys", is_flag=True, default=False, help=HELP_PLAIN_FOREIGN_KEYS
)
def main_list(
db_path,
table,
*,
where,
search,
columns,
hide,
page,
limit,
offset,
order_by,
desc,
plain_foreign_keys,
):
"""
List the rows in the table, optionally filtered by a SQL clause.
"""
_select(
db_path,
table,
where=where,
search=search,
columns=columns,
hide=hide,
page=page,
limit=limit,
offset=offset,
order_by=order_by,
desc=desc,
plain_foreign_keys=plain_foreign_keys,
)
@cli.command(name="select")
@click.argument("db_path")
@click.argument("table")
@click.option("-w", "--where", default="")
@click.option("-s", "--search")
@click.option("--columns", multiple=True, default=[], help=HELP_COLUMNS)
@click.option("--hide", multiple=True, default=[], help=HELP_HIDE)
@click.option("-p", "--page", default=1, help=HELP_PAGE)
@click.option("--limit", default=None, help=HELP_LIMIT)
@click.option("--offset", default=None, help=HELP_OFFSET)
@click.option("--order-by", multiple=True, default=[], help=HELP_ORDER_BY)
@click.option("--desc", is_flag=True, default=False, help=HELP_DESC)
@click.option(
"--plain-foreign-keys", is_flag=True, default=False, help=HELP_PLAIN_FOREIGN_KEYS
)
def main_select(
db_path,
table,
*,
where,
search,
columns,
hide,
page,
limit,
offset,
order_by,
desc,
plain_foreign_keys,
):
"""
Alias for 'list'.
"""
_select(
db_path,
table,
where=where,
search=search,
columns=columns,
hide=hide,
page=page,
limit=limit,
offset=offset,
order_by=order_by,
desc=desc,
plain_foreign_keys=plain_foreign_keys,
)
def _select(
db_path,
table,
*,
where,
search,
columns,
hide,
page,
limit,
offset,
order_by,
desc,
plain_foreign_keys,
):
"""
Base implementation shared by `main_list`, `main_search`, and `main_select`.
"""
with Database(db_path, readonly=True) as db:
try:
rows = db.select(
table,
where=where,
order_by=order_by,
limit=limit,
offset=offset,
descending=desc if order_by else None,
get_related=not plain_foreign_keys,
)
except sqlite3.OperationalError:
# Because `get_related` uses SQL joins, it may cause 'ambiguous column'
# errors if the user-supplied WHERE clause has unqualified column names. So
# we simply retry on error with `get_related=False`.
rows = db.select(
table,
where=where,
order_by=order_by,
limit=limit,
offset=offset,
descending=desc if order_by else None,
get_related=False,
)
if not plain_foreign_keys:
for row in rows:
for key, value in row.items():
if isinstance(value, collections.OrderedDict):
row[key] = get_column_as_string(value)
if search:
search = search.lower()
filtered_rows = []
for row in rows:
yes = False
for value in row.values():
if isinstance(value, str) and search in value.lower():
yes = True
elif isinstance(value, collections.OrderedDict):
for subvalue in value.values():
if isinstance(subvalue, str) and search in subvalue.lower():
yes = True
break
if yes:
break
if yes:
filtered_rows.append(row)
rows = filtered_rows
if not rows:
if search:
print(
f"No rows found in table {table!r} "
+ f"matching search query {search!r}."
)
elif where:
print(f"No rows found in table {table!r} with constraint {where!r}.")
else:
print(f"No row founds in table {table!r}.")
else:
prettyprint_rows(rows, columns=columns, hide=hide, page=page)
@cli.command(name="migrate")
@click.argument("db_path")
@click.argument("schema_path")
@click.option("--table", default=None)
@click.option(
"--no-confirm",
is_flag=True,
default=False,
help="Perform the migration without requiring human confirmation.",
)
@click.option(
"--no-backup",
is_flag=True,
default=False,
help="Don't create a backup of the database.",
)
@click.option(
"--no-rename",
is_flag=True,
default=False,
help=HELP_NO_RENAME,
)
@click.option(
"--debug",
is_flag=True,
default=False,
help="Run the database in debug mode.",
)
def main_migrate(
db_path, schema_path, table, *, no_confirm, no_backup, no_rename, debug
):
"""
Migrate the database to match the Python schema.
"""
schema = get_schema_from_path(schema_path)
with Database(db_path, transaction=False, debug=debug) as db:
diff, data_dropped = _diff(db, schema, table, detect_renaming=not no_rename)
if diff is None:
return
if not no_confirm:
prompt = "Do you wish to perform the migration?"
if data_dropped:
prompt += red(" Some data may be lost.")
print()
if not click.confirm(prompt):
print()
print("Migration aborted.")
sys.exit(2)
if not no_backup:
_, backup_name = tempfile.mkstemp(
prefix="isqlite-backup-", suffix=".sqlite3"
)
shutil.copy2(db_path, backup_name)
try:
db.apply_diff(diff)
except Exception:
traceback.print_exc()
print()
print("Migration rolled back due to Python exception.")
sys.exit(2)
if no_backup:
print()
print("Migration completed successfully.")
else:
print()
print(
"Migration completed successfully. "
+ f"Backup of database before migration saved at {backup_name}."
)
@cli.command(name="rename-column")
@click.argument("db_path")
@click.argument("table")
@click.argument("old_name")
@click.argument("new_name")
def main_rename_column(db_path, table, old_name, new_name):
"""
Rename a column.
"""
with Database(db_path) as db:
db.rename_column(table, old_name, new_name)
print(f"Column {old_name!r} renamed to {new_name!r} in table {table!r}.")
@cli.command(name="rename-table")
@click.argument("db_path")
@click.argument("table")
@click.argument("new_name")
def main_rename_table(db_path, table, new_name):
"""
Rename a table.
"""
with Database(db_path) as db:
db.rename_table(table, new_name)
print(f"Table {table!r} renamed to {new_name!r}.")
@cli.command(name="reorder-columns")
@click.argument("db_path")
@click.argument("table")
@click.argument("columns", nargs=-1)
def main_reorder_columns(db_path, table, columns):
"""
Change the order of columns in a table.
"""
with Database(db_path) as db:
db.reorder_columns(table, columns)
print(f"Columns of table {table!r} reordered.")
@cli.command(name="schema")
@click.argument("db_path")
@click.argument("table", required=False, default=None)
@click.option("--as-python", is_flag=True, default=False)
def main_schema(db_path, table, *, as_python):
"""
List the names of the tables in the database.
"""
with Database(db_path, readonly=True) as db:
if table is not None:
row = db.get(
"sqlite_master",
where="type = 'table' AND name = :table",
values={"table": table},
)
if row is None:
report_error_and_exit(f"table {table!r} not found.")
sql = row["sql"]
if as_python:
raise NotImplementedError
else:
try:
# Use sqliteparser to parse and pretty-print the table schema.
create_table_statement = sqliteparser.parse(sql)[0]
print(create_table_statement)
except sqliteparser.SQLiteParserError:
# If sqliteparser can't parse the table schema, just directly print
# what SQLite returned to us.
print(sql)
else:
if as_python:
raise NotImplementedError
else:
rows = db.select(
"sqlite_master",
where="type = 'table' AND name NOT LIKE 'sqlite_%'",
order_by="name",
)
if rows:
print("\n".join(row["name"] for row in rows))
@cli.command(name="search")
@click.argument("db_path")
@click.argument("table")
@click.argument("query")
@click.option("-w", "--where", default="")
@click.option("--columns", multiple=True, default=[], help=HELP_COLUMNS)
@click.option("--hide", multiple=True, default=[], help=HELP_HIDE)
@click.option("-p", "--page", default=1, help=HELP_PAGE)
@click.option("--limit", default=None, help=HELP_LIMIT)
@click.option("--offset", default=None, help=HELP_OFFSET)
@click.option("--order-by", multiple=True, default=[], help=HELP_ORDER_BY)
@click.option("--desc", is_flag=True, default=False, help=HELP_DESC)
@click.option(
"--plain-foreign-keys", is_flag=True, default=False, help=HELP_PLAIN_FOREIGN_KEYS
)
def main_search(
db_path,
table,
query,
*,
where,
columns,
hide,
page,
limit,
offset,
order_by,
desc,
plain_foreign_keys,
):
"""
Alias for 'list <table> -s <query>'.
"""
_select(
db_path,
table,
where=where,
search=query,
columns=columns,
hide=hide,
page=page,
limit=limit,
offset=offset,
order_by=order_by,
desc=desc,
plain_foreign_keys=plain_foreign_keys,
)
@cli.command(name="sql")
@click.argument("db_path")
@click.argument("query")
@click.option("--columns", multiple=True, default=[], help=HELP_COLUMNS)
@click.option("--hide", multiple=True, default=[], help=HELP_HIDE)
@click.option("-p", "--page", default=1, help=HELP_PAGE)
@click.option(
"--write",
is_flag=True,
default=False,
help="Allow writing to the database. False by default.",
)
def main_sql(db_path, query, *, columns, hide, page, write):
"""
Run a SQL command.
"""
readonly = not write
with Database(db_path, readonly=readonly) as db:
try:
rows = db.sql(query)
except sqlite3.OperationalError as e:
if e.args and e.args[0] == "attempt to write a readonly database":
report_error_and_exit(
"cannot write to read-only database. Re-run with the --write flag."
)
raise e
if rows:
prettyprint_rows(rows, columns=columns, hide=hide, page=page)
# Don't print a message if there are no rows, because some SQL queries (e.g.,
# UPDATE) are not expected to return any rows, and printing a message can be
# confusing.
@cli.command(name="update")
@click.argument("db_path")
@click.argument("table")
@click.argument("pk", type=int)
@click.argument("payload", nargs=-1)
@click.option(
"--auto-timestamp/--no-auto-timestamp",
default=True,
help=HELP_AUTO_TIMESTAMP_UPDATE,
)
def main_update(db_path, table, pk, payload, *, auto_timestamp):
"""
Update an existing row non-interactively.
PAYLOAD should be a list of space-separated key-value pairs, e.g.
isqlite update --db db.sqlite3 my_table 123 a=1 b=2
To set a column null, use the special NULL value.
"""
if not payload:
report_error_and_exit("payload must not be empty")
payload_as_map = {}
for key_value in payload:
key, value = key_value.split("=", maxsplit=1)
if value == "NULL":
value = None
payload_as_map[key] = value
if auto_timestamp:
auto_timestamp_columns = ["last_updated_at"]
else:
auto_timestamp_columns = []
with Database(db_path) as db:
updated = db.update_by_pk(
table, pk, payload_as_map, auto_timestamp_columns=auto_timestamp_columns
)
if updated:
print(f"Row {pk} updated.")
else:
report_error_and_exit(f"row {pk} not found in table {table!r}.")
def prettyprint_rows(rows, *, columns=[], hide=[], page=1):
headers = [key for key in rows[0].keys() if should_show_column(key, columns, hide)]
table_rows = [
[cell for key, cell in row.items() if should_show_column(key, columns, hide)]
for row in rows
]
table = tabulate(table_rows, headers=headers)
overflow = False
width = shutil.get_terminal_size().columns
placeholder = " ..."
for line in table.splitlines():
if len(line) > width:
start = width * (page - 1)
end = start + width - len(placeholder)
if end < len(line):
print(line[start:end] + placeholder)
overflow = True
else:
print(line[start:end])
else:
print(line)
if table_rows:
print()
print(f"{pluralize(len(table_rows), 'row')}.")
if overflow or page > 1:
print()
if overflow:
print("Some columns truncated or hidden due to overflow.")
if page > 1:
print(
f"To see the previous page of columns, re-run with --page={page - 1}."
)
if overflow:
print(f"To see the next page of columns, re-run with --page={page + 1}.")
def prettyprint_row(row):
table = list(row.items())
print(tabulate(table))
def should_show_column(key, columns, hide):
if columns:
return key in columns
if hide:
return key not in hide
return True
def get_column_as_string(column):
pk = None
text = None
# Pretty rudimentary logic: assume the first integer value is the row's primary key
# and the first string value is a reasonable choice for displaying the row.
for value in column.values():
if isinstance(value, int) and pk is None:
pk = value
elif isinstance(value, str) and text is None:
text = value
if pk is not None and text is not None:
break
if pk is not None:
if text is not None:
return f"{pk} ({text})"
else:
return str(pk)
else:
if text is not None:
return text
else:
return "<foreign row>"
def get_schema_from_path(schema_path):
if schema_path is None:
return None
spec = importlib.util.spec_from_file_location("schema", schema_path)
if spec is None:
report_error_and_exit(f"could not load schema file at {schema_path}")
schema_module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(schema_module)
try:
schema = schema_module.SCHEMA
except AttributeError:
report_error_and_exit(f"did not find SCHEMA variable in {schema_path}")
if not isinstance(schema, Schema):
report_error_and_exit("SCHEMA must be an isqlite.Schema object")
return schema
def group_diff_by_table(diff):
diff_map = collections.defaultdict(list)
for op in diff:
diff_map[op.table_name].append(op)
return diff_map
def red(s):
return click.style(s, fg="red")
def blue(s):
return click.style(s, fg="blue")
def pluralize(n, word):
if n == 1:
return f"{n} {word}"
else:
return f"{n} {word}s"
def report_error_and_exit(message):
print(f"Error: {message}", file=sys.stderr)
sys.exit(1)
|
from django.urls import path
from .views import AdopterListView, AdopterCreateView, AdopterUpdateView
app_name = "adopters"
urlpatterns = [
path("adopters/", AdopterListView.as_view(), name="adopter-list"),
path("adopters/new", AdopterCreateView.as_view(), name="adopter-new"),
path("adopters/<int:pk>", AdopterUpdateView.as_view(), name="adopter-edit"),
]
|
# -*- coding: utf-8 -*-
from ._version import __version__, __version_info__
from .storage import LocalStorage
__all__ = ["__version__", "__version_info__", "LocalStorage"]
|
# This is an example which simulates the use case here: https://github.com/CoffeaTeam/coffea/blob/master/binder/muonspectrum_v1.ipynb
import time
import uproot
import uproot_methods
import awkward
from skyhookdmclient import SkyhookDM
import numpy
from coffea import hist
sk = SkyhookDM()
sk.connect('192.170.236.173','hepdatapool')
dst = sk.getDataset('nanoexample')
tstart = time.time()
masshist = hist.Hist("Counts", hist.Bin("mass", r"$m_{\mu\mu}$ [GeV]", 30000, 0.25, 300))
tables = sk.runQuery(dst,'select *, project Events;1.nMuon,Events;1.Muon_pt,Events;1.Muon_eta,Events;1.Muon_phi,Events;1.Muon_mass,Events;1.Muon_charge')
table = tables[0]
table.set_entrysteps(2)
for chunk in table:
p4 = uproot_methods.TLorentzVectorArray.from_ptetaphim(
chunk.pop('MUON_PT'),
chunk.pop('MUON_ETA'),
chunk.pop('MUON_PHI'),
chunk.pop('MUON_MASS'),
)
muons = awkward.JaggedArray.zip(p4=p4, charge=chunk['MUON_CHARGE'])
twomuons = (muons.counts == 2)
opposite_charge = (muons['charge'].prod() == -1)
dimuons = muons[twomuons & opposite_charge].distincts()
dimuon_mass = (dimuons.i0['p4'] + dimuons.i1['p4']).mass
masshist.fill(mass=dimuon_mass.flatten())
elapsed = time.time() - tstart
# fig, ax, _ = hist.plot1d(masshist)
# ax.set_xscale('log')
# ax.set_yscale('log')
# ax.set_ylim(0.1, 1e6)
print("Events/s:", masshist.values()[()].sum()/elapsed)
|
import folium
import pandas as pd
#대학교 리스트를 데이터 프레임으로 변환
df = pd.read_excel('D:/5674-833_4th/part4/서울지역 대학교 위치.xlsx',engine= 'openpyxl')
#서울 지도 만들기
seoul_map = folium.Map(location=[37.55,126.98], tiles= 'Stamen Terrain',
zoom_start= 12)
df.set_index('학교',inplace = True)
#대학교 위치 정보를 Marker로 표시
for name,lat,lng in zip(df.index,df.위도,df.경도):
folium.CircleMarker([lat,lng],
radius = 10, #원의 반지름
color = 'brown', #원의 둘레 색상
fill = True,
fill_color = 'coral', #원을 채우는 색
fill_opacity = 0.7, #투명도
popup= name
).add_to(seoul_map)
seoul_map.save('D:/seoul_colleges2.html')
|
from django.db import IntegrityError
from django.test import TestCase
from .models import Profile, User
class UserTest(TestCase):
""" Test module for Puppy model """
def setUp(self):
User.objects.create(
email='mario.rossi@gmail.com',
password="password",
first_name="mario",
last_name="rossi"
)
def test_user_create(self):
self.assertRaises(
IntegrityError,
User.objects.create,
email='lucia.rossi@gmail.com',
password="password",
)
def test_profile_created(self):
mario = User.objects.get(email="mario.rossi@gmail.com")
self.assertEqual(
mario.email, "mario.rossi@gmail.com"
)
self.assertIsNotNone(
mario.profile
)
def test_profile_slug_created(self):
mario = User.objects.get(email="mario.rossi@gmail.com")
self.assertIsNotNone(
mario.profile.slug
)
self.assertIsNot(
mario.profile.slug,
""
)
|
#!/usr/bin/env python
#
# 파이썬을 사용해서 JSON과 JSON Lines 파일을 읽고 쓰기
#
import sys, os, re
import json
import codecs
ary_of_objects = [
{'name': 'Russell Jurney', 'title': 'CEO'},
{'name': 'Muhammad Imran', 'title': 'VP of Marketing'},
{'name': 'Fe Mata', 'title': 'Chief Marketing Officer'},
]
path = "/tmp/test.jsonl"
#
# 객체를 jsonl에 쓰기
#
f = codecs.open(path, 'w', 'utf-8')
for row_object in ary_of_objects:
# ensure_ascii=False is essential or errors/corruption will occur
json_record = json.dumps(row_object, ensure_ascii=False)
f.write(json_record + "\n")
f.close()
print("Wrote JSON Lines file /tmp/test.jsonl")
#
# 이 jsonl을 다시 객체로 읽어 들이기
#
ary_of_objects = []
f = codecs.open(path, "r", "utf-8")
for line in f:
record = json.loads(line.rstrip("\n|\r"))
ary_of_objects.append(record)
print(ary_of_objects)
print("Read JSON Lines file /tmp/test.jsonl")
#
# json과 jsonl 파일을 읽고 쓰기 위한 유틸리티 함수
#
def write_json_file(obj, path):
'''객체를 덤프해서 파일에 json으로 씀'''
f = codecs.open(path, 'w', 'utf-8')
f.write(json.dumps(obj, ensure_ascii=False))
f.close()
def write_json_lines_file(ary_of_objects, path):
'''객체 리스트를 json lines 파일로 덤프함'''
f = codecs.open(path, 'w', 'utf-8')
for row_object in ary_of_objects:
json_record = json.dumps(row_object, ensure_ascii=False)
f.write(json_record + "\n")
f.close()
def read_json_file(path):
'''일반 json 파일(레코드 당 CR 없이)을 객체로 변환'''
text = codecs.open(path, 'r', 'utf-8').read()
return json.loads(text)
def read_json_lines_file(path):
'''json lines 파일(레코드 당 CR 존재)을 객체 배열로 변환'''
ary = []
f = codecs.open(path, "r", "utf-8")
for line in f:
record = json.loads(line.rstrip("\n|\r"))
return ary
|
# coding=utf-8
"""
Wrapper for various check actions for different objects.
"""
import os
import socket
import subprocess
from typing import Optional, Dict, List
from is_it_up.exceptions import IsItUpException
_ = Optional, Dict, List
class IsItUpBase(object):
def __init__(
self,
host: str,
ports: Optional[List[str]] = None,
timeout: Optional[float] = None,
) -> None:
self._state = {"available": False, "host": host}
self._hostname = None
self._ipaddr = None
def _resolve_dns_or_ip(self, host: str) -> None:
try:
result = socket.inet_aton(host)
self._ipaddr = host
self._hostname = self.__get_hostname(host)
except socket.error:
self._ipaddr = self.__get_ip(host)
self._hostname = host
def __get_ip(self, domain: str) -> Optional[str]:
try:
ip = socket.gethostbyname(domain)
return ip
except Exception:
return None
def __get_hostname(self, ipaddr: str) -> Optional[str]:
try:
hostname = socket.gethostbyaddr(ipaddr)[0]
return hostname
except Exception:
return None
def _ping(self, host: str, times: int = 1, timeout: int = 2000) -> None:
if os.name == "posix":
cmd = f"ping -c {times} -W {timeout} {host}"
elif os.name in ("nt", "dos", "ce"):
cmd = f"ping -n {times} -w {timeout} {host}"
result = subprocess.call(cmd, stdout=subprocess.DEVNULL, shell=True)
if result == 0:
self._state["ping"] = True
else:
self._state["ping"] = False
def _scan_ports(self, host: str, ports: List[str], timeout: float = 1.0) -> None:
int_ports = []
for i in ports:
if i.count("-") == 1:
first_port, last_port = i.split("-")
if first_port.isdigit() and last_port.isdigit():
first_port = int(first_port)
last_port = int(last_port)
else:
raise IsItUpException(f"Wrong port range for {host}")
int_ports = int_ports + list(range(first_port, last_port + 1))
elif i.count("-") == 0:
if i.isdigit():
int_ports.append(int(i))
else:
raise IsItUpException(f"Wrong port range for {host}")
else:
raise IsItUpException(f"Wrong port range for {host}")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
checked_ports = {key: False for key in int_ports}
for port in int_ports:
result = s.connect_ex((host, port))
if result == 0:
checked_ports[port] = True
s.close()
self._state["scanned_ports"] = checked_ports
|
from __future__ import annotations
from typing import Any, Generator, Optional, Tuple, Union
import numpy as np
from numpy.random import RandomState
from sklearn.model_selection import BaseCrossValidator
from sklearn.utils import check_random_state, resample
from ._typing import ArrayLike
class Subsample(BaseCrossValidator): # type: ignore
"""
Generate a sampling method, that resamples the training set with
possible bootstraps. It can replace KFold or LeaveOneOut as cv argument
in the MAPIE class.
Parameters
----------
n_resamplings : int
Number of resamplings.
n_samples: int
Number of samples in each resampling. By default ``None``,
the size of the training set.
replace: bool
Whether to replace samples in resamplings or not.
random_state: Optional
int or RandomState instance.
Examples
--------
>>> import numpy as np
>>> from mapie.subsample import Subsample
>>> cv = Subsample(n_resamplings=2,random_state=0)
>>> X = np.array([1,2,3,4,5,6,7,8,9,10])
>>> for train_index, test_index in cv.split(X):
... print(f"train index is {train_index}, test index is {test_index}")
train index is [5 0 3 3 7 9 3 5 2 4], test index is [8 1 6]
train index is [7 6 8 8 1 6 7 7 8 1], test index is [0 2 3 4 5 9]
"""
def __init__(
self,
n_resamplings: int,
n_samples: Optional[int] = None,
replace: bool = True,
random_state: Optional[Union[int, RandomState]] = None,
) -> None:
self.n_resamplings = n_resamplings
self.n_samples = n_samples
self.replace = replace
self.random_state = random_state
def split(
self, X: ArrayLike
) -> Generator[Tuple[Any, ArrayLike], None, None]:
"""
Generate indices to split data into training and test sets.
Parameters
----------
X : ArrayLike of shape (n_samples, n_features)
Training data.
Yields
------
train : ArrayLike of shape (n_indices_training,)
The training set indices for that split.
test : ArrayLike of shape (n_indices_test,)
The testing set indices for that split.
"""
indices = np.arange(len(X))
n_samples = (
self.n_samples if self.n_samples is not None else len(indices)
)
random_state = check_random_state(self.random_state)
for k in range(self.n_resamplings):
train_index = resample(
indices,
replace=self.replace,
n_samples=n_samples,
random_state=random_state,
stratify=None,
)
test_index = np.array(
list(set(indices) - set(train_index)), dtype=np.int64
)
yield train_index, test_index
def get_n_splits(self, *args: Any, **kargs: Any) -> int:
"""
Returns the number of splitting iterations in the cross-validator.
Returns
-------
n_splits : int
Returns the number of splitting iterations in the cross-validator.
"""
return self.n_resamplings
|
from django import forms
from django.forms.models import BaseInlineFormSet
from django.contrib import admin
from django.utils.translation import ugettext_lazy as _
from .models import Organisation, CategoryTemplate, Category, Contract
from .admin_forms import CategoryTemplateAdminForm
class CategoryInline(admin.StackedInline):
model = Category
fields = ('category_template',)
extra = 0
class GroupCategoryInline(admin.StackedInline):
model = Category.groups.through
extra = 0
class OrganisationAdmin(admin.ModelAdmin):
list_display = ('name', 'trigram', 'description')
prepopulated_fields = {'slug': ('name',)}
inlines = [CategoryInline]
class CategoryTemplateAdmin(admin.ModelAdmin):
list_display = (
'name', 'description', 'use_creation_form', 'display_reporting')
prepopulated_fields = {'slug': ('name',)}
form = CategoryTemplateAdminForm
class CategoryAdmin(admin.ModelAdmin):
list_display = ('organisation', 'category_template')
list_display_links = ('category_template',)
search_fields = ('organisation__name', 'category_template__name')
ordering = ('organisation', 'category_template')
filter_horizontal = ('users', 'groups', 'third_parties')
fieldsets = (
(None, {'fields': ('organisation', 'category_template')}),
('Members', {'fields': ('groups', 'users',)}),
('Third parties', {'fields': ('third_parties',)}),
)
class RequiredInlineFormSet(BaseInlineFormSet):
def clean(self):
super(RequiredInlineFormSet, self).clean()
existing_data = [data and not data.get('DELETE', False)
for data in self.cleaned_data]
if not any(existing_data):
raise forms.ValidationError(_('Please select at least one category'))
class UserCategoryInline(admin.StackedInline):
model = Category.users.through
extra = 0
formset = RequiredInlineFormSet
class ContractAdmin(admin.ModelAdmin):
list_display = ('number', 'name', 'get_associated_categories')
filter_horizontal = ('categories',)
def get_associated_categories(self, obj):
categories = obj.categories.all()
return ", ".join([c.name for c in categories])
get_associated_categories.short_description = _('Categories')
admin.site.register(Organisation, OrganisationAdmin)
admin.site.register(CategoryTemplate, CategoryTemplateAdmin)
admin.site.register(Category, CategoryAdmin)
admin.site.register(Contract, ContractAdmin)
|
"""Define common test utilities."""
import os
TEST_ALTITUDE = "1609.3"
TEST_API_KEY = "12345"
TEST_LATITUDE = "51.528308"
TEST_LONGITUDE = "-0.3817803"
def load_fixture(filename):
"""Load a fixture."""
path = os.path.join(os.path.dirname(__file__), "fixtures", filename)
with open(path, encoding="utf-8") as fptr:
return fptr.read()
|
import os
import re
import pickle
import functools
import logbook
from pathlib import Path
from subprocess import DEVNULL, Popen
from pathos.multiprocessing import ProcessingPool
import pandas as pd
from ete3 import Tree
from genbankqc import config
import genbankqc.genome as genome
class Species:
def __init__(
self,
path,
max_unknowns=200,
contigs=3.0,
assembly_size=3.0,
mash=3.0,
assembly_summary=None,
metadata=None,
):
"""Represents a collection of genomes in `path`
:param path: Path to the directory of related genomes you wish to analyze.
:param max_unknowns: Number of allowable unknown bases, i.e. not [ATCG]
:param contigs: Acceptable deviations from median number of contigs
:param assembly_size: Acceptable deviations from median assembly size
:param mash: Acceptable deviations from median MASH distances
:param assembly_summary: a pandas DataFrame with assembly summary information
"""
self.path = os.path.abspath(path)
self.deviation_values = [max_unknowns, contigs, assembly_size, mash]
self.label = "-".join(map(str, self.deviation_values))
self.paths = config.Paths(
root=Path(self.path), subdirs=["metadata", ".logs", "qc"]
)
self.qc_results_dir = os.path.join(self.paths.qc, self.label)
if not os.path.isdir(self.qc_results_dir):
os.mkdir(self.qc_results_dir)
self.name = os.path.basename(os.path.normpath(path))
self.log = logbook.Logger(self.name)
self.max_unknowns = max_unknowns
self.contigs = contigs
self.assembly_size = assembly_size
self.mash = mash
self.assembly_summary = assembly_summary
self.qc_dir = os.path.join(self.path, "qc")
self.passed_dir = os.path.join(self.qc_results_dir, "passed")
self.stats_path = os.path.join(self.qc_dir, "stats.csv")
self.nw_path = os.path.join(self.qc_dir, "tree.nw")
self.dmx_path = os.path.join(self.qc_dir, "dmx.csv")
self.failed_path = os.path.join(self.qc_results_dir, "failed.csv")
self.tree_img = os.path.join(self.qc_results_dir, "tree.svg")
self.summary_path = os.path.join(self.qc_results_dir, "qc_summary.txt")
self.allowed_path = os.path.join(self.qc_results_dir, "allowed.p")
self.paste_file = os.path.join(self.qc_dir, "all.msh")
# Figure out if defining these as None is necessary
self.tree = None
self.stats = None
self.dmx = None
if os.path.isfile(self.stats_path):
self.stats = pd.read_csv(self.stats_path, index_col=0)
if os.path.isfile(self.nw_path):
self.tree = Tree(self.nw_path, 1)
if os.path.isfile(self.failed_path):
self.failed_report = pd.read_csv(self.failed_path, index_col=0)
if os.path.isfile(self.dmx_path):
try:
self.dmx = pd.read_csv(self.dmx_path, index_col=0, sep="\t")
except pd.errors.EmptyDataError:
self.log.exception("Failed to read distance matrix")
self.metadata_path = os.path.join(
self.qc_dir, "{}_metadata.csv".format(self.name)
)
self.criteria = ["unknowns", "contigs", "assembly_size", "distance"]
self.tolerance = {
"unknowns": max_unknowns,
"contigs": contigs,
"assembly_size": assembly_size,
"distance": mash,
}
self.passed = self.stats
self.failed = {}
self.med_abs_devs = {}
self.dev_refs = {}
self.allowed = {"unknowns": max_unknowns}
self.colors = {
"unknowns": "red",
"contigs": "green",
"distance": "purple",
"assembly_size": "orange",
}
self.genomes = [
genome.Genome(path, self.assembly_summary) for path in self.genome_paths
]
def __str__(self):
self.message = [
"Species: {}".format(self.name),
"Maximum Unknown Bases: {}".format(self.max_unknowns),
"Acceptable Deviations:",
"Contigs, {}".format(self.contigs),
"Assembly Size, {}".format(self.assembly_size),
"MASH: {}".format(self.mash),
]
return "\n".join(self.message)
def assess(f):
@functools.wraps(f)
def wrapper(self):
try:
assert sorted(self.genome_names.tolist()) == sorted(
self.stats.index.tolist()
)
assert os.path.isfile(self.allowed_path)
self.log.info("Already complete")
except (AttributeError, AssertionError):
f(self)
return wrapper
def tree_complete(self):
try:
leaf_names = [re.sub(".fasta", "", i) for i in self.tree.get_leaf_names()]
assert (
sorted(leaf_names)
== sorted(self.stats.index.tolist())
== sorted(self.genome_names.tolist())
)
return True
except (AssertionError, AttributeError):
return False
@property
def genome_paths(self, ext="fasta"):
"""Returns a generator for every file ending with `ext`
:param ext: File extension of genomes in species directory
:returns: Generator of Genome objects for all genomes in species dir
:rtype: generator
"""
return [
os.path.join(self.path, genome)
for genome in os.listdir(self.path)
if genome.endswith(ext)
]
@property
def total_genomes(self):
return len(list(self.genomes))
@property
def sketches(self):
return Path(self.qc_dir).glob("GCA*msh")
@property
def total_sketches(self):
return len(list(self.sketches))
@property
def genome_names(self):
ids = [i.name for i in self.genomes]
return pd.Index(ids)
@property
def biosample_ids(self):
ids = self.assembly_summary.df.loc[self.accession_ids].biosample.tolist()
return ids
# may be redundant. see genome_names attrib
@property
def accession_ids(self):
ids = [i.accession_id for i in self.genomes if i.accession_id is not None]
return ids
def mash_paste(self):
if os.path.isfile(self.paste_file):
os.remove(self.paste_file)
sketches = os.path.join(self.qc_dir, "*msh")
cmd = "mash paste {} {}".format(self.paste_file, sketches)
Popen(cmd, shell="True", stderr=DEVNULL).wait()
if not os.path.isfile(self.paste_file):
self.log.error("MASH paste failed")
self.paste_file = None
def mash_dist(self):
from multiprocessing import cpu_count
ncpus = cpu_count() - 2
cmd = "mash dist -p {} -t '{}' '{}' > '{}'".format(
ncpus, self.paste_file, self.paste_file, self.dmx_path
)
Popen(cmd, shell="True", stderr=DEVNULL).wait()
self.dmx = pd.read_csv(self.dmx_path, index_col=0, sep="\t")
# Make distance matrix more readable
names = [os.path.splitext(i)[0].split("/")[-1] for i in self.dmx.index]
self.dmx.index = names
self.dmx.columns = names
self.dmx.to_csv(self.dmx_path, sep="\t")
def mash_sketch(self):
"""Sketch all genomes"""
with ProcessingPool() as pool:
pool.map(genome.sketch_genome, self.genome_paths)
def run_mash(self):
try:
self.mash_sketch()
except Exception:
self.log.exception("mash sketch failed")
try:
self.mash_paste()
except Exception:
self.log.exception("mash paste failed")
try:
self.mash_dist()
except Exception:
self.log.exception("mash dist failed")
def get_tree(self):
if not self.tree_complete():
from ete3.coretype.tree import TreeError
import numpy as np
from skbio.tree import TreeNode
from scipy.cluster.hierarchy import weighted
ids = ["{}.fasta".format(i) for i in self.dmx.index.tolist()]
triu = np.triu(self.dmx.as_matrix())
hclust = weighted(triu)
t = TreeNode.from_linkage_matrix(hclust, ids)
nw = t.__str__().replace("'", "")
self.tree = Tree(nw)
try:
# midpoint root tree
self.tree.set_outgroup(self.tree.get_midpoint_outgroup())
except TreeError:
self.log.error("Unable to midpoint root tree")
self.tree.write(outfile=self.nw_path)
@property
def stats_files(self):
return Path(self.qc_dir).glob("GCA*csv")
def get_stats(self):
"""Get stats for all genomes. Concat the results into a DataFrame"""
# pool.map needs an arg for each function that will be run
dmx_mean = [self.dmx.mean()] * len(self.genome_paths)
with ProcessingPool() as pool:
results = pool.map(genome.mp_stats, self.genome_paths, dmx_mean)
self.stats = pd.concat(results)
self.stats.to_csv(self.stats_path)
def MAD(self, df, col):
"""Get the median absolute deviation for col"""
MAD = abs(df[col] - df[col].median()).mean()
return MAD
def MAD_ref(MAD, tolerance):
"""Get the reference value for median absolute deviation"""
dev_ref = MAD * tolerance
return dev_ref
def bound(df, col, dev_ref):
lower = df[col].median() - dev_ref
upper = df[col].median() + dev_ref
return lower, upper
def filter_unknown_bases(self):
"""Filter out genomes with too many unknown bases."""
self.failed["unknowns"] = self.stats.index[
self.stats["unknowns"] > self.tolerance["unknowns"]
]
self.passed = self.stats.drop(self.failed["unknowns"])
# Perform this logic in self.filter
# Don't use decorator
def check_passed_count(f):
"""
Count the number of genomes in self.passed.
Commence with filtering only if self.passed has more than five genomes.
"""
@functools.wraps(f)
def wrapper(self, *args):
if len(self.passed) > 5:
f(self, *args)
else:
self.allowed[args[0]] = ""
self.failed[args[0]] = ""
self.log.info("Not filtering based on {}".format(f.__name__))
return wrapper
@check_passed_count
def filter_contigs(self, criteria):
"""
Only look at genomes with > 10 contigs to avoid throwing off the
median absolute deviation.
Median absolute deviation - Average absolute difference between
number of contigs and the median for all genomes
Extract genomes with < 10 contigs to add them back in later.
Add genomes with < 10 contigs back in
"""
eligible_contigs = self.passed.contigs[self.passed.contigs > 10]
not_enough_contigs = self.passed.contigs[self.passed.contigs <= 10]
# TODO Define separate function for this
med_abs_dev = abs(eligible_contigs - eligible_contigs.median()).mean()
self.med_abs_devs["contigs"] = med_abs_dev
# Define separate function for this
# The "deviation reference"
dev_ref = med_abs_dev * self.contigs
self.dev_refs["contigs"] = dev_ref
self.allowed["contigs"] = eligible_contigs.median() + dev_ref
self.failed["contigs"] = eligible_contigs[
abs(eligible_contigs - eligible_contigs.median()) > dev_ref
].index
eligible_contigs = eligible_contigs[
abs(eligible_contigs - eligible_contigs.median()) <= dev_ref
]
eligible_contigs = pd.concat([eligible_contigs, not_enough_contigs])
eligible_contigs = eligible_contigs.index
self.passed = self.passed.loc[eligible_contigs]
@check_passed_count
def filter_MAD_range(self, criteria):
"""
Filter based on median absolute deviation.
Passing values fall within a lower and upper bound.
"""
# Get the median absolute deviation
med_abs_dev = abs(self.passed[criteria] - self.passed[criteria].median()).mean()
dev_ref = med_abs_dev * self.tolerance[criteria]
lower = self.passed[criteria].median() - dev_ref
upper = self.passed[criteria].median() + dev_ref
allowed_range = (str(int(x)) for x in [lower, upper])
allowed_range = "-".join(allowed_range)
self.allowed[criteria] = allowed_range
self.failed[criteria] = self.passed[
abs(self.passed[criteria] - self.passed[criteria].median()) > dev_ref
].index
self.passed = self.passed[
abs(self.passed[criteria] - self.passed[criteria].median()) <= dev_ref
]
@check_passed_count
def filter_MAD_upper(self, criteria):
"""
Filter based on median absolute deviation.
Passing values fall under the upper bound.
"""
# Get the median absolute deviation
med_abs_dev = abs(self.passed[criteria] - self.passed[criteria].median()).mean()
dev_ref = med_abs_dev * self.tolerance[criteria]
upper = self.passed[criteria].median() + dev_ref
self.failed[criteria] = self.passed[self.passed[criteria] > upper].index
self.passed = self.passed[self.passed[criteria] <= upper]
upper = "{:.4f}".format(upper)
self.allowed[criteria] = upper
def base_node_style(self):
from ete3 import NodeStyle, AttrFace
nstyle = NodeStyle()
nstyle["shape"] = "sphere"
nstyle["size"] = 2
nstyle["fgcolor"] = "black"
for n in self.tree.traverse():
n.set_style(nstyle)
if re.match(".*fasta", n.name):
nf = AttrFace("name", fsize=8)
nf.margin_right = 150
nf.margin_left = 3
n.add_face(nf, column=0)
# Might be better in a layout function
def style_and_render_tree(self, file_types=["svg"]):
from ete3 import TreeStyle, TextFace, CircleFace
ts = TreeStyle()
title_face = TextFace(self.name.replace("_", " "), fsize=20)
title_face.margin_bottom = 10
ts.title.add_face(title_face, column=0)
ts.branch_vertical_margin = 10
ts.show_leaf_name = False
# Legend
ts.legend.add_face(TextFace(""), column=1)
for category in ["Allowed", "Tolerance", "Filtered", "Color"]:
category = TextFace(category, fsize=8, bold=True)
category.margin_bottom = 2
category.margin_right = 40
ts.legend.add_face(category, column=1)
for i, criteria in enumerate(self.criteria, 2):
title = criteria.replace("_", " ").title()
title = TextFace(title, fsize=8, bold=True)
title.margin_bottom = 2
title.margin_right = 40
cf = CircleFace(4, self.colors[criteria], style="sphere")
cf.margin_bottom = 5
filtered_count = len(
list(filter(None, self.failed_report.criteria == criteria))
)
filtered = TextFace(filtered_count, fsize=8)
filtered.margin_bottom = 5
allowed = TextFace(self.allowed[criteria], fsize=8)
allowed.margin_bottom = 5
allowed.margin_right = 25
tolerance = TextFace(self.tolerance[criteria], fsize=8)
tolerance.margin_bottom = 5
ts.legend.add_face(title, column=i)
ts.legend.add_face(allowed, column=i)
ts.legend.add_face(tolerance, column=i)
ts.legend.add_face(filtered, column=i)
ts.legend.add_face(cf, column=i)
for f in file_types:
out_tree = os.path.join(self.qc_results_dir, "tree.{}".format(f))
self.tree.render(out_tree, tree_style=ts)
def color_tree(self):
from ete3 import NodeStyle
self.base_node_style()
for failed_genome in self.failed_report.index:
n = self.tree.get_leaves_by_name(failed_genome + ".fasta").pop()
nstyle = NodeStyle()
nstyle["fgcolor"] = self.colors[
self.failed_report.loc[failed_genome, "criteria"]
]
nstyle["size"] = 9
n.set_style(nstyle)
self.style_and_render_tree()
def filter(self):
self.filter_unknown_bases()
self.filter_contigs("contigs")
self.filter_MAD_range("assembly_size")
self.filter_MAD_upper("distance")
with open(self.allowed_path, "wb") as p:
pickle.dump(self.allowed, p)
self.summary()
self.write_failed_report()
def write_failed_report(self):
from itertools import chain
if os.path.isfile(self.failed_path):
os.remove(self.failed_path)
ixs = chain.from_iterable([i for i in self.failed.values()])
self.failed_report = pd.DataFrame(index=ixs, columns=["criteria"])
for criteria in self.failed.keys():
if type(self.failed[criteria]) == pd.Index:
self.failed_report.loc[self.failed[criteria], "criteria"] = criteria
self.failed_report.to_csv(self.failed_path)
def summary(self):
summary = [
self.name,
"Unknown Bases",
"Allowed: {}".format(self.allowed["unknowns"]),
"Tolerance: {}".format(self.tolerance["unknowns"]),
"Filtered: {}".format(len(self.failed["unknowns"])),
"\n",
"Contigs",
"Allowed: {}".format(self.allowed["contigs"]),
"Tolerance: {}".format(self.tolerance["contigs"]),
"Filtered: {}".format(len(self.failed["contigs"])),
"\n",
"Assembly Size",
"Allowed: {}".format(self.allowed["assembly_size"]),
"Tolerance: {}".format(self.tolerance["assembly_size"]),
"Filtered: {}".format(len(self.failed["assembly_size"])),
"\n",
"MASH",
"Allowed: {}".format(self.allowed["distance"]),
"Tolerance: {}".format(self.tolerance["distance"]),
"Filtered: {}".format(len(self.failed["distance"])),
"\n",
]
summary = "\n".join(summary)
with open(os.path.join(self.summary_path), "w") as f:
f.write(summary)
return summary
def link_genomes(self):
if not os.path.exists(self.passed_dir):
os.mkdir(self.passed_dir)
for passed_genome in self.passed.index:
fname = "{}.fasta".format(passed_genome)
src = os.path.join(self.path, fname)
dst = os.path.join(self.passed_dir, fname)
try:
os.link(src, dst)
except FileExistsError:
continue
@assess
def qc(self):
if self.total_genomes > 10:
self.run_mash()
self.get_stats()
self.filter()
self.link_genomes()
self.get_tree()
self.color_tree()
self.log.info("QC finished")
self.report()
def report(self):
try:
assert (
self.total_genomes == self.total_sketches == len(list(self.stats_files))
)
except AssertionError:
from itertools import combinations
self.log.error("File counts do not match up.")
self.log.error(f"{self.total_genomes} total .fasta files")
self.log.error(f"{self.total_sketches} total sketch .msh files")
self.log.error(f"{len(list(self.stats_files))} total stats .csv files")
sketches = [genome.Genome.id_(i.as_posix()) for i in self.sketches]
stats = [genome.Genome.id_(i.as_posix()) for i in self.stats_files]
genome_ids = [i.accession_id for i in self.genomes]
ids = [genome_ids, sketches, stats]
for a, b in combinations(ids, 2):
diff = set(a) - set(b)
if bool(diff):
for i in diff:
self.log.error(i)
try:
assert Path(self.dmx_path).stat().st_size # Check if dmx is empty
except AssertionError:
self.log.error("Distance matrix is empty")
try:
assert Path(self.passed_dir).iterdir()
except AssertionError:
self.log.error("Passed directory is empty")
def select_metadata(self, metadata):
try:
self.metadata = metadata.joined.loc[self.biosample_ids]
self.metadata.to_csv(self.metadata_path)
except KeyError:
self.log.exception("Metadata failed")
|
# -*- coding:utf-8 -*-
from appium import webdriver
import time
# server启动参数
desired_caps = {}
# 设备参数
desired_caps['platformName'] = 'Android'
desired_caps['platformVersion'] = '5.1'
desired_caps['deviceName'] = '192.168.56.101:5555'
# app参数
desired_caps['appPackage'] = 'cn.goapk.market'
desired_caps['appActivity'] = 'com.anzhi.market.ui.MainActivity'
# 解决输入中文
desired_caps['unicodeKeyboard'] = True
desired_caps['resetKeyboard'] = True
driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)
HumanIcon = driver.find_element_by_class_name("android.widget.ImageView")
HumanIcon.click() |
from collections import Counter
from typing import List, Union, Optional, Set, Dict
import numpy as np
from docqa.dataset import Dataset, TrainingData, ListDataset, ListBatcher
from docqa.utils import ResourceLoader, flatten_iterable, max_or_none
from docqa.configurable import Configurable
from docqa.data_processing.preprocessed_corpus import DatasetBuilder, FilteredData
"""
Objects to represent question-context-answer training points / datasets
"""
class Answer(object):
""" Abstract representation of an answer to question """
def get_vocab(self):
raise NotImplemented()
class ContextAndQuestion(object):
"""
This is our standard unit of training data, context and a single question/answer.
The answer type is unspecified and depends on the application.
"""
def __init__(self, question: List[str], answer: Optional[Answer],
question_id: object, doc_id=None):
self.question = question
self.answer = answer
self.question_id = question_id
self.doc_id = doc_id
@property
def n_context_words(self) -> int:
raise NotImplementedError()
def get_context(self) -> List[str]:
raise NotImplementedError()
class SentencesAndQuestion(ContextAndQuestion):
def __init__(self, context: List[List[str]], question: List[str],
answer: Optional[Answer], question_id: object, doc_id=None):
super().__init__(question, answer, question_id, doc_id)
self.context = context
@property
def n_context_words(self):
return sum(len(s) for s in self.context)
def get_context(self):
return flatten_iterable(self.context)
class ParagraphAndQuestion(ContextAndQuestion):
def __init__(self, context: List[str], question: List[str],
answer: Optional[Answer], question_id: object, doc_id=None):
super().__init__(question, answer, question_id, doc_id)
self.context = context
@property
def n_context_words(self):
return len(self.context)
def get_context(self):
return self.context
class ContextLenKey(Configurable):
def __call__(self, q: ContextAndQuestion):
return q.n_context_words
class ContextLenBucketedKey(Configurable):
def __init__(self, bucket_size: int):
self.bucket_size = bucket_size
def __call__(self, q: SentencesAndQuestion):
return q.n_context_words//self.bucket_size
class ParagraphAndQuestionSpec(object):
""" Bound on the size of `ParagraphAndQuestion` objects """
def __init__(self, batch_size, max_question_words=None,
max_num_context_words=None, max_word_size=None, max_batch_size=None):
if batch_size is not None:
if max_batch_size is None:
max_batch_size = batch_size
elif max_batch_size != batch_size:
raise ValueError()
self.batch_size = batch_size
self.max_num_quesiton_words = max_question_words
self.max_num_context_words = max_num_context_words
self.max_word_size = max_word_size
self.max_batch_size = max_batch_size
def __add__(self, o):
return ParagraphAndQuestionSpec(
max_or_none(self.batch_size, o.batch_size),
max_or_none(self.max_num_quesiton_words, o.max_num_quesiton_words),
max_or_none(self.max_num_context_words, o.max_num_context_words),
max_or_none(self.max_word_size, o.max_word_size),
max_or_none(self.max_batch_size, o.max_batch_size)
)
class QaCorpusLazyStats(object):
"""
Metadata about a set of such questions we might need for things like
computing which words vectors to use/train
"""
def __init__(self, data: List[ContextAndQuestion]):
self.data = data
self._question_counts = None
self._context_counts = None
def get_question_counts(self):
if self._question_counts is None:
counter = Counter()
for q in self.data:
counter.update(q.question)
self._question_counts = counter
return self._question_counts
def get_context_counts(self):
if self._context_counts is None:
counter = Counter()
for q in self.data:
counter.update(q.get_context())
self._context_counts = counter
return self._context_counts
def get_word_counts(self):
return self.get_context_counts() + self.get_question_counts()
class QaCorpusStats(object):
def __init__(self, question_counts, context_counts):
self.question_counts = question_counts
self.context_counts = context_counts
def get_question_counts(self):
return self.question_counts
def get_context_counts(self):
return self.context_counts
def get_word_counts(self):
return self.get_context_counts() + self.get_question_counts()
class WordCounts(object):
def __init__(self, word_counts):
self.word_counts = word_counts
def get_word_counts(self):
return self.word_counts
def compute_voc(data: List[ContextAndQuestion]):
voc = set()
for point in data:
voc.update(point.question)
if point.answer is not None:
voc.update(point.answer.get_vocab())
voc.update(point.get_context())
return voc
class ParagraphQuestionFilter(Configurable):
def keep(self, data_point: ContextAndQuestion) -> bool:
raise NotImplemented()
class QuestionFilter(ParagraphQuestionFilter):
def __init__(self, ques_size_th: int):
self.ques_size_th = ques_size_th
def keep(self, data_point: ContextAndQuestion):
return len(data_point.question) <= self.ques_size_th
class AnswerWord(ParagraphQuestionFilter):
def __init__(self, para_size_th: int):
self.para_size_th = para_size_th
def keep(self, data_point: ContextAndQuestion):
return all(ans.para_word_end < self.para_size_th for ans in data_point.answer)
class AnySplitAnswerFilter(ParagraphQuestionFilter):
def keep(self, data_point: SentencesAndQuestion):
for answer in data_point.answer:
if answer.sent_start != answer.sent_end:
return False
return True
class AnswerSentence(ParagraphQuestionFilter):
def __init__(self, sent_size_th: Union[int, None] = None,
num_sent_th: Union[int, None]=None):
self.num_sent_th = num_sent_th
self.sent_size_th = sent_size_th
def keep(self, data_point: SentencesAndQuestion):
for answer in data_point.answer:
if self.num_sent_th is not None:
if answer.sent_end >= self.num_sent_th:
return False
if self.sent_size_th is not None:
if answer.word_start >= self.sent_size_th:
return False
return True
def apply_filters(data: List, data_filters: List[ParagraphQuestionFilter], name: str):
if len(data) == 0:
raise ValueError()
if len(data_filters) == 0:
return data
else:
pruned = []
removed = np.zeros(len(data_filters), dtype=np.int32)
for x in data:
keep = True
for i,f in enumerate(data_filters):
if not f.keep(x):
keep = False
removed[i] += 1
break
if keep:
pruned.append(x)
for i,x in enumerate(data_filters):
print("\t%s filtered %d(%.5f) from %s" % (x.__class__.__name__, removed[i], removed[i]/len(data), name))
n_removed = len(data)-len(pruned)
print("Pruned a total of %d/%d (%.3f) for %s" % (n_removed, len(data), n_removed/len(data), name))
return pruned
def build_spec(batch_size: int,
max_batch_size: int,
data: List[ContextAndQuestion]) -> ParagraphAndQuestionSpec:
max_ques_size = 0
max_word_size = 0
max_para_size = 0
for data_point in data:
context = data_point.get_context()
max_word_size = max(max_word_size, max(len(word) for word in context))
max_para_size = max(max_para_size, len(context))
if data_point.question is not None:
max_ques_size = max(max_ques_size, len(data_point.question))
max_word_size = max(max_word_size, max(len(word) for word in data_point.question))
return ParagraphAndQuestionSpec(batch_size, max_ques_size, max_para_size,
max_word_size, max_batch_size)
class ParagraphAndQuestionDataset(ListDataset):
""" Dataset with q/a pairs and that exposes some meta-data about its elements """
def get_spec(self) -> ParagraphAndQuestionSpec:
return build_spec(self.batching.get_fixed_batch_size(),
self.batching.get_max_batch_size(),
self.data)
def get_vocab(self) -> Set[str]:
return compute_voc(self.data)
class ParagraphAndQuestionsBuilder(DatasetBuilder):
""" For use with the preprocesed_corpus framework """
def __init__(self, batching: ListBatcher, sample=None, sample_seed=None):
if sample_seed is not None and sample is None:
raise ValueError("Seed set, but sampling not requested")
self.batching = batching
self.sample_seed = sample_seed
self.sample = sample
def build_stats(self, data):
if isinstance(data, FilteredData):
return QaCorpusLazyStats(data.data)
else:
return QaCorpusLazyStats(data)
def build_dataset(self, data, evidence) -> Dataset:
if isinstance(data, FilteredData):
data, l = data.data, data.true_len
else:
data, l = data, None
if self.sample is not None:
cur_len = len(data)
data = np.random.RandomState(self.sample_seed).choice(data, self.sample, replace=False)
if l is not None:
l *= len(data) / cur_len
if l is None:
l = len(data)
print("Building dataset")
print(len(data), l)
return ParagraphAndQuestionDataset(data, self.batching, l)
class ParagraphQaTrainingData(TrainingData):
""" Training data derived from a "corpus" objects loads elements and a preprocess method """
def __init__(self,
corpus,
percent_train_dev: Optional[float],
train_batcher: ListBatcher,
eval_batcher: ListBatcher,
data_filters: List[ParagraphQuestionFilter] = None):
self.percent_train_dev = percent_train_dev
self.eval_batcher = eval_batcher
self.train_batcher = train_batcher
self.corpus = corpus
self.data_filters = data_filters
self._train = None
self._dev = None
self._dev_len = None
self._train_len = None
def _preprocess(self, x):
return x, len(x)
@property
def name(self):
return self.corpus.name
def _load_data(self):
if self._train is not None:
return
print("Loading data for: " + self.corpus.name)
self._train, self._train_len = self._preprocess(self.corpus.get_train())
if self.percent_train_dev is None:
dev = self.corpus.get_dev()
if dev is not None:
self._dev, self._dev_len = self._preprocess(self.corpus.get_dev())
else:
raise NotImplemented()
if self.data_filters is not None:
self._dev = apply_filters(self._dev, self.data_filters, "dev")
self._train = apply_filters(self._train, self.data_filters, "train")
def get_train(self) -> Dataset:
self._load_data()
return ParagraphAndQuestionDataset(self._train, self.train_batcher)
def get_train_corpus(self):
self._load_data()
return QaCorpusLazyStats(self._train)
def get_eval(self) -> Dict[str, Dataset]:
self._load_data()
eval_sets = dict(train=ParagraphAndQuestionDataset(self._train, self.eval_batcher, self._train_len))
if self._dev is not None:
eval_sets["dev"] = ParagraphAndQuestionDataset(self._dev, self.eval_batcher, self._dev_len)
return eval_sets
def get_resource_loader(self) -> ResourceLoader:
return self.corpus.get_resource_loader()
def __getstate__(self):
state = self.__dict__
state["_train"] = None
state["_dev"] = None
return state
def __setstate__(self, state):
self.__dict__ = state
|
# Last version 03102019, mod: limite to while iteration
def DP_simp(r,AA0,nstd,sm = 5):
import pandas as pd
import numpy as np
from running_mean import running_mean
AA=running_mean(AA0,sm)#[sm-1:]
rr=r[(sm-1)/2:-(sm-1)/2]#pd.rolling_mean(r,sm)[sm-1:]
Er = AA - AA0[(sm-1)/2:-(sm-1)/2]#[sm-1:]
n = np.arange(0,np.size(AA))
flag = np.zeros(shape = np.size(AA))
flag[0] = 1
flag[-1] = 1
flag2 = np.zeros(shape = np.size(AA))
flag2[0] = 1
flag2[-1] = 1
end = False
nlevels = 0
while end == False:
nlevels = nlevels + 1
if nlevels > np.size(r)*2: end = True
pix = np.squeeze(np.where(flag2 == 1))
p1 = AA[pix[0]]
p2 = AA[pix[1]]
n1 = n[pix[0]]
n2 = n[pix[1]]
L = ((p2-p1)/(n2-n1))*(n-n1)+p1
d = abs(AA-L)
d[0:n1+1] = 0
d[n2:] = 0
d[np.where(AA < 0)] = 0
eps_mean = np.nanmean(Er[n1:n2+1])
eps_std = nstd*np.nanstd(Er[n1:n2+1])
eps = eps_mean + eps_std
if ((np.size(d)>1) & (np.max(d) > 0)):
nm = np.where(d == np.max(d))
dm = d[nm]
if dm > eps:
#print dm, eps, eps_mean,eps_std , nm
flag[nm] = 1
flag2[nm] = 1
else:
#print "menor que el umbral"
for i in range(n1,n2):
flag2[i] = 1
for i in range(np.size(flag)-1):
if ((flag2[i] == 1) & (flag2[i+1]== 1)):
flag2[i] = 2
#print "1"
else:
for i in range(np.size(flag)-1):
if ((flag2[i] == 1) & (flag2[i+1]== 1)):
flag2[i] = 2
#print "terminado"
if flag2[-2] == 2: end = True
return [rr[np.squeeze(np.where(flag == 1))], AA[np.squeeze(np.where(flag == 1))],rr,AA]
#print nm,dm,eps,np.squeeze(np.where(flag2 == 1))
#pylab.plot(n,AA)
#pylab.scatter(n[np.squeeze(np.where(flag == 1))],AA[np.squeeze(np.where(flag == 1))])
#print flag2 |
#!/usr/bin/python2
from scapy.all import *
#dest = input("Destination: ")
#dest = raw_input("\nDestination: ")
#destport = input("Destination port: ") #Porta de destino
dest = '10.0.0.99'
destport = '1234'
ip = IP(dst=dest)
udp = UDP(dport=int(destport),sport=40000)
raw = Raw(b'Quero um video 720p')
pkt = ip/udp/raw
t = sr(pkt)
#sr(pkt)
print(t)
|
"""
Unit-tests for orderby module public interface, in the way
it is supposed to be used in sorted() and others
"""
from orderby import asc, desc, orderby
from unittest import TestCase
TEST_DATA_PERSONS = (
{'id': 0, 'lastname': 'Smith', 'firstname': 'John', 'age': 42, 'score': 50},
{'id': 1, 'lastname': 'Smith', 'firstname': 'Jane', 'age': 37, 'score': 100},
{'id': 2, 'lastname': 'A', 'firstname': 'B', 'age': 20, 'score': 50},
{'id': 3, 'lastname': 'A', 'firstname': 'A', 'age': 20, 'score': 50},
)
def get_ids(items):
""" id fields from sorted list-of-dicts """
return tuple(x['id'] for x in items)
class TestOrderByAPI(TestCase):
def test_asc_desc_chain(self):
result = sorted(TEST_DATA_PERSONS, key=desc('age').asc('lastname', 'firstname').desc('score'))
self.assertEqual(get_ids(result), (0, 1, 3, 2))
def test_asc_inits_the_chain(self):
keyf = asc('foo')
self.assertTrue(callable(keyf.asc))
self.assertTrue(callable(keyf.desc))
def test_desc_inits_the_chain(self):
keyf = desc('bar')
self.assertTrue(callable(keyf.asc))
self.assertTrue(callable(keyf.desc))
def test_desc_same_as_reverse(self):
rdesc = sorted(TEST_DATA_PERSONS, key=desc('lastname'))
rrev = sorted(TEST_DATA_PERSONS, key=asc('lastname'), reverse=True)
self.assertEqual(rdesc, rrev)
def test_orderby_qstrings(self):
expected = (
# order by string -> expected id order
('lastname, firstname, score', (3, 2, 1, 0)),
('score DESC, age DESC, lastname, firstname', (1, 0, 3, 2)),
('id DESC', (3, 2, 1, 0)),
)
for qstring, result in expected:
ordered = sorted(TEST_DATA_PERSONS, key=orderby(qstring))
self.assertEqual(get_ids(ordered), result)
def test_inplace_sorting(self):
copied = list(TEST_DATA_PERSONS)
self.assertEqual(get_ids(copied), (0, 1, 2, 3))
copied.sort(key=orderby('score DESC, lastname, firstname, age, id'))
self.assertEqual(get_ids(copied), (1, 3, 2, 0))
|
# coding: utf-8
# <h1>Table of Contents<span class="tocSkip"></span></h1>
# <div class="toc"><ul class="toc-item"><li><span><a href="#Introduction" data-toc-modified-id="Introduction-1"><span class="toc-item-num">1 </span>Introduction</a></span></li><li><span><a href="#Get-the-vancouver-image" data-toc-modified-id="Get-the-vancouver-image-2"><span class="toc-item-num">2 </span>Get the vancouver image</a></span></li><li><span><a href="#Read-in-the-bands--4-(red)-and-5-(near-infrared)" data-toc-modified-id="Read-in-the-bands--4-(red)-and-5-(near-infrared)-3"><span class="toc-item-num">3 </span>Read in the bands 4 (red) and 5 (near infrared)</a></span></li><li><span><a href="#Find-the-toa-reflectance-for-each-channel" data-toc-modified-id="Find-the-toa-reflectance-for-each-channel-4"><span class="toc-item-num">4 </span>Find the toa reflectance for each channel</a></span></li><li><span><a href="#Silence-annoying-warnings-from-numpy" data-toc-modified-id="Silence-annoying-warnings-from-numpy-5"><span class="toc-item-num">5 </span>Silence annoying warnings from numpy</a></span></li><li><span><a href="#NIR-is-much-more-reflective-than-red" data-toc-modified-id="NIR-is-much-more-reflective-than-red-6"><span class="toc-item-num">6 </span>NIR is much more reflective than red</a></span></li><li><span><a href="#Calculate-the-ndvi" data-toc-modified-id="Calculate-the-ndvi-7"><span class="toc-item-num">7 </span>Calculate the ndvi</a></span></li><li><span><a href="#Does-the-reflectance-step-matter?" data-toc-modified-id="Does-the-reflectance-step-matter?-8"><span class="toc-item-num">8 </span>Does the reflectance step matter?</a></span></li></ul></div>
# # Introduction
#
# This notebook reads in the red, and near-ir bands from a landsat 8 image
# and calculates the [ndvi](https://en.wikipedia.org/wiki/Normalized_difference_vegetation_index), defined as
#
# $$ndvi = (nir - red)/(nir + red)$$
#
# where nir and red are the
# respective spectral directional reflectances.
# In[13]:
from pathlib import Path
from a301.utils.data_read import download
import numpy as np
import pprint
from matplotlib import pyplot as plt
# # Get the vancouver image
# In[2]:
import rasterio
import a301
filenames=["LC08_L1TP_047026_20150614_20180131_01_T1_B4.TIF",
"LC08_L1TP_047026_20150614_20180131_01_T1_B5.TIF",
"LC08_L1TP_047026_20150614_20180131_01_T1_MTL.txt"]
dest_folder=a301.data_dir / Path("landsat8/vancouver")
# In[7]:
for the_file in filenames:
landsat_tif = Path('landsat_scenes/l8_vancouver') / Path(the_file)
download(str(landsat_tif),dest_folder=dest_folder)
band2=list(dest_folder.glob("*_B2.TIF"))[0]
band3=list(dest_folder.glob("*_B3.TIF"))[0]
band4=list(dest_folder.glob("*_B4.TIF"))[0]
band5=list(dest_folder.glob("*_B5.TIF"))[0]
mtl_file=list(dest_folder.glob("*MTL.txt"))[0]
# # Read in the bands 4 (red) and 5 (near infrared)
#
# Note that rasterio is a pretty complicated object with a lot of functionality.
#
# The full documentation is at https://rasterio.readthedocs.io/en/latest/
#
# Save the image profile, coordinate reference system (crs) and affine transform for inspection -- these will be the same for every band in the image
# In[5]:
with rasterio.open(band4) as b4_raster:
b4_data = b4_raster.read(1)
transform=b4_raster.transform
crs=b4_raster.crs
profile=b4_raster.profile
with rasterio.open(band5) as b5_raster:
b5_data = b5_raster.read(1)
# # Find the toa reflectance for each channel
#
# Use [toa_reflectance_8](https://github.com/phaustin/a301_code/blob/c2070ca26090dc4a7e612c1e9c4ed2d9e865ae5e/a301/landsat/toa_reflectance.py#L19) to turn band counts into reflectance.
# In[9]:
from a301.landsat.toa_reflectance import toa_reflectance_8
out=toa_reflectance_8([4,5],mtl_file)
# # Silence annoying warnings from numpy
# In[ ]:
np.seterr(divide='ignore',invalid='ignore')
# # NIR is much more reflective than red
# In[28]:
hit= (out[5] < 1.2) & (out[5] > 0)
plt.hist(out[5][hit].flat)
plt.title('band 5 reflectance');
# In[29]:
hit= (out[4] < 1.2) & (out[4] > 0)
plt.hist(out[4][hit].flat)
plt.title('band 4 reflectance');
# # Calculate the ndvi
# In[30]:
ndvi = (out[5] - out[4])/(out[5] + out[4])
# In[32]:
hit= (ndvi < 1.) & (ndvi > -1)
plt.hist(ndvi[hit].flat)
plt.title('ndvi');
# # Does the reflectance step matter?
#
# Check to see if you histograms look different when you do the ndvi with raw counts
# instead of reflectance.
|
from QtModularUiPack.Framework.Math.Spectrogram import spectrogram
|
from regression_tests import *
class Test001(Test):
settings=TestSettings(
tool='fileinfo',
args='--verbose --json',
input='dropped.ex'
)
def test_delayed_imports_detection(self):
assert self.fileinfo.succeeded
self.assertEqual(self.fileinfo.output['importTable']['numberOfImports'], '80')
self.assertEqual(self.fileinfo.output['importTable']['md5'], '6f94503e98785a3637bc2177cce10427')
self.assertEqual(self.fileinfo.output['importTable']['imports'][69]['index'], '69')
self.assertEqual(self.fileinfo.output['importTable']['imports'][72]['index'], '72')
self.assertEqual(self.fileinfo.output['importTable']['imports'][73]['index'], '73')
self.assertEqual(self.fileinfo.output['importTable']['imports'][74]['index'], '74')
self.assertEqual(self.fileinfo.output['importTable']['imports'][75]['index'], '75')
self.assertEqual(self.fileinfo.output['importTable']['imports'][76]['index'], '76')
self.assertEqual(self.fileinfo.output['importTable']['imports'][77]['index'], '77')
self.assertEqual(self.fileinfo.output['importTable']['imports'][78]['index'], '78')
self.assertEqual(self.fileinfo.output['importTable']['imports'][79]['index'], '79')
assert 'name' not in self.fileinfo.output['importTable']['imports'][69]
self.assertEqual(self.fileinfo.output['importTable']['imports'][72]['name'], 'GetInputState')
self.assertEqual(self.fileinfo.output['importTable']['imports'][73]['name'], 'wsprintfA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][74]['name'], 'PostThreadMessageA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][75]['name'], 'GetMessageA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][76]['name'], 'GetDesktopWindow')
self.assertEqual(self.fileinfo.output['importTable']['imports'][77]['name'], 'RegOpenKeyExA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][78]['name'], 'RegCloseKey')
self.assertEqual(self.fileinfo.output['importTable']['imports'][79]['name'], 'RegQueryValueExA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][69]['libraryName'], 'WS2_32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][72]['libraryName'], 'USER32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][73]['libraryName'], 'USER32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][74]['libraryName'], 'USER32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][75]['libraryName'], 'USER32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][76]['libraryName'], 'USER32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][77]['libraryName'], 'ADVAPI32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][78]['libraryName'], 'ADVAPI32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][79]['libraryName'], 'ADVAPI32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][69]['address'], '0x40911c')
self.assertEqual(self.fileinfo.output['importTable']['imports'][72]['address'], '0x4020ae')
self.assertEqual(self.fileinfo.output['importTable']['imports'][73]['address'], '0x402078')
self.assertEqual(self.fileinfo.output['importTable']['imports'][74]['address'], '0x40209c')
self.assertEqual(self.fileinfo.output['importTable']['imports'][75]['address'], '0x40208a')
self.assertEqual(self.fileinfo.output['importTable']['imports'][76]['address'], '0x402058')
self.assertEqual(self.fileinfo.output['importTable']['imports'][77]['address'], '0x4020f2')
self.assertEqual(self.fileinfo.output['importTable']['imports'][78]['address'], '0x4020c0')
self.assertEqual(self.fileinfo.output['importTable']['imports'][79]['address'], '0x4020e0')
self.assertEqual(self.fileinfo.output['importTable']['imports'][69]['ordinalNumber'], '20')
self.assertEqual(self.fileinfo.output['importTable']['imports'][69]['delayed'], 'false')
self.assertEqual(self.fileinfo.output['importTable']['imports'][72]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][73]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][74]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][75]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][76]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][77]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][78]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][79]['delayed'], 'true')
class Test002(Test):
settings=TestSettings(
tool='fileinfo',
args='--verbose --json',
input='delay_loaded_dlls_by_va_32bit.ex_'
)
def test_delayled_imports_detection(self):
assert self.fileinfo.succeeded
self.assertEqual(self.fileinfo.output['importTable']['numberOfImports'], '31')
self.assertEqual(self.fileinfo.output['importTable']['md5'], 'c64d18c2324195b6f30e544ac4d0793a')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['index'], '0')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['libraryName'], 'KERNEL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['address'], '0x400a00')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['name'], 'GetModuleHandleA')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['ordinalNumber'], '294')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['delayed'], 'false')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['index'], '25')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['address'], '0x400708')
assert 'name' not in self.fileinfo.output['importTable']['imports'][25]
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['ordinalNumber'], '17')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['index'], '26')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['address'], '0x4006e8')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['name'], 'InitCommonControlsEx')
assert 'ordinalNumber' not in self.fileinfo.output['importTable']['imports'][26]
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['index'], '27')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['libraryName'], 'WS2_32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['address'], '0x40075e')
assert 'name' not in self.fileinfo.output['importTable']['imports'][27]
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['ordinalNumber'], '115')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['delayed'], 'true')
class Test003(Test):
settings=TestSettings(
tool='fileinfo',
args='--verbose --json',
input='delay_loaded_dlls_rva_32bit.ex_'
)
def test_delayed_imports_detection(self):
assert self.fileinfo.succeeded
self.assertEqual(self.fileinfo.output['importTable']['numberOfImports'], '31')
self.assertEqual(self.fileinfo.output['importTable']['md5'], '7877a03959578abdcfd18f857518208c')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['index'], '0')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['libraryName'], 'KERNEL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['address'], '0x400c00')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['name'], 'WaitForSingleObject')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['ordinalNumber'], '1124')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['delayed'], 'false')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['index'], '25')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['address'], '0x4006ec')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['name'], 'InitCommonControlsEx')
assert 'ordinalNumber' not in self.fileinfo.output['importTable']['imports'][25]
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['index'], '26')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['address'], '0x4006d1')
assert 'name' not in self.fileinfo.output['importTable']['imports'][26]
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['ordinalNumber'], '17')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['index'], '27')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['libraryName'], 'WS2_32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['address'], '0x400727')
assert 'name' not in self.fileinfo.output['importTable']['imports'][27]
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['ordinalNumber'], '115')
self.assertEqual(self.fileinfo.output['importTable']['imports'][27]['delayed'], 'true')
class Test004(Test):
settings=TestSettings(
tool='fileinfo',
args='--verbose --json',
input='delay_loaded_dlls_rva_64bit.ex_'
)
def test_delayed_imports_detection(self):
assert self.fileinfo.succeeded
self.assertEqual(self.fileinfo.output['importTable']['numberOfImports'], '30')
self.assertEqual(self.fileinfo.output['importTable']['md5'], '68592d0426806874d10b4c28d9c5cd40')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['index'], '0')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['libraryName'], 'KERNEL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['address'], '0x140001000')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['name'], 'WaitForSingleObject')
self.assertEqual(self.fileinfo.output['importTable']['imports'][0]['ordinalNumber'], '1128')
self.assertEqual(self.fileinfo.output['importTable']['imports'][24]['index'], '24')
self.assertEqual(self.fileinfo.output['importTable']['imports'][24]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][24]['address'], '0x1400009b7')
self.assertEqual(self.fileinfo.output['importTable']['imports'][24]['name'], 'InitCommonControlsEx')
assert 'ordinalNumber' not in self.fileinfo.output['importTable']['imports'][24]
self.assertEqual(self.fileinfo.output['importTable']['imports'][24]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['index'], '25')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['libraryName'], 'COMCTL32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['address'], '0x140000932')
assert 'name' not in self.fileinfo.output['importTable']['imports'][25]
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['ordinalNumber'], '17')
self.assertEqual(self.fileinfo.output['importTable']['imports'][25]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['index'], '26')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['libraryName'], 'WS2_32.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['address'], '0x140000a60')
assert 'name' not in self.fileinfo.output['importTable']['imports'][26]
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['ordinalNumber'], '115')
self.assertEqual(self.fileinfo.output['importTable']['imports'][26]['delayed'], 'true')
class Test005(Test):
settings=TestSettings(
tool='fileinfo',
args='--verbose --json',
input='delayimports.ex'
)
def test_delayed_imports_detection(self):
assert self.fileinfo.succeeded
self.assertEqual(self.fileinfo.output['importTable']['numberOfImports'], '4')
self.assertEqual(self.fileinfo.output['importTable']['imports'][3]['address'], '0x401150')
self.assertEqual(self.fileinfo.output['importTable']['imports'][3]['index'], '3')
self.assertEqual(self.fileinfo.output['importTable']['imports'][3]['libraryName'], 'msvcrt.dll')
self.assertEqual(self.fileinfo.output['importTable']['imports'][3]['name'], 'printf')
self.assertEqual(self.fileinfo.output['importTable']['imports'][3]['delayed'], 'true')
self.assertEqual(self.fileinfo.output['importTable']['md5'], '4e7b7b5b63ae609e9707b4896498325d')
|
from beaker.middleware import SessionMiddleware
from bottle import Bottle
from jumpscale.loader import j
from jumpscale.packages.auth.bottle.auth import SESSION_OPTS, admin_only, login_required
from jumpscale.packages.polls.chats.threefold import VOTES
from jumpscale.sals.chatflows.polls import all_users
app = Bottle()
def _map_vote_results(user_votes, votes_questions):
votes_data = {}
for question_name, answers in user_votes.items():
for question in votes_questions.values():
if question["title"] == question_name:
answer = answers.index(1)
votes_data[question_name] = question["options"][answer]
return votes_data
@app.route("/api/results")
@login_required
@admin_only
def results():
votes_data = {}
for voter_name in all_users.list_all():
voter = all_users.get(voter_name)
votes_data[j.data.text.removeprefix(voter_name, "threefold_")] = _map_vote_results(voter.vote_data, VOTES)
votes_data["-Number of voters"] = all_users.count
return votes_data
@app.route("/api/names")
@login_required
@admin_only
def names():
data = {"names": []}
for voter_name in all_users.list_all():
voter = all_users.get(voter_name)
tname = j.data.text.removeprefix(voter_name, "threefold_")
data["names"].append(voter.extra_data.get("full_name", tname))
data["-Number of voters"] = all_users.count
return data
app = SessionMiddleware(app, SESSION_OPTS)
|
import os
import json
import urllib
import urllib.request
from typing import Dict, Any
SLACK_URL = "https://slack.com/api/chat.postMessage"
def create_wayback_machine_response(event: Dict[str, Any]) -> str:
""" """
elements = event['blocks'] \
.pop()['elements'] \
.pop()['elements']
links = list(filter(lambda el: el['type'] == "link", elements))
if not links:
return "Please include a link when you mention me."
results = set()
for link in links:
url = f"http://archive.org/wayback/available?url={link['url']}"
with urllib.request.urlopen(url) as request:
response = json.loads(request.read().decode('utf-8'))
print(response)
snapshot = response.get('archived_snapshots')
if not snapshot:
continue
results.add(snapshot['closest']['url'])
if not results:
return "Sorry, I couldn't find any results for that. If your linked webpage(s) are new, we may not have picked them up in our latest crawl."
return "Here's what I found: \n" + '\n'.join(results)
def respond_to_mention(event):
channel_id = event.get("channel")
data = urllib.parse.urlencode((
("token", os.environ["SLACK_BOT_TOKEN"]),
("channel", channel_id),
("text", create_wayback_machine_response(event))
)).encode('ascii')
request = urllib.request.Request(SLACK_URL, data=data, method="POST")
request.add_header( "Content-Type", "application/x-www-form-urlencoded" )
# Fire off the request!
urllib.request.urlopen(request).read()
def lambda_handler(event, context):
print(f"Received event:\n{event}\nWith context:\n{context}")
respond_to_mention(json.loads(event['body'])['event'])
return "200 OK"
|
# 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.
# coding: utf-8
# pylint: disable=unused-argument
"""
Symbol of SqueezeNet
Reference:
Iandola, Forrest N., et al.
"Squeezenet: Alexnet-level accuracy with 50x fewer parameters and< 0.5 mb model size." (2016).
"""
from tvm import relay
from .init import create_workload
from . import layers
# Helpers
def _make_fire(net, squeeze_channels, expand1x1_channels, expand3x3_channels, prefix):
net = _make_fire_conv(net, squeeze_channels, 1, 0, "%s_input" % prefix)
left = _make_fire_conv(net, expand1x1_channels, 1, 0, "%s_left" % prefix)
right = _make_fire_conv(net, expand3x3_channels, 3, 1, "%s_right" % prefix)
# NOTE : Assume NCHW layout here
net = relay.concatenate((left, right), axis=1)
return net
def _make_fire_conv(net, channels, kernel_size, padding=0, prefix=""):
net = layers.conv2d(net,
channels=channels,
kernel_size=(kernel_size, kernel_size),
padding=(padding, padding), name="%s_conv" % prefix)
net = relay.nn.bias_add(net, relay.var("%s_conv_bias" % prefix))
net = relay.nn.relu(net)
return net
# Net
def get_net(batch_size, image_shape, num_classes, version, dtype):
"""Get symbol of SqueezeNet
Parameters
----------
batch_size : int
The batch size used in the model
image_shape : tuple, optional
The input image shape
num_classes: int
The number of classification results
version : str, optional
"1.0" or "1.1" of SqueezeNet
"""
assert version in ['1.0', '1.1'], ("Unsupported SqueezeNet version {version}:"
"1.0 or 1.1 expected".format(version=version))
data_shape = (batch_size,) + image_shape
net = relay.var("data", shape=data_shape, dtype=dtype)
if version == '1.0':
net = layers.conv2d(net,
channels=96,
kernel_size=(7, 7),
strides=(2, 2),
padding=(3, 3),
name="conv1")
net = relay.nn.bias_add(net, relay.var("conv1_bias"))
net = relay.nn.relu(net)
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 16, 64, 64, "fire1")
net = _make_fire(net, 16, 64, 64, "fire2")
net = _make_fire(net, 32, 128, 128, "fire3")
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 32, 128, 128, "fire4")
net = _make_fire(net, 48, 192, 192, "fire5")
net = _make_fire(net, 48, 192, 192, "fire6")
net = _make_fire(net, 64, 256, 256, "fire7")
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 64, 256, 256, "fire8")
else:
net = layers.conv2d(net,
channels=64,
kernel_size=(3, 3),
strides=(2, 2),
padding=(1, 1),
name="conv1")
net = relay.nn.bias_add(net, relay.var("conv1_bias"))
net = relay.nn.relu(net)
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 16, 64, 64, "fire1")
net = _make_fire(net, 16, 64, 64, "fire2")
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 32, 128, 128, "fire3")
net = _make_fire(net, 32, 128, 128, "fire4")
net = relay.nn.max_pool2d(net, pool_size=(3, 3), strides=(2, 2))
net = _make_fire(net, 48, 192, 192, "fire5")
net = _make_fire(net, 48, 192, 192, "fire6")
net = _make_fire(net, 64, 256, 256, "fire7")
net = _make_fire(net, 64, 256, 256, "fire8")
net = relay.nn.dropout(net, rate=0.5)
net = layers.conv2d(
net, channels=num_classes, kernel_size=(1, 1), name="conv_final")
net = relay.nn.bias_add(net, relay.var("conv_final_bias"))
net = relay.nn.relu(net)
net = relay.nn.global_avg_pool2d(net)
net = relay.nn.batch_flatten(net)
net = relay.nn.softmax(net)
args = relay.ir_pass.free_vars(net)
return relay.Function(args, net)
def get_workload(batch_size=1,
num_classes=1000,
version='1.0',
image_shape=(3, 224, 224),
dtype="float32"):
"""Get benchmark workload for SqueezeNet
Parameters
----------
batch_size : int
The batch size used in the model
num_classes : int, optional
Number of classes
version : str, optional
"1.0" or "1.1" of SqueezeNet
image_shape : tuple, optional
The input image shape
dtype : str, optional
The data type
Returns
-------
net : nnvm.Symbol
The computational graph
params : dict of str to NDArray
The parameters.
"""
net = get_net(batch_size, image_shape, num_classes, version, dtype)
return create_workload(net)
|
import unittest
from mock import MagicMock
import fdm.analysis.analyzer
from fdm import Mesh
from fdm.analysis.analyzer import (Output, create_variables, OrderedNodes)
from fdm.geometry import Point
def create_mesh(node_number, virtual_nodes=(), delta=2.):
length = delta*node_number
return Mesh(
[Point(i*length/(node_number - 1)) for i in range(node_number)],
virtual_nodes,
)
class CreateVariablesTest(unittest.TestCase):
def test_Call_OnlyRealNodes_ReturnNodeToVariableNumberMapper(self):
real_nodes = n1, n2 = Point(1.), Point(2.)
nodes = self._create_ordered_nodes(real_nodes)
result = self._create(nodes)
expected = {n1: 0, n2: 1}
self.assertEqual(expected, result)
def test_Call_RealAndVirtualNodes_ReturnNodeToVariableNumberMapper(self):
real_nodes = n1, n2 = Point(1.), Point(2.)
virtual_nodes = v1, v2 = Point(-1.), Point(3.)
nodes = self._create_ordered_nodes(real_nodes, virtual_nodes)
result = self._create(nodes)
expected = {n1: 0, n2: 1, v1: 2, v2: 3}
self.assertEqual(expected, result)
def _create_ordered_nodes(self, real_nodes, virtual_nodes=()):
return real_nodes + virtual_nodes
@staticmethod
def _create(nodes):
return fdm.analysis.analyzer.create_variables(nodes)
class ExtendVariablesTest(unittest.TestCase):
def test_Call_NoExtensionPoints_ReturnTheSame(self):
variables = self._create_variables(Point(1.), Point(2.))
nodes = ()
result = self._extend(variables, nodes)
expected = variables
self.assertEqual(expected, result)
def test_Call_OneNode_ReturnExtendedVariables(self):
variables = self._create_variables(Point(1.), Point(2.))
nodes = [Point(1.5)]
result = self._extend(variables, nodes)
expected = self._create_variables(Point(1.), Point(2.), Point(1.5))
self.assertEqual(expected, result)
@staticmethod
def _create_variables(*nodes):
return create_variables(nodes)
@staticmethod
def _extend(variables, nodes):
return fdm.analysis.analyzer.extend_variables(variables, nodes)
class OutputTest(unittest.TestCase):
def test_GetItem_IndexInMesh_ReturnValueInRealNode(self):
value = 2
o = Output([1, value, 3], 2, {})
result = o[1]
expected = value
self.assertEquals(expected, result)
def test_GetItem_NegativeIndex_ReturnValueInVirtualNode(self):
value = 3.
virtual_node_address = -1
address_forwarder = {virtual_node_address: 2}
o = Output([1, 2, value, 4], 2, address_forwarder)
result = o[virtual_node_address]
expected = value
self.assertEquals(expected, result)
def test_GetItem_PositiveIndex_ReturnValueInVirtualNode(self):
value = 2
virtual_node_address = 3
address_forwarder = {virtual_node_address: 2}
o = Output([1, 2, value], 2, address_forwarder)
result = o[virtual_node_address]
expected = value
self.assertEquals(expected, result)
class OrderedNodesTest(unittest.TestCase):
def test_IndicesForReal_Always_ReturnRealNodesIndices(self):
rn = [Point(1.)]
vn = [Point(-1.)]
mesh = MagicMock(
real_nodes=rn,
virtual_nodes=vn,
)
o = OrderedNodes(mesh)
result = o.indices_for_real
expected = [0]
self.assertEquals(expected, result) |
import re
from oelint_parser.cls_item import Variable
from oelint_adv.cls_rule import Rule
from oelint_parser.helper_files import get_valid_package_names, get_valid_named_resources, expand_term
from oelint_parser.constants import CONSTANTS
class VarPnBpnUsage(Rule):
def __init__(self):
super().__init__(id="oelint.vars.specific",
severity="error",
message="'{}' is set specific to ['{}'], but isn't known from PACKAGES, MACHINE or resources",
onappend=False)
def check(self, _file, stash):
res = []
items = stash.GetItemsFor(filename=_file, classifier=Variable.CLASSIFIER,
attribute=Variable.ATTR_VAR)
_comp = stash.GetItemsFor(filename=_file, classifier=Variable.CLASSIFIER,
attribute=Variable.ATTR_VAR,
attributeValue="COMPATIBLE_MACHINE")
_comp = "".join(x.VarValueStripped for x in _comp)
_packages = get_valid_package_names(stash, _file)
_named_res = get_valid_named_resources(stash, _file)
for i in items:
_machine = []
if i.GetMachineEntry():
_machine = [i.GetMachineEntry(), expand_term(stash, _file, i.GetMachineEntry())]
if not _machine:
continue
if any(x in _packages for x in _machine):
continue
if any(x in _named_res for x in _machine):
continue
if any(x in CONSTANTS.MachinesKnown for x in _machine):
continue
if _comp:
if any(re.match(_comp, x) for x in _machine):
continue
res += self.finding(i.Origin, i.InFileLine,
override_msg=self.Msg.format(i.VarName, _machine[0]))
return res
|
import sys
import time
import os
import re
import datetime
from enum import IntEnum
from os.path import expanduser
from bs4 import BeautifulSoup, SoupStrainer
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
# from selenium.webdriver.firefox.options import Options
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
class gridCols(IntEnum):
SECTION = 0
TYPE = 1
CLSNUM = 2
INST = 3
OPEN_S = 4
RES_S = 5
SEAT_T = 6
WAITING = 7
STATUS = 8
DAYS = 9
START = 10
END = 11
BUILDING = 12
ROOM = 13
def get_class_or_empty_list(obj):
val = obj.get("class")
return val if val else []
def get_info(input_html=None):
## AS OF 5/18/18
SUMMER = 2186
FALL = 2188
##
if input_html is not None:
class_blocks = parse_pass(input_html)
result = {"quarter": "F18", "classes": class_blocks}
return result
class_blocks = []
capab = DesiredCapabilities.CHROME
capab['chromeOptions'] = {'args': ['--headless']}
driver = webdriver.Remote(command_executor="http://localhost:9515", desired_capabilities=capab)
driver.get("https://pass.calpoly.edu")
driver.execute_script(f"window.location.href='/?selectedTerm={FALL}'")
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "dismissNew"))
)
element.click()
q_title = driver.find_element_by_class_name("pageTitleQuarter").text
q_title = q_title[0] + q_title[len(q_title)-2:]
dept_selector = driver.find_element_by_xpath("//select[@data-filter='dept']")
num_courses = 0
for option in dept_selector.find_elements_by_tag_name('option'):
dept, ln = option.text.split("-")[:2]
option.click()
click_courses(driver, dept)
# Go to next page
driver.find_element_by_id("nextBtn").click()
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.CLASS_NAME, "select-course"))
)
now = datetime.datetime.now()
timestamp = now.strftime("%Y%m%d-%H%M")
html = driver.page_source
with open(expanduser(f"~/pass_html/pass-{timestamp}.html"), "w") as passfile:
passfile.write(html)
driver.close()
class_blocks = parse_pass(html)
result = {"quarter": q_title, "classes": class_blocks}
return result
def click_courses(driver, d):
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.CLASS_NAME, "selectCol"))
)
# This is to wait for the table to fully load (the wait driver doesn't
# always work if it was clicked before
time.sleep(1)
course_list = driver.find_element_by_class_name("course-list")
for btn in course_list.find_elements_by_class_name("btn"):
WebDriverWait(driver, 10).until(EC.visibility_of(btn))
btn.click()
time.sleep(1)
def parse_pass(html):
strainer = SoupStrainer("div", class_="select-course")
classes = []
soup = BeautifulSoup(html, 'html.parser', parse_only=strainer)
for class_block in soup.children:
sections = []
class_name = class_block.h3.text
name = class_name.split("-")[0]
name = name.rstrip().lstrip()
clsname = re.sub(' +',' ', name)
for row in class_block("tr"):
if "key-cancel" in get_class_or_empty_list(row):
continue
# First need to see if this is a notes row or a data row
start_elem = row.find("td", class_="sectionNumber")
if start_elem == None:
continue
cols = list(row("td"))
i = cols.index(start_elem)
# For some reason a section has a * in it, remove anything that's not a number
section_num = int(re.sub("[^0-9]", "", cols[i].text))
status = cols[i+gridCols.STATUS].text.lstrip().rstrip()
sections.append({
"section": section_num,
"type": cols[i+gridCols.TYPE].text,
"class_number": int(cols[i+gridCols.CLSNUM].text),
"instructor": cols[i+gridCols.INST].text,
"open_seats": int(cols[i+gridCols.OPEN_S].text),
"reserved_seats": int(cols[i+gridCols.RES_S].text),
"taken": int(cols[i+gridCols.SEAT_T].text),
"waiting": int(cols[i+gridCols.WAITING].text),
"status": status,
"days": cols[i+gridCols.DAYS].text,
"start_time": cols[i+gridCols.START].text,
"end_time": cols[i+gridCols.END].text,
"building": cols[i+gridCols.BUILDING].text,
"room": cols[i+gridCols.ROOM].span.text,
})
# Add a 0.01 to fix division by 0 error, if the denominator is 0 the numerator is certainly 0 as well
sections = sorted(sections, key=lambda k: (k["taken"]+k["waiting"])/(k["open_seats"]+k["reserved_seats"]+k["waiting"]+k["taken"]+0.01))
result = {"title": clsname, "sections": sections}
classes.append(result)
return classes
|
from rest_framework import serializers
from app.models import CountTrue
class UserSerializer(serializers.Serializer):
"""
A serializer class for serializing the SlackUsers
"""
id = serializers.IntegerField()
firstname = serializers.CharField()
lastname = serializers.CharField()
photo = serializers.CharField()
is_tapped = serializers.BooleanField()
class SecureUserSerializer(UserSerializer):
"""
A serializer class for serializing SlackUsers that exposes the SlackID.
This is used only under authorized access.
"""
slack_id = serializers.CharField()
class ReportSerializer(serializers.Serializer):
@classmethod
def count(cls, queryset):
"""
This method counts the number of breakfast and lunch served.
It writes the results to a list having the below structure.
[
{breakfast:XX, lunch:XX, date:"YYYY-MM-DD"},
..
]
"""
result_group = queryset.values('date')
annotate_report = result_group.annotate(
breakfast=CountTrue('breakfast'),
lunch=CountTrue('lunch')
)
def serialize(queryset):
return [
{"breakfast": res["breakfast"], "lunch": res["lunch"],
"date": res["date"]} for res in queryset
]
return serialize(annotate_report)
# lunch = queryset.filter(lunch=1).values('date').count()
|
from os import walk, path
from glob import glob
README = '''
Recursively searching for *.js files inside 'src' folder and
checking if the file is flowed ('// @flow' is on the first line)
'''
DELIM, PATH = '---------------------------------------------------------------', 'src'
print(README)
print(DELIM)
files = [y for x in walk(PATH) for y in glob(path.join(x[0], '*.js'))]
for filename in files:
with open(filename) as file:
first_line = file.readline().strip()
if first_line != '// @flow':
print('Unflowed file: \t"%s"' % filename)
print(DELIM)
|
if False:
from lib.Processing3 import *
"""
長方形の分割によるユークリッド互除法の可視化（正方形の再帰的な分割）
"""
add_library("controlP5")
SIZE_X = 500
SIZE_Y = 500
num_a = 10
num_b = 6
ratio = 1.0 * num_b / num_a
threshold = 40
def setup():
size(SIZE_X, SIZE_Y)
colorMode(HSB, 1)
global cp5
cp5 = ControlP5(this)
cp5.addSlider("num_a").setPosition(20, 20).setRange(1, 40).setValue(num_a).setNumberOfTickMarks(40)
cp5.addSlider("num_b").setPosition(20, 30).setRange(1, 40).setValue(num_b).setNumberOfTickMarks(40)
cp5.addSlider("threshold").setPosition(20, 40).setRange(10, 400).setValue(threshold).setNumberOfTickMarks(40)
cp5.addButton("reset_button").setLabel("RESET").setPosition(20, 160).setSize(20, 20).onClick(lambda e: reset())
reset()
def reset():
background(0)
div_square(PVector(0, 0), width)
def div_square(_position, _wd):
count = 0
# ベクトルを作成（参照渡しにならないようにする）
p = PVector(_position.x, _position.y)
end_position = PVector(_wd + p.x, _wd + p.y)
fill(color(random(1), 1, 1, 0.3))
rect(p.x, p.y, _wd, _wd)
while _wd > threshold:
count += 1
if count % 2 == 1:
while p.x + _wd * ratio < end_position.x + 0.1:
div_rect(p, _wd * ratio)
p.x += _wd * ratio
_wd = end_position.x - p.x
else:
while p.y + _wd / ratio < end_position.y + 0.1:
div_rect(p, _wd)
p.y += _wd / ratio
_wd = end_position.y - p.y
def div_rect(_position, _wd):
count = 0
# ベクトルを作成（参照渡しにならないようにする）
p = PVector(_position.x, _position.y)
end_position = PVector(_wd + p.x, _wd / ratio + p.y)
fill(color(random(1), 1, 1, 0.3))
rect(p.x, p.y, _wd, _wd / ratio)
while _wd > threshold:
count += 1
if count % 2 == 0:
while p.x + _wd < end_position.x + 0.1:
div_square(p, _wd)
p.x += _wd
_wd = end_position.x - p.x
else:
while p.y + _wd < end_position.y + 0.1:
div_square(p, _wd)
p.y += _wd
_wd = end_position.y - p.y
# def mouseClicked():
# global num_a, num_b, threshold, ratio
# num_a = int(random(1, 20))
# num_b = int(random(1, 20))
# while num_a == num_b:
# num_b = int(random(1, 20))
# threshold = int(random(10, 200))
# print('num_a = ' + str(num_a) + ', num_b= ' + str(num_b) + ', threshold = ' + str(threshold))
# ratio = 1.0 * num_a / num_b
# background(0, 0, 1)
# div_square(PVector(0, 0), width)
def draw():
global num_a, num_b, threshold, ratio
num_a = int(cp5.getController('num_a').getValue())
num_b = int(cp5.getController('num_b').getValue())
threshold = int(cp5.getController('threshold').getValue())
ratio = 1.0 * num_b / num_a
print(num_a, num_b, threshold, ratio)
|
# coding=utf-8
# Copyright 2018 The TF-Agents 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.
"""Tests for tf_agents.network.value_network."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from tf_agents.networks import value_network
from tf_agents.specs import tensor_spec
from tensorflow.python.framework import test_util # TF internal
class ValueNetworkTest(tf.test.TestCase):
@test_util.run_in_graph_and_eager_modes()
def testBuilds(self):
observation_spec = tensor_spec.BoundedTensorSpec((8, 8, 3), tf.int32, 0, 1)
observation = tensor_spec.sample_spec_nest(
observation_spec, outer_dims=(1,))
net = value_network.ValueNetwork(
observation_spec, conv_layer_params=[(4, 2, 2)], fc_layer_params=(5,))
value, _ = net(observation)
self.evaluate(tf.compat.v1.global_variables_initializer())
self.assertEqual([1], value.shape.as_list())
self.assertEqual(6, len(net.variables))
# Conv Net Kernel
self.assertEqual((2, 2, 3, 4), net.variables[0].shape)
# Conv Net bias
self.assertEqual((4,), net.variables[1].shape)
# Fc Kernel
self.assertEqual((64, 5), net.variables[2].shape)
# Fc Bias
self.assertEqual((5,), net.variables[3].shape)
# Value Shrink Kernel
self.assertEqual((5, 1), net.variables[4].shape)
# Value Shrink bias
self.assertEqual((1,), net.variables[5].shape)
@test_util.run_in_graph_and_eager_modes()
def testHandlesExtraOuterDims(self):
observation_spec = tensor_spec.BoundedTensorSpec((8, 8, 3), tf.int32, 0, 1)
observation = tensor_spec.sample_spec_nest(
observation_spec, outer_dims=(3, 3, 2))
net = value_network.ValueNetwork(
observation_spec, conv_layer_params=[(4, 2, 2)], fc_layer_params=(5,))
value, _ = net(observation)
self.assertEqual([3, 3, 2], value.shape.as_list())
if __name__ == '__main__':
tf.test.main()
|
"""Gibbs sampler"""
import tensorflow_probability as tfp
__all__ = ["GibbsStep", "DeterministicScanKernel", "flatten_results"]
tfd = tfp.distributions # pylint: disable=no-member
mcmc = tfp.mcmc # pylint: disable=no-member
def flatten_results(results):
"""Results structures from nested Gibbs samplers sometimes
need flattening for writing out purposes.
"""
lst = []
def recurse(r):
for i in iter(r):
if isinstance(i, list):
for j in flatten_results(i):
yield j
else:
yield i
return [r for r in recurse(results)]
def get_tlp(results):
"""Fetches a target log prob from a results structure"""
if isinstance(results, list):
return get_tlp(results[-1])
else:
return results.accepted_results.target_log_prob
def put_tlp(results, target_log_prob):
"""Puts a target log prob into a results structure"""
if isinstance(results, list):
results[0] = put_tlp(results[0], target_log_prob)
return results
else:
accepted_results = results.accepted_results._replace(
target_log_prob=target_log_prob
)
return results._replace(accepted_results=accepted_results)
def get_tlp_fn(kernel):
if hasattr(kernel, "target_log_prob_fn"):
return kernel.target_log_prob_fn
else:
return get_tlp_fn(kernel.inner_kernel)
def put_tlp_fn(kernel, target_log_prob_fn):
if "target_log_prob_fn" in kernel.parameters:
kernel.parameters["target_log_prob_fn"] = target_log_prob_fn
else:
put_tlp_fn(kernel.inner_kernel, target_log_prob_fn)
class GibbsStep(mcmc.TransitionKernel):
def __init__(self, state_elem, inner_kernel, name=None):
"""Instantiates a Gibbs step
:param state_elem: the index of the element in `state` to be sampled
:param inner_kernel: the `tfp.mcmc.TransitionKernel` which operates on
the state element
"""
self._parameters = dict(
state_elem=state_elem,
inner_kernel=inner_kernel,
target_log_prob_fn=get_tlp_fn(inner_kernel),
name=name,
)
@property
def is_calibrated(self):
return self._parameters["inner_kernel"].is_calibrated
@property
def state_elem(self):
return self._parameters["state_elem"]
@property
def inner_kernel(self):
return self._parameters["inner_kernel"]
@property
def target_log_prob_fn(self):
return self._parameters["target_log_prob_fn"]
@property
def name(self):
return self._parameters["name"]
def conditional_target_log_prob(self, state):
"""Closes over `state`, returning a function to
calculate the conditional log prob for `state[state_elem]
"""
def fn(state_part):
state[self.state_elem] = state_part
return self.target_log_prob_fn(*state)
return fn
def one_step(self, current_state, previous_results, seed=None):
"""Runs the Gibbs step.
We close over the state, replacing the kernel target log
probability function with the conditional log prob.
"""
put_tlp_fn(self.inner_kernel, self.conditional_target_log_prob(current_state))
next_state_part, next_results = self.inner_kernel.one_step(
current_state[self.state_elem], previous_results, seed
)
current_state[self.state_elem] = next_state_part
return current_state, next_results
def bootstrap_results(self, current_state):
put_tlp_fn(self.inner_kernel, self.conditional_target_log_prob(current_state))
return self.inner_kernel.bootstrap_results(current_state[self.state_elem])
class DeterministicScanKernel(mcmc.TransitionKernel):
def __init__(self, kernel_list, name=None):
# Require to check if all kernel.is_calibrated is True
self._parameters = dict(name=name, kernel_list=kernel_list)
@property
def is_calibrated(self):
return True
@property
def kernel_list(self):
return self._parameters["kernel_list"]
def one_step(self, current_state, previous_results, seed=None):
"""We iterate over the state elements, calling each kernel in turn.
The `target_log_prob` is forwarded to the next `previous_results`
such that each kernel has a current `target_log_prob` value. In graph
and XLA modes, the for loop should be unrolled.
"""
next_results = previous_results # Semantic sugar
next_state = current_state
for i, sampler in enumerate(self.kernel_list):
next_state, next_results[i] = sampler.one_step(
next_state, previous_results[i], seed
)
tlp = get_tlp(next_results[i])
next_idx = (i + 1) % len(self.kernel_list)
next_results[next_idx] = put_tlp(next_results[next_idx], tlp)
return next_state, next_results
def bootstrap_results(self, current_state):
return [kernel.bootstrap_results(current_state) for kernel in self.kernel_list]
|
import numpy as np
import torch
from torch import nn
import sys
import util
class DataLoader(nn.Module):
"""Data loader module for training MCFlow
Args:
mode (int): Determines if we are loading training or testing data
seed (int): Used to determine the fold for cross validation experiments or reproducibility consideration if not
path (str): Determines the dataset to load
drp_percent (float): Determines the binomial success rate for observing a feature
"""
MODE_TRAIN = 0
MODE_TEST = 1
def __init__(self, mode=MODE_TRAIN, seed=0, path='news', drp_percent=0.5):
self.path = path
if path == 'mnist':
self.original_tr, self.original_te, img_shape = util.path_to_matrix(path)
else:
matrix = util.path_to_matrix(path)
self.matrix, self.maxs, self.mins = util.preprocess(matrix) #Preprocess according to the paper cited above
if path == 'mnist':
self.mask_tr, self.mask_te = util.create_img_dropout_masks(drp_percent, path, img_shape, len(self.original_tr), len(self.original_te))
self.train, self.test = util.fill_img_missingness(self.original_tr, self.original_te, self.mask_tr, self.mask_te, img_shape, 0) #For now 0 represents nearest neighbor calc
else:
np.random.shuffle(self.matrix)
np.random.seed(seed)
self.mask = util.make_static_mask(drp_percent, seed, path, self.matrix) #check if the mask is there or not in this function
self.original_tr, self.original_te = util.create_k_fold(self.matrix, seed)
self.unique_values = []
self.mask_tr, self.mask_te = util.create_k_fold_mask(seed, self.mask)
trans = np.transpose(self.matrix)
for r_idx, rows in enumerate(trans):
row = []
for c_idx, element in enumerate(rows):
if self.mask[c_idx][r_idx] == 0:
row.append(element)
self.unique_values.append(np.asarray(row))
self.train, self.test = util.fill_missingness(self.matrix, self.mask, self.unique_values, self.path, seed)
self.mode = mode
def reset_imputed_values(self, nn_model, nf_model, seed, args):
random_mat = np.clip(util.inference_imputation_networks(nn_model, nf_model, self.train, args), 0, 1)
self.train = (1-self.mask_tr) * self.original_tr + self.mask_tr * random_mat
random_mat = np.clip(util.inference_imputation_networks(nn_model, nf_model, self.test, args), 0, 1)
self.test = (1-self.mask_te) * self.original_te + self.mask_te * random_mat
def reset_img_imputed_values(self, nn_model, nf_model, seed, args):
util.inference_img_imputation_networks(nn_model, nf_model, self.train, self.mask_tr, self.original_tr, args)
util.inference_img_imputation_networks(nn_model, nf_model, self.test, self.mask_te, self.original_te, args)
def __len__(self):
if self.mode==0:
return len(self.train)
elif self.mode==1:
return len(self.test)
else:
print("Data loader mode error -- acceptable modes are 0,1,2")
sys.exit()
def __getitem__(self, idx):
if self.mode==0:
return torch.Tensor(self.train[idx]) , (torch.Tensor(self.original_tr[idx]), torch.Tensor(self.mask_tr[idx]))
elif self.mode==1:
return torch.Tensor(self.test[idx]) , (torch.Tensor(self.original_te[idx]), torch.Tensor(self.mask_te[idx]))
else:
print("Data loader mode error -- acceptable modes are 0,1,2")
sys.exit()
|
# -*- coding: utf-8 -*-
from slacker import Slacker
class Slack(object):
def __init__(self, token, channels=None, username=None, icon_url=None):
self.slack = Slacker(token)
self.username = username
self.icon_url = icon_url
self.channels = channels if channels else self.list_channels()
def list_channels(self):
return [channel['name'] for channel in self.slack.channels.list().body['channels'] if not channel['is_archived']]
def send_message(self, message, channel):
if channel not in self.channels:
raise AttributeError(f'Channel [{channel}] is not available')
self.slack.chat.post_message(
f'#{channel}',
message,
username=self.username,
icon_url=self.icon_url)
def __getattr__(self, channel):
if channel in self.channels:
return lambda x: self.send_message(x, channel=channel)
raise AttributeError(f'Channel [{channel}] is not available')
|
"""This is an auto-generated file. Modify at your own risk"""
from typing import Awaitable, Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
if TYPE_CHECKING:
from cripy import ConnectionType, SessionType
__all__ = ["CSS"]
class CSS:
"""
This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles)
have an associated `id` used in subsequent operations on the related object. Each object type has
a specific `id` structure, and those are not interchangeable between objects of different kinds.
CSS objects can be loaded using the `get*ForNode()` calls (which accept a DOM node id). A client
can also keep track of stylesheets via the `styleSheetAdded`/`styleSheetRemoved` events and
subsequently load the required stylesheet contents using the `getStyleSheet[Text]()` methods.
Domain Dependencies:
* DOM
Status: Experimental
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS`
"""
__slots__ = ["client"]
def __init__(self, client: Union["ConnectionType", "SessionType"]) -> None:
"""Initialize a new instance of CSS
:param client: The client instance to be used to communicate with the remote browser instance
"""
self.client: Union["ConnectionType", "SessionType"] = client
def addRule(
self, styleSheetId: str, ruleText: str, location: Dict[str, Any]
) -> Awaitable[Dict]:
"""
Inserts a new rule with the given `ruleText` in a stylesheet with given `styleSheetId`, at the
position specified by `location`.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-addRule`
:param styleSheetId: The css style sheet identifier where a new rule should be inserted.
:param ruleText: The text of a new rule.
:param location: Text position of a new rule in the target style sheet.
:return: The results of the command
"""
return self.client.send(
"CSS.addRule",
{"styleSheetId": styleSheetId, "ruleText": ruleText, "location": location},
)
def collectClassNames(self, styleSheetId: str) -> Awaitable[Dict]:
"""
Returns all class names from specified stylesheet.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-collectClassNames`
:param styleSheetId: The styleSheetId
:return: The results of the command
"""
return self.client.send("CSS.collectClassNames", {"styleSheetId": styleSheetId})
def createStyleSheet(self, frameId: str) -> Awaitable[Dict]:
"""
Creates a new special "via-inspector" stylesheet in the frame with given `frameId`.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-createStyleSheet`
:param frameId: Identifier of the frame where "via-inspector" stylesheet should be created.
:return: The results of the command
"""
return self.client.send("CSS.createStyleSheet", {"frameId": frameId})
def disable(self) -> Awaitable[Dict]:
"""
Disables the CSS agent for the given page.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-disable`
:return: The results of the command
"""
return self.client.send("CSS.disable", {})
def enable(self) -> Awaitable[Dict]:
"""
Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been
enabled until the result of this command is received.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-enable`
:return: The results of the command
"""
return self.client.send("CSS.enable", {})
def forcePseudoState(
self, nodeId: int, forcedPseudoClasses: List[str]
) -> Awaitable[Dict]:
"""
Ensures that the given node will have specified pseudo-classes whenever its style is computed by
the browser.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-forcePseudoState`
:param nodeId: The element id for which to force the pseudo state.
:param forcedPseudoClasses: Element pseudo classes to force when computing the element's style.
:return: The results of the command
"""
return self.client.send(
"CSS.forcePseudoState",
{"nodeId": nodeId, "forcedPseudoClasses": forcedPseudoClasses},
)
def getBackgroundColors(self, nodeId: int) -> Awaitable[Dict]:
"""
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getBackgroundColors`
:param nodeId: Id of the node to get background colors for.
:return: The results of the command
"""
return self.client.send("CSS.getBackgroundColors", {"nodeId": nodeId})
def getComputedStyleForNode(self, nodeId: int) -> Awaitable[Dict]:
"""
Returns the computed style for a DOM node identified by `nodeId`.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getComputedStyleForNode`
:param nodeId: The nodeId
:return: The results of the command
"""
return self.client.send("CSS.getComputedStyleForNode", {"nodeId": nodeId})
def getInlineStylesForNode(self, nodeId: int) -> Awaitable[Dict]:
"""
Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM
attributes) for a DOM node identified by `nodeId`.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getInlineStylesForNode`
:param nodeId: The nodeId
:return: The results of the command
"""
return self.client.send("CSS.getInlineStylesForNode", {"nodeId": nodeId})
def getMatchedStylesForNode(self, nodeId: int) -> Awaitable[Dict]:
"""
Returns requested styles for a DOM node identified by `nodeId`.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getMatchedStylesForNode`
:param nodeId: The nodeId
:return: The results of the command
"""
return self.client.send("CSS.getMatchedStylesForNode", {"nodeId": nodeId})
def getMediaQueries(self) -> Awaitable[Dict]:
"""
Returns all media queries parsed by the rendering engine.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getMediaQueries`
:return: The results of the command
"""
return self.client.send("CSS.getMediaQueries", {})
def getPlatformFontsForNode(self, nodeId: int) -> Awaitable[Dict]:
"""
Requests information about platform fonts which we used to render child TextNodes in the given
node.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getPlatformFontsForNode`
:param nodeId: The nodeId
:return: The results of the command
"""
return self.client.send("CSS.getPlatformFontsForNode", {"nodeId": nodeId})
def getStyleSheetText(self, styleSheetId: str) -> Awaitable[Dict]:
"""
Returns the current textual content for a stylesheet.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-getStyleSheetText`
:param styleSheetId: The styleSheetId
:return: The results of the command
"""
return self.client.send("CSS.getStyleSheetText", {"styleSheetId": styleSheetId})
def setEffectivePropertyValueForNode(
self, nodeId: int, propertyName: str, value: str
) -> Awaitable[Dict]:
"""
Find a rule with the given active property for the given node and set the new value for this
property
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setEffectivePropertyValueForNode`
:param nodeId: The element id for which to set property.
:param propertyName: The propertyName
:param value: The value
:return: The results of the command
"""
return self.client.send(
"CSS.setEffectivePropertyValueForNode",
{"nodeId": nodeId, "propertyName": propertyName, "value": value},
)
def setKeyframeKey(
self, styleSheetId: str, range: Dict[str, Any], keyText: str
) -> Awaitable[Dict]:
"""
Modifies the keyframe rule key text.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setKeyframeKey`
:param styleSheetId: The styleSheetId
:param range: The range
:param keyText: The keyText
:return: The results of the command
"""
return self.client.send(
"CSS.setKeyframeKey",
{"styleSheetId": styleSheetId, "range": range, "keyText": keyText},
)
def setMediaText(
self, styleSheetId: str, range: Dict[str, Any], text: str
) -> Awaitable[Dict]:
"""
Modifies the rule selector.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setMediaText`
:param styleSheetId: The styleSheetId
:param range: The range
:param text: The text
:return: The results of the command
"""
return self.client.send(
"CSS.setMediaText",
{"styleSheetId": styleSheetId, "range": range, "text": text},
)
def setRuleSelector(
self, styleSheetId: str, range: Dict[str, Any], selector: str
) -> Awaitable[Dict]:
"""
Modifies the rule selector.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setRuleSelector`
:param styleSheetId: The styleSheetId
:param range: The range
:param selector: The selector
:return: The results of the command
"""
return self.client.send(
"CSS.setRuleSelector",
{"styleSheetId": styleSheetId, "range": range, "selector": selector},
)
def setStyleSheetText(self, styleSheetId: str, text: str) -> Awaitable[Dict]:
"""
Sets the new stylesheet text.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setStyleSheetText`
:param styleSheetId: The styleSheetId
:param text: The text
:return: The results of the command
"""
return self.client.send(
"CSS.setStyleSheetText", {"styleSheetId": styleSheetId, "text": text}
)
def setStyleTexts(self, edits: List[Dict[str, Any]]) -> Awaitable[Dict]:
"""
Applies specified style edits one after another in the given order.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-setStyleTexts`
:param edits: The edits
:return: The results of the command
"""
return self.client.send("CSS.setStyleTexts", {"edits": edits})
def startRuleUsageTracking(self) -> Awaitable[Dict]:
"""
Enables the selector recording.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-startRuleUsageTracking`
:return: The results of the command
"""
return self.client.send("CSS.startRuleUsageTracking", {})
def stopRuleUsageTracking(self) -> Awaitable[Dict]:
"""
Stop tracking rule usage and return the list of rules that were used since last call to
`takeCoverageDelta` (or since start of coverage instrumentation)
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-stopRuleUsageTracking`
:return: The results of the command
"""
return self.client.send("CSS.stopRuleUsageTracking", {})
def takeCoverageDelta(self) -> Awaitable[Dict]:
"""
Obtain list of rules that became used since last call to this method (or since start of coverage
instrumentation)
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#method-takeCoverageDelta`
:return: The results of the command
"""
return self.client.send("CSS.takeCoverageDelta", {})
def fontsUpdated(
self, listener: Optional[Callable[[Dict[str, Any]], Any]] = None
) -> Any:
"""
Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded
web font
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#event-fontsUpdated`
:param listener: Optional listener function
:return: If a listener was supplied the return value is a callable that
will remove the supplied listener otherwise a future that resolves
with the value of the event
"""
event_name = "CSS.fontsUpdated"
if listener is None:
future = self.client.loop.create_future()
def _listener(event: Optional[Dict] = None) -> None:
future.set_result(event)
self.client.once(event_name, _listener)
return future
self.client.on(event_name, listener)
return lambda: self.client.remove_listener(event_name, listener)
def mediaQueryResultChanged(
self, listener: Optional[Callable[[Any], Any]] = None
) -> Any:
"""
Fires whenever a MediaQuery result changes (for example, after a browser window has been
resized.) The current implementation considers only viewport-dependent media features.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#event-mediaQueryResultChanged`
:param listener: Optional listener function
:return: If a listener was supplied the return value is a callable that
will remove the supplied listener otherwise a future that resolves
with the value of the event
"""
event_name = "CSS.mediaQueryResultChanged"
if listener is None:
future = self.client.loop.create_future()
def _listener(event: Optional[Dict] = None) -> None:
future.set_result(event)
self.client.once(event_name, _listener)
return future
self.client.on(event_name, listener)
return lambda: self.client.remove_listener(event_name, listener)
def styleSheetAdded(
self, listener: Optional[Callable[[Dict[str, Any]], Any]] = None
) -> Any:
"""
Fired whenever an active document stylesheet is added.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#event-styleSheetAdded`
:param listener: Optional listener function
:return: If a listener was supplied the return value is a callable that
will remove the supplied listener otherwise a future that resolves
with the value of the event
"""
event_name = "CSS.styleSheetAdded"
if listener is None:
future = self.client.loop.create_future()
def _listener(event: Optional[Dict] = None) -> None:
future.set_result(event)
self.client.once(event_name, _listener)
return future
self.client.on(event_name, listener)
return lambda: self.client.remove_listener(event_name, listener)
def styleSheetChanged(
self, listener: Optional[Callable[[Dict[str, Any]], Any]] = None
) -> Any:
"""
Fired whenever a stylesheet is changed as a result of the client operation.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#event-styleSheetChanged`
:param listener: Optional listener function
:return: If a listener was supplied the return value is a callable that
will remove the supplied listener otherwise a future that resolves
with the value of the event
"""
event_name = "CSS.styleSheetChanged"
if listener is None:
future = self.client.loop.create_future()
def _listener(event: Optional[Dict] = None) -> None:
future.set_result(event)
self.client.once(event_name, _listener)
return future
self.client.on(event_name, listener)
return lambda: self.client.remove_listener(event_name, listener)
def styleSheetRemoved(
self, listener: Optional[Callable[[Dict[str, Any]], Any]] = None
) -> Any:
"""
Fired whenever an active document stylesheet is removed.
See `https://chromedevtools.github.io/devtools-protocol/tot/CSS#event-styleSheetRemoved`
:param listener: Optional listener function
:return: If a listener was supplied the return value is a callable that
will remove the supplied listener otherwise a future that resolves
with the value of the event
"""
event_name = "CSS.styleSheetRemoved"
if listener is None:
future = self.client.loop.create_future()
def _listener(event: Optional[Dict] = None) -> None:
future.set_result(event)
self.client.once(event_name, _listener)
return future
self.client.on(event_name, listener)
return lambda: self.client.remove_listener(event_name, listener)
|
import sys
import pathlib
include_fileendings = ["py", "txt", "yml", "cfg", "rst", "md", "ini", "in"]
include_files = ["Makefile"]
exclude_files = ["rename_package.py"]
args = sys.argv[1:]
new_name = args[0]
this_dir = pathlib.Path('.').absolute()
for drc in this_dir.glob("**/*"):
if drc.is_dir():
new_dir = str(drc.absolute()).replace("bfmdummypackage",new_name)
drc.rename(new_dir)
for file in this_dir.glob("**/*"):
if file.is_file():
new_file = str(file.absolute()).replace("bfmdummypackage",new_name)
file.rename(new_file)
for file in this_dir.glob("**/*"):
if file.is_file() and \
((file.suffix[1:] in include_fileendings) or (file.name in include_files)) and \
file.name not in exclude_files:
with open(file,'r') as f:
text = f.read()
new_text = text.replace("bfmdummypackage",new_name)
with open(file,'w') as f:
f.write(new_text)
|
# Generated by Django 3.0.5 on 2020-07-03 20:00
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
('home', '0018_auto_20200627_1023'),
]
operations = [
migrations.AddField(
model_name='comment',
name='content_type',
field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.DO_NOTHING, to='contenttypes.ContentType'),
preserve_default=False,
),
]
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2018 JMatica Srl
#
# This file is part of apitestframework.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from enum import IntEnum, unique
@unique
class TestStatus(IntEnum):
'''
Status of a Test
'''
# test not executed yet
PENDING = 0
# test in execution
RUNNING = 1
# test executed successfully
SUCCESS = 2
# test executed with failures
FAILURE = 3
# test skipped
SKIPPED = 4
# unknown
UNKNOWN = 39
def icon(self) -> str:
'''
Return a unicode symbol representing the status
:return: A code representing the status
:rtype: str
'''
if self == TestStatus.PENDING:
return '\N{White Hourglass}'
elif self == TestStatus.RUNNING:
return '\N{Black Right-Pointing Triangle}'
elif self == TestStatus.SUCCESS:
return '\N{Heavy Check Mark}'
elif self == TestStatus.FAILURE:
return '\N{Heavy Ballot X}'
elif self == TestStatus.SKIPPED:
return '\N{Fisheye}'
else:
return '\N{Question Mark}'
|
"""Models for projects.
"""
from sqlalchemy.ext.associationproxy import association_proxy
from app import db
from base import Base
from .log import Log
from .association_objects import ProjectsUsers
class Project(db.Model, Base):
"""A WordSeer project for a collection of documents.
Attributes:
name (str): A human-readable name for this project.
path (str): The location of the directory of the files of this project.
user (User): The owner of this project.
documents (list of Documents): ``Document``\s present in this project.
"""
STATUS_UNPROCESSED = 0
STATUS_PREPROCESSING = 1
STATUS_DONE = 2
STATUS_FAILED = 3
STATUS_NAMES = {
STATUS_UNPROCESSED: "Not yet procesed.",
STATUS_PREPROCESSING: "Preprocessing.",
STATUS_DONE: "Preprocessed.",
STATUS_FAILED: "Preprocessing failed."
}
# Attributes
name = db.Column(db.String)
path = db.Column(db.String)
status = db.Column(db.Integer, default=STATUS_UNPROCESSED)
deleted = db.Column(db.Boolean, default=False)
# Active project indicator
active_project = None
# Relationships
counts = db.relationship(
"Count",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True
)
dependency_in_sentence = db.relationship(
"DependencyInSentence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True
)
document_files = db.relationship( # ? oddly configured relationship
"DocumentFile",
single_parent=True,
secondary="document_files_in_projects",
backref="projects",
cascade="all, delete-orphan",
passive_deletes=True
)
frequent_words = db.relationship(
"FrequentWord",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
frequent_sequences = db.relationship(
"FrequentSequence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
grammatical_rel = db.relationship(
"GrammaticalRelationship",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
logs = db.relationship(
"Log",
backref="project",
cascade="all, delete-orphan",
passive_deletes=True)
properties = db.relationship(
"Property",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
properties_of_sentences = db.relationship(
"PropertyOfSentence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
sentences = db.relationship(
"Sentence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
sequences = db.relationship(
"Sequence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
sequence_in_sentence = db.relationship(
"SequenceInSentence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
sets = db.relationship(
"Set",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
structure_files = db.relationship(
"StructureFile",
backref="project",
cascade="all, delete-orphan",
passive_deletes=True)
units = db.relationship(
"Unit",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
users = association_proxy(
"project_users",
"user",
creator=lambda user: ProjectsUsers(user=user))
word_in_sentence = db.relationship(
"WordInSentence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
word_in_sequence = db.relationship(
"WordInSequence",
backref="project",
lazy="dynamic",
cascade="all, delete-orphan",
passive_deletes=True)
def is_processable(self):
"""Check if this project can be processed.
"""
if (self.status == self.STATUS_UNPROCESSED and len(self.document_files) > 0 and
len(self.structure_files) > 0):
return True
return False
def get_documents(self):
"""A method to get all the ``Document``\s that are in this project.
Returns:
list of ``Document``\s.
"""
documents = []
for document_file in self.document_files:
documents.extend(document_file.documents)
return documents
def get_errors(self, start=0):
"""Return all ``ErrorLogs`` attached to this project.
"""
return Log.query.filter(Log.project == self).\
filter(Log.type == "error")\
.filter(Log.id > int(start))\
.all()
def get_warnings(self, start=0):
"""Return all ``WarningLogs`` attached to this project.
"""
return Log.query.filter(Log.project == self).\
filter(Log.type == "warning")\
.filter(Log.id > int(start))\
.all()
def get_infos(self, start=0):
"""Return all ``InfoLogs`` attached to this project.
"""
return Log.query.filter(Log.project == self)\
.filter(Log.type == "info")\
.filter(Log.id > int(start))\
.all()
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
__author__ = 'andyguo'
from deco import data_type_validation
from numbers import Number
from vector import Vec2f, Vec3f, Vec4f
class MatrixBase(object):
__slots__ = ['data']
dimension = (1, 1)
def __eq__(self, other):
if isinstance(other, MatrixBase):
return all((round(self[r][c] - other[r][c], 6) == 0
for r in range(self.dimension[0])
for c in range(self.dimension[1])))
return False
def clear(self):
for r in range(self.dimension[0]):
for c in range(self.dimension[1]):
self[r][c] = 0
class Matrix_22f(MatrixBase):
dimension = (2, 2)
@data_type_validation(a00=Number, a01=Number, a10=Number, a11=Number)
def __init__(self, a00, a01, a10, a11):
self.data = [Vec2f(a00, a01), Vec2f(a10, a11)]
def __repr__(self):
return '{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\n'.format(self.data[0][0], self.data[0][1],
self.data[1][0], self.data[1][1])
@data_type_validation(index=int)
def row(self, index):
return Vec2f(self.data[index][0], self.data[index][1])
@data_type_validation(index=int)
def col(self, index):
return Vec2f(self.data[0][index], self.data[1][index])
@data_type_validation(index=int)
def __getitem__(self, index):
return self.data[index]
def __add__(self, other):
if isinstance(other, Matrix_22f):
return Matrix_22f(self[0][0] + other[0][0], self[0][1] + other[0][1],
self[1][0] + other[1][0], self[1][1] + other[1][1])
if isinstance(other, Number):
return Matrix_22f(self[0][0] + other, self[0][1] + other,
self[1][0] + other, self[1][1] + other)
@data_type_validation(other=Number)
def __radd__(self, other):
return Matrix_22f(self[0][0] + other, self[0][1] + other,
self[1][0] + other, self[1][1] + other)
def __sub__(self, other):
if isinstance(other, Matrix_33f):
return Matrix_22f(self[0][0] - other[0][0], self[0][1] - other[0][1],
self[1][0] - other[1][0], self[1][1] - other[1][1])
if isinstance(other, Number):
return Matrix_22f(self[0][0] - other, self[0][1] - other,
self[1][0] - other, self[1][1] - other)
@data_type_validation(other=Number)
def __rsub__(self, other):
return Matrix_33f(other - self[0][0], other - self[0][1],
other - self[1][0], other - self[1][1])
def __neg__(self):
return -1.0 * self
def __mul__(self, other):
if isinstance(other, Matrix_22f):
a00 = self.row(0).dot(other.col(0))
a01 = self.row(0).dot(other.col(1))
a10 = self.row(1).dot(other.col(0))
a11 = self.row(1).dot(other.col(1))
return Matrix_22f(a00, a01,
a10, a11)
if isinstance(other, Vec2f):
x = self.row(0).dot(other)
y = self.row(1).dot(other)
return Vec2f(x, y)
if isinstance(other, Number):
return Matrix_22f(self[0][0] * other, self[0][1] * other,
self[1][0] * other, self[1][1] * other)
@data_type_validation(other=Number)
def __rmul__(self, other):
return Matrix_22f(self[0][0] * other, self[0][1] * other,
self[1][0] * other, self[1][1] * other)
def t(self):
return Matrix_22f.from_list(self.data)
def det(self):
return self[0][0] * self[1][1] - self[0][1] * self[1][0]
def inv(self):
det = self.det()
if det == 0:
raise ValueError('this Matrix is singular!')
a00 = self[1][1] / det
a10 = -self[1][0] / det
a01 = -self[0][1] / det
a11 = self[0][0] / det
return Matrix_22f(a00, a01,
a10, a11)
@classmethod
def identity(cls):
return cls(1.0, 0.0,
0.0, 1.0)
@classmethod
@data_type_validation(l=list)
def from_list(cls, l):
return cls(l[0][0], l[0][1],
l[1][0], l[1][1])
@classmethod
@data_type_validation(diagonal=(list, Vec2f))
def from_diagonal(cls, diagonal):
return cls(diagonal[0], 0,
0, diagonal[1])
@classmethod
def from_matrix_33(cls, m33):
if isinstance(m33, Matrix_33f):
return Matrix_22f(m33[0][0], m33[0][1],
m33[1][0], m33[1][1])
@classmethod
def from_matrix_44(cls, m44):
if isinstance(m44, Matrix_44f):
return Matrix_22f(m44[0][0], m44[0][1],
m44[1][0], m44[1][1])
class Matrix_33f(MatrixBase):
dimension = (3, 3)
@data_type_validation(a00=Number, a01=Number, a02=Number, a10=Number, a11=Number, a12=Number, a20=Number,
a21=Number, a22=Number)
def __init__(self, a00, a01, a02, a10, a11, a12, a20, a21, a22):
self.data = [Vec3f(a00, a01, a02), Vec3f(a10, a11, a12), Vec3f(a20, a21, a22)]
def __repr__(self):
return '{:.06f}\t{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\t{:.06f}\n'.format(self.data[0][0], self.data[0][1], self.data[0][2],
self.data[1][0], self.data[1][1], self.data[1][2],
self.data[2][0], self.data[2][1], self.data[2][2])
@data_type_validation(index=int)
def row(self, index):
return Vec3f(self.data[index][0], self.data[index][1], self.data[index][2])
@data_type_validation(index=int)
def col(self, index):
return Vec3f(self.data[0][index], self.data[1][index], self[2][index])
@data_type_validation(index=int)
def __getitem__(self, index):
return self.data[index]
def __add__(self, other):
if isinstance(other, Matrix_33f):
return Matrix_33f(self[0][0] + other[0][0], self[0][1] + other[0][1], self[0][2] + other[0][2],
self[1][0] + other[1][0], self[1][1] + other[1][1], self[1][2] + other[1][2],
self[2][0] + other[2][0], self[2][1] + other[2][1], self[2][2] + other[2][2])
if isinstance(other, Number):
return Matrix_33f(self[0][0] + other, self[0][1] + other, self[0][2] + other,
self[1][0] + other, self[1][1] + other, self[1][2] + other,
self[2][0] + other, self[2][1] + other, self[2][2] + other)
@data_type_validation(other=Number)
def __radd__(self, other):
return Matrix_33f(self[0][0] + other, self[0][1] + other, self[0][2] + other,
self[1][0] + other, self[1][1] + other, self[1][2] + other,
self[2][0] + other, self[2][1] + other, self[2][2] + other)
def __sub__(self, other):
if isinstance(other, Matrix_33f):
return Matrix_33f(self[0][0] - other[0][0], self[0][1] - other[0][1], self[0][2] - other[0][2],
self[1][0] - other[1][0], self[1][1] - other[1][1], self[1][2] - other[1][2],
self[2][0] - other[2][0], self[2][1] - other[2][1], self[2][2] - other[2][2])
if isinstance(other, Number):
return Matrix_33f(self[0][0] - other, self[0][1] - other, self[0][2] - other,
self[1][0] - other, self[1][1] - other, self[1][2] - other,
self[2][0] - other, self[2][1] - other, self[2][2] - other)
@data_type_validation(other=Number)
def __rsub__(self, other):
return Matrix_33f(other - self[0][0], other - self[0][1], other - self[0][2],
other - self[1][0], other - self[1][1], other - self[1][2],
other - self[2][0], other - self[2][1], other - self[2][2])
def __neg__(self):
return -1.0 * self
def __mul__(self, other):
if isinstance(other, Matrix_33f):
a00 = self.row(0).dot(other.col(0))
a01 = self.row(0).dot(other.col(1))
a02 = self.row(0).dot(other.col(2))
a10 = self.row(1).dot(other.col(0))
a11 = self.row(1).dot(other.col(1))
a12 = self.row(1).dot(other.col(2))
a20 = self.row(2).dot(other.col(0))
a21 = self.row(2).dot(other.col(1))
a22 = self.row(2).dot(other.col(2))
return Matrix_33f(a00, a01, a02,
a10, a11, a12,
a20, a21, a22)
if isinstance(other, Vec3f):
x = self.row(0).dot(other)
y = self.row(1).dot(other)
z = self.row(2).dot(other)
return Vec3f(x, y, z)
if isinstance(other, Number):
return Matrix_33f(self[0][0] * other, self[0][1] * other, self[0][2] * other,
self[1][0] * other, self[1][1] * other, self[1][2] * other,
self[2][0] * other, self[2][1] * other, self[2][2] * other)
@data_type_validation(other=Number)
def __rmul__(self, other):
return Matrix_33f(self[0][0] * other, self[0][1] * other, self[0][2] * other,
self[1][0] * other, self[1][1] * other, self[1][2] * other,
self[2][0] * other, self[2][1] * other, self[2][2] * other)
def t(self):
return Matrix_33f(self[0][0], self[1][0], self[2][0],
self[0][1], self[1][1], self[2][1],
self[0][2], self[1][2], self[2][2])
def det(self):
d1 = self[0][0] * Matrix_22f(self[1][1], self[1][2], self[2][1], self[2][2]).det()
d2 = self[0][1] * Matrix_22f(self[1][0], self[1][2], self[2][0], self[2][2]).det()
d3 = self[0][2] * Matrix_22f(self[1][0], self[1][1], self[2][0], self[2][1]).det()
return d1 - d2 + d3
def inv(self):
det = self.det()
if det == 0:
raise ValueError('this Matrix is singular!')
a00 = (self[1][1] * self[2][2] - self[1][2] * self[2][1]) / det
a10 = -(self[1][0] * self[2][2] - self[1][2] * self[2][0]) / det
a20 = (self[1][0] * self[2][1] - self[1][1] * self[2][0]) / det
a01 = -(self[0][1] * self[2][2] - self[0][2] * self[2][1]) / det
a11 = (self[0][0] * self[2][2] - self[0][2] * self[2][0]) / det
a21 = -(self[0][0] * self[2][1] - self[0][1] * self[2][0]) / det
a02 = (self[0][1] * self[1][2] - self[0][2] * self[1][1]) / det
a12 = -(self[0][0] * self[1][2] - self[0][2] * self[1][0]) / det
a22 = (self[0][0] * self[1][1] - self[0][1] * self[1][0]) / det
return Matrix_33f(a00, a01, a02,
a10, a11, a12,
a20, a21, a22)
@classmethod
def identity(cls):
return cls(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0)
@classmethod
@data_type_validation(l=list)
def from_list(cls, l):
return cls(l[0][0], l[0][1], l[0][2],
l[1][0], l[1][1], l[1][2],
l[2][0], l[2][1], l[2][2])
@classmethod
def from_matrix_44(cls, m44):
if isinstance(m44, Matrix_44f):
return Matrix_33f(m44[0][0], m44[0][1], m44[0][2],
m44[1][0], m44[1][1], m44[1][2],
m44[2][0], m44[2][1], m44[2][2])
@classmethod
def from_matrix_22(cls, m22):
if isinstance(m44, Matrix_22f):
return Matrix_33f(m22[0][0], m22[0][1], 0.0,
m22[1][0], m22[1][1], 0.0,
0.0, 0.0, 1.0)
@classmethod
@data_type_validation(diagonal=(list, Vec3f))
def from_diagonal(cls, diagonal):
return cls(diagonal[0], 0, 0,
0, diagonal[1], 0,
0, 0, diagonal[2])
@classmethod
def from_quaternion(cls, q):
from quaternion import Quaternion
if isinstance(q, Quaternion):
return q.matrix()
@classmethod
@data_type_validation(rx=Number, ry=Number, rz=Number)
def from_euler_angles(cls, rx, ry, rz, order='xyz'):
import math
mx = cls.identity()
mx[1][1] = mx[2][2] = math.cos(math.radians(rx))
mx[1][2] = -math.sin(math.radians(rx))
mx[2][1] = -mx[1][2]
my = cls.identity()
my[0][0] = my[2][2] = math.cos(math.radians(ry))
my[0][2] = math.sin(math.radians(ry))
my[2][0] = -my[0][2]
mz = cls.identity()
mz[0][0] = mz[1][1] = math.cos(math.radians(rz))
mz[0][1] = -math.sin(math.radians(rz))
mz[1][0] = -mz[0][1]
mapping = {'x': mx, 'y': my, 'z': mz}
return mapping[order[2]] * mapping[order[1]] * mapping[order[0]]
def quaternion(self):
from quaternion import Quaternion
return Quaternion.from_matrix(self)
def euler_angles(self, order='xyz'):
import math
if order == 'xyz':
angle_1 = math.degrees(math.atan2(self[2][1], self[2][2]))
angle_2 = -math.degrees(math.asin(self[2][0]))
angle_3 = math.degrees(math.atan2(self[1][0], self[0][0]))
return angle_1, angle_2, angle_3
if order == 'xzy':
angle_1 = -math.degrees(math.atan2(self[1][2], self[1][1]))
angle_2 = math.degrees(math.asin(self[1][0]))
angle_3 = -math.degrees(math.atan2(self[2][0], self[0][0]))
return angle_1, angle_3, angle_2
if order == 'yzx':
angle_1 = math.degrees(math.atan2(self[0][2], self[0][0]))
angle_2 = -math.degrees(math.asin(self[0][1]))
angle_3 = math.degrees(math.atan2(self[2][1], self[1][1]))
return angle_3, angle_1, angle_2
if order == 'yxz':
angle_1 = -math.degrees(math.atan2(self[0][1], self[1][1]))
angle_2 = math.degrees(math.asin(self[2][0]))
angle_3 = -math.degrees(math.atan2(self[2][0], self[2][2]))
return angle_2, angle_1, angle_3
if order == 'zxy':
angle_1 = math.degrees(math.atan2(self[1][0], self[1][1]))
angle_2 = -math.degrees(math.asin(self[1][2]))
angle_3 = math.degrees(math.atan2(self[0][2], self[2][2]))
return angle_2, angle_3, angle_1
if order == 'zyx':
angle_1 = -math.degrees(math.atan2(self[0][1], self[0][0]))
angle_2 = math.degrees(math.asin(self[0][2]))
angle_3 = -math.degrees(math.atan2(self[1][2], self[2][2]))
return angle_3, angle_2, angle_1
class Matrix_44f(MatrixBase):
dimension = (4, 4)
@data_type_validation(a00=Number, a01=Number, a02=Number, a03=Number,
a10=Number, a11=Number, a12=Number, a13=Number,
a20=Number, a21=Number, a22=Number, a23=Number,
a30=Number, a31=Number, a32=Number, a33=Number)
def __init__(self, a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33):
self.data = [Vec4f(a00, a01, a02, a03),
Vec4f(a10, a11, a12, a13),
Vec4f(a20, a21, a22, a23),
Vec4f(a30, a31, a32, a33)]
def __repr__(self):
return '{:.06f}\t{:.06f}\t{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\t{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\t{:.06f}\t{:.06f}\n' \
'{:.06f}\t{:.06f}\t{:.06f}\t{:.06f}\n'.format(
self.data[0][0], self.data[0][1], self.data[0][2], self.data[0][3],
self.data[1][0], self.data[1][1], self.data[1][2], self.data[1][3],
self.data[2][0], self.data[2][1], self.data[2][2], self.data[2][3],
self.data[3][0], self.data[3][1], self.data[3][2], self.data[3][3])
@data_type_validation(index=int)
def row(self, index):
return Vec4f(self[index][0], self[index][1], self[index][2], self[index][3])
@data_type_validation(index=int)
def col(self, index):
return Vec4f(self[0][index], self[1][index], self[2][index], self[3][index])
@data_type_validation(index=int)
def __getitem__(self, index):
return self.data[index]
def __add__(self, other):
if isinstance(other, Matrix_44f):
return Matrix_44f(self[0][0] + other[0][0], self[0][1] + other[0][1], self[0][2] + other[0][2],
self[0][3] + other[0][3],
self[1][0] + other[1][0], self[1][1] + other[1][1], self[1][2] + other[1][2],
self[1][3] + other[1][4],
self[2][0] + other[2][0], self[2][1] + other[2][1], self[2][2] + other[2][2],
self[2][3] + other[2][4],
self[3][0] + other[3][0], self[3][1] + other[3][1], self[3][2] + other[3][2],
self[3][3] + other[3][4],
)
if isinstance(other, Number):
return Matrix_44f(self[0][0] + other, self[0][1] + other, self[0][2] + other, self[0][3] + other,
self[1][0] + other, self[1][1] + other, self[1][2] + other, self[1][3] + other,
self[2][0] + other, self[2][1] + other, self[2][2] + other, self[2][3] + other,
self[3][0] + other, self[3][1] + other, self[3][2] + other, self[3][3] + other)
@data_type_validation(other=Number)
def __radd__(self, other):
return Matrix_44f(self[0][0] + other, self[0][1] + other, self[0][2] + other, self[0][3] + other,
self[1][0] + other, self[1][1] + other, self[1][2] + other, self[1][3] + other,
self[2][0] + other, self[2][1] + other, self[2][2] + other, self[2][3] + other,
self[3][0] + other, self[3][1] + other, self[3][2] + other, self[3][3] + other)
def __sub__(self, other):
if isinstance(other, Matrix_44f):
return Matrix_44f(self[0][0] - other[0][0], self[0][1] - other[0][1], self[0][2] - other[0][2],
self[0][3] - other[0][3],
self[1][0] - other[1][0], self[1][1] - other[1][1], self[1][2] - other[1][2],
self[1][3] - other[1][4],
self[2][0] - other[2][0], self[2][1] - other[2][1], self[2][2] - other[2][2],
self[2][3] - other[2][4],
self[3][0] - other[3][0], self[3][1] - other[3][1], self[3][2] - other[3][2],
self[3][3] - other[3][4],
)
if isinstance(other, Number):
return Matrix_44f(other - self[0][0], other - self[0][1], other - self[0][2], other - self[0][3],
other - self[1][0], other - self[1][1], other - self[1][2], other - self[1][3],
other - self[2][0], other - self[2][1], other - self[2][2], other - self[2][3],
other - self[3][0], other - self[3][1], other - self[3][2], other - self[3][3])
@data_type_validation(other=Number)
def __rsub__(self, other):
return Matrix_44f(other - self[0][0], other - self[0][1], other - self[0][2], other - self[0][3],
other - self[1][0], other - self[1][1], other - self[1][2], other - self[1][3],
other - self[2][0], other - self[2][1], other - self[2][2], other - self[2][3],
other - self[3][0], other - self[3][1], other - self[3][2], other - self[3][3])
def __neg__(self):
return -1.0 * self
def __mul__(self, other):
if isinstance(other, Matrix_44f):
a00 = self.row(0).dot(other.col(0))
a01 = self.row(0).dot(other.col(1))
a02 = self.row(0).dot(other.col(2))
a03 = self.row(0).dot(other.col(3))
a10 = self.row(1).dot(other.col(0))
a11 = self.row(1).dot(other.col(1))
a12 = self.row(1).dot(other.col(2))
a13 = self.row(1).dot(other.col(3))
a20 = self.row(2).dot(other.col(0))
a21 = self.row(2).dot(other.col(1))
a22 = self.row(2).dot(other.col(2))
a23 = self.row(2).dot(other.col(3))
a30 = self.row(3).dot(other.col(0))
a31 = self.row(3).dot(other.col(1))
a32 = self.row(3).dot(other.col(2))
a33 = self.row(3).dot(other.col(3))
return Matrix_44f(a00, a01, a02, a03,
a10, a11, a12, a13,
a20, a21, a22, a23,
a30, a31, a32, a33)
if isinstance(other, Vec4f):
x = self.row(0).dot(other)
y = self.row(1).dot(other)
z = self.row(2).dot(other)
w = self.row(3).dot(other)
return Vec3f(x, y, z, w)
if isinstance(other, Number):
return Matrix_33f(self[0][0] * other, self[0][1] * other, self[0][2] * other,
self[1][0] * other, self[1][1] * other, self[1][2] * other,
self[2][0] * other, self[2][1] * other, self[2][2] * other)
data_type_validation(other=Number)
def __rmul__(self, other):
return Matrix_44f(self[0][0] * other, self[0][1] * other, self[0][2] * other, self[0][3] * other,
self[1][0] * other, self[1][1] * other, self[1][2] * other, self[1][3] * other,
self[2][0] * other, self[2][1] * other, self[2][2] * other, self[2][3] * other,
self[3][0] * other, self[3][1] * other, self[3][2] * other, self[3][3] * other)
def t(self):
return Matrix_44f(self[0][0], self[1][0], self[2][0], self[3][0],
self[0][1], self[1][1], self[2][1], self[3][1],
self[0][2], self[1][2], self[2][2], self[3][2],
self[0][3], self[1][3], self[2][3], self[3][3])
def det(self):
d1 = self[0][0] * Matrix_33f(self[1][1], self[1][2], self[1][3],
self[2][1], self[2][2], self[2][3],
self[3][1], self[3][2], self[3][3]).det()
d2 = self[0][1] * Matrix_33f(self[1][0], self[1][2], self[1][3],
self[2][0], self[2][2], self[2][3],
self[3][0], self[3][2], self[3][3]).det()
d3 = self[0][2] * Matrix_33f(self[1][0], self[1][1], self[1][3],
self[2][0], self[2][1], self[2][3],
self[3][0], self[3][1], self[3][3]).det()
d4 = self[0][3] * Matrix_33f(self[1][0], self[1][1], self[1][2],
self[2][0], self[2][1], self[2][2],
self[3][0], self[3][1], self[3][2]).det()
return d1 - d2 + d3 - d4
def inv(self):
d00 = Matrix_33f(self[1][1], self[1][2], self[1][3],
self[2][1], self[2][2], self[2][3],
self[3][1], self[3][2], self[3][3]).det()
d01 = Matrix_33f(self[1][0], self[1][2], self[1][3],
self[2][0], self[2][2], self[2][3],
self[3][0], self[3][2], self[3][3]).det()
d02 = Matrix_33f(self[1][0], self[1][1], self[1][3],
self[2][0], self[2][1], self[2][3],
self[3][0], self[3][1], self[3][3]).det()
d03 = Matrix_33f(self[1][0], self[1][1], self[1][2],
self[2][0], self[2][1], self[2][2],
self[3][0], self[3][1], self[3][2]).det()
det = self[0][0] * d00 - self[0][1] * d01 + self[0][2] * d02 - self[0][3] * d03
if det == 0:
raise ValueError('this Matrix is singular!')
a00 = d00 / det
a01 = -d01 / det
a02 = d02 / det
a03 = -d03 / det
a10 = -Matrix_33f(self[0][1], self[0][2], self[0][3],
self[2][1], self[2][2], self[2][3],
self[3][1], self[3][2], self[3][3]).det() / det
a11 = Matrix_33f(self[0][0], self[0][2], self[0][3],
self[2][0], self[2][2], self[2][3],
self[3][0], self[3][2], self[3][3]).det() / det
a12 = -Matrix_33f(self[0][0], self[0][1], self[0][3],
self[2][0], self[2][1], self[2][3],
self[3][0], self[3][1], self[3][3]).det() / det
a13 = Matrix_33f(self[0][0], self[0][1], self[0][2],
self[2][0], self[2][1], self[2][2],
self[3][0], self[3][1], self[3][2]).det() / det
a20 = Matrix_33f(self[0][1], self[0][2], self[0][3],
self[1][1], self[1][2], self[1][3],
self[3][1], self[3][2], self[3][3]).det() / det
a21 = -Matrix_33f(self[0][0], self[0][2], self[0][3],
self[1][0], self[1][2], self[1][3],
self[3][0], self[3][2], self[3][3]).det() / det
a22 = Matrix_33f(self[0][0], self[0][1], self[0][3],
self[1][0], self[1][1], self[1][3],
self[3][0], self[3][1], self[3][3]).det() / det
a23 = -Matrix_33f(self[0][0], self[0][1], self[0][2],
self[1][0], self[1][1], self[1][2],
self[3][0], self[3][1], self[3][2]).det() / det
a30 = -Matrix_33f(self[0][1], self[0][2], self[0][3],
self[1][1], self[1][2], self[1][3],
self[2][1], self[2][2], self[2][3]).det() / det
a31 = Matrix_33f(self[0][0], self[0][2], self[0][3],
self[1][0], self[1][2], self[1][3],
self[2][0], self[2][2], self[2][3]).det() / det
a32 = -Matrix_33f(self[0][0], self[0][1], self[0][3],
self[1][0], self[1][1], self[1][3],
self[2][0], self[2][1], self[2][3]).det() / det
a33 = Matrix_33f(self[0][0], self[0][1], self[0][2],
self[1][0], self[1][1], self[1][2],
self[2][0], self[2][1], self[2][2]).det() / det
return Matrix_44f(a00, a10, a20, a30,
a01, a11, a21, a31,
a02, a12, a22, a32,
a03, a13, a23, a33)
@property
def diagonal(self):
return Vec4f(self[0][0], self[1][1], self[2][2], self[3][3])
@classmethod
def identity(cls):
return cls(1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0)
@classmethod
@data_type_validation(l=list)
def from_list(cls, l):
return cls(l[0][0], l[0][1], l[0][2], l[0][3],
l[1][0], l[1][1], l[1][2], l[1][3],
l[2][0], l[2][1], l[2][2], l[2][3],
l[3][0], l[3][1], l[3][2], l[3][3])
@classmethod
@data_type_validation(diagonal=(list, Vec4f))
def from_diagonal(cls, diagonal):
return cls(diagonal[0], 0, 0, 0,
0, diagonal[1], 0, 0,
0, 0, diagonal[2], 0,
0, 0, 0, diagonal[3])
@classmethod
@data_type_validation(m22=Matrix_22f)
def from_matrix_22(cls, m22):
return cls(m22[0][0], m22[0][1], 0, 0,
m22[1][0], m22[1][1], 0, 0,
0, 0, 1, 0,
0, 0, 0, 1)
@classmethod
@data_type_validation(m33=Matrix_33f)
def from_matrix_33(cls, m33):
return cls(m33[0][0], m33[0][1], m33[0][2], 0,
m33[1][0], m33[1][1], m33[1][2], 0,
m33[2][0], m33[2][1], m33[2][2], 0,
0, 0, 0, 1)
@classmethod
@data_type_validation(x=Number, y=Number, z=Number,
rx=Number, ry=Number, rz=Number,
sx=Number, sy=Number, sz=Number)
def compose(cls, x, y, z, rx, ry, rz, sx=1.0, sy=1.0, sz=1.0, transform_order='srt', rotation_order='xyz'):
translate_matrix = Matrix_44f.identity()
translate_matrix[0][3] = x
translate_matrix[1][3] = y
translate_matrix[2][3] = z
rotate_matrix = Matrix_44f.from_matrix_33(Matrix_33f.from_euler_angles(rx, ry, rz, order=rotation_order))
scale_matrix = Matrix_44f.from_diagonal(Vec4f(sx, sy, sz, 1.0))
mapping = {'s': scale_matrix, 'r': rotate_matrix, 't': translate_matrix}
return mapping[transform_order[2]] * mapping[transform_order[1]] * mapping[transform_order[0]]
def _decompose_rst(self):
return self._decompose_srt()
def _decompose_rts(self):
return self._decompose_str()
def _decompose_trs(self):
return self._decompose_tsr()
def _decompose_srt(self):
translate_matrix = Matrix_44f.identity()
translate_matrix[0][3] = self[0][3]
translate_matrix[1][3] = self[1][3]
translate_matrix[2][3] = self[2][3]
scale_matrix = Matrix_44f.from_diagonal([self.col(0).length, self.col(1).length, self.col(2).length, 1.0])
rotate_matrix = Matrix_44f.identity()
rotate_matrix[0][0] = self[0][0] / scale_matrix[0][0]
rotate_matrix[1][0] = self[1][0] / scale_matrix[0][0]
rotate_matrix[2][0] = self[2][0] / scale_matrix[0][0]
rotate_matrix[0][1] = self[0][1] / scale_matrix[1][1]
rotate_matrix[1][1] = self[1][1] / scale_matrix[1][1]
rotate_matrix[2][1] = self[2][1] / scale_matrix[1][1]
rotate_matrix[0][2] = self[0][2] / scale_matrix[2][2]
rotate_matrix[1][2] = self[1][2] / scale_matrix[2][2]
rotate_matrix[2][2] = self[2][2] / scale_matrix[2][2]
return {'translate': translate_matrix,
'rotate' : rotate_matrix,
'scale' : scale_matrix}
def _decompose_str(self):
scale_matrix = Matrix_44f.from_diagonal([self.col(0).length, self.col(1).length, self.col(2).length, 1.0])
rotate_matrix = Matrix_44f.identity()
rotate_matrix[0][0] = self[0][0] / scale_matrix[0][0]
rotate_matrix[1][0] = self[1][0] / scale_matrix[0][0]
rotate_matrix[2][0] = self[2][0] / scale_matrix[0][0]
rotate_matrix[0][1] = self[0][1] / scale_matrix[1][1]
rotate_matrix[1][1] = self[1][1] / scale_matrix[1][1]
rotate_matrix[2][1] = self[2][1] / scale_matrix[1][1]
rotate_matrix[0][2] = self[0][2] / scale_matrix[2][2]
rotate_matrix[1][2] = self[1][2] / scale_matrix[2][2]
rotate_matrix[2][2] = self[2][2] / scale_matrix[2][2]
translate_matrix = Matrix_44f.identity()
temp = rotate_matrix.inv() * self
translate_matrix[0][3] = temp[0][3]
translate_matrix[1][3] = temp[1][3]
translate_matrix[2][3] = temp[2][3]
return {'translate': translate_matrix,
'rotate' : rotate_matrix,
'scale' : scale_matrix}
def _decompose_tsr(self):
scale_matrix = Matrix_44f.from_diagonal([self.col(0).length, self.col(1).length, self.col(2).length, 1.0])
rotate_matrix = Matrix_44f.identity()
rotate_matrix[0][0] = self[0][0] / scale_matrix[0][0]
rotate_matrix[1][0] = self[1][0] / scale_matrix[0][0]
rotate_matrix[2][0] = self[2][0] / scale_matrix[0][0]
rotate_matrix[0][1] = self[0][1] / scale_matrix[1][1]
rotate_matrix[1][1] = self[1][1] / scale_matrix[1][1]
rotate_matrix[2][1] = self[2][1] / scale_matrix[1][1]
rotate_matrix[0][2] = self[0][2] / scale_matrix[2][2]
rotate_matrix[1][2] = self[1][2] / scale_matrix[2][2]
rotate_matrix[2][2] = self[2][2] / scale_matrix[2][2]
translate_matrix = Matrix_44f.identity()
temp = scale_matrix.inv() * rotate_matrix.inv() * self
translate_matrix[0][3] = temp[0][3]
translate_matrix[1][3] = temp[1][3]
translate_matrix[2][3] = temp[2][3]
return {'translate': translate_matrix,
'rotate' : rotate_matrix,
'scale' : scale_matrix}
def decompose(self, transform_order='srt', rotation_order='xyz', matrix_form=False):
func = getattr(self, '_decompose_{}'.format(transform_order), None)
if func:
result = func()
if matrix_form:
return result
translate = (result['translate'][0][3], result['translate'][1][3], result['translate'][2][3])
rotate = Matrix_33f.from_matrix_44(result['rotate']).euler_angles(order=rotation_order)
scale = (result['scale'][0][0], result['scale'][1][1], result['scale'][2][2])
return {'translate': translate, 'rotate': rotate, 'scale': scale}
return None
if __name__ == '__main__':
from quaternion import Quaternion
transform_order = 'trs'
m44 = Matrix_44f.compose(1, 2, 3, 10, 20, 30, 1, 1, 1, transform_order=transform_order)
m44_2 = Matrix_44f.compose(1, 2, 3, 10, 20, 30, 1, 1, 1)
# print Quaternion.from_euler_angles(10, 20, 30).matrix()
print m44.decompose(transform_order=transform_order)
m44.clear()
print m44
# order = 'zyx'
#
# a = Quaternion.from_euler_angles(10, 20, 30, order=order)
# print a
# print a.matrix()
#
# m = Matrix_33f.from_quaternion(a)
# print m
#
# print Matrix_33f.from_euler_angles(10, 20, 30, order=order)
# print m.quaternion()
# print m.euler_angles(order)
|
from .centroidal_phi import CentroidalPhi, EESplines
from .contact_sequence_wrapper import ContactSequenceWrapper
from .problem_definition import createMultiphaseShootingProblem
from .spline_utils import polyfitND
|
from common.models import *
from common.toontown import *
from common.threads import *
|
import sys
#sys.path.append('/scratch/pradap/python-work/py_entitymatching')
|
# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from collections import OrderedDict
import functools
import re
from typing import Dict, Optional, Sequence, Tuple, Type, Union
import pkg_resources
from google.api_core.client_options import ClientOptions
from google.api_core import exceptions as core_exceptions
from google.api_core import gapic_v1
from google.api_core import retry as retries
from google.auth import credentials as ga_credentials # type: ignore
from google.oauth2 import service_account # type: ignore
try:
OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault]
except AttributeError: # pragma: NO COVER
OptionalRetry = Union[retries.Retry, object] # type: ignore
from google.api_core import operation as gac_operation # type: ignore
from google.api_core import operation_async # type: ignore
from google.cloud.appengine_admin_v1.services.versions import pagers
from google.cloud.appengine_admin_v1.types import app_yaml
from google.cloud.appengine_admin_v1.types import appengine
from google.cloud.appengine_admin_v1.types import deploy
from google.cloud.appengine_admin_v1.types import operation as ga_operation
from google.cloud.appengine_admin_v1.types import version
from google.protobuf import duration_pb2 # type: ignore
from google.protobuf import empty_pb2 # type: ignore
from google.protobuf import timestamp_pb2 # type: ignore
from .transports.base import VersionsTransport, DEFAULT_CLIENT_INFO
from .transports.grpc_asyncio import VersionsGrpcAsyncIOTransport
from .client import VersionsClient
class VersionsAsyncClient:
"""Manages versions of a service."""
_client: VersionsClient
DEFAULT_ENDPOINT = VersionsClient.DEFAULT_ENDPOINT
DEFAULT_MTLS_ENDPOINT = VersionsClient.DEFAULT_MTLS_ENDPOINT
common_billing_account_path = staticmethod(
VersionsClient.common_billing_account_path
)
parse_common_billing_account_path = staticmethod(
VersionsClient.parse_common_billing_account_path
)
common_folder_path = staticmethod(VersionsClient.common_folder_path)
parse_common_folder_path = staticmethod(VersionsClient.parse_common_folder_path)
common_organization_path = staticmethod(VersionsClient.common_organization_path)
parse_common_organization_path = staticmethod(
VersionsClient.parse_common_organization_path
)
common_project_path = staticmethod(VersionsClient.common_project_path)
parse_common_project_path = staticmethod(VersionsClient.parse_common_project_path)
common_location_path = staticmethod(VersionsClient.common_location_path)
parse_common_location_path = staticmethod(VersionsClient.parse_common_location_path)
@classmethod
def from_service_account_info(cls, info: dict, *args, **kwargs):
"""Creates an instance of this client using the provided credentials
info.
Args:
info (dict): The service account private key info.
args: Additional arguments to pass to the constructor.
kwargs: Additional arguments to pass to the constructor.
Returns:
VersionsAsyncClient: The constructed client.
"""
return VersionsClient.from_service_account_info.__func__(VersionsAsyncClient, info, *args, **kwargs) # type: ignore
@classmethod
def from_service_account_file(cls, filename: str, *args, **kwargs):
"""Creates an instance of this client using the provided credentials
file.
Args:
filename (str): The path to the service account private key json
file.
args: Additional arguments to pass to the constructor.
kwargs: Additional arguments to pass to the constructor.
Returns:
VersionsAsyncClient: The constructed client.
"""
return VersionsClient.from_service_account_file.__func__(VersionsAsyncClient, filename, *args, **kwargs) # type: ignore
from_service_account_json = from_service_account_file
@classmethod
def get_mtls_endpoint_and_cert_source(
cls, client_options: Optional[ClientOptions] = None
):
"""Return the API endpoint and client cert source for mutual TLS.
The client cert source is determined in the following order:
(1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
client cert source is None.
(2) if `client_options.client_cert_source` is provided, use the provided one; if the
default client cert source exists, use the default one; otherwise the client cert
source is None.
The API endpoint is determined in the following order:
(1) if `client_options.api_endpoint` if provided, use the provided one.
(2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
default mTLS endpoint; if the environment variabel is "never", use the default API
endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
use the default API endpoint.
More details can be found at https://google.aip.dev/auth/4114.
Args:
client_options (google.api_core.client_options.ClientOptions): Custom options for the
client. Only the `api_endpoint` and `client_cert_source` properties may be used
in this method.
Returns:
Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the
client cert source to use.
Raises:
google.auth.exceptions.MutualTLSChannelError: If any errors happen.
"""
return VersionsClient.get_mtls_endpoint_and_cert_source(client_options) # type: ignore
@property
def transport(self) -> VersionsTransport:
"""Returns the transport used by the client instance.
Returns:
VersionsTransport: The transport used by the client instance.
"""
return self._client.transport
get_transport_class = functools.partial(
type(VersionsClient).get_transport_class, type(VersionsClient)
)
def __init__(
self,
*,
credentials: ga_credentials.Credentials = None,
transport: Union[str, VersionsTransport] = "grpc_asyncio",
client_options: ClientOptions = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
) -> None:
"""Instantiates the versions client.
Args:
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
transport (Union[str, ~.VersionsTransport]): The
transport to use. If set to None, a transport is chosen
automatically.
client_options (ClientOptions): Custom options for the client. It
won't take effect if a ``transport`` instance is provided.
(1) The ``api_endpoint`` property can be used to override the
default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT
environment variable can also be used to override the endpoint:
"always" (always use the default mTLS endpoint), "never" (always
use the default regular endpoint) and "auto" (auto switch to the
default mTLS endpoint if client certificate is present, this is
the default value). However, the ``api_endpoint`` property takes
precedence if provided.
(2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
is "true", then the ``client_cert_source`` property can be used
to provide client certificate for mutual TLS transport. If
not provided, the default SSL client certificate will be used if
present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
set, no client certificate will be used.
Raises:
google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
creation failed for any reason.
"""
self._client = VersionsClient(
credentials=credentials,
transport=transport,
client_options=client_options,
client_info=client_info,
)
async def list_versions(
self,
request: Union[appengine.ListVersionsRequest, dict] = None,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> pagers.ListVersionsAsyncPager:
r"""Lists the versions of a service.
Args:
request (Union[google.cloud.appengine_admin_v1.types.ListVersionsRequest, dict]):
The request object. Request message for
`Versions.ListVersions`.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.cloud.appengine_admin_v1.services.versions.pagers.ListVersionsAsyncPager:
Response message for Versions.ListVersions.
Iterating over this object will yield results and
resolve additional pages automatically.
"""
# Create or coerce a protobuf request object.
request = appengine.ListVersionsRequest(request)
# Wrap the RPC method; this adds retry and timeout information,
# and friendly error handling.
rpc = gapic_v1.method_async.wrap_method(
self._client._transport.list_versions,
default_timeout=None,
client_info=DEFAULT_CLIENT_INFO,
)
# Certain fields should be provided within the metadata header;
# add these here.
metadata = tuple(metadata) + (
gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
)
# Send the request.
response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
# This method is paged; wrap the response in a pager, which provides
# an `__aiter__` convenience method.
response = pagers.ListVersionsAsyncPager(
method=rpc, request=request, response=response, metadata=metadata,
)
# Done; return the response.
return response
async def get_version(
self,
request: Union[appengine.GetVersionRequest, dict] = None,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> version.Version:
r"""Gets the specified Version resource. By default, only a
``BASIC_VIEW`` will be returned. Specify the ``FULL_VIEW``
parameter to get the full resource.
Args:
request (Union[google.cloud.appengine_admin_v1.types.GetVersionRequest, dict]):
The request object. Request message for
`Versions.GetVersion`.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.cloud.appengine_admin_v1.types.Version:
A Version resource is a specific set
of source code and configuration files
that are deployed into a service.
"""
# Create or coerce a protobuf request object.
request = appengine.GetVersionRequest(request)
# Wrap the RPC method; this adds retry and timeout information,
# and friendly error handling.
rpc = gapic_v1.method_async.wrap_method(
self._client._transport.get_version,
default_timeout=None,
client_info=DEFAULT_CLIENT_INFO,
)
# Certain fields should be provided within the metadata header;
# add these here.
metadata = tuple(metadata) + (
gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
)
# Send the request.
response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
# Done; return the response.
return response
async def create_version(
self,
request: Union[appengine.CreateVersionRequest, dict] = None,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> operation_async.AsyncOperation:
r"""Deploys code and resource files to a new version.
Args:
request (Union[google.cloud.appengine_admin_v1.types.CreateVersionRequest, dict]):
The request object. Request message for
`Versions.CreateVersion`.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.api_core.operation_async.AsyncOperation:
An object representing a long-running operation.
The result type for the operation will be :class:`google.cloud.appengine_admin_v1.types.Version` A Version resource is a specific set of source code and configuration files
that are deployed into a service.
"""
# Create or coerce a protobuf request object.
request = appengine.CreateVersionRequest(request)
# Wrap the RPC method; this adds retry and timeout information,
# and friendly error handling.
rpc = gapic_v1.method_async.wrap_method(
self._client._transport.create_version,
default_timeout=None,
client_info=DEFAULT_CLIENT_INFO,
)
# Certain fields should be provided within the metadata header;
# add these here.
metadata = tuple(metadata) + (
gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
)
# Send the request.
response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
# Wrap the response in an operation future.
response = operation_async.from_gapic(
response,
self._client._transport.operations_client,
version.Version,
metadata_type=ga_operation.CreateVersionMetadataV1,
)
# Done; return the response.
return response
async def update_version(
self,
request: Union[appengine.UpdateVersionRequest, dict] = None,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> operation_async.AsyncOperation:
r"""Updates the specified Version resource. You can specify the
following fields depending on the App Engine environment and
type of scaling that the version resource uses:
**Standard environment**
- ```instance_class`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.instance_class>`__
*automatic scaling* in the standard environment:
- ```automatic_scaling.min_idle_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
- ```automatic_scaling.max_idle_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
- ```automaticScaling.standard_scheduler_settings.max_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#StandardSchedulerSettings>`__
- ```automaticScaling.standard_scheduler_settings.min_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#StandardSchedulerSettings>`__
- ```automaticScaling.standard_scheduler_settings.target_cpu_utilization`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#StandardSchedulerSettings>`__
- ```automaticScaling.standard_scheduler_settings.target_throughput_utilization`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#StandardSchedulerSettings>`__
*basic scaling* or *manual scaling* in the standard environment:
- ```serving_status`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.serving_status>`__
- ```manual_scaling.instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#manualscaling>`__
**Flexible environment**
- ```serving_status`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.serving_status>`__
*automatic scaling* in the flexible environment:
- ```automatic_scaling.min_total_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
- ```automatic_scaling.max_total_instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
- ```automatic_scaling.cool_down_period_sec`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
- ```automatic_scaling.cpu_utilization.target_utilization`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version.FIELDS.automatic_scaling>`__
*manual scaling* in the flexible environment:
- ```manual_scaling.instances`` <https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#manualscaling>`__
Args:
request (Union[google.cloud.appengine_admin_v1.types.UpdateVersionRequest, dict]):
The request object. Request message for
`Versions.UpdateVersion`.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.api_core.operation_async.AsyncOperation:
An object representing a long-running operation.
The result type for the operation will be :class:`google.cloud.appengine_admin_v1.types.Version` A Version resource is a specific set of source code and configuration files
that are deployed into a service.
"""
# Create or coerce a protobuf request object.
request = appengine.UpdateVersionRequest(request)
# Wrap the RPC method; this adds retry and timeout information,
# and friendly error handling.
rpc = gapic_v1.method_async.wrap_method(
self._client._transport.update_version,
default_timeout=None,
client_info=DEFAULT_CLIENT_INFO,
)
# Certain fields should be provided within the metadata header;
# add these here.
metadata = tuple(metadata) + (
gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
)
# Send the request.
response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
# Wrap the response in an operation future.
response = operation_async.from_gapic(
response,
self._client._transport.operations_client,
version.Version,
metadata_type=ga_operation.OperationMetadataV1,
)
# Done; return the response.
return response
async def delete_version(
self,
request: Union[appengine.DeleteVersionRequest, dict] = None,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> operation_async.AsyncOperation:
r"""Deletes an existing Version resource.
Args:
request (Union[google.cloud.appengine_admin_v1.types.DeleteVersionRequest, dict]):
The request object. Request message for
`Versions.DeleteVersion`.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
google.api_core.operation_async.AsyncOperation:
An object representing a long-running operation.
The result type for the operation will be :class:`google.protobuf.empty_pb2.Empty` A generic empty message that you can re-use to avoid defining duplicated
empty messages in your APIs. A typical example is to
use it as the request or the response type of an API
method. For instance:
service Foo {
rpc Bar(google.protobuf.Empty) returns
(google.protobuf.Empty);
}
The JSON representation for Empty is empty JSON
object {}.
"""
# Create or coerce a protobuf request object.
request = appengine.DeleteVersionRequest(request)
# Wrap the RPC method; this adds retry and timeout information,
# and friendly error handling.
rpc = gapic_v1.method_async.wrap_method(
self._client._transport.delete_version,
default_timeout=None,
client_info=DEFAULT_CLIENT_INFO,
)
# Certain fields should be provided within the metadata header;
# add these here.
metadata = tuple(metadata) + (
gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
)
# Send the request.
response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,)
# Wrap the response in an operation future.
response = operation_async.from_gapic(
response,
self._client._transport.operations_client,
empty_pb2.Empty,
metadata_type=ga_operation.OperationMetadataV1,
)
# Done; return the response.
return response
async def __aenter__(self):
return self
async def __aexit__(self, exc_type, exc, tb):
await self.transport.close()
try:
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
gapic_version=pkg_resources.get_distribution(
"google-cloud-appengine-admin",
).version,
)
except pkg_resources.DistributionNotFound:
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
__all__ = ("VersionsAsyncClient",)
|
# FEWTURE-BOOM: do not report me (not an orphan)
# FEWTURE-I-AM-AN-ORPHAN: report me
# FEWTURE-I-AM-NOT-AN-ORPHAN: do not report me (pragma) no-check-fixmes
|
from machine import Pin
from time import sleep
# both esp8266 and esp32 have led on pin 2
led = Pin(2, Pin.OUT)
while True:
led.value(not led.value())
sleep(1)
|
from sys import path
path.append("../APTED/apted")
path.append("../ML_Models/ObjectDetection")
path.append("util/")
import caption_generator
import constants
import json
import requests
import datetime
import parse_show_tree
import urllib
from apted import APTED, PerEditOperationConfig
import apted.helpers as apth
import detect_objects
import random
def get_similar_images(query_image):
print("qik_search :: get_similar_images :: query_image :: ", query_image)
similar_images = {}
# Noting the time taken for further auditing.
time = datetime.datetime.now()
# Querying the backend to fetch the list of similar images.
cap_req = constants.SIMILAR_SEARCH_URL + query_image
cap_res_text = requests.get(cap_req).text
print("qik_search :: get_similar_images :: cap_res_text :: ", cap_res_text)
try:
# Converting the response to a JSON.
cap_res = json.loads(requests.get(cap_req).text)
# Shuffling the dictionary.
items = list(cap_res.items())
random.shuffle(items)
shuffled_cap_res = dict(items)
# Replacing the image URL with an updated URL.
for link in shuffled_cap_res:
caption = shuffled_cap_res[link]
updated_link = link.replace(constants.TOMCAT_OLD_IP_ADDR, constants.TOMCAT_IP_ADDR)
similar_images[updated_link] = caption
print("qik_search :: get_similar_images :: similar_images :: ", similar_images)
# Auditing the response time.
print("qik_search :: get_similar_images :: Execution time :: ", (datetime.datetime.now() - time))
except:
print("qik_search :: get_similar_images :: No similar images found.")
return similar_images
def qik_search(query_image, ranking_func=None, obj_det_enabled=False, pure_objects_search=False, fetch_count=None):
obj_res = None
cap_res = None
similar_images = None
captionRanksDict = {}
sortedCaptionRanksDict = {}
# Noting the time taken for further auditing.
time = datetime.datetime.now()
if obj_det_enabled:
# Initial Loading of the object detection model.
detect_objects.init()
# Detecting objects.
json_data = {}
json_data['objects'] = detect_objects.get_detected_objects(query_image, constants.OBJECT_DETECTED_THRESHOLD)
print("qik_search :: qik_search :: objects :: ", json_data['objects'])
# Querying the backend to fetch the list of images and captions based on the objects detected.
obj_req = constants.DETECT_OBJECTS_URL + urllib.parse.quote(str(json_data))
obj_res = json.loads(requests.get(obj_req).text)
print("qik_search :: qik_search :: obj_res :: ", obj_res)
if pure_objects_search:
if obj_res is not None:
# Forming the return image set.
for resMap in obj_res:
caption = resMap['caption']
image = resMap['fileURL']
# Temp Fix done to replace Tomcat IP. Needs to be handled in the IndexEngine.
image_path = image.replace(constants.TOMCAT_OLD_IP_ADDR, constants.TOMCAT_IP_ADDR)
captionRanksDict[image_path + ":: " + caption] = 1
print(captionRanksDict)
# Formating done for Ranking
sortedCaptionRanksDict = sorted(captionRanksDict.items(), key=lambda kv: kv[1], reverse=True)
# Auditing the QIK execution time.
print("QIK Execution time :: ", (datetime.datetime.now() - time))
if sortedCaptionRanksDict and fetch_count is not None:
print("sortedCaptionRanksDict :: ", sortedCaptionRanksDict[:fetch_count])
return "Query Image", sortedCaptionRanksDict[:fetch_count], None
else:
print("sortedCaptionRanksDict :: ", sortedCaptionRanksDict)
return "Query Image", sortedCaptionRanksDict, None
return "Query Image", sortedCaptionRanksDict, None
# Initial Loading of the caption generator model.
caption_generator.init()
# Generating the captions.
query = caption_generator.get_caption(query_image, True)
# Handling the fullstops in captions.
if query[-1] == '.':
query = query[:-1].strip()
print("Caption Generated :: ", query)
# Querying the backend to fetch the list of images and captions.
cap_req = constants.SOLR_QUERY_URL + query
cap_res = json.loads(requests.get(cap_req).text)
print("QIK Captions Response :: ", cap_res)
print("QIK Fetch Execution time :: ", (datetime.datetime.now() - time))
# Merging the two responses.
if obj_res is None:
res = cap_res
elif cap_res is None:
res = obj_res
else:
res = obj_res + cap_res
print("QIK Combined Response :: ", res)
# Forming the return image set.
if res is not None:
# Generating the parse tree for the input query.
queryParseTree = parse_show_tree.parseSentence(query)
# Generating the dependency tree for the input query.
queryDepTree = parse_show_tree.dependencyParser(query)
# Performing TED based Ranking on the parse tree.
if ranking_func == 'Parse Tree':
for resMap in res:
# for Auditing TED Time
ted_time = datetime.datetime.now()
image = resMap['fileURL']
caption = resMap['caption']
captionParseTree = resMap['parseTree']
parseTED = APTED(apth.Tree.from_text(queryParseTree), apth.Tree.from_text(captionParseTree),
PerEditOperationConfig(1, 1, 1)).compute_edit_distance()
# Temp Fix done to replace Tomcat IP. Needs to be handled in the IndexEngine.
image_path = image.replace(constants.TOMCAT_OLD_IP_ADDR, constants.TOMCAT_IP_ADDR)
captionRanksDict[image_path + ":: " + caption] = parseTED
# Sorting the results based on the Parse TED.
sortedCaptionRanksDict = sorted(captionRanksDict.items(), key=lambda kv: kv[1], reverse=False)
elif ranking_func == 'Dependency Tree':
for resMap in res:
# for Auditing TED Time
ted_time = datetime.datetime.now()
image = resMap['fileURL']
caption = resMap['caption']
depTree = resMap['depTree']
parseTED = APTED(apth.Tree.from_text(queryDepTree), apth.Tree.from_text(depTree),
PerEditOperationConfig(1, 1, 1)).compute_edit_distance()
# Temp Fix done to replace Tomcat IP. Needs to be handled in the IndexEngine.
image_path = image.replace(constants.TOMCAT_OLD_IP_ADDR, constants.TOMCAT_IP_ADDR)
captionRanksDict[image_path + ":: " + caption] = parseTED
# Sorting the results based on the Parse TED.
sortedCaptionRanksDict = sorted(captionRanksDict.items(), key=lambda kv: kv[1], reverse=False)
else:
# Forming the return image set (Without ranking)
for resMap in res:
caption = resMap['caption']
image = resMap['fileURL']
# Temp Fix done to replace Tomcat IP. Needs to be handled in the IndexEngine.
image_path = image.replace(constants.TOMCAT_OLD_IP_ADDR, constants.TOMCAT_IP_ADDR)
captionRanksDict[image_path + ":: " + caption] = 1
print(captionRanksDict)
# Formating done for Ranking
sortedCaptionRanksDict = sorted(captionRanksDict.items(), key=lambda kv: kv[1], reverse=True)
similar_images = get_similar_images(query)
print("qik_search :: qik_search :: similar_images :: ", similar_images)
# Auditing the QIK execution time.
print("QIK Execution time :: ", (datetime.datetime.now() - time))
if sortedCaptionRanksDict and fetch_count is not None:
print("sortedCaptionRanksDict :: ", sortedCaptionRanksDict[:fetch_count])
return query, sortedCaptionRanksDict[:fetch_count], similar_images
else:
print("sortedCaptionRanksDict :: ", sortedCaptionRanksDict)
return query, sortedCaptionRanksDict, similar_images
|
from flask_wtf import FlaskForm
from wtforms import StringField,SelectField,TextAreaField,SubmitField
from wtforms.validators import Required, Email
from wtforms import ValidationError
from ..models import Subscription
class UpdateProfile(FlaskForm):
bio = TextAreaField('Tell us about you.',validators = [Required()])
submit = SubmitField('Submit')
class BlogForm(FlaskForm):
title = StringField('Title',validators = [Required()])
description = TextAreaField('Description',validators = [Required()])
submit = SubmitField('submit')
class CommentForm(FlaskForm):
comment = TextAreaField('Leave a comment',validators=[Required()])
submit = SubmitField('Comment')
class UpdateBlogForm(FlaskForm):
title = StringField('Title',validators = [Required()])
description = TextAreaField('Description',validators = [Required()])
submit = SubmitField('submit')
class SubscriptionForm(FlaskForm):
email = StringField('Email',validators = [Required(),Email()])
submit = SubmitField('Submit')
def validate_email(self,data_field):
if Subscription.query.filter_by(email = data_field.data).first():
raise ValidationError('There is an account with that email')
def validate_name(self,data_field):
if Subscription.query.filter_by(name = data_field.data).first():
raise ValidationError('That name is taken')
|
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
"""
Implement experimental syncing methods.
"""
from __future__ import annotations
from meerschaum import Pipe
from meerschaum.plugins import add_plugin_argument, make_action
from meerschaum.utils.typing import Optional, Any, List, SuccessTuple
from collections import namedtuple
ErrorRow = namedtuple('ErrorRow', ('scenario', 'method', 'error'))
__version__ = '0.1.2'
required = [
'numpy', 'prime-sieve', 'dateutil', 'galois', 'matplotlib', 'duckdb',
]
add_plugin_argument(
'--sync-methods', nargs='+', help=(
"Sync methods to use. Defaults to ['join-new-ids']."
)
)
add_plugin_argument(
'--backtrack-minutes', type=int, help=(
"How many minutes to backtrack when fetching new data."
)
)
add_plugin_argument(
'--source', help="Connector keys to the source database (e.g. 'sql:main')"
)
add_plugin_argument(
'--target', help="Connector keys to the target database (e.g. 'sql:main')"
)
add_plugin_argument(
'--iterations', help="How many iterations to run per scenario and method (results will be averaged).",
type=int,
)
@make_action
def scenarios(
action: Optional[List[str]] = None,
source: Optional[str] = 'sql:memory',
target: Optional[str] = 'sql:memory',
sync_methods: Optional[List[str]] = None,
begin: Optional[datetime.datetime] = None,
end: Optional[datetime.datetime] = None,
iterations: Optional[int] = None,
debug: bool = False,
**kw
) -> SuccessTuple:
"""
Run synchronization scenario simulations.
"""
from .scenarios import (
init_scenarios, ITERATIONS_PER_SCENARIO_FM, SIMULATION_BEGIN, SIMULATION_INTERVAL
)
from .methods import fetch_methods as fetch_methods_dict, sync_methods as sync_methods_dict
from meerschaum.connectors.parse import parse_instance_keys
from meerschaum.utils.warnings import info
from meerschaum.utils.packages import import_pandas
from meerschaum.config._paths import PLUGINS_RESOURCES_PATH
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import duckdb
source_connector = parse_instance_keys(source)
target_connector = parse_instance_keys(target)
_scenarios = init_scenarios(source_connector, target_connector)
usage = "Usage: scenarios ['" + "', '".join(_scenarios.keys()) + "']"
if (
begin is not None and end is not None
and begin.month == end.month and begin.year == end.year
):
return False, "The interval needs to span across at least two months."
run_scenarios = action
if not run_scenarios:
run_scenarios = _scenarios.keys()
run_sync_methods = sync_methods if sync_methods else list(fetch_methods_dict.keys()) + list(sync_methods_dict.keys())
for scenario in run_scenarios:
if scenario not in _scenarios:
return False, usage
plugin_path = PLUGINS_RESOURCES_PATH / 'syncx'
scenarios_path = plugin_path / 'scenarios'
scenarios_path.mkdir(parents=True, exist_ok=True)
pd = import_pandas()
for scenario_name in run_scenarios:
scenario_path = scenarios_path / scenario_name
scenario_path.mkdir(parents=True, exist_ok=True)
figures_path = scenario_path / 'figures'
csv_path = scenario_path / 'csv'
figures_path.mkdir(parents=True, exist_ok=True)
csv_path.mkdir(parents=True, exist_ok=True)
info(f"Testing scenario '{scenario_name}'...")
drt_methods_dfs, rt_methods_dfs, er_methods_dfs, rer_methods_dfs, vl_methods_dfs, dvl_methods_dfs = [], [], [], [], [], []
for sm in run_sync_methods:
info(f"Testing sync method '{sm}'...")
combo_name = scenario_name + '_' + sm
runtimes_dfs = []
averages_dfs = []
errors_dfs = []
rel_errors_dfs = []
cumulative_volumes_dfs = []
daily_volumes_dfs = []
for i in range(ITERATIONS_PER_SCENARIO_FM if iterations is None else iterations):
info(f"Iteration #{i + 1} for scenario '{scenario_name}' with sync method '{sm}'.")
runtimes_data, errors_data, cumulative_volumes_data, daily_volumes_data = (
_scenarios[scenario_name].start(sm, begin=begin, end=end, debug=debug)
)
runtimes_df = pd.DataFrame(runtimes_data)
errors_df = pd.DataFrame(errors_data)[['Datetime', 'Errors']]
rel_errors_df = pd.DataFrame(errors_data)[['Datetime', 'Percent']]
cumulative_volumes_df = pd.DataFrame(cumulative_volumes_data)
daily_volumes_df = pd.DataFrame(daily_volumes_data)
runtimes_df[sm] = runtimes_df['Runtime']
runtimes_dfs.append(runtimes_df[['Datetime', sm]])
averages_dfs.append(
duckdb.query(
f"""
SELECT DATE_TRUNC('month', "Datetime"::DATE) AS 'Month', AVG(Runtime) AS '{sm}'
FROM runtimes_df
GROUP BY DATE_TRUNC('month', "Datetime"::DATE)
"""
).to_df()
)
errors_df[sm] = errors_df['Errors']
errors_dfs.append(errors_df[['Datetime', sm]])
rel_errors_df[sm] = rel_errors_df['Percent']
rel_errors_dfs.append(rel_errors_df[['Datetime', sm]])
cumulative_volumes_df[sm] = cumulative_volumes_df['Rows']
cumulative_volumes_dfs.append(cumulative_volumes_df[['Datetime', sm]])
daily_volumes_df[sm] = daily_volumes_df['Rows']
daily_volumes_dfs.append(daily_volumes_df[['Datetime', sm]])
drt_methods_dfs.append(pd.concat(runtimes_dfs).groupby(by='Datetime', as_index=False).mean())
rt_methods_dfs.append(pd.concat(averages_dfs).groupby(by='Month', as_index=False).mean())
er_methods_dfs.append(pd.concat(errors_dfs).groupby(by='Datetime', as_index=False).mean())
rer_methods_dfs.append(pd.concat(rel_errors_dfs).groupby(by='Datetime', as_index=False).mean())
vl_methods_dfs.append(pd.concat(cumulative_volumes_dfs).groupby(by='Datetime', as_index=False).mean())
dvl_methods_dfs.append(pd.concat(daily_volumes_dfs).groupby(by='Datetime', as_index=False).mean())
### We've tested all of the fetch methods for this scenario
### and now have a list of the average dataframes.
drt_figure_df = drt_methods_dfs[0]
for _df in drt_methods_dfs[1:]:
drt_figure_df = drt_figure_df.merge(_df)
rt_figure_df = rt_methods_dfs[0]
for _df in rt_methods_dfs[1:]:
rt_figure_df = rt_figure_df.merge(_df)
er_figure_df = er_methods_dfs[0]
for _df in er_methods_dfs[1:]:
er_figure_df = er_figure_df.merge(_df)
rer_figure_df = rer_methods_dfs[0]
for _df in rer_methods_dfs[1:]:
rer_figure_df = rer_figure_df.merge(_df)
vl_figure_df = vl_methods_dfs[0]
for _df in vl_methods_dfs[1:]:
vl_figure_df = vl_figure_df.merge(_df)
dvl_figure_df = dvl_methods_dfs[0]
for _df in dvl_methods_dfs[1:]:
dvl_figure_df = dvl_figure_df.merge(_df)
max_drt = max(drt_figure_df[run_sync_methods].max())
max_rt = max(rt_figure_df[run_sync_methods].max())
max_er = max(er_figure_df[run_sync_methods].max())
min_rer = max(min(rer_figure_df[run_sync_methods].min()) - 10, 0)
max_rer = min(max(rer_figure_df[run_sync_methods].max()), 100)
max_vl = max(vl_figure_df[run_sync_methods].max())
max_dvl = max(dvl_figure_df[run_sync_methods].max())
### Create one figure per scenario with all of the methods.
drt_ax = drt_figure_df.plot(x='Datetime')
drt_ax.set_ylim([0.0, max_drt + 0.1])
plt.ylabel("Seconds")
drt_ax.set_title(f"Daily Runtimes of Scenario '{scenario_name}'")
drt_figure_df.to_csv(csv_path / (scenario_name + '_daily_runtime.csv'))
plt.savefig(figures_path / (scenario_name + '_daily_runtime.png'), bbox_inches="tight")
rt_ax = rt_figure_df.plot(x='Month')
rt_ax.set_ylim([0.0, max_rt + 0.1])
plt.ylabel("Seconds")
rt_ax.set_title(f"Monthly Average Runtimes of Scenario '{scenario_name}'")
rt_figure_df.to_csv(csv_path / (scenario_name + '_monthly_runtime.csv'))
plt.savefig(figures_path / (scenario_name + '_monthly_runtime.png'), bbox_inches="tight")
er_ax = er_figure_df.plot(x='Datetime', kind='line')
er_ax.set_ylim([0.0, max_er + 10])
er_ax.xaxis.set_major_locator(mdates.MonthLocator())
er_ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
plt.ylabel("Missing Rows")
er_ax.set_title(f"Cumulative Errors of Scenario '{scenario_name}'")
er_figure_df.to_csv(csv_path / (scenario_name + '_errors.csv'))
plt.savefig(figures_path / (scenario_name + '_errors.png'), bbox_inches="tight")
rer_ax = rer_figure_df.plot(x='Datetime', kind='line')
rer_ax.set_ylim([min_rer, max_rer])
rer_ax.xaxis.set_major_locator(mdates.MonthLocator())
rer_ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
plt.ylabel("Accuracy Percentage")
rer_ax.set_title(f"Running Accuracy Rate of Scenario '{scenario_name}'")
rer_figure_df.to_csv(csv_path / (scenario_name + '_error_rate.csv'))
plt.savefig(figures_path / (scenario_name + '_error_rate.png'), bbox_inches="tight")
vl_ax = vl_figure_df.plot(x='Datetime', kind='line')
vl_ax.set_ylim([0, max_vl + 10])
vl_ax.xaxis.set_major_locator(mdates.MonthLocator())
vl_ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
plt.ylabel("Rows Transferred")
vl_ax.set_title(f"Cumulative Fetched Row Volume of Scenario '{scenario_name}'")
vl_figure_df.to_csv(csv_path / (scenario_name + '_cumulative_volume.csv'))
plt.savefig(figures_path / (scenario_name + '_cumulative_volume.png'), bbox_inches="tight")
dvl_ax = dvl_figure_df.plot(x='Datetime', kind='line')
dvl_ax.set_ylim([0, max_dvl + 10])
dvl_ax.xaxis.set_major_locator(mdates.MonthLocator())
dvl_ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
plt.ylabel("Rows Transferred")
dvl_ax.set_title(f"Daily Fetched Row Volume of Scenario '{scenario_name}'")
dvl_figure_df.to_csv(csv_path / (scenario_name + '_daily_volume.csv'))
plt.savefig(figures_path / (scenario_name + '_daily_volume.png'), bbox_inches="tight")
return True, "Success"
def sync(
pipe: Pipe,
sync_method: str = 'join-new-ids',
backtrack_minutes: Optional[int] = None,
with_extras: bool = False,
debug: bool = False,
**kw
) -> SuccessTuple:
"""
:param sync_method:
The method used to request new data based on the cache context.
"""
from meerschaum import Pipe
from meerschaum.utils.warnings import warn
from meerschaum.connectors.parse import parse_connector_keys
definition = pipe.parameters.get('fetch', {}).get('definition', None)
if definition is None:
warn(f"No definition for pipe '{pipe}'.")
return None
conn_keys = pipe.parameters.get('fetch', {}).get('connector', 'sql')
conn = parse_connector_keys(conn_keys)
_pipe = Pipe(instance=pipe.instance_connector, **pipe.meta)
_pipe._connector = conn
if backtrack_minutes is not None:
pipe.parameters['backtrack_minutes'] = backtrack_minutes
from .scenarios import empty_df
from .methods import fetch_methods, sync_methods
if sync_method not in sync_methods and sync_method not in fetch_methods:
warn(f"Invalid sync method '{sync_method}'.")
return None
### If not optimizations may be made, perform a naive sync.
if not pipe.exists(debug=debug):
return sync_methods['naive'](_pipe, with_extras=with_extras, debug=debug)
if sync_method in fetch_methods:
fetched_df = fetch_methods[sync_method](
_pipe,
debug = debug
)
filtered_df = (
_pipe.filter_existing(fetched_df, debug=debug)
if fetched_df is not None else empty_df()
)
success_tuple = _pipe.sync(filtered_df, check_existing=False, debug=debug)
if with_extras:
return success_tuple, filtered_df, fetched_df
return success_tuple
return sync_methods[sync_method](
_pipe,
with_extras = with_extras,
debug = debug,
**kw
)
|
from .expected_gradients import AttributionPriorExplainer
from .fixup import mixup_data, mixup_criterion
from .visualization import show_pil_image, pil_img, visualize_attrs |
#!/bin/env python
# -*- coding: utf8 -*-
import pymysql as pm
def check_and_connect(args):
if 'host' not in args or not args['host']:
raise AttributeError()
if 'user' not in args or not args['user']:
raise AttributeError()
if 'database' not in args or not args['database']:
raise AttributeError()
if 'password' not in args or not args['password']:
conn = pm.connect(host=args['host'], user=args['user'], database=args['database'], charset='utf8')
else:
conn = pm.connect(host=args['host'], user=args['user'],
password=args['password'], database=args['database'], charset='utf8')
return conn
def get_all_tables(conn):
cursor = conn.cursor()
cursor.execute('show tables')
tables = cursor.fetchall()
cursor.close()
return tables
def get_all_columns(conn, tablename):
cursor = conn.cursor()
cursor.execute('desc %s' %tablename)
columns = cursor.fetchall()
cursor.close()
return columns
def parse_columns(columns, camel_case):
fields = []
for col in columns:
line = col[1].split('(')
if len(line)>1:
type = line[0]
size = line[1][:-1]
else:
type = line[0].lower()
size = 0
if col[2].lower() == 'no':
nullstr = ', nullable=False'
else:
nullstr = ''
if col[3].lower() == 'pri':
prikeystr = ', primary_key=True'
else:
prikeystr = ''
if col[4]:
defaultstr = ', default=%s' %col[4]
else:
defaultstr = ''
if camel_case:
fieldname = camelCaseFieldName(col[0])
else:
fieldname = col[0]
if type in ('bit', 'bool'):
fieldstr = '%s = db.Column("%s", db.Boolean%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('tinyint', 'smallint', 'mediumint', 'int', 'integer', 'bigint'):
fieldstr = '%s = db.Column("%s", db.Integer%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('float', 'double'):
fieldstr = '%s = db.Column("%s", db.Float%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('char', 'varchar'):
if defaultstr:
dps = defaultstr.split('=')
defaultstr = dps[0] + "='" + dps[1] + "'"
fieldstr = '%s = db.Column("%s", db.String(%s)%s%s%s)' %(fieldname, col[0], size, prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('date'):
fieldstr = '%s = db.Column("%s", db.Date%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('time'):
fieldstr = '%s = db.Column("%s", db.Time%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('datetime', 'timestamp'):
fieldstr = '%s = db.Column("%s", db.DateTime%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('tinytext', 'text', 'mediumtext', 'longtext'):
if defaultstr:
dps = defaultstr.split('=')
defaultstr = dps[0] + "='" + dps[1] + "'"
fieldstr = '%s = db.Column("%s", db.Text%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr)
continue
if type in ('tinyblob', 'blob', 'mediumblob', 'longblob', 'binary', 'varbinary'):
fieldstr = '%s = db.Column("%s", db.LargeBinary%s%s%s)' %(fieldname, col[0], prikeystr, nullstr, defaultstr)
fields.append(fieldstr+'\n')
continue
return fields
def camelCaseClassName(s):
return ''.join(map(lambda x: x.capitalize(), s.split('_')))
def camelCaseFieldName(s):
fields = s.split('_')
return fields[0] + ''.join(map(lambda x: x.capitalize(), fields[1:]))
def write_entities(conn, tables, conf):
for tb in tables:
tn = tb[0]
if conf['tables'] and tn not in conf['tables']:
continue
if conf['exclude'] and tn in conf['exclude']:
continue
tn_ = tn
if conf['tableNamePrefix']:
for p in conf['tableNamePrefix']:
if tn.startswith(p):
tn_ = tn[len(p):]
if conf['toCamelCase']:
tn_ = camelCaseClassName(tn_)
import os
if not os.path.exists(conf['output']):
os.mkdir(conf['output'])
with open(conf['output']+'/'+tn_+'.py', 'w') as fn:
fn.write('''# -*- coding: utf8 -*-
from sqlalchemy_serializer import SerializerMixin as mixin
''')
fn.write('from %s import %s\n\n\n' %(conf['dbModule'], conf['dbVariable']))
fn.write('class %s(db.Model, mixin):\n' %tn_)
fn.write(' '*4 + '__tablename__ = "%s"\n\n' %tn)
fields = parse_columns(get_all_columns(conn, tn), conf['toCamelCase'])
for f in fields:
fn.write(' '*4+f+'\n')
fn.write('\n')
def parse_config(configfile):
import chardet
with open(configfile, 'rb') as fn:
data = fn.read()
lines = data.decode(chardet.detect(data)['encoding'])
import json
conf = json.JSONDecoder().decode(lines)
return conf
if __name__=='__main__':
import sys
if len(sys.argv) < 2:
print('Usage: python autogen.py [CONFIG JSON FILE]')
exit(-1)
conf = parse_config(sys.argv[1])
conf['host'] = conf['host'] if 'host' in conf else 'localhost'
conf['user'] = conf['user'] if 'user' in conf else 'root'
conf['password'] = conf['password'] if 'password' in conf else ''
conf['database'] = conf['database'] if 'database' in conf else 'test'
conf['output'] = conf['output'] if 'output' in conf else 'out_entities'
conf['dbModule'] = conf['dbModule'] if 'dbModule' in conf else 'app'
conf['dbVariable'] = conf['dbVariable'] if 'dbVariable' in conf else 'db'
conf['tableNamePrefix'] = conf['tableNamePrefix'] if 'tableNamePrefix' in conf else None
conf['tables'] = conf['tables'] if 'tables' in conf else None
conf['exclude'] = conf['exclude'] if 'exclude' in conf else None
conf['toCamelCase'] = conf['toCamelCase'] if 'toCamelCase' in conf else True
conn = check_and_connect(conf)
tables = get_all_tables(conn)
write_entities(conn, tables, conf)
conn.close()
|
# GIS4WRF (https://doi.org/10.5281/zenodo.1288569)
# Copyright (c) 2018 D. Meyer and M. Riechert. Licensed under MIT.
from typing import Tuple, Callable
import os
import re
from functools import partial
from gis4wrf.core.util import export, gdal, get_temp_dir, get_temp_vsi_path, remove_dir, remove_vsis
from gis4wrf.core.crs import CRS, LonLat
from gis4wrf.core.readers.wps_binary_index import read_wps_binary_index_file
from .categories_to_gdal import get_gdal_categories
@export
def convert_wps_binary_to_vrt_dataset(folder: str, use_vsi: bool=False) -> Tuple[str,str,str,Callable[[],None]]:
"""Converts a WPS Binary format dataset into a mosaic VRT dataset referencing per-tile VRT datasets."""
m = read_wps_binary_index_file(folder)
if m.proj_id == 'regular_ll' and m.stdlon is not None:
raise NotImplementedError('stdlon not supported for regular_ll')
# scan folder for available tiles
tile_filename_re = re.compile('^({d})-({d})\.({d})-({d})$'.format(d='\d{' + str(m.filename_digits) + '}'))
tiles = []
for filename in os.listdir(folder):
match = tile_filename_re.match(filename)
if match:
tiles.append({
'filename': filename,
'path': os.path.join(folder, filename),
'start_x': int(match.group(1)),
'end_x': int(match.group(2)),
'start_y': int(match.group(3)),
'end_y': int(match.group(4))
})
if not tiles:
raise ValueError('No tiles found')
# determine raster dimensions
xsize = max(tile['end_x'] for tile in tiles) # type: int
ysize = max(tile['end_y'] for tile in tiles) # type: int
zsize = m.tile_z_end - m.tile_z_start + 1
# convert to GDAL metadata
dtype_mapping = {
(1, False): gdal.GDT_Byte, # GDAL only supports unsigned byte
(2, False): gdal.GDT_UInt16,
(2, True): gdal.GDT_Int16,
(3, False): gdal.GDT_UInt32,
(3, True): gdal.GDT_Int32
}
try:
dtype = dtype_mapping[(m.word_size, m.signed)]
except KeyError:
raise ValueError('word_size/signed combination not supported')
if m.proj_id == 'regular_ll':
crs = CRS.create_lonlat()
elif m.proj_id == 'lambert':
# It doesn't matter what the origin is. This only influences the
# projection coordinates to which the data is anchored to but the
# georeferencing itself does not change. See down below on how
# the geo transform is computed based on the known geographical
# coordinates in the data.
origin = LonLat(lon=m.stdlon, lat=(m.truelat1+m.truelat2)/2)
crs = CRS.create_lambert(m.truelat1, m.truelat2, origin)
elif m.proj_id == 'mercator':
# See comment above about origin.
origin_lon = m.stdlon if m.stdlon is not None else 0
crs = CRS.create_mercator(m.truelat1, origin_lon)
elif proj_id == 'albers_nad83':
# See comment above about origin.
origin = LonLat(lon=m.stdlon, lat=(m.truelat1+m.truelat2)/2)
crs = CRS.create_albers_nad83(m.truelat1, m.truelat2, origin)
# FIXME handle polar vs polar_wgs84 differently
elif m.proj_id == 'polar':
crs = CRS.create_polar(m.truelat1, m.stdlon)
elif m.proj_id == 'polar_wgs84':
crs = CRS.create_polar(m.truelat1, m.stdlon)
else:
raise NotImplementedError('Unsupported projection')
known_x_idx_gdal = m.known_idx.x - 0.5
if m.top_bottom:
known_y_idx_gdal = ysize - m.known_idx.y - 0.5
dy_gdal = -m.dy
else:
known_y_idx_gdal = m.known_idx.y - 0.5
dy_gdal = m.dy
known_xy = crs.to_xy(m.known_lonlat)
upper_left_x = known_xy.x - known_x_idx_gdal * m.dx
upper_left_y = known_xy.y + known_y_idx_gdal * m.dy
geo_transform = (upper_left_x, m.dx, 0, upper_left_y, 0, dy_gdal)
# print('known_x_idx_gdal: {}'.format(known_x_idx_gdal))
# print('known_y_idx_gdal: {}'.format(known_y_idx_gdal))
# print('known_xy: {}'.format(m.known_xy))
# print('upper_left_x: {}'.format(upper_left_x))
# print('upper_left_y: {}'.format(upper_left_y))
# VRTRawRasterBand metadata
line_width = m.word_size * (m.tile_x + m.tile_bdr * 2) # x size incl. border
tile_size = line_width * (m.tile_y + m.tile_bdr * 2) # tile size incl. border
line_offset = line_width
image_offset = m.tile_bdr * line_width + m.tile_bdr * m.word_size
pixel_offset = m.word_size
byte_order = 'LSB' if m.little_endian else 'MSB'
# create tile VRTs
if use_vsi:
out_dir = get_temp_vsi_path(ext='')
else:
out_dir = get_temp_dir()
driver = gdal.GetDriverByName('VRT') # type: gdal.Driver
tile_vrt_paths = {}
for tile in tiles:
vsi_path = '{}/{}.vrt'.format(out_dir, tile['filename'])
vrt = driver.Create(vsi_path, m.tile_x, m.tile_y, 0) # type: gdal.Dataset
for z in range(m.tile_z_start - 1, m.tile_z_end):
options = [
'subClass=VRTRawRasterBand',
'SourceFilename={}'.format(tile['path']),
'relativeToVRT=0',
'ImageOffset={}'.format(z * tile_size + image_offset),
'PixelOffset={}'.format(pixel_offset),
'LineOffset={}'.format(line_offset),
'ByteOrder=' + byte_order
]
vrt.AddBand(dtype, options)
vrt.FlushCache()
tile_vrt_paths[tile['filename']] = vsi_path
# create mosaic VRT
mosaic_vrt_path = '{}/mosaic.vrt'.format(out_dir)
vrt = driver.Create(mosaic_vrt_path, xsize, ysize, zsize, dtype) # type: gdal.Dataset
vrt.SetProjection(crs.proj4)
vrt.SetGeoTransform(geo_transform)
if m.categorical:
color_table, cat_names = get_gdal_categories(m.categories, m.category_min, m.category_max)
for band_idx in range(1, zsize + 1):
band = vrt.GetRasterBand(band_idx) # type: gdal.Band
if m.missing_value is not None:
band.SetNoDataValue(m.missing_value)
band.SetScale(m.scale_factor)
if m.categorical:
band.SetRasterColorInterpretation(gdal.GCI_PaletteIndex)
band.SetRasterColorTable(color_table)
band.SetRasterCategoryNames(cat_names)
sources = {}
for idx, tile in enumerate(tiles):
tile_vrt_path = tile_vrt_paths[tile['filename']]
if m.top_bottom:
end_y = ysize - tile['start_y'] - 1
start_y = end_y - m.tile_y + 1
else:
start_y = tile['start_y'] - 1
sources['source_{}'.format(idx)] = ('''
<SimpleSource>
<SourceFilename relativeToVRT="0">{path}</SourceFilename>
<SourceBand>{band}</SourceBand>
<SrcRect xOff="0" yOff="0" xSize="{tile_x}" ySize="{tile_y}" />
<DstRect xOff="{offset_x}" yOff="{offset_y}" xSize="{tile_x}" ySize="{tile_y}" />
</SimpleSource>''').format(
path=tile_vrt_path, band=band_idx,
tile_x=m.tile_x, tile_y=m.tile_y,
offset_x=tile['start_x']-1, offset_y=start_y)
band.SetMetadata(sources, 'vrt_sources')
vrt.FlushCache()
vrt_paths = [mosaic_vrt_path] + list(tile_vrt_paths.values())
if use_vsi:
dispose = partial(remove_vsis, vrt_paths)
else:
dispose = partial(remove_dir, out_dir)
short_name = os.path.basename(folder)
title = short_name
if m.units and m.units != 'category':
title += ' in ' + m.units
if m.description:
title += ' (' + m.description + ')'
# The title is returned as VRT does not support dataset descriptions.
return mosaic_vrt_path, title, short_name, dispose
|
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# This script reuses some code from https://github.com/nlpyang/BertSum
"""
Utility functions for downloading, extracting, and reading the
CNN/DM dataset at https://github.com/harvardnlp/sent-summary.
"""
from textsumm.models.transformers.datasets import (
SummarizationDataset,
IterableSummarizationDataset,
)
from textsumm.dataset.url_utils import (
maybe_download,
maybe_download_googledrive,
extract_zip,
)
from torchtext.utils import extract_archive
import regex as re
import os
from nltk.tokenize.treebank import TreebankWordDetokenizer
from nltk import tokenize
import nltk
nltk.download("punkt")
# have to move these local functions outside due to use of pool of processes
REMAP = {
"-lrb-": "(",
"-rrb-": ")",
"-lcb-": "{",
"-rcb-": "}",
"-lsb-": "[",
"-rsb-": "]",
"``": '"',
"''": '"',
}
def _clean(x):
return re.sub(
r"-lrb-|-rrb-|-lcb-|-rcb-|-lsb-|-rsb-|``|''", lambda m: REMAP.get(
m.group()), x,
)
def _remove_ttags(line):
line = re.sub(r"<t>", "", line)
# change </t> to <q>
# pyrouge test requires <q> as sentence splitter
line = re.sub(r"</t>", "<q>", line)
return line
def _target_sentence_tokenization(line):
return line.split("<q>")
def join(sentences):
return " ".join(sentences)
def CNNDMSummarizationDataset(*args, **kwargs):
"""Load the CNN/Daily Mail dataset preprocessed by harvardnlp group."""
URLS = ["https://s3.amazonaws.com/opennmt-models/Summary/cnndm.tar.gz"]
def _setup_datasets(
url, top_n=-1, local_cache_path=".data", prepare_extractive=True
):
FILE_NAME = "cnndm.tar.gz"
maybe_download(url, FILE_NAME, local_cache_path)
dataset_tar = os.path.join(local_cache_path, FILE_NAME)
extracted_files = extract_archive(dataset_tar)
for fname in extracted_files:
if fname.endswith("train.txt.src"):
train_source_file = fname
if fname.endswith("train.txt.tgt.tagged"):
train_target_file = fname
if fname.endswith("test.txt.src"):
test_source_file = fname
if fname.endswith("test.txt.tgt.tagged"):
test_target_file = fname
if prepare_extractive:
return (
SummarizationDataset(
train_source_file,
target_file=train_target_file,
source_preprocessing=[_clean, tokenize.sent_tokenize],
target_preprocessing=[
_clean,
_remove_ttags,
_target_sentence_tokenization,
],
word_tokenize=nltk.word_tokenize,
top_n=top_n,
),
SummarizationDataset(
test_source_file,
target_file=test_target_file,
source_preprocessing=[_clean, tokenize.sent_tokenize],
target_preprocessing=[
_clean,
_remove_ttags,
_target_sentence_tokenization,
],
word_tokenize=nltk.word_tokenize,
top_n=top_n,
),
)
else:
return (
SummarizationDataset(
train_source_file,
target_file=train_target_file,
source_preprocessing=[_clean, tokenize.sent_tokenize],
target_preprocessing=[
_clean,
_remove_ttags,
_target_sentence_tokenization,
],
top_n=top_n,
),
SummarizationDataset(
test_source_file,
target_file=test_target_file,
source_preprocessing=[_clean, tokenize.sent_tokenize],
target_preprocessing=[
_clean,
_remove_ttags,
_target_sentence_tokenization,
],
top_n=top_n,
),
)
return _setup_datasets(*((URLS[0],) + args), **kwargs)
class CNNDMBertSumProcessedData:
"""Class to load dataset preprocessed by BertSum paper at
https://github.com/nlpyang/BertSum
"""
@staticmethod
def download(local_path=".data"):
FILE_ID = "1x0d61LP9UAN389YN00z0Pv-7jQgirVg6"
FILE_NAME = "bertsum_data.zip"
os.makedirs(local_path, exist_ok=True)
output_dir = os.path.join(local_path, "processed_data")
os.makedirs(output_dir, exist_ok=True)
maybe_download_googledrive(
google_file_id=FILE_ID, file_name=FILE_NAME, work_directory=local_path
)
extract_zip(
file_path=os.path.join(local_path, FILE_NAME), dest_path=output_dir,
)
return output_dir
def detokenize(line):
"""
Detokenizes the processed CNN/DM dataset to recover the original dataset,
e.g. converts "-LRB-" back to "(" and "-RRB-" back to ")".
"""
line = line.strip().replace("``", '"').replace("''", '"').replace("`", "'")
twd = TreebankWordDetokenizer()
s_list = [
twd.detokenize(x.strip().split(" "), convert_parentheses=True)
for x in line.split("<S_SEP>")
]
return " ".join(s_list)
def CNNDMSummarizationDatasetOrg(
local_path=".", top_n=-1, return_iterable=False, return_dev_data=False
):
"""
Downloads a version of the CNN/DailyMail dataset with minimal processing
from https://github.com/microsoft/unilm/tree/master/unilm-v1
This version of the CNN/DM dataset was originally downloaded from
https://github.com/harvardnlp/sent-summary
and preprocessed following https://github.com/abisee/cnn-dailymail.
Args:
local_path (str): Path to store the downloaded data. If the data file
doesn't exist in this path, it's downloaded and unzipped.
top_n (int): Number of lines to read. Defaults to -1 and the entire dataset
is read.
return_iterable (bool): If False, returns SummarizationDataset.
If True, returns IterableSummarizationDataset. Defaults to False.
return_dev_data (bool): if False, returns train and test data splits.
If True, returns train, test, and dev data splits. Defaults to False.
Returns:
tuple: tuple containing train, test (, and dev) datasets.
"""
# Download and unzip the data
FILE_ID = "1jiDbDbAsqy_5BM79SmX6aSu5DQVCAZq1"
FILE_NAME = "cnndm_data.zip"
output_dir = os.path.join(local_path, "cnndm_data")
os.makedirs(output_dir, exist_ok=True)
# This folder contains the a version of the dataset with minimal processing
org_data_dir = os.path.join(output_dir, "org_data")
expected_data_files = set(
[
"train.src",
"org_data",
"dev.src",
"test.tgt",
"train.tgt",
"dev.tgt",
"test.src",
]
)
expected_org_data_files = set(
[
"training.summary",
"test.article",
"dev.article",
"training.article",
"dev.summary",
"test.summary",
]
)
maybe_download_googledrive(
google_file_id=FILE_ID, file_name=FILE_NAME, work_directory=local_path
)
if (
set(os.listdir(output_dir)) != expected_data_files
or set(os.listdir(org_data_dir)) != expected_org_data_files
):
extract_zip(
file_path=os.path.join(local_path, FILE_NAME),
dest_path=output_dir,
)
train_source_file = os.path.join(org_data_dir, "training.article")
train_target_file = os.path.join(org_data_dir, "training.summary")
test_source_file = os.path.join(org_data_dir, "test.article")
test_target_file = os.path.join(org_data_dir, "test.summary")
dev_source_file = os.path.join(org_data_dir, "dev.article")
dev_target_file = os.path.join(org_data_dir, "dev.summary")
source_preprocessing = [detokenize]
target_preprocessing = [detokenize]
if return_iterable:
train_dataset = IterableSummarizationDataset(
source_file=train_source_file,
target_file=train_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
test_dataset = IterableSummarizationDataset(
source_file=test_source_file,
target_file=test_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
else:
train_dataset = SummarizationDataset(
source_file=train_source_file,
target_file=train_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
test_dataset = SummarizationDataset(
source_file=test_source_file,
target_file=test_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
if return_dev_data:
if return_iterable:
dev_dataset = IterableSummarizationDataset(
source_file=dev_source_file,
target_file=dev_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
else:
dev_dataset = SummarizationDataset(
source_file=dev_source_file,
target_file=dev_target_file,
source_preprocessing=source_preprocessing,
target_preprocessing=target_preprocessing,
top_n=top_n,
)
return train_dataset, test_dataset, dev_dataset
else:
return train_dataset, test_dataset
|
#!/usr/bin/env python
import sys
import pcapy
from scapy import *
from impacket.ImpactDecoder import *
try:
conf.verb=0
except NameError:
# Scapy v2
from scapy.all import *
conf.verb=0
if len(sys.argv) != 2:
print "Usage: ./replay.py <iface>"
sys.exit(1)
interface=sys.argv[1]
max_bytes = 2048
promiscuous = False
read_timeout = 100 # in milliseconds
packet_limit = -1 # infinite
pc = pcapy.open_live(interface, max_bytes, promiscuous, read_timeout)
def recv_pkts(hdr, data):
replay = True
if data[11] == "\xFF":
return
# separate ethernet header and ieee80211 packet
raw_header = data[:11] + "\xFF" + data[12:14]
header = Ether(raw_header)
try:
# end of separation
packet = Dot11(data[14:])
except struct.error:
# Ignore unpack errors on short packages
return
# manipulate/drop/insert dot11 packet
print packet.summary()
# end of manipulation
# construct packet and replay
if replay == True:
data = header/packet
sendp(data, iface=interface)
pc.loop(packet_limit, recv_pkts) # capture packets
|
from arch.api.utils import log_utils
from arch.api.proto import feature_scale_meta_pb2
from arch.api.proto import feature_scale_param_pb2
from arch.api.model_manager import manager as model_manager
from federatedml.feature.min_max_scaler import MinMaxScaler
from federatedml.feature.standard_scaler import StandardScaler
from federatedml.util import consts
LOGGER = log_utils.getLogger()
class Scaler(object):
"""
The Scaler class is used to data scale. MinMaxScale and StandardScale is supported now
"""
def __init__(self, scale_param):
"""
Parameters
----------
scale_param: object, the parameters of scale
"""
self.scale_param = scale_param
self.cols_scale_value = None
self.mean = None
self.std = None
self.class_name = self.__class__.__name__
def fit(self, data):
"""
Apply scale for input data
Parameters
----------
data: data_instance, input data
Returns
----------
data:data_instance, data after scale
scale_value_results: list, the fit results information of scale
"""
LOGGER.info("Start scale data fit ...")
scale_value_results = []
self.header = data.schema.get('header')
if self.scale_param.method == consts.MINMAXSCALE:
min_max_scaler = MinMaxScaler(mode=self.scale_param.mode, area=self.scale_param.area,
feat_upper=self.scale_param.feat_upper,
feat_lower=self.scale_param.feat_lower,
out_upper=self.scale_param.out_upper, out_lower=self.scale_param.out_lower)
data, cols_scale_value = min_max_scaler.fit(data)
scale_value_results.append(cols_scale_value)
self.cols_scale_value = cols_scale_value
elif self.scale_param.method == consts.STANDARDSCALE:
standard_scaler = StandardScaler(with_mean=self.scale_param.with_mean, with_std=self.scale_param.with_std)
data, mean, std = standard_scaler.fit(data)
scale_value_results.append(mean)
scale_value_results.append(std)
self.mean = mean
self.std = std
else:
LOGGER.info("Scale method is {}, do nothing and return!".format(self.scale_param.method))
data.schema['header'] = self.header
LOGGER.info("End fit data ...")
return data, scale_value_results
def transform(self, data, fit_config):
"""
Transform input data using scale with fit results
Parameters
----------
data: data_instance, input data
fit_config: list, the fit results information of scale
Returns
----------
transform_data:data_instance, data after transform
"""
LOGGER.info("Start scale data transform ...")
if len(fit_config) == 0:
LOGGER.warning("length fit_config is 0, can not do transform, do nothing and return")
if self.scale_param.method == consts.MINMAXSCALE:
min_max_scaler = MinMaxScaler()
data = min_max_scaler.transform(data, fit_config[0])
elif self.scale_param.method == consts.STANDARDSCALE:
standard_scaler = StandardScaler()
data = standard_scaler.transform(data, mean=fit_config[0], scale=fit_config[1])
else:
LOGGER.info("DataTransform method is {}, do nothing and return!".format(self.scale_param.method))
LOGGER.info("End transform data ...")
return data
def _save_min_max_meta(self, name, namespace):
if self.scale_param.area == consts.ALL:
LOGGER.debug("save_min_max_meta with mode is all")
feat_upper = "None" if self.scale_param.feat_upper is None else str(self.scale_param.feat_upper)
feat_lower = "None" if self.scale_param.feat_lower is None else str(self.scale_param.feat_lower)
out_upper = "None" if self.scale_param.out_upper is None else str(self.scale_param.out_upper)
out_lower = "None" if self.scale_param.out_lower is None else str(self.scale_param.out_lower)
min_max_scale_meta = feature_scale_meta_pb2.MinMaxScaleMeta(feat_upper=feat_upper,
feat_lower=feat_lower,
out_upper=out_upper,
out_lower=out_lower)
minmax_scale_meta = {"0": min_max_scale_meta}
meta_protobuf_obj = feature_scale_meta_pb2.ScaleMeta(is_scale=True,
strategy=self.scale_param.method,
minmax_scale_meta=minmax_scale_meta)
else:
LOGGER.debug("save_min_max_meta with mode is {}".format(self.scale_param.mode))
meta_protobuf_obj = feature_scale_meta_pb2.ScaleMeta(is_scale=True)
buffer_type = "{}.meta".format(self.class_name)
model_manager.save_model(buffer_type=buffer_type,
proto_buffer=meta_protobuf_obj,
name=name,
namespace=namespace)
return buffer_type
def save_min_max_model(self, name, namespace):
"""
Save MinMaxScaler param and meta
Parameters
----------
name: str, save DTable table_name
namespace: str, DTable namespace
Returns
----------
tuple,
include meta string name and param string name
"""
meta_buffer_type = self._save_min_max_meta(name, namespace)
min_max_scale_param_dict = {}
if self.cols_scale_value is not None:
for i in range(len(self.header)):
feat_lower = self.cols_scale_value[i][0]
feat_upper = self.cols_scale_value[i][1]
out_lower = self.cols_scale_value[i][2]
out_upper = self.cols_scale_value[i][3]
param_obj = feature_scale_param_pb2.MinMaxScaleParam(feat_upper=feat_upper,
feat_lower=feat_lower,
out_upper=out_upper,
out_lower=out_lower)
min_max_scale_param_dict[self.header[i]] = param_obj
param_protobuf_obj = feature_scale_param_pb2.ScaleParam(minmax_scale_param=min_max_scale_param_dict)
param_buffer_type = "{}.param".format(self.class_name)
model_manager.save_model(buffer_type=param_buffer_type,
proto_buffer=param_protobuf_obj,
name=name,
namespace=namespace)
return [(meta_buffer_type, param_buffer_type)]
def _save_standard_scale_meta(self, name, namespace):
with_mean = self.scale_param.with_mean
with_std = self.scale_param.with_std
standard_scale_meta = feature_scale_meta_pb2.StandardScaleMeta(with_mean=with_mean, with_std=with_std)
meta_protobuf_obj = feature_scale_meta_pb2.ScaleMeta(is_scale=True,
strategy=self.scale_param.method,
standard_scale_meta=standard_scale_meta)
buffer_type = "{}.meta".format(self.class_name)
model_manager.save_model(buffer_type=buffer_type,
proto_buffer=meta_protobuf_obj,
name=name,
namespace=namespace)
return buffer_type
def save_standard_scale_model(self, name, namespace):
"""
Save StandardScaler param and meta
Parameters
----------
name: str, save DTable table_name
namespace: str, DTable namespace
Returns
----------
tuple,
include meta string name and param string name
"""
meta_buffer_type = self._save_standard_scale_meta(name, namespace)
standard_scale_param_dict = {}
for i in range(len(self.header)):
mean = self.mean[i]
std = self.std[i]
param_obj = feature_scale_param_pb2.StandardScaleParam(mean=mean, scale=std)
standard_scale_param_dict[self.header[i]] = param_obj
param_protobuf_obj = feature_scale_param_pb2.ScaleParam(standard_scale_param=standard_scale_param_dict)
param_buffer_type = "{}.param".format(self.class_name)
model_manager.save_model(buffer_type=param_buffer_type,
proto_buffer=param_protobuf_obj,
name=name,
namespace=namespace)
return [(meta_buffer_type, param_buffer_type)]
def save_model(self, name, namespace):
"""
Save Scaler param and meta
Parameters
----------
name: str, save DTable table_name
namespace: str, DTable namespace
Returns
----------
tuple,
include meta string name and param string name
"""
if self.scale_param.method == consts.MINMAXSCALE:
LOGGER.debug("save min_max scale model")
return self.save_min_max_model(name, namespace)
elif self.scale_param.method == consts.STANDARDSCALE:
LOGGER.debug("save standard scale model")
return self.save_standard_scale_model(name, namespace)
else:
LOGGER.debug("can not save {} model".format(self.scale_param.method))
return None
def load_model(self, name, namespace, header):
"""
load Scaler model
Parameters
----------
name: str, DTable table_name
namespace: str, DTable namespace
Returns
----------
list,
scale information
"""
self.header = header
param_buffer_type = "{}.param".format(self.class_name)
param_obj = feature_scale_param_pb2.ScaleParam()
model_manager.read_model(buffer_type=param_buffer_type,
proto_buffer=param_obj,
name=name,
namespace=namespace)
if self.scale_param.method == consts.MINMAXSCALE:
cols_scale_value = []
param_dict = param_obj.minmax_scale_param
for idx, header_name in enumerate(self.header):
if header_name in param_dict:
feat_upper = param_dict[header_name].feat_upper
feat_lower = param_dict[header_name].feat_lower
out_upper = param_dict[header_name].out_upper
out_lower = param_dict[header_name].out_lower
cols_scale_value.append((feat_lower,
feat_upper,
out_lower,
out_upper))
else:
raise ValueError("Can not find the header name {} in model.".format(header_name))
model_scale_value_results = [ cols_scale_value ]
elif self.scale_param.method == consts.STANDARDSCALE:
mean = []
std = []
param_dict = param_obj.standard_scale_param
for idx, header_name in enumerate(self.header):
if header_name in param_dict:
mean.append(param_dict[header_name].mean)
std.append(param_dict[header_name].scale)
else:
raise ValueError("Can not find the header name {} in model.".format(header_name))
model_scale_value_results = [ mean, std ]
else:
raise ValueError("Unknown scale method:{}".format(self.scale_param.method))
return model_scale_value_results
|
from django.urls import path
from .import views
urlpatterns=[
path('',views.index,name='index'),
path('register',views.register,name='register'),
path('login',views.login,name='login'),
path('data',views.data,name='data'),
path('predict',views.predict,name='predict'),
path('logout',views.logout,name='logout')
] |
import html
import arrow
from bs4 import BeautifulSoup
from jinja2 import Template
from digesters.base_digester import BaseDigester
class RedditNotificationDigester(BaseDigester):
def __init__(self, store_writer, userId):
super(RedditNotificationDigester, self).__init__()
self.store_writer = store_writer
self.userId = userId
self.new_message_count = 0
self.new_articles = 0
self.reddit_notifications = self.store_writer.get_from_binary("reddit-notifications")
if self.reddit_notifications is None:
self.reddit_notifications = {}
self.most_recently_seen = self.store_writer.get_from_binary("reddit-recently-seen")
if self.most_recently_seen is None:
self.most_recently_seen = 0
self.new_notifications = {}
self.previously_notified_article_count = len(self.reddit_notifications)
if self.previously_notified_article_count > 0:
self.previously_notified_article_most_recent = max(self.reddit_notifications)
else:
self.previously_notified_article_most_recent = 0
def process_new_notification(self, rfc822content, msg, html_message, text_message):
unescapedHtml = html.unescape(html_message.decode("UTF-8"))
unescapedHtml = unescapedHtml.replace('<!-- Main -->', '<div id="mmain"><div class="mmessage">')
unescapedHtml = unescapedHtml.replace('<!-- Separator -->', '</div>')
unescapedHtml = unescapedHtml.replace('<!-- END Main -->', '</div>')
unescapedHtml = unescapedHtml.replace('<!-- Button -->', '</div>')
unescapedHtml = unescapedHtml.replace('<!-- END Separator -->', '<div class="mmessage">')
unescapedHtml = unescapedHtml.replace('<hr>', '<hr/>')
soup = BeautifulSoup(unescapedHtml, 'html.parser')
forr = soup.find("strong", attrs = {"class": "call-to-action"}).text.split(" for u/")[1]
if (forr != self.userId):
return False
self.new_message_count += 1
whenStr = arrow.get(msg['Date'].split(',', 1)[1].strip(), 'D MMM YYYY HH:mm:ss ZZ')
when = whenStr.timestamp
anchors = soup.findAll("a")
for anchor in anchors:
href_ = anchor["href"]
if anchor.text == "a thread":
newtag = soup.new_tag("span")
newtag.string = " a Thread "
anchor.insert_before(newtag)
anchor.decompose()
elif "/comments/" in href_:
newtag = soup.new_tag("div")
endIx = href_.find("/?context=")
endIx = href_[0:endIx].rfind("/")
newtag.string = " on " + href_[href_.find("/r/"):endIx] + " "
anchor.wrap(newtag)
mmain = soup.find("div", attrs={"id": "mmain"})
messagesHtml = str(BeautifulSoup(mmain.decode_contents(), 'html.parser'))
messagesHtml = messagesHtml[0: messagesHtml.rfind("<!-- Button -->")]
messages = BeautifulSoup(messagesHtml, 'html.parser').findAll("div", attrs = {"class": "mmessage"})
for ctr, message in enumerate(messages):
messageHtml = str(message)
if len(messageHtml) > len('<div class="mmessage">\\n</div>'):
self.reddit_notifications[when + ctr/10] = {
"message": messageHtml
}
return True
def rewrite_digest_emails(self, digest_folder_proxy, has_previous_message, previously_seen, sender_to_implicate):
if self.previously_notified_article_count == len(self.reddit_notifications):
return
# Deleted email (by the user) means they don't want to see THOSE notifications listed in a Digest again.
if has_previous_message == False:
if self.previously_notified_article_count > 0:
self.most_recently_seen = self.previously_notified_article_most_recent
templ = """<html><body>{% if not_first_email %}<span>You have previously messages up to: {{most_recent_seen_str}}</span>{% endif %}
<table>
<tr style="background-color: #acf;">
<th colspan="2">Messages</th>
</tr>
{% for when, message in notificationsToPrint|dictsort(false, by='key')|reverse %}{% if message['line_here'] %} <!--1--><tr><td colspan="2" style="border-bottom: 1pt solid
red;
border-top: 1pt solid
red;"><center>^ New Messages Since You Last Checked ^</center></td></tr><!--cl1-->{% endif %} <!--2--><tr style="{{loop.cycle('','background-color: #def;')}}">
<td></td>
<td>
{{message['message']}}
</td>
</tr><!--cl2-->{% endfor %}
</table></body></html>""".replace("\n ", "\n")
template = Template(templ)
cnt = 0
for when in sorted(iter(self.reddit_notifications.keys()), reverse=True):
cnt = cnt + 1
if cnt > 30: # only show thirty
self.reddit_notifications.pop(when, None)
num_messages_since_last_seen = self.add_line_for_messages_seen_already()
seen_formated = arrow.get(self.most_recently_seen).to("local").format("MMM DD YYYY hh:mm A")
email_html = template.render(notificationsToPrint = self.reddit_notifications,
most_recent_seen=self.most_recently_seen,
most_recent_seen_str=seen_formated,
not_first_email=(self.most_recently_seen > 0))
# Delete previous email, and write replacement
if has_previous_message:
digest_folder_proxy.delete_previous_message()
digest_folder_proxy.append(self.make_new_raw_email(email_html, num_messages_since_last_seen, sender_to_implicate))
# Save
self.store_writer.store_as_binary("reddit-notifications", self.reddit_notifications)
self.store_writer.store_as_binary("reddit-recently-seen", self.most_recently_seen)
def add_line_for_messages_seen_already(self):
num_messages_since_last_seen = 0
line_here_done = False
for ts0, messages in sorted(iter(self.reddit_notifications.items()), reverse=False):
if self.most_recently_seen != 0 and ts0 >= self.most_recently_seen and line_here_done == False:
messages['line_here'] = True
line_here_done = True
num_messages_since_last_seen = num_messages_since_last_seen +1
if self.most_recently_seen == 0:
num_messages_since_last_seen = len(self.reddit_notifications)
return num_messages_since_last_seen
def matching_incoming_headers(self):
return ["From: Reddit <notifications@redditmail.com>",
"Subject: [reddit] .* u/" + self.userId]
def matching_digest_subject(self):
return self.userId + ': Reddit Messages Digest'
def matching_digest_sender(self):
return "Reddit"
def print_summary(self):
print("New " + self.userId + " notifications: " + str(self.new_message_count))
def make_new_raw_email(self, email_html, count, sender_to_implicate):
new_message = 'Subject: ' + self.matching_digest_subject() + ": " + str(count) + ' new notifications(s)\n'
new_message += 'From: \"' + self.matching_digest_sender() + '\" <' + sender_to_implicate + '>\n'
new_message += 'Content-Transfer-Encoding: 8bit\n'
new_message += 'Content-Type: multipart/alternative; boundary="---NOTIFICATION_BOUNDARY' \
+ self.notification_boundary_rand + '"\n'
new_message += 'MIME-Version: 1.0\n'
new_message += 'This is a multi-part message in MIME format.\n'
new_message += '-----NOTIFICATION_BOUNDARY' + self.notification_boundary_rand \
+ '\nContent-Type: text/html; charset="utf-8"\n'
new_message += 'Content-Transfer-Encoding: 8bit\n\n\n'
new_message += email_html.replace("\n\n\n", "\n").replace("\n\n", "\n")
new_message += '\n\n-----NOTIFICATION_BOUNDARY' + self.notification_boundary_rand
return new_message
|
def fun1(y, z):
x = y % 3 + z * 2
if x > 5 and y <= 10 or z == 0:
return x + y + z
elif z < 3:
return z * z * z
return x
def fun2(n):
if n <= 0:
return 0
cnt = 0
while n != 1:
if n % 2 == 0:
n = n / 2
else:
n = 3 * n + 1
cnt = cnt + 1
return cnt
def fun2r(n):
if n <= 1:
return 0
if n % 2 == 0:
n = n / 2
else:
n = 3 * n + 1
return 1 + fun2r(n)
def fun3(n):
if n < 0:
return ""
a = "0"
b = "1"
while n > 0:
n = n - 1
x = a + b
y = b + a
a = x
b = y
return a
|
import re
from terroroftinytown.client import errors
from terroroftinytown.services.isgd import IsgdService
from terroroftinytown.services.rand import HashRandMixin
from terroroftinytown.services.status import URLStatus
from terroroftinytown.six.moves import html_parser
class VgdService(IsgdService):
def parse_blocked(self, response):
try:
return IsgdService.parse_blocked(self, response)
except errors.UnexpectedNoResult:
pass
response.encoding = 'utf-8'
match = re.search("<p>For reference and to help those fighting spam the original destination of this URL is given below \(we strongly recommend you don't visit it since it may damage your PC\): -<br />(.*)</p><h2>v\.gd</h2><p>v\.gd is a free service used to shorten long URLs\.", response.text)
if not match:
raise errors.UnexpectedNoResult("Could not find target URL in 'Link Disabled' page")
url = match.group(1)
url = html_parser.HTMLParser().unescape(url)
if url == "":
return (URLStatus.unavailable, None, None)
return (URLStatus.ok, url, response.encoding)
class Vgd6Service(HashRandMixin, VgdService):
def get_shortcode_width(self):
return 6
|
from django.db import models
# Create your models here.
class Order(models.Model):
title = models.CharField(max_length=32)
def __str__(self):
return self.title
class Food(models.Model):
title = models.CharField(max_length=32)
|
# -*- coding: utf-8 -*-
"""
--------------------------------------
@File : __init__.py
@Author : maixiaochai
@Email : maixiaochai@outlook.com
@Created on : 2020/5/22 15:39
--------------------------------------
"""
from copy import deepcopy
from flask import jsonify
from flask_restful import Resource, marshal
from flask_restful.fields import Integer, String, DateTime, Nested, List
from flask_restful.reqparse import RequestParser
from werkzeug.datastructures import FileStorage
from App.extensions import scheduler
from App.models.jobs import JobData, JobStatus
from App.models.logs import ModLog
from App.setting import *
from App.utils import (set_model_value, job_handler, get_next_time, save_job_data, save_job_status, up_job_status,
save_mod_log, cron_to_dict, up_job_data, del_job, rm_empty_kw, FileHandler, gen_cmd, to_lower
)
# Request 解析参数。自动去除值两边空格
parser_jobs = RequestParser(trim=True)
# 继承parser_job
parser_actions = parser_jobs.copy()
# 继承 parser_job
parser_put = parser_jobs.copy()
# ============================================== [ parser_job ] ==============================================
parser_jobs.add_argument("timeStyle", dest="time_style", type=str, required=True, choices=[f"{TRIGGER_TYPE_CRON}", ],
help=f"请输入时间风格, [{TRIGGER_TYPE_CRON}|{TRIGGER_TYPE_DATE}|{TRIGGER_TYPE_INTERVAL}]")
parser_jobs.add_argument("timeData", dest="time_data", type=str, required=True, help="请输入执行时间，如 0 5 * * *")
parser_jobs.add_argument("jobType", dest="job_type", type=str, required=True,
choices=[f"{JOB_TYPE_CLI}", f"{JOB_TYPE_SCRIPT}"],
help=f"请输入正确的任务类型,[{JOB_TYPE_CLI}|{JOB_TYPE_SCRIPT}]")
parser_jobs.add_argument("jobCmd", dest="job_cmd", type=str, help="请输入任务运行命令, 如 python test.py")
parser_jobs.add_argument("createdBy", dest="created_by", type=str, required=True, help="请输入任务创建人姓名")
parser_jobs.add_argument("category", dest="category", type=str, required=True,
help="请输入任务所属业务，[mes|erp|warranty|radar|pms|stopcard|...]")
parser_jobs.add_argument("desc", dest="desc", type=str, required=True, help="请输入任务描述")
# 文件上传
parser_jobs.add_argument("file", type=FileStorage, help="请上传文件", location=["files"])
# ============================================== [ parser_action ] ==============================================
parser_actions.add_argument("action", type=str, required=True, help="请输入操作名称")
# ================================================ [ parser_put ] ================================================
# 5个参数 action, timeStyle, timeData, desc, category
parser_put.add_argument("timeStyle", dest="time_style", type=str, choices=[f"{TRIGGER_TYPE_CRON}", ],
help=f"请输入时间风格, [{TRIGGER_TYPE_CRON}|{TRIGGER_TYPE_DATE}|{TRIGGER_TYPE_INTERVAL}]")
parser_put.add_argument("jobType", dest="job_type", type=str,
choices=[f"{JOB_TYPE_CLI}", f"{JOB_TYPE_SCRIPT}"],
help=f"请输入正确的任务类型,[{JOB_TYPE_CLI}|{JOB_TYPE_SCRIPT}]")
parser_put.add_argument("jobCmd", dest="job_cmd", type=str, help="请输入任务运行命令, 如 python test.py")
parser_put.add_argument("timeData", dest="time_data", type=str, help="请输入执行时间，如 0 5 * * *")
parser_put.add_argument("createdBy", dest="created_by", type=str, help="请输入需求人")
parser_put.add_argument("category", dest="category", type=str,
help="请输入任务所属业务，[mes|erp|warranty|radar|pms|stopcard|...]")
# 文件类型
parser_put.add_argument("file", type=FileStorage, help="请上传文件", location=["files"])
parser_put.add_argument("desc", dest="desc", type=str, help="请输入任务描述")
# ============================================== [ parser done ] ==============================================
post_fields = {
"jobName": String(attribute="job_name"),
"job_type": String(attribute="job_type"),
"jobCmd": String(attribute="job_cmd"),
"timeStyle": String(attribute="time_style"),
"timeData": String(attribute="time_data")
}
posts_fields = {
"status": Integer,
"msg": String,
"total": Integer,
"data": List(Nested(post_fields))
}
job_fields = {
"jobName": String(attribute="job_name"),
"jobType": String(attribute="job_type"),
"jobCmd": String(attribute="job_cmd"),
"timeStyle": String(attribute="time_style"),
"timeData": String(attribute="time_data"),
"nextRunTime": DateTime(attribute="next_run_time", dt_format="iso8601"),
"category": String(attribute="category"),
"file": String(attribute="file_name", default=""),
"comment": String(attribute="desc"),
}
jobs_fields = {
"status": Integer,
"msg": String,
"total": Integer,
"data": List(Nested(job_fields))
}
class JobsResource(Resource):
"""
Job CRUD/RUN/PAUSE/RESUME
rules:
1) category 字段用小写
2) file_name 字段大小写敏感
3) job_type 字段用小写
4) time_style 字段小写
"""
def get(self, job_name):
"""
任务获取,可获取单个，多个
"""
status, msg, error = HTTP_OK, MSG_JOB_QUERY_SUCCESS, ""
job_name = str(job_name.strip())
jobs_data, result_data = [], []
# 部分job data
if job_name.lower() != "all":
if ";" not in job_name:
jobs_data = [scheduler.get_job(job_name)]
else:
job_names = job_name.split(";")
for name in job_names:
jobs_data.append(scheduler.get_job(name))
else:
# 全部 job data
jobs_data = scheduler.get_jobs()
try:
jobs_info = get_next_time(jobs_data)
for item in jobs_info:
_job = JobData.query.filter(JobData.job_name == item["job_name"]).first()
_info = deepcopy(item)
_info["job_type"] = _job.job_type
_info["job_cmd"] = _job.job_cmd
_info["time_style"] = _job.time_style
_info["time_data"] = _job.time_data
_info["category"] = _job.category
_info["file_name"] = _job.file_name
_info["desc"] = _job.desc
result_data.append(_info)
except AttributeError as err:
status, msg = HTTP_QUERY_ERROR, MSG_JOB_QUERY_FAILED
error = str(err)
result = {
"status": status,
"msg": msg,
"total": len(result_data),
"data": result_data
}
result_fields = deepcopy(jobs_fields)
if error:
result["error"] = error
result_fields["error"] = String
return marshal(result, result_fields)
def post(self, job_name):
"""
添加一个任务
"""
job_args = parser_jobs.parse_args()
full_data = {"job_name": job_name}
set_model_value(full_data, job_args)
# 去掉没有值的键值对儿
full_data = rm_empty_kw(full_data)
# category/time_style/job_type 都用小写
to_lower(full_data, LOWER_KEYS)
status, msg, error = HTTP_CREATED_OK, MSG_JOB_CREATED_SUCCESS, ""
fh = FileHandler()
job_data = JobData.query.filter(JobData.job_name == job_name).first()
try:
_exist = scheduler.get_job(job_name)
_exist_cat = _exist_file_name = False
_arg_cat = full_data.get("category").lower()
_arg_file_name = ""
if job_data:
_exist_cat = _arg_cat == job_data.category
if "file" in full_data:
_filename = full_data.get("file").filename
_arg_file_name = fh.secure_name(_filename)
_exist_file_name = _arg_file_name == job_data.file_name
if _exist_cat and _exist_file_name:
raise Exception(f"Category'{_arg_cat}'下已经存在 文件'{_arg_file_name}'")
if not _exist:
# 准备添加到调度的数据
sched_dict = {
"job_name": job_name,
"job_cmd": job_args.job_cmd,
"time_style": job_args.time_style.lower(),
"time_data": job_args.time_data,
"cwd": None
}
job_type = full_data["job_type"]
# 纯粹执行命令
if job_type == JOB_TYPE_CLI:
if "file" in full_data:
raise Exception("jobType 为'cli'时，不需要'file' 字段。")
elif job_type == JOB_TYPE_SCRIPT:
if "file" not in full_data:
raise Exception("'file'字段为空。")
# 替换命令中的文件名称为安全的文件名称，防止意外
# Demo: "../../test.py" -> "test.py"
file_content = job_args.file
filename_src = file_content.filename
filename_secure = fh.secure_name(filename_src)
full_data["file_name"] = filename_secure
# 如果 job_cmd 有值
# 与这里相反的情况是 job_cmd 没有值，而 file 有值，通过 file 生成 job_cmd
if "job_cmd" in full_data:
job_cmd = job_args.job_cmd
if filename_src not in job_cmd:
raise Exception("'jobCmd'命令中未发现'file'中的文件名")
else:
job_cmd = job_cmd.replace(filename_src, filename_secure)
full_data["job_cmd"] = sched_dict["job_cmd"] = job_cmd
# 如果job_cmd 字段没有值，则根据 file 字段的 filename 推断命令，赋值给 job_cmd
else:
cmd = gen_cmd(filename_secure)
full_data["job_cmd"] = sched_dict["job_cmd"] = cmd
# ===================[ 无论有没有 job_cmd 都要进行的操作, start ]====================
work_dir = fh.save_file(job_args.category, job_args.file)
sched_dict["cwd"] = work_dir
# ====================[ 无论有没有 job_cmd 都要进行的操作, end ]=====================
if "file" in full_data:
# 删除 file 字段，该字段不保存到数据库
full_data.pop("file")
# job 数据保存到数据库, 这步在 job_handler 之前是因为执行器要查 JobData 表
save_job_data(full_data, JobData)
# 将 job添加到调度
job_handler(scheduler, sched_dict)
# 添加job_name 到job 状态表
save_job_status(job_name, JobStatus)
# 添加job 修改日志
save_mod_log(ACTION_CREATED, full_data, ModLog, JobData)
else:
status = HTTP_CONFLICT
msg = MSG_JOB_EXISTED
except Exception as err:
status = HTTP_CREATED_FAILED
msg = MSG_JOB_CREATED_FAILED
error = str(err)
result = {
"status": status,
"msg": msg,
"total": 0 if error else 1,
"data": full_data
}
result_fields = deepcopy(posts_fields)
# 如果出现错误，则在返回结果中加上报错内容
if error:
result["error"] = error
result_fields["error"] = String
result_fields.pop("data")
return marshal(result, result_fields)
def put(self, job_name):
"""
处理任务操作 暂停/恢复/立即执行
"""
args_actions = parser_actions.parse_args()
action = args_actions.get("action").lower()
msg, error = "", ""
# 任务暂停
if action == "pause":
try:
scheduler.pause_job(job_name) # 暂停
up_job_status(job_name, JobStatus, STATUS_DICT.get(action)) # 修改任务状态
save_mod_log(action, {"job_name": job_name}, ModLog, JobData) # 保存人为动作
msg = MSG_JOB_PAUSED_SUCCESS
except Exception as err:
error = str(err)
msg = MSG_JOB_PAUSED_FAILED
# 任务恢复
elif action == "resume":
try:
scheduler.resume_job(job_name) # 恢复
up_job_status(job_name, JobStatus, STATUS_DICT.get(action)) # 修改任务状态
save_mod_log(action, {"job_name": job_name}, ModLog, JobData) # 保存人为动作
msg = MSG_JOB_RESUMED_SUCCESS
except Exception as err:
error = str(err)
msg = MSG_JOB_RESUMED_FAILED
# 任务立刻执行
elif action == "run":
"""
[2020-06-03]
Q: 为什么在 run_job 前后加上 pause_job 和 resume_job？
A: 主要是考虑到在任务运行期间，假设该任务的调度时间也到了，会造成两次运行。
对于某些内部逻辑没有限制的任务，同时运行两个实例，结果是灾难性的。
所以，为了防止这种情况发生,首先暂停该任务的调度（在内部源码上的实现是将 next_run_time 置空）
在程序运行完成后，再恢复该程序的调度。这样，可以尽最大可能避免两个实例在运行。
同时在配置中，max_instance=1 和 coalesce=True，这两个组合，也可以避免多个实例同时运行。
"""
# 获取run之前的状态
next_time = scheduler.get_job(job_name).next_run_time
before_run_status = STATUS_SLEEP if next_time else STATUS_PAUSED
try:
# 总的思想是，run完成后，恢复run之前的调度状态
if before_run_status == STATUS_SLEEP:
scheduler.pause_job(job_name)
up_job_status(job_name, JobStatus, STATUS_DICT.get(action)) # 修改任务状态
save_mod_log(action, {"job_name": job_name}, ModLog, JobData) # 保存人为动作
scheduler.run_job(job_name) # 运行
msg = MSG_JOB_RUNNING_SUCCESS
except Exception as err:
error = str(err)
msg = MSG_JOB_RUNNING_FAILED
finally:
run_result = RESULT_SUCCESS if not error else RESULT_FAILED
up_job_status(job_name, JobStatus, before_run_status, run_result) # 修改任务状态
if before_run_status == STATUS_SLEEP:
scheduler.resume_job(job_name) # 恢复
# 更改除job_name外的 job信息
elif action == "update":
args_update = parser_put.parse_args()
full_data = {"job_name": job_name}
set_model_value(full_data, args_update)
# 移除没有值的键值对儿
full_data = rm_empty_kw(full_data)
# 对指定的键值小写
to_lower(full_data, LOWER_KEYS)
# 用于更新 job 的数据
changes = {}
try:
# 禁止修改 job_type
if "job_type" in full_data:
raise Exception("'jobType'字段不能修改")
# ======================[ 这里限定了 time_style 和 time_data 必须同时出现 ] ============================
# 若修改 time_data 数据，time_style 必须同时指定，若不指定后者，默认 time_style 为 date 风格
if "time_style" in full_data and "time_data" in full_data:
# 字符串时间变字典时间
# Demo: "*/1 * * * *" → {"minute": "*/1", "hour": "*", "day": "*", "month": "*", "day_of_week": "*"}
trigger_data = cron_to_dict(CRON_KEYS, full_data.get("time_data"))
changes["trigger"] = full_data.get("time_style")
changes.update(trigger_data) # 时间风格
elif "time_style" in full_data and "time_data" not in full_data:
raise Exception("'timeData'没有值或者缺失, 该字段要与'timeStyle'字段同时使用")
elif "time_style" not in full_data and "time_data" in full_data:
raise Exception("'timeStyle'没有值或者缺失, 该字段要与'timeData'字段同时使用")
# =========================[ 这里处理 job_cmd、file 和 category 的关系 ] ===============================
"""
1> 思想是：每个关键字段，只管处理自己相关的操作，不用全局考虑。
这样，大家都处理好自己的内容，整个任务都处理好了。
由简单的任务组成复杂的任务，这才是符合计算机的逻辑，才是简单逻辑实现复杂逻辑的最优解思路。
这种思想的字段处理顺序就有规定，最优顺序处理为：file > category > job_cmd
数据(包括中间数据)先 保存到 full_data 库，最后再组装 kwargs
full_data 就是一个流水线托盘，上边放数据, 每一步只放处理好的数据，该删除的删除。
full_data 中的临时变量key 前用双单下划线表示，便于最后识别和处理, demo, full_data["__key"]
整个流程处理完成后，作为最终数据
[2020-06-16] 采用 1> 方案
2> 心得，多个流程控制，不要怕繁琐和运行效率低下，这其实是将大问题分解为固定条件下的诸多小问题，逐个击破的策略。
这样，在写逻辑时，不容易出现考虑不到和复杂交织的情况
"""
tmp_prefix = "__"
t_secure_filename = f"{tmp_prefix}file_name"
t_insecure_filename = f"{tmp_prefix}old_filename"
t_cwd = f"{tmp_prefix}cwd"
t_cmd = f"{tmp_prefix}cmd"
t_cat = f"{tmp_prefix}category"
fh = FileHandler()
old_job_data = JobData.query.filter(JobData.job_name == job_name).first()
old_job_type = old_job_data.job_type
# 执行脚本类型的任务
if old_job_type in (JOB_TYPE_CLI, JOB_TYPE_SCRIPT):
if old_job_type != JOB_TYPE_SCRIPT and "file" in full_data:
raise Exception(f"jobType 非'{JOB_TYPE_SCRIPT}'时，不能上传文件")
old_cat = old_job_data.category
old_filename = old_job_data.file_name
if "file" in full_data:
file = full_data.get("file")
new_filename = fh.secure_name(file.filename)
# =============================[ 处理 cmd: start ]==============================
old_cmd = old_job_data.job_cmd
if old_filename:
if old_filename in old_cmd:
new_cmd = old_cmd.replace(old_filename, new_filename)
else:
new_cmd = gen_cmd(new_filename)
else:
new_cmd = gen_cmd(new_filename)
full_data["cmd"] = full_data[t_cmd] = new_cmd
# ==============================[ 处理 cmd: end ]================================
# 删除旧文件
if old_filename:
fh.del_file(old_cat, old_filename)
# 保存新文件
fh.save_file(old_cat, file)
full_data["file_name"] = new_filename
# 传递给 category 字段处理用
# 如果 new != old ,则用 new， 如果 new == old，用 new 或 old 都一样, 所以，统一用 new。
full_data[t_secure_filename] = new_filename
full_data[t_insecure_filename] = file.filename
# file 字段不需要更新到数据库，去除掉
full_data.pop("file")
if "category" in full_data:
new_cat = full_data.get("category")
if new_cat != old_cat:
# 有可能更新 args 中，没有 file 字段，也就不会有 t_secure_filename
# 同理，jobData 中 file_name 也可能为空，也就是说，这是 job_type != "script"的任务
if t_secure_filename in full_data:
cat_filename = full_data.get(t_secure_filename)
else:
cat_filename = old_filename
cats = JobData.query.filter(JobData.category == old_cat).all()
total_cats = len(cats) if cats else 0
if cat_filename:
# 有文件, 则将文件移动到新文件夹里
_ = fh.move_to(old_cat, new_cat, cat_filename, total_cats)
else:
# 针对只是修改 category 且 job_type != "script" 的任务
# 如果目录不存在则创建
cat_dir = fh.abs_dirname(new_cat)
fh.mkdir(cat_dir)
# [2020-07-01]
# 如果只有一个 job 在使用 old_cat 文件夹(也就是自己)，那么删除
if total_cats < 2:
wk_dir = fh.abs_dirname(old_cat)
fh.rm_dir(wk_dir)
full_data["cwd"] = fh.abs_dirname(new_cat)
full_data[t_cwd] = fh.abs_dirname(new_cat)
full_data[t_cat] = new_cat
if "job_cmd" in full_data:
new_cmd = full_data.get("job_cmd")
filename_insecure = full_data.get(t_insecure_filename)
# 如果 t_insecure_filename 不在 job_cmd 中，替换也没问题，相当于没换
if filename_insecure:
filename_secure = full_data[t_secure_filename]
if filename_insecure not in new_cmd:
raise Exception(f"file'{filename_insecure}' 不在jobCmd`{new_cmd}`中。")
else:
new_cmd = new_cmd.replace(filename_insecure, filename_secure)
else:
# # 这里的完整分分支结构，是为了让思考难度降低
# # 没有文件就用原始的命令
# # new_cmd = new_cmd
pass
full_data["job_cmd"] = full_data["cmd"] = new_cmd
else:
# # 这里的完整分分支结构，是为了让思考难度降低
# # 没有 job_cmd 就用之前 file 处理中得到的 cmd 和 t_cmd
if "cmd" in full_data:
full_data["job_cmd"] = full_data["cmd"]
# 去掉临时变量
full_data_keys = list(full_data.keys())
for k in full_data_keys:
if k.startswith(tmp_prefix):
full_data.pop(k)
# =========================[ 一个文件夹内执行某个脚本 ]=========================
elif old_job_type == JOB_TYPE_DIR:
# 不支持文件夹上传
raise ValueError(f"'jobType'为'{JOB_TYPE_DIR}'类型的命令暂时不支持")
# ========================[ 组装 job 参数, start ]=========================
full_data_keys = set(full_data.keys())
if "cmd" in full_data_keys or "cwd" in full_data_keys:
kwargs = {
"job_name": job_name,
"cmd": full_data.get("cmd") or old_job_data.job_cmd,
"cwd": full_data.get("cwd") or fh.abs_dirname(old_job_data.category)
}
kwargs_eys = list(kwargs.keys())
for _k in kwargs_eys:
if _k != "job_name" and _k in full_data_keys:
kwargs[_k] = full_data.pop(_k)
elif _k == "job_name":
continue
changes["kwargs"] = kwargs
# =========================[ 组装 job 参数, end ]==========================
if changes:
# 对调度涉及到的参数的修改生效
scheduler.modify_job(job_name, **changes)
"""
[2020-06-10]
对于上传文件的分类，是按照 category 字段进行的。
category 改变，该任务对应的脚本也要移动到对应的文件夹中。
同时，执行脚本的工作目录值(cwd 参数)也要改变。
这样，才能保持文件所在目录和 category 是一致的，调度任务执行时才能找到要执行的脚本。
在查看文件内容时，才能保证能找到文件, 从而展示脚本内容。
"""
# 更新该job在JobData中的元数据
up_job_data(full_data, JobData)
# 将更改记录保存到日志
save_mod_log(ACTION_UPDATED, full_data, ModLog, JobData)
msg = MSG_JOB_MODIFIED_SUCCESS
except Exception as err:
error = str(err)
msg = MSG_JOB_MODIFIED_FAILED
status = HTTP_OK if not error else HTTP_EXECUTE_FAILED
result = {
"status": status,
"msg": msg,
"jobName": job_name,
"action": action
}
# 如果出现错误，则在返回结果中加上报错内容
if error:
result["error"] = error
return jsonify(result)
def delete(self, job_name):
"""
删除指定 job
:param job_name: str/list 要删除的 job
"""
error = ""
is_exist = scheduler.get_job(job_name)
fh = FileHandler()
try:
if is_exist:
args = {"job_name": job_name}
# 移除
scheduler.remove_job(job_name)
# 注意这里的顺序，先添加移除日志，再移除，否则移除日志找不到元数据
save_mod_log(ACTION_DELETED, args, ModLog, JobData)
# 如果有文件, 删除文件
job_data = JobData.query.filter(JobData.job_name == job_name).first()
cat, filename = job_data.category, job_data.file_name
if filename:
fh.del_file(cat, filename)
# 如果目录为空, 并且没有其他job 在使用这个目录，删除目录
cats = JobData.query.filter(JobData.category == cat).all()
total_cats = len(cats) if cats else 0
if total_cats < 2:
wk_dir = fh.abs_dirname(cat)
fh.rm_dir(wk_dir)
# 删除jobStatus/jobData 中的数据
del_job(job_name, JobStatus, JobData)
except Exception as err:
error = str(err)
status, msg = (HTTP_EXECUTE_FAILED, MSG_JOB_DELETED_FAILED) if error else (HTTP_OK, MSG_JOB_DELETED_SUCCESS)
msg = MSG_JOB_DELETED_AGAIN if not is_exist else msg
result = {
"status": status,
"msg": msg,
"jobName": job_name,
"action": ACTION_DELETED
}
# 如果出现错误，则在返回结果中加上报错内容
if error:
result["error"] = error
return jsonify(result)
|
__author__ = 'antonellacalvia'
import AST as Tree
def constantsPass(tree, funcs):
vars = {}
def run(n, pos= 0, name= ""):
for iter in range(len(n.nodes)):
i = n.nodes[iter]
if not n.isEnd():
run(i, iter, i.name if type(i) in [Tree.FuncBraceOpen, Tree.FuncBody] or (type(i) is Tree.FuncCall and i.inline) else name)
if type(i) in [Tree.Assign, Tree.InitInline]:
if (type(i.owner) is Tree.CreateAssign and i.owner.nodes[0].imutable) or (type(i) is Tree.InitInline and i.imutable):
inner = i.nodes[0]
if type(inner) is Tree.ReadVar:
if inner.package + "_" + inner.name in funcs:
vars[name + "_" + i.package + "_" + i.name] = inner
elif type(inner) is Tree.FuncCall and inner.partial:
for c in inner.nodes[1:]:
if not type(c) is Tree.Under:
if not isConstant(c):
break
else:
optimizeFunc(i, pos)
if isConstant(i.nodes[0]):
vars[name+"_"+i.package+"_"+i.name] = turnToNode(evaluate(i.nodes[0]), i)
elif type(i) is Tree.ReadVar:
varname = name+"_"+i.package+"_"+i.name
if varname in vars:
node = vars[varname]
node.owner = n
n.nodes[iter] = node
elif type(i) is Tree.Field and i.indexPackage:
r = Tree.ReadVar(i.field, True,i)
r.package = i.nodes[0].package
i.owner.nodes[iter] = r
r.owner = i.owner
r.type = i.type
elif type(i) is Tree.Array:
if i.range or i.init:
if i.range:
if isConstant(i.nodes[0]) and isConstant(i.nodes[1]):
arr = Tree.Array()
for c in range(evaluate(i.nodes[0]), evaluate(i.nodes[1])):
arr.addNode(turnToNode(c))
elif i.init:
if isConstant(i.nodes[0]):
arr = Tree.Array()
for c in range(evaluate(i.nodes[0])):
arr.addNode(i.nodes[1])
arr.owner = n
arr.type = i.type
n.nodes[iter] = arr
elif isConstant(i):
result = evaluate(i)
node = turnToNode(result, i)
node.owner = n
n.nodes[iter] = node
elif type(i) is Tree.Operator and i.overload and not i.curry:
f = Tree.FuncCall(i)
f.type = i.type
r = Tree.ReadVar(i.name, True, i)
r.package = i.package
r.imutable = True
r.type = Types.FuncPointer([c.type for c in i], i.type)
f.addNode(r)
for c in i: f.addNode(c)
f.owner = i.owner
i.owner.nodes[iter] = f
def turnToNode(number, pos):
if type(number) is int:
return Tree.Int(str(number), pos)
elif type(number) is float:
return Tree.Float(str(number), pos)
elif type(number) is bool:
return Tree.Bool("true" if number else "false", pos)
elif type(number) is str:
return Tree.String(number, pos)
raise Exception("cannot turn to constant node, "+number)
def removeBlock():
for root in tree:
added = 0
for iter in range(len(root.nodes)):
iter += added
i = root.nodes[iter]
if type(i) is Tree.Block:
del root.nodes[iter]
for d in i:
d.owner = root
root.nodes.insert(iter, d)
iter += 1
added += len(i.nodes)-1
run(tree)
removeBlock()
def isConstant(n):
if not type(n) in [Tree.Operator, Tree.Int, Tree.Float, Tree.Bool, Tree.String] or n.curry == True:
return False
for i in n:
if not type(i) in [Tree.Int, Tree.Float, Tree.Bool, Tree.String, Tree.Under] and not (
type(i) is Tree.FuncCall and i.inline and isConstant(i.nodes[-1])):
return False
return True
def evaluate(i):
if type(i) is Tree.Int:
return int(i.number)
elif type(i) is Tree.String:
return str(i.string)
elif type(i) is Tree.FuncCall:
return evaluate(i.nodes[-1])
elif type(i) is Tree.Float:
return float(i.number)
elif type(i) is Tree.Bool:
return (True if i.bool == "true" else False)
elif type(i) is Tree.Operator:
if i.kind == "+":
return evaluate(i.nodes[0]) + evaluate(i.nodes[1])
elif i.kind == "-":
return evaluate(i.nodes[0]) - evaluate(i.nodes[1])
elif i.kind == "*":
return evaluate(i.nodes[0]) * evaluate(i.nodes[1])
elif i.kind == "/":
if type(i.type) is Tree.Int:
return evaluate(i.nodes[0]) // evaluate(i.nodes[1])
return evaluate(i.nodes[0]) / evaluate(i.nodes[1])
elif i.kind == "and":
return evaluate(i.nodes[0]) and evaluate(i.nodes[1])
elif i.kind == "or":
return evaluate(i.nodes[0]) or evaluate(i.nodes[1])
elif i.kind == "not":
return not evaluate(i.nodes[0])
elif i.kind == "==":
return evaluate(i.nodes[0]) == evaluate(i.nodes[1])
elif i.kind == "!=":
return evaluate(i.nodes[0]) != evaluate(i.nodes[1])
elif i.kind == "<":
return evaluate(i.nodes[0]) < evaluate(i.nodes[1])
elif i.kind == ">":
return evaluate(i.nodes[0]) > evaluate(i.nodes[1])
elif i.kind == ">=":
return evaluate(i.nodes[0]) >= evaluate(i.nodes[1])
elif i.kind == "<=":
return evaluate(i.nodes[0]) <= evaluate(i.nodes[1])
from TopCompiler import Types
def optimizeFunc(i, pos):
block = Tree.Block(i)
block.noBrackets = True
block.type = Types.Null()
start = Tree.FuncStart(i.name, i.nodes[0].type, i)
braces = Tree.FuncBraceOpen(i)
body = Tree.FuncBody(i)
start.package = i.package
braces.package = i.package
braces.name = i.name
body.package = i.package
body.name = i.name
body.returnType = i.nodes[0].type
i.owner.owner.nodes[pos] = block
block.owner = i.owner.owner
block.addNode(start)
block.addNode(braces)
block.addNode(body)
call = i.nodes[0]
newCall = Tree.FuncCall(i)
newCall.type = call.type
r = call.nodes[0]
newCall.addNode(r)
count = 0
index = 0
for c in call.nodes[1:]:
if type(c) is Tree.Under:
create = Tree.Create(str(count), call.nodes[0].type.args[index], i)
create.package = i.package
braces.addNode(create)
t = Tree.InitArg(str(count), i)
t.package = i.package
t.imutable = True
t.type = call.nodes[0].type.args[index]
body.addNode(t)
r = Tree.ReadVar(str(count), False, i)
r.package = i.package
r.varType = call.nodes[0].type.args[index]
r.imutable = True
newCall.addNode(r)
count += 1
else:
newCall.addNode(c)
index += 1
body.addNode(newCall)
|
from sqlalchemy.ext.asyncio import create_async_engine
from source.infrastructure.settings import application_settings
engine = create_async_engine(
application_settings.postgres_url,
pool_size=50,
max_overflow=0
)
|
# -*- coding: utf-8 -*-
from collections import OrderedDict
from pyramid.view import view_config
from chsdi.models.bod import Translations
class TranslationService(object):
def __init__(self, request):
self.geodataStaging = request.registry.settings['geodata_staging']
self.cbName = request.params.get('callback')
self.request = request
self.lang = request.lang
@view_config(route_name='translations', renderer='jsonp')
def translations(self):
model = Translations
lang = self.lang
query = self.request.db.query(model).order_by(model.msgId)
msgIds = OrderedDict([(q.msgId, getattr(q, lang)) for q in query])
return msgIds
|
import serial
import time
ser = serial.Serial('COM3', 115200, timeout=5)
time.sleep(5)
#<Timestamp, track number, MIDI channel, type, key, value>
ser.write(bytes(b'<0,0,0,8,0,0>'))
ser.write(bytes(b'<0,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<12,1,0,1,52,126>'))
ser.readline()
ser.write(bytes(b'<65,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<1015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<1064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<1473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<1499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<1511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<1564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<1973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<1999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<2015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<2064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<2449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<2462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<2473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<2473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<2499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<2515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<2564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<2973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<2999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<3011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<3064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<3473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<3499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<3515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<3564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<3949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<3962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<3973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<3973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<3999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<4015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<4064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<4473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<4499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<4511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<4564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<4973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<4999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<5015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<5064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<5449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<5462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<5473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<5473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<5499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<5499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<5515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<5520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<5564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<5564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<5749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<5749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<5773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<5814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<5973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<5999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<5999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<5999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<6011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<6020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<6064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<6064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<6249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<6249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<6270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<6314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<6473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<6499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<6499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<6499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<6515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<6516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<6564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<6564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<6949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<6962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<6973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<6973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<6999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<7015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<7064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<7211,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<7249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<7270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<7314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<7473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<7499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<7499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<7499,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<7519,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<7523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<7564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<7564,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<7973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<7973,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<7999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<7999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<7999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<8012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<8015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<8016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<8064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<8064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<8064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<8449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<8462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<8473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<8473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<8473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<8473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<8499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<8499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<8512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<8523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<8564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<8564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<8973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<8973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<8999,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<8999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<9013,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<9020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<9064,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<9064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<9249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<9249,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<9267,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<9314,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<9473,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<9499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<9499,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<9499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<9499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<9514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<9516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<9520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<9564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<9564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<9564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<9949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<9962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<9973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<9973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<9973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<9999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<10015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<10064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<10211,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<10249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<10270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<10314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<10473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<10499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<10499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<10499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<10514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<10520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<10564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<10564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<10973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<10999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<11012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<11064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<11349,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<11449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<11465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<11473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<11473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<11499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<11499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<11512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<11520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<11564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<11564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<11973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<11973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<11999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<11999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<12013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<12017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<12064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<12064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<12473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<12473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<12499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<12499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<12512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<12520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<12564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<12564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<12949,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<12962,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<12973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<12973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<12973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<12999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<12999,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<13017,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<13020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<13064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<13064,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<13249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<13249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<13273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<13314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<13473,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<13499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<13499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<13499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<13512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<13514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<13564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<13564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<13973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<13973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<13999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<13999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<14012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<14020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<14064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<14064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<14449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<14465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<14473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<14473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<14473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<14499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<14499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<14512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<14523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<14564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<14564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<14749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<14749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<14770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<14814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<14973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<14999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<14999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<15014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<15064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<15449,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<15467,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<15473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<15473,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<15499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<15512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<15564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<15749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<15770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<15814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<15949,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<15962,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<15973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<15973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<15999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<15999,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<15999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<16017,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<16023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<16064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<16064,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<16249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<16249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<16270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<16314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<16473,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<16499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<16499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<16499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<16515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<16523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<16564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<16564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<16973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<16999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<17012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<17064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<17448,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<17449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<17462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<17473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<17473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<17499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<17499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<17512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<17520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<17564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<17564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<17749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<17749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<17773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<17814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<17973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<17999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<17999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<17999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<18011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<18020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<18064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<18064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<18249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<18249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<18270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<18314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<18473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<18499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<18499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<18499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<18515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<18516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<18564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<18564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<18949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<18962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<18973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<18973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<18999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<19015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<19064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<19211,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<19249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<19270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<19314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<19473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<19499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<19499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<19499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<19515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<19523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<19564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<19564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<19973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<19973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<19999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<19999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<20012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<20016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<20064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<20064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<20449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<20462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<20473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<20473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<20473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<20499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<20499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<20512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<20523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<20564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<20564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<20973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<20973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<20999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<20999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<21016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<21020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<21064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<21064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<21249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<21449,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<21467,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<21473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<21499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<21512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<21514,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<21564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<21699,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<21949,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<21949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<21965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<21967,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<21973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<21973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<21973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<21999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<22020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<22064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<22249,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<22249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<22270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<22314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<22499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<22499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<22499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<22512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<22514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<22564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<22564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<22973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<22999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<23015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<23064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<23449,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<23462,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<23473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<23473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<23499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<23515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<23564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<23599,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<23749,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<23762,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<23814,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<23973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<23999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<23999,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<23999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<24013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<24017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<24064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<24064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<24473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<24473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<24499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<24499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<24499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<24512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<24512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<24520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<24564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<24564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<24564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<24973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<24999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<25020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<25064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<25249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<25249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<25273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<25314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<25448,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<25448,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<25499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<25499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<25499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<25512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<25514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<25564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<25564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<25973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<25973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<25999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<25999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<25999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<26012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<26015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<26020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<26064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<26064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<26064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<26473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<26499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<26523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<26564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<26749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<26749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<26770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<26814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<26948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<26948,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<26999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<26999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<26999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<27014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<27017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<27064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<27064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<27065,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<27086,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<27130,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<27449,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<27467,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<27473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<27497,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<27497,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<27498,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<27499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<27499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<27512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<27516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<27564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<27564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<27749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<27770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<27814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<27973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<27973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<27999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<27999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<27999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<28012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<28023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<28064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<28064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<28249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<28449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<28470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<28473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<28486,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<28499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<28511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<28564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<28973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<28999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<29015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<29064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<29449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<29462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<29473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<29473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<29499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<29515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<29564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<29973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<29999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<30011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<30064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<30473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<30499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<30515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<30564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<30949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<30962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<30973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<30973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<30999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<30999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<31015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<31020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<31064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<31064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<31249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<31249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<31267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<31314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<31473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<31499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<31499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<31499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<31511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<31520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<31564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<31564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<31949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<31966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<31973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<31973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<31999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<31999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<32009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<32014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<32015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<32064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<32064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<32199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<32249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<32249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<32259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<32314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<32449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<32449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<32462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<32466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<32473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<32473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<32499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<32499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<32499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<32509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<32514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<32515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<32564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<32564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<32699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<32749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<32749,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<32759,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<32814,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<32949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<32966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<32973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<32999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<32999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<32999,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<32999,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<33009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<33009,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<33014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<33019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<33064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<33064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<33064,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<33199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<33449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<33466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<33473,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<33473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<33473,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<33473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<33499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<33499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<33515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<33523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<33564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<33564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<33749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<33749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<33759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<33814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<33949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<33962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<33973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<33973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<33999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<33999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<33999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<34012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<34016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<34064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<34064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<34249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<34249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<34267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<34314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<34473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<34499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<34499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<34513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<34564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<34949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<34970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<34973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<34999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<34999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<34999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<35009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<35012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<35014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<35016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<35064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<35064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<35064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<35199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<35249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<35249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<35259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<35314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<35449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<35470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<35473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<35473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<35499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<35499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<35499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<35499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<35509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<35514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<35515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<35517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<35564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<35564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<35564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<35699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<35749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<35749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<35759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<35814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<35949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<35970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<35973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<35973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<35999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<35999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<35999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<36009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<36014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<36014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<36064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<36064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<36199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<36449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<36470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<36473,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<36473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<36473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<36499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<36512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<36564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<36749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<36767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<36814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<36949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<36965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<36973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<36973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<36999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<36999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<36999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<37012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<37020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<37064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<37064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<37249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<37249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<37273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<37314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<37473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<37499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<37499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<37513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<37564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<37949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<37970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<37973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<37999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<38012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<38014,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<38064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<38199,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<38449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<38449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<38462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<38470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<38473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<38473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<38473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<38749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<38770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<38814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<38949,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<38967,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<38973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<38999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<38999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<39014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<39064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<39473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<39499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<39512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<39564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<39949,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<39949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<39965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<39970,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<39973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<39973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<39973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<39999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<40012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<40064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<40249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<40270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<40314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<40473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<40499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<40499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<40514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<40564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<40949,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<40973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<40973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<40999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<41012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<41064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<41249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<41270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<41314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<41449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<41462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<41473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<41473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<41499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<41499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<41499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<41517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<41523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<41564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<41564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<41749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<41749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<41770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<41814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<41973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<41999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<41999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<41999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<42015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<42023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<42064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<42064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<42473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<42499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<42512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<42564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<42948,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<42949,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<42962,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<42973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<42973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<42999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<42999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<43012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<43020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<43064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<43064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<43249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<43249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<43267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<43314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<43473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<43499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<43499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<43499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<43511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<43520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<43564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<43564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<43565,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<43586,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<43630,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<43949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<43966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<43973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<43997,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<43998,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<43999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<43999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<43999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<44009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<44012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<44014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<44015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<44064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<44064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<44064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<44199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<44249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<44249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<44259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<44314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<44449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<44466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<44473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<44473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<44499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<44499,1,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<44499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<44499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<44509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<44512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<44514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<44520,1,0,1,76,130>'))
ser.readline()
ser.write(bytes(b'<44564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<44564,1,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<44564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<44699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<44749,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<44749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<44759,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<44814,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<44949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<44966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<44973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<44973,1,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<44999,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<44999,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<44999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<44999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<45009,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<45009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<45014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<45019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<45064,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<45064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<45064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<45199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<45449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<45466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<45473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<45473,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<45473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<45473,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<45499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<45499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<45512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<45512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<45564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<45564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<45749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<45759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<45814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<45973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<45973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<45999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<45999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<45999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<45999,1,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<46012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<46016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<46020,1,0,1,75,127>'))
ser.readline()
ser.write(bytes(b'<46064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<46064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<46064,1,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<46249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<46249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<46267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<46314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<46473,1,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<46473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<46499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<46499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<46499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<46513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<46520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<46564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<46564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<46949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<46970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<46973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<46973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<46999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<46999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<47009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<47014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<47016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<47064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<47064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<47199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<47249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<47249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<47259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<47314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<47449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<47449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<47462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<47470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<47473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<47473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<47499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<47499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<47499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<47509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<47514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<47515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<47564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<47564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<47699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<47749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<47749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<47759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<47814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<47949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<47970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<47973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<47973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<47999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<47999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<47999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<48009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<48014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<48064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<48064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<48249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<48267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<48314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<48473,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<48473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<48499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<48499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<48499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<48512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<48520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<48564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<48564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<48749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<48749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<48773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<48814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<48949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<48965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<48973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<48973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<48999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<48999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<48999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<49012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<49020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<49064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<49064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<49249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<49249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<49270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<49314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<49473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<49499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<49499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<49513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<49564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<49949,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<49967,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<49973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<49973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<49999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<50016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<50064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<50249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<50270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<50314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<50449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<50462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<50473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<50473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<50499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<50499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<50499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<50512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<50520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<50564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<50564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<50749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<50749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<50773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<50814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<50973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<50999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<50999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<50999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<51012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<51014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<51064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<51064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<51473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<51473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<51499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<51499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<51512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<51520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<51564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<51564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<51949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<51965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<51973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<51973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<51973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<51999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<51999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<52012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<52023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<52064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<52064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<52249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<52249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<52270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<52314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<52473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<52499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<52499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<52514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<52564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<52973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<52999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<52999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<53012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<53016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<53064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<53064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<53199,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<53223,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<53264,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<53299,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<53449,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<53473,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<53473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<53473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<53486,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<53499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<53499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<53499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<53512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<53512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<53515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<53564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<53564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<53564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<53749,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<53949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<53970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<53973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<53973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<53986,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<53999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<54011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<54064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<54473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<54499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<54515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<54564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<54949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<54962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<54973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<54973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<54999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<55015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<55064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<55473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<55499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<55511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<55564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<55973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<55999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<56015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<56064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<56449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<56462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<56473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<56473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<56499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<56515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<56564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<56973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<56999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<57011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<57064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<57473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<57499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<57515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<57564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<57949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<57962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<57973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<57973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<57999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<57999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<58015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<58020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<58064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<58064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<58249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<58249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<58273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<58314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<58473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<58499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<58499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<58499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<58499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<58511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<58511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<58520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<58564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<58564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<58564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<58749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<58749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<58770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<58814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<58973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<58973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<58999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<58999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<58999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<59015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<59016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<59064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<59064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<59449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<59462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<59473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<59473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<59499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<59515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<59564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<59711,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<59749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<59770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<59814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<59973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<59999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<59999,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<59999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<59999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<60019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<60022,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<60023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<60064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<60064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<60064,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<60473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<60473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<60473,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<60499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<60499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<60515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<60516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<60564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<60564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<60949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<60962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<60973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<60973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<60973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<60999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<60999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<61012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<61023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<61064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<61064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<61473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<61473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<61499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<61499,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<61499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<61510,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<61513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<61520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<61564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<61564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<61564,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<61749,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<61749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<61767,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<61814,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<61973,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<61973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<61999,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<61999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<61999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<62016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<62020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<62064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<62064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<62449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<62462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<62473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<62473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<62499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<62515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<62564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<62711,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<62749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<62770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<62814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<62973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<62999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<62999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<62999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<62999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<63014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<63017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<63020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<63064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<63064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<63064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<63473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<63473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<63499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<63515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<63564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<63948,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<63949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<63962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<63973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<63973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<63999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<63999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<64015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<64020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<64064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<64064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<64249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<64249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<64270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<64314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<64473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<64499,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<64499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<64499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<64509,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<64517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<64564,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<64564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<64949,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<64963,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<64973,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<64973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<64973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<64999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<65020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<65064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<65449,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<65466,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<65473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<65473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<65499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<65499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<65512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<65520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<65564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<65564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<65749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<65749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<65773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<65814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<65973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<65999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<65999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<65999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<65999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<66012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<66014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<66017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<66064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<66064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<66064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<66473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<66473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<66473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<66499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<66499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<66515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<66520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<66564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<66564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<66949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<66962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<66973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<66973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<66973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<66999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<66999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<67015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<67023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<67064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<67064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<67249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<67249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<67270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<67314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<67473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<67499,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<67499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<67499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<67499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<67509,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<67514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<67517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<67564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<67564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<67564,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<67565,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<67586,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<67630,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<67949,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<67967,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<67973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<67973,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<67997,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<67997,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<67998,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<67999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<68013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<68064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<68249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<68270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<68314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<68449,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<68466,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<68473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<68473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<68499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<68499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<68499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<68512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<68523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<68564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<68564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<68749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<68749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<68770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<68814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<68973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<68999,1,0,1,35,210>'))
ser.readline()
ser.write(bytes(b'<68999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<68999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<68999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<69012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<69014,1,0,1,35,126>'))
ser.readline()
ser.write(bytes(b'<69023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<69064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<69064,1,0,1,35,81>'))
ser.readline()
ser.write(bytes(b'<69064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<69473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<69473,1,0,0,35,0>'))
ser.readline()
ser.write(bytes(b'<69499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<69515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<69564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<69948,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<69949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<69962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<69973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<69973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<69999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<69999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<70012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<70020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<70064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<70064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<70249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<70249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<70273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<70314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<70473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<70499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<70499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<70499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<70499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<70511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<70511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<70520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<70564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<70564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<70564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<70749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<70749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<70770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<70814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<70973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<70973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<70999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<70999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<70999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<70999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<71009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<71014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<71016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<71064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<71064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<71064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<71449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<71465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<71473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<71499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<71512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<71514,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<71564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<71699,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<71711,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<71711,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<71749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<71749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<71770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<71770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<71814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<71814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<71949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<71965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<71973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<71973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<71999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<71999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<71999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<71999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<71999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<72012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<72020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<72023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<72064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<72064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<72064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<72473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<72473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<72473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<72499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<72499,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<72499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<72509,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<72512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<72516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<72564,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<72564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<72564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<72949,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<72962,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<72973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<72973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<72973,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<72973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<72999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<72999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<73012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<73023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<73064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<73064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<73473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<73473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<73499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<73499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<73499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<73513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<73516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<73520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<73564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<73564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<73564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<73749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<73949,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<73967,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<73973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<73973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<73999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<73999,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<74009,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<74012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<74014,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<74064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<74064,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<74199,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<74449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<74449,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<74465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<74467,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<74473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<74473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<74473,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<74473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<74499,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<74499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<74509,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<74523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<74564,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<74564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<74749,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<74749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<74749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<74749,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<74759,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<74770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<74814,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<74814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<74999,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<74999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<74999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<74999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<74999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<74999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<75012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<75014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<75016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<75017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<75064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<75064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<75064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<75064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<75473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<75473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<75499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<75499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<75512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<75515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<75564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<75564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<75849,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<75948,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<75999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<76012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<76064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<76448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<76448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<76473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<76499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<76499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<76513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<76517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<76564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<76564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<76973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<76973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<76999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<76999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<76999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<77012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<77016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<77020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<77064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<77064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<77064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<77473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<77473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<77499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<77499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<77515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<77520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<77564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<77564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<77749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<77749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<77749,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<77749,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<77762,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<77773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<77814,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<77814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<77948,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<77999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<77999,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<77999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<77999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<78012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<78014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<78064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<78064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<78473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<78473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<78499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<78499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<78499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<78512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<78515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<78520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<78564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<78564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<78564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<78973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<78999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<79023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<79064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<79249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<79249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<79270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<79314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<79448,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<79448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<79499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<79499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<79499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<79514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<79517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<79564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<79564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<79565,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<79586,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<79630,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<79949,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<79949,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<79962,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<79967,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<79973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<79973,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<79997,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<79997,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<79998,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<79999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<79999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<80012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<80016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<80064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<80064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<80249,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<80249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<80262,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<80270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<80314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<80314,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<80473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<80473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<80499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<80499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<80499,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<80499,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<80499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<80512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<80512,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<80523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<80564,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<80564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<80564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<80749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<80949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<80970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<80973,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<80973,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<80986,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<80999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<81011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<81064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<81473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<81499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<81515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<81564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<81949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<81962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<81973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<81973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<81999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<82015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<82064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<82423,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<82499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<82511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<82564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<82973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<82999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<83015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<83064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<83449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<83462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<83473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<83473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<83499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<83499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<83515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<83520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<83564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<83564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<83749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<83749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<83767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<83814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<83973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<83999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<83999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<83999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<84011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<84020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<84064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<84064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<84449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<84466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<84473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<84473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<84499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<84499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<84509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<84514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<84515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<84564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<84564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<84699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<84749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<84749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<84759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<84814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<84949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<84949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<84962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<84966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<84973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<84973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<84999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<84999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<84999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<85009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<85014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<85015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<85064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<85064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<85199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<85249,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<85249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<85259,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<85314,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<85449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<85466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<85473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<85499,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<85499,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<85499,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<85499,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<85509,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<85509,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<85514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<85519,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<85564,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<85564,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<85564,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<85699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<85949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<85966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<85973,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<85973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<85973,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<85973,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<85999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<85999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<86015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<86023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<86064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<86064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<86249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<86249,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<86259,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<86314,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<86449,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<86462,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<86473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<86473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<86499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<86499,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<86499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<86512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<86516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<86564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<86564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<86749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<86749,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<86767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<86814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<86973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<86999,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<86999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<87013,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<87064,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<87449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<87470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<87473,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<87499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<87499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<87499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<87509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<87512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<87514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<87516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<87564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<87564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<87564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<87699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<87749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<87749,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<87759,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<87814,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<87949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<87970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<87973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<87973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<87999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<87999,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<87999,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<87999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<88009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<88014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<88015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<88017,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<88064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<88064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<88064,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<88199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<88249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<88249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<88259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<88314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<88449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<88470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<88473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<88473,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<88499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<88499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<88499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<88509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<88514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<88514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<88564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<88564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<88699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<88949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<88970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<88973,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<88973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<88973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<88999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<89012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<89064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<89249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<89267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<89314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<89449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<89465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<89473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<89473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<89499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<89499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<89499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<89512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<89520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<89564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<89564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<89749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<89749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<89773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<89814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<89973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<89999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<89999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<90013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<90064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<90449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<90470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<90473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<90499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<90512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<90514,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<90564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<90699,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<90949,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<90949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<90962,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<90970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<90973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<90973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<90973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<91249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<91270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<91314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<91449,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<91467,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<91473,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<91499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<91499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<91514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<91564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<91973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<91999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<92012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<92064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<92449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<92449,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<92465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<92470,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<92473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<92473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<92473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<92499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<92512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<92564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<92749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<92770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<92814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<92973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<92999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<92999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<93014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<93064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<93449,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<93473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<93473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<93499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<93512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<93564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<93749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<93770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<93814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<93949,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<93962,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<93973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<93973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<93999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<93999,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<93999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<94017,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<94023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<94064,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<94064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<94249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<94249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<94270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<94314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<94473,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<94499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<94499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<94499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<94515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<94523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<94564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<94564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<94973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<94999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<95012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<95064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<95448,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<95449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<95462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<95473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<95473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<95499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<95499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<95499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<95512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<95520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<95520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<95564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<95564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<95564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<95749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<95749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<95749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<95749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<95767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<95773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<95814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<95814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<95973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<95999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<95999,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<95999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<95999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<96011,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<96020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<96064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<96064,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<96065,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<96086,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<96130,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<96449,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<96449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<96461,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<96466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<96473,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<96473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<96497,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<96498,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<96499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<96499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<96509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<96514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<96514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<96564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<96564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<96699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<96749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<96749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<96759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<96814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<96949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<96949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<96965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<96966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<96973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<96973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<96999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<96999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<96999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<97009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<97012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<97014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<97064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<97064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<97199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<97249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<97249,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<97259,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<97314,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<97449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<97466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<97473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<97499,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<97499,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<97499,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<97499,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<97499,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<97509,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<97509,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<97514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<97519,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<97522,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<97564,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<97564,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<97564,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<97564,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<97699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<97949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<97966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<97973,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<97973,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<97973,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<97973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<97973,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<97999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<98014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<98064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<98249,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<98259,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<98314,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<98449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<98465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<98473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<98473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<98499,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<98499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<98499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<98512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<98516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<98564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<98564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<98749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<98749,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<98767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<98814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<98973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<98999,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<98999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<98999,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<98999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<99010,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<99013,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<99020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<99064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<99064,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<99064,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<99449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<99470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<99473,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<99473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<99473,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<99499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<99499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<99509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<99514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<99516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<99564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<99564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<99699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<99749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<99749,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<99759,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<99814,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<99949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<99949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<99962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<99970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<99973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<99973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<99999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<99999,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<99999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<100009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<100014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<100015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<100064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<100064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<100199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<100249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<100249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<100259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<100314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<100449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<100470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<100473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<100473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<100499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<100499,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<100499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<100499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<100509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<100514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<100517,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<100564,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<100564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<100564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<100749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<100767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<100814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<100973,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<100973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<100973,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<100999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<100999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<100999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<101012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<101020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<101064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<101064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<101249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<101249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<101273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<101314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<101449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<101465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<101473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<101473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<101499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<101499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<101499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<101512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<101520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<101564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<101564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<101749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<101749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<101770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<101814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<101973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<101999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<101999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<101999,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<102009,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<102013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<102064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<102064,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<102449,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<102467,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<102473,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<102473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<102473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<102499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<102516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<102564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<102749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<102770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<102814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<102949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<102962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<102973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<102973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<102999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<102999,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<102999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<103012,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<103020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<103064,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<103064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<103249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<103249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<103273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<103314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<103473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<103499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<103499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<103499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<103499,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<103512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<103514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<103517,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<103564,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<103564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<103564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<103973,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<103973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<103973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<103999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<103999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<104015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<104020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<104064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<104064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<104449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<104462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<104473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<104473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<104473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<104499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<104499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<104515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<104523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<104564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<104564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<104749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<104749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<104770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<104814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<104973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<104999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<104999,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<104999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<105009,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<105014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<105064,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<105064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<105473,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<105473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<105499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<105499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<105512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<105516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<105564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<105564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<105699,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<105723,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<105764,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<105799,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<105949,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<105973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<105973,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<105973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<105986,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<105999,0,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<105999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<105999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<106012,0,0,1,66,133>'))
ser.readline()
ser.write(bytes(b'<106014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<106015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<106064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<106064,0,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<106064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<106065,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<106078,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<106130,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<106449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<106470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<106473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<106473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<106486,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<106497,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<106498,0,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<106499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<106499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<106511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<106511,1,0,1,40,130>'))
ser.readline()
ser.write(bytes(b'<106564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<106564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<106973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<106973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<106999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<107015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<107064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<107449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<107462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<107473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<107473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<107499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<107515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<107564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<107923,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<107999,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<108011,1,0,1,40,130>'))
ser.readline()
ser.write(bytes(b'<108064,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<108473,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<108499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<108515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<108564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<108949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<108962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<108973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<108973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<108999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<108999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<109015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<109020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<109064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<109064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<109249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<109249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<109273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<109314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<109473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<109499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<109499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<109499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<109511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<109520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<109564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<109564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<109749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<109749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<109770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<109814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<109973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<109999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<109999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<109999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<110015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<110016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<110064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<110064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<110449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<110462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<110473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<110473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<110499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<110515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<110564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<110711,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<110749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<110770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<110814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<110973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<110999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<110999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<110999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<111019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<111023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<111064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<111064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<111473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<111473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<111499,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<111499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<111499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<111509,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<111512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<111515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<111564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<111564,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<111564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<111973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<111973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<111999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<111999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<112012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<112012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<112064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<112064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<112211,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<112249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<112259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<112314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<112473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<112473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<112499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<112499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<112499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<112509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<112513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<112564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<112564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<112749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<112749,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<112759,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<112814,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<112973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<112999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<112999,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<112999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<112999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<113009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<113012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<113016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<113064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<113064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<113064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<113249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<113249,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<113266,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<113314,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<113449,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<113465,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<113473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<113473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<113473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<113499,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<113499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<113499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<113517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<113520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<113564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<113564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<113749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<113749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<113767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<113814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<113973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<113999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<113999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<113999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<114014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<114016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<114064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<114064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<114473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<114499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<114499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<114512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<114515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<114564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<114564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<114973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<114973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<114999,1,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<114999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<115012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<115020,1,0,1,75,127>'))
ser.readline()
ser.write(bytes(b'<115064,1,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<115064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<115423,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<115473,1,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<115473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<115499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<115499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<115513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<115517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<115564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<115564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<115973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<115973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<115999,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<115999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<116009,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<116012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<116064,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<116064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<116249,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<116249,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<116266,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<116314,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<116449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<116462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<116473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<116473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<116499,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<116499,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<116517,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<116564,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<116749,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<116749,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<116767,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<116814,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<116973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<116999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<116999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<117014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<117016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<117064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<117064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<117249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<117249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<117267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<117314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<117473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<117499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<117499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<117499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<117512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<117520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<117564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<117564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<117949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<117965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<117973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<117973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<117999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<118012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<118064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<118448,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<118473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<118499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<118499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<118512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<118514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<118564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<118564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<118749,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<118749,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<118765,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<118814,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<118973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<118999,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<118999,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<118999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<118999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<119012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<119012,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<119016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<119064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<119064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<119064,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<119249,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<119249,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<119262,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<119314,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<119473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<119473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<119499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<119499,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<119499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<119499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<119512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<119512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<119517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<119564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<119564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<119564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<119749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<119749,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<119770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<119814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<119973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<119973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<119999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<119999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<119999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<120015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<120023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<120064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<120064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<120473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<120499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<120512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<120564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<120949,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<120962,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<120973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<120973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<120999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<121012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<121064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<121423,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<121473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<121499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<121499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<121511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<121511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<121564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<121564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<121666,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<121676,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<121731,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<121833,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<121843,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<121898,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<121916,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<121973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<121973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<121999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<121999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<122009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<122015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<122064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<122064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<122083,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<122166,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<122176,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<122231,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<122249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<122333,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<122343,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<122398,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<122416,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<122449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<122462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<122473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<122473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<122499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<122499,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<122509,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<122515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<122564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<122564,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<122583,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<122666,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<122676,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<122731,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<122749,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<122833,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<122850,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<122898,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<122916,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<122973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<122999,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<122999,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<122999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<123017,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<123019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<123022,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<123064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<123064,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<123064,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<123083,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<123166,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<123187,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<123231,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<123249,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<123333,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<123357,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<123398,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<123416,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<123473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<123473,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<123499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<123499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<123514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<123520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<123564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<123564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<123583,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<123666,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<123687,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<123731,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<123749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<123833,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<123851,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<123898,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<123916,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<123949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<123965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<123973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<123973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<123999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<123999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<124012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<124012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<124064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<124064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<124083,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<124166,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<124179,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<124231,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<124249,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<124333,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<124349,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<124398,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<124416,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<124473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<124499,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<124499,0,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<124499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<124510,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<124512,0,0,1,66,133>'))
ser.readline()
ser.write(bytes(b'<124513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<124564,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<124564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<124564,0,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<124583,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<124666,0,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<124679,0,0,1,64,133>'))
ser.readline()
ser.write(bytes(b'<124731,0,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<124749,0,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<124833,0,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<124846,0,0,1,63,134>'))
ser.readline()
ser.write(bytes(b'<124849,0,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<124898,0,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<124973,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<124973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<124999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<124999,0,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<125012,0,0,1,64,133>'))
ser.readline()
ser.write(bytes(b'<125014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<125064,0,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<125064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<125083,0,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<125166,0,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<125179,0,0,1,66,133>'))
ser.readline()
ser.write(bytes(b'<125231,0,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<125249,0,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<125333,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<125349,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<125398,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<125416,0,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<125449,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<125466,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<125473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<125473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<125499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<125499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<125512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<125512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<125564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<125564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<125583,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<125666,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<125679,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<125731,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<125749,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<125833,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<125851,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<125898,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<125916,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<125973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<125999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<125999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<125999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<126014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<126017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<126020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<126064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<126064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<126064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<126083,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<126166,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<126187,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<126231,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<126249,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<126333,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<126357,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<126398,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<126416,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<126473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<126473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<126499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<126499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<126515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<126520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<126564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<126564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<126583,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<126666,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<126684,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<126731,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<126749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<126833,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<126850,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<126898,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<126916,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<126949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<126962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<126973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<126973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<126999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<126999,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<127009,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<127015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<127064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<127064,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<127083,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<127166,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<127176,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<127231,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<127249,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<127333,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<127343,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<127398,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<127416,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<127473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<127499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<127499,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<127499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<127509,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<127513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<127517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<127564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<127564,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<127564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<127583,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<127973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<127973,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<127999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<128016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<128064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<128448,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<128449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<128462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<128473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<128473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<128499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<128499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<128499,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<128509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<128512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<128517,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<128564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<128564,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<128564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<128973,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<128973,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<128973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<128999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<128999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<128999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<128999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<129014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<129016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<129017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<129020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<129064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<129064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<129064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<129064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<129473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<129473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<129499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<129515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<129564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<129849,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<129948,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<129949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<129962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<129973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<129973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<129999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<129999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<129999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<130012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<130015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<130020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<130064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<130064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<130064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<130473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<130473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<130473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<130499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<130499,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<130499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<130499,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<130509,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<130514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<130517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<130517,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<130564,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<130564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<130564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<130564,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<130973,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<130973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<130999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<130999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<131012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<131016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<131064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<131064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<131211,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<131211,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<131249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<131270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<131314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<131473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<131473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<131499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<131499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<131499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<131499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<131512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<131512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<131523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<131564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<131564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<131564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<131749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<131749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<131770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<131814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<131973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<131973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<131999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<131999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<131999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<132012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<132023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<132064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<132064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<132473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<132499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<132515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<132564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<132949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<132962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<132973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<132973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<132999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<133012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<133064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<133423,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<133473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<133499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<133511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<133564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<133949,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<133949,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<133949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<133959,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<133961,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<133970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<133973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<133973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<133999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<134014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<134014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<134014,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<134064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<134199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<134199,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<134449,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<134449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<134449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<134459,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<134465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<134470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<134473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<134473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<134499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<134512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<134514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<134514,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<134564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<134699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<134699,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<134949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<134949,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<134959,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<134970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<134973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<134999,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<134999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<135014,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<135014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<135019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<135022,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<135064,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<135064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<135199,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<135199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<135449,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<135449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<135459,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<135470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<135473,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<135473,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<135473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<135473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<135499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<135514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<135564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<135749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<135749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<135759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<135767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<135814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<135814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<135949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<135965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<135973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<135973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<135999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<135999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<135999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<135999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<135999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<136009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<136012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<136020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<136064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<136064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<136064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<136249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<136249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<136249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<136249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<136259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<136273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<136314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<136314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<136473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<136499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<136499,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<136499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<136499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<136499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<136499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<136509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<136510,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<136513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<136520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<136564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<136564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<136564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<136564,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<136749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<136749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<136749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<136773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<136814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<136973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<136973,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<136999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<136999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<136999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<137016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<137020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<137064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<137064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<137249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<137249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<137267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<137314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<137449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<137462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<137473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<137473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<137499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<137499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<137499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<137515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<137516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<137564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<137564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<137749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<137749,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<137759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<137814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<137973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<137999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<137999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<137999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<137999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<138014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<138016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<138017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<138064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<138064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<138064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<138249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<138249,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<138259,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<138314,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<138473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<138473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<138499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<138499,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<138499,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<138509,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<138512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<138564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<138564,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<138749,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<138749,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<138759,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<138814,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<138949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<138965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<138973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<138973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<138999,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<138999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<138999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<139009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<139012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<139064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<139064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<139249,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<139249,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<139259,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<139314,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<139473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<139499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<139499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<139499,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<139499,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<139509,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<139509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<139513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<139564,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<139564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<139564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<139749,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<139749,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<139766,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<139814,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<139973,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<139973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<139999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<139999,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<139999,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<140016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<140017,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<140064,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<140064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<140249,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<140249,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<140266,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<140314,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<140449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<140462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<140473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<140473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<140499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<140499,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<140499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<140509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<140512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<140564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<140564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<140749,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<140749,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<140759,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<140814,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<140973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<140999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<140999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<140999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<140999,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<141009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<141014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<141017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<141064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<141064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<141064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<141249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<141249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<141259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<141314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<141473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<141473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<141499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<141499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<141499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<141509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<141515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<141564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<141564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<141749,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<141749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<141766,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<141814,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<141949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<141962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<141973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<141973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<141999,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<141999,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<141999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<142015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<142017,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<142064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<142064,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<142249,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<142249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<142270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<142314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<142473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<142499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<142499,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<142499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<142499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<142509,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<142514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<142523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<142564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<142564,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<142564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<142973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<142973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<142973,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<142999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<142999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<142999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<143012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<143016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<143017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<143064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<143064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<143064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<143249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<143249,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<143270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<143314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<143473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<143473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<143499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<143499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<143499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<143499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<143512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<143512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<143520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<143564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<143564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<143564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<143749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<143749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<143773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<143814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<143973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<143973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<143999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<143999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<143999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<143999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<144012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<144012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<144020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<144064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<144064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<144064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<144473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<144473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<144473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<144499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<144499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<144517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<144520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<144564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<144564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<144949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<144949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<144962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<144965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<144973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<144973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<144973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<144973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<144999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<144999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<145020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<145023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<145064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<145064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<145473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<145473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<145499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<145511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<145564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<145949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<145949,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<145949,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<145959,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<145961,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<145966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<145973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<145973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<145999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<146014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<146014,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<146014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<146064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<146199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<146199,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<146449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<146449,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<146449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<146459,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<146465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<146466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<146473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<146473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<146499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<146512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<146514,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<146514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<146564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<146699,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<146699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<146949,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<146949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<146959,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<146966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<146973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<146999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<146999,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<147014,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<147014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<147019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<147022,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<147064,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<147064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<147199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<147199,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<147449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<147449,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<147459,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<147466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<147473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<147473,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<147473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<147473,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<147499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<147514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<147564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<147749,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<147749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<147759,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<147759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<147814,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<147814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<147949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<147965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<147973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<147973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<147999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<147999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<147999,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<147999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<147999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<148009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<148012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<148016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<148064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<148064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<148064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<148249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<148249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<148249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<148249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<148259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<148267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<148314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<148314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<148473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<148499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<148499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<148499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<148499,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<148499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<148510,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<148513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<148520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<148564,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<148564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<148564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<148949,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<148959,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<148973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<148973,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<148973,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<148973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<148999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<149016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<149064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<149249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<149259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<149314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<149449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<149462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<149473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<149473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<149499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<149499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<149499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<149509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<149515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<149564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<149564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<149749,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<149749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<149766,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<149814,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<149973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<149999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<149999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<149999,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<149999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<150014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<150017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<150020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<150064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<150064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<150064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<150249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<150249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<150267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<150314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<150473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<150473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<150499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<150499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<150499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<150512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<150516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<150564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<150564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<150749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<150749,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<150759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<150814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<150949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<150965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<150973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<150973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<150999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<150999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<150999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<151012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<151016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<151064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<151064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<151249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<151249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<151270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<151314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<151473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<151499,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<151499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<151499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<151499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<151509,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<151513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<151520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<151564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<151564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<151564,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<151973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<151973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<151973,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<151999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<151999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<152016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<152016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<152064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<152064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<152249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<152249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<152267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<152314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<152449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<152462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<152473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<152473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<152499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<152499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<152499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<152512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<152520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<152564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<152564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<152749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<152749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<152773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<152814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<152973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<152999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<152999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<152999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<153017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<153020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<153064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<153064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<153249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<153249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<153270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<153314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<153449,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<153464,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<153473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<153473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<153499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<153499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<153520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<153564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<153749,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<153749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<153762,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<153814,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<153949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<153965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<153973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<153999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<153999,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<153999,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<154012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<154012,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<154064,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<154064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<154249,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<154249,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<154265,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<154314,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<154473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<154499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<154499,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<154499,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<154509,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<154512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<154564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<154564,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<154749,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<154749,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<154765,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<154814,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<154949,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<154964,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<154973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<154973,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<154999,0,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<154999,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<154999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<155012,0,0,1,66,133>'))
ser.readline()
ser.write(bytes(b'<155013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<155064,0,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<155064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<155249,0,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<155249,0,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<155266,0,0,1,61,135>'))
ser.readline()
ser.write(bytes(b'<155314,0,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<155499,0,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<155499,0,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<155512,0,0,1,63,134>'))
ser.readline()
ser.write(bytes(b'<155564,0,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<155749,0,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<155749,0,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<155762,0,0,1,64,133>'))
ser.readline()
ser.write(bytes(b'<155814,0,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<155948,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<155986,0,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<155999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<155999,0,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<156012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<156012,0,0,1,66,133>'))
ser.readline()
ser.write(bytes(b'<156064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<156064,0,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<156473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<156499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<156499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<156514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<156515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<156564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<156564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<156948,0,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<156999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<157017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<157064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<157249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<157249,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<157270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<157314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<157448,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<157448,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<157499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<157499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<157499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<157513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<157520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<157564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<157564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<157749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<157749,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<157767,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<157814,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<157973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<157999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<157999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<157999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<157999,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<158012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<158015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<158020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<158064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<158064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<158064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<158711,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<158749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<158770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<158814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<158948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<158948,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<158999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<158999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<158999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<159014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<159020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<159064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<159064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<159473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<159473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<159499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<159499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<159499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<159512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<159515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<159516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<159564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<159564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<159564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<159973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<159999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<160020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<160064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<160448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<160448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<160473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<160499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<160499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<160499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<160512,0,0,1,69,129>'))
ser.readline()
ser.write(bytes(b'<160514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<160520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<160564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<160564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<160564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<160749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<160749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<160770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<160814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<160973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<160973,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<160999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<160999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<160999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<160999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<161012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<161016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<161017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<161064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<161064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<161064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<161473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<161499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<161520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<161564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<161749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<161749,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<161770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<161814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<161948,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<161948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<161999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<161999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<161999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<162012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<162014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<162064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<162064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<162473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<162499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<162499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<162512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<162515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<162564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<162564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<162948,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<162999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<163017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<163064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<163249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<163249,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<163270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<163314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<163448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<163448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<163499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<163499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<163499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<163513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<163520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<163564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<163564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<163749,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<163749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<163767,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<163814,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<163973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<163999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<163999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<163999,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<163999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<164012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<164015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<164020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<164064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<164064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<164064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<164711,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<164749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<164770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<164814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<164948,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<164948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<164999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<164999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<164999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<165014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<165020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<165064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<165064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<165473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<165473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<165499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<165499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<165499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<165512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<165515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<165516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<165564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<165564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<165564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<165973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<165999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<166020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<166064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<166448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<166448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<166473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<166499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<166499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<166514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<166520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<166564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<166564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<166749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<166749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<166770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<166814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<166973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<166999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<166999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<166999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<166999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<166999,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<167012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<167012,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<167016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<167017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<167064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<167064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<167064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<167064,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<167473,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<167473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<167499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<167520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<167564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<167749,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<167749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<167770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<167814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<167948,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<167948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<167999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<167999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<167999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<168014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<168023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<168064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<168064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<168473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<168499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<168499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<168512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<168515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<168564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<168564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<168948,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<168999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<169020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<169064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<169249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<169249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<169273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<169314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<169448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<169448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<169499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<169499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<169499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<169513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<169520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<169564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<169564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<169749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<169749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<169770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<169814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<169973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<169999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<169999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<169999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<169999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<169999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<170009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<170012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<170015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<170016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<170064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<170064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<170064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<170064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<170473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<170473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<170499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<170499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<170512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<170517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<170564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<170564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<170711,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<170711,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<170749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<170749,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<170759,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<170770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<170814,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<170814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<170973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<170973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<170999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<170999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<170999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<170999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<170999,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<171009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<171014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<171023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<171064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<171064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<171064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<171473,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<171473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<171473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<171499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<171499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<171499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<171499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<171509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<171512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<171515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<171516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<171564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<171564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<171564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<171564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<171973,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<171973,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<171999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<171999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<172009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<172023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<172064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<172064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<172448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<172448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<172473,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<172473,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<172499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<172499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<172499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<172509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<172514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<172520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<172564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<172564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<172564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<172973,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<172973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<172973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<172999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<172999,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<173016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<173017,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<173064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<173064,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<173449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<173462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<173473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<173473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<173473,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<173499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<173499,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<173499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<173512,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<173516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<173520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<173564,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<173564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<173564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<173749,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<173749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<173749,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<173749,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<173759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<173770,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<173814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<173814,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<173973,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<173999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<173999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<173999,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<173999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<173999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<174009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<174014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<174023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<174064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<174064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<174064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<174473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<174499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<174499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<174512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<174515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<174564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<174564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<175423,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<175423,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<175448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<175448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<175499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<175513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<175564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<175749,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<175767,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<175814,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<175973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<175999,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<175999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<175999,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<176009,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<176012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<176064,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<176064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<176249,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<176249,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<176266,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<176314,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<176449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<176462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<176473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<176473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<176499,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<176499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<176499,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<176517,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<176517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<176564,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<176564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<176749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<176749,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<176770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<176814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<176973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<176999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<176999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<176999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<177014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<177016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<177064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<177064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<177473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<177499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<177499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<177512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<177515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<177564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<177564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<178186,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<178249,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<178262,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<178314,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<178448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<178448,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<178499,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<178499,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<178499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<178499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<178499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<178512,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<178514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<178516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<178517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<178564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<178564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<178564,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<178564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<178749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<178749,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<178749,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<178770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<178814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<178999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<178999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<179020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<179064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<179249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<179249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<179273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<179314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<179499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<179499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<179520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<179564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<179749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<179749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<179767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<179814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<179923,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<179923,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<179999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<179999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<179999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<179999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<180012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<180015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<180016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<180064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<180064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<180064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<182848,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<182848,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<182848,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<182999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<183011,1,0,1,52,126>'))
ser.readline()
ser.write(bytes(b'<183064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<183473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<183499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<183515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<183564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<183949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<183962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<183973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<183973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<183999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<184015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<184064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<184473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<184499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<184511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<184564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<184973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<184999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<185015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<185064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<185449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<185462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<185473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<185473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<185499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<185515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<185564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<185973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<185999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<186011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<186064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<186473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<186499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<186515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<186564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<186949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<186962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<186973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<186973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<186999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<187015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<187064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<187473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<187499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<187511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<187564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<187973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<187999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<188015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<188064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<188449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<188462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<188473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<188473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<188499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<188499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<188515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<188520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<188564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<188564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<188749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<188749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<188773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<188814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<188973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<188999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<188999,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<188999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<188999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<189011,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<189011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<189020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<189064,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<189064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<189064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<189249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<189249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<189270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<189314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<189473,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<189473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<189499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<189499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<189499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<189515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<189516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<189564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<189564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<189949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<189962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<189973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<189973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<189999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<190015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<190064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<190211,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<190249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<190270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<190314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<190473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<190499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<190499,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<190499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<190499,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<190519,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<190522,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<190523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<190564,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<190564,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<190564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<190973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<190973,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<190973,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<190999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<190999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<191015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<191016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<191064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<191064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<191449,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<191462,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<191473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<191473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<191473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<191499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<191499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<191512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<191523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<191564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<191564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<191973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<191973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<191999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<191999,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<191999,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<192010,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<192013,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<192020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<192064,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<192064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<192064,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<192249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<192249,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<192267,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<192314,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<192473,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<192473,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<192499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<192499,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<192499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<192514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<192520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<192564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<192564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<192949,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<192966,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<192973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<192973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<192999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<193012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<193064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<193211,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<193249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<193270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<193314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<193473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<193499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<193499,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<193499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<193499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<193514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<193517,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<193520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<193564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<193564,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<193564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<193973,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<193973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<193999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<194015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<194064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<194448,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<194449,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<194462,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<194473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<194473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<194499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<194499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<194515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<194520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<194564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<194564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<194749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<194749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<194770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<194814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<194973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<194999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<194999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<194999,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<195009,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<195017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<195064,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<195064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<195449,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<195463,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<195473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<195473,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<195473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<195499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<195520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<195564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<195949,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<195966,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<195973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<195973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<195999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<195999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<196012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<196020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<196064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<196064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<196249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<196249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<196273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<196314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<196473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<196499,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<196499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<196499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<196499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<196512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<196514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<196517,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<196564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<196564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<196564,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<196973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<196973,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<196973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<196999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<196999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<197015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<197020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<197064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<197064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<197449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<197462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<197473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<197473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<197473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<197499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<197499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<197515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<197523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<197564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<197564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<197749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<197749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<197770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<197814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<197973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<197999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<197999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<197999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<197999,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<198009,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<198014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<198017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<198064,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<198064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<198064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<198065,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<198086,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<198130,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<198449,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<198467,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<198473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<198473,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<198497,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<198497,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<198498,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<198499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<198499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<198512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<198516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<198564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<198564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<198749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<198770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<198814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<198973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<198973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<198999,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<198999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<198999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<198999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<199012,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<199012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<199023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<199064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<199064,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<199064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<199249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<199249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<199270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<199314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<199473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<199473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<199499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<199499,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<199499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<199499,1,0,1,35,210>'))
ser.readline()
ser.write(bytes(b'<199512,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<199514,1,0,1,35,126>'))
ser.readline()
ser.write(bytes(b'<199523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<199564,1,0,1,35,81>'))
ser.readline()
ser.write(bytes(b'<199564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<199564,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<199973,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<199973,1,0,0,35,0>'))
ser.readline()
ser.write(bytes(b'<199999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<200015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<200064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<200448,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<200449,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<200462,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<200473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<200473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<200499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<200499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<200512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<200520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<200564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<200564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<200749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<200749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<200773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<200814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<200973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<200999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<200999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<200999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<200999,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<201011,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<201011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<201020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<201064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<201064,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<201064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<201249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<201249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<201270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<201314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<201473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<201473,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<201499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<201499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<201499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<201499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<201509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<201514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<201516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<201564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<201564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<201564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<201949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<201965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<201973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<201999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<202012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<202014,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<202064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<202199,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<202211,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<202211,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<202249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<202249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<202270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<202270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<202314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<202314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<202449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<202465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<202473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<202473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<202499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<202499,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<202499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<202499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<202499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<202512,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<202520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<202523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<202564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<202564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<202564,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<202973,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<202973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<202973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<202999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<202999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<202999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<203009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<203012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<203016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<203064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<203064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<203064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<203449,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<203462,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<203473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<203473,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<203473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<203473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<203499,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<203499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<203512,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<203523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<203564,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<203564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<203973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<203973,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<203999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<203999,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<203999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<204013,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<204016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<204020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<204064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<204064,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<204064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<204249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<204449,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<204467,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<204473,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<204473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<204499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<204499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<204509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<204512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<204514,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<204564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<204564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<204699,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<204949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<204949,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<204965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<204967,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<204973,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<204973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<204973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<204973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<204999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<204999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<205009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<205023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<205064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<205064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<205249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<205249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<205249,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<205249,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<205259,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<205270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<205314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<205314,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<205499,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<205499,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<205499,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<205499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<205499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<205499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<205512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<205514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<205516,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<205517,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<205564,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<205564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<205564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<205564,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<205973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<205973,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<205999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<205999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<206012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<206015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<206064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<206064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<206349,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<206448,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<206499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<206512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<206564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<206948,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<206948,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<206973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<206999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<206999,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<207013,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<207017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<207064,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<207064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<207473,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<207473,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<207499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<207499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<207499,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<207512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<207516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<207520,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<207564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<207564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<207564,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<207973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<207973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<207999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<207999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<208015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<208020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<208064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<208064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<208249,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<208249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<208249,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<208249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<208262,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<208273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<208314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<208314,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<208448,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<208499,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<208499,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<208499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<208499,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<208512,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<208514,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<208564,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<208564,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<208973,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<208973,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<208999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<208999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<208999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<209012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<209015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<209020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<209064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<209064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<209064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<209473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<209499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<209523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<209564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<209749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<209749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<209770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<209814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<209948,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<209948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<209999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<209999,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<209999,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<210014,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<210017,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<210064,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<210064,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<210065,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<210086,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<210130,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<210449,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<210449,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<210462,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<210467,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<210473,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<210473,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<210497,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<210497,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<210498,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<210499,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<210499,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<210512,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<210516,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<210564,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<210564,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<210749,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<210749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<210762,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<210770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<210814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<210814,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<210973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<210973,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<210999,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<210999,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<210999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<210999,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<210999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<211012,1,0,1,47,120>'))
ser.readline()
ser.write(bytes(b'<211012,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<211023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<211064,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<211064,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<211064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<211249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<211449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<211470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<211473,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<211473,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<211486,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<211499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<211511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<211564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<211973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<211999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<212015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<212064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<212449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<212462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<212473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<212473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<212499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<212515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<212564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<212923,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<212999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<213011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<213064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<213473,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<213499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<213515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<213564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<213949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<213962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<213973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<213973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<213999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<213999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<214015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<214020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<214064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<214064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<214249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<214249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<214267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<214314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<214473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<214499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<214499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<214499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<214511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<214520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<214564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<214564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<214949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<214966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<214973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<214973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<214999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<214999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<215009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<215014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<215015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<215064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<215064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<215199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<215249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<215249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<215259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<215314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<215449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<215449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<215462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<215466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<215473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<215473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<215499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<215499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<215499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<215509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<215514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<215515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<215564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<215564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<215699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<215749,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<215749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<215759,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<215814,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<215949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<215966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<215973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<215999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<215999,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<215999,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<215999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<216009,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<216009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<216014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<216019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<216064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<216064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<216064,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<216199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<216449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<216466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<216473,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<216473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<216473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<216473,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<216499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<216499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<216515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<216523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<216564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<216564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<216749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<216749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<216759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<216814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<216949,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<216962,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<216973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<216973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<216999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<216999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<216999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<217012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<217016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<217064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<217064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<217249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<217249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<217267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<217314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<217473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<217499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<217499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<217513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<217564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<217949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<217970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<217973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<217999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<217999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<217999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<218009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<218012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<218014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<218016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<218064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<218064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<218064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<218199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<218249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<218249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<218259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<218314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<218449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<218470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<218473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<218473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<218499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<218499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<218499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<218499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<218509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<218514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<218515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<218517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<218564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<218564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<218564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<218699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<218749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<218749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<218759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<218814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<218949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<218970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<218973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<218973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<218999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<218999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<218999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<219009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<219014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<219014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<219064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<219064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<219199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<219449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<219470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<219473,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<219473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<219473,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<219499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<219512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<219564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<219749,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<219767,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<219814,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<219949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<219965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<219973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<219973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<219999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<219999,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<219999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<220012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<220020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<220064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<220064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<220249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<220249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<220273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<220314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<220473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<220499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<220499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<220513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<220564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<220949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<220970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<220973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<220999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<221012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<221014,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<221064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<221199,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<221449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<221449,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<221462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<221470,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<221473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<221473,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<221473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<221749,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<221770,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<221814,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<221949,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<221967,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<221973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<221999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<221999,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<222014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<222064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<222473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<222499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<222512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<222564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<222949,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<222949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<222965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<222970,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<222973,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<222973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<222973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<222999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<223012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<223064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<223249,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<223270,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<223314,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<223473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<223499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<223499,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<223514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<223564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<223949,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<223973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<223973,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<223999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<224012,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<224064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<224249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<224270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<224314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<224449,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<224462,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<224473,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<224473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<224499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<224499,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<224499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<224517,1,0,1,73,127>'))
ser.readline()
ser.write(bytes(b'<224523,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<224564,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<224564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<224749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<224749,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<224770,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<224814,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<224973,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<224999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<224999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<224999,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<225015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<225023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<225064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<225064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<225473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<225499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<225512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<225564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<225948,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<225949,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<225962,1,0,1,66,123>'))
ser.readline()
ser.write(bytes(b'<225973,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<225973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<225999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<225999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<225999,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<226012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<226020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<226020,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<226064,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<226064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<226064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<226249,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<226249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<226249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<226249,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<226267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<226273,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<226314,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<226314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<226473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<226499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<226499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<226499,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<226499,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<226511,1,0,1,40,126>'))
ser.readline()
ser.write(bytes(b'<226520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<226564,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<226564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<226565,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<226586,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<226630,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<226949,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<226949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<226961,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<226966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<226973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<226973,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<226997,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<226998,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<226999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<226999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<227009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<227014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<227014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<227064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<227064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<227199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<227249,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<227249,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<227259,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<227314,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<227449,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<227449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<227465,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<227466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<227473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<227473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<227499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<227499,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<227499,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<227509,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<227512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<227514,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<227564,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<227564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<227699,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<227749,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<227749,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<227759,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<227814,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<227949,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<227966,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<227973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<227999,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<227999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<227999,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<227999,1,0,1,39,210>'))
ser.readline()
ser.write(bytes(b'<227999,1,0,1,51,210>'))
ser.readline()
ser.write(bytes(b'<228009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<228009,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<228014,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<228019,1,0,1,51,121>'))
ser.readline()
ser.write(bytes(b'<228022,1,0,1,39,120>'))
ser.readline()
ser.write(bytes(b'<228064,1,0,1,51,94>'))
ser.readline()
ser.write(bytes(b'<228064,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<228064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<228064,1,0,1,39,94>'))
ser.readline()
ser.write(bytes(b'<228199,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<228449,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<228466,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<228473,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<228473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<228473,1,0,0,39,0>'))
ser.readline()
ser.write(bytes(b'<228473,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<228473,1,0,0,51,0>'))
ser.readline()
ser.write(bytes(b'<228499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<228514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<228564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<228749,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<228759,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<228814,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<228949,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<228965,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<228973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<228973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<228999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<228999,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<228999,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<229012,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<229016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<229064,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<229064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<229249,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<229249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<229267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<229314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<229473,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<229499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<229499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<229499,1,0,1,49,210>'))
ser.readline()
ser.write(bytes(b'<229499,1,0,1,37,210>'))
ser.readline()
ser.write(bytes(b'<229510,1,0,1,37,122>'))
ser.readline()
ser.write(bytes(b'<229513,1,0,1,49,122>'))
ser.readline()
ser.write(bytes(b'<229520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<229564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<229564,1,0,1,49,95>'))
ser.readline()
ser.write(bytes(b'<229564,1,0,1,37,78>'))
ser.readline()
ser.write(bytes(b'<229949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<229970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<229973,1,0,0,37,0>'))
ser.readline()
ser.write(bytes(b'<229973,1,0,0,49,0>'))
ser.readline()
ser.write(bytes(b'<229973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<229999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<229999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<230009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<230014,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<230016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<230064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<230064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<230199,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<230249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<230249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<230259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<230314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<230449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<230449,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<230462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<230470,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<230473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<230473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<230499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<230499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<230499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<230509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<230514,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<230515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<230564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<230564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<230699,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<230749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<230749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<230759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<230814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<230949,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<230970,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<230973,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<230973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<230999,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<230999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<230999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<230999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<231009,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<231014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<231017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<231064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<231064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<231064,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<231249,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<231267,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<231314,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<231473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<231473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<231473,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<231499,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<231499,1,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<231499,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<231512,1,0,1,63,124>'))
ser.readline()
ser.write(bytes(b'<231520,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<231564,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<231564,1,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<231749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<231749,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<231773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<231814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<231949,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<231965,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<231973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<231973,1,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<231999,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<231999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<231999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<232012,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<232020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<232064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<232064,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<232249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<232249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<232270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<232314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<232473,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<232499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<232499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<232499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<232513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<232517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<232564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<232564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<232973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<232973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<232999,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<232999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<232999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<233012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<233012,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<233020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<233064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<233064,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<233064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<233473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<233499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<233520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<233564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<233749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<233749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<233773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<233814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<233948,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<233948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<233999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<233999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<233999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<234012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<234014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<234064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<234064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<234473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<234499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<234499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<234499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<234512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<234515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<234520,0,0,1,76,132>'))
ser.readline()
ser.write(bytes(b'<234564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<234564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<234564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<235186,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<235211,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<235249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<235270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<235314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<235448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<235448,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<235499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<235499,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<235499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<235513,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<235517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<235564,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<235564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<235973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<235973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<235999,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<235999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<235999,1,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<236012,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<236012,1,0,1,69,126>'))
ser.readline()
ser.write(bytes(b'<236020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<236064,1,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<236064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<236064,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<236473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<236499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<236520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<236564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<236749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<236749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<236773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<236814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<236948,1,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<236948,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<236999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<236999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<236999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<237012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<237014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<237064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<237064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<237473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<237499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<237499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<237512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<237515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<237564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<237564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<237948,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<237999,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<237999,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<238009,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<238020,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<238064,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<238064,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<238249,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<238249,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<238249,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<238249,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<238259,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<238270,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<238314,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<238314,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<238448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<238448,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<238499,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<238499,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<238499,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<238499,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<238499,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<238509,1,0,1,45,126>'))
ser.readline()
ser.write(bytes(b'<238509,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<238517,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<238564,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<238564,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<238564,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<238949,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<238963,1,0,1,57,123>'))
ser.readline()
ser.write(bytes(b'<238973,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<238973,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<238973,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<238973,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<238999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<238999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<238999,0,0,1,87,210>'))
ser.readline()
ser.write(bytes(b'<238999,0,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<239009,0,0,1,87,150>'))
ser.readline()
ser.write(bytes(b'<239011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<239016,1,0,1,61,125>'))
ser.readline()
ser.write(bytes(b'<239020,0,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<239064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<239064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<239064,0,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<239064,0,0,1,87,78>'))
ser.readline()
ser.write(bytes(b'<239473,0,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<239473,0,0,0,87,0>'))
ser.readline()
ser.write(bytes(b'<239499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<239499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<239509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<239520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<239564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<239564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<239749,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<239749,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<239749,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<239749,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<239759,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<239773,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<239814,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<239814,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<239948,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<239948,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<239999,1,0,1,44,210>'))
ser.readline()
ser.write(bytes(b'<239999,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<239999,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<239999,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<239999,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<239999,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<240012,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<240014,1,0,1,56,123>'))
ser.readline()
ser.write(bytes(b'<240016,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<240017,1,0,1,44,121>'))
ser.readline()
ser.write(bytes(b'<240064,1,0,1,44,87>'))
ser.readline()
ser.write(bytes(b'<240064,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<240064,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<240064,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<240473,1,0,0,44,0>'))
ser.readline()
ser.write(bytes(b'<240473,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<240473,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<240473,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<240499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<240499,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<240499,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<240499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<240499,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<240509,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<240512,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<240515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<240515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<240520,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<240564,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<240564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<240564,1,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<240564,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<240564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<240973,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<240973,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<240999,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<240999,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<241009,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<241023,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<241064,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<241064,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<241249,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<241249,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<241249,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<241249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<241259,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<241270,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<241314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<241314,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<241448,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<241448,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<241448,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<241499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<241499,1,0,1,42,210>'))
ser.readline()
ser.write(bytes(b'<241499,1,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<241499,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<241509,1,0,1,42,122>'))
ser.readline()
ser.write(bytes(b'<241514,1,0,1,54,121>'))
ser.readline()
ser.write(bytes(b'<241564,1,0,1,42,94>'))
ser.readline()
ser.write(bytes(b'<241564,1,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<241949,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<241949,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<241959,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<241967,0,0,1,81,145>'))
ser.readline()
ser.write(bytes(b'<241973,1,0,0,42,0>'))
ser.readline()
ser.write(bytes(b'<241973,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<241973,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<241973,1,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<241999,1,0,1,61,210>'))
ser.readline()
ser.write(bytes(b'<241999,1,0,1,66,210>'))
ser.readline()
ser.write(bytes(b'<242012,1,0,1,66,127>'))
ser.readline()
ser.write(bytes(b'<242016,1,0,1,61,129>'))
ser.readline()
ser.write(bytes(b'<242064,1,0,1,61,78>'))
ser.readline()
ser.write(bytes(b'<242064,1,0,1,66,78>'))
ser.readline()
ser.write(bytes(b'<242249,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<242249,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<242259,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<242270,0,0,1,80,146>'))
ser.readline()
ser.write(bytes(b'<242314,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<242314,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<242473,1,0,0,61,0>'))
ser.readline()
ser.write(bytes(b'<242473,1,0,0,66,0>'))
ser.readline()
ser.write(bytes(b'<242499,1,0,1,35,210>'))
ser.readline()
ser.write(bytes(b'<242499,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<242499,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<242499,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<242499,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<242499,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<242509,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<242512,1,0,1,47,125>'))
ser.readline()
ser.write(bytes(b'<242514,1,0,1,35,131>'))
ser.readline()
ser.write(bytes(b'<242523,0,0,1,78,136>'))
ser.readline()
ser.write(bytes(b'<242564,1,0,1,35,81>'))
ser.readline()
ser.write(bytes(b'<242564,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<242564,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<242564,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<242749,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<242749,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<242949,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<242949,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<242959,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<242970,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<242973,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<242973,1,0,0,35,0>'))
ser.readline()
ser.write(bytes(b'<242986,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<242986,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<242999,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<243011,1,0,1,40,144>'))
ser.readline()
ser.write(bytes(b'<243064,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<243498,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<243499,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<243515,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<243564,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<243949,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<243962,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<243973,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<243973,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<243999,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<244015,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<244064,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<244473,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<244499,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<244511,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<244564,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<244973,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<244999,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<245015,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<245064,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<245449,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<245462,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<245473,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<245473,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<245499,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<245515,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<245564,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<245973,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<245999,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<246011,1,0,1,52,123>'))
ser.readline()
ser.write(bytes(b'<246064,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<246503,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<246530,1,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<246546,1,0,1,59,124>'))
ser.readline()
ser.write(bytes(b'<246595,1,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<247011,1,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<247024,1,0,1,64,123>'))
ser.readline()
ser.write(bytes(b'<247034,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<247034,1,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<247542,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<247558,1,0,1,68,128>'))
ser.readline()
ser.write(bytes(b'<247565,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<248098,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<248111,1,0,1,71,128>'))
ser.readline()
ser.write(bytes(b'<248119,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<248704,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<248704,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<248725,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<248725,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<248769,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<248769,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<248982,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<248982,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<248998,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<249016,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<249063,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<249276,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<249292,1,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<249313,1,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<249357,1,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<249369,1,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<249390,1,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<249434,1,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<249830,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<249840,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<249895,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<250080,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<250418,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<250418,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<250428,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<250435,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<250438,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<250438,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<251054,1,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<251055,1,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<251056,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<251069,1,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<251121,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<251134,1,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<251155,1,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<251199,1,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<251211,1,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<251235,1,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<251276,1,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<251595,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<251595,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<251605,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<251612,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<251642,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<251643,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<251939,0,0,1,97,210>'))
ser.readline()
ser.write(bytes(b'<251939,0,0,1,85,210>'))
ser.readline()
ser.write(bytes(b'<251949,0,0,1,97,150>'))
ser.readline()
ser.write(bytes(b'<251949,0,0,1,85,150>'))
ser.readline()
ser.write(bytes(b'<252004,0,0,1,97,78>'))
ser.readline()
ser.write(bytes(b'<252004,0,0,1,85,78>'))
ser.readline()
ser.write(bytes(b'<252217,0,0,0,97,0>'))
ser.readline()
ser.write(bytes(b'<252217,0,0,0,85,0>'))
ser.readline()
ser.write(bytes(b'<252233,0,0,1,95,210>'))
ser.readline()
ser.write(bytes(b'<252233,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<252243,0,0,1,95,150>'))
ser.readline()
ser.write(bytes(b'<252250,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<252298,0,0,1,95,78>'))
ser.readline()
ser.write(bytes(b'<252298,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<252511,0,0,0,95,0>'))
ser.readline()
ser.write(bytes(b'<252511,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<252527,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<252527,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<252537,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<252545,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<252592,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<252592,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<252805,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<252805,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<252819,1,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<252819,1,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<252820,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<252821,1,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<252839,1,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<252886,1,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<252898,1,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<252919,1,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<252963,1,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<253359,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<253359,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<253369,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<253380,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<253424,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<253424,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<253609,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<253609,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<253948,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<253948,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<253958,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<253967,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<253967,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<254583,1,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<254585,1,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<254586,1,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<254602,1,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<254651,1,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<254663,1,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<254676,1,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<254728,1,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<254740,1,0,1,75,210>'))
ser.readline()
ser.write(bytes(b'<254761,1,0,1,75,137>'))
ser.readline()
ser.write(bytes(b'<254805,1,0,1,75,78>'))
ser.readline()
ser.write(bytes(b'<255124,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<255124,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<255134,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<255145,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<255172,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<255173,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<255468,0,0,1,81,210>'))
ser.readline()
ser.write(bytes(b'<255468,0,0,1,93,210>'))
ser.readline()
ser.write(bytes(b'<255478,0,0,1,93,150>'))
ser.readline()
ser.write(bytes(b'<255486,0,0,1,81,144>'))
ser.readline()
ser.write(bytes(b'<255533,0,0,1,81,78>'))
ser.readline()
ser.write(bytes(b'<255533,0,0,1,93,78>'))
ser.readline()
ser.write(bytes(b'<255746,0,0,0,81,0>'))
ser.readline()
ser.write(bytes(b'<255746,0,0,0,93,0>'))
ser.readline()
ser.write(bytes(b'<255762,0,0,1,92,210>'))
ser.readline()
ser.write(bytes(b'<255762,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<255772,0,0,1,92,150>'))
ser.readline()
ser.write(bytes(b'<255783,0,0,1,80,145>'))
ser.readline()
ser.write(bytes(b'<255827,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<255827,0,0,1,92,78>'))
ser.readline()
ser.write(bytes(b'<256041,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<256041,0,0,0,92,0>'))
ser.readline()
ser.write(bytes(b'<256056,0,0,1,78,210>'))
ser.readline()
ser.write(bytes(b'<256056,0,0,1,90,210>'))
ser.readline()
ser.write(bytes(b'<256066,0,0,1,90,150>'))
ser.readline()
ser.write(bytes(b'<256080,0,0,1,78,138>'))
ser.readline()
ser.write(bytes(b'<256121,0,0,1,90,78>'))
ser.readline()
ser.write(bytes(b'<256121,0,0,1,78,78>'))
ser.readline()
ser.write(bytes(b'<256335,0,0,0,78,0>'))
ser.readline()
ser.write(bytes(b'<256335,0,0,0,90,0>'))
ser.readline()
ser.write(bytes(b'<256348,1,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<256348,1,0,0,75,0>'))
ser.readline()
ser.write(bytes(b'<256349,1,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<256351,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<256364,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<256416,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<256428,0,0,1,73,210>'))
ser.readline()
ser.write(bytes(b'<256446,0,0,1,73,137>'))
ser.readline()
ser.write(bytes(b'<256493,0,0,1,73,78>'))
ser.readline()
ser.write(bytes(b'<256505,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<256526,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<256570,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<256585,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<256595,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<256650,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<258090,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<258113,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<258113,0,0,0,73,0>'))
ser.readline()
ser.write(bytes(b'<258114,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<258115,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<258115,1,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<258130,1,0,1,56,133>'))
ser.readline()
ser.write(bytes(b'<258131,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<258180,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<258180,1,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<258240,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<258261,0,0,1,76,138>'))
ser.readline()
ser.write(bytes(b'<258303,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<258305,0,0,1,76,78>'))
ser.readline()
ser.write(bytes(b'<258316,0,0,1,71,138>'))
ser.readline()
ser.write(bytes(b'<258350,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<258365,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<258490,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<258591,0,0,1,69,210>'))
ser.readline()
ser.write(bytes(b'<258604,0,0,1,69,135>'))
ser.readline()
ser.write(bytes(b'<258656,0,0,1,69,78>'))
ser.readline()
ser.write(bytes(b'<258816,0,0,0,69,0>'))
ser.readline()
ser.write(bytes(b'<258830,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<258846,0,0,1,68,137>'))
ser.readline()
ser.write(bytes(b'<258895,0,0,1,68,78>'))
ser.readline()
ser.write(bytes(b'<259081,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<259096,0,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<259109,0,0,1,64,133>'))
ser.readline()
ser.write(bytes(b'<259161,0,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<259348,0,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<259363,0,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<259379,0,0,1,59,133>'))
ser.readline()
ser.write(bytes(b'<259428,0,0,1,59,78>'))
ser.readline()
ser.write(bytes(b'<259566,1,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<259568,1,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<259629,1,0,1,57,210>'))
ser.readline()
ser.write(bytes(b'<259643,1,0,1,57,133>'))
ser.readline()
ser.write(bytes(b'<259694,1,0,1,57,78>'))
ser.readline()
ser.write(bytes(b'<259915,1,0,0,57,0>'))
ser.readline()
ser.write(bytes(b'<259932,1,0,1,52,210>'))
ser.readline()
ser.write(bytes(b'<259944,1,0,1,52,133>'))
ser.readline()
ser.write(bytes(b'<259997,1,0,1,52,88>'))
ser.readline()
ser.write(bytes(b'<260218,1,0,0,52,0>'))
ser.readline()
ser.write(bytes(b'<260235,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<260248,1,0,1,47,131>'))
ser.readline()
ser.write(bytes(b'<260300,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<260521,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<260538,1,0,1,45,210>'))
ser.readline()
ser.write(bytes(b'<260548,1,0,1,45,135>'))
ser.readline()
ser.write(bytes(b'<260603,1,0,1,45,91>'))
ser.readline()
ser.write(bytes(b'<262573,1,0,0,45,0>'))
ser.readline()
ser.write(bytes(b'<262681,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<262682,0,0,1,54,210>'))
ser.readline()
ser.write(bytes(b'<262694,1,0,1,47,131>'))
ser.readline()
ser.write(bytes(b'<262697,0,0,1,54,131>'))
ser.readline()
ser.write(bytes(b'<262746,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<262747,0,0,1,54,87>'))
ser.readline()
ser.write(bytes(b'<262869,0,0,1,63,210>'))
ser.readline()
ser.write(bytes(b'<262882,0,0,1,63,134>'))
ser.readline()
ser.write(bytes(b'<262934,0,0,1,63,87>'))
ser.readline()
ser.write(bytes(b'<264674,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<264774,0,0,1,59,210>'))
ser.readline()
ser.write(bytes(b'<264790,0,0,1,59,133>'))
ser.readline()
ser.write(bytes(b'<264821,0,0,0,63,0>'))
ser.readline()
ser.write(bytes(b'<264821,0,0,0,59,0>'))
ser.readline()
ser.write(bytes(b'<264823,0,0,0,54,0>'))
ser.readline()
ser.write(bytes(b'<264824,1,0,1,40,210>'))
ser.readline()
ser.write(bytes(b'<264824,1,0,1,47,210>'))
ser.readline()
ser.write(bytes(b'<264824,0,0,1,56,210>'))
ser.readline()
ser.write(bytes(b'<264836,1,0,1,40,135>'))
ser.readline()
ser.write(bytes(b'<264837,1,0,1,47,131>'))
ser.readline()
ser.write(bytes(b'<264839,0,0,1,56,133>'))
ser.readline()
ser.write(bytes(b'<264889,1,0,1,40,93>'))
ser.readline()
ser.write(bytes(b'<264889,1,0,1,47,78>'))
ser.readline()
ser.write(bytes(b'<264889,0,0,1,56,88>'))
ser.readline()
ser.write(bytes(b'<265501,0,0,0,56,0>'))
ser.readline()
ser.write(bytes(b'<265539,0,0,1,64,210>'))
ser.readline()
ser.write(bytes(b'<265552,0,0,1,64,133>'))
ser.readline()
ser.write(bytes(b'<265604,0,0,1,64,78>'))
ser.readline()
ser.write(bytes(b'<266203,0,0,1,68,210>'))
ser.readline()
ser.write(bytes(b'<266216,0,0,0,68,0>'))
ser.readline()
ser.write(bytes(b'<266216,0,0,0,64,0>'))
ser.readline()
ser.write(bytes(b'<266917,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<266930,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<267632,0,0,1,76,210>'))
ser.readline()
ser.write(bytes(b'<267644,0,0,0,76,0>'))
ser.readline()
ser.write(bytes(b'<268346,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<268359,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<268396,0,0,1,83,210>'))
ser.readline()
ser.write(bytes(b'<268413,0,0,1,83,150>'))
ser.readline()
ser.write(bytes(b'<268461,0,0,1,83,78>'))
ser.readline()
ser.write(bytes(b'<268894,1,0,0,40,0>'))
ser.readline()
ser.write(bytes(b'<268894,1,0,0,47,0>'))
ser.readline()
ser.write(bytes(b'<269073,0,0,0,83,0>'))
ser.readline()
ser.write(bytes(b'<269156,0,0,1,71,210>'))
ser.readline()
ser.write(bytes(b'<269169,0,0,1,71,140>'))
ser.readline()
ser.write(bytes(b'<269204,0,0,1,80,210>'))
ser.readline()
ser.write(bytes(b'<269221,0,0,1,71,78>'))
ser.readline()
ser.write(bytes(b'<269225,0,0,1,80,146>'))
ser.readline()
ser.write(bytes(b'<269251,0,0,1,88,210>'))
ser.readline()
ser.write(bytes(b'<269261,0,0,1,88,150>'))
ser.readline()
ser.write(bytes(b'<269269,0,0,1,80,78>'))
ser.readline()
ser.write(bytes(b'<269316,0,0,1,88,78>'))
ser.readline()
ser.write(bytes(b'<273286,0,0,0,71,0>'))
ser.readline()
ser.write(bytes(b'<273286,0,0,0,80,0>'))
ser.readline()
ser.write(bytes(b'<273286,0,0,0,88,0>'))
ser.readline()
ser.write(bytes(b'<0,0,0,7,0,0>'))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.