content
stringlengths 7
1.05M
|
|---|
# Data processing
with open('input') as f:
in_data = [line.rstrip() for line in f]
for i in range(25, len(in_data)):
pre_i = in_data[i-25:i]
summed_pair_found = False
for a in pre_i:
for b in pre_i:
if a != b:
if int(a)+int(b) == int(in_data[i]):
summed_pair_found = True
if not summed_pair_found:
print(in_data[i])
exit()
|
#! python3
pessoas = [
{'nome': 'Pedro', 'idade': 11},
{'nome': 'Mariana', 'idade': 18},
{'nome': 'Arthur', 'idade': 26},
{'nome': 'Rebeca', 'idade': 6},
{'nome': 'Tiago', 'idade': 19},
{'nome': 'Gabriela', 'idade': 17},
]
menores = filter(lambda p: p['idade'] < 18, pessoas)
print(list(menores))
nomeMaiorede6caracteres = filter(lambda p: len(p['nome']) > 6, pessoas)
print(list(nomeMaiorede6caracteres)) |
#!/usr/bin/python3
# python实现集合
# Date: 2020-07-13
class Set:
"""列表实现集合"""
def __init__(self):
self.items = []
def add(self, item):
if item not in self.items:
self.items.append(item)
def clear(self):
self.items = []
def discard(self, item):
if item in self.items:
self.items.remove(item)
def remove(self, item):
if item in self.items:
self.items.remove(item)
else:
raise KeyError(f"Remove {item} from empty set")
def pop(self):
if len(self.items) != 0:
item = self.items[0]
self.items = self.items[1:]
else:
raise KeyError(f"Pop from empty set")
return item
if __name__ == "__main__":
s = Set()
s.add(1)
s.add(10)
s.add(100)
print(s.pop())
|
class Solution(object):
def mySqrt(self, x):
"""
:type x: int
:rtype: int
"""
if x < 0:
return -1
elif x == 0:
return 0
start, end = 1, x
while start + 1 < end:
mid = start + (end - start) / 2
if mid**2 == x:
return mid
elif mid**2 > x:
end = mid
else:
start = mid
return start
|
line = input()
a, b = line.split()
a = int(a)
b = int(b)
print(a + b)
|
def load(opt, splits):
"""
Load the TUF train dataset
:return:
"""
return {"train": [], "val": []} |
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
"""
Implement strStr().
Return the index of the first occurrence of needle in haystack,
or -1 if needle is not part of haystack.
>>> Solution().strStr("asdf", "")
0
>>> Solution().strStr("hello", "ll")
2
>>> Solution().strStr("aaaaa", "bba")
-1
>>> Solution().strStr("a", "a")
0
:param haystack: the string to find in
:param needle: the target substring
:return: the index of the substring
"""
if len(needle) == 0:
return 0
if len(haystack) == 0 or len(haystack) < len(needle):
return -1
return self.python_built_in(haystack, needle)
def python_built_in(self, haystack: str, needle: str) -> int:
"""
T: O(n)
The python built in method
:param haystack: the string to find in
:param needle: the target substring
:return: the index of the substring
"""
return haystack.index(needle) if needle in haystack else -1
def two_pointer(self, haystack: str, needle: str) -> int:
"""
T: O(n^2)
The two po9inter solution. Note: also the brute force solution
:param haystack: the string to find in
:param needle: the target substring
:return: the index of the substring
"""
idx = 0
while idx <= len(haystack) - len(needle):
if haystack[idx] == needle[0]:
is_match = True
num_char = 0
while num_char < len(needle):
if haystack[idx + num_char] != needle[num_char]:
is_match = False
break
num_char += 1
if is_match:
return idx
idx += 1
return -1
|
class ContentTypeSerializer(object):
"""
A ContentTypeSerializer handles the conversion from
a python data structure to a bytes object representing
the content in a particular content type.
"""
def content_type(self):
"""
return back what a list of content types
this serializer should support.
"""
raise NotImplementedError() # noqa
def main_type(self):
"""
return back a single content type that represents this
serializer.
"""
raise NotImplementedError() # noqa
def dump(data):
"""
should return back a bytes (or string in python 2),
representation of your object, to be used in e.g. response
bodies.
a ValueError should be returned in the case where
the object cannote be serialized.
"""
raise NotImplementedError() # noqa
def load(raw_bytes):
"""
given a bytes object, should return a base python data
structure that represents the object.
a ValueError should be returned in the case where
the object cannot be serialized.
"""
raise NotImplementedError() # noqa
def can_handle(content_type_name):
"""
given a content type, returns true if this serializer
can convert bodies of the given type.
"""
raise NotImplementedError() # noqa
|
employees_happiness = [int(happiness) for happiness in input().split()]
factor = int(input())
factored_employees_happiness = list(map(lambda h: h * factor, employees_happiness))
find_average_happiness = sum(factored_employees_happiness) / len(factored_employees_happiness)
happy_employees = [e for e in factored_employees_happiness if e >= find_average_happiness]
unhappy_employees = [e for e in factored_employees_happiness if e < find_average_happiness]
if len(happy_employees) >= len(unhappy_employees):
print(f'Score: {len(happy_employees)}/{len(employees_happiness)}. Employees are happy!')
else:
print(f'Score: {len(happy_employees)}/{len(employees_happiness)}. Employees are not happy!') |
db_config = {
'user': 'user',
'password': 'password',
'host': 'host.com',
'port': 12345,
'database': 'db-name',
"autocommit": True
} |
class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
"""
'''
T: O(m * n)
S: (m + n)
'''
nrow = len(matrix)
ncol = len(matrix[0])
rows, cols = set(), set()
for i in range(nrow):
for j in range(ncol):
if matrix[i][j] == 0:
rows.add(i)
cols.add(j)
for i in range(nrow):
for j in range(ncol):
if i in rows or j in cols:
matrix[i][j] = 0
|
# encoding: utf-8
"""
@version: v1.0
@author: Richard
@license: Apache Licence
@contact: [email protected]
@site:
@software: PyCharm
@time: 2019/9/8 9:37
"""
def get_remove_len(node_pth: list) -> int:
reversed_pth = list(reversed(node_pth))
pth_len = 0
lst_node = reversed_pth[0]
for node in reversed_pth[1:]:
pth_len += (lst_node - node - 1)
lst_node = node
return pth_len
def remove_n_chars_to_be_sub_str(s, p):
if p in s:
return 0
matrix = []
s_len = len(s)
for sub_chr in p:
matrix.append([i for i in range(s_len) if s[i] == sub_chr])
p_len = len(p)
first_nodes = matrix[0]
all_pths = []
for f_node in first_nodes:
pths = []
cur_node = f_node
pths.append(cur_node)
for i in range(1, p_len):
next_nodes = matrix[i]
next_nodes = list(filter(lambda n: n > cur_node, next_nodes))
if next_nodes:
pths.append(next_nodes[0])
cur_node = next_nodes[0]
if len(pths) == p_len:
all_pths.append(pths)
all_pths.sort(key=get_remove_len)
return get_remove_len(all_pths[0])
if __name__ == '__main__':
s = 'facbacdefacbabdfcadef'
p = 'fdef'
print(remove_n_chars_to_be_sub_str(s, p))
|
VALUE_TYPES = {
'short', 'int', 'long',
'uchar', 'ushort', 'uint', 'ulong',
'bool', 'float', 'double', 'size_t',
'uint8', 'int8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64',
}
VALA_TYPES = VALUE_TYPES | {
'char', 'string', 'void*', 'void**', 'time_t',
}
VALA_ALIASES = {
'unsigned int': 'uint',
'short unsigned int': 'ushort',
'unsigned long': 'ulong',
'int64_t': 'int64',
'uint64_t': 'uint64',
'long long': 'int64',
}
GLIB_TYPES = {
"GData": "GLib.Datalist",
}
|
num = float(input("Enter a Number: "))
if num > 0:
print("This is a Positive Number")
elif num == 0:
print("Zero")
else:
print("This is a Negative Number")
|
"""
borg.algorithms
===============
This package is intended for hash and checksum functions.
"""
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
@AUTHOR:Joselyn Zhao
@CONTACT:[email protected]
@HOME_PAGE:joselynzhao.top
@SOFTWERE:PyCharm
@FILE:20060402.py
@TIME:2020/6/4 21:17
@DES:7. 整数反转
'''
'''简单粗暴的错误方法'''
# def reverse(self, x: int) -> int:
# n = x
# listn = []
# while (n != 0):
# k = n % 10
# n = n / 10
# listn.append(k)
# lenl = len(listn)
# sum = 0
# for i in range(lenl):
# sum += listn[i] * pow(10, lenl - 1 - i)
# if x <= 0:
# sum = -sum
# return sum
# x = -123
#
# print(bin(x))
# n = bin(x)
# print(n)
# print(type(n))
# start_point = 2
# qianzui = '0b'
# if n[0]=='-':
# start_point=3
# qianzui='-0b'
# real_n = list(map(int,n[start_point:]))
# print(real_n)
# for i in range(len(real_n)):
# real_n[i]=1-real_n[i]
#
# print(real_n)
#
# out = qianzui+''.join(map(str,real_n))
# print(out)
#
# print(int(out,2))
x = 1563847412
fuhao = 0
if x<0:
x = -x
fuhao=-1
xx = list(str(x))
xxx = list(map(int,xx))
print(xxx)
sum = 0
lens = len(xxx)
for i in range(lens):
current = xxx[i]*pow(10, i)
sum += current
print(sum)
if sum>pow(2,32):
print(0)
if fuhao==-1:
sum=-sum
print(sum)
print(pow(2,31))
|
"""
Working with Binary Search Trees (BSTs).
The height of a binary search tree is the number of edges between the tree's
root and its furthest leaf. You are given a pointer, root, pointing to the
root of a binary search tree. Complete the getHeight function provided in your
editor so that it returns the height of the binary search tree.
Link: https://www.hackerrank.com/challenges/30-binary-search-trees/problem
Link: https://en.wikipedia.org/wiki/Binary_search_tree
"""
class Node:
def __init__(self,data):
self.right=self.left=None
self.data = data
class Solution:
def insert(self,root,data):
if root==None:
return Node(data)
else:
if data<=root.data:
cur=self.insert(root.left,data)
root.left=cur
else:
cur=self.insert(root.right,data)
root.right=cur
return root
def getHeight(self,root):
if root == None:
return -1
else:
return 1 + max( self.getHeight(root.left), self.getHeight(root.right) )
T=int(input())
myTree=Solution()
root=None
for i in range(T):
data=int(input())
root=myTree.insert(root,data)
height=myTree.getHeight(root)
print(f'Height: {height}') |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
class ContentType:
O365_CONNECTOR_CARD = "application/vnd.microsoft.teams.card.o365connector"
FILE_CONSENT_CARD = "application/vnd.microsoft.teams.card.file.consent"
FILE_DOWNLOAD_INFO = "application/vnd.microsoft.teams.file.download.info"
FILE_INFO_CARD = "application/vnd.microsoft.teams.card.file.info"
class Type:
O365_CONNECTOR_CARD_VIEWACTION = "ViewAction"
O365_CONNECTOR_CARD_OPEN_URI = "OpenUri"
O365_CONNECTOR_CARD_HTTP_POST = "HttpPOST"
O365_CONNECTOR_CARD_ACTION_CARD = "ActionCard"
O365_CONNECTOR_CARD_TEXT_INPUT = "TextInput"
O365_CONNECTOR_CARD_DATE_INPUT = "DateInput"
O365_CONNECTOR_CARD_MULTICHOICE_INPUT = "MultichoiceInput"
|
class Log:
lines = []
def __init__(self):
self.lines = []
def add(self, line):
self.lines.append(line)
def flush(self):
for line in self.lines:
print(line)
self.lines = []
battle_log = Log()
general_log = Log() |
num1 = 111
num2 = 222
num3 = 333333
num3 = 333
num4 = 4444
|
"""This module contains a collection of functions related to
flood data.
"""
#ml2015
def stations_level_over_threshold(stations,tol):
"""For Task 2B - returns a list of tuples
The tuples contain a station and then a relative water level
the relative water level must be greater than tol
returned list should be in descending order"""
threshold_list=[]
for station in stations:
m=station.relative_water_level()
if m==None:
pass
elif m>tol:
threshold_list.append((station, m))
final_threshold_list = sorted(threshold_list, key=lambda x: x[1], reverse=True)
return final_threshold_list
def stations_highest_rel_level(stations, N):
"""For Task 2C - returns a list of N stations at which relative typical water level is highest
List is sorted in descending order"""
list_highest_level = []
for station in stations:
m=station.relative_water_level()
if m==None:
pass
else:
list_highest_level.append((station,m))
sorted_list_highest_level = sorted(list_highest_level, key=lambda x: x[1], reverse=True)
i=0
short_list=[]
while i<N:
short_list.append(sorted_list_highest_level[i][0])
i+=1
return short_list
|
class MaterialPropertyMap:
def __init__(self):
self._lowCutoffs = []
self._highCutoffs = []
self._properties = []
def error_check(self, cutoff, conductivity):
if not isinstance(cutoff, tuple) or len(cutoff) != 2:
raise Exception("Cutoff has to be a tuple(int,int) specifying the low and high cutoffs")
for i in range(len(self._lowCutoffs)):
if (self._highCutoffs[i] >= cutoff[0] >= self._lowCutoffs[i]) \
or (self._highCutoffs[i] >= cutoff[1] >= self._lowCutoffs[i]):
raise Exception("Invalid material range. The range overlaps an existing material range")
check = False
if isinstance(conductivity, tuple):
if any(i < 0 for i in conductivity):
check = True
else:
if conductivity < 0:
check = True
if check:
raise Exception("Invalid conductivity. Must be positive")
return conductivity
def _append_inputs(self, cutoff, conductivity):
self._lowCutoffs.append(cutoff[0])
self._highCutoffs.append(cutoff[1])
self._properties.append(conductivity)
def get_size(self):
return len(self._lowCutoffs)
def get_material(self, i):
if i >= len(self._lowCutoffs):
raise Exception("Invalid index. Maximum size: " + str(self.get_size()))
if i < 0:
raise Exception("Invalid index. Must be >= 0")
return self._lowCutoffs[i], self._highCutoffs[i], self._properties[i]
def show(self):
print("Material conductivity as [low-high cutoffs] = conductivity:")
for i in range(len(self._lowCutoffs)):
print('[{} - {}] = {}'.format(self._lowCutoffs[i], self._highCutoffs[i], self._properties[i]))
class IsotropicConductivityMap(MaterialPropertyMap):
def __init__(self):
super().__init__()
def add_material(self, cutoff, conductivity):
conductivity = self.error_check(cutoff, conductivity)
if isinstance(conductivity, bool):
return
self._append_inputs(cutoff, conductivity)
class AnisotropicConductivityMap(MaterialPropertyMap):
def __init__(self):
super().__init__()
def add_material(self, cutoff, kxx, kyy, kzz, kxy, kxz, kyz):
conductivity = (kxx, kyy, kzz, kxy, kxz, kyz)
conductivity = self.error_check(cutoff, conductivity)
if isinstance(conductivity, bool):
return
self._append_inputs(cutoff, conductivity)
def add_isotropic_material(self, cutoff, k):
conductivity = (k, k, k, 0., 0., 0.)
conductivity = self.error_check(cutoff, conductivity)
if isinstance(conductivity, bool):
return
self._append_inputs(cutoff, conductivity)
def add_orthotropic_material(self, cutoff, kxx, kyy, kzz):
conductivity = (kxx, kyy, kzz, 0., 0., 0.)
conductivity = self.error_check(cutoff, conductivity)
if isinstance(conductivity, bool):
return
self._append_inputs(cutoff, conductivity)
def add_material_to_orient(self, cutoff, k_axial, k_radial):
conductivity = (k_axial, k_radial)
conductivity = self.error_check(cutoff, conductivity)
if isinstance(conductivity, bool):
return
self._append_inputs(cutoff, conductivity)
class ElasticityMap(MaterialPropertyMap):
def __init__(self):
super().__init__()
def add_material(self, cutoff, C11, C12, C13, C14, C15, C16, C22, C23, C24, C25, C26,
C33, C34, C35, C36, C44, C45, C46, C55, C56, C66):
elasticity = (C11, C12, C13, C14, C15, C16,
C22, C23, C24, C25, C26,
C33, C34, C35, C36,
C44, C45, C46,
C55, C56,
C66)
elasticity = self.error_check(cutoff, elasticity)
if isinstance(elasticity, bool):
return
self._append_inputs(cutoff, elasticity)
def add_isotropic_material(self, cutoff, E_youngmod, nu_poissrat):
Lambda = (nu_poissrat * E_youngmod) / ((1 + nu_poissrat) * (1 - 2 * nu_poissrat))
mu = E_youngmod / (2 * (1 + nu_poissrat))
elasticity = (Lambda + 2 * mu, Lambda, Lambda, 0., 0., 0.,
Lambda + 2 * mu, Lambda, 0., 0., 0.,
Lambda + 2 * mu, 0., 0., 0.,
2 * mu, 0., 0.,
2 * mu, 0.,
2 * mu)
elasticity = self.error_check(cutoff, elasticity)
if isinstance(elasticity, bool):
return
self._append_inputs(cutoff, elasticity)
def add_material_to_orient(self, cutoff, E_axial, E_radial, nu_poissrat_12, nu_poissrat_23, G12):
elasticity = (E_axial, E_radial, nu_poissrat_12, nu_poissrat_23, G12)
elasticity = self.error_check(cutoff, elasticity)
if isinstance(elasticity, bool):
return
self._append_inputs(cutoff, elasticity)
def show(self):
print("Material elasticity as [low-high cutoffs] = elasticity:")
for i in range(len(self._lowCutoffs)):
print('[{} - {}] = '.format(self._lowCutoffs[i], self._highCutoffs[i], self._properties[i]))
if len(self._properties[i]) == 5:
print('{}'.format(self._properties[i]))
else:
first_elast, last_elast = (0, 6)
for i2 in range(6):
print('{}'.format(self._properties[i][first_elast:last_elast]))
first_elast = last_elast
last_elast += 5 - i2
|
class EncodingApiCommunicator(object):
def __init__(self, inner):
self.inner = inner
def call(self, path, command, arguments=None, queries=None,
additional_queries=()):
path = path.encode()
command = command.encode()
arguments = self.transform_dictionary(arguments or {})
queries = self.transform_dictionary(queries or {})
promise = self.inner.call(
path, command, arguments, queries, additional_queries)
return self.decorate_promise(promise)
def transform_dictionary(self, dictionary):
return dict(self.transform_item(item) for item in dictionary.items())
def transform_item(self, item):
key, value = item
return (key.encode(), value)
def decorate_promise(self, promise):
return EncodedPromiseDecorator(promise)
class EncodedPromiseDecorator(object):
def __init__(self, inner):
self.inner = inner
def get(self):
response = self.inner.get()
return response.map(self.transform_row)
def __iter__(self):
return map(self.transform_row, self.inner)
def transform_row(self, row):
return dict(self.transform_item(item) for item in row.items())
def transform_item(self, item):
key, value = item
return (key.decode(), value)
|
class Person:
def __init__(self, first_name, last_name):
self.first_name = first_name
self.last_name = last_name
self.age = 0
def full_name(self):
return self.first_name + " " + self.last_name
def record_info(self):
return self.last_name + ", " + self.first_name
person = Person("Bob", "Smith")
person2 = Person("Sally", "Smith")
Person.record_info = record_info
myfn = Person.full_name
print(myfn(person2))
# print(Person)
# print(person)
# print(person.full_name())
# print(person.record_info())
# print(person.first_name)
# print(person.age)
# person.age = 34
# print(person.age)
# del person.first_name
# print(person.first_name)
|
class Node:
def __init__(self, data) -> None:
self.data = data
self.nextNode = None
class LinkedList:
def __init__(self):
self.head = None
self.numOfNodes = 0
def insert_new(self, data):
self.numOfNodes += 1
new_node = Node(data)
if not self.head:
self.head = new_node
else:
new_node.nextNode = self.head
self.head = new_node
def insert_to_end(self, data):
self.numOfNodes += 1
new_node = Node(data)
actual_node = self.head
while actual_node.nextNode is not None:
actual_node = actual_node.nextNode
actual_node.nextNode = new_node
def remove(self, data):
if self.head is None:
return
actual_node = self.head
previous = None
while actual_node is not None and actual_node.data != data:
previous = actual_node
actual_node = actual_node.nextNode
if actual_node is None:
return
if previous is None:
self.head = actual_node.nextNode
else:
previous.nextNode = actual_node.nextNode
@property
def get_size(self):
return self.numOfNodes
def traverse(self):
actual = self.head
while actual is not None:
print(actual.data)
actual = actual.nextNode
if __name__ == "__main__":
t = LinkedList()
t.insert_new(1)
t.insert_new(10)
print(t.get_size)
t.traverse()
|
adventures = [
{"id": 1, "name": "Test Location"},
{"id": 12, "name": "The Sewer"},
{"id": 15, "name": "The Spooky Forest"},
{"id": 16, "name": "The Haiku Dungeon"},
{"id": 17, "name": "The Hidden Temple"},
{"id": 18, "name": "Degrassi Knoll"},
{"id": 19, "name": "The Limerick Dungeon"},
{"id": 20, "name": 'The "Fun" House'},
{"id": 21, "name": "The Misspelled Cemetary (Pre-Cyrpt)"},
{"id": 22, "name": "Tower Ruins"},
{"id": 23, "name": "Drunken Stupor"},
{"id": 24, "name": "The Typical Tavern Rats"},
{"id": 25, "name": "The Typical Tavern Booze"},
{"id": 26, "name": "The Hippy Camp"},
{"id": 27, "name": "Orcish Frat House"},
{"id": 29, "name": "Orcish Frat House (In Disguise)"},
{"id": 30, "name": "The Bat Hole Entryway"},
{"id": 31, "name": "Guano Junction"},
{"id": 32, "name": "Batrat and Ratbat Burrow"},
{"id": 33, "name": "Beanbat Chamber"},
{"id": 34, "name": "The Boss Bat's Lair"},
{"id": 37, "name": "The Spectral Pickle Factory"},
{"id": 38, "name": "The Enormous Greater-Then Sign"},
{"id": 39, "name": "The Dungeons of Doom"},
{"id": 40, "name": "Cobb's Knob Kitchens"},
{"id": 41, "name": "Cobb's Knob Treasury"},
{"id": 42, "name": "Cobb's Knob Harem"},
{"id": 43, "name": "Outskirts of Camp Logging Camp"},
{"id": 44, "name": "Camp Logging Camp"},
{"id": 45, "name": "South of the Border"},
{"id": 46, "name": "Thugnderdome"},
{"id": 47, "name": "The Bugbear Pens (Pre-Quest)"},
{"id": 48, "name": "The Spooky Gravy Barrow"},
{"id": 49, "name": "The Bugbear Pens (Post-Quest)"},
{"id": 50, "name": "Knob Goblin Laboratory"},
{"id": 51, "name": "Cobb's Knob Menagerie, Level 1"},
{"id": 52, "name": "Cobb's Knob Menagerie, Level 2"},
{"id": 53, "name": "Cobb's Knob Menagerie, Level 3"},
{"id": 54, "name": "The Defiled Nook"},
{"id": 55, "name": "The Defiled Cranny"},
{"id": 56, "name": "The Defiled Alcove"},
{"id": 57, "name": "The Defiled Niche"},
{"id": 58, "name": "The Misspelled Cemetary (Post-Cyrpt)"},
{"id": 59, "name": "The Icy Peak in The Recent Past"},
{"id": 60, "name": "The Goatlet"},
{"id": 61, "name": "Itznotyerzitz Mine"},
{"id": 62, "name": "Lair of the Ninja Snowmen"},
{"id": 63, "name": "The eXtreme Slope"},
{"id": 65, "name": "The Hippy Camp"},
{"id": 66, "name": "The Obligatory Pirate's Cove"},
{"id": 67, "name": "The Obligatory Pirate's Cove (In Disguise)"},
{"id": 70, "name": "The Roulette Tables"},
{"id": 71, "name": "The Poker Room"},
{"id": 73, "name": "The Inexplicable Door"},
{"id": 75, "name": "The Dark Neck of the Woods"},
{"id": 76, "name": "The Dark Heart of the Woods"},
{"id": 77, "name": "The Dark Elbow of the Woods"},
{"id": 79, "name": "The Deep Fat Friar's Gate"},
{"id": 80, "name": "The Valley Beyond the Orc Chasm"},
{"id": 81, "name": "The Penultimate Fantasy Airship"},
{"id": 82, "name": "The Castle in the Clouds in the Sky"},
{"id": 83, "name": "The Hole in the Sky"},
{"id": 84, "name": "St. Sneaky Pete's Day Stupor"},
{"id": 85, "name": "A Battlefield (No Uniform)"},
{"id": 86, "name": "A BattleField (In Cloaca-Cola Uniform)"},
{"id": 87, "name": "A Battlefield (In Dyspepsi-Cola Uniform)"},
{"id": 88, "name": "Market Square, 28 Days Later"},
{"id": 89, "name": "The Mall of Loathing, 28 Days Later"},
{"id": 90, "name": "Wrong Side of the Tracks, 28 Days Later"},
{"id": 91, "name": "Noob Cave"},
{"id": 92, "name": "The Dire Warren"},
{"id": 93, "name": "Crimbo Town Toy Factory (2005)"},
{"id": 94, "name": "Crimbo Toy Town Factory (2005) (Protesting)"},
{"id": 96, "name": "An Incredibly Strange Place (Bad Trip)"},
{"id": 97, "name": "An Incredibly Strange Place (Great Trip)"},
{"id": 98, "name": "An Incredibly Strange Place (Mediocre Trip)"},
{"id": 99, "name": "The Road to White Citadel"},
{"id": 100, "name": "Whitey's Grove"},
{"id": 101, "name": "The Knob Shaft"},
{"id": 102, "name": "The Haunted Kitchen"},
{"id": 103, "name": "The Haunted Conservatory"},
{"id": 104, "name": "The Haunted Library"},
{"id": 105, "name": "The Haunted Billiards Room"},
{"id": 106, "name": "The Haunted Gallery"},
{"id": 107, "name": "The Haunted Bathroom"},
{"id": 108, "name": "The Haunted Bedroom"},
{"id": 109, "name": "The Haunted Ballroom"},
{"id": 110, "name": "The Icy Peak"},
{"id": 111, "name": "The Black Forest"},
{"id": 112, "name": "The Sleazy Back Alley"},
{"id": 113, "name": "The Haunted Pantry"},
{"id": 114, "name": "Outskirts of Cobb's Knob"},
{"id": 115, "name": "Simple Tool-Making Cave"},
{"id": 116, "name": "The Spooky Fright Factory"},
{"id": 117, "name": "The Crimborg Collective Factory"},
{"id": 118, "name": "The Hidden City"},
{"id": 119, "name": "The Palindome"},
{"id": 121, "name": "The Arid, Extra-Dry Desert (without Ultrahydrated)"},
{"id": 122, "name": "An Oasis"},
{"id": 123, "name": "The Arid, Extra-Dry Desert (with Ultrahydrated)"},
{"id": 124, "name": "The Upper Chamber"},
{"id": 125, "name": "The Middle Chamber"},
{"id": 126, "name": "The Themthar Hills"},
{"id": 127, "name": "The Hatching Chamber"},
{"id": 128, "name": "The Feeding Chamber"},
{"id": 129, "name": "The Guards' Chamber"},
{"id": 130, "name": "The Queen's Chamber"},
{"id": 131, "name": "Wartime Hippy Camp (In Frat Boy Ensemble)"},
{"id": 132, "name": "The Battlefield (In Frat Warrior Fatigues)"},
{"id": 133, "name": "Wartime Hippy Camp"},
{"id": 134, "name": "Wartime Frat House (In Filthy Hippy Disguise)"},
{"id": 135, "name": "Wartime Frat House"},
{"id": 136, "name": "Sonofa Beach"},
{"id": 137, "name": "McMillicancuddy's Barn"},
{"id": 139, "name": "The Junkyard"},
{"id": 140, "name": "The Battlefield (In War Hippy Fatigues)"},
{"id": 141, "name": "The Pond"},
{"id": 142, "name": "The Back 40"},
{"id": 143, "name": "The Other Back 40"},
{"id": 144, "name": "The Granary"},
{"id": 145, "name": "The Bog"},
{"id": 146, "name": "The Family Plot"},
{"id": 147, "name": "The Shady Thicket"},
{"id": 148, "name": "Heartbreaker's Hotel"},
{"id": 149, "name": "The Hippy Camp (Bombed Back to the Stone Age)"},
{"id": 150, "name": "The Orcish Frat House (Bombed Back to the Stone Age)"},
{"id": 151, "name": "The Stately Pleasure Dome"},
{"id": 152, "name": "The Mouldering Mansion"},
{"id": 153, "name": "The Rogue Windmill"},
{"id": 154, "name": "The Junkyard (Post-War)"},
{"id": 155, "name": "McMillicancuddy's Farm (Post-War)"},
{"id": 156, "name": "The Grim Grimacite Site"},
{"id": 157, "name": "Barrrney's Barrr"},
{"id": 158, "name": "The F'c'le"},
{"id": 159, "name": "The Poop Deck"},
{"id": 160, "name": "Belowdecks"},
{"id": 161, "name": "A Sinister Dodecahedron"},
{"id": 162, "name": "Crimbo Town Toy Factory (2007)"},
{"id": 163, "name": "A Yuletide Bonfire"},
{"id": 164, "name": "A Shimmering Portal"},
{"id": 166, "name": "A Maze of Sewer Tunnels"},
{"id": 167, "name": "Hobopolis Town Square"},
{"id": 168, "name": "Burnbarrel Blvd."},
{"id": 169, "name": "Exposure Esplanade"},
{"id": 170, "name": "The Heap"},
{"id": 171, "name": "The Ancient Hobo Burial Ground"},
{"id": 172, "name": "The Purple Light District"},
{"id": 173, "name": "Go for a Swim"},
{"id": 174, "name": "The Arrrboretum"},
{"id": 175, "name": "The Spectral Salad Factory"},
{"id": 177, "name": "Mt. Molehill"},
{"id": 178, "name": "Wine Racks (Northwest)"},
{"id": 179, "name": "Wine Racks (Northeast)"},
{"id": 180, "name": "Wine Racks (Southwest)"},
{"id": 181, "name": "Wine Racks (Southeast)"},
{"id": 182, "name": "Next to that Barrel with Something Burning in it"},
{"id": 183, "name": "Near an Abandoned Refrigerator"},
{"id": 184, "name": "Over Where the Old Tires Are"},
{"id": 185, "name": "Out By that Rusted-Out Car"},
]
|
font = {
' ' : [
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
],
'!' : [
' ',
' ',
' OO ',
' 88 ',
' || ',
' || ',
" `' ",
' ,, ',
' db ',
' ',
' ',
],
'"' : [
' ',
' gp gp ',
' \\/ \\/ ',
" `' `' ",
' ',
' ',
' ',
' ',
' ',
' ',
' ',
],
'#' : [
' ',
' ',
" ,M' dP ",
" dP .M' ",
' mmmMmmMmm ',
' MP dP ',
'mmdMmmMmmm ',
" ,M' dP ",
" dP ,M' ",
' ',
' ',
],
'$' : [
' ',
' M ',
' ,,,M.. ',
"'P M `db, ",
'8m._M `"\' ',
'`YMMM._ ',
' `MYMMb, ',
'M M .M8 ',
"YbmmMmd9' ",
' M ',
' ',
],
'%' : [
' ',
' ',
',M""Yg. ,M\' ',
"MY Mb ,M' ",
"8M. ,M9,M' ",
' `""\' ,M\',;:. ',
" ,M',MP Yb ",
" ,M' `M. .M: ",
",M' Ybmmd' ",
' ',
' ',
],
'&' : [
' ',
' ',
' ,gM""bg ',
' 8MI ,8 ',
' WMp," ',
' ,gPMN. jM"\' ',
",M. YMp.M' ",
'8Mp ,MMp ',
"`YMbmm'``MMm. ",
' ',
' ',
],
"'" : [
' ',
' gp ',
' \\/ ',
" `' ",
' ',
' ',
' ',
' ',
' ',
' ',
' ',
],
'(' : [
' ',
' ..',
" pd' ",
' 6P ',
"6M' ",
'MN ',
'MN ',
'YM. ',
' Mb ',
' Yq. ',
' ``',
],
')' : [
' ',
'.. ',
' `bq ',
' YA ',
' `Mb ',
' 8M ',
' 8M ',
' ,M9 ',
' dM ',
' .pY ',
"'' ",
],
'*' : [
' ',
' q p ',
' \\ / ',
'o=--*--=o ',
' / \\ ',
' d b ',
' ',
' ',
' ',
' ',
' ',
],
'+' : [
' ',
' ',
' ',
' ',
' M ',
' M ',
'mmmmMmmmm ',
' M ',
' M ',
' ',
' ',
],
',' : [
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ,, ',
' dg ',
' ,j ',
",' ",
],
'-' : [
' ',
' ',
' ',
' ',
' ',
' ',
'mmmmm ',
' ',
' ',
' ',
' ',
],
'.' : [
' ',
' ',
' ',
' ',
' ',
' ',
' ',
',, ',
'db ',
' ',
' ',
],
'/' : [
' ',
' AW ',
" ,M' ",
' MV ',
' AW ',
" ,M' ",
' MV ',
' AW ',
" ,M' ",
' MV ',
'AW ',
],
'0' : [
' ',
' ',
' ',
' ',
' ,pP""Yq. ',
"6W' `Wb ",
'8M M8 ',
'YA. ,A9 ',
" `Ybmmd9' ",
' ',
' ',
],
'1' : [
' ',
' ',
' ',
' __, ',
'`7MM ',
' MM ',
' MM ',
' MM ',
'.JMML.',
' ',
' ',
],
'2' : [
' ',
' ',
' ',
' ',
' pd*"*b. ',
'(O) j8 ',
' ,;j9 ',
" ,-=' ",
'Ammmmmmm ',
' ',
' ',
],
'3' : [
' ',
' ',
' ',
' ',
' pd""b. ',
'(O) `8b ',
' ,89 ',
' ""Yb. ',
' 88 ',
"(O) .M' ",
" bmmmd' ",
],
'4' : [
' ',
' ',
' ',
' ',
' ,AM ',
' AVMM ',
" ,W' MM ",
",W' MM ",
'AmmmmmMMmm ',
' MM ',
' MM ',
],
'5' : [
' ',
' ',
' ',
' ',
' M****** ',
'.M ',
'|bMMAg. ',
' `Mb ',
' jM ',
'(O) ,M9 ',
' 6mmm9 ',
],
'6' : [
' ',
' ',
' .6*" ',
" ,M' ",
',Mbmmm. ',
"6M' `Mb. ",
'MI M8 ',
'WM. ,M9 ',
' WMbmmd9 ',
' ',
' ',
],
'7' : [
' ',
' ',
' ',
' ',
"M******A' ",
"Y A' ",
" A' ",
" A' ",
" A' ",
" A' ",
" A' ",
],
'8' : [
' ',
' ',
' ,6*"*VA. ',
'dN V8 ',
'`MN. ,g9 ',
' ,MMMMq. ',
'6P `YMb ',
'8b `M9 ',
'`MmmmmM9 ',
' ',
' ',
],
'9' : [
' ',
' ',
' ',
' ',
' .d*"*bg. ',
'6MP Mb ',
'YMb MM ',
' `MbmmdM9 ',
" .M' ",
' .d9 ',
' m"\' ',
],
':' : [
' ',
' ',
' ',
' ',
' gp ',
' "" ',
' ',
' ,, ',
' db ',
' ',
' ',
],
';' : [
' ',
' ',
' ',
' ',
' gp ',
' "" ',
' ',
' ,, ',
' dg ',
' ,j ',
",' ",
],
'<' : [
' ',
' ',
' ',
" ,;//'",
" ,;//' ",
",//' ",
'`\\\\. ',
' `\\\\:. ',
' `\\\\.',
' ',
' ',
],
'=' : [
' ',
' ',
' ',
' ',
' ',
'mmmmmmmmm ',
' ',
'mmmmmmmmm ',
' ',
' ',
' ',
],
'>' : [
' ',
' ',
' ',
'`\\\\. ',
' `\\\\:. ',
' `\\\\.',
" ,;//'",
" ,;//' ",
",//' ",
' ',
' ',
],
'?' : [
' ',
' ',
',M"""b. ',
"89' `Mg ",
' ,M9 ',
" mMMY' ",
' MM ',
' ,, ',
' db ',
' ',
' ',
],
'@' : [
' ',
' ',
' ,.-==-. ',
" ,pd' `g. ",
' ,P ,dMb.A Y. ',
',P dP ,MP j8 ',
"8: dM' dM d' ",
"Wb YML.dML..d' ",
' Wb ``""^`"\' ',
' `M.. .,! ',
" `Ybmmd' ",
],
'A' : [
' ',
' ',
' db ',
' ;MM: ',
' ,V^MM. ',
' ,M `MM ',
' AbmmmqMA ',
" A' VML ",
'.AMA. .AMMA.',
' ',
' ',
],
'B' : [
' ',
' ',
'`7MM"""Yp, ',
' MM Yb ',
' MM dP ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
'.JMMmmmd9 ',
' ',
' ',
],
'C' : [
' ',
' ',
' .g8"""bgd ',
".dP' `M ",
"dM' ` ",
'MM ',
'MM. ',
"`Mb. ,' ",
' `"bmmmd\' ',
' ',
' ',
],
'D' : [
' ',
' ',
'`7MM"""Yb. ',
' MM `Yb. ',
' MM `Mb ',
' MM MM ',
' MM ,MP ',
" MM ,dP' ",
".JMMmmmdP' ",
' ',
' ',
],
'E' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM d ',
' MMmmMM ',
' MM Y , ',
' MM ,M ',
'.JMMmmmmMMM ',
' ',
' ',
],
'F' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM d ',
' MM""MM ',
' MM Y ',
' MM ',
'.JMML. ',
' ',
' ',
],
'G' : [
' ',
' ',
' .g8"""bgd ',
".dP' `M ",
"dM' ` ",
'MM ',
"MM. `7MMF'",
'`Mb. MM ',
' `"bmmmdPY ',
' ',
' ',
],
'H' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM MM ',
' MMmmmmmmMM ',
' MM MM ',
' MM MM ',
'.JMML. .JMML.',
' ',
' ',
],
'I' : [
' ',
' ',
"`7MMF'",
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
'.JMML.',
' ',
' ',
],
'J' : [
' ',
' ',
" `7MMF'",
' MM ',
' MM ',
' MM ',
' MM ',
'(O) MM ',
' Ymmm9 ',
' ',
' ',
],
'K' : [
' ',
' ',
"`7MMF' `YMM' ",
" MM .M' ",
' MM .d" ',
' MMMMM. ',
' MM VMA ',
' MM `MM. ',
'.JMML. MMb.',
' ',
' ',
],
'L' : [
' ',
' ',
"`7MMF' ",
' MM ',
' MM ',
' MM ',
' MM , ',
' MM ,M ',
'.JMMmmmmMMM ',
' ',
' ',
],
'M' : [
' ',
' ',
"`7MMM. ,MMF'",
' MMMb dPMM ',
' M YM ,M MM ',
" M Mb M' MM ",
" M YM.P' MM ",
" M `YM' MM ",
".JML. `' .JMML.",
' ',
' ',
],
'N' : [
' ',
' ',
"`7MN. `7MF'",
' MMN. M ',
' M YMb M ',
' M `MN. M ',
' M `MM.M ',
' M YMM ',
'.JML. YM ',
' ',
' ',
],
'O' : [
' ',
' ',
' .g8""8q. ',
".dP' `YM. ",
"dM' `MM ",
'MM MM ',
'MM. ,MP ',
"`Mb. ,dP' ",
' `"bmmd"\' ',
' ',
' ',
],
'P' : [
' ',
' ',
'`7MM"""Mq. ',
' MM `MM.',
' MM ,M9 ',
' MMmmdM9 ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'Q' : [
' ',
' ',
' .g8""8q. ',
".dP' `YM. ",
"dM' `MM ",
'MM MM ',
'MM. ,MP ',
"`Mb. ,dP' ",
' `"bmmd"\' ',
' MMb ',
" `bood'",
],
'R' : [
' ',
' ',
'`7MM"""Mq. ',
' MM `MM. ',
' MM ,M9 ',
' MMmmdM9 ',
' MM YM. ',
' MM `Mb. ',
'.JMML. .JMM.',
' ',
' ',
],
'S' : [
' ',
' ',
' .M"""bgd ',
',MI "Y ',
'`MMb. ',
' `YMMNq. ',
'. `MM ',
'Mb dM ',
'P"Ybmmd" ',
' ',
' ',
],
'T' : [
' ',
' ',
'MMP""MM""YMM ',
"P' MM `7 ",
' MM ',
' MM ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'U' : [
' ',
' ',
"`7MMF' `7MF'",
' MM M ',
' MM M ',
' MM M ',
' MM M ',
' YM. ,M ',
' `bmmmmd"\' ',
' ',
' ',
],
'V' : [
' ',
' ',
"`7MMF' `7MF'",
' `MA ,V ',
' VM: ,V ',
" MM. M' ",
" `MM A' ",
' :MM; ',
' VF ',
' ',
' ',
],
'W' : [
' ',
' ',
"`7MMF' A `7MF'",
' `MA ,MA ,V ',
' VM: ,VVM: ,V ',
" MM. M' MM. M' ",
" `MM A' `MM A' ",
' :MM; :MM; ',
' VF VF ',
' ',
' ',
],
'X' : [
' ',
' ',
"`YMM' `MP' ",
' VMb. ,P ',
" `MM.M' ",
' MMb ',
" ,M'`Mb. ",
' ,P `MM. ',
'.MM:. .:MMa.',
' ',
' ',
],
'Y' : [
' ',
' ',
"`YMM' `MM'",
' VMA ,V ',
' VMA ,V ',
' VMMP ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'Z' : [
' ',
' ',
'MMM"""AMV ',
"M' AMV ",
"' AMV ",
' AMV ',
' AMV , ',
' AMV ,M ',
'AMVmmmmMM ',
' ',
' ',
],
'[' : [
' ',
'mmmmm ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MMmmm ',
],
'\\' : [
' ',
'VM ',
' MA ',
' `M. ',
' VM ',
' MA ',
' `M. ',
' VM ',
' MA ',
' `M. ',
' VM ',
],
']' : [
' ',
'mmmmm ',
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
'mmmMM ',
],
'^' : [
' ',
' /\\ ',
' //\\\\ ',
'// \\\\',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
],
'_' : [
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
'mmmmmmm ',
],
'`' : [
' ',
" ,'",
";' ",
'bg ',
'"" ',
' ',
' ',
' ',
' ',
' ',
' ',
],
'a' : [
' ',
' ',
' ',
' ',
' ,6"Yb. ',
'8) MM ',
' ,pm9MM ',
'8M MM ',
'`Moo9^Yo.',
' ',
' ',
],
'b' : [
' ',
' ,, ',
'*MM ',
' MM ',
' MM,dMMb. ',
' MM `Mb ',
' MM M8 ',
' MM. ,M9 ',
" P^YbmdP' ",
' ',
' ',
],
'c' : [
' ',
' ',
' ',
' ',
' ,p6"bo ',
"6M' OO ",
'8M ',
'YM. , ',
" YMbmd' ",
' ',
' ',
],
'd' : [
' ',
' ,, ',
' `7MM ',
' MM ',
' ,M""bMM ',
',AP MM ',
'8MI MM ',
'`Mb MM ',
' `Wbmd"MML.',
' ',
' ',
],
'e' : [
' ',
' ',
' ',
' ',
' .gP"Ya ',
",M' Yb ",
'8M"""""" ',
'YM. , ',
" `Mbmmd' ",
' ',
' ',
],
'f' : [
' ',
' ,...',
' .d\' ""',
' dM` ',
' mMMmm ',
' MM ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'g' : [
' ',
' ',
' ',
' ',
' .P"Ybmmm ',
':MI I8 ',
' WmmmP" ',
'8M ',
' YMMMMMb ',
"6' dP ",
"Ybmmmd' ",
],
'h' : [
' ',
' ,, ',
'`7MM ',
' MM ',
' MMpMMMb. ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML JMML.',
' ',
' ',
],
'i' : [
' ',
' ,, ',
' db ',
' ',
'`7MM ',
' MM ',
' MM ',
' MM ',
'.JMML.',
' ',
' ',
],
'j' : [
' ',
' ,, ',
' db ',
' ',
' `7MM ',
' MM ',
' MM ',
' MM ',
' MM ',
'QO MP ',
'`bmP ',
],
'k' : [
' ',
' ',
'`7MM ',
' MM ',
" MM ,MP'",
' MM ;Y ',
' MM;Mm ',
' MM `Mb. ',
'.JMML. YA.',
' ',
' ',
],
'l' : [
' ',
' ,, ',
'`7MM ',
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
'.JMML.',
' ',
' ',
],
'm' : [
' ',
' ',
' ',
' ',
'`7MMpMMMb.pMMMb. ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMML JMML JMML.',
' ',
' ',
],
'n' : [
' ',
' ',
' ',
' ',
'`7MMpMMMb. ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML JMML.',
' ',
' ',
],
'name' : [
'G',
'e',
'o',
'r',
'g',
'i',
'a',
'1',
'1',
],
'o' : [
' ',
' ',
' ',
' ',
' ,pW"Wq. ',
"6W' `Wb ",
'8M M8 ',
'YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'p' : [
' ',
' ',
' ',
' ',
'`7MMpdMAo. ',
' MM `Wb ',
' MM M8 ',
' MM ,AP ',
" MMbmmd' ",
' MM ',
'.JMML. ',
],
'q' : [
' ',
' ',
' ',
' ',
' ,dW"Yvd ',
" ,W' MM ",
' 8M MM ',
' YA. MM ',
' `MbmdMM ',
' MM ',
' .JMML.',
],
'r' : [
' ',
' ',
' ',
' ',
'`7Mb,od8 ',
' MM\' "\' ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
's' : [
' ',
' ',
' ',
' ',
',pP"Ybd ',
'8I `" ',
'`YMMMa. ',
'L. I8 ',
"M9mmmP' ",
' ',
' ',
],
't' : [
' ',
' ',
' mm ',
' MM ',
'mmMMmm ',
' MM ',
' MM ',
' MM ',
' `Mbmo ',
' ',
' ',
],
'u' : [
' ',
' ',
' ',
' ',
'`7MM `7MM ',
' MM MM ',
' MM MM ',
' MM MM ',
' `Mbod"YML.',
' ',
' ',
],
'v' : [
' ',
' ',
' ',
' ',
"`7M' `MF'",
' VA ,V ',
' VA ,V ',
' VVV ',
' W ',
' ',
' ',
],
'w' : [
' ',
' ',
' ',
' ',
"`7M' ,A `MF'",
' VA ,VAA ,V ',
' VA ,V VA ,V ',
' VVV VVV ',
' W W ',
' ',
' ',
],
'x' : [
' ',
' ',
' ',
' ',
"`7M' `MF'",
" `VA ,V' ",
' XMX ',
" ,V' VA. ",
'.AM. .MA.',
' ',
' ',
],
'y' : [
' ',
' ',
' ',
' ',
"`7M' `MF'",
' VA ,V ',
' VA ,V ',
' VVV ',
' ,V ',
' ,V ',
'OOb" ',
],
'z' : [
' ',
' ',
' ',
' ',
'M"""MMV ',
"' AMV ",
' AMV ',
' AMV , ',
'AMMmmmM ',
' ',
' ',
],
'{' : [
' ',
' ,pm ',
' 6M ',
' MM ',
' M9 ',
'_.d"\' ',
'`"bp. ',
' Mb ',
' MM ',
' YM ',
' `bm ',
],
'|' : [
' ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
'MM ',
],
'}' : [
' ',
'mq. ',
' Mb ',
' MM ',
' YM ',
' `"b._',
' ,qd"\'',
' 6M ',
' MM ',
' M9 ',
"md' ",
],
'~' : [
' ',
' ',
' ',
' ',
' ',
' ,og. ,',
'" `6o" ',
' ',
' ',
' ',
' ',
],
'Α' : [
' ',
' ',
' db ',
' ;MM: ',
' ,V^MM. ',
' ,M `MM ',
' AbmmmqMA ',
" A' VML ",
'.AMA. .AMMA.',
' ',
' ',
],
'Β' : [
' ',
' ',
'`7MM"""Yp, ',
' MM Yb ',
' MM dP ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
'.JMMmmmd9 ',
' ',
' ',
],
'Γ' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM ',
' MM ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'Δ' : [
' ',
' ',
' db ',
' ;MM: ',
' ,V^MM. ',
' ,M `MM ',
" A' `MA ",
" A' VML ",
'AMMMMMMMMMMA ',
' ',
' ',
],
'Ε' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM d ',
' MMmmMM ',
' MM Y , ',
' MM ,M ',
'.JMMmmmmMMM ',
' ',
' ',
],
'Ζ' : [
' ',
' ',
'MMM"""AMV ',
"M' AMV ",
"' AMV ",
' AMV ',
' AMV , ',
' AMV ,M ',
'AMVmmmmMM ',
' ',
' ',
],
'Η' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM MM ',
' MMmmmmmmMM ',
' MM MM ',
' MM MM ',
'.JMML. .JMML.',
' ',
' ',
],
'Θ' : [
' ',
' ',
' .p8"""8q. ',
" 6M' `Mp ",
'6MP L J YMb ',
'8MI MMMMM IM8 ',
'YMb F 7 dM9 ',
' YM. ,M9 ',
' `Mbmmmd"\' ',
' ',
' ',
],
'Ι' : [
' ',
' ',
"`7MMF'",
' MM ',
' MM ',
' MM ',
' MM ',
' MM ',
'.JMML.',
' ',
' ',
],
'Κ' : [
' ',
' ',
"`7MMF' `YMM' ",
" MM .M' ",
' MM .d" ',
' MMMMM. ',
' MM VMA ',
' MM `MM. ',
'.JMML. MMb.',
' ',
' ',
],
'Λ' : [
' ',
' ',
' db ',
' ;MM: ',
' ,V^MM. ',
' ,M `MM ',
" A' `MA ",
" A' VML ",
'.AMA. .AMMA.',
' ',
' ',
],
'Μ' : [
' ',
' ',
"`7MMM. ,MMF'",
' MMMb dPMM ',
' M YM ,M MM ',
" M Mb M' MM ",
" M YM.P' MM ",
" M `YM' MM ",
".JML. `' .JMML.",
' ',
' ',
],
'Ν' : [
' ',
' ',
"`7MN. `7MF'",
' MMN. M ',
' M YMb M ',
' M `MN. M ',
' M `MM.M ',
' M YMM ',
'.JML. YM ',
' ',
' ',
],
'Ξ' : [
' ',
' ',
'MMMMMMMMMM ',
"P' `7 ",
"' L J ` ",
' MMMMMM ',
'. F 7 , ',
'L. ,J ',
'MMMMMMMMMM ',
' ',
' ',
],
'Ο' : [
' ',
' ',
' .p8""8q. ',
" 6M' `Mp ",
'6MP YMb ',
'8MI IM8 ',
'YMb dM9 ',
' YM. ,M9 ',
' `"bmmd"\' ',
' ',
' ',
],
'Π' : [
' ',
' ',
'`7MM""""""MMF\'',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML. .JMML.',
' ',
' ',
],
'Ρ' : [
' ',
' ',
'`7MM"""Mq. ',
' MM `MM.',
' MM ,M9 ',
' MMmmdM9 ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'Σ' : [
' ',
' ',
'VMA""YMM ',
' VMA `7 ',
' VMA ',
' XV ',
' AV , ',
' AV ,M ',
'AMMMMMMMF ',
' ',
' ',
],
'Τ' : [
' ',
' ',
'MMP""MM""YMM ',
"P' MM `7 ",
' MM ',
' MM ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'Υ' : [
' ',
' ',
"`YMM' `MM'",
' VMA ,V ',
' VMA ,V ',
' VMMP ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'Φ' : [
' ',
' ',
" `7MMF' ",
' ,mmmmMMmmmm. ',
'6MP MM YMb ',
'8M MM M8 ',
'YMb MM dM9 ',
" `YmmmMMmmmP' ",
' .JMML. ',
' ',
' ',
],
'Χ' : [
' ',
' ',
"`YMM' `MP' ",
' VMb. ,P ',
" `MM.M' ",
' MMb ',
" ,M'`Mb. ",
' ,P `MM. ',
'.MM:. .:MMa.',
' ',
' ',
],
'Ψ' : [
' ',
' ',
"`7MM `7MMF' MMF'",
' MM MM MM ',
' MM MM MM ',
' MM. MM ,MM ',
' YbmmMMmmdP ',
' MM ',
' .JMML. ',
' ',
' ',
],
'Ω' : [
' ',
' ',
' ,p^"^q. ',
' ,MV VM. ',
' 8M. ,M8 ',
' YM. ,MP ',
" `Mb dM' ",
'L b. .d J ',
'MMMMM. .MMMMM ',
' ',
' ',
],
'α' : [
' ',
' ',
' ',
' ',
' ,p"q.,M7 ',
"6W' `;W' ",
'8M AW ',
'YA. ,AP ',
' `Ybd9`Ybo ',
' ',
' ',
],
'β' : [
' ',
' ,,.. ',
" ,MF'``A. ",
" 6M .M' ",
' MM mmb. ',
' MM Yb ',
' MM b8 ',
' MM. p9 ',
" MM`bmd9' ",
' MM ',
' MM ',
],
'γ' : [
' ',
' ',
' ',
' ',
'`7MMq OO ',
' VAq ,MP ',
' VA. pd ',
' VA.V ',
' WW ',
' MM ',
' YP ',
],
'δ' : [
' ',
' ,,,.. ',
" dM'``OO ",
' `YMb. ',
' ,g"YMM. ',
" 6W' `Wb ",
' 8M M8 ',
' YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'ε' : [
' ',
' ',
' ',
' ',
' ,p6"bo ',
"8' OO ",
' >mm ',
'8I ,',
" `Mbmd' ",
' ',
' ',
],
'ζ' : [
' ',
' ',
' 6mmmmp ',
" ,M' ",
' ,dP ',
',MP ',
'MM ',
'WM. ',
' YMMMMq. ',
' ;8 ',
' "=--\' ',
],
'η' : [
' ',
' ',
' ',
' ',
'`7MMpMMMq. ',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
' MM ',
' MM ',
],
'θ' : [
' ',
' ,,.. ',
",6P`'Yb. ",
"6M' `Mb ",
'MM MM ',
'MM""""MM ',
"YM JM'",
'`M. ,M9 ',
" `YbdP' ",
' ',
' ',
],
'ι' : [
' ',
' ',
' ',
' ',
'`7MM ',
' MM ',
' MM ',
' MM ',
' YMbo ',
' ',
' ',
],
'κ' : [
' ',
' ',
' ',
' ',
'`7MM ,pO) ',
' MM ;P ',
' MM;N. ',
' MM YM. ',
' MM YMbo ',
' ',
' ',
],
'λ' : [
' ',
' ',
' (Ob. ',
' M ',
' db ',
' AMA. ',
" AM'`M ",
" ,M' db ",
"JM' Yb.",
' ',
' ',
],
'μ' : [
' ',
' ',
' ',
' ',
'MM MM ',
'MM MM ',
'MM MM ',
'MM MM ',
'MVbgd"\'Ybo ',
'M. ',
'M8 ',
],
'ν' : [
' ',
' ',
' ',
' ',
'`7WA OO ',
' VA ,V ',
' VA ,V ',
' VVV ',
' W ',
' ',
' ',
],
'ξ' : [
' ',
' ',
' 6ggmmm ',
" pP' ",
' bq. ',
' >mmmm ',
',MP ',
'`Mq. ',
' `"MMMq. ',
' ;8 ',
' "=--\' ',
],
'ο' : [
' ',
' ',
' ',
' ',
' ,pW"Wq. ',
"6W' `Wb ",
'8M M8 ',
'YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'π' : [
' ',
' ',
' ',
' ',
',mgmmmggmp ',
"' M MM ",
' M MM ',
' ,M MM ',
"O9' YMbo ",
' ',
' ',
],
'ρ' : [
' ',
' ',
' ',
' ',
' ,pW"Wq. ',
"6W' `Wb ",
'8M M8 ',
'MA. ,A9 ',
"MMYbmd9' ",
'MM ',
'MM ',
],
'ς' : [
' ',
' ',
' ',
' ',
' ,6""bo ',
'6W OO ',
'8M ',
'YM. ',
' `"MMMq. ',
' ;8 ',
' "=--\' ',
],
'σ' : [
' ',
' ',
' ',
' ',
' ,pW"Wmmmm ',
"6W' `Wb ",
'8M M8 ',
'YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'τ' : [
' ',
' ',
' ',
' ',
',mmggmmm ',
"' MM ",
' MM ',
' MM ',
' YMbo ',
' ',
' ',
],
'υ' : [
' ',
' ',
' ',
' ',
'odMp OMg ',
' MM `M.',
" MM M'",
' MM ,P ',
" `YMm9' ",
' ',
' ',
],
'φ' : [
' ',
' ',
' MM ',
' MM ',
' ,p8"MM"8q. ',
',MP MM YM. ',
'8M MM M8 ',
"`Mb MM JM' ",
" `YbmMMmdP' ",
' MM ',
' MM ',
],
'χ' : [
' ',
' ',
' ',
' ',
'oq. AV ',
' `M. AV ',
' `M.AV ',
' AV ',
' AV`M. ',
' AV `M. ',
' AV `bo ',
],
'ψ' : [
' ',
' ',
' ',
' ',
'oqb. MM Ob. ',
' MM MM YM ',
' MM MM M ',
' MM MM ,P ',
" `YbmMMmd' ",
' MM ',
' MM ',
],
'ω' : [
' ',
' ',
' ',
' ',
" .p' `q. ",
"6M' `Mb ",
'MM :M: MM ',
'YM :M: M9 ',
' Ybd9 Ybd9 ',
' ',
' ',
],
'ϕ' : [
' ',
' ',
' ',
' ',
' ,p\' .g"8b. ',
',MP MM `Mq ',
'8M: MM M8 ',
"`Mb MM JM' ",
" `YbmMMmd' ",
' MM ',
' MM ',
],
'Ё' : [
' qp qp ',
' "" "" ',
'`7MM"""YMM ',
' MM `7 ',
' MM d ',
' MMmmMM ',
' MM Y , ',
' MM ,M ',
'.JMMmmmmMMM ',
' ',
' ',
],
'А' : [
' ',
' ',
' db ',
' ;MM: ',
' ,V^MM. ',
' ,M `MM ',
' AbmmmqMA ',
" A' VML ",
'.AMA. .AMMA.',
' ',
' ',
],
'Б' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
'.JMMmmmd9 ',
' ',
' ',
],
'В' : [
' ',
' ',
'`7MM"""Yp, ',
' MM Yb ',
' MM dP ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
'.JMMmmmd9 ',
' ',
' ',
],
'Г' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM ',
' MM ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'Д' : [
' ',
' ',
' `7MP""MMF\' ',
' M MM ',
' P MM ',
" ;' MM ",
' ,9 MM ',
' ,9 MM ',
'gMmmmmmmMMmm ',
'MV VM ',
'V V ',
],
'Е' : [
' ',
' ',
'`7MM"""YMM ',
' MM `7 ',
' MM d ',
' MMmmMM ',
' MM Y , ',
' MM ,M ',
'.JMMmmmmMMM ',
' ',
' ',
],
'Ж' : [
' ',
' ',
"o8b. `7MMF' ,d8o ",
" `Yb MM 6P' ",
' Y. MM ,9 ',
' >bmMMmd< ',
" ,dP' MM `YM. ",
" dM' MM `Mb ",
'.dM .JMML. `Mba.',
' ',
' ',
],
'З' : [
' ',
' ',
' MgY""Yb. ',
" M' M8 ",
" ' ,M' ",
' ""Yg. ',
' `MM ',
'QQ dM ',
'`Ybmmmd" ',
' ',
' ',
],
'И' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM ,AMM ',
" MM ,A'MM ",
' MM AV MM ',
" MM,V' MM ",
" MMV' MM ",
'.JMML. .JMML.',
' ',
' ',
],
'Й' : [
' 69 69 ',
" `--' ",
"`7MMF' `7MMF'",
' MM ,AMM ',
" MM ,A'MM ",
' MM AV MM ',
" MM,V' MM ",
" MMV' MM ",
'.JMML. .JMML.',
' ',
' ',
],
'К' : [
' ',
' ',
"`7MMF' ,d8o ",
" MM 6P' ",
' MM ,9 ',
' MMmd< ',
' MM `YM. ',
' MM `Mb ',
'.JMML. `MMa.',
' ',
' ',
],
'Л' : [
' ',
' ',
' `7MP""MMF\'',
' M MM ',
' P MM ',
" j' MM ",
' ,9 MM ',
',.,9 MM ',
"OO' ,JMML.",
' ',
' ',
],
'М' : [
' ',
' ',
"`7MMM. ,MMF'",
' MMMb dPMM ',
' M YM ,M MM ',
" M Mb M' MM ",
" M YM.P' MM ",
" M `YM' MM ",
".JML. `' .JMML.",
' ',
' ',
],
'Н' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM MM ',
' MMmmmmmmMM ',
' MM MM ',
' MM MM ',
'.JMML. .JMML.',
' ',
' ',
],
'О' : [
' ',
' ',
' .p8"""8q. ',
" 6M' `Mp ",
'6MP YMb ',
'8MI IM8 ',
'YMb dM9 ',
' YM. ,M9 ',
' `Mbmmmd"\' ',
' ',
' ',
],
'П' : [
' ',
' ',
'`7MM"""""MMF\'',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML. .JMML.',
' ',
' ',
],
'Р' : [
' ',
' ',
'`7MM"""Mq. ',
' MM `MM.',
' MM ,M9 ',
' MMmmdM9 ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'С' : [
' ',
' ',
' .g8"""bgd ',
".dP' `M ",
"dM' ` ",
'MM ',
'MM. ',
"`Mb. ,' ",
' `"bmmmd\' ',
' ',
' ',
],
'Т' : [
' ',
' ',
'MMP""MM""YMM ',
"P' MM `7 ",
' MM ',
' MM ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'У' : [
' ',
' ',
"`YMM' `MM'",
' VMA ,V ',
' VMA ,V ',
' VMVMP ',
" YMP' ",
" QQ jM' ",
" 69bdP' ",
' ',
' ',
],
'Ф' : [
' ',
' ',
" `7MMF' ",
' ,mmmmMMmmmm. ',
'6MP MM YMb ',
'8M MM M8 ',
'YMb MM dM9 ',
" `YmmmMMmmmP' ",
' .JMML. ',
' ',
' ',
],
'Х' : [
' ',
' ',
"`YMM' `MP' ",
' VMb. ,P ',
" `MM.M' ",
' MMb ',
" ,M'`Mb. ",
' ,P `MM. ',
'.MM:. .:MMa.',
' ',
' ',
],
'Ц' : [
' ',
' ',
"`7MMF' `7MMF' ",
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMMmmmmmMMmm ',
' VM ',
' V ',
],
'Ч' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM MM ',
' YM. ,MM ',
' `"""\' MM ',
' MM ',
' ,JMML.',
' ',
' ',
],
'Ш' : [
' ',
' ',
"`7MMF' `7MMF' `7MMF'",
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMMmmmmmMMmmmmmMML.',
' ',
' ',
],
'Щ' : [
' ',
' ',
"`7MMF' `7MMF' `7MMF' ",
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMMmmmmmMMmmmmmMMmm ',
' VM ',
' V ',
],
'Ъ' : [
' ',
' ',
'MMP""MMF\' ',
'P MM ',
' MM ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
' .JMMmmmd9 ',
' ',
' ',
],
'Ы' : [
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM MM ',
' MM"""bg. MM ',
' MM `Y MM ',
' MM ,9 MM ',
'.JMMmmmd9 .JMML.',
' ',
' ',
],
'Ь' : [
' ',
' ',
"`7MMF' ",
' MM ',
' MM ',
' MM"""bg. ',
' MM `Y ',
' MM ,9 ',
'.JMMmmmd9 ',
' ',
' ',
],
'Э' : [
' ',
' ',
' MqP""""8q. ',
" M' `Mp ",
' YMb ',
" ,p6bqpd'M8 ",
' dM9 ',
'(O) ,M9 ',
' `"Ybmmmd"\' ',
' ',
' ',
],
'Ю' : [
' ',
' ',
'`7MMF\' .g8""8q. ',
" MM .dP' `YM. ",
" MM dM' `MM ",
' MMmmMM MM ',
' MM MM. ,MP ',
" MM `Mb. ,dP' ",
'.JMML. `"bmmd"\' ',
' ',
' ',
],
'Я' : [
' ',
' ',
' .pM"""MMF\'',
" .MM' MM ",
' YM. MM ',
' YMmmmMM ',
" ,dP' MM ",
" dM' MM ",
'.dM .JMML.',
' ',
' ',
],
'а' : [
' ',
' ',
' ',
' ',
' ,6"Yb. ',
'8) MM ',
' ,pm9MM ',
'8M MM ',
'`Moo9^Yo.',
' ',
' ',
],
'б' : [
' ',
' , ',
" ,dMMMP' ",
'dP ',
'M,dW"Wb. ',
"MW' `Wb ",
'MM M8 ',
'YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'в' : [
' ',
' ',
' ',
' ',
'`7MM""Yq. ',
' MM j8 ',
' MM""Yq. ',
' MM j8 ',
".JMMmmm9' ",
' ',
' ',
],
'г' : [
' ',
' ',
' ',
' ',
'`7MM"""M ',
' MM ` ',
' MM ',
' MM ',
'.JMML. ',
' ',
' ',
],
'д' : [
' ',
' ',
' ',
' ',
' VM""MMF\' ',
' ,9 MM ',
" d' MM ",
' ,9 MM ',
'gMmmmmMMm ',
'V V ',
' ',
],
'е' : [
' ',
' ',
' ',
' ',
' .gP"Ya ',
",M' Yb ",
'8M"""""" ',
'YM. , ',
" `Mbmmd' ",
' ',
' ',
],
'ж' : [
' ',
' ',
' ',
' ',
" OQ. `MM' ,QO ",
' b MM P ',
' >mMMm< ',
" ,d' MM `b. ",
'.ed .MM. `ba.',
' ',
' ',
],
'з' : [
' ',
' ',
' ',
' ',
'MgY"Ya ',
"M' M8",
' ""< ',
'QQ M8',
"YbmmP' ",
' ',
' ',
],
'и' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF'",
' MM ,MM ',
" MM ,' MM ",
" MM' MM ",
'.JMML..JMML.',
' ',
' ',
],
'й' : [
' ',
' ',
' 69 69 ',
" `--' ",
"`7MMF'`7MMF'",
' MM ,MM ',
" MM ,' MM ",
" MM' MM ",
'.JMML..JMML.',
' ',
' ',
],
'к' : [
' ',
' ',
' ',
' ',
"`7MM' ,M8 ",
' MM j ',
' MMmd ',
' MM `M ',
'.JMM. YMk ',
' ',
' ',
],
'л' : [
' ',
' ',
' ',
' ',
' `7M""MMF\'',
' M MM ',
' ,P MM ',
". d' MM ",
"8M' .JMML.",
' ',
' ',
],
'м' : [
' ',
' ',
' ',
' ',
"`7MMb ,MMMF'",
" M Mb d'MM ",
" M dM ;' MM ",
' M MVP MM ',
'.JM. `P .MML.',
' ',
' ',
],
'н' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF'",
' MM MM ',
' MMmmmmMM ',
' MM MM ',
'.JMML..JMML.',
' ',
' ',
],
'о' : [
' ',
' ',
' ',
' ',
' ,pW"Wq. ',
"6W' `Wb ",
'8M M8 ',
'YA. ,A9 ',
" `Ybmd9' ",
' ',
' ',
],
'п' : [
' ',
' ',
' ',
' ',
'`7MM""""MMF\'',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML..JMML.',
' ',
' ',
],
'р' : [
' ',
' ',
' ',
' ',
'`7MMpdMAo. ',
' MM `Wb ',
' MM M8 ',
' MM ,AP ',
" MMbmmd' ",
' MM ',
'.JMML. ',
],
'с' : [
' ',
' ',
' ',
' ',
' ,p6"bo ',
"6M' OO ",
'8M ',
'YM. , ',
" YMbmd' ",
' ',
' ',
],
'т' : [
' ',
' ',
' ',
' ',
'MM""MM""MM ',
'P MM Y ',
' MM ',
' MM ',
' .JMML. ',
' ',
' ',
],
'у' : [
' ',
' ',
' ',
' ',
"`7M' `MF'",
' VA ,V ',
' VA ,V ',
' VVV ',
' ,V ',
' ,V ',
'OOb" ',
],
'ф' : [
' ',
' ',
' `7MM ',
' MM ',
' .mmqMMpmm. ',
"6M' MM `Mb ",
'8M MM M8 ',
'YM. MM ,M9 ',
" `YmdMMbmP' ",
' MM ',
' .JMML. ',
],
'х' : [
' ',
' ',
' ',
' ',
"`7M' `MF'",
" `VA ,V' ",
' XMX ',
" ,V' VA. ",
'.AM. .MA.',
' ',
' ',
],
'ц' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF' ",
' MM MM ',
' MM MM ',
' MM MM ',
'.JMMmmmmMMmm ',
' VM ',
' V ',
],
'ч' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF'",
' MM MM ',
" ``=.='MM ",
' MM ',
' .JMML.',
' ',
' ',
],
'ш' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF'`7MMF'",
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMMmmmmMMmmmmMML.',
' ',
' ',
],
'щ' : [
' ',
' ',
' ',
' ',
"`7MMF'`7MMF'`7MMF' ",
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMMmmmmMMmmmmMMmm ',
' VM ',
' V ',
],
'ъ' : [
' ',
' ',
' ',
' ',
'MM""MMF\' ',
'P MM ',
' MM""Yq. ',
' MM j8 ',
" .JMMmmm9' ",
' ',
' ',
],
'ы' : [
' ',
' ',
' ',
' ',
"`7MMF' `7MMF'",
' MM MM ',
' MM""Yq. MM ',
' MM j8 MM ',
".JMMmmm9'.JMML.",
' ',
' ',
],
'ь' : [
' ',
' ',
' ',
' ',
"`7MMF' ",
' MM ',
' MM""Yq. ',
' MM j8 ',
".JMMmmm9' ",
' ',
' ',
],
'э' : [
' ',
' ',
' ',
' ',
'YdM"Wb. ',
"' `Wb ",
' ,6bqpM8 ',
'O ,A9 ',
"`Ybmd9' ",
' ',
' ',
],
'ю' : [
' ',
' ',
' ',
' ',
'`7MMF\' ,pW"Wq. ',
" MM 6W' `Wb ",
' MMmm8M M8 ',
' MM YA. ,A9 ',
".JMML. `Ybmd9' ",
' ',
' ',
],
'я' : [
' ',
' ',
' ',
' ',
" ,pMMMMMF'",
' 8I MM ',
' `YmmmMM ',
' dP MM ',
'.JP .JMML.',
' ',
' ',
],
'ё' : [
' ',
' ,, ,, ',
' db db ',
' ',
' .gP"Ya ',
",M' Yb ",
'8M"""""" ',
'YM. , ',
" `Mbmmd' ",
' ',
' ',
],
'ff' : [
' ',
' ,... ,...',
' .d\' "".d\' ""',
' dM` dM` ',
' mMMmmmmMMmm ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML..JMML. ',
' ',
' ',
],
'fi' : [
' ',
' ,...,, ',
" .d' db ",
' dM` ',
' mMMmmmmMM ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML..JMML.',
' ',
' ',
],
'fl' : [
' ',
' ,...,, ',
" .d' 7MM ",
' dM` MM ',
' mMMmm MM ',
' MM MM ',
' MM MM ',
' MM MM ',
'.JMML..JMML.',
' ',
' ',
],
'ffi' : [
' ',
' ,... ,...,, ',
' .d\' "".d\' db ',
' dM` dM` ',
' mMMmmmmMMmmmmMM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMML..JMML..JMML.',
' ',
' ',
],
'ffl' : [
' ',
' ,... ,...,, ',
' .d\' "".d\' 7MM ',
' dM` dM` MM ',
' mMMmmmmMMmm MM ',
' MM MM MM ',
' MM MM MM ',
' MM MM MM ',
'.JMML..JMML..JMML.',
' ',
' ',
],
} |
class Solution:
def amendSentence(self, s):
# code here
ans = ""
string = ""
for i in range(len(s)):
if 97 <= ord(s[i]) <= 122:
string += s[i]
else:
if string:
ans += string
ans += " "
string = ""
string += s[i].lower()
ans += string
return ans
#{
# Driver Code Starts
#Initial Template for Python 3
if __name__ == '__main__':
t = int(input())
for _ in range(t):
s = input()
solObj = Solution()
print(solObj.amendSentence(s))
# } Driver Code Ends
|
# Copyright (c) 2021 Qualcomm Technologies, Inc.
# All Rights Reserved.
def _tb_advance_global_step(module):
if hasattr(module, 'global_step'):
module.global_step += 1
return module
def _tb_advance_token_counters(module, tensor, verbose=False):
token_count = getattr(module, 'tb_token_count', None)
if token_count is not None:
T = tensor.size(1)
if token_count.last != T:
if token_count.last != 0:
token_count.total += token_count.last
token_count.sample_idx += 1
token_count.last = T
if verbose:
print(f'>>> T={T}\tlast_T={token_count.last}\tcumsum_T={token_count.total}')
return module
def _tb_hist(module, tensor, name, verbose=False):
hist_kw = dict(bins='auto')
tb_writer = getattr(module, 'tb_writer', None)
if tb_writer is not None:
if module.layer_idx == module.num_layers - 1:
tensor = tensor[:, 0]
# per-tensor
layer_s = str(1 + module.layer_idx).zfill(2)
full_name = f'{layer_s}/layer/{name}'
global_step = module.global_step
if verbose:
stats = f'min={tensor.min():.1f}, max={tensor.max():.1f}'
info = (
f'TB logging {full_name}\t{tuple(tensor.size())}\t({stats})\t'
f'[global_step={global_step}] ...'
)
print(info)
tb_writer.add_histogram(full_name, tensor, global_step=global_step, **hist_kw)
# per-token
sample_idx_s = str(module.tb_token_count.sample_idx + 1).zfill(2)
T = tensor.size(1)
full_name = f'{layer_s}/token/{sample_idx_s}/{name}'
for i in range(T):
tb_writer.add_histogram(full_name, tensor[0, i], global_step=i, **hist_kw)
|
def getMapCommon():
common = """SYMBOLSET "./etc/symbols.sym"
FONTSET "./etc/fonts/fonts.list"
IMAGETYPE "png"
"""
return common
def getPng():
output = """OUTPUTFORMAT
NAME "png"
DRIVER "AGG/PNG"
MIMETYPE "image/png"
IMAGEMODE RGB
EXTENSION "png"
END\n"""
return output
def getGif():
output = """OUTPUTFORMAT
NAME "gif"
DRIVER "GD/GIF"
MIMETYPE "image/gif"
IMAGEMODE PC256
EXTENSION "gif"
END\n"""
return output
def getJpeg():
output = """OUTPUTFORMAT
NAME "jpeg"
DRIVER "AGG/JPEG"
MIMETYPE "image/jpeg"
IMAGEMODE RGB
EXTENSION "jpg"
END\n"""
return output
def getScale():
scale = """SCALEBAR
STATUS OFF
UNITS KILOMETERS
INTERVALS 3
TRANSPARENT TRUE
OUTLINECOLOR 0 0 0
END\n"""
return scale
def getLegend():
legend = """LEGEND
STATUS ON
LABEL
COLOR 51 51 51
FONT verdana # font needs to be inside fonts.list
TYPE TRUETYPE
SIZE 8
END
KEYSIZE 24 16
END\n"""
return legend
def getSize(x = 2048, y = 2048):
size = 'SIZE {x} {y}'.format(x=str(x), y=str(y))
return size
def getUnits():
units = 'UNITS METERS'
return units
def getExtent(ext):
extent = 'EXTENT {xmin} {ymin} {xmax} {ymax}'.format(xmin=ext[0], ymin=ext[1], xmax=ext[2], ymax=ext[3])
return extent
def getProjection(epsg):
projection = """PROJECTION
"init=epsg:{epsg}"
END""".format(epsg=epsg)
return projection
def getWeb(title, abstract, keywords):
web = """WEB
IMAGEPATH "/tmp/"
IMAGEURL "/tmp/"
METADATA
"wms_title" "GOV Canada - {title}"
"wms_abstract" "{abstract}"
"wms_server_version" "1.1.1"
"wms_enable_request" "GetCapabilities GetMap GetFeatureInfo GetLegendGraphic"
"wms_formatlist" "image/png,image/gif,image/jpeg"
"wms_format" "image/png"
"wms_feature_info_mime_type" "text/html"
"wms_keywordlist" "Canada,Map,Carte,NRCan,RNCan,Natural Resources Canada,Ressources naturelles Canada,{keywords}"
INCLUDE "./etc/projections.inc"
INCLUDE "./etc/service_metadata_en.inc"
END # metadata
END # web""".format(title=title, abstract=abstract, keywords=keywords)
return web
def getLayerMetadata(name, projection):
meta = """METADATA
"wms_title" "{name}"
"wms_srs" "EPSG:{projection}"
"wms_enable_request" "GetCapabilities GetMap GetFeatureInfo GetLegendGraphic"
END # metadata""".format(name=name, projection=projection)
return meta
def getLayerGeometry(fieldsNode):
poly = False
line = False
if fieldsNode != None:
for elem in fieldsNode:
fieldName = elem.find('./FieldName').text
if 'SHAPE_LENGTH' == fieldName.upper():
line = True
elif 'SHAPE_AREA' == fieldName.upper():
poly = True
if poly:
geom = 'Polygon'
elif line:
geom = 'Line'
else:
# if there is no field description we assume it is a point layer
# TODO: validate the assumption
geom = 'Point'
return geom
def getSeparator():
return '# --------------------------------------------------------------' |
nome = str(input('Qual é o seu nome? ')).strip()
print('''O seu nome apenas em letras garrafais (porém amigáveis) é {}
Já em letras minusculas {}. Seu nome possuí {} letras.
Seu primeiro nome tem {} '''.format(nome.upper(), nome.lower(), len(nome) - nome.count(' '), nome.find(' ')))
#separa = nome.split()
#print('Seu primeiro nome tem {}'.format(len(separa[0]))) |
# -*- coding: utf-8 -*-
"""SDP Tango Master Release info."""
__subsystem__ = 'TangoControl'
__service_name__ = 'SDPMaster'
__version_info__ = (0, 1, 0)
__version__ = '.'.join(map(str, __version_info__))
__service_id__ = ':'.join(map(str, (__subsystem__,
__service_name__,
__version__)))
__all__ = [
'__subsystem__',
'__service_name__',
'__version__',
'__service_id__',
]
|
# -*- coding: utf-8 -*-
"""
Created on Fri Sep 10 15:18:19 2021
@author: qizhe
"""
class Solution:
def climbStairs(self, n: int) -> int:
if n <= 1:
return n
pre = 1
cur = 2
for _ in range(2,n):
cur, pre = cur + pre, cur
return cur
if __name__ == '__main__':
solu = Solution()
input_Str = str('hello')
# input_list =
input_List = [5,1,5]
input_Num = 5
# for i in input_List:
result = solu.climbStairs(input_Num)
# output_Str = 'result = ' + solu.intToRoman(input_int)
output_Str = ' result = ' + str(result)
print(output_Str) |
class ExpressionReader:
priorityComparision = ['=']
andOrComparision = ['OR']
operations = []
operations.extend(priorityComparision)
operations.extend(andOrComparision)
def read(expression):
lst = ExpressionReader.__split(expression)
#lst = ExpressionReader.__parsePriorityExpression(lst, ExpressionReader.priorityComparision)
#lst = ExpressionReader.__parseExpression(lst)
return lst
def __split(expression):
lst = []
chars = ''
acceptSpace = False
for char in expression:
if char == '(' or char == ')':
if chars != '':
lst.append(chars)
chars = ''
lst.append(char)
continue
if char == '\'' or char == '\"':
acceptSpace = not acceptSpace
if char == ' ' and acceptSpace == False:
if chars != '':
lst.append(chars)
chars = ''
continue
else:
chars = chars + char
if chars != '':
lst.append(chars)
return lst
def __parsePriorityExpression(lst, operations):
newLst = []
for i in range(0, len(lst) - 1):
if lst[i] in operations:
arguments = []
arguments.append(lst[i-1])
operation = lst[i]
arguments.append(lst[i+1])
dataDriven = ExpressionReader.toDataDrivenStyle(operation, arguments)
if dataDriven is None:
return None
newLst.append(dataDriven)
elif lst[i] in ExpressionReader.operations:
newLst.append(lst[i])
return newLst
def __parseExpression(lst):
if lst is None:
return None
while len(lst) > 1:
arguments = []
arguments.append(lst.pop(0))
operation = lst.pop(0)
arguments.append(lst.pop(0))
dataDriven = ExpressionReader.toDataDrivenStyle(operation, arguments)
if dataDriven is None:
return None
lst.insert(0, dataDriven)
return lst
def toDataDrivenStyle(operation, arguments):
if operation == '=':
return '[\"==\",[\"get\",\"' + arguments[0] + '\"],' + arguments[1] + ']'
if operation == 'OR':
return '[\"any\",' + arguments[0] + ',' + arguments[1] + ']'
return None
# subset = 'loaiDatHT = \'CAN\' OR loaiDatHT = \'COC\' OR loaiDatHT = \'CQP\' OR loaiDatHT = \'DBV\' OR loaiDatHT = \'DCK\' OR loaiDatHT = \'DCH\' OR loaiDatHT = \'DDT\' OR loaiDatHT = \'DGD\' OR loaiDatHT = \'DKH\' OR loaiDatHT = \'DNL\' OR loaiDatHT = \'DSH\' OR loaiDatHT = \'DSN\' OR loaiDatHT = \'DTS\' OR loaiDatHT = \'DTT\' OR loaiDatHT = \'DVH\' OR loaiDatHT = \'DXH\' OR loaiDatHT = \'DYT\' OR loaiDatHT = \'SKC\' OR loaiDatHT = \'SKK\' OR loaiDatHT = \'SKN\' OR loaiDatHT = \'SKX\' OR loaiDatHT = \'TIN\' OR loaiDatHT = \'TMD\' OR loaiDatHT = \'TON\' OR loaiDatHT = \'TSC\' OR loaiDatHT = \'TSN\' OR loaiDatHT = \'SKX\' OR loaiDatHT = \'DRA\' OR loaiDatHT = \'NTD\''
# print(ExpressionReader.read(subset))
testIn = '\"loaiDatHT\" in (\'DGT\')'
print(ExpressionReader.read(testIn)) |
'''A large FizzBuzz as an output using small FizzBuzz numbers.(FizzBuzz=FizBuz for better alignment
and make sure your output terminal covers the entire length of the screen to avoid automatic newlines)'''
# Author: @AmanMatrix
def iCheck(i):
if i%15==0:
i='FizBuz'
elif i%3==0:
i='Fizz'
elif i%5==0:
i='Buzz'
else:i=i
return i
for i in range(1,101):
if(i==1):
print("\n",iCheck(i),end=" ")
elif(i<=5):
print(iCheck(i),end=" ")
elif(i==6):
print(" ",iCheck(i),end=" ")
elif(i<=9):
print(iCheck(i),end=" ")
elif(i==10):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=12):
print(iCheck(i),end="")
elif(i==13):
print(" ",iCheck(i),end=" ")
elif(i==14):
print(iCheck(i))
elif(i==15):
print(iCheck(i),end=" ")
elif(i==16):
print(iCheck(i),end=" ")
elif(i<=18):
print(iCheck(i),end=" ")
elif(i==19):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=21):
print(iCheck(i),end=" ")
elif(i==22):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=25):
print(iCheck(i),end=" ")
elif(i==26):
print(" ",iCheck(i),end="")
elif(i<=27):
print(iCheck(i),end=" ")
elif(i==28):
print(iCheck(i),end=" ")
elif(i<=30):
print(iCheck(i),end=" ")
elif(i==31):
print(" ",iCheck(i),end=" ")
elif(i<=33):
print(iCheck(i),end=" ")
elif(i==34):
print(" ",iCheck(i),end=" ")
elif(i<=36):
print(iCheck(i),end="")
elif(i<=37):
print(" ",iCheck(i),end="")
elif(i<=38):
print(" ",iCheck(i),end="")
elif(i==39):
print(" ",iCheck(i),end=" ")
elif(i<=41):
print(iCheck(i),end=" ")
elif(i==42):
print(" ",iCheck(i),end=" ")
elif(i<=44):
print(iCheck(i),end=" ")
elif(i==45):
print(f"\n{iCheck(i)}",end=" ")
elif(i<=47):
print(iCheck(i),end=" ")
elif(i<=49):
print(" ",iCheck(i),end=" ")
elif(i==50):
print(" ",iCheck(i),end=" ")
elif(i==51):
print(" ",iCheck(i),end=" ")
elif(i==52):
print(iCheck(i),end=" ")
elif(i==53):
print(iCheck(i),end=" ")
elif(i<=55):
print(iCheck(i),end=" ")
elif(i==56):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=58):
print(iCheck(i),end="")
elif(i<=60):
print(" ",iCheck(i),end=" ")
elif(i<=61):
print(" ",iCheck(i),end=" ")
elif(i<=62):
print(iCheck(i),end=" ")
elif(i<=64):
print(iCheck(i),end=" ")
elif(i<=66):
print(iCheck(i),end=" ")
elif(i<=67):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=69):
print(iCheck(i),end="")
elif(i<=71):
print(" ",iCheck(i),end=" ")
elif(i<=72):
print(" ",iCheck(i),end=" ")
elif(i<=73):
print(iCheck(i),end=" ")
elif(i<=74):
print(iCheck(i),end=" ")
elif(i<=75):
print(iCheck(i),end=" ")
elif(i<=76):
print(iCheck(i),end=" ")
elif(i<=77):
print(iCheck(i),end=" ")
elif(i<=78):
print(f"\n {iCheck(i)}",end=" ")
elif(i<=80):
print(iCheck(i),end="")
elif(i==81):
print(" ",iCheck(i),end=" ")
elif(i<=83):
print("",iCheck(i),end="")
elif(i<=84):
print(" ",iCheck(i),end=" ")
elif(i<=86):
print(iCheck(i),end="")
elif(i<=87):
print(" ",iCheck(i),end=" ")
elif(i<=89):
print(iCheck(i),end=" ")
elif(i<=90):
print(" ",iCheck(i),end="")
elif(i<=92):
print(iCheck(i),end="")
elif(i<=93):
print(" ",iCheck(i),end="")
elif(i<=95):
print("",iCheck(i),end="")
elif(i<=96):
print(" ",iCheck(i),end="")
elif(i<=99):
print(iCheck(i),end="")
else:
print(" ",iCheck(i)) |
i = 1.0
print(i)
print("Hello world!")
print(type(i))
a = "Hello"
print(type(a))
# print(a+i) <-Error!
a += "world!"
print(a)
print("this is string: {}, {}".format(3, "ala bala"))
print("pi = %f" % 3.14)
|
MACHINE_A = 'MachineA'
MACHINE_B = 'MachineB'
INIT = 'Init'
E_STOP = 'stop'
E_INCREASE = 'increase'
E_DECREASE = 'decrease'
|
lista = str(input('Digite uma frase com parenteses: '))
pilha = []
for simbolo in lista:
if simbolo == '(':
pilha.append('(')
elif lista == ')':
if len(pilha) > 0:
pilha.pop()
else:
pilha.append(')')
break
if len(pilha) == 0:
print('Sua expressão está correta ')
else:
print('Sua expressão está errada ')
# Esse exerciceo é muito importante: a tecnica usada foi muito simples
# a cada parenteses aberto que estiver
# dentro da lista ele joga na pilha quando encontrar
# o seu par de parenteses fechado ele joga na pilha
# e desaparesem ficando a pilha com nenhum parenteses
# se a pilha ficar com um numero acima
# de 0 é pq um dos parenteses
# n teve seu par então a frase fica errada!
|
#=============================================================================
## Automatic Repository Version Generation Utility
## Author: Zhenyu Wu
## Revision 1: Apr 28. 2016 - Initial Implementation
#=============================================================================
__all__ = [ 'VersionLint' ]
|
print('='*10,'LOJA ART','='*10)
compras = float(input('Preço das compras: R$'))
print('''FORMAS DE PAGAMENTO
[ 1 ] À vista dinheiro/cheque:
[ 2 ] À vista cartão:
[ 3 ] 2X no cartão:
[ 4 ] 3X no cartão ou mais:''')
opção = int(input('Qual a opção?'))
if opção == 1:
desconto = compras-(compras*10/100)
print('O preço deste produto agora é {} e voçê ganhou um desconto de 10%!'.format(desconto))
elif opção == 2:
desconto2 = compras-(compras*5/100)
print('O preço deste produto agora é {} e voçê ganhou um desconto de 5%!'.format(desconto2))
elif opção == 3:
parcelas1 = compras/2
print('Sua compra será parcelada em 2x de R${}, SEM JUROS'.format(parcelas1))
print('Sua compra será de R${}'.format(compras))
elif opção == 4:
quantas = int(input('Quantas parcelas?'))
juros = compras+(compras*20/100)
parcelas = juros / quantas
print('Sua compra será parcelada em {}x de R${:.2f}, COM JUROS'.format(quantas, parcelas))
print('Sua compra de {} vai custar {} no final.'.format(compras, juros))
else:
totao = 0
print('OPÇÃO INVALIDA DE PAGAMENTO, TENTE NOVAMENTE!') |
def fun(f): #string
# Some functions need zero or more
# arguements then we have to use
# *args & **kwargs
def wrapper(*args, **kwargs):
print("Start")
#print(string)
# to return the values that are passed
values = f(*args, **kwargs)
print("End")
return values
# return the wrapper function being called use --> ()
#return wrapper()
return wrapper
@fun
def fun2(x):
print("Funtion 2")
return x
@fun
def fun3():
print("Function 3")
### x = fun(fun2)
##fun(fun2)
##print()
##fun(fun3)
##fun2 = fun(fun2)
##fun3 = fun(fun3)
A = fun2('a')
print()
print(A)
print()
fun3()
|
symbols = [
'TSLA',
'GOOG',
'FB',
'NFLX',
'PFE',
'KO',
'AAPL',
'MSFT',
'DIS',
'UBER',
'AMZN',
'TWTR',
'SBUX',
'F',
'XOM',
'GFINBURO.MX',
'BIMBOA.MX',
'GFNORTEO.MX',
'TLEVISACPO.MX',
'AZTECACPO.MX',
'ALSEA.MX',
'ORBIA.MX',
'POSADASA.MX',
'VOLARA.MX',
'LIVEPOLC-1.MX',
'AEROMEX.MX',
'WALMEX.MX',
'PE&OLES.MX',
'BBVA.MX',
'GAPB.MX',
] |
# ADD BINARY LEETCODE SOLUTION:
# creating a class.
class Solution(object):
# creating a function to solve the problem.
def addBinary(self, a, b):
# using the 'bin' function to convert each integer into its binary format.
sum = bin(int(a, 2) + int(b, 2))
# returning the value of the sum, while truncating the '0b' prefix.
return sum[2:] |
mywords = ['Krishna', 'Rameshwar Dass', 'Usha', 'Ramesh']
for w in mywords:
print(w, end='')
#Krishna Rameshwar Dass Usha Ramesh |
C = set(
"""
I [и] a aли a҃ i iли ̕И ͑И ι ιли І Ї А Дa Да И ЛІ Ли Лі Неже Ни Ниже Но Нъ Ні Ніже Таже Ти а а. а͑ али ами ато а҅ а҆ д дa да же и и͑ и͑ли и͑лі и͗ иж иже ии ил илi или илї ино и҃ и҅ и҅ ли и҅ли и҆ и҆ли й ли либо любо лі лї н на не не бо нъ неже ни ни же ниa ниж ниже но нъ нъ҅ нъ҆ нь нь͗ нь҆ ні нї нѫ нꙑ о͑баче о͑во ово о҅во пи съ тaче та та ж та же таж таже таж҃ ти тоже толи і іли ілі і҃ і҅ ї їли ї꙯ ѡва ѡво ѡдѣ ҅А ҅И ꙁане Ꙇ Ꙇ҅ ꙇ ꙇли ꙇлꙇ ꙇ҃ ꙇ҅ ꙇ҅ли ꙗ
""".split()
)
Dq = set(
"""
Егда Їде ВЪНГДА ВЪНЕГДА ВЬНЕГДА Вънегда Вьнегда Вьн҄егда ЕГДА Егдa Егда Еліко Е҅гда Камо Коли Отънѭдѣже Якож а͑кы а͑кꙑ аки акоже акъ акы акꙑ амо амо же аможе амѡж ациже а҅коже а҅кꙑ бытто внегда въегда въедга вънегда вънегъда вън҄егда вьнегда вьн҄егда вьн҄егдаже вь҆н҄егда где гдето гдѣ дажде даже догде докамѣстъ донелиже дон҄елиже дѣ егдa егдaже егда егдаже егода еда едга еже ели елико еликож еликоже е҅гда и͑деже и͑жде и͑ждеже иде иде же идеже идѣ идѣ же идѣж идѣже иждеже и҅деже и҅жде и҅ждеже и҆жде кaко ка как како какъ какь какѡ как҃ как҃о камо камь кам҃ като кде кдѣ ко кога когда кодь коже кои коли колиждо коликолико колко колї колꙿкото куда куды къгда къде кѹды кꙋда кꙿде некъли нь же нѭдѫже одънелиже отъ нелиже отънелиже отън҄елиже о҅кꙑ о҅тъ н҄елиже о҅тъкѫдоуже о҅тън҄елиже о҅тън҄елѣже о҅тън҄ѫдоуже о҅тън҄ѫдꙋже о҅ть҆н҄елиже о҅ть҆н҄ѫдоуже поне сколко сколь столко тогдaжде толко только чем что я͑ко я͑коже яко яко же якож якоже яможе ідеже іже їдеже їжде їждеже Ѣко Ѣкоже ѣко ѣкоже ѣможе ѥ͑гʼда ѥ͑гда ѥ͑же ѥ͑ликоже ѥгʼда ѥгдa ѥгда ѥда ѥлико ѥликоже ѥ҅гда ѥ҅гꙿда ѥ҅же ѥ҅лико ѥ҅ликоже ѥ҅лма ѥ҅лмиже ѥ҅льма ѥ҅лꙿма ѧко ѧкоже ѭ̑доуже ѭ̑дѣже ѭдоуже ѭ҄доуже ѹдѹ же ѿколе ѿкыдѣ ѿнележе ѿнюдоу ѿнюду ѿнюдѹ ѿнѹдꙋ же ҅Егда ꙇдеже ꙇдѣже ꙇжде же ꙇждеже ꙇ҅деже ꙗ͑ко ꙗ͑коже ꙗк ꙗко ꙗко ж ꙗко же ꙗкож ꙗкоже ꙗкож҃ ꙗкѡж ꙗкѡже ꙗможе ꙗоже ꙗ҅ко ꙗ҅коже
""".split()
)
Du = set(
"""
aште aще Въскѫѭ Въ҃скѫѭ Вьскѫѭ Доколѣ Дѣѣ҅ши Е Егда Едa Еда Кaко Како Какъ Когда Кое Колъ Коль Коль краты Коліко Къгда Къде ЛІ Почто Почтѡ Чи аште аш҃те аще а҅ште вскую въскоую въскую въскѫѭ въскѫѭ̑ въскѹю въскꙋю вьскоую вьскѫѫ гдѣ деши до колѣ доколи доколиѣ доколѣ дѣї дѣѣши дѣѣ҅ши дѣѥ҅ши е͑да едa еда еже елико е҅да и҅ли кaко кaмо кʼде как кака како какъ какь какѡ какꙿ камо камѡ кде кдѣ когдa когда кодь коли колико коликы колко колми колъ коль коль͗ колько колькраты кольми коль҆ коль҆ми колⸯми колꙿми кудѣ къгда къде къді кьде кь҆де кѡлико кѫдоу кѫдѫ кѹда кѹды кѹдꙑ кꙿде л ли ль лі лї нъ о͑тъкѫдоу отъ коудѫ отъ кѫдоу отъ кѫдѣ отъ кѫдѫ отъкѫдоу отъкѫдѣ отъкѹдѹ отьноудоуже о҅тъкѫдоу почʼто почто почьто почꙿто пошто сколко сколько ци чи яко єда ѣште ѥ͑да ѥ͑лико ѥда ѥ҅гда ѥ҅да ѿколѣ ѿкоудоу ѿкуду ѿкѫдѹ ѿкѹдȣ ѿкѹдѹ ѿкѹдꙋ ѿкꙋдꙋ ѿнюдоу
""".split()
)
G = set(
"""
a]ште aште aще ιже Аж Аже Аче Аште Аще Ащте Дa Да Доиждеже Доідеже Доїждеже Егда Еда Елма Елмаж Зане Понеже Пон҄еже Чтобы а а ҅ште а[ч]е а͑ а͑ко а͑кы а͑ште аж аж[е аже ажь аки ако акоже акⷪ акꙑ али атче атъ ать аче аше аште аще ащте а҅ а҅ко а҅кꙑ а҅цѣ а҅ште а҅шти а҅штишꙙ а҅ще во еже воеже воежебы д дa дaже да даa давно даже даче до дои͑деже дои͑жде доиде доидеже доиждеже докамѣстъ доколо донʼдеже донде донде ж дондеж дондеже дондѣ же дондѣже донеле донележе донелѣ донелѣ же донелѣже донъдеже донь͗жде донь͗ждеже доньдеже доньжде донь҆деже донь҆жде донѥлѣже дон҄деже дон҄елиже дон҄елѣже дон҄ьдеже донⸯдеже дон꙽деже донꙿдѣже доідеже доіжде доіждеже доіже доꙇдеже дѡнʼдеже егда едa еда еж еже ежели ели елижды елма ж елма же елмаже ел꙽ма же естли е҅да е҅лма же зaне зaнѥ зaн҄е зaн҄еже зан̑е зане зане ж зане же занеже занже занода зань заньже занѣ зан҄еже защ[о защо и͑ и͑мꙿже иже и҅мже и҅мъже и҅мꙿже како като ко кꙿдеже любо л҄юбо не бо нꙿ некли ноли оже око оли олна оте оти отънели оце о҅тьн҄ѫдѣже пакꙑ по н҄еже поеликѹ покаместь покамѣста пон̑еже понеж понеже понѥже пон҄е пон҄еже преже тѣмь҆ хоти хоть хотя хотѧ хоша ци цы цѣ че четъ чи чо би чт(о что что бы что бꙑ чтоб чтобъ чтобы чтобь чтобꙑ чтопъ чтъ чтѡ што штоб штобы штѡ щто я͑ко я͑коже яко яко же якоже ѡже Ѣко Ѣште Ѣще Ѣ҅ко ѣ]ко ѣко ѣкоже ѣште ѣще ѣ҅ше ѥ͑дʼва ѥ͑да ѥ͑же ѥ͑лма ѥ͑лꙿма ѥда ѥже ѥлмаже ѥль҆ма же ѥ҅да ѥ҅же ѥ҅ли ѥ҅лма ѥ҅лма же ѥ҅лмаже ѥ҅льма ѥ҅ль҆ма ѥ҅лꙿма ѧко ѧкоже ѿ ѿкато ѿнележе ѿнелѣже ҅Аште ҅Елма ҍли ӑште ꙁа н҄еже ꙁане ꙁанѥже ꙁан҄е ꙁан҄еже ꙇжде ꙇли ꙇмъже ꙗ͑ко ꙗ͑коже ꙗже ꙗк ꙗко ꙗко же ꙗкож ꙗкоже ꙗкѡж ꙗште ꙗ҅ко ꙗ҅коже
""".split()
)
I = set(
"""
aллилѹїa aм[и]нь aмин aминь aминⸯ ͗Ѡ ͗Ѡле АЛЕЛОУЇѢ АЛЕЛОУГѢ АЛЕЛОУИѢ АЛЛЕЛОУГЬѢ АЛЛѢЛОУИѢ АЛѢЛОУЇѢ Амин Аминъ Аминь Аминⸯ Аминꙿ А҅минь Вотъ Горе О Оу Оувъі Оувы Се Сѣ Увы а͑ми͆ а͑мин а͑минъ абвгдежѕꙁии̑клмнѡ аллилуия амин аминъ аминь аминꙿ аминꙿ амн амнъ амнь амін амінь аміⷩ амїнь ам҃нь амⰹн а҅мин а҅минъ а҅минь҆ а҅минꙿ бе веле воле вото вотъ горе гѡре д е͑и͑ е͑и͗ е͑се еи ей еі е҅и е҅и҅ е҅и҆ е҅се еꙇ лютѣ на ни ні нїи о о̑у о͑ оле осaнⸯнa осе оу оува оувы оувⸯвa охъ о҄увы о҅ о҅сан· на р се сесь҆ си сѣ увы ю̑ Ѡ Ѡ̈ Ѡле Ѡсaн҄нa Ѡ҄ Ѡ҅санна Ѡ҅санънна Ѡ҅санꙿна ѡ ѡ̆ ѡ̑ ѡ̑ле ѡ̑сана ѡ̑санна ѡ̑санꙿн ѡ̑санꙿна ѡле ѡсaннa ѡсанна ѡсе ѡто ѡхъ ѡ҄ ѡ҄ле ѡ҅ ѡ҅санна ѥ͑се ѥи ѥ҅се ѹвы Ѽ ѽ ҅Амин ҅Ѡ ҆Ѡ ҆Ѡле ҆Ѡсанꙿна ҆Ⱉ ꙋвы ꙗ҅роу ꙗ҅у
""".split()
)
Ma = set(
"""
.в҃ .е҃ 10 1000 12 13 14 15 160 1689 1707 1708 171 1771 1786 18 1850 19 2 20 24 25 26 28 29 3 30 300 300000 4 40 400000 5 50 500 6 60 7 70 70000 7018 725 8 9 i҃ ·з҃і ͑Единъ͗ Ѕ ЅІ Ї҃В А Б В В҃ Г ДІ Дь҆вѣ Д҃ Е ЕІ Единъ Единъꙇ Единь Едіного Е҃ Е҅динꙑ З И ИІ И҃ И҃҃ К Л М Н҃ Оба Одинъ Р Седми Седмь Четырʼми Четыре Четꙑрі а адно аі҃ а҃ а҃ι а҃і а҃҂ а҃҃҃ а꙯ї б б҃ б҃ꙇ б҃ꙇ҃ в в.мa восмъ восмъдесятъ восмь ві҃ в҃ в҃ι в҃і в҃ї в҃҂ в҃҃ в҃҃ꙇ в҃ꙇ в꙯ в꙯і в꙯ї г г.и г͆ горести гі҃ г҃ г҃·ми г҃·х г҃ι г҃и г҃і г҃҃ г҃҃҃ г꙯і г꙯ї д дʼва дʼвѣма двa два двадесѧт двадесѧтїи двадесѧтⸯ дватцат дватцет дватцети дватцеть двацети две двем двема двое двоему двои двоих двоихъ двои҅ми двои҆ двоу двою двою̑ двою҄ двоѥ двоѥ͑го двоѥ҆ дву двудесѧту двунадесѧту двух двухъ двѣ двѣмa двѣма двѣнатьцать двѣсте двѣстѣ двѹ двꙋ двꙋх де=с=ѧтъ девет девяносто девятю девѧносто девѧт девѧти девѧтнадесѧтїю девѧть девⱕти девⱕть девꙙть девꙙть҆ десет десете десети десеть десетⸯ десеⷮ҇ десят десятеро десять десѧ десѧт десѧте десѧтемъ десѧти десѧтии десѧтима десѧтиі десѧтиѭ десѧтъ десѧтъма десѧть десѧтьма десѧтьѭ десѧтѣ десѧтꙑ десѩте десѩти десⱕте десⱕтемъ десⱕти десⱕтъ десⱕты десꙙте десꙙтемь҆ десꙙтехъ десꙙтехꙿ десꙙти десꙙторо десꙙтъ десꙙть десꙙть҆ десꙙть҆ма десꙙть҆мь десꙙтꙑѧ дино дним дова довҍ друг҃ꙗ дрꙋгꙑ дъвa дъва дъвое дъвоего дъвое҅ дъвою дъвою̑ дъвоюдесѧтѹ дъвою҄ дъвоѭ дъвоꙗ дъвѣ дъвѣмa дъвѣма дъвѹ дъвҍ дь͗вѣма дьвaмa дьва дьвоѥ дьвѣ дьвѣмa дьвѣма дьчѧти дьчѧть дь҆ва дь҆вѣ дь҆вѣма ді д҃ д҃.ми д҃.хъ д҃ι д҃рь д҃і д҃ѭ д҃҃҃҃ дⸯвa дⸯвѣмa д꙯ дꙿва дꙿвѣма е еi еди един единa едина единааго единаго единаго] единая едине единем единема единемъ едини едино единого единои едином единомоу единому единомъ единомь единомѹ единомꙋ единоуемоу единою единоі единоѧ единоѩ едину единъ единым единымъ единыхъ единыя единыѧ единь единѣ единѣмъ единѣмь единѣм꙽ единѣхъ единѫ единѫѭ единѫѭ҄ единѹ единꙋ единꙑ един꙽ едьного едінаго едіного едіномоу едіному едіномѹ едінъ едїнаго едїне едїного едїнъ еі еі҃ еї҃ е҃ е҃i е҃ι е҃ти е҃і е҃і҃ е҃҃҃ е҃҃҃і е҅дꙿнои҆ е҅дꙿнѫ е꙯ е꙯ї жрѣбѧти ж҃ з з.ро з.҃ры з͆ зі҃ з҃ з҃ι з҃і з҃ї з҃҃҃ и и͆ и͆ї иі иі҃ и҃ и҃ι и҃і и҃҃ и҃҃҃ и꙯ к к͆ѕ к҃ к҃҃ к҃҃҃ к꙯ к꙯в л л͆ л͆ѳ л҃ л҃҃ л҃҃҃ л꙯ м м͆ м͆ мъ м҃ м҃.ми м҃:ми м҃҃ м꙯ н н҃ н҃тъ н҃ть н꙯ о͑ба о͑бои о͑бои͗ о͠ обa оба обое обои обоихъ обою обоі обоѭ обѡю обѣ обѣихъ обѣмa обѣма один одиного одинои одиномь одиноѣ одинъ одинѡ одинѣхъ одинѹ одна однимъ одно одново одного однои одномъ одны однѹ одого одїного одїнъ осемь осми осмидесѧт осмь осьмь о҃ о҃҃҃ о҅ба о҅бои о҅бои҅ми о҅бои҅мъ о҅бои҅хъ о҅бою о҅бою̑ о҅боѥ о҅боѥ҅го о҅боѥ҅моу о҅боѥ҅мъ о҅боѧ о҅бѣ о҅бѣма о҅смь҆ п п[ѧ]ть пети петь полоуторы полтара полтора полтораста полторы полъпѧтадьсѧтъ полѹтора полѹторꙑ полѹшестадьсѧтъ пръвaго пят пятдесят пяти пятию пятнадцать пятнатцет пятнатцетъ пятнацет пять пятью пятю пѣти пѧт пѧта десѧте пѧтдесѧт пѧти пѧтию пѧтиѭ пѧть пѧтьдесѧт пѧтьнадесѧт пѧтьѭ п҃ п҃тъ п҃҃ п҃҃҃ п҃҃҃҃ пꙗтию пꙙти пꙙтиѭ̑ пꙙтиѭ҄ пꙙтъ пꙙть пꙙть͗ пꙙть҆ пꙙтꙑи р р͆ ри҃ р҃ р҃҃ р҃҃҃ р꙯ р꙯и с седʼми седми седмию седмиѩ седмиѭ̑ седмъ седмь седꙿмь҆ семи семидесѧтъ семисотъ семию семнатцеть семъдесят семые семьюдесѧтъ семї собоѫ сорока сорокъ сотъ стa ста сто стомъ сту стъмь стѣ стѣхъ стѹ стꙋ съто сътомa сътома сътомъ сътомь сътоу сътъ съть сътѣ сътꙑ сьта сьтъ сьтѣхъ сѿ с҃ т тисꙋщь трее трема треми тремъ треначать третии͗ третьятцет третятцет трех трехъ трею треѥ три три[е]х тридесят тридесѧти тридесѧть тридесⱕти трие трии триидесꙙтъ трии҆ трими тринатцеть тристa триста тритцать тритцет тритцеть тритчеть триі триї триѥ трои троих троѣ троѥ трье трьми трьмъ трьмь҆ трьхъ трьї трьѥ трь҆ми трь҆мъ трь҆мь трь҆мь҆ трь҆хъ трі тріи трї трїе трїемъ трїи тъісѫщи тъісѫщі тысечи тысечь тысоущы тысящи тысящу тысящъ тысѧч тысѧча тысѧчахъ тысѧчи тысѧчь тысѧчю тысѧчѣ тысѧшь тысѧщ тысѧща тысѧщахъ тысѧщею тысѧщи тысѧщъ тысѧщь тысѧщѧ тьссѧч тьсѧч т҃ т҃҃ тꙑ[сѧ]чю тꙑсѧце тꙑсѧч тꙑсѧштaмъ тꙑсѧшти тꙑсѧшть тꙑсѧштѧ тꙑсѧштѫ тꙑсѧщи тꙑсѧщь тꙑсѩштъ тꙑсѩшті тꙑсѫштaмa тꙑсѫштама тꙑсѫштами тꙑсѫштамъ тꙑсѫшти тꙑсѫштъ тꙑсѫшть тꙑсѫшть҆ тꙑсѫштѧ тꙑсѫштꙙ тꙑсѫщь тꙑсѫщѩ тꙑсѭшть тꙑсꙙшть҆ у у҃ у҃҃ ф ф҃ ф҃҃ х х҃ цетꙑри ц҃ ч часома четверы четворо четворꙑ четврътъи͗ четири четыре четыремъ четыри четырми четырнатцет четырнатцеть четырь четырь͗ четырь͗ми четырѣ четьірь четꙑре четꙑремъ четꙑрехъ четꙑри четꙑридесѧт҃ четꙑръ четꙑръ десꙙтъ четꙑръми четꙑрь четꙑрьми четꙑрь҆ми ч҃ ч҃҃ ч҃҃҃ шедесѧть шеснатцет шестеро шести шестих шестию шестиѭ шестиѭ҄ шесть шестьдесят шестьдесѧт шестью шесть҆ шестѣмь єдин[оо] єдино єдиною єдинъ єдинь ѕ ѕı ѕі҃ ѕ҃ ѕ҃.ю ѕ҃ι ѕ҃і ѕ҃ї ѕ҃҂ ѕ҃҃ ѕ҃ꙇ ѕ꙯ і іе҃ і҃ і꙯в і꙯и ї ї͆ їѳ҃ ї҃а ї҃в ї҃г ї҃д ї҃е ї҃з ї҃и ї҃ѕ ї҃҃҃ѳ ї꙯ Ѡбѣмa Ѡбѣма ѡба ѡбе ѡбема ѡбое ѡбоему ѡбои ѡбоим ѡбоимъ ѡбоих ѡбоихъ ѡбою ѡбоя ѡбоѥ ѡбоꙗ ѡбѣ ѡбѣих ѡбѣма ѡдин ѡдина ѡдини ѡдино ѡдинова ѡдиного ѡдинои ѡдином ѡдиномоу ѡдиною ѡдинъ ѡдинѣхъ ѡдна ѡднемь ѡдно ѡдново ѡдного ѡдное ѡдному ѡдну ѡдны ѡдным ѡднѣ ѡднѹ ѡдіными ѡдїну ѡсмъ ѡсмь ѡсмьдесѧтъ ѡ҃ ѢДИНА ѥ͑дʼна ѥ͑дʼно ѥ͑дʼного ѥ͑дʼномоу ѥ͑дʼномъ ѥ͑дʼномѹ ѥ͑дʼноѭ҄ ѥ͑динʼ ѥ͑дина ѥ͑дини ѥ͑дино ѥ͑диномъ ѥ͑диноѭ҄ ѥ͑динъ ѥ͑динъи ѥ͑динѢмь͗ ѥ͑динѣмъ ѥ͑динѣмь͗ ѥ͑динѣхъ ѥ͑динѫ ѥ͑дно ѥ͑дного ѥ͑дномоу ѥ͑дномъ ѥ͑дномь͗ ѥ͑дноѧ ѥ͑дноѭ҄ ѥ͑днѣмъ ѥ͑дінѢхъ ѥ͗дʼного ѥ͗дʼнои͗ ѥдʼного ѥдʼномоу ѥдин ѥдинa ѥдина ѥдини ѥдино ѥдиного ѥдинои ѥдином ѥдиномȣ ѥдиному ѥдиномь ѥдиномѹ ѥдиномꙋ ѥдиноꙗ ѥдину ѥдинъ ѥдины ѥдиныи ѥдинь ѥдинѣмъ ѥдинѣмь ѥдинѣхъ ѥдинѹ ѥдинꙋ ѥднои ѥдномоу ѥдноѧ ѥдін ѥдїного ѥ҅дин ѥ҅дина ѥ҅дини ѥ҅дино ѥ҅динои҆ ѥ҅диномоу ѥ҅диноуо̑умꙋ ѥ҅диною ѥ҅диноѧ ѥ҅динъ ѥ҅динь҆ ѥ҅динѣмъ ѥ҅динѣмь҆ ѥ҅динѣмꙿ ѥ҅динѣхъ ѥ҅динѫ ѥ҅динꙑ ѥ҅динꙑи ѥ҅динꙑи҆ ѥ҅ди҆нъ ѥ҅дно ѥ҅дного ѥ҅днои ѥ҅днои҆ ѥ҅дномоу ѥ҅дномъ ѥ҅дномь҆ ѥ҅дноѧ҆ ѥ҅дноѭ̑ ѥ҅дноѭ҄ ѥ҅днѣмъ ѥ҅днѣмъ҆ ѥ҅днѣмь ѥ҅днѣмь҆ ѥ҅днѫ ѥ҅дінъ ѥ҅дꙿна ѥ҅дꙿно ѥ҅дꙿного ѥ҅дꙿнои ѥ҅дꙿномоу ѥ҅дꙿномъ ѥ҅дꙿномь ѥ҅дꙿнѣми ѥ҅дꙿнѫ ѥ҅дꙿꙿни ѯ ѯ͠ ѯ҃ ѯ꙯ ѱ҃ Ѳ ѲІ ѳ ѳ҃ ѳ҃.ть ѳ҃i ѳ҃ι ѳ҃і ѳ҃ї ѳ҃҃ ѳ꙯ ѻбоихъ ѻбѣ ѿ ѿ҃ ҁ҃ ҂ ҃s ҂·ѕ҃ ҂М ҂а ҂а҃ ҂в҃ ҂г҃ ҂д҃ ҂е҃ ҂з ҂з҃ ҂и҃ ҂и҃і ҂л҃ ҂ѕ ҂ѕ҃ ҂ѕ҃і ҂ѕ҃҃ ҂і҃ ҂ѯ ҂ѳ҃ ҂ᴤ҃ ҃s ҃sі ҃а ҃г ҅Ѥдинъ ꙁ ꙁ꙯ ꙁ꙯ї ꙇ҃ ꙇ҃б ꙇ҃ть ꙉ ꙉ҃ ꙉ҃.-ти
""".split()
)
Pd = set(
"""
Cїи ͑Овъ ͑Они ͑Ономоу ͑Онъ ωнъ Еже Ови Он Они Онъ Онь О҅нъ Сaми Сiе СЕ СЕѨ Сами Самомѹ Се Сего Сегож Сегоже Сегѡ Сеи Сеи҅ Семоу Семꙋ Сеѧ Си Сии Сии͗ Сии҅ Сим Симъ Сихъ Сица Сию Сиѩ Сиꙗ Съ Сь Сьі Сі Сї Сїи Сїѧ ТОМЗЕ ТОМЬЗЕ: ТЪЗЕ Та Тая Ти То Тоiже Тоiж҃ Того Того ж Того же Того ж҃ Тогож Тогоже Тогож҃ Тог҃ же Тог҃же Тое же Тоеже Тоиж҃ Том же Томже Томоу Тому Томь же Томьж Томьже Томьж҃ Томѹ Томѹ же Том҃же Тоя Тоѣ же Тоѣже Тоѥ же Тоѥж Тоѥже Тъ Тъй Тъі Ті Тіи Тѣм Тѣми Тѣмъ Тѣмь Тѣмꙿ Тѫ Тꙑ амъ ана ани ано анѣ богꙑ божиих еж еже есѩ е҅же иж иже инaa инїи иѡнова и҅же и҅мже какоѧ коѥѧжде ни ны н҄имꙿже о о̆на о̆нъ о͑ви о͑во о͑въ о͑вы о͑вѣмъ о͑на о͑ни о͑но о͑ного о͑нои͑ о͑номоу о͑нъ о͑ны о͑ні о͑нѣмʼ о͑нѣмъ о͑нѣмꙿ о͗ни овa ова ови ово ового овомоу овъ овы овь овѣмъ овꙑ овꙑхъ он онa она онази онаи оная онема они оно оноi онова оного оное онози онои ономȣ ономоу оному ономъ ономь ономѹ оноя оноѧ оноꙗ ону онъ онъи онъсица оны онымъ оныхъ онь оні онїа онѣ онѣма онѣмъ онѣх онѣхъ онѫ онѹ онѹю онⸯ онꙑ онꙑхъ он꙽ от отъ о҅ва о҅ви о҅во о҅вомоу о҅въ о҅вь о҅вꙑ о҅на о҅ни о҅но о҅ного о҅нои҆ о҅номоу о҅номь҆ о҅ноѧ о҅ноѧ҅ о҅ноѧ҆ о҅ноѭ̑ о҅нъ о҅нь҆сицꙙ о҅нѣми о҅нѣмъ о҅нѣмь҆ о҅нѣхъ о҅нѫ о҅нꙑ о҅нꙿ с с[е сaми сaмо сaмого сaмомоу сaмомь сaмомꙋ сaмоі сaмъ сaмь сaмѹ сaмⸯ сiе сам самʼ сама самаго самамѹ самаю саме сами самим самимъ самих само самог самого самое самои самой самом самомоу самому самомъ самомь самомѹ самоую самоѥ самоѥ҆ самоѧ саму самъ самы самымъ самыхъ самыя самь самь͗ самї самѣм самѣма самѣми самѣмъ самѣх самѣхъ самѣхꙿ самѫ самѹ самꙑ сам꙽ самꙿ се се же се ж҃ сево сег сег[о сега сего сегоже сегѡ сее сеж сеже сеж҃ сеи сеи же сеи҅ сеи҆ сей селика селико селикѫ селикꙑ селицѣ сем семʼ семже семоу сему семуже семъ семь семь же семь ж҃ семь͗ семьже семь҆ семѹ семѹ же семⸯ семꙋ семꙿ сесь сею сею̑ сею҄ сея сеі сеѥ сеѧ сеѧ͑ сеѧ͗ сеѧ҅ сеѧ҆ сеѩ сеѩ҅ сеѭ сеѭ̑ сеѭ҄ сеⱕꙙ сеꙗ си си же сиxъ сиа сие сиже сии сии͑ сии͗ сии҅ сии҆ сим сим ͛ симʼ сима сими симъ симь симьж симⸯ сим꙽ симꙿ сих сихʼ сихъ сихъ жде сихь сихⸯ сица сице сицего сицемѹ сици сицъ сиць сицѣми сицѣмъ сицѣхъ сицѧ сицѫ сицꙙ сию сия сия͑ сиі сиї сиѥ сиѥ͗ сиѧ сиѧ͗ сиѧ҅ сиѧ҆ сиѩ сиѩ҅ сиѫ сиѭ сиѭ̑ сиѭ҄ сиѯъ сиꙗ сн сомомѹ съ сь сь͗ сьі сьѣ сьѩ сьѭ сьѭ̑ сь҆ сь҆ѧ сь҆ѭ̑ сю сюю сі сі-ѭ сіа сіе сіи сіи͗ сімь сімі сіхъ сіце сію сія сїа сїаже сїе сїи сїхъ сїю сїѧ сїꙗ сѣ сѣи сѣми сѣмъ сѥмь сѧ сꙇмь сꙿ т[оо]моу т]омь тa тaa тaко тaкого тaкомѹ тaкъ тaкъиже тaкь тaкѫ тaкꙑ тaцѣмa тaцѣми тaцѣхъ тaцѣхь та та жде та же таво тази така тако таковаꙗ таковомоу таковоуо̑умоу таковꙑи҆ такого такои такои҆ такомоу такомъ такоѧ такоѭ̑ такъ такъ жде такъжде такыѧ такѫ таму таци тацѣми тацѣмъ тацѣмь тацѣхъ тая таѧ таѧ же тг҃о тг҃оже те теи тем теми темъ темь тех тех жа техъ тех҃ ти ти жде ти же тии҆ тихъ тию тиї ткомоу тмь то то ж то жде то же то жъ то ж҃ тоiже тоiж҃ това тово товож тог тог]о тогази того того ж того жде того же тогож тогожде тогоже тогож҃ тогѡ тогѡ же тог҃ тог҃же тог҃о тое тое ж тое же тоеже тож тожде тоже тожъ тож҃ тои тои ж тои же тои͗ тоижде тоижд꙯е тоиже тоиж҃ тоизи тои҅ тои҅жде тои҆ той той же толикa толика толикааго толико толикомъ толикоу толикоѩ толикъ толикы толикь толикѫ толикꙑ толикꙑи҅мъ толикꙑи҅мꙿ толикꙑи҆ толици толицѣ толицѣми толицѣмъ толицѣмь҆ толицѣхъ толцѣмьж толікѫ том том же томȣ томже томжѹ томо томоу томоужде томо҄у тому тому же томуже томъ томъ жде томъ же томъже томь томь же томь ж҃ томь͗ томьж томьжде томьже томьж҃ томь҆ томѹ томѹ же томѹ жь томѹж томѹжде томѹж҃ том҃же томⸯ томꙋ томꙿ тот тотъ тот꙽ тоу тоуж҃ тою тою же тоюже тоя тоя же тояже тоє тоі тої тоѣ тоѣ же тоѥ тоѥже тоѧ тоѧзе тоѧ҅ тоѧ҅ жде тоѧ҆ тоѩ тоѫ тоѭ тоѭ̑ тоѭ҄ тоⱖ тоꙇжде тоꙗ ту ту же туже тую тую жь тъ тъ ж тъ жде тъ же тъж тъжде тъж҇ тъзи тъи тъи҅ тъй тъі тъ҆ ты тые тыи тыми тымъ тымь тыхъ тыя тыѧ тыꙗ ть тьжде тьхъ ть҆ ті тіи тїи тїꙗ тѡг тѡго тѡгѡ тѡи тѡм тѡмъ тѡмь тѡмѹ тѣ тѣ же тѣxъ тѣе тѣж тѣже тѣжь тѣи тѣм тѣм же тѣмa тѣмʼ тѣма тѣмже тѣми тѣми жде тѣмъ тѣмъ жде тѣмъ҆ тѣмь тѣмь же тѣмь͗ тѣмьже тѣмь҆ тѣмⸯ тѣмꙿ тѣх тѣхъ тѣхъ жде тѣхъ же тѣхь тѣхⸯ тѣ҃м тѫ тѫ жде тѹ тѹ же тѹже тѹж҃ тѹю тѹюже тѿ т҃же т҃ож тⱕ тꙋ тꙑ тꙑи тꙑм тꙑмъ тꙑхъ тꙑѧ тꙑѧ҆ тꙙ цaмь цег’ чиѭ҄ эта это этѡ ємоу Ѡнa Ѡни Ѡнъ Ѡнѣмъ ѡва ѡви ѡвого ѡвѡмоу ѡвⸯ ѡи ѡн ѡнa ѡнʼ ѡна ѡнаи ѡнаю ѡная ѡнемʼ ѡни ѡнихъ ѡно ѡнова ѡног ѡного ѡногози ѡное ѡнои ѡном ѡномȣ ѡномоу ѡному ѡномъ ѡномь ѡномѹ ѡномꙋ ѡноя ѡноѧ ѡну ѡнъ ѡнъзи ѡны ѡным ѡнь ѡньзи ѡнїа ѡнїи ѡнѣ ѡнѣм ѡнѣмʼ ѡнѣма ѡнѣмъ ѡнѣх ѡнѣхъ ѡнѹ ѡнꙋ ѡнꙑ ѡн꙽ ѡн꙽сица ѡнꙿзи ѥ͑же ѥже ѥ҅дногоже ѥ҅же ѥ҆же ѻнʼ ѻнѫ ѿ же ҅Еже ҅Она ҅Они ҅Онъ ҅Ѥже ꙗ͑же ꙗ҅же
""".split()
)
Pi = set(
"""
КЪ.ТО Каковы Каѣ Комоу Которыми Которꙑ Которꙑи Коѥѧ Кто Къто Кьто Чʼто Чему Чесо Чесомоу Что Чъто Чьто Чꙿто к оѥ҅мꙋ кaко кaкѫ кaѣ кaꙗ кʼто ка кыи каа кака какая какаѧ какимъ како каков какова каково каковъ каковыѧ какого какое какои какой какому какою каку какую какїе какѫ какꙑ какꙿво каци кацѣмъ кая каѣ каѧ каꙗ каꙗ҅ ким коа ково кога кого когѡ кое коево коего коеи коемъ коея коеі коеѭ коеѭ҄ кои коимъ колика коликим колико коликоу коликѹ колицѣмъ колицѣмь колицѣх колкихъ ком комоу кому комь комѹ котерааго котерую кото которaaго которааго котораго котораѧ котории которое которои которомъ которомꙋ котороумоу которую которъи которыи которым которымъ которыѧ которѹю которꙑ которꙑи которꙑи҅мъ коіхъ коѥ коѥ͑ коѥ͑и͗ коѥ͗ коѥго коѥму коѥ҅ коѥ҅га коѥ҅го коѥ҅моу коѥ҅ѧ коѥ҅ѭ҄ коѥ҆ коѭ коѭ̑ кто ктѡ кую къто кыи кыи͑ми кыими кыѧ кїи кїимъ кїих кѡлико кѫѭ кѫѭ̑ кѫѭ҄ кѹю кⸯто кꙋю кꙑ кꙑи кꙑи͗ кꙑихꙿ кꙑи҅ кꙑи҅м кꙑи҅ми кꙑи҅мъ кꙑи҅хъ кꙑи҆ кꙑмъ кꙑмь кꙑхъ кꙑѧ кꙑѧ҅ кꙑѩ кꙿто нѣчьто сколкѹ хто цето циї цьто цьтъ чʼто чево чего чеи чем чемоу чему чемъ чемь чемѹ чемꙋ чесо чесого чесомоу чесомѹ чи чии чии҆ чим чимъ чимь чиі чсо что чъсо чъто чье чьем чьсо чьсомоу чьто чья чь҆со чїи чѣм ч҃его чꙿсо чꙿсого чꙿто што що ѥ҅же ѿколе ꙗкьже
""".split()
)
Pk = set(
"""
cꙗ СЕБѢ Себѣ СѨ ебѧ с с[ебѣ с[ѧ с]ѧ са сбѣ свои͑ свои͑хъ своихъ свои҅хъ свои҆хъ своі своіхъ своѥ͑моу своѥ͑мь͗ своѥго своѧ͗ се себе себя себѢ себѣ себѧ си сиѧ соб[ою собе собою собоюю собоѭ собоѭ̑ собоѭ҄ собя собѣ собѧ собҍ ссѩ стѧ съ събою събѣ сь ся сі сї сїѧ сѣбе сѣбѣ сѣбѧ сѧ сѩ сѩx сѫбоѭ с҃ сⱕ сꙗ сꙙ сꙙ҆ с꙽ѧ ц ца ця шь шꙙ
""".split()
)
Pp = set(
"""
-Е =васъ= aз aзъ aзь aзⸯ i iмъ iхъ «Ты ͗и ι ιмъ І Ї Аз Азъ Вамъ Васъ Ваю Вы Вꙑ ЕГО ЕМОУ Емоу И Мене Мнѣ Мъі Мьнѣ МѨ Мѩ Мꙑ НАСЪ НЕМОУ Намъ Насъ Т]ъи Тебе Тебѣ Тъи Тъі Ты Тꙑ Я Яз Язъ а аȥъ а͑зъ аего аз азʼ азъ азь аз꙽ а҅ꙁъ аꙁъ аꙁь бы вa]мъ вaмa вaми вaмъ вaмь вaмⸯ вaс вaсъ вaсь вaсⸯ вaю вaꙇ ва ваc вам вама вами вамо вамъ вамь вамь҆ вам҃ вамꙿ вас васъ вась вас҃ васꙿ ваю ваю̑ ваю҄ ваѭ ва҃с ви вмъ вмь въ въ-і въі вы вьи вьі вїе вѣ вꙑ вꙑи го гы дним е е же е]м[оу е͑моу еа ево евѡ ег его егъ егѡ ег҃ ег҃о ее еи еи҅ ей ем емȣ емо емоу емоу- емоу: ему емъ емь емѹ емꙋ ею ею҅ ея еі еѣ еѧ еѩ еѩ҅ еѭ еѭ҄ е҅ е҅го е҅и҅ е҅и҆ е҅моу е҅мꙋ е҆и҆ еҍ еꙇ еꙗ и и͑ и͑мʼ и͑ма и͑ми и͑мъ и͑хʼ и͑хъ и͗ и͗мъ им им же имa имʼ има ими имо имъ имь имѧ их ихʼ ихъ ихь их҃ ихⸯ иі и҃ и҅ и҅ мъ и҅ма и҅ми и҅мъ и҅мꙿ и҅хъ и҅хꙿ и҆ и҆мꙿ и҆хъ й м м ꙙ м[ъною мʼноѭ̑ ме ме.не меия мене менене меня менѣ менѧ менꙗ ми мне мниа мною мноѭ мноѭ̑ мноѭ҄ мнъю мнѣ мнѫѭ мнҍ мнⸯѣ моне моу мъ мъ]нҍ мъи мъною мъноѭ мъноѭ̑ мъноѭ҄ мънѣ мънҍ мъі мы мыѣ мь͗нѢ мь͗нѣ мьмьн-ѣ мьн͗ѣ мьноѭ мьнь мьнѢ мьнѣ мьы мь҆ноѭ̑ мь҆нѣ мя мі мї мѧ мѩ мѹ м҃и мⱕ мⸯноѭ мⸯнѣ мꙋ мꙑ мꙑи мꙗ мꙙ мꙙ҅ н нa нaм нaмa нaми нaмъ нaмь нaмⸯ нaс нaсъ нaсь нaю н̑̑ихъ н̑е н̑его н̑емоу н̑емъ н̑емь н̑емь͗ н̑емѹ н̑емꙋ н̑ею̑ н̑еѧ н̑еѭ̑ н̑ими н̑имъ н̑имь н̑имь͗ н̑ихъ н̑ь н̑я н̑імъ н̑ѣ н̑ѥмоу н̑ѧ н̑ⰹмъ н̑ⱕ н̑ꙙ на нам намʼ нама намамъ нами намо намъ намь нам꙽ намꙿ нас насо насъ нась нас҃ наю наю̑ наю҄ не нево нег него негѡ негѻ нее неи ней нем нем же немȣ немʼ немоу нему немъ немь немѫ немѹ нем҃ немꙋ нею нею̑ нея неі неї неѣ неѧ неѩ неѭ неѭ҄ неꙗ ни ни ми ним нима ними ними. нимо нимъ нимь нимї ним҃ ним҃и нимⸯ ним꙽ них нихʼ нихъ нихь них҃ нми ного ном нсъ нъ нъи нъъї нъі нъї ны нь ньи ньмъ ньмь ньі нь҆ ню нім німи німъ німь німі ніхъ нїми нїмъ нїмь нїхъ нѣ нѣво нѣго нѣи нѣи҅ нѣму нѣмъ нѣмь нѣмѹ нѣмꙋ нѣю нѥ нѥа нѥго нѥи нѥмо нѥмоу нѥмь нѥмѹ нѥмꙋ нѥнѹ нѥю нѥѥ нѥꙗ нѧ нѩ нѫ нѫѭ нѭ н҄[е]моу н҄[емь н҄е н҄его н҄еи н҄еи͗ н҄еи҆ н҄емоу н҄емъ н҄емь н҄емь҆ н҄емꙋ н҄емꙿ н҄ею н҄ею̑ н҄ею҄ н҄еі н҄еѧ н҄еѧ҆ н҄еѩ н҄еѭ н҄еѭ̑ н҄еѭ҄ н҄и н҄им н҄имa н҄има н҄ими н҄имъ н҄имь н҄имь҆ н҄их[ъ н҄ихʼ н҄ихъ н҄ихь н҄ь н҄ь҆ н҄іхъ н҄ѥмоу н҄ѧ н҄ѩ н҄ѫ н҄ѭ н҄ⱕ н҄ꙗ н҄ꙙ нⸯ нꙑ нꙗ нꙙ сaмого сaмъ сами самого самъ се си т т-ъі т[ꙑ тбе тбѣ те тебе тебя тебѢ тебѣ тебѧ ти тобе тобо тобою тобоѫ тобоѭ тобоѭ̑ тобоѭ҄ тобя тобѡю тобѣ тобѧ тобѫѭ тобҍ това тои тъ тъбе тъбҍ тъи тъі тъї ты тя ті тїꙗ тѣбе тѣбя тѣбѣ тѣх тѧ тѩ тⱕ тꙑ тꙑи тꙗ тꙙ хъ хь ю я яз язъ єг єго єгѡ єи ємоу єму ємꙋ єю єѥ і і-мъ і-хъ іми імо імъ імь іхъ ї їмъ їхъ ѣ ѣзъ ѥ ѥ]го ѥ͑го ѥ͑и ѥ͑и͗ ѥ͑моу ѥ͑мъ ѥ͑мѹ ѥ͑ю̑ ѥ͑ю҄ ѥ͑ѧ ѥ͑ѧ͗ ѥго ѥгѡ ѥе ѥи ѥи҆ ѥмȣ ѥмоу ѥму ѥмь ѥмѹ ѥмꙋ ѥю ѥє ѥѥ ѥѧ ѥ҅га ѥ҅го ѥ҅и ѥ҅и҅ ѥ҅и҆ ѥ҅мо ѥ҅моу ѥ҅мо҄у ѥ҅мъ ѥ҅мꙋ ѥ҅ю̑ ѥ҅ю҄ ѥ҅і̑ ѥ҅ѧ ѥ҅ѧ҅ ѥ҅ѧ҆ ѥ҅ѭ̑ ѥ҆го ѥ҆и ѥ҆и҆ ѥꙗ ѧ ѧ͑ ѧ͗ ѧз ѧзо ѧзъ ѧ҅ ѧ҆ ѩ ѩѩ ѩ҅ ѫ ѭ ѭ̑ ѭ͗ ѭ҄ ѭ҅ ѭ҆ ҅ насъ Ꙇ ꙇ ꙇxъ ꙇмa ꙇма ꙇми ꙇмъ ꙇмь ꙇх ꙇхъ ꙇ҃мa ꙇ҃мъ ꙇ҅хъ ꙗ ꙗȥъ ꙗз ꙗзъ ꙗ҆
""".split()
)
Pr = set(
"""
eже iже ͑Иже ιм же Імьже ЇЖЕ Їже Їміже Їхъ же Егоже ЕжЕ Еже Елико Емоуже Еѭже ИЖЕ Иже Котороѥ Которыи Которыя Кто НЪЖЕ Что Што Юже Яже ацем꙽же дето е е еже е]гоже еЖе его ж его же егож егоже егѡж еж еже ежь еиже ели елика еликими елико еликѹ еліко емоу-ж-е емоуже ему же емуже емѹже еюже еяже еіже еѩже еѭже е҅же е҅и҅же еꙇже еꙗже же и же и͑же и͑мʼже и͑мꙿже и͑хъже иж ижде иже имʼ же имже ими же имиж имиже имъж имъже имь же имьж имьже имⸯже им꙽же их же ихʼ же ихже ихъ же ихъже ихⸯже их꙽же ихꙿже и҅жде и҅же и҅маже и҅мже и҅мжꙿе и҅миже и҅мъже и҅мꙿже и҅хже и҅хъже и҅хꙿже какова каково камѹ каторае катораи катораю каторая каторое катором каторых каци кемъ кимь коа ково кого когѡ кое коем кои коих кои҆ кой колико комо комоу кому комъ комѹ котораго которая котораѧ котораꙗ котории которого которое которои которой которомь которомꙋ которую которы которые которыи который которых которыхъ которыя которꙑи которꙑхъ котѡрые коѫ коꙗ кто ктѡ къиже къто кѡму кѫѭ кꙑмъ н̑егоже н̑еи͑же н̑емже н̑имь͗же н̑ихъже н̑ьже не же него же негож негоже нее же неже неи же неиж неиже нем же немже немоуж немоуже немуже немъ ж немъже немь же немьже нем꙽ же нем꙽же неюже неяже неѧже неѩже неѩ҅же неꙗже никыи͑же нимже нимиже нимъже нимь же нимьже нимⸯже них же нихже нихъ же нихъже нихъхъже нихⸯже них꙽же ничимьже нъже ньже нь҆же ню же нюже ніхъже ніх꙽же нїхже нѣже нѣиже нѥгоже нѥже нѥи же нѥм же нѥмьже нѥм’ же нѥмⸯже нѧже нѫже нѭже н҄егоже н҄еже н҄еи͑же н҄еи҅же н҄емʼже н҄емже н҄емоуже н҄емъже н҄емь͗же н҄емьже н҄емь҆же н҄емꙿже н҄ею̑же н҄еꙇже н҄имже н҄имиже н҄имъже н҄ихъже н҄ихьже н҄ьже н҄ѧже н҄ѫже н҄ѭже н҄ⱕже нⸯже оже онже сколь томьже хто хъже хіъ же цего ции циї цто цѣмь чево чег чего чем чему чемъ чемь чемѹ чето чимь что чтѡ што що юж юже я͑же я͑когоже я͑къ яже яко же яковъ єж єже єиже єлицими єму же іже імъже імьже іхъже ї їже їжехъ їмже їмъже ѡмуже ѢЖЕ Ѣже ѣже ѣкaже ѣкаже ѣкъиже ѣцѣмъ ѣцѣхъ ѥ же ѥ͑гоже ѥ͑же ѥ͑лико ѥ͑ликы ѥ͑моуже ѥго же ѥгож ѥгоже ѥже ѥиже ѥлико ѥмуже ѥмѹ же ѥмѹже ѥмꙋже ѥюже ѥѧ҅же ѥ҅го ѥ҅гоже ѥ҅же ѥ҅и҅же ѥ҅лико ѥ҅моуже ѥ҅мꙋже ѥ҅ю̑же ѥ҅ѧже ѥ҅ѧ҅же ѥ҅ѭ̑же ѥ҅ѭ҄же ѥ҆же ѥꙗже ѧ͑же ѧже ѧ҅же Ѩже ѩже ѩжѩ ѫ҅же Ѭже ѭ̑же ѭж-е ѭже ѭ҄же Ꙇже ꙇ[же ꙇже ꙇжь ꙇзе ꙇмъже ꙇмьже ꙇхже ꙇхъже ꙇ҅. хъже ꙇ҅же ꙇ҅хъже ꙗж ꙗже ꙗ҅же ꙗ҅ка ꙗ҆же
""".split()
)
Ps = set(
"""
=н=aшихъ Вaши Ваши Мои Мої Моѣ Нашъ Нашь Т]воѣ Твоі Твої Твоѣ Твоѥ҅ Твоѥ҅моу в]aшь вaшa вaше вaшего вaшеи вaшемоу вaшемь вaшеѩ вaшеꙗ вaши вaшими вaшимъ вaшимь вaшихъ вaшихь вaшь вaшю вaшѧ вaшѫ вaшꙋ ваша ваше вашева вашег вашего вашеи вашеи҆ вашем вашемоу вашему вашемъ вашемь вашемѹ вашемꙋ вашею вашея вашеі вашеѧ вашеѧ҆ вашеѩ вашеѭ ваши вашим вашима вашими вашимъ вашимь ваших вашихъ вашу вашъ вашь вашь͗ вашьа вашю ваші вашімъ вашіхъ вашѣ вашѧ вашѩ вашѫ вашⱕ вашꙙ воѣ воѩ вшаа въшъ м[оі мае маеи маему маим маих мая мего мо мо]ѩ моа мое моево моег моего моеи моеи҅ моеи҆ моей моем моемо моемоу моему моемъ моемь моемьемь моемѹ моемꙋ моею моею҅ моея моеі моеї моеѣ моеѧ моеѩ моеѩ҅ моеѭ мое҅ мое҆ мои мои͑ма мои͑мъ мои͑хъ мои͗ моим моима моими моимъ моимь моимі моих моихъ моихь моих’ мои҅ мои҅ма мои҅ми мои҅мъ мои҅мꙿ мои҅хъ мои҆ мой мою мою̑ моя моя͗ моі моіма моіми моімъ моімь моіхъ мої моїма моїмъ моїмь моїхъ моѣ моѥ моѥ͑ моѥ͑го моѥ͑и͗ моѥ͑моу моѥ͑мъ моѥ͑ю̑ моѥ͑ю҄ моѥ͑ѧ моѥ͑ѧ͗ моѥ͗ моѥго моѥе моѥи моѥи҆ моѥму моѥмъ моѥмь моѥмѹ моѥмꙋ моѥю моѥю̑ моѥѣ моѥѧ моѥѭ моѥ҄и моѥ҅ моѥ҅го моѥ҅мо моѥ҅моу моѥ҅мъ моѥ҅ю̑ моѥ҅ю҄ моѥ҅ѧ моѥ҅ѧ҆ моѥ҆ моѥ҆го моѥ҆и҆ моѥꙗ моѧ моѩ моѭ моѭ̑ моѭ҄ моꙇ моꙇ[мь моꙇми моꙇмъ моꙇмь моꙇхъ моꙗ моꙗ҆ мъѥи мѡи мꙑмъ н]aши нa нaш нaшa нaше нaшего нaшеи нaшемоу нaшемь нaшемѹ нaшею нaши нaшими нaшимъ нaшимь нaшихъ нaшихь нaшмь нaшь нaші нaшімь нaшімь: нaшімі нaшімꙇ нaшіхъ нaшѣ нaшѧ нaшѫ нaшⸯ нaшꙇхъ нaшꙋ нанашего насего наш наш[а] наша нашго наше нашева нашег нашего нашегѡ нашег҃ нашеи нашеи͗ нашей нашем нашемоу нашему нашемъ нашемь нашемь҆ нашемѹ нашемꙋ нашею нашею̑ нашея нашеї нашеѧ нашеѭ̑ нашеѭ҄ нашеꙗ наши нашиихъ нашим нашима нашими нашимъ нашимы нашимь наших нашихъ наших҃ нашог нашоу нашу нашъ нашь нашь҆ нашю наші нашіма нашімъ нашімі нашіхъ нашї нашѣ нашѧ нашѩ нашѫ нашѹ нашⱕ нашⸯ нашꙋ нашꙙ нашꙿ наѭ неговы неино неинь нешего нш҃а нш҃ег нш҃ь нъі нѥина нѥино нѥины нѥинь н҃ша н҃шго н҃шеи н҃ши н҃шим н҃шимъ н҃ших н҃шихъ н҃шмꙋ н҃шхъ н҃шь н҃шю оимъ оімъ оімь своима своѫ с҃тъꙇмь с҃тьꙇмь твего тво тво-ї твоа твое твоево твоег твоего твоеи твоем твоемоу твоему твоемъ твоемь твоемѹ твоемꙋ твоею твоея твоеі твоеї твоеѥ твоеѧ твоеѩ твоеѩ҅ твоеѭ твоеѭ҄ твоеꙗ твои твои мъ твои͑мъ твои͑хъ твои͗ твои͗ми твои͗мъ твоим твоима твоими твоимъ твоимь твоих твоихъ твоихь твои҅ твои҅мъ твои҅хъ твои҆ твой твою твоя твоєг твоі твоіма твоіми твоімъ твоімь твоімі твоімї твоімꙇ твоіхъ твої твоїмъ твоїмь твоїхъ твоѣ твоѣ҅ твоѥ твоѥ͑го твоѥ͑и твоѥ͑моу твоѥ͑мъ твоѥ͑мꙋ твоѥ͑ю̑ твоѥ͑ю҄ твоѥ͑ѧ твоѥ͑ѭ̑ твоѥ͗ твоѥго твоѥи твоѥи͑ твоѥи҆ твоѥму твоѥмь твоѥмѹ твоѥмꙋ твоѥю твоѥѧ твоѥѧ҆ твоѥѭ̑ твоѥѭ҄ твоѥ҅ твоѥ҅го твоѥ҅и твоѥ҅и҆ твоѥ҅моу твоѥ҅мъ твоѥ҅мꙿ твоѥ҅ю̑ твоѥ҅ѧ твоѥ҅ѧ҆ твоѥ҅ѭ твоѥ҅ѭ҄ твоѥ҆ твоѥ҆го твоѥ҆и҆ твоѥ҆ѧ҅ твоѥꙗ твоѧ твоѩ твоѫ твоѭ твоѭ̑ твоѭ҄ твоꙇ твоꙇxъ твоꙇмa твоꙇмъ твоꙇмь твоꙇмі твоꙇхъ твоꙗ твоꙗ҆ твѫѭ тъвоемѹ тъвоѧ
""".split()
)
Pt = set(
"""
СВОЕ СВОЕГО СВОѬ асвоимъ сваево сваю сво своi своiхъ своа свое своеi своеа своево своег своего своегѡ своее своеи своеих своеи҅ своей своем своемȣ своемоу своемоу: своему своемъ своемь своемѹ своем҃ своемꙋ своею своея своеі своеіѧ своеѣ своеѥ своеѧ своеѩ своеѩ҅ своеѫ своеѭ своеѭ҄ свое҅ свое҆и҆ своеꙗ свои свои͑ свои͑ма свои͑ми свои͑мъ свои͗ свои͗мъ свои͗хъ своим своима своими своимъ своимь своимі своимї своимⸯ своих своихъ своихь своих҃ свои҅ свои҅ма свои҅ми свои҅ми҆ свои҅мъ свои҅мꙿ свои҅хъ свои҆ свой свомъ свооемъ свосемѹ свою своя своя͑ своя͗ своєго своєи своємоу своєму своєю своі своіемъ своіма своіми своімъ своімь своімі своіхъ свої своїми своїмъ своїмь своїмі своїхъ своѣ своѥ своѥ͑го своѥ͑и своѥ͑и͗ своѥ͑мъ своѥ͑ѧ͑ своѥ͑ѭ̑ своѥ͑ѭ҄ своѥ͗ своѥ͗и своѥг[оо] своѥго своѥгъ своѥгѡ своѥи своѥи҆ своѥмоу своѥму своѥмъ своѥмь своѥмѹ своѥю своѥю̑ своѥя своѥѣ своѥѧ своѥѧ҆ своѥ҅ своѥ҅го своѥ҅и своѥ҅и҆ своѥ҅моу своѥ҅мъ своѥ҅мꙋ своѥ҅ю̑ своѥ҅ю҄ своѥ҅ѧ своѥ҅ѧ҆ своѥ҅ѭ̑ своѥ҅ѭ҄ своѥ҆ своѥ҆ѧ҆ своѥ҆ѭ̑ своѥꙗ своѧ своѧ҅ своѧ҆ своѩ своѩ҃ своѩ҅ своѩꙇ своѫ своѭ своѭ: своѭ̑ своѭ̑. своѭ҄ своѭ҅ сво҄ꙇхъ своꙇмa своꙇми своꙇмъ своꙇмь своꙇхъ своꙗ своꙗ҆ свъѧ свѡего свѡи соѥго с҃тъꙇмь твоеа
""".split()
)
Px = set(
"""
(и)нои [всеѧ iнии iное iнѡва iнꙑмъ iнꙑхъ iнꙑх҃ ВСЕГО ВЪсѣхъ ВЬСЕГО ВЬСХЪ ВЬСѦ Весъ Весь Все Всемоу Вси Всю Всѣ Всѣмъ Всѧ Въсе Въсеѩ Въси Въсъ Въсі Въсѣ Въсѩ Вь͗си Вь͗сѫ Вьсе Вьсего Вьсеѩ Вьси Вьсъ Вьсі Вьсѣ Вьсѣмъ Вьсѣмь Вьсѩ Вь҆си Вь҆сѣмъ Вⸯсѣ Вⸯсѣмъ Етеріи Е҅дини Ини Комоу Которыи Къто Кыꙗ Некий Никотерꙑ же Никтоже Никътоже Никъꙇ Ничто Ничтоже Ничьтоже Нічесоже Нѣкоѥ҅го Нѣцїи Чьто в'сѭ в[сѧ в[ь]сѣ вʼса вʼсеи вʼсемь͗ вʼси вʼсѣхъ вʼсⱕ вево вес весъ весь весь͗ вохи вохо вохъ вс вс- всa вса все все и всеi всеа всево всего всее всеи всеи҆ всей всем всеми всемоу всему всемъ всемь всемї всемѹ всемꙋ всех всехо всехъ всею всея всеі всеѣ всеѧ всеѧ҆ всеѭ̑ всеꙗ вси всими всихъ всхъ всхѣ всь всю вся всѣ всѣго всѣи всѣм всѣмʼ всѣми всѣмоу всѣмъ всѣмь всѣмѹ всѣм҃ всѣх всѣхʼ всѣхъ всѣхь всѣх҃ всѣю всѣѧ всѧ всѧго всѧмѹ всѫ всѹ всꙋ всꙗ всꙙ вхѹ въсa въса въсе въсего въсеи въсемь въсемѹ въсею въсеі въсеѥ въсеѩ въси въсъ въсь въсю въсі въсѣ въсѣми въсѣмъ въсѣмь въсѣхъ въсѣхь въсѣхⸯ въсѧ въсѩ въсѫ въсѹ въсꙋ вь сеи вь͑сь͑ вь͗са вь͗се вь͗сего вь͗сеи вь͗сеи͗ вь͗семоу вь͗семъ вь͗семь вь͗семь͗ вь͗сеѧ вь͗сеѭ҄ вь͗си вь͗сь вь͗сь͗ вь͗сѢми вь͗сѢмъ вь͗сѢхъ вь͗сѣми вь͗сѣмъ вь͗сѣмь вь͗сѣмь͗ вь͗сѣхъ вь͗сѫ вь͗сⱕ вь͗сꙙ вьс[ѣх]ъ вьсa вьса вьсе вьсего вьсеи вьсеи͗ вьсеи҅ вьсемоу вьсемъ вьсемь вьсемѹ вьсехъ вьсею вьсеі вьсеѥ вьсеѧ вьсеѩ вьсеѭ вьсеꙗ вьси вьсми вьсмъ вьсъ вьсь вьсь͗ вьсь҆ вьсю вьсі вьсѣ вьсѣми вьсѣмъ вьсѣмь вьсѣмь҆ вьсѣмі вьсѣхъ вьсѣхь вьсѣцѣї вьсѧ вьсѩ вьсѫ вьсѭ вьсѹ вьсꙗ вьсꙙ вь҆ сего вь҆са вь҆се вь҆сего вь҆сеи вь҆сеи҆ вь҆семоу вь҆семъ вь҆семь҆ вь҆сеѧ вь҆сеѭ̑ вь҆си вь҆сь вь҆сь҆ вь҆сѣ вь҆сѣми вь҆сѣмо вь҆сѣмъ вь҆сѣмь вь҆сѣмь҆ вь҆сѣмꙿ вь҆сѣх вь҆сѣхъ вь҆сѫ вь҆сꙙ вь҆сꙿ вѣ вⸯсa вⸯсе вⸯсего вⸯсеѩ вⸯсеѭ вⸯси вⸯсь вⸯсѣ вⸯсѣми вⸯсѣмъ вⸯсѣмь вⸯсѣхъ вⸯсѣхь вⸯсѣхⸯ вⸯсѧ вⸯсꙋ в꙽си вꙿса вꙿсемь҆ вꙿси вꙿсѣ вꙿсѣми вꙿсѣмъ вꙿсѣхь вꙿсѧ единa едина едини единого единомоу единомъ единомь единъ единь едині единѣмъ единѣмь единѫ единꙑ една едінъ едінꙑ елика етерa етера етери етериі етериꙇ етеро етеромъ етеромь етероу етеръ етеры етеріи етерѣ етерѫ етерꙑ е҅динъ е҅тера е҅тери е҅теромъ е҅теръ и и͑ни и͑но и͑ного и͑номоу и͑ноѧ и͑нъ и͑ны и͑нѢхъ и͑нѣми и͑нѣмъ и͑нѣхъ иго ин инa инȣ ина инаа иная инаѧ инаꙗ инехъ ини инии ино инова иново иного иногѡ иног҃ иное инои иной ином иномоу иному иномъ иномь иномѹ иноу иною иноѥ иноѧ иноѩ иноѭ иноꙗ ину иную инъ инъмоу ины иныа иные иныи иным иными инымъ иных иныхъ иныя иныѥ иныѧ иныꙗ инь инїи инѣ инѣма инѣми инѣмъ инѣмь инѣмь҆ инѣх инѣхъ инѣхь инѫ инѹ инѹю инⸯ инꙑ инꙑе инꙑхъ инꙑхь инꙑѥ инꙑꙗ ин꙽ иого и҅на и҅ни и҅но и҅ного и҅нои и҅нои҆ и҅номоу и҅номь҆ и҅ноѧ и҅нъ и҅нѣми и҅нѣмъ и҅нѣмъ҆ и҅нѣмь и҅нѣмь҆ и҅нѣмꙿ и҅нѣхъ и҅нѫ и҅нꙑ и҅нꙿ к[то кaꙗждa кʼто кааждо какава какаѧ какие какимъ каких какихъ како̏ какова каково каковъ каковѣ каковѹ какое какои какой какомъ какомѹ каку какъ какїе какѹю кацѣм кацѣмъ кацѣмь кая каѧ каꙗ кемъ ки кии кимъ кимь ким꙽ кого когоджо когожде когождо когоже когожъдо когожьдо когѡ ког҃ кое коего коегождо коегожꙿде коеи коей коемждо коемуждо коемъ коея коеѭ кое҅ждо кое҅и҆ кождо коже кожъдо кожьдо кои коиждо коими кокаѧ кокою колико колицѢ колицѣмъ колицѣх комоу комоуждо комоуже комоужъдо комоужьдо кому комуждо комъ комьже комѹ комѹждо комѹже комѹжьдо комꙋ комꙋждо котомъ котораго которая котораѧ котореи котори коториждо которого которое которои которой которомъ которомь которою котороѣ которые которыи который которыхъ которѣи котѡраꙗ котѡрыи коѥ коѥ͑го коѥ͑же коѥ͑и коѥ͑ѧ͗ коѥго коѥгоже коѥжьдо коѥи҆ коѥмоу коѥ҅го коѥ҅гождо коѥ҅ждо коѥ҅мь҆ждо коѥ҅мꙿжде коѥ҅ѧ҅ коѥ҅ѧ҆ коѥ҆ коѧжде кто ктѡ кую куюждо къбо го къждо къжъдо къжьдо къто кътомоу кыи͑ма кыи͑хъ кыиждо кыиже кыими кыихъ кым кыя кыѧ кьждо кьжъдо кїиждо кїиждѡ кѣкїѧ кѣмъ кѣм꙽же кѫѭ кѫѭ̑ кѹю кѹюждо кⸯто кꙑи҅ми кꙑи҅мъ кꙑи҆ кꙑмо кꙑѧ кꙿто ликто милостинꙗми некакою некатарые неки некихъ некоемъ неколико некомѹ некоторая некїи ни которому ни кто ни ѥ͑динъ же ни ѥ͑дінъ ни ѥ҅дина ни ѥ҅дино ни ѥ҅динъ ни ѥ҅дно ни ѥ҅дного ни ѥ҅дного же ни ѥ҅дномоу ни ѥ҅дноѧ же ни ѥ҅дноѧ҅ же ни ѥ҅днѣмъ ни ѥ҅дꙿного ни-комьже никaкогоже никaкоѩже никʼтоже никака никакаа никакаѧ никакими никакова никаково никаковъ никаковы никаковꙋ никакого никакогоже никакои никакоиже никакой никакому же никакоя никакоꙗ никакъже никакыѧ никаꙗже никимже никово никого никого же никогож никогоже никое ж никоего никоего ж никоею никоею же никоеяже никоеѧ никоеѧже никоеѩже никое҅же никоеꙗ же никои никомȣже никомоу никомоу же никомоуже никому никому же никому жь никомуже никомѹ никомѹ же никомѹже никомѹж҃ никомꙋ никомꙋже никотерꙑ же никотерꙑи же никотораго никоторово никоторого никоторомѹже никоторые никоторыми никоторымъ никоторымь никоторꙑ никоторꙑ же никоѥго же никоѥи҅же никоѥ҅гоже никоѥ҅же никоѥ҅ѧ҅же никоѥ҅ѭ҄же никоѥꙗ же никоѥꙗже никоѩже никто никто ж никто же никтож никтоже никтѡ никтѡ же никтѡж никъто никъто же никътоже никътозе никⸯтоже никꙑ же никꙑже никꙑи же никꙑи͑мъже никꙑиже никꙑмьже ник꙽тоже никꙿтоже нихто ництоже ничʼсоже ничево ничег ничего ничего же ничегоже ничемъ ничесо же ничесоже ничето же ничим ничим же ничимже ничимъже ничимь же ничимьже ничимь҆же ничимꙿже ничсо же ничсоже ничсо҅же ничто ничто же ничтож ничтоже ничтѡж ничъже ничъсоже ничътоже ничь͗соже ничьсо же ничьсоже ничьсѡже ничьто же ничьтоже ничь҆согоже ничь҆соже ничꙿсоже ничꙿтоже ништо нищо ниѥ҅дноже ниѥ҅дꙿногоже нікʼтоже нічесоже нѢкоѥ нѣ нѣ-колицѣхъ нѣвторое нѣгого нѣгоѥ҅го нѣкаа нѣкака нѣкако нѣкакъ нѣкакы нѣкакѫ нѣкакѹ нѣкацѣми нѣкая нѣкаѧ нѣкаꙗ нѣкии нѣкий нѣким нѣкихъ нѣкия нѣкога нѣкого нѣкое нѣкоег нѣкоего нѣкоем нѣкоему нѣкоемъ нѣкоемѹ нѣкоею нѣкои нѣкоимь нѣколико нѣколиком нѣколикою нѣколикѹ нѣколицех нѣколицѣх нѣколицѣхъ нѣколькомь нѣкомоу нѣкомꙋ нѣкоторааго нѣкотораѧ нѣкотории нѣкотории҆ нѣкоторое нѣкотороуо҄умоу нѣкотороѥ нѣкоторыи нѣкоторым нѣкоторыя нѣкоторѣи нѣкоторѣмь нѣкоторѫѭ̑ нѣкоторѹю нѣкоторꙑи͗ нѣкоторꙑи҅ми нѣкоторꙑи҅мъ нѣкоторꙑи҆ нѣкоторꙑѧ҆ нѣкоѥ нѣкоѥго нѣкоѥмȣ нѣкоѥмѹ нѣкоѥ҅ нѣкоѥ҅го нѣкоѥ҅моу нѣкоѥ҅мꙋ нѣкоѥ҆ нѣкоѥꙗ нѣкто нѣкъто нѣкыи нѣкыихъ нѣкых нѣкыѧ нѣкїи нѣкїѧ нѣкѣмъ нѣкѫѭ̑ нѣкѹю нѣкꙑ нѣкꙑи нѣкꙑихъ нѣкꙑи҅ми нѣкꙑи҅мъ нѣкꙑи҆ нѣкꙑѧ҆ нѣкꙿто нѣци нѣции нѣции҆ нѣцыи нѣцїи нѣцѣхъ нѣчʼто нѣчева нѣчево нѣчесо нѣчто нѣчъто нѣчьто нѣчь҆со нѣчꙿто н҄ииа҅ꙗ҅же ова ово овъ овъихъ овы овѣмъ овꙑ ризах сичꙿка сичꙿки сичꙿко сичꙿкы тогоже хто цеме ции ции҅ ции҆ циї цого цѣмъ цѣхъ чʼто чева чево чего чем чемже чемъ чемь чемь же чемьже чемѹ чем꙽ чесо чесомъже чесомь҆же чии чим чимо чимъ чимь что чтоже чтѡ чъто чьему чьемъ чьсо чьсомоу чьто чьѥи чьѥмь чь҆со чь҆то чімъ чѣмъ чꙿсо чꙿто што що ынех ынои ыном ыномъ ыною ыноѥ ыную ынъ ыным ынымъ ыных ынѣми єдинь єдна інаго інии іниі іное інъ інъі інѣхъ їна їни їно їного їномъ їнъ їнѣмъ їнѣхъ ѡв ѡва ѡви ѡвому ѡвъ ѡвы ѡвыи ѡвым ѡвых ѡвыхъ ѡвїи ѡвѣм ѡвѣмъ ѡвѣмь ѡвѣхъ ѡвѹ ѥ͑динъ ѥ͑днѫ ѥ͑дінѣмъ ѥдини ѥдиномь ѥдинь ѥтерь ѥ҅динъ ѥ҅динъ҆ ѥ҅дна ѥ҅дного ѥ҅днои҅ ѥ҅дꙿного Ꙇнѫ Ꙇ҅нѫ ꙇ[нa ꙇнa ꙇна ꙇная ꙇни ꙇно ꙇнова ꙇного ꙇное ꙇномоу ꙇному ꙇноѩ ꙇноѭ ꙇнъ ꙇные ꙇнымъ ꙇнь ꙇнїи ꙇнѣмъ ꙇнѣмь ꙇнѣхъ ꙇнѫ ꙇнꙑ ꙇ҅нѣхъ ꙇ҅нꙑ ꙗ҅къ
""".split()
)
R = set(
"""
=въ= [за] [из] iз iзъ ȥ ιз Ісъ Їз Їз-д Їс Ат БЕЗ Без Безо Бес Блізъ Блізь В ВО ВЪ ВЬ Во Въ Въі Вь Вь͗ Вь҆ Г Для До Зa За ИЗ-Д Из Из-д Изъ Ис Иѕо К КО КЪ Къ Кь Кⸯ Нa НА НАД НАДЪ НДЪ На Надо Надъ О ОТ ОТЪ Окръстъ От Ото Отъ Оу О҃т О҅ О҅тъ ПО ПРѢДЪ ПРѢЖДЕ По Посрѣдѣ Пре Преж Прежде Преже При Про Прѣдо Прѣдъ Прѣжде Ради С Со Съ Х а бе бе- беȥ беȥъ беж без безʼ безд безо безъ безь без꙽ безꙿ бес бесъ бес꙽ беꙁ беꙁъ беꙁꙿ близ близъ близь блиꙁъ блізъ блізь бѣсѡ б҃е в в малѣ в[ъ вo вʼ вʼзлѣ вʼкроугъ ва ве вез꙽ верху верхъ внутрь внѣ внꙋтри во вовь возле вонъ вр?xоу връхоу връху врь͗хоу врьхѹ врь҆хоу втаи въ въ. въ͗ въвъ въз възлѣ въкроугъ вън вънъ вънѣ въс въскрaи въскраи въі въ҆ въꙁ высподи вь вь͗ вь͗нѣ вь͗слѢдъ вь͗слѣдъ вьз вьнѣѭдоу вьнѫтрьѭ̑доу вьрхѹ вьслѣдъ вь҆ вь҆нѣ вь҆слѣдъ вѡ в҃ в’ вⸯ вꙑ вꙑше в꙽ вꙿ г гора д д-о да далече дао для длѧ до дъ дѣла дѣлма дѣль҆ма дѣлѧ дѣл҄ъма дѣл҄ьма дѣл҄ѣ дѣл҄ꙗ дѣлꙗ дѣлꙿма дҍлѧ ж з з[a зa зʼ за заради зъ з꙽ и иȥ и͑ и͑з и͑зʼ и͑зд и͑зъ и͑с иа иж из из за из-д из-д- изʼ изд изноутри изнꙋтри изо изъ изь из’ из꙽ изꙿ ис искрь исъ ис꙽ и҃с и҅ и҅ж и҅с и҅ꙁ и҅ꙁ-д и҅ꙁд и҅ꙁъ и҅ꙁꙿ и҆ꙁ иꙁ иꙁь иꙁꙿ к к[ъ кʼ ка ко кроме кромѣ крѡмѣ къ къ҆ кь кь͗ кь҆ к҃ к’ кⸯ к꙽ кꙿ меж междоу между междю междꙋ межи межоу межъ межь межю межⷣꙋ мимо мьжю мю мюждю мѣжду мѣсто н н а нa нaд нaдъ нaдь на на на-д над надʼ надо надъ надь напередъ напротиву насреди нат на҅ не недалече ни о о̆ о̆тъ о̑ о̑у о͑ о͑крьсть о͑крѫгʼ о͑т о͑тʼ о͑тъ о͑ть о͑ть͗ о͗тъ об обо объ около окрестъ окрстъ округъ окръстъ окръсть окрьстъ окрьсть окрь҆сть҆ окрѹг освѣнь от от[ъ отʼ отаи ото отъ отъ вьнѣѫдоу отъ- оть оть҆ оу о҃ о҃тъ о҄у о҅ о҅крьсть о҅крь҆сть҆ о҅крѫгъ о҅т о҅тъ о҅ть о҅ть҆ о҅ть҆тъ҆ о҅тꙿ о҆ о҆тъ п п]о па пад педъ пер]е[дъ пере перед переди передо передъ переже перет перъ перьдъ по по сторонь по томь по. под подале подаль подле подлъгъ подлѣ подо подъ подъле подь подь҆ подѫ под҃ подꙿ пониж поперегъ после посль послѣ послѣдь послѣжде послѣже посреди посредѣ посрѢдоу посрѢдѢ посрѣдоу посрѣдѣ посторонь посьле потаи потивꙋ прi пра прде прдъ прдѣ пред предо предъ пред҃ преж прежде преже прекі при прид про промеж промежду промежи промежоу промежь промежю промежѹ промежꙋ промьжю промѣжи против противо противоу противу противъ противь противѫ противѹ противꙋ протиоу пръвѣе прьвѣѥ҅ прь҆вѣѥ прь҆вѣѥ҆ прі прї прѢдъ прѢжде прѣ прѣд прѣдо прѣдъ прѣдь прѣдь͗ прѣдь҆ прѣдѣ прѣдꙿ прѣжде прѣже прѣж҃ прѣмо прѫтивѫ пьредъ пьрьдъ пѡслѣ пѹ рaд[и рaди рaді рaзвѣ ра рад рад. ради радма раді радꙿма разве развїе развѣ развѣе разъвѣ разьве ра҅ди раꙁвѣ рити роꙁвѣ р҃҃҃ с сʼ са сверхъ свѣн҄е се скʼрозѣ сквоз сквозе сквозѣ сквоѕѣ сквоꙁѣ сквѣзѣ скозѣ со сопротивъ спустя сред среди средь средѣ срѣдѣ ссъ съ съпротивꙋ съсꙿ съ҆ сь сь͗ сь҆ сѹпротивъ сѹпротивь с҃ с’ с꙯ с꙽ с꙽квоѕѣ сꙿ тъ у х хъ цересъ через черезъ чересъ черосъ чрез чрезъ чресъ чрѣсъ ч꙽резъ ъ ѕ ѕа і і-з-д із із-д ізъ іс ї їз їз-д їс їꙁъ Ѡ Ѡб Ѡкръстъ Ѡт Ѡто Ѡтъ Ѡть ѡ ѡ[тъ ѡ̑ ѡб ѡба полы ѡбаполъ ѡбаполы ѡбо ѡбъ ѡколо ѡкололо ѡкрестъ ѡкрстъ ѡкрьсть ѡкрѹг ѡкрѹгъ ѡпрично ѡт ѡтаи ѡто ѡтъ ѡть ѡ҃ ѡ҄ ѩдѣ ѹ ѻ ѻколо Ѿ ѿ ѿ всюдоу ѿт ѿѡ ҆Отъ ꙁа ꙇ ꙇж ꙇз ꙇз-д- ꙇзвьноу ꙇзд ꙇзо ꙇзѫтриі ꙇс ꙇскрь ꙋ ꙋ҅ ꙗ҅че Во О
""".split()
)
V = set(
"""
[бѣ] Буде Бъістъ Бъіхомъ Бъіхъ Бъїхомъ Бывъ Были Быс Бысть Быти Бяшеть БѢ БѢа͑хѫ Бѣ Бѣaхѫ Бѣaше Бѣaшете Бѣахѫ Бѣсте Бѧхоу Бѧше Бѫдетъ Бѫди Бѫді Бѫдѣмъ Бѫдѣте Бѫдѫ Бѫдѫтъ Бꙑвъ Бꙑвъше Бꙑвъшема Бꙑвъши Бꙑвъшоу Бꙑвъшю Бꙑс Бꙑстъ Бꙑхомъ Бꙑшѧ Бꙑшѩ Выс Есмя Естъ Есть Нстъ Суть Сѫшти б б]ѧше бдуть бе беста беше беѣ би бивъша бимъ бимь бисте бихомъ бишѧ бодетъ бодѫтъ боуд боудет боудета боудете боудетъ боудеть боудеши боуди боудите боудоут боудоуть боудши боудѣте боудѣть боудѣтѣ боудꙋть буд буда буде будевѣ будем будемъ будет будета будете будетъ будеть будет҃ будеш будеши будешъ будешь буди будите будть буду будут будутъ будуть будущаго будущая будуще будущем будущемъ будущи будущии будущїи будь будьть будѣте будѧше буть бъ бъвъшю бъивъшемъ бъилъ бъистъ бъиті бъс҃ бъілъ бъістъ бъіті бъіхомъ бъіхъ бъішѩ бъіⷭ҇ бъїхъ бъїшѩ бы быв бывʼше бывʼшемъ бывʼши бывша бывшаго бывшагѡ бывшая бывше бывшее бывшемъ бывшею бывшеє бывшеѥ бывши бывшии бывшим бывшимъ бывших бывшоу бывшю бывшюю бывшѹ бывшꙋ бывшꙋю бывъ бывъша бывъшаа͑го бывъше бывъшеи бывъшемъ бывъшеѥ бывъшеѥ͗ бывъши бывъшиихъ бывъшиї бывъшиїмъ бывъшоу бывъшю бывъшѫ бывъшѫѭ҄ бывъшѹ бывыи бывь бывь͗шемъ бывьї быв꙽шаго быв꙽шаѧ быв꙽шее быв꙽шихъ быв꙽шѹ был была были было былъ былы былѡ был҃о был꙽ быс быс̂ быст быстʼ быста бысте быстъ бысть бысь быс҃ быт быти быть бых быхом быхомъ быхъ быхъмъ быхѡм бых҇ быша быше бышⱕ бы҃ бы҃с бь бьівьшоу бьіс꙯ бьіти бяхуть бяше бяшетъ бі бімъ бімь бішѩ бї бѢ бѢʼхѫ бѢа͑хѫ бѢа͑ше бѢхомъ бѣ бѣaхо бѣaхѫ бѣaше бѣaшете бѣaшѧ бѣʼ бѣʼше бѣа͑ста бѣа͑хѫ бѣа͑ше бѣаа҅ше бѣаста бѣахѫ бѣахѹть бѣахꙋ бѣаша бѣаше бѣашете бѣа҅ста бѣа҅хѫ бѣа҅ше бѣстa бѣста бѣсте бѣх бѣхомʼ бѣхомъ бѣхоу бѣхъ бѣхѫ бѣхѹ бѣхⸯ бѣхꙋ бѣша бѣше бѣшѧ бѣшѩ бѣшѫ бѣшⱕ бѣшꙙ бѣяху бѣѣхѫ бѣѣше бѣѣ҅ше бѣѣ҆ше бѣѧше бѣꙿста бѣꙿхѫ бѧaхѹ бѧста бѧх бѧхȣть бѧховѣ бѧхом бѧхомъ бѧхоу бѧху бѧхуть бѧхъ бѧхѹ бѧхѹть бѧхꙋ бѧша бѧше бѧшеть бѧш҃ бѫ бѫде бѫдевѣ бѫдемъ бѫдет бѫдет[ъ бѫдетa бѫдета бѫдете бѫдетъ бѫдеть бѫдетꙿ бѫдеши бѫдеші бѫди бѫді бѫдѣмъ бѫдѣмь҆ бѫдѣте бѫдѫ бѫдѫтʼ бѫдѫтъ бѫдѫть бѫдѫштаа͑го бѫдѫштааго бѫдѫштее бѫдѫштеѥ бѫдѫштеѥ҆ бѫдѫштии҅мъ бѫдѫштии҅хъ бѫдѫщии бѫтъ бѹд бѹде бѹдевѣ бѹдем бѹдет бѹдете бѹдетъ бѹдеть бѹдеш]и бѹдеши бѹдешї бѹди бѹдть бѹдщемъ бѹдь бѹдьше бѹдѣмъ бѹдѣтъ бѹдѧше бѹдѹ бѹдѹт бѹдѹтъ бѹдѹть бѹдѹщаго бѹдѹщаѧ бѹдѹщемъ бѹдѹщии бѹдѹщиї бѹдѹщю бѹдꙋт бѹдꙋть бѹдꙋщаго бѹдꙋщаѧ бѹдꙋщее бѹдꙋщем бѹдꙋщим бѹдꙋщих бѹдꙗше бѹт б҃ъіⷭ҇ б҃ы бꙋд[е бꙋде бꙋдемъ бꙋдет бꙋдетъ бꙋдеть бꙋдеш бꙋдеши бꙋди бꙋдоущем бꙋдь бꙋдѣт бꙋдѧше бꙋдꙋт бꙋдꙋтъ бꙋдꙋщи бꙑ бꙑвша бꙑвше бꙑвшеи бꙑвшемъ бꙑвшемь бꙑвши бꙑвшоу бꙑвшоуо̑умоу бꙑвшю бꙑвшꙙ бꙑвъ бꙑвъи҆ бꙑвъшaa бꙑвъшaaго бꙑвъшaго бꙑвъшaего бꙑвъшaмъ бꙑвъша бꙑвъшаа бꙑвъшааго бꙑвъшаа҅го бꙑвъшаго бꙑвъшамъ бꙑвъшаꙗ бꙑвъшаꙗ҆ бꙑвъшаꙿ бꙑвъше бꙑвъшее бꙑвъшеи бꙑвъшема бꙑвъшемъ бꙑвъшеі бꙑвъшеѥ бꙑвъшеѥ҅ бꙑвъшеѥ҆ бꙑвъши бꙑвъшии бꙑвъшиихъ бꙑвъшии҅ бꙑвъшии҅мъ бꙑвъшии҅хъ бꙑвъшии҆ бꙑвъшимъ бꙑвъшихъ бꙑвъшиімъ бꙑвъшиімь бꙑвъшиї бꙑвъшиїхъ бꙑвъшоу бꙑвъшоуо҄умоу бꙑвъшъ бꙑвъшь҆и бꙑвъшю бꙑвъшюмоу бꙑвъшіи бꙑвъшіімъ бꙑвъшѧ бꙑвъшѧѩ бꙑвъшѫѭ бꙑвъшѫѭ̑ бꙑвъшꙋ бꙑвъшꙙ бꙑвь͗шемъ бꙑвьшаꙗ҆ бꙑвьшѧ бꙑвь҆шее҅ бꙑвь҆ши бꙑвⸯшемь бꙑвꙑи бꙑвꙑи҆ бꙑвꙑшии҅хъ бꙑвꙿ бꙑвꙿша бꙑвꙿшаа͑го бꙑвꙿшааго бꙑвꙿшии҅хъ бꙑвꙿшоу бꙑвꙿшѫ бꙑлa бꙑла бꙑле бꙑли бꙑло бꙑлъ бꙑлꙑ бꙑс бꙑс̂ бꙑст бꙑста бꙑсте бꙑстъ бꙑсть бꙑстꙿ бꙑс҃ бꙑти бꙑтъ бꙑті бꙑтї бꙑт҃ бꙑхо бꙑховѣ бꙑхом бꙑхомъ бꙑхом҃ бꙑхомꙑ бꙑхъ бꙑхь бꙑшa бꙑша бꙑше бꙑшѧ бꙑшѩ бꙑшꙙ бꙑⷭ҇ бꙑⷮ бꙗаше бꙗше е е[с]и е]смь еc е͑свѣ еестъ емь ес есвѣ есвҍ есемо еси есме есми есмо есмъ есмы есмь есмя есмѧ есмꙑ ест ест-ъ естa еста есте естъ есть естя есьмъ есьмь есі есітъ есї ес҃ ес꙽мы ес꙽мь етсь е҃ е҅ е҅си е҅смъ е҅ста е҅стъ и нѣсте сȣща си смъ соут соуть соуща соущаа соущаѧ соуще соущи соущим соущимъ соущоу соущь соущю соущї соущїи соущꙋ стъ сут сутъ суть суща сущаго сущая суще сущее сущеи сущемъ сущи сущие сущии сущим сущими сущимъ сущих сущихъ сущу сущую сущю сущюю съи҆ съштоу сы сыи сыи͗ сі сѫ сѫ- тъ сѫ.....тъ сѫи сѫт сѫтъ сѫтъ҆ сѫть сѫтꙿ сѫштa сѫштaa сѫшта сѫштаа сѫштааго сѫштамъ сѫштая сѫштаꙗ сѫште сѫштее сѫштеи сѫштеи҆ сѫштемʼ сѫштема сѫштемъ сѫштемь͗ сѫштеі сѫштеѥ сѫштеѭ сѫштеꙇ сѫшти сѫштии сѫштиими сѫштиимъ сѫштиихъ сѫштии҅ сѫштии҅ми сѫштии҅мъ сѫштии҅хъ сѫштии҆ сѫштимъ сѫштиімъ сѫштиіхъ сѫштиї сѫштиїми сѫштиїмъ сѫштиїхъ сѫштиꙗ҅ сѫштоу сѫштоуо̑умоу сѫштоуꙋмоу сѫштъ сѫштъштъ сѫшть сѫшть҆и҆ сѫштю сѫштіимъ сѫштімъ сѫштѧ сѫштѧѩ сѫштѫ сѫштѫѭ сѫштѫѭ̑ сѫштⱕ сѫштⱕѧ сѫштꙋ сѫштꙙ сѫштꙙѧ сѫштꙙѧ҆ сѫща сѫще сѫщеи сѫщи сѫщимъ сѫщоу сѫщтихъ сѫщю сѫщіимъ сѫщіихъ сѫщѧѩ сѫщѫ сѫщѹ сѹт сѹть сѹт҃ сѹщa сѹщaa сѹщȣ сѹща сѹщааго сѹщаго сѹщаѧ сѹщаꙗ сѹще сѹщее сѹщеи сѹщемa сѹщема сѹщемъ сѹщи сѹщии сѹщиими сѹщиимъ сѹщиихъ сѹщимъ сѹщих сѹщь сѹщю сѹщюѹмѹ сѹщѹ сѹщꙋ сѹщꙋю сꙋт сꙋть сꙋща сꙋще сꙋщеи сꙋщи сꙋщими сꙋщимъ сꙋщоу сꙋщѹ сꙋщꙋ сꙑ сꙑи сꙑи҆ сꙙи сꙙі сꙛщꙋ ще щю є єс єсмы єсмь єсмѧ єсте єсть єс҃ ѥ ѥ͑сʼмъ ѥ͑свѣ ѥ͑си ѥ͑смъ ѥ͑ст ѥ͑ста ѥ͑сте ѥ͑стъ ѥ͑сть ѥси ѥсм ѥсме ѥсми ѥсмъ ѥсмы ѥсмь ѥсмⸯ ѥсмꙑ ѥстa ѥста ѥсте ѥстъ ѥсть ѥсьмы ѥс҇ ѥ҅ ѥ҅свѣ ѥ҅си ѥ҅смъ ѥ҅смь҆ ѥ҅ста ѥ҅сте ѥ҅стъ ѥ҅стъ҆ ѥ҅сть ѥ҅сть҆ ѥ҅стꙿ ѥ҅сі ѥ҆ ѥ҆стъ
""".split()
)
|
#!/usr/bin/env python3
SQL92_reserved = [
"ABSOLUTE", "ACTION", "ADD", "ALL", "ALLOCATE", "ALTER", "AND", "ANY", "ARE", "AS", "ASC", "ASSERTION", "AT", "AUTHORIZATION", "AVG",
"BEGIN", "BETWEEN", "BIT", "BIT_LENGTH", "BOTH", "BY",
"CASCADE", "CASCADED", "CASE", "CAST", "CATALOG", "CHAR", "CHARACTER", "CHAR_LENGTH", "CHARACTER_LENGTH", "CHECK", "CLOSE", "COALESCE", "COLLATE", "COLLATION", "COLUMN", "COMMIT", "CONNECT", "CONNECTION", "CONSTRAINT", "CONSTRAINTS", "CONTINUE", "CONVERT", "CORRESPONDING", "COUNT", "CREATE", "CROSS", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR",
"DATE", "DAY", "DEALLOCATE", "DEC", "DECIMAL", "DECLARE", "DEFAULT", "DEFERRABLE", "DEFERRED", "DELETE", "DESC", "DESCRIBE", "DESCRIPTOR", "DIAGNOSTICS", "DISCONNECT", "DISTINCT", "DOMAIN", "DOUBLE", "DROP",
"ELSE", "END", "END-EXEC", "ESCAPE", "EXCEPT", "EXCEPTION", "EXEC", "EXECUTE", "EXISTS", "EXTERNAL", "EXTRACT",
"FALSE", "FETCH", "FIRST", "FLOAT", "FOR", "FOREIGN", "FOUND", "FROM", "FULL",
"GET", "GLOBAL", "GO", "GOTO", "GRANT", "GROUP",
"HAVING", "HOUR",
"IDENTITY", "IMMEDIATE", "IN", "INDICATOR", "INITIALLY", "INNER", "INPUT", "INSENSITIVE", "INSERT", "INT", "INTEGER", "INTERSECT", "INTERVAL", "INTO", "IS", "ISOLATION",
"JOIN",
"KEY",
"LANGUAGE", "LAST", "LEADING", "LEFT", "LEVEL", "LIKE", "LOCAL", "LOWER",
"MATCH", "MAX", "MIN", "MINUTE", "MODULE", "MONTH",
"NAMES", "NATIONAL", "NATURAL", "NCHAR", "NEXT", "NO", "NOT", "NULL", "NULLIF", "NUMERIC",
"OCTET_LENGTH", "OF", "ON", "ONLY", "OPEN", "OPTION", "OR", "ORDER", "OUTER", "OUTPUT", "OVERLAPS",
"PAD", "PARTIAL", "POSITION", "PRECISION", "PREPARE", "PRESERVE", "PRIMARY", "PRIOR", "PRIVILEGES",
"PROCEDURE", "PUBLIC",
"READ", "REAL", "REFERENCES", "RELATIVE", "RESTRICT", "REVOKE", "RIGHT", "ROLLBACK", "ROWS",
"SCHEMA", "SCROLL", "SECOND", "SECTION", "SELECT", "SESSION", "SESSION_USER", "SET", "SIZE", "SMALLINT", "SOME", "SPACE", "SQL", "SQLCODE", "SQLERROR", "SQLSTATE", "SUBSTRING", "SUM", "SYSTEM_USER",
"TABLE", "TEMPORARY", "THEN", "TIME", "TIMESTAMP", "TIMEZONE_HOUR", "TIMEZONE_MINUTE", "TO", "TRAILING", "TRANSACTION", "TRANSLATE", "TRANSLATION", "TRIM", "TRUE",
"UNION", "UNIQUE", "UNKNOWN",
"UPDATE", "UPPER", "USAGE", "USER", "USING",
"VALUE", "VALUES", "VARCHAR", "VARYING", "VIEW",
"WHEN", "WHENEVER", "WHERE", "WITH", "WORK", "WRITE",
"YEAR",
"ZONE",
]
SQL92_non_reserved = [
"ADA",
"C", "CATALOG_NAME", "CHARACTER_SET_CATALOG", "CHARACTER_SET_NAME", "CHARACTER_SET_SCHEMA", "CLASS_ORIGIN", "COBOL", "COLLATION_CATALOG", "COLLATION_NAME", "COLLATION_SCHEMA", "COLUMN_NAME", "COMMAND_FUNCTION", "COMMITTED", "CONDITION_NUMBER", "CONNECTION_NAME", "CONSTRAINT_CATALOG", "CONSTRAINT_NAME", "CONSTRAINT_SCHEMA", "CURSOR_NAME",
"DATA", "DATETIME_INTERVAL_CODE", "DATETIME_INTERVAL_PRECISION", "DYNAMIC_FUNCTION",
"FORTRAN", "LENGTH",
"MESSAGE_LENGTH", "MESSAGE_OCTET_LENGTH", "MESSAGE_TEXT", "MORE", "MUMPS",
"NAME", "NULLABLE", "NUMBER",
"PASCAL", "PLI",
"REPEATABLE", "RETURNED_LENGTH", "RETURNED_OCTET_LENGTH", "RETURNED_SQLSTATE", "ROW_COUNT",
"SCALE", "SCHEMA_NAME", "SERIALIZABLE", "SERVER_NAME", "SUBCLASS_ORIGIN",
"TABLE_NAME", "TYPE",
"UNCOMMITTED", "UNNAMED",
]
if __name__ == '__main__':
print("\t // Reserved Keyword")
for k in SQL92_reserved:
print("\t KEYWORD_{}_TOKEN = \"{}\"".format(k.replace('-', '_'), k))
print("\n")
print("\t // Non Reserved Keyword\n")
for k in SQL92_non_reserved:
print("\t KEYWORD_{}_TOKEN = \"{}\"".format(k.replace('-', '_'), k))
print("\n")
print("---------")
print("\n")
for k in SQL92_reserved:
print("\t \"{}\": KEYWORD_{}_TOKEN,".format(k, k.replace('-', '_')))
print("\n")
print("---------")
print("\n")
for k in SQL92_non_reserved:
print("\t \"{}\": KEYWORD_{}_TOKEN,".format(k, k.replace('-', '_')))
print()
print("\n")
print("---------")
print("\n")
for k in SQL92_reserved:
print("{{\"{}\", token.KEYWORD_{}_TOKEN, \"{}\"}}, ".format(k, k.replace('-', '_'), k))
for k in SQL92_non_reserved:
print("{{\"{}\", token.KEYWORD_{}_TOKEN, \"{}\"}}, ".format(k, k.replace('-', '_'), k))
print()
|
def can_build(env, platform):
return True
def configure(env):
pass
def is_enabled():
# Disabled by default being experimental at the moment.
# Enable manually with `module_gdscript_transpiler_enabled=yes` option.
return False
|
# @Title: 递增的三元子序列 (Increasing Triplet Subsequence)
# @Author: KivenC
# @Date: 2019-03-15 16:56:39
# @Runtime: 84 ms
# @Memory: 13.5 MB
class Solution:
def increasingTriplet(self, nums: List[int]) -> bool:
if len(nums) < 3:
return False
i, j = float('inf'), float('inf')
for num in nums:
if num <= i:
i = num
elif num <= j:
j = num
else:
return True
return False
|
class PERIOD:
DAILY = "daily"
WEEKLY = "weekly"
MONTHLY = "monthly"
# Converting BYTES to KB, MB, GB
BYTES_TO_KBYTES = 1024
BYTES_TO_MBYTES = 1048576
BYTES_TO_GBYTES = 1073741824
|
"""
Job initialization.
"""
class Job():
"""
Performs general statistics over the crowdsourcing jobs.
"""
@staticmethod
def aggregate(units, judgments, config):
"""
Aggregates information about the total number of units, total number of judgments,
total number of workers that provided annotations and the total duration of the job.
Args:
units: Units contained in the job.
judgments: Judgments contained in the job.
config: Job configuration as provided as input for the metrics.
Returns:
A dataframe of one row that stores general stats on the crowdsourcing jobs.
"""
agg = {
'unit' : 'nunique',
'judgment' : 'nunique',
'worker' : 'nunique',
'duration' : 'mean'
}
job = judgments.groupby('job').agg(agg)
# compute job runtime
runtime = (max(judgments['submitted']) - min(judgments['started']))
job['runtime'] = runtime #float(runtime.days) * 24 + float(runtime.seconds) / 3600
job['runtime.per_unit'] = job['runtime'] / job['unit']
job['judgments.per.worker'] = job['judgment'] / job['worker']
metrics = ['unique_annotations', 'annotations']
for metric in metrics:
for col in config.output.values():
# aggregate unit metrics
job[col+'.'+metric] = units[col+'.'+metric].mean()
job = job.reindex(sorted(job.columns), axis=1)
return job
|
class MyClass:
'''This is the docstring for this class'''
def __init__(self):
# setup per-instance variables
self.x = 1
self.y = 2
self.z = 3
class MySecondClass:
'''This is the docstring for this second class'''
def __init__(self):
# setup per-instance variables
self.p = 1
self.d = 2
self.q = 3
|
# coding: utf8
class InvalidUnitToDXAException(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class Unit(object):
@classmethod
def to_dxa(cls, val):
if len(val) < 2:
return 0
else:
unit = val[-2:]
val = int(val.rstrip(unit))
if val == 0:
return 0
if unit == 'cm':
return cls.cm_to_dxa(val)
elif unit == 'in':
return cls.in_to_dxa(val)
elif unit == 'pt':
return cls.pt_to_dxa(val)
else:
raise InvalidUnitToDXAException("Unit to DXA should be " +
"Centimeters(cm), " +
"Inches(in) or " +
"Points(pt)")
@classmethod
def pixel_to_emu(cls, pixel):
return int(round(pixel * 12700))
@classmethod
def cm_to_dxa(cls, centimeters):
inches = centimeters / 2.54
points = inches * 72
dxa = points * 20
return dxa
@classmethod
def in_to_dxa(cls, inches):
points = inches * 72
dxa = cls.pt_to_dxa(points)
return dxa
@classmethod
def pt_to_dxa(cls, points):
dxa = points * 20
return dxa
|
input = """
c num blocks = 1
c num vars = 150
c minblockids[0] = 1
c maxblockids[0] = 150
p cnf 150 617
90 -20 8 0
-111 -68 -13 0
8 -150 -9 0
-66 63 -93 0
-135 40 81 0
106 -127 134 0
-54 123 45 0
24 -77 59 0
-82 48 71 0
12 75 87 0
127 -29 88 0
-120 -33 60 0
-126 -102 31 0
134 9 -150 0
62 -56 -83 0
92 27 75 0
-133 -52 50 0
-20 97 -13 0
65 55 -17 0
74 -77 -123 0
-11 -125 -98 0
-67 -35 -114 0
134 3 51 0
-113 132 101 0
94 -8 52 0
66 -1 -17 0
40 -21 -55 0
144 -125 -117 0
-28 43 -147 0
76 58 12 0
-2 27 103 0
58 125 7 0
-8 74 -15 0
-123 -46 108 0
98 -112 -92 0
-102 -31 -99 0
-3 116 38 0
-104 11 127 0
63 26 72 0
-97 96 -31 0
-136 132 -85 0
-23 32 -29 0
131 39 -75 0
68 -132 -110 0
-133 93 -28 0
41 32 -142 0
-1 81 -21 0
-59 131 12 0
115 -29 62 0
-117 40 73 0
10 -79 -75 0
-81 -8 117 0
130 -136 -21 0
-133 10 -112 0
29 -57 119 0
-130 112 97 0
37 71 69 0
28 -49 -88 0
-123 86 84 0
135 33 111 0
100 48 17 0
137 -47 -66 0
111 96 -93 0
-141 104 -19 0
-31 65 3 0
101 -3 -91 0
55 -123 -36 0
-90 -95 116 0
-79 137 -107 0
-25 68 -105 0
-66 -42 143 0
42 148 60 0
-31 80 -28 0
-10 -5 -126 0
-45 48 23 0
130 -36 96 0
100 65 -47 0
118 -75 18 0
111 -72 -135 0
143 7 -32 0
-45 83 -95 0
-52 -59 71 0
90 -139 -8 0
114 -95 -38 0
75 -12 116 0
26 15 79 0
-51 -50 -27 0
132 13 -147 0
-17 94 -76 0
106 79 121 0
-5 -43 117 0
53 118 51 0
-128 111 -146 0
45 53 77 0
-75 10 60 0
-10 100 99 0
51 -50 150 0
37 121 -127 0
-131 130 141 0
-75 -123 38 0
-76 -64 112 0
124 -144 138 0
-87 -51 -21 0
-36 -138 -12 0
63 -97 -130 0
-23 64 14 0
22 -143 -71 0
-28 -40 97 0
-35 -50 -22 0
-101 -24 -103 0
-125 -103 -6 0
-35 -16 -124 0
71 42 -48 0
6 11 -148 0
56 -101 -117 0
79 80 -113 0
-144 12 100 0
-99 114 -94 0
-82 -99 22 0
122 -86 137 0
-44 -7 -55 0
110 -120 23 0
-91 -54 131 0
108 -53 -110 0
97 62 -133 0
-37 69 -86 0
-111 68 66 0
-6 -12 -37 0
-136 60 40 0
24 -49 9 0
-64 125 -135 0
-108 -140 113 0
-139 -124 -90 0
24 -63 100 0
-138 -134 63 0
139 -21 -91 0
-53 132 59 0
57 54 -17 0
108 98 124 0
-105 -103 -68 0
-3 -24 84 0
-81 9 150 0
-65 52 -7 0
-123 91 -14 0
133 2 -66 0
-30 -103 -118 0
-136 26 131 0
-29 88 -111 0
148 -110 -41 0
20 10 -83 0
-129 77 -69 0
-65 -99 113 0
-117 107 -64 0
-9 -18 -94 0
23 48 -121 0
24 -145 108 0
65 30 -54 0
53 -87 108 0
-36 13 -76 0
-70 -130 -8 0
-66 -40 -65 0
30 -132 -124 0
-148 -114 -17 0
-116 -105 92 0
97 -14 -60 0
-83 50 -54 0
142 -140 105 0
-28 -142 -137 0
-92 -6 -72 0
109 -121 66 0
-138 -19 93 0
-86 41 46 0
-86 -121 -110 0
79 -85 -143 0
119 -104 -149 0
-139 -121 -42 0
-85 14 -4 0
42 121 -57 0
-5 -140 109 0
56 134 -37 0
-45 140 -73 0
-129 -42 64 0
9 -67 -41 0
127 -50 -46 0
-99 -33 119 0
28 131 -106 0
30 79 48 0
-35 -101 30 0
88 -101 -133 0
-70 -141 -146 0
55 148 -4 0
-63 50 -49 0
-141 105 112 0
72 119 -37 0
127 -75 134 0
49 83 -68 0
30 -51 64 0
125 -37 123 0
26 -60 99 0
82 63 44 0
-120 -75 107 0
18 145 -118 0
-140 5 14 0
-60 -119 132 0
85 29 -79 0
-3 -46 -104 0
-31 42 41 0
131 -51 -96 0
-71 -61 81 0
-55 39 -120 0
67 -73 -58 0
20 -72 -45 0
-122 42 40 0
26 -97 96 0
53 -83 -76 0
53 -100 85 0
-11 67 -26 0
-46 106 30 0
13 -6 -94 0
12 -32 -71 0
-31 33 117 0
104 29 -139 0
85 91 47 0
-90 122 147 0
95 -100 67 0
-50 142 75 0
-95 -83 -97 0
70 -22 -53 0
80 -81 118 0
-147 -28 62 0
52 -143 -54 0
-12 28 -128 0
129 -142 -123 0
-51 42 -113 0
63 121 39 0
45 -17 -1 0
76 22 104 0
-22 114 -127 0
2 86 -6 0
32 -148 59 0
106 -88 102 0
-139 58 137 0
17 38 -78 0
-106 -18 112 0
40 -93 -75 0
-12 121 58 0
-13 83 6 0
-13 -139 -88 0
-72 1 59 0
105 -140 49 0
111 40 -119 0
-105 -121 104 0
-144 -68 53 0
135 122 -106 0
-56 117 98 0
-31 -39 -122 0
-117 -130 -41 0
-150 -86 -3 0
-126 -149 93 0
-40 -29 54 0
32 -10 -2 0
-14 50 139 0
-121 -89 -32 0
-125 90 55 0
60 -107 52 0
66 12 127 0
-115 69 105 0
96 -41 61 0
-79 41 134 0
58 -108 -93 0
-26 -119 57 0
-139 -53 -113 0
-86 142 54 0
99 133 -97 0
82 145 -139 0
-134 -2 -95 0
-12 120 136 0
50 -141 49 0
-16 81 -70 0
-148 149 -12 0
-17 119 128 0
35 115 -58 0
123 4 134 0
123 -34 -109 0
-124 5 -2 0
98 118 -70 0
87 105 -135 0
140 -93 17 0
-102 74 119 0
-32 -20 -48 0
80 -77 134 0
-68 42 -143 0
-66 -73 -109 0
-126 97 -38 0
82 -60 -117 0
112 -88 -106 0
-11 -123 124 0
-84 -106 87 0
-57 118 -102 0
-84 43 61 0
-134 22 -12 0
45 -86 111 0
-37 -10 -124 0
27 -123 70 0
77 38 132 0
-70 37 -12 0
44 -53 -127 0
-139 -6 49 0
-69 -58 90 0
19 68 -112 0
-56 -52 118 0
70 62 147 0
2 -75 -35 0
89 59 -80 0
-13 30 122 0
138 23 28 0
125 35 -14 0
98 -52 18 0
85 -109 -55 0
-98 -112 -33 0
51 -129 35 0
-119 27 148 0
-33 122 104 0
54 -34 -11 0
-15 16 -97 0
75 56 13 0
-35 -126 -120 0
114 -83 -78 0
-36 69 -58 0
-85 125 -89 0
35 -115 133 0
22 -134 67 0
129 6 57 0
-142 -30 98 0
40 -82 21 0
62 53 -101 0
-91 -47 -135 0
84 -58 -50 0
26 19 150 0
-22 -27 -54 0
49 -18 61 0
-146 -35 -46 0
-35 40 -86 0
-110 73 -29 0
-104 112 -149 0
73 -61 90 0
48 -135 -130 0
78 -100 93 0
94 -53 137 0
37 -5 68 0
133 78 -105 0
-71 115 26 0
59 115 -38 0
-148 -40 -23 0
30 -46 109 0
-100 117 -16 0
81 102 -94 0
141 50 -35 0
143 -1 -26 0
-125 10 50 0
58 2 -28 0
128 19 -12 0
-60 121 129 0
53 82 -22 0
-9 -131 -128 0
-42 -88 55 0
-43 70 93 0
-87 15 32 0
143 -93 33 0
-39 -3 -47 0
19 -38 125 0
136 -18 57 0
144 -95 -84 0
-125 -137 -117 0
83 -95 148 0
117 -118 51 0
25 77 -53 0
-8 125 -142 0
-88 -81 -27 0
-98 75 20 0
125 -82 -68 0
133 76 87 0
6 -94 148 0
-110 39 -56 0
-20 11 -122 0
72 -137 118 0
120 -57 -144 0
57 72 -89 0
-82 32 -95 0
136 34 -110 0
-125 110 59 0
-5 -41 -31 0
139 -86 -31 0
49 -12 -84 0
-93 -119 -110 0
-11 -73 20 0
-72 -8 118 0
99 87 114 0
92 -135 121 0
-76 -82 -93 0
119 -116 5 0
82 -106 37 0
-76 84 -136 0
-74 -2 12 0
-45 -60 137 0
114 45 -119 0
-98 76 -79 0
41 -22 -79 0
53 136 112 0
46 -39 127 0
-88 20 2 0
128 -55 64 0
-110 74 -5 0
-64 -137 118 0
45 102 -110 0
57 118 110 0
66 -90 118 0
55 -142 -81 0
57 -108 -93 0
13 -116 54 0
3 -61 10 0
109 113 -147 0
125 24 -91 0
53 107 147 0
6 79 -118 0
23 111 -122 0
-34 -9 -94 0
-15 4 -29 0
-109 32 -35 0
61 30 62 0
-122 -30 92 0
-118 -46 -20 0
23 -37 108 0
-95 6 -57 0
-149 -135 86 0
27 133 -42 0
-81 87 -97 0
102 -51 -107 0
-45 -61 20 0
128 2 46 0
-33 -35 24 0
-133 -54 28 0
-114 -62 53 0
-79 133 22 0
33 -40 -35 0
-13 -111 138 0
-124 21 88 0
84 -50 115 0
30 -3 146 0
21 61 40 0
-74 45 -1 0
-88 74 -121 0
111 44 14 0
77 7 101 0
-68 62 40 0
50 26 -84 0
-72 -55 74 0
92 136 -67 0
-86 -47 -14 0
65 -97 49 0
150 7 -75 0
114 66 85 0
143 106 63 0
-112 89 -3 0
53 7 -2 0
-71 24 -117 0
28 128 85 0
5 89 -56 0
-115 46 -37 0
23 -124 -59 0
83 -39 43 0
-9 -118 145 0
-145 120 -39 0
132 -3 -144 0
-17 -64 -44 0
-128 39 28 0
-142 21 8 0
-20 85 11 0
92 -105 115 0
-77 -104 28 0
15 -102 149 0
-52 82 -22 0
-25 -80 65 0
66 144 71 0
-2 -112 140 0
-105 22 -92 0
-4 -112 -150 0
97 -3 -74 0
-64 80 16 0
118 49 -93 0
-100 -98 -67 0
7 122 46 0
-66 6 -105 0
18 11 -110 0
121 -128 -6 0
129 -12 69 0
110 114 66 0
-120 91 61 0
-108 -118 -31 0
-65 -83 145 0
-74 -79 101 0
49 -75 -133 0
-42 86 -34 0
20 111 -16 0
-125 135 63 0
59 -139 110 0
-74 57 73 0
45 -137 39 0
-15 -132 -28 0
145 105 -88 0
135 22 98 0
-52 -148 -36 0
-143 -102 -121 0
-10 33 139 0
23 69 116 0
-106 -12 11 0
25 -97 105 0
-65 25 43 0
70 72 -40 0
21 81 65 0
43 78 -27 0
132 -32 -135 0
-42 -134 60 0
-30 -17 62 0
127 -122 5 0
-101 140 -132 0
-110 114 19 0
62 83 -108 0
-144 85 16 0
17 -79 -88 0
-42 109 -114 0
108 -86 59 0
79 -62 20 0
56 99 -86 0
142 82 -4 0
-132 128 115 0
107 -6 -7 0
92 -81 -28 0
77 -51 6 0
3 -6 111 0
-129 -62 -52 0
-116 -75 99 0
146 -134 34 0
135 -46 132 0
67 44 8 0
-68 149 119 0
140 111 61 0
71 102 128 0
115 88 50 0
27 53 -58 0
-25 -24 150 0
15 116 -82 0
7 -141 -109 0
-65 -70 -54 0
-2 -36 66 0
133 148 -138 0
96 -116 -64 0
-58 -19 -90 0
49 -77 120 0
10 -58 -101 0
-114 134 -94 0
87 -49 32 0
-25 -74 -91 0
-36 -80 63 0
93 -105 77 0
-53 137 76 0
27 -76 -22 0
-58 -35 -17 0
139 72 15 0
-117 8 -104 0
-132 -114 139 0
32 -9 -72 0
108 -51 115 0
94 -86 128 0
-72 -126 -121 0
144 -95 -4 0
-58 15 -115 0
20 110 -31 0
-145 -110 -49 0
-70 -67 -56 0
33 -52 94 0
-104 -112 -43 0
16 32 29 0
-21 -18 -41 0
45 119 -129 0
-143 -107 -101 0
-42 -20 116 0
134 39 -104 0
148 -34 46 0
112 -96 74 0
96 69 32 0
52 150 87 0
-82 -85 19 0
-42 -40 24 0
26 -22 -123 0
87 45 130 0
49 94 -149 0
144 -40 -61 0
-120 -105 -71 0
-144 -35 16 0
-49 73 -53 0
113 139 20 0
81 -55 61 0
-103 147 -35 0
145 17 33 0
79 -69 150 0
-60 -39 -134 0
43 -114 109 0
-148 5 62 0
-75 -55 128 0
1 -108 -141 0
43 13 -104 0
-17 60 -55 0
128 -127 -53 0
-13 128 121 0
117 -137 -80 0
22 -110 14 0
"""
output = "SAT"
|
def count(word, letter):
count = 0
for i in word:
if i == letter:
count = count + 1
return count
word = input('Enter a word:')
letter = input('Enter a letter to count in word:')
print("There are {} {}'s in your word".format(count(word,letter), letter))
|
class Square:
def __init__(self, side):
self.side = side
def perimeter(self):
return self.side * 4
def area(self):
return self.side ** 2
pass
class Rectangle:
def __init__(self, width, height):
self.width, self.height = width, height
def perimeter(self):
return self.width * 2 + self.height * 2
def area(self):
return self.width * self.height
q = Square(5)
print(q.perimeter())
print(q.area())
r = Rectangle(5, 10)
print(r.perimeter(), r.area())
|
def first_function(values):
''' (list of int) -> NoneType
'''
for i in range(len(values)):
if values[i] % 2 == 1:
values[i] += 1
def second_function(value):
''' (int) -> int
'''
if value % 2 == 1:
value += 1
return value
def snippet_1():
a = [1, 2, 3]
b = 1
first_function(a)
second_function(b)
print(a)
print(b)
# output: (2 MARKS)
# [2, 2, 4]
# 1
# why? second_function(1) will not return 2 if we don't print it.
def snippet_2():
a = [1, 2, 3]
b = 1
print(first_function(a))
print(second_function(b))
# output: (2 MARKS)
# None
# 2
|
# -*- coding: utf-8 -*-
vagrant = 'vagrant'
def up():
return '{} up'.format(vagrant)
def ssh():
return '{} ssh'.format(vagrant)
def suspend():
return '{} suspend'.format(vagrant)
def status():
return '{} status'.format(vagrant)
def halt():
return '{} halt'.format(vagrant)
def destroy(force=False):
options = ''
if force:
options += '--force'
return '{} destroy {}'.format(vagrant, options)
def share(**kwargs):
options = ''
name = kwargs.get('name')
if name:
options += '--name {}'.format(name)
if options != '':
options = ' ' + options
return '{} share{}'.format(vagrant, options)
|
def split_block (string:str, seps:(str, str)) -> str:
_, content = string.split (seps[0])
block, _ = content.split (seps[1])
return block
def is_not_empty (value):
return value != ''
def contens_colons (value:str) -> bool:
return value.count(":") == 0
content = ""
with open ("examples/add.asm") as f:
content = f.read()
code, data = [*map (lambda x: split_block (content, x), [(".code", ".endcode"), (".data", ".enddata")])]
code = [*filter (is_not_empty, code.split ('\n'))]
data = [*filter (is_not_empty, data.split ('\n'))]
print (code)
print (data)
instructions = [*filter (contens_colons, code)]
markings = [*filter (lambda x: not contens_colons (x), code)]
there_is_instruction = [*map ( lambda x: len (x.split (":")[1].replace (" ", "")) != 0, markings)]
print (instructions)
print (markings)
print (there_is_instruction) |
class Solution:
def sumOfDistancesInTree(self, N, edges):
"""
:type N: int
:type edges: List[List[int]]
:rtype: List[int]
"""
graph = collections.defaultdict(list)
for u, v in edges:
graph[u].append(v)
graph[v].append(u)
sums = [0] * N
counts = [1] * N
def dfs1(curr, prev, graph, sums, counts):
for next in graph[curr]:
if next != prev:
dfs1(next, curr, graph, sums, counts)
sums[curr] += sums[next] + counts[next]
counts[curr] += counts[next]
def dfs2(curr, prev, graph, sums, counts):
for next in graph[curr]:
if next != prev:
sums[next] = sums[curr] - counts[next] + len(graph) - counts[next]
dfs2(next, curr, graph, sums, counts)
dfs1(0, -1, graph, sums, counts)
dfs2(0, -1, graph, sums, counts)
return sums
|
class Solution:
# @return an integer
def threeSumClosest(self, num, target):
num.sort()
res = sum(num[:3])
if res > target:
diff = res-target
elif res < target:
diff = target-res
else:
return res
n = len(num)
for i in xrange(n):
j, k = i+1, n-1
while j < k:
s = num[i]+num[j]+num[k]
if s > target:
n_diff = s-target
k -= 1
elif s < target:
n_diff = target-s
j += 1
else:
return s
if n_diff < diff:
res, diff = s, n_diff
return res
|
# -*- encoding:utf-8 -*-
"""Autogenerated file, do not edit. Submit translations on Transifex."""
MESSAGES = {
"%d min remaining to read": "%dminutas de lectura remanente",
"(active)": "(active)",
"Also available in:": "Anque disponibile in:",
"Archive": "Archivo",
"Atom feed": "Fluxo Atom",
"Authors": "Authores",
"Categories": "Categorias",
"Comments": "Commentos",
"LANGUAGE": "Interlingua",
"Languages:": "Linguas:",
"More posts about %s": "Plure entratas super %s",
"Newer posts": "Entratas plus recente",
"Next post": "Entrata successive",
"Next": "Successive",
"No posts found.": "Nulle entrata esseva trovate.",
"Nothing found.": "Nihil esseva trovate.",
"Older posts": "Entratas plus vetule",
"Original site": "Sito original",
"Posted:": "Publicate:",
"Posts about %s": "Entratas super %s",
"Posts by %s": "Entratas per %s",
"Posts for year %s": "Entratas del anno %s",
"Posts for {month_day_year}": "Entratas de {month_day_year}",
"Posts for {month_year}": "Entratas de {month_year}",
"Previous post": "Entrata precedente",
"Previous": "Precendente",
"Publication date": "Data de publication",
"RSS feed": "Fluxo RSS",
"Read in English": "Lege in interlingua",
"Read more": "Lege plus",
"Skip to main content": "Salta al contento principal",
"Source": "Sorgente",
"Subcategories:": "Subcategorias:",
"Tags and Categories": "Etiquettas e categorias",
"Tags": "Etiquettas",
"Toggle navigation": "Commuta navigation",
"Uncategorized": "Sin categoria",
"Up": "In alto",
"Updates": "Actualisationes",
"Write your page here.": "Scribe tu pagina hic.",
"Write your post here.": "Scribe tu entrata hic.",
"old posts, page %d": "Vetule entratas, pagina %d",
"page %d": "pagina %d",
"updated": "actualisate",
}
|
'''
Prompt:
Given two strings, s1 and s2, write code to check if s2 is a rotation of s1.
(e.g., "waterbottle" is a rotation of "erbottlewat").
Follow up:
What if you could use one call of a helper method isSubstring?
'''
# Time: O(n), Space: O(n)
def isStringRotation(s1, s2):
if len(s1) != len(s2):
return False
strLength = len(s1) or len(s2)
s1Prefix = []
s1Suffix = [c for c in s1]
s2Prefix = [c for c in s2]
s2Suffix = []
for idx in range(strLength):
if s1Suffix == s2Prefix and s1Prefix == s2Suffix:
return True
s1Prefix.append(s1Suffix.pop(0))
s2Suffix.insert(0, s2Prefix.pop())
return False
'''
Follow up:
Notice that if isStringRotation(s1, s2) == True
Let `p` be the prefix of the string and `s` the suffix.
Then s1 can be broken down into s1=`ps` and s2=`sp`
Therefore, notice that s1s1 = `psps`, so s2 must be a substring.
So: return isSubstring(s1+s1, s2)
'''
print(isStringRotation("waterbottle", "erbottlewat"))
print(isStringRotation("waterbottle", "erbottlewqt"))
print(isStringRotation("waterbottle", "eniottlewdt"))
print(isStringRotation("lucas", "sluca"))
print(isStringRotation("lucas", "wluca"))
|
# Instantiate Cache information
n = 10
cache = [None] * (n + 1)
def fib_dyn(n):
# Base Case
if n == 0 or n == 1:
return n
# Check cache
if cache[n] != None:
return cache[n]
# Keep setting cache
cache[n] = fib_dyn(n-1) + fib_dyn(n-2)
return cache[n]
fib_dyn(10) |
pessoa = {}
pessoas = []
soma = cont = 0
mulher = []
maior = []
while True:
pessoa['nome'] = str(input('Nome: '))
pessoa['sexo'] = str(input('Sexo: [M/F] '))[0].upper().strip()
if pessoa['sexo'] in 'F':
mulher.append(pessoa['nome'])
pessoa['idade'] = int(input('Idade: '))
soma += pessoa['idade']
cont += 1
pessoas.append(pessoa.copy())
r = str(input('Deseja continuar? [S/N] '))[0].upper().strip()
if r == 'N':
break
media = soma / cont
print(f'O número de pessoas cadastradas foram {len(pessoas)}')
print(f'A média das idades é de {media:.2f} anos!')
print(f'As mulheres são {mulher}')
for p in pessoas:
if p['idade'] > media:
maior.append(p['nome'])
print(f'As pessoas acima da média de idade são {maior}')
|
"""
The ``refstate`` module
=========================
Provides integral models for boundary layer computations
Available functions
-------------------
"""
class refstate:
def __init__(self, **kwargs):
self._dict = kwargs
#def Reynolds(self): |
# -*- coding: utf-8 -*-
# TODO: datetime support
###
### DO NOT CHANGE THIS FILE
###
### The code is auto generated, your change will be overwritten by
### code generating.
###
DefinitionsNewrun = {'required': ['name'], 'type': 'object', 'properties': {'count': {'type': 'boolean'}, 'prePro': {'type': 'boolean'}, 'fqRegex': {'type': 'string'}, 'star': {'type': 'boolean'}, 'name': {'type': 'string'}, 'fastqc': {'type': 'boolean'}, 'genomeInddex': {'type': 'string'}, 'gtfFile': {'type': 'string'}, 'rnaseqqc': {'type': 'boolean'}, 'fqDirs': {'type': 'string'}, 'sampleNames': {'type': 'string'}, 'fastaRef': {'type': 'string'}, 'extn': {'type': 'string'}, 'fqDir': {'type': 'string'}, 'makeIndices': {'type': 'boolean'}}}
DefinitionsRun = {'required': ['name'], 'type': 'object', 'properties': {'count': {'type': 'boolean'}, 'prePro': {'type': 'boolean'}, 'fqRegex': {'type': 'string'}, 'star': {'type': 'boolean'}, 'name': {'type': 'string'}, 'fastqc': {'type': 'boolean'}, 'genomeInddex': {'type': 'string'}, 'gtfFile': {'type': 'string'}, 'rnaseqqc': {'type': 'boolean'}, 'fqDirs': {'type': 'string'}, 'sampleNames': {'type': 'string'}, 'fastaRef': {'type': 'string'}, 'extn': {'type': 'string'}, 'fqDir': {'type': 'string'}, 'makeIndices': {'type': 'boolean'}}}
DefinitionsErrormodel = {'required': ['code', 'message'], 'type': 'object', 'properties': {'message': {'type': 'string'}, 'code': {'type': 'integer', 'format': 'int32'}}}
validators = {
('runs', 'POST'): {'json': DefinitionsNewrun},
}
filters = {
('runs', 'POST'): {200: {'headers': None, 'schema': DefinitionsRun}},
('runs', 'GET'): {200: {'headers': None, 'schema': {'items': DefinitionsRun, 'type': 'array'}}},
}
scopes = {
}
class Security(object):
def __init__(self):
super(Security, self).__init__()
self._loader = lambda: []
@property
def scopes(self):
return self._loader()
def scopes_loader(self, func):
self._loader = func
return func
security = Security()
def merge_default(schema, value):
# TODO: more types support
type_defaults = {
'integer': 9573,
'string': 'something',
'object': {},
'array': [],
'boolean': False
}
return normalize(schema, value, type_defaults)[0]
def normalize(schema, data, required_defaults=None):
if required_defaults is None:
required_defaults = {}
errors = []
class DataWrapper(object):
def __init__(self, data):
super(DataWrapper, self).__init__()
self.data = data
def get(self, key, default=None):
if isinstance(self.data, dict):
return self.data.get(key, default)
if hasattr(self.data, key):
return getattr(self.data, key)
else:
return default
def has(self, key):
if isinstance(self.data, dict):
return key in self.data
return hasattr(self.data, key)
def _normalize_dict(schema, data):
result = {}
data = DataWrapper(data)
for key, _schema in schema.get('properties', {}).iteritems():
# set default
type_ = _schema.get('type', 'object')
if ('default' not in _schema
and key in schema.get('required', [])
and type_ in required_defaults):
_schema['default'] = required_defaults[type_]
# get value
if data.has(key):
result[key] = _normalize(_schema, data.get(key))
elif 'default' in _schema:
result[key] = _schema['default']
elif key in schema.get('required', []):
errors.append(dict(name='property_missing',
message='`%s` is required' % key))
return result
def _normalize_list(schema, data):
result = []
if isinstance(data, (list, tuple)):
for item in data:
result.append(_normalize(schema.get('items'), item))
elif 'default' in schema:
result = schema['default']
return result
def _normalize_default(schema, data):
if data is None:
return schema.get('default')
else:
return data
def _normalize(schema, data):
if not schema:
return None
funcs = {
'object': _normalize_dict,
'array': _normalize_list,
'default': _normalize_default,
}
type_ = schema.get('type', 'object')
if not type_ in funcs:
type_ = 'default'
return funcs[type_](schema, data)
return _normalize(schema, data), errors
|
class Callback(object):
def __init__(self, fire_rate=1.0, fire_interval=None):
self.FireRate = fire_rate
self.NextFire = self.FireInterval = fire_interval
self.FireLevel = 0.0
self.FireCount = 0
def __call__(self, event, *params, **args):
self.FireCount += 1
self.FireLevel += self.FireRate
if self.FireInterval is not None and self.FireCount < self.NextFire:
return
if self.FireLevel < 1.0:
return
if hasattr(self, event):
getattr(self, event)(*params, **args)
self.FireLevel -= 1.0
if self.FireInterval is not None:
self.NextFire += self.FireInterval
class CallbackList(object):
#
# Sends event data to list of Callback objects and to list of callback functions
#
def __init__(self, *callbacks):
self.Callbacks = list(callbacks)
def add(self, *callbacks):
self.Callbacks += list(callbacks)
def __call__(self, event, *params, **args):
for cb in self.Callbacks:
cb(event, *params, **args)
@staticmethod
def convert(arg):
if isinstance(arg, CallbackList):
return arg
elif isinstance(arg, (list, tuple)):
return CallbackList(*arg)
elif arg is None:
return CallbackList() # empty
else:
raise ValueError("Can not convert %s to CallbackList" % (arg,))
|
class A(Exception):
def __init__(s, err, *args):
s.err = err
s.d = 2323
@property
def message(s):
return 'kawabunga'
def __str__(s):
return s.message
class B(A):
pass
try:
raise A('hh', 89)
except B as e:
print(1) |
"""Classifier calibration techniques.
https://arxiv.org/pdf/1902.06977.pdf
https://arxiv.org/abs/1706.04599
"""
|
string = input()
for i in range(len(string)):
emoticon = ''
if string[i] == ':':
emoticon += string[i] + string[i + 1]
print(emoticon)
|
# -*- encoding: utf-8 -*-
#######################################################################################################################
# DESCRIPTION:
#######################################################################################################################
# TODO
#######################################################################################################################
# AUTHORS:
#######################################################################################################################
# Carlos Serrada, 13-11347, <[email protected]>
# Juan Ortiz, 13-11021 <[email protected]>
#######################################################################################################################
# CLASS DECLARATION:
#######################################################################################################################
class CNF:
def __init__(self):
self.clauses = []
self.variables = []
self.map = {}
def add(self, clause):
for term in clause.terms:
name = term.name
if not (name in self.map):
self.map[name] = len(self.variables)
self.variables.append(name)
self.clauses.append(clause)
def __str__(self):
header = "p cnf " + str(len(self.variables)) + " " + str(len(self.clauses)) + "\n"
cnf = ""
for clause in self.clauses:
for term in clause.terms:
cnf += ("-" if term.negative else "") + str(self.map[term.name] + 1) + " "
cnf += "0\n"
return header + cnf
def parse(self, file_path):
variables = []
with open(file_path) as file:
for index, line in enumerate(file):
if index == 1:
variables = [x > 0 for x in list(map(int, line.split(' ')))[:-1]]
return variables
def solve(self, file_path):
values = self.parse(file_path)
solution = {}
for i in range(len(values)):
solution[self.variables[i]] = values[i]
return solution
#######################################################################################################################
# :)
#######################################################################################################################
|
"""7. Reverse Integer
https://leetcode.com/problems/reverse-integer/
Given a signed 32-bit integer x, return x with its digits reversed. If
reversing x causes the value to go outside the signed 32-bit integer range
[-2^31, 2^31 - 1], then return 0.
Assume the environment does not allow you to store 64-bit integers (signed or
unsigned).
Example 1:
Input: x = 123
Output: 321
Example 2:
Input: x = -123
Output: -321
Example 3:
Input: x = 120
Output: 21
Example 4:
Input: x = 0
Output: 0
Constraints:
-2^31 <= x <= 2^31 - 1
"""
class Solution:
def reverse(self, x: int) -> int:
maxsize = 2 ** 31 - 1
if x < 0:
return -self.reverse(-x)
string = str(x)
reversed_string = string[::-1]
ans = 0
for c in reversed_string:
ans = ans * 10 + int(c)
if ans > maxsize:
return 0
return ans
def reverse2(self, x: int) -> int:
if x < 0:
return -self.reverse2(-x)
ans = 0
maxsize = 2 ** 31 - 1
while x != 0:
x, y = divmod(x, 10)
ans = ans * 10 + y
return ans if ans <= maxsize else 0
|
"""
Given an integer array with even length, where different numbers in this array represent different
kinds of candies. Each number means one candy of the corresponding kind. You need to distribute
these candies equally in number to brother and sister. Return the maximum number of kinds of
candies the sister could gain.
Example 1:
Input: candies = [1,1,2,2,3,3]
Output: 3
Explanation:
There are three different kinds of candies (1, 2 and 3), and two candies for each kind.
Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3],
too. The sister has three different kinds of candies.
Example 2:
Input: candies = [1,1,2,3]
Output: 2
Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1]. The
sister has two different kinds of candies, the brother has only one kind of candies.
Note:
1. The length of the given array is in range [2, 10000], and will be even.
2. The number in given array is in range [-100000, 100000].
"""
class Solution:
def distributeCandies(self, candies):
return min(len(set(candies)), len(candies) // 2)
|
'''
For a string sequence, a string word is k-repeating if word
concatenated k times is a substring of sequence. The word's
maximum k-repeating value is the highest value k where word
is k-repeating in sequence. If word is not a substring of
sequence, word's maximum k-repeating value is 0.
Given strings sequence and word, return the maximum
k-repeating value of word in sequence.
Example:
Input: sequence = "ababc", word = "ab"
Output: 2
Explanation: "abab" is a substring in "ababc".
Example:
Input: sequence = "ababc", word = "ba"
Output: 1
Explanation: "ba" is a substring in "ababc". "baba" is not
a substring in "ababc".
Example:
Input: sequence = "ababc", word = "ac"
Output: 0
Explanation: "ac" is not a substring in "ababc".
Constraints:
- 1 <= sequence.length <= 100
- 1 <= word.length <= 100
- sequence and word contains only lowercase English
letters.
'''
#Difficulty: Easy
#211 / 211 test cases passed.
#Runtime: 24 ms
#Memory Usage: 14.2 MB
#Runtime: 24 ms, faster than 96.10% of Python3 online submissions for Maximum Repeating Substring.
#Memory Usage: 14.2 MB, less than 75.28% of Python3 online submissions for Maximum Repeating Substring.
class Solution:
def maxRepeating(self, sequence: str, word: str) -> int:
x = 1
while word*x in sequence:
x += 1
return x-1
|
altPulo, qntdCano = map(int, input().split())
canos = list(map(int, input().split()))
atual = canos.pop(0)
for cano in canos:
if max([cano, atual]) - min([cano, atual]) > altPulo:
print('GAME OVER')
quit()
atual = cano
print('YOU WIN')
|
# this graph to check the algorithm
graph={
'S':['B','D','A'],
'A':['C'],
'B':['D'],
'C':['G','D'],
'S':['G'],
}
#function of BFS
def BFS(graph,start,goal):
Visited=[]
queue=[[start]]
while queue:
path=queue.pop(0)
node=path[-1]
if node in Visited:
continue
Visited.append(node)
if node==goal:
return path
else:
adjecent_nodes=graph.get(node,[])
for node2 in adjecent_nodes:
new_path=path.copy()
new_path.append(node2)
queue.append(new_path)
Solution=BFS(graph,'S','G')
print('Solution is ',Solution)
|
# -*- coding: utf-8 -*-
"""
cvtToC2Dict.py
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Convert ToC (Table of Content from Word document) text to List of Dict in Python
Sample of Source file:
1 宏观经济学 1
1.1 商业银行理论 1
1.1.1 银行存款准备金率的概念 1
1.1.2 存款准备金率变动对商业银行的影响 1
:copyright: (c) 2020/11/06 by wanglei.
:license: MIT
TODO:
"""
if __name__ == "__main__":
TOC = []
with open('toc.txt') as file:
for line in file:
idx = 0
for word in line.split(' '):
if idx == 0:
pass
elif idx == 1:
pass
elif idx == 2:
pass
else:
pass
idx += 1
|
print('Vamos analisar.')
a = input('Escreva uma palavra: ')
print(f'O tipo primitivo é {type(a)}')
print(f'Tem espaço: {a.isspace()}')
print(f'É um número: {a.isnumeric()}')
print(f'É alphabetico: {a.isalpha()}')
print(f'É alphanumérico: {a.isalnum()}')
print(f'É maiuscula: {a.isupper()}')
print(f'É minuscula: {a.islower()}')
print(f'Está capitalizado: {a.istitle()}')
|
"""
1184. Distance Between Bus Stops
Easy
A bus has n stops numbered from 0 to n - 1 that form a circle. We know the distance between all pairs of neighboring stops where distance[i] is the distance between the stops number i and (i + 1) % n.
The bus goes along both directions i.e. clockwise and counterclockwise.
Return the shortest distance between the given start and destination stops.
Example 1:
Input: distance = [1,2,3,4], start = 0, destination = 1
Output: 1
Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.
Example 2:
Input: distance = [1,2,3,4], start = 0, destination = 2
Output: 3
Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3.
Example 3:
Input: distance = [1,2,3,4], start = 0, destination = 3
Output: 4
Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4.
Constraints:
1 <= n <= 10^4
distance.length == n
0 <= start, destination < n
0 <= distance[i] <= 10^4
"""
class Solution:
def distanceBetweenBusStops(self, distance: List[int], start: int, destination: int) -> int:
a, b = min(start, destination), max(start, destination)
return min(sum(distance[a:b]), sum(distance)-sum(distance[a:b])) |
class Solution:
def solve(self, nums):
sameIndexAfterSortingCount = 0
sortedNums = sorted(nums)
for i in range(len(nums)):
if sortedNums[i] == nums[i]:
sameIndexAfterSortingCount += 1
return sameIndexAfterSortingCount
|
S = 'shrubbery'
L = list(S)
print('L', L)
|
coffee =10
while True:
money = int(input("돈을 넣어 주세요: "))
payback = money-300
more_money = 300-money
if money == 300:
print("결재 완료. 커피를 줍니다.")
coffee -= 1
elif money >300:
print(f'거스름돈 {payback}를 주고 커피를 줍니다.')
coffee -= 1
elif (1< money <300 ):
print(f'커피는` 300원이니 추가로 {more_money}를 더 내야합니다.')
money += int(input(f'{more_money}만큼 지불해야합니다.'))
if money == 300:
print("결재 완료. 커피를 줍니다.")
coffee -= 1
if coffee == 0:
print("커피 재고가 없습니다.")
break |
def get_binary_nmubmer(decimal_number):
assert isinstance(decimal_number, int)
return bin(decimal_number)
print(get_binary_nmubmer(10.5)) |
def is_kadomatsu(a):
if a[0] == a[1] or a[1] == a[2] or a[0] == a[2]:
return False
return min(a) == a[1] or max(a) == a[1]
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(3):
for j in range(3):
a[i], b[j] = b[j], a[i]
if is_kadomatsu(a) and is_kadomatsu(b):
print('Yes')
exit()
a[i], b[j] = b[j], a[i]
print('No')
|
# In Part B, you had a chance to explore how both the percentage of your salary that you save each month
# and your annual raise affect how long it takes you to save for a down payment. This is nice, but
# suppose you want to set a particular goal, e.g. to be able to afford the down payment in three years.
# How much should you save each month to achieve this? In this problem, you are going to write a
# program to answer that question. To simplify things, assume:
# 3
# 1. Your semiannual raise is .07 (7%)
# 2. Your investments have an annual return of 0.04 (4%)
# 3. The down payment is 0.25 (25%) of the cost of the house
# 4. The cost of the house that you are saving for is $1M.
# You are now going to try to find the best rate of savings to achieve a down payment on a $1M house in
# 36 months. Since hitting this exactly is a challenge, we simply want your savings to be within $100 of
# the required down payment.
#user provided input
annual_salary = int(input("Enter your starting annual salary: $"))
#fixed variables
total_cost = 1000000
portion_down_payment = 0.25
down_payment = total_cost * portion_down_payment
current_savings = 0.0
r = 0.04
monthly_r = r / 12
semi_annual_raise_months = 6
semi_annual_raise = 0.07
months_goal = 36
#setup for the bisection
high = 10000
low = 0
epsilon = 100 #acceptable margin of error for the answer
step_count = 0
while True:
step_count += 1
portion_saved = (high + low) // 2 #note to self: "//" is floor division. In other words, only the integer is returned
working_salary = annual_salary
working_savings = current_savings
for months in range(1,months_goal+1):
working_savings += ((working_salary/12) * (portion_saved / 10000)) + (working_savings*r/12)
if months % semi_annual_raise_months == 0:
working_salary *= 1 + semi_annual_raise #note to self: the "*=" operator multiplies everything on the right by the left and THEN performs the math (addition in this case)
if abs(working_savings - down_payment) <= epsilon:
print("The best savings rate to make your downpayment in 36 months is:", (portion_saved/100), "% or", (portion_saved / 10000))
print("Steps in bisection search:", step_count)
break
elif abs(working_savings - down_payment) > epsilon and working_savings > down_payment:
high = portion_saved
elif abs(working_savings - down_payment) > epsilon and working_savings < down_payment:
low = portion_saved
if low == high:
print("you can't pay this down in 3 years with you your current salary")
break |
class Tesla:
# WRITE YOUR CODE HERE
def __init__(self, model: str, color: str, autopilot: bool = False, seats_count: int = 5, is_locked: bool = True, battery_charge: float = 99.9, efficiency: float = 0.3):
self.__model = model
self.__color = color
self.__autopilot = autopilot
self.__battery_charge = battery_charge
self.__is_locked = is_locked
self.__seats_count = seats_count
self.__efficiency = efficiency
@property
def color(self) -> str:
return self.__color
@property
def autopilot(self) -> str:
return self.__autopilot
@property
def seats_count(self) -> int:
return self.__seats_count
@property
def is_locked(self) -> bool:
return self.__is_locked
@property
def battery_charge(self) -> int:
return self.__battery_charge
@color.setter
def color(self, new_color: str) -> None:
self.__color = new_color
@autopilot.setter
def autopilot(self, autopilot: bool) -> None:
self.__autopilot = autopilot
@seats_count.setter
def seats_count(self, seats: int) -> None:
if(seats < 2):
return "Seats count cannot be lower than 2!"
self.__seats_count = seats
@is_locked.setter
def is_locked(self) -> None:
self.is_locked = True
def autopilot(self, obsticle: str) -> str:
'''
Takes in an obsticle object as string, returns string information about successfully avoiding the object or string information about availability of autopilot.
Parameters:
obsticle (str): An real world object that needs to be manuverd
Returns:
success (str): String informing about avoided obsticle
fail (str): String warning that the car does not have autopilot
'''
if self.__autopilot:
return f"Tesla model {self.__model} avoids {obsticle}"
return "Autopilot is not available"
#unlocking car
def unlock(self) -> None:
self.__is_locked = False
# opening doors
def open_doors(self) -> str:
'''
Returns string information about opening the doors of the car.
Parameters:
None
Returns:
success (str): String informing that the doors are opening
fail (str): String warning that the car is locked
'''
if(self.__is_locked):
return "Car is locked!"
return "Doors opens sideways"
# checking battery
def check_battery_level(self) -> str:
return f"Battery charge level is {self.__battery_charge}%"
# charging battery
def charge_battery(self) -> None:
self.__battery_charge = 100
# driving the car
def drive(self, travel_range: float):
'''
Takes in the travel distance number, returns remaining battery life or not enough battery warning.
Parameters:
travel_range (float): A float number
Returns:
battery_charge_level (str): String informing about remaining battery life
String warning (str): String warning that there is not enough battery to complete the travel distance
'''
battery_discharge_percent = travel_range * self.__efficiency
# COMPLETE THE FUNCTION
if self.__battery_charge - battery_discharge_percent >= 0:
self.__battery_charge = self.__battery_charge - battery_discharge_percent
return self.check_battery_level()
else:
return "Battery charge level is too low!"
def welcome(self) -> str:
raise NotImplementedError
|
def sum(*args):
total_sum = 0
for number in args:
total_sum += number
return total_sum
result = sum(1, 3, 4, 5, 8, 9, 16)
print({ 'result': result })
|
class VangError(Exception):
def __init__(self, msg=None, key=None):
self.msg = msg or {}
self.key = key
class InitError(Exception):
pass
|
BOS_TOKEN = '[unused98]'
EOS_TOKEN = '[unused99]'
CLS_TOKEN = '[CLS]'
SPACE_TOKEN = '[unused1]'
UNK_TOKEN = '[UNK]'
SPECIAL_TOKENS = [BOS_TOKEN, EOS_TOKEN, CLS_TOKEN, SPACE_TOKEN, UNK_TOKEN]
TRAIN = 'train'
EVAL = 'eval'
PREDICT = 'infer'
MODAL_LIST = ['image', 'others']
|
class Solution:
def reverseStr(self, s, k):
"""
:type s: str
:type k: int
:rtype: str
"""
ans = []
i = 0
while i < len(s):
di = min(len(s) - i, k)
ans.append(s[i:i + di][::-1])
i += di
di = min(len(s) - i, k)
ans.append(s[i:i + di])
i += di
return ''.join(ans) |
def saveHigh(whatyouwant):
file = open('HighPriorityIssues.txt', 'a')
file.write(formatError(whatyouwant))
file.close()
def saveMedium(whatyouwant):
file = open('MediumPriorityIssues.txt', 'a')
file.write(formatError(whatyouwant))
file.close()
def saveLow(whatyouwant):
file = open('LowPriorityIssues.txt', 'a')
file.write(formatError(whatyouwant))
file.close()
def formatError(input):
if not isinstance(input, str):
return repr(input)
return input
|
#!/usr/bin/python3
def add(*matrices):
def check(data):
if data == 1:
return True
else:
raise ValueError
return [[sum(slice) for slice in zip(*row) if check(len(set(map(len, row))))]
for row in zip(*matrices) if check(len(set(map(len, matrices))))]
|
"""
:py:mod:`pypara` is a Python library for
- encoding currencies and monetary value objects,
- performing monetary arithmetic and conversions, and
- running rudimentary accounting operations.
Furthermore, there are some type convenience for general use.
The source code is organised in sub-packages and sub-modules.
"""
#: Defines the version of the package.
__version__ = "0.0.27.dev0"
|
# By Websten from forums
#
# Given your birthday and the current date, calculate your age in days.
# Account for leap days.
#
# Assume that the birthday and current date are correct dates (and no
# time travel).
#
def daysBetweenDates(year1, month1, day1, year2, month2, day2):
daysOfMonths = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0]
if isLeap(year1):
daysOfMonths[1] = 29
else:
daysOfMonths[1] = 28
if year1 == year2:
return (daysOfMonths[month1-1] - day1) + sum(daysOfMonths[month1:month2-1]) + day2
totalDays = 0
for year in range(year1, year2 + 1):
if isLeap(year):
daysOfMonths[1] = 29
else:
daysOfMonths[1] = 28
if year == year1:
totalDays += (daysOfMonths[month1-1] - day1) + sum(daysOfMonths[month1:])
elif year == year2:
totalDays += day2 + sum(daysOfMonths[:month2 - 1])
else:
totalDays += sum(daysOfMonths)
return totalDays
# Test routine
def isLeap(year):
return (year % 100 == 0 and year % 400 == 0 ) or (year % 4 == 0 and year % 100 != 0)
#if year % 4 == 0:
#if year % 100 == 0:
#if year % 400 == 0:
#return True
#else:
#return False
#return True
#return False
def test():
test_cases = [((2012,1,1,2012,2,28), 58),
((2012,1,1,2012,3,1), 60),
((2011,6,30,2012,6,30), 366),
((2011,1,1,2012,8,8), 585 ),
((1900,1,1,1999,12,31), 36523)]
for (args, answer) in test_cases:
result = daysBetweenDates(*args)
if result != answer:
print ("Test with data:", args, "failed")
else:
print ("Test case passed!")
#test()
print(daysBetweenDates(1973,7,28,2018,1,13))
|
class HWriter(object):
def __init__(self):
self.__bIsNewLine = True # are we at a new line position?
self.__bHasContent = False # do we already have content in this line?
self.__allParts = []
self.__prefix = ""
self.__nIndent = 0
#
def incrementIndent(self):
self.__nIndent += 1
if self.__nIndent > len(self.__prefix):
self.__prefix += "\t"
#
def decrementIndent(self):
if self.__nIndent == 0:
raise Exception("Indentation error!")
self.__nIndent -= 1
#
def write(self, *items):
# print("write( " + repr(items) + " )")
if self.__bIsNewLine:
self.__bIsNewLine = False
for item in items:
if hasattr(type(item), "__iter__"):
for i in item:
if len(i) > 0:
if not self.__bHasContent:
self.__allParts.append(self.__prefix[:self.__nIndent])
self.__allParts.append(i)
self.__bHasContent = True
else:
if len(item) > 0:
if not self.__bHasContent:
self.__allParts.append(self.__prefix[:self.__nIndent])
self.__allParts.append(item)
self.__bHasContent = True
#
def writeLn(self, *items):
# print("writeLn( " + repr(items) + " )")
if self.__bIsNewLine:
self.__bIsNewLine = False
for item in items:
if hasattr(type(item), "__iter__"):
for i in item:
if len(i) > 0:
if not self.__bHasContent:
self.__allParts.append(self.__prefix[:self.__nIndent])
self.__allParts.append(i)
self.__bHasContent = True
else:
if len(item) > 0:
if not self.__bHasContent:
self.__allParts.append(self.__prefix[:self.__nIndent])
self.__allParts.append(item)
self.__bHasContent = True
self.lineBreak()
#
#
# Add a line break if (and only if) the last item was not a line break.
# Typically you won't want to use this method but <c>writeLn</c> instead.
# <c>writeLn</c> will add a line in any case.
#
def lineBreak(self):
if not self.__bIsNewLine:
self.__bHasContent = False
self.__allParts.append("\n")
self.__bIsNewLine = True
#
#
# Get a list of lines (without line breaks).
#
def getLines(self) -> list:
ret = []
iStart = 0
iMax = len(self.__allParts)
for i in range(0, iMax):
if self.__allParts[i] == "\n":
ret.append("".join(self.__allParts[iStart:i]))
iStart = i + 1
if iMax > iStart:
ret.append("".join(self.__allParts[iStart:]))
return ret
#
def toString(self) -> str:
self.lineBreak()
return "".join(self.__allParts)
#
def __str__(self):
self.lineBreak()
return "".join(self.__allParts)
#
def __repr__(self):
return "HWriter<" + str(len(self.__allParts)) + " parts>"
#
#
|
class Symbol:
def __init__(self, name):
self.name = name
def __hash__(self):
return hash(self.name)
def __eq__(self, other):
return self.name == other.name
class SymbolTable:
def __init__(self):
self._symbol_table = dict()
def put_symbol(self, symbol):
self._symbol_table[symbol] = 1
def get_symbol(self, symbol):
return self._symbol_table[symbol]
|
#Faça um programa que leia 2 notas de um aluno, verifique
#se as notas são válidas e exiba na tela a média destas
#notas. Uma nota válida deve ser, obrigatoriamente, um
#valor entre 0.0 e 10.0, onde caso a nota não possua
#um valor válido, este fato deve ser informado ao
#usuário e o programa termina.
notas=[]
i=0
for c in range(0,2):
n=float(input("Informe a nota do aluno: "))
if(n>=0 and n<=10):
notas.append(n)
else:
print("valor invalido")
break
|
"""
Chovin Carlson - House by the Waves:
https://www.youtube.com/watch?v=nkU8r5QKN3Y
How to:
- Run the statements line by line (alt+enter),
go to the next one whenever you feel like
- The "#### > run block <" blocks should be
executed together (ctrl+enter)
- If you want to fast-forward through the song,
just execute the blocks together (ctrl+enter)
from the beginning, so you don't have to go
through every variation of each instrument
- Enjoy ! :+1:
"""
n1 >> noise(PSine(32),)
n1 >> noise(P(PSine(32),PSine(24)),)
n1 >> noise(P(PSine(32),PSine(24),PSine(27)),)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7),)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=16,)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=16,lpf=1200,lpr=(linvar([0,6],64),linvar([3,0],53))+PSine(5)*.7)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=0,lpf=1200,lpr=(linvar([0,6],64),linvar([3,0],53))+PSine(5)*.7)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=2,lpf=1200,lpr=(linvar([0,6],64),linvar([3,0],53))+PSine(5)*.7)
n1 >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=linvar([0,16],65),lpf=1200,lpr=(linvar([0,6],64),linvar([3,0],53)))
n1.reset() >> noise(P(PSine(32),PSine(24),PSine(27),PSine(18)*.7,PSine(45)),amp=P(.8,.7,.8,.7,.9)*.4,dur=.5,formant=(linvar([1,3],48),linvar([3,1],53)),chop=16,lpf=1200,lpr=(linvar([0,6],64),linvar([3,0],53)))
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12),)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand(b1.dur)/8),)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand(b1.dur)/8),amp=.8,)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand(b1.dur)/8),amp=.8,formant=1,)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand(b1.dur)/8),amp=.8,formant=2,)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand(b1.dur)/8),amp=.6,formant=2,)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.5,delay=(0,PRand([0,PRand(b1.dur)/8])),amp=.6,formant=2,)
b2 >> bell(0,dur=PRand(20)+.125,delay=(0,PRand([0,PRand(b2.dur)/3])),)
b2 >> bell(0,dur=PRand(20)+.125,delay=(0,PRand([0,PRand(b2.dur)/3])),amp=linvar([.25,.5],PRand(8,32)),)
b2 >> bell(0,dur=PRand(20)+.125,delay=(0,PRand([0,PRand(b2.dur)/3])),amp=linvar([.25,.5],PRand(8,32)),lpf=linvar([2200,4000],PRand(36)),)
b2 >> bell(0,dur=PRand(20)+.125,delay=(0,PRand([0,PRand(b2.dur)/3])),amp=linvar([.25,.5],PRand(8,32)),lpf=linvar([2200,4000],PRand(36)),oct=PRand([5,6]),)
b2 >> bell(0,dur=PRand(20)*1.25+.125,delay=(0,PRand([0,PRand(b2.dur)/3])),amp=linvar([.25,.5],PRand(8,32)),lpf=linvar([2200,4000],PRand(36)),oct=PRand([5,6]),)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.25,delay=(0,PRand([0,PRand(b1.dur)/8])),amp=.6,formant=2,)
s1 >> soprano([0,4,(3,1),2],dur=8,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.6,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.6,lpf=1200,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.2,lpf=1200,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.4,lpf=1200,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.6,lpf=1200,)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),delay=P(0,.125,.25),)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),delay=P(0,.125,.25),sus=.15,)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),delay=P(0,.125,.25),sus=.15,chop=1,)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),delay=P(0,.125,.25),sus=.15,chop=1,amp=.8,)
s2 >> spark((7,5,[4,9]),dur=PRand(6,24),delay=P(0,.125,.25)*.8,sus=.15,chop=1,amp=.8,)
s2 >> spark((7,5,[4,[9,10]]),dur=PRand(6,24),delay=P(0,.125,.25)*.8,sus=.15,chop=1,amp=.8,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,amp=P(PRange(4,0,-1)/8+.25),)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),formant=1,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,0,0,0),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,2),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=4,amp=P(PRange(4,0,-1)/8+.25),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=4,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,echo=1,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,echo=1,decay=1,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,echo=1,decay=1,sus=b3.dur-1.5,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,echo=1,decay=1,sus=b3.dur-1.5,formant=1,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.4,echo=1,decay=1,sus=b3.dur-1.5,formant=(0,1),)
b1 >> blip(PRand(8)+(0,PRand(4)),dur=PRand(2,12)*1.25,delay=(0,PRand([0,PRand(b1.dur)/8])),amp=.5,formant=2,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.5,lpf=1200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=3,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=2.5,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=2,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=1.5,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=1,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=.75,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=.5,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=.25,amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
#### > run block <
piv = [1,1.5,2,2.5,3,3,4,4]
piv.extend(piv[::-1])
pivd = 16
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=var(piv,pivd),amp=P(PRange(4,0,-1)/8+.25)*.6,delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
#### > run block <
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=.3,echo=1,decay=1,sus=b3.dur-1.5,formant=(0,1),)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=(.4,.3),echo=1,decay=1,sus=b3.dur-1.5,formant=(0,1),)
#### > run block < danger
piv = [0.25,0.25,1/3,1/3,0.5,0.625,0.75,0.875,1,1.5,2,2.5,3,3,4,4]
piv.extend(piv[::-1])
pivd = 8
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=var(piv,pivd),amp=P(PRange(4,0,-1)/8+.25)*linvar([.4,.6,.4],[[pivd*2]+[pivd*(len(piv)-4)]+[pivd*2]]),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
#### > run block <
p1 >> pluck(var([9,7,3,4,2,1],8) + (0,2,0,[4,5,6]),dur=Pvar([linvar(piv,pivd),var(piv,pivd)],len(piv)*pivd),amp=P(PRange(4,0,-1)/8+.25)*linvar([.4,.6,.4],[[pivd*2]+[pivd*(len(piv)-4)]+[pivd*2]]),delay=P(PRange(4,0,-1)/4),formant=1,lpf=1500,hpf=200,)
s1 >> soprano([0,4,(3,1),2],dur=8,sus=s1.dur/2,amp=.6,lpf=1200,)
b3 >> bass((p1.degree-1)+(0,2),dur=8,amp=(.4,.3),echo=1,decay=1,sus=b3.dur-1.5,formant=(0,1),)
Group(p1).amplify = 0.9
Group(p1).amplify = 0.8
Group(p1).amplify = 0.7
Group(p1,s2).amplify = 0.7
Group(p1,s2,b1).amplify = 0.7
Group(p1,s2,b1).amplify = 0.6
Group(p1,s2,b1,s1).amplify = 0.6
Group(p1,s2,b1,s1,b2).amplify = 0.6
Group(p1,s2,b1,s1,b2).amplify = 0.5
Group(p1,s2,b1,s1,b2,n1).amplify = 0.5
Group(p1,s2,b1,s1,b2,n1).amplify = 0.4
Group(p1,s2,b1,s1,b2,n1).amplify = 0.3
Group(p1,s2,b1,s1,b2,n1).amplify = 0.2
Group(p1,s2,b1,s1,b2,n1,b3).amplify = 0.2
Group(p1,s2,b1,s1,b2,n1,b3).amplify = 0.4
Group(p1,s2,b1,s1,b2,n1,b3).amplify = 0
|
#Max retorna o maior numero de um iteravel ou o maior de 2 ou mais elementos
#Min retorna o menor numero de um iteravel ou o menor de 2 ou mais elementos
lista=[9,5,2,1,4,5,3,6,21,5,4,55,0]
print(max(lista))
print(max(8,9,5,7,4,5,6))
dicionario={'a':0,'b':1,'f':51,'g':12,'q':5,'u':3,'d':2}
print(max(dicionario))
print(max(dicionario.values()))
print(min(lista))
print(min(8,9,5,7,4,5,6))
dicionario1={'a':0,'b':1,'f':51,'g':12,'q':5,'u':3,'d':2}
print(min(dicionario1))
print(min(dicionario1.values()))
nomes=['alexandre', 'maiure','joselito']
print(min(nomes)) #pela ordem alfabetica
print(max(nomes)) #pela ordem alfabetica |
# Input your Wi-Fi credentials here, if applicable, and rename to "secrets.py"
ssid = ''
wpa = ''
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.