content stringlengths 7 1.05M |
|---|
class Solution:
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
i = 0
while i < len(nums)-1: ##此处索引一直更新所以不会超限
if nums[i] == nums[i+1]:
nums.remove(nums[i])
else:
i += 1
return len(nums)
## 如果用for loop会有问题，此处的i 循环不更新，所以会索引超限
for i in range(len(nums)-1):
if nums[i] == nums[i+1]:
nums.remove(nums[i])
else:
continue
return len(nums)##
|
CURRENT_NEWS_API_KEY = '' # Replace with your news.org API keys
news = {
'api_key': '',
'base_everything_url': 'https://newsapi.org/v2/everything'
} |
'''
Given a square matrix of N rows and columns, find out whether it is symmetric or not.
>>Input Format:
The first line of the input contains an integer number n which represents the number of rows and the number of columns.
From the second line, take n lines input with each line containing n integer elements with each element separated by a space.
>>Output Format:
Print 'YES' if it is symmetric otherwise 'NO'
>>Example:
Input:
2
1 2
2 1
Output:
YES
'''
z, l = [], []
n = int(input())
[z.append(list(map(int, input().split()))) for i in range(n)]
[l.append(list(i)) for i in list(zip(*z))]
print ("YES" if l == z else "NO", end="")
|
#在0的位置进行移动到target的位置，每次可以选择向左或者向右，第n次移动n步，问最短移动到target的次数
def reachNumber(target):
"""
:param target: int
:return: number
"""
t = abs(target)
k = 0
s = 0
while s<t:
k+=1
s+=k
dt = s-t
if dt%2==0:
return k
else:
if k%2==0:
return k+1
else:
return k+2
if __name__=='__main__':
target = 13
num=reachNumber(target)
print(num) |
ENV='development'
DEBUG=True
SQLALCHEMY_DATABASE_URI='sqlite:///data_base.db'
#SQLALCHEMY_ECHO=True
SQLALCHEMY_TRACK_MODIFICATIONS=False
SCHEDULER_API_ENABLED = True
|
# Exercise number 2 - Python WorkOut
# Author: Barrios Ramirez Luis Fernando
# Language: Python3 3.8.2 64-bit
def my_sum(*numbers): # The "splat" operator is used when we need an arbitrary amount of arguments
output = numbers[0]
for i in numbers[1:]: # It returns a tuple
output += i
return output
print(my_sum(4, 6))
|
n = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'B', 'H']
i = sorted(n.index(x) for x in input().split())
c = (i[1] - i[0], i[2] - i[1])
if c in ((4, 3), (3, 5), (5, 4)):
print('major')
elif c in ((3, 4), (4, 5), (5, 3)):
print('minor')
else:
print('strange')
|
template='''
def __init__(self, base_space, **kwargs):
super().__init__() # Time scheme is set from Model.__init__()
# Set base space (manifold)
#------------------------------
assert base_space.dimension == len(self.coordinates), \
"Dimension of base_space is different from the number of coordinates"
self.base_space = base_space
{% if constant_functions_flag %}
#-----------------------
# Set constant functions
#-----------------------
# Set a default nan value for constants
{% for function in constant_functions %}self.{{function.as_keyvar}} = np.nan # @@ set constant value @@
{% endfor %}
# Set constant function values from external **kwargs (when provided)
for key in kwargs:
if key in self.constant_functions:
setattr(self, key, kwargs[key])
# Alert when a constant is np.nan
for function in self.constant_functions:
if getattr(self, function) is np.nan:
print(f"Warning: function `{function}` has to be set")
{% endif %}
{% if constants_flag %}
#---------------------------
# Set constants of the model
#---------------------------
# Set a default nan value for constants
{% for constant in constants %}self.{{constant.as_keyvar}} = np.nan # @@ set constant value @@
{% endfor %}
# Set constant values from external **kwargs (when provided)
for key in kwargs:
if key in self.constants:
setattr(self, key, kwargs[key])
# Alert when a constant is np.nan
for constant in self.constants:
if getattr(self, constant) is np.nan:
print(f"Warning: constant `{constant}` has to be set")
{% endif %}
'''
|
class Solution(object):
def isBoomerang(self, points):
"""
:type points: List[List[int]]
:rtype: bool
"""
p1, p2, p3 = points[0], points[1], points[2]
if p2[0] != p1[0]:
a = (p2[1] - p1[1]) / float(p2[0] - p1[0])
b = p1[1] - a * p1[0]
return p3[1] != (a * p3[0] + b)
else:
return p3[0] != p2[0] and p1[1] != p2[1]
def test_is_boomerang():
s = Solution()
assert s.isBoomerang([[1, 1], [2, 3], [3, 2]])
assert s.isBoomerang([[1, 1], [2, 2], [3, 3]]) is False
assert s.isBoomerang([[1, 1], [1, 2], [1, 3]]) is False
assert s.isBoomerang([[0, 0], [1, 1], [1, 1]]) is False
assert s.isBoomerang([[0, 0], [2, 1], [2, 1]]) is False
assert s.isBoomerang([[0, 1], [0, 1], [2, 1]]) is False
|
aPL = 4.412E-10
nPL = 5.934
G13 = 5290.
enerPlas = aPL/G13*90.65**(nPL + 1.)*nPL/(nPL + 1.)*0.2**3
enerFrac = 0.788*0.2*0.2
enerTotal = enerPlas+enerFrac
parameters = {
"results": [
{
"type": "max",
"step": "Step-7",
"identifier":
{
"symbol": "S13",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 90.65,
"tolerance": 0.01
},
{
"type": "max",
"step": "Step-9",
"identifier":
{
"symbol": "S13",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 91.08,
"tolerance": 0.01
},
{
"type": "max",
"step": "Step-11",
"identifier":
{
"symbol": "S13",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 79.96,
"tolerance": 0.05
},
{
"type": "max",
"step": "Step-17",
"identifier":
{
"symbol": "SDV_CDM_d1T",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 0.0,
"tolerance": 0.0
},
{
"type": "max",
"step": "Step-17",
"identifier":
{
"symbol": "SDV_CDM_d1C",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 0.0,
"tolerance": 0.0
},
{
"type": "continuous",
"identifier":
{
"symbol": "S12",
"elset": "ALL_ELEMS",
"position": "Element 1 Int Point 1"
},
"referenceValue": 0.0,
"tolerance": 0.1
},
{
"type": "tabular",
"identifier": "Plastic dissipation: ALLPD for Whole Model",
"referenceValue": [
(0.0, 0.0),
(0.10, aPL/G13*69.2368**(nPL + 1.)*nPL/(nPL + 1.)*0.2**3), # End of step 1 (all plasticity)
(0.25, aPL/G13*79.045**(nPL + 1.)*nPL/(nPL + 1.)*0.2**3), # End of step 3 (all plasticity)
(0.40, aPL/G13*85.5842**(nPL + 1.)*nPL/(nPL + 1.)*0.2**3), # End of step 5 (all plasticity)
(0.55, aPL/G13*90.6525**(nPL + 1.)*nPL/(nPL + 1.)*0.2**3), # End of step 7 (all plasticity)
],
"tolerance_percentage": 0.05
},
{
"type": "finalValue",
"identifier": "Plastic dissipation: ALLPD for Whole Model",
"referenceValue": enerTotal, # Total energy dissipation (plasticity + fracture)
"tolerance": 0.02*enerTotal
}
]
}
|
x = int(input("숫자?: "))
i = 2
while i == 2:
if x%i == 0:
print(i, end=' ')
x = x / i
continue
else:
i += 1
while i <= x:
if x%i == 0:
print(i, end=' ')
x = x / i
continue
i += 2
|
# -*- coding: utf-8 -*-
# Scrapy settings for jn_scraper project
#
# For simplicity, this file contains only settings considered important or
# commonly used. You can find more settings consulting the documentation:
#
# https://doc.scrapy.org/en/latest/topics/settings.html
# https://doc.scrapy.org/en/latest/topics/downloader-middleware.html
# https://doc.scrapy.org/en/latest/topics/spider-middleware.html
BOT_NAME = 'jn_scraper'
SPIDER_MODULES = ['scraper.spiders']
NEWSPIDER_MODULE = 'scraper.spiders'
# Obey robots.txt rules
ROBOTSTXT_OBEY = True
ITEM_PIPELINES = {'scraper.pipelines.ProductItemPipeline': 200}
|
def rounding(numbers):
num = [round(float(x)) for x in numbers]
return num
print(rounding(input().split(" "))) |
expected_output={
'interface': {
'HundredGigE2/0/1': {
'if_id': '0x3',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 1,
'last_serdes': 1,
'cntx': 0,
'lpn': 1,
'gpn': 769,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/2': {
'if_id': '0x485',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 2,
'first_serdes': 2,
'last_serdes': 3,
'cntx': 0,
'lpn': 2,
'gpn': 770,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/3': {
'if_id': '0x519',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 3,
'first_serdes': 4,
'last_serdes': 5,
'cntx': 0,
'lpn': 3,
'gpn': 771,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/4': {
'if_id': '0x487',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 4,
'first_serdes': 6,
'last_serdes': 7,
'cntx': 0,
'lpn': 4,
'gpn': 772,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/5': {
'if_id': '0x488',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 5,
'first_serdes': 8,
'last_serdes': 9,
'cntx': 0,
'lpn': 5,
'gpn': 773,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/6': {
'if_id': '0x8',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 6,
'first_serdes': 10,
'last_serdes': 11,
'cntx': 0,
'lpn': 6,
'gpn': 774,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/7': {
'if_id': '0x48a',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 7,
'first_serdes': 12,
'last_serdes': 13,
'cntx': 0,
'lpn': 7,
'gpn': 775,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/8': {
'if_id': '0x48b',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 8,
'first_serdes': 14,
'last_serdes': 15,
'cntx': 0,
'lpn': 8,
'gpn': 776,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/9': {
'if_id': '0x48c',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 9,
'first_serdes': 16,
'last_serdes': 17,
'cntx': 0,
'lpn': 9,
'gpn': 777,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/10': {
'if_id': '0x51f',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 10,
'first_serdes': 18,
'last_serdes': 19,
'cntx': 0,
'lpn': 10,
'gpn': 778,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/11': {
'if_id': '0x513',
'inst': 0,
'asic': 0,
'core': 5,
'port': 0,
'subport': 0,
'mac': 11,
'last_serdes': 1,
'cntx': 0,
'lpn': 11,
'gpn': 779,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/12': {
'if_id': '0x514',
'inst': 0,
'asic': 0,
'core': 5,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 12,
'first_serdes': 20,
'last_serdes': 21,
'cntx': 0,
'lpn': 12,
'gpn': 780,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/13': {
'if_id': '0x51a',
'inst': 0,
'asic': 0,
'core': 5,
'port': 0,
'subport': 0,
'mac': 13,
'first_serdes': 4,
'last_serdes': 5,
'cntx': 0,
'lpn': 13,
'gpn': 781,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/14': {
'if_id': '0x51b',
'inst': 0,
'asic': 0,
'core': 5,
'port': 0,
'subport': 0,
'mac': 14,
'first_serdes': 6,
'last_serdes': 7,
'cntx': 0,
'lpn': 14,
'gpn': 782,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/15': {
'if_id': '0x492',
'inst': 0,
'asic': 0,
'core': 5,
'port': 0,
'subport': 0,
'mac': 15,
'first_serdes': 8,
'last_serdes': 15,
'cntx': 0,
'lpn': 15,
'gpn': 783,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/16': {
'if_id': '0x493',
'inst': 0,
'asic': 0,
'core': 5,
'port': 0,
'subport': 0,
'mac': 16,
'first_serdes': 16,
'last_serdes': 23,
'cntx': 0,
'lpn': 16,
'gpn': 784,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/17': {
'if_id': '0x494',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 17,
'last_serdes': 7,
'cntx': 0,
'lpn': 17,
'gpn': 785,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/18': {
'if_id': '0x495',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 18,
'first_serdes': 8,
'last_serdes': 15,
'cntx': 0,
'lpn': 18,
'gpn': 786,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/19': {
'if_id': '0x496',
'inst': 0,
'asic': 0,
'core': 4,
'port': 0,
'subport': 0,
'mac': 19,
'first_serdes': 8,
'last_serdes': 9,
'cntx': 0,
'lpn': 19,
'gpn': 787,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/20': {
'if_id': '0x497',
'inst': 0,
'asic': 0,
'core': 4,
'port': 0,
'subport': 0,
'mac': 20,
'last_serdes': 7,
'cntx': 0,
'lpn': 20,
'gpn': 788,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/21': {
'if_id': '0x498',
'inst': 0,
'asic': 0,
'core': 3,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 21,
'last_serdes': 1,
'cntx': 0,
'lpn': 21,
'gpn': 789,
'type': 'NIF',
'active': 'Y'
},
'FourHundredGigE2/0/22': {
'if_id': '0x499',
'inst': 0,
'asic': 0,
'core': 3,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 22,
'first_serdes': 8,
'last_serdes': 15,
'cntx': 0,
'lpn': 22,
'gpn': 790,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/23': {
'if_id': '0x19',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 23,
'first_serdes': 16,
'last_serdes': 17,
'cntx': 0,
'lpn': 23,
'gpn': 791,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/24': {
'if_id': '0x516',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 24,
'first_serdes': 18,
'last_serdes': 19,
'cntx': 0,
'lpn': 24,
'gpn': 792,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/25': {
'if_id': '0x49c',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 25,
'last_serdes': 1,
'cntx': 0,
'lpn': 25,
'gpn': 793,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/26': {
'if_id': '0x51c',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 26,
'first_serdes': 20,
'last_serdes': 21,
'cntx': 0,
'lpn': 26,
'gpn': 794,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/27': {
'if_id': '0x49e',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 27,
'first_serdes': 4,
'last_serdes': 5,
'cntx': 0,
'lpn': 27,
'gpn': 795,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/28': {
'if_id': '0x49f',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 28,
'first_serdes': 6,
'last_serdes': 7,
'cntx': 0,
'lpn': 28,
'gpn': 796,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/29': {
'if_id': '0x4a0',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 29,
'first_serdes': 8,
'last_serdes': 9,
'cntx': 0,
'lpn': 29,
'gpn': 797,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/30': {
'if_id': '0x4a1',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 30,
'first_serdes': 10,
'last_serdes': 11,
'cntx': 0,
'lpn': 30,
'gpn': 798,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/31': {
'if_id': '0x4a2',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 31,
'first_serdes': 12,
'last_serdes': 13,
'cntx': 0,
'lpn': 31,
'gpn': 799,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/32': {
'if_id': '0x4a3',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 32,
'first_serdes': 14,
'last_serdes': 15,
'cntx': 0,
'lpn': 32,
'gpn': 800,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/33': {
'if_id': '0x4a4',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 33,
'first_serdes': 16,
'last_serdes': 17,
'cntx': 0,
'lpn': 33,
'gpn': 801,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/34': {
'if_id': '0x51d',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 34,
'first_serdes': 18,
'last_serdes': 19,
'cntx': 0,
'lpn': 34,
'gpn': 802,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/35': {
'if_id': '0x517',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 35,
'first_serdes': 20,
'last_serdes': 21,
'cntx': 0,
'lpn': 35,
'gpn': 803,
'type': 'NIF',
'active': 'Y'
},
'HundredGigE2/0/36': {
'if_id': '0x518',
'inst': 0,
'asic': 0,
'core': 3,
'port': 0,
'subport': 0,
'mac': 36,
'first_serdes': 22,
'last_serdes': 23,
'cntx': 0,
'lpn': 36,
'gpn': 804,
'type': 'NIF',
'active': 'Y'
},
'AppGigabitEthernet2/0/1': {
'if_id': '0x4a8',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 37,
'first_serdes': 22,
'last_serdes': 22,
'cntx': 0,
'lpn': 37,
'gpn': 805,
'type': 'NIF',
'active': 'Y'
},
'AppGigabitEthernet2/0/2': {
'if_id': '0x4a9',
'inst': 0,
'asic': 0,
'core': 4,
'ifg_id': 1,
'port': 0,
'subport': 0,
'mac': 38,
'first_serdes': 23,
'last_serdes': 23,
'cntx': 0,
'lpn': 38,
'gpn': 806,
'type': 'NIF',
'active': 'Y'
}
}
} |
"""
In a town, there are n people labeled from 1 to n. There is a rumor that one of these people is secretly the town judge.
If the town judge exists, then:
The town judge trusts nobody.
Everybody (except for the town judge) trusts the town judge.
There is exactly one person that satisfies properties 1 and 2.
You are given an array trust where trust[i] = [ai, bi] representing that the person labeled ai trusts the person labeled bi.
Return the label of the town judge if the town judge exists and can be identified, or return -1 otherwise.
From leetcode : https://leetcode.com/problems/find-the-town-judge/
"""
class Solution:
def findJudge(self, n: int, trust: List[List[int]]) -> int:
count = [0] * (n + 1)
for i, j in trust:
count[i] -= 1
count[j] += 1
for i in range(1, n+1):
if count[i] == n-1:
return i
return -1
|
# DOBRO, TRIPLO E RAIZ QUADRADA
"""Lê um número e exibe seu dobro, seu triplo e sua raiz quadrada"""
n = float(input('Digite um número: _ '))
print('O dobro de {} é {:.2f}'.format(n, n * 2))
print('O triplo de {} é {:.2f}'.format(n, n * 3))
print('A raiz quadrada de {} é {:.2f}'.format(n, n ** 0.5))
|
class Solution:
def PredictTheWinner(self, nums) -> bool:
def score(start, end, player):
# player == 1 表示玩家1，player == -1 表示玩家2
# 返回当前玩家在当前状态下可以得到的最优分数（用玩家1-玩家2的差值表示）。
if start == end:
return nums[start] * player
left_score = nums[start] * player + score(start + 1, end, -player)
right_score = nums[end] * player + score(start, end - 1, -player)
if player == 1:
return max(left_score, right_score)
else:
return min(left_score, right_score)
finally_score = score(0, len(nums) - 1, 1)
return finally_score >= 0
def PredictTheWinner_2(self, nums) -> bool:
def score(start, end):
# 返回当前玩家在当前状态下可以得到的最优分数（用当前玩家-另一玩家的差值表示）。
if start == end:
return nums[start]
left_score = nums[start] - score(start + 1, end)
right_score = nums[end] - score(start, end - 1)
return max(left_score, right_score)
finally_score = score(0, len(nums) - 1)
return finally_score >= 0
def PredictTheWinner_3(self, nums) -> bool:
length = len(nums)
dp = [[0] * length for _ in range(length)] # 用列表推导建立二维数组
for i in range(length):
dp[i][i] = nums[i]
for k in range(1, length):
# k表示每一斜行
for v in range(length - k):
# v表示斜行长度
# i = f(k) + v
# j = g(k) + v
i = 0 + v
j = k + v
dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1])
return dp[0][length - 1] >= 0
if __name__ == '__main__':
solution = Solution()
nums = [1, 5, 233, 7]
print(solution.PredictTheWinner(nums))
|
n = 0
totn = 0
soma = 0
while n != 999:
soma = soma + n
n = int(input('Digite um número: '))
if n == 999:
break
totn = totn + 1
print(f'total de numeros: {totn}')
print(f'soma: {soma}')
|
{'73c02eb6f6524b1bab84ccaa733260d2': {'cmd': '$ cat '
'/home/gk/repos/terminal_markdown_viewer/src/mdv/plugins/config.py',
'res': '# fmt:off\n'
"environ_prefix = 'MDV_'\n"
'\n'
'# :docs:default_plugins\n'
'class Plugins:\n'
' # functional name = module '
'name (in user or pkg plugins '
'dir)\n'
' boxes = '
"'term_css_boxes'\n"
" color = 'color'\n"
' colors_256 = '
"'color_table_256'\n"
' colors_web = '
"'color_table_web'\n"
' conf = '
"'mdv_conf'\n"
' log = '
"'structlog'\n"
' mdparser = '
"'pymarkdown'\n"
' render = '
"'term_render'\n"
' style = '
"'term_css_style'\n"
' textmaps = '
"'term_font_textmaps.py'\n"
' theme = '
"'theme_base16'\n"
' tree_analyzer = '
"'html_beautifulsoup'\n"
'\n'
' class Actions:\n'
' colortables= '
"'colortables'\n"
" view = 'view'\n"
" help = 'help'\n"
'\n'
'# :docs:default_plugins\n'
'\n'
'class Output:\n'
' html_out = None # when given '
"we write the html here ('-' for "
'stdout)\n'
' term_out = None # when given '
"we write the ansi here ('-' set "
'as default when run from cli)\n'
' ruler = None # add a '
'horizontal ruler for terminal '
'output\n'
' \n'
'\n'
'class Logging:\n'
' # pip install structlog '
'provides nice dev logging Eats '
'around 0.03s app startup time '
'though.\n'
" log_level = 'info'\n"
'\n'
'class Terminal:\n'
' true_color = True\n'
' width = 0 # 0: '
'auto\n'
' height = 0\n'
' width_default = 80 # '
'fallback\n'
' height_default = 24\n'
'\n'
'class Markdown:\n'
' rm_spaces = True\n'
' tab_length = 4\n'
" sample_text = '''# "
'H1\\nHello *World!* from '
"mdv!'''\n"
'\n'
'\n'
'class Styling:\n'
' # those are initialized with '
'display: inline even w/o a '
'stylesheet:\n'
" inline_tags = ['em', "
"'strong', 'b', 'code', 'del', "
"'super', 'sub']\n"
" theme = 'theme_base16' \n"
" css_file = '' # requires "
'pip install cssutils\n'
'\n'
' class Variables:\n'
' class Text:\n'
" hr_sep = '─'\n"
" txt_block_cut = '✂'\n"
" code_pref = '| "
"'\n"
" list_pref = '- "
"'\n"
" bquote_pref = '|'\n"
" hr_ends = '◈'\n"
'\n'
' class Cells:\n'
" H1 = '1;33'\n"
" H2 = '1;32'\n"
" H3 = '1;35'\n"
" H4 = '1;35'\n"
" H5 = '1;34'\n"
" R = '31'\n"
" L = '2;90'\n"
" BG = '30'\n"
" BGL = '30'\n"
" D = ''\n"
" T = '36'\n"
" C = '3;100;97'\n"
" EM = '3;31'\n"
" STRONG = '1;32;41'\n"
' CH1, CH2, CH3, CH4, '
'CH5 = H1, H2, H3, H4, H5\n'
'\n'
' class Admonitions:\n'
" attention = 'H1'\n"
" caution = 'H2'\n"
" danger = 'R'\n"
" dev = 'H5'\n"
" hint = 'H4'\n"
" note = 'H3'\n"
" question = 'H5'\n"
" summary = 'H1'\n"
" warning = 'R'\n"
'\n'
' class Code:\n'
' def_lexer = '
"'python'\n"
' guess_lexer = True\n'
'\n'
' class Highlight:\n'
" Comment = 'L'\n"
" Error = 'R'\n"
' Generic = '
"'CH2'\n"
' Keyword = '
"'CH3'\n"
' Name = '
"'CH1'\n"
' Number = '
"'CH4'\n"
' Operator = '
"'CH5'\n"
' String = '
"'CH4'\n"
'\n'
'\n'
' class CSS:\n'
" BQ = {'border': "
"'2 solid H1'}\n"
" UL = {'padding': "
'2}\n'
" OL = {'padding': "
'2}\n'
'\n'
'\n'
'# ansi cols (default):\n'
'# Convention:\n'
'# Numbers are the ansi 256 color '
'codes (those are independent of '
'your terminal theme)\n'
'# Strings: Ansi code as is.\n'
'# Example: 124 rendered '
"identical as '38;5;124' or 'H4' "
'if H4 then is 124\n'
'# The string form allows to set '
'also underlined, bold, (...) if '
'your term supports it.\n'
'# See e.g.: '
'https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences/33206814#33206814\n'
'\n'
'# Semantics:\n'
'# R: Red (warnings), L: low '
'visi, BG: background, BGL: '
'background light, C=code\n'
'# H1 - H5 = the color theme.\n'
'\n'
'\n'
'# , # H1: bold yellow\n'
'# , # bold green\n'
'# , # bold cyan\n'
'# , # bold magenta\n'
'# , # H5 bold blue\n'
'# , # R red\n'
'# , # L dimmed bright black '
'-> rendered as gray usually\n'
'# , # black\n'
'# , # black\n'
"# '', # D: document (outer "
'div)\n'
'# , # T(ext) white\n'
'# , # C(ode) italic bright '
'b/w bg and fg\n'
"# '3;31', # em italics\n"
"# '1;32;41', # bold\n"
"# {'border': '2 solid H1'},\n"
'# # {\n'
"# # 'ansi': '1;32',\n"
"# # 'border': '1 solid "
"H1',\n"
"# # 'border-right': '2 "
"dashed H2',\n"
"# # 'border-left': '3 "
"solid H2',\n"
"# # 'margin': 1,\n"
"# # 'padding': 2,\n"
'# # },\n'
"# {'border': '2 solid H1'},\n"
"# {'padding': 2, 'ansi': "
"'H2'},\n"
'# )\n'
'# # normal text color:\n'
"# color = 'T'\n"
'\n'
'# # terminal columns (width). 0 '
'-> autodetect or use from cli\n'
'# col = 0\n'
'\n'
'# # hirarchical indentation by:\n'
"# left_indent = ' '\n"
'\n'
"# link_start = '①'\n"
'# link_start_ord = '
'ord(link_start)\n'
'\n'
"# log_level = 'debug'\n"
'\n'
'# # it: inline table, h: hide, '
'i: inline\n'
"# show_links = 'it'\n"
'\n'
'# tab_length = 4\n'
'\n'
'# # could be given, otherwise '
'read from ansi_tables.json:\n'
'# themes = {}\n'
'\n'
'\n'
'# # sample for the theme roller '
'feature:\n'
"# md_sample = ''\n"
'\n'
'# # dir monitor recursion max:\n'
'# mon_max_files = 1000\n'
'\n'
'# rm_spaces = True\n'
'\n'
"# sample_text = '''\n"
'# # H1\n'
'\n'
'# Hello *World!*\n'
"# '''\n"
'\n'
'# '
'------------------------------------------------------------------ '
'End Config\n'}} |
class Hero:
def __init__(self, nama, attack,health,defense):
self.name = nama
self.attack = attack
self.health = health
self.defense = defense
|
def compress(string):
counter = 1
result = []
for i in range(len(string)):
if not (i + 1) == len(string) and string[i] == string[i + 1]:
counter += 1
else:
result.append(string[i] + str(counter))
counter = 1
final = "".join(result)
if len(string) > len(final):
return final
return string
print(compress('rrrrrrqqqqqqaaaaddddaaaadda')) |
__project__ = "nerblackbox"
__author__ = "Felix Stollenwerk"
__version__ = "0.0.13"
__license__ = "Apache 2.0"
|
s=input()
s=s.split(" ")
n=int(s[0])
k=int(s[1])
m=n//2
if n%2==1:
m+=1
if k<=m:
print(2*k-1)
else:
k=k-m
print(2*k) |
class ImproperlyConfigured(Exception):
""" Raised in the event ``operations-api`` has not been properly configured
"""
pass
class HTTPError(Exception):
""" Raised in the event ``operations-api`` was not able to get data from remote server
"""
pass
|
def merge(A, n1i, n2j):
for k in range(len(A)):
if(len(n2j) == 0 and len(n1i) != 0):
A[k] = n1i.pop(0);
elif(len(n1i) == 0 and len(n2j) != 0):
A[k] = n2j.pop(0);
else:
if(n1i[0] >= n2j[0]):
A[k] = n1i.pop(0);
else:
A[k] = n2j.pop(0);
return A;
def merge_sort(A):
div = (len(A)//2);
n1i = A[:div];
n2j = A[div:];
if(len(A) > 2):
merge_sort(n1i);
merge_sort(n2j);
merge(A, n1i, n2j);
else:
merge(A, n1i, n2j);
A = [1 ,35, 7, 5, 46,
2, 47, 8, 4, 6,
8, 42, 378, 418,
4, 35, 78, 6, 48,
375, 78, 348, 7, 8];
"""
def merge(A, n1i, n2j):
i = 0;
j = 0;
n1i.append(-269970676);
n2j.append(-269970676);
for k in range(len(A)):
if(n1i[i] >= n2j[j]):
A[k] = n1i[i];
i += 1;
else:
A[k] = n2j[j];
j += 1;
return A;
""" |
class Solution:
d = {
'I': 1,
'V': 5,
'X': 10,
'L': 50,
'C': 100,
'D': 500,
'M': 1000,
'IV': 4,
'IX': 9,
'XL': 40,
'XC': 90,
'CD': 400,
'CM': 900
}
def romanToInt(self, s):
n,i = 0,0
while i < len(s):
if i + 1 < len(s) and s[i: i + 2] in Solution.d:
n += Solution.d[s[i: i + 2]]
i += 2
else:
n += Solution.d.get(s[i], 0)
i += 1
return n
|
def between_markers(text: str, begin: str, end: str) -> str:
"""
returns substring between two given markers
"""
return ('' if len(text.split(begin)[0]) > len(text.split(end)[0]) and
begin in text and end in text else
text.split(begin)[-1].split(end)[0] if begin in text and
end in text else
text.split(begin)[-1] if begin in text else
text.split(end)[0] if end in text else text)
if __name__ == '__main__':
print('Example:')
print(between_markers('What is >apple<', '>', '<'))
# These "asserts" are used for self-checking and not for testing
assert between_markers('What is >apple<', '>', '<') == "apple", "One sym"
assert between_markers("<head><title>My new site</title></head>",
"<title>", "</title>") == "My new site", "HTML"
assert between_markers('No[/b] hi', '[b]', '[/b]') == 'No', 'No opened'
assert between_markers('No [b]hi', '[b]', '[/b]') == 'hi', 'No close'
assert between_markers('No hi', '[b]', '[/b]') == 'No hi', 'No markers at all'
assert between_markers('No <hi>', '>', '<') == '', 'Wrong direction'
print('Wow, you are doing pretty good. Time to check it!')
|
class Person:
def __init__(self, fname, lname):
self.fname = fname
self.lname = lname
def __repr__(self):
return f'{self.fname} {self.lname}'
p1 = Person('John', 'Smith')
class Student(Person):
pass
if __name__ == '__main__':
s = Student('Tom', 'Adams')
print(s)
print(isinstance(s, Student))
print(isinstance(s, Person))
print(issubclass(Student, Person))
|
# Solution to exercise PermMissingElem
# http://www.codility.com/train/
def solution(A):
N = len(A)
# The array with the missing entry added should sum to (N+2)(N+1)/2
# so the missing entry can be determined by subtracting the sum of
# the entries of A
missing_element = (N+2)*(N+1)/2 - sum(A)
return missing_element
|
with open("input.txt") as f:
lines = f.readlines()
S = lines.pop(0).strip()
lines.pop(0)
rules = {}
for r in lines:
s = r.strip().split(" -> ")
rules[s[0]] = s[1]
for n in range(10):
S = S[0] + "".join(list(map(lambda x,y: rules[x+y] + y, S[0:-1], S[1:])))
# Histogram
f = {}
for c in S:
f[c] = f.get(c,0) + 1
print(max(f.values()) - min(f.values()))
|
class dataManager():
""" This class manage all data about scores and teams """
def __init__(self):
""" Constructor """
self.choix = 0
self.nameBlueTeam = ""
self.nameGreyTeam = ""
self.nameBlackTeam = ""
|
"""
A Libraray to initilize the avaiable modules and data structures
"""
|
class Solution:
def countArrangement(self, n: int) -> int:
state = '1' * n
# dp[state] means number of targ arrangement
# easily dp[state] = sum(dp[possible_next_state])
dp = {}
dp['0'*n] = 1
def dfs(state_now, index):
# basic
if state_now in dp:
return dp[state_now]
else:
dp[state_now] = 0
for i in range(len(state_now)):
if state_now[i] == '1':
if (i + 1 > index and (i + 1) % index == 0) or (i + 1 < index and index % (i + 1) == 0) or index == i + 1:
next_state = state_now[0:i] + '0' + state_now[i+1:]
dp[state_now] += dfs(next_state, index+1)
return dp[state_now]
return dfs(state, 1)
|
# AUTOGENERATED BY NBDEV! DO NOT EDIT!
__all__ = ["index", "modules", "custom_doc_links", "git_url"]
index = {"AlreadyImportedError": "00_core.ipynb",
"InvalidFilePath": "00_core.ipynb",
"InvalidFolderPath": "00_core.ipynb",
"InvalidFileExtension": "00_core.ipynb",
"Pdf": "00_core.ipynb"}
modules = ["core.py"]
doc_url = "https://fabraz.github.io/vigilant/"
git_url = "https://github.com/fabraz/fastagger/tree/master/"
def custom_doc_links(name): return None
|
class Solution:
def maxPower(self, s: str) -> int:
ans = cur = 0
prev = ''
for c in s:
if c == prev:
cur += 1
else:
cur = 1
prev = c
if cur > ans:
ans = cur
return ans |
"""AyudaEnPython: https://www.facebook.com/groups/ayudapython
"""
suma = 0
# si son 100 personas, se cambia 10 por 100 (dentro de range)
for _ in range(10):
peso = float(input("Ingresar peso: "))
suma += peso
print(f"Peso acumulado {suma}") |
class CommandError(Exception):
def __init__(self, msg):
self.msg = msg
class SilentError(Exception):
# log and drop, don't reveal details to caller. The timing difference is
# ok.
pass
class ReplayError(Exception):
pass
class WrongVerfkeyError(Exception):
pass
class BadSignatureError(Exception):
pass
class UnknownChannelError(Exception):
"""Message not decryptable by any of our channels."""
class ContactNotReadyError(Exception):
pass
|
# For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT [x86_const.py]
X86_REG_INVALID = 0
X86_REG_AH = 1
X86_REG_AL = 2
X86_REG_AX = 3
X86_REG_BH = 4
X86_REG_BL = 5
X86_REG_BP = 6
X86_REG_BPL = 7
X86_REG_BX = 8
X86_REG_CH = 9
X86_REG_CL = 10
X86_REG_CS = 11
X86_REG_CX = 12
X86_REG_DH = 13
X86_REG_DI = 14
X86_REG_DIL = 15
X86_REG_DL = 16
X86_REG_DS = 17
X86_REG_DX = 18
X86_REG_EAX = 19
X86_REG_EBP = 20
X86_REG_EBX = 21
X86_REG_ECX = 22
X86_REG_EDI = 23
X86_REG_EDX = 24
X86_REG_EFLAGS = 25
X86_REG_EIP = 26
X86_REG_EIZ = 27
X86_REG_ES = 28
X86_REG_ESI = 29
X86_REG_ESP = 30
X86_REG_FPSW = 31
X86_REG_FS = 32
X86_REG_GS = 33
X86_REG_IP = 34
X86_REG_RAX = 35
X86_REG_RBP = 36
X86_REG_RBX = 37
X86_REG_RCX = 38
X86_REG_RDI = 39
X86_REG_RDX = 40
X86_REG_RIP = 41
X86_REG_RIZ = 42
X86_REG_RSI = 43
X86_REG_RSP = 44
X86_REG_SI = 45
X86_REG_SIL = 46
X86_REG_SP = 47
X86_REG_SPL = 48
X86_REG_SS = 49
X86_REG_CR0 = 50
X86_REG_CR1 = 51
X86_REG_CR2 = 52
X86_REG_CR3 = 53
X86_REG_CR4 = 54
X86_REG_CR5 = 55
X86_REG_CR6 = 56
X86_REG_CR7 = 57
X86_REG_CR8 = 58
X86_REG_CR9 = 59
X86_REG_CR10 = 60
X86_REG_CR11 = 61
X86_REG_CR12 = 62
X86_REG_CR13 = 63
X86_REG_CR14 = 64
X86_REG_CR15 = 65
X86_REG_DR0 = 66
X86_REG_DR1 = 67
X86_REG_DR2 = 68
X86_REG_DR3 = 69
X86_REG_DR4 = 70
X86_REG_DR5 = 71
X86_REG_DR6 = 72
X86_REG_DR7 = 73
X86_REG_DR8 = 74
X86_REG_DR9 = 75
X86_REG_DR10 = 76
X86_REG_DR11 = 77
X86_REG_DR12 = 78
X86_REG_DR13 = 79
X86_REG_DR14 = 80
X86_REG_DR15 = 81
X86_REG_FP0 = 82
X86_REG_FP1 = 83
X86_REG_FP2 = 84
X86_REG_FP3 = 85
X86_REG_FP4 = 86
X86_REG_FP5 = 87
X86_REG_FP6 = 88
X86_REG_FP7 = 89
X86_REG_K0 = 90
X86_REG_K1 = 91
X86_REG_K2 = 92
X86_REG_K3 = 93
X86_REG_K4 = 94
X86_REG_K5 = 95
X86_REG_K6 = 96
X86_REG_K7 = 97
X86_REG_MM0 = 98
X86_REG_MM1 = 99
X86_REG_MM2 = 100
X86_REG_MM3 = 101
X86_REG_MM4 = 102
X86_REG_MM5 = 103
X86_REG_MM6 = 104
X86_REG_MM7 = 105
X86_REG_R8 = 106
X86_REG_R9 = 107
X86_REG_R10 = 108
X86_REG_R11 = 109
X86_REG_R12 = 110
X86_REG_R13 = 111
X86_REG_R14 = 112
X86_REG_R15 = 113
X86_REG_ST0 = 114
X86_REG_ST1 = 115
X86_REG_ST2 = 116
X86_REG_ST3 = 117
X86_REG_ST4 = 118
X86_REG_ST5 = 119
X86_REG_ST6 = 120
X86_REG_ST7 = 121
X86_REG_XMM0 = 122
X86_REG_XMM1 = 123
X86_REG_XMM2 = 124
X86_REG_XMM3 = 125
X86_REG_XMM4 = 126
X86_REG_XMM5 = 127
X86_REG_XMM6 = 128
X86_REG_XMM7 = 129
X86_REG_XMM8 = 130
X86_REG_XMM9 = 131
X86_REG_XMM10 = 132
X86_REG_XMM11 = 133
X86_REG_XMM12 = 134
X86_REG_XMM13 = 135
X86_REG_XMM14 = 136
X86_REG_XMM15 = 137
X86_REG_XMM16 = 138
X86_REG_XMM17 = 139
X86_REG_XMM18 = 140
X86_REG_XMM19 = 141
X86_REG_XMM20 = 142
X86_REG_XMM21 = 143
X86_REG_XMM22 = 144
X86_REG_XMM23 = 145
X86_REG_XMM24 = 146
X86_REG_XMM25 = 147
X86_REG_XMM26 = 148
X86_REG_XMM27 = 149
X86_REG_XMM28 = 150
X86_REG_XMM29 = 151
X86_REG_XMM30 = 152
X86_REG_XMM31 = 153
X86_REG_YMM0 = 154
X86_REG_YMM1 = 155
X86_REG_YMM2 = 156
X86_REG_YMM3 = 157
X86_REG_YMM4 = 158
X86_REG_YMM5 = 159
X86_REG_YMM6 = 160
X86_REG_YMM7 = 161
X86_REG_YMM8 = 162
X86_REG_YMM9 = 163
X86_REG_YMM10 = 164
X86_REG_YMM11 = 165
X86_REG_YMM12 = 166
X86_REG_YMM13 = 167
X86_REG_YMM14 = 168
X86_REG_YMM15 = 169
X86_REG_YMM16 = 170
X86_REG_YMM17 = 171
X86_REG_YMM18 = 172
X86_REG_YMM19 = 173
X86_REG_YMM20 = 174
X86_REG_YMM21 = 175
X86_REG_YMM22 = 176
X86_REG_YMM23 = 177
X86_REG_YMM24 = 178
X86_REG_YMM25 = 179
X86_REG_YMM26 = 180
X86_REG_YMM27 = 181
X86_REG_YMM28 = 182
X86_REG_YMM29 = 183
X86_REG_YMM30 = 184
X86_REG_YMM31 = 185
X86_REG_ZMM0 = 186
X86_REG_ZMM1 = 187
X86_REG_ZMM2 = 188
X86_REG_ZMM3 = 189
X86_REG_ZMM4 = 190
X86_REG_ZMM5 = 191
X86_REG_ZMM6 = 192
X86_REG_ZMM7 = 193
X86_REG_ZMM8 = 194
X86_REG_ZMM9 = 195
X86_REG_ZMM10 = 196
X86_REG_ZMM11 = 197
X86_REG_ZMM12 = 198
X86_REG_ZMM13 = 199
X86_REG_ZMM14 = 200
X86_REG_ZMM15 = 201
X86_REG_ZMM16 = 202
X86_REG_ZMM17 = 203
X86_REG_ZMM18 = 204
X86_REG_ZMM19 = 205
X86_REG_ZMM20 = 206
X86_REG_ZMM21 = 207
X86_REG_ZMM22 = 208
X86_REG_ZMM23 = 209
X86_REG_ZMM24 = 210
X86_REG_ZMM25 = 211
X86_REG_ZMM26 = 212
X86_REG_ZMM27 = 213
X86_REG_ZMM28 = 214
X86_REG_ZMM29 = 215
X86_REG_ZMM30 = 216
X86_REG_ZMM31 = 217
X86_REG_R8B = 218
X86_REG_R9B = 219
X86_REG_R10B = 220
X86_REG_R11B = 221
X86_REG_R12B = 222
X86_REG_R13B = 223
X86_REG_R14B = 224
X86_REG_R15B = 225
X86_REG_R8D = 226
X86_REG_R9D = 227
X86_REG_R10D = 228
X86_REG_R11D = 229
X86_REG_R12D = 230
X86_REG_R13D = 231
X86_REG_R14D = 232
X86_REG_R15D = 233
X86_REG_R8W = 234
X86_REG_R9W = 235
X86_REG_R10W = 236
X86_REG_R11W = 237
X86_REG_R12W = 238
X86_REG_R13W = 239
X86_REG_R14W = 240
X86_REG_R15W = 241
X86_REG_BND0 = 242
X86_REG_BND1 = 243
X86_REG_BND2 = 244
X86_REG_BND3 = 245
X86_REG_ENDING = 246
X86_EFLAGS_MODIFY_AF = 1<<0
X86_EFLAGS_MODIFY_CF = 1<<1
X86_EFLAGS_MODIFY_SF = 1<<2
X86_EFLAGS_MODIFY_ZF = 1<<3
X86_EFLAGS_MODIFY_PF = 1<<4
X86_EFLAGS_MODIFY_OF = 1<<5
X86_EFLAGS_MODIFY_TF = 1<<6
X86_EFLAGS_MODIFY_IF = 1<<7
X86_EFLAGS_MODIFY_DF = 1<<8
X86_EFLAGS_MODIFY_NT = 1<<9
X86_EFLAGS_MODIFY_RF = 1<<10
X86_EFLAGS_PRIOR_OF = 1<<11
X86_EFLAGS_PRIOR_SF = 1<<12
X86_EFLAGS_PRIOR_ZF = 1<<13
X86_EFLAGS_PRIOR_AF = 1<<14
X86_EFLAGS_PRIOR_PF = 1<<15
X86_EFLAGS_PRIOR_CF = 1<<16
X86_EFLAGS_PRIOR_TF = 1<<17
X86_EFLAGS_PRIOR_IF = 1<<18
X86_EFLAGS_PRIOR_DF = 1<<19
X86_EFLAGS_PRIOR_NT = 1<<20
X86_EFLAGS_RESET_OF = 1<<21
X86_EFLAGS_RESET_CF = 1<<22
X86_EFLAGS_RESET_DF = 1<<23
X86_EFLAGS_RESET_IF = 1<<24
X86_EFLAGS_RESET_SF = 1<<25
X86_EFLAGS_RESET_AF = 1<<26
X86_EFLAGS_RESET_TF = 1<<27
X86_EFLAGS_RESET_NT = 1<<28
X86_EFLAGS_RESET_PF = 1<<29
X86_EFLAGS_SET_CF = 1<<30
X86_EFLAGS_SET_DF = 1<<31
X86_EFLAGS_SET_IF = 1<<32
X86_EFLAGS_TEST_OF = 1<<33
X86_EFLAGS_TEST_SF = 1<<34
X86_EFLAGS_TEST_ZF = 1<<35
X86_EFLAGS_TEST_PF = 1<<36
X86_EFLAGS_TEST_CF = 1<<37
X86_EFLAGS_TEST_NT = 1<<38
X86_EFLAGS_TEST_DF = 1<<39
X86_EFLAGS_UNDEFINED_OF = 1<<40
X86_EFLAGS_UNDEFINED_SF = 1<<41
X86_EFLAGS_UNDEFINED_ZF = 1<<42
X86_EFLAGS_UNDEFINED_PF = 1<<43
X86_EFLAGS_UNDEFINED_AF = 1<<44
X86_EFLAGS_UNDEFINED_CF = 1<<45
X86_EFLAGS_RESET_RF = 1<<46
X86_EFLAGS_TEST_RF = 1<<47
X86_EFLAGS_TEST_IF = 1<<48
X86_EFLAGS_TEST_TF = 1<<49
X86_EFLAGS_TEST_AF = 1<<50
X86_EFLAGS_RESET_ZF = 1<<51
X86_EFLAGS_SET_OF = 1<<52
X86_EFLAGS_SET_SF = 1<<53
X86_EFLAGS_SET_ZF = 1<<54
X86_EFLAGS_SET_AF = 1<<55
X86_EFLAGS_SET_PF = 1<<56
X86_EFLAGS_RESET_0F = 1<<57
X86_EFLAGS_RESET_AC = 1<<58
X86_FPU_FLAGS_MODIFY_C0 = 1<<0
X86_FPU_FLAGS_MODIFY_C1 = 1<<1
X86_FPU_FLAGS_MODIFY_C2 = 1<<2
X86_FPU_FLAGS_MODIFY_C3 = 1<<3
X86_FPU_FLAGS_RESET_C0 = 1<<4
X86_FPU_FLAGS_RESET_C1 = 1<<5
X86_FPU_FLAGS_RESET_C2 = 1<<6
X86_FPU_FLAGS_RESET_C3 = 1<<7
X86_FPU_FLAGS_SET_C0 = 1<<8
X86_FPU_FLAGS_SET_C1 = 1<<9
X86_FPU_FLAGS_SET_C2 = 1<<10
X86_FPU_FLAGS_SET_C3 = 1<<11
X86_FPU_FLAGS_UNDEFINED_C0 = 1<<12
X86_FPU_FLAGS_UNDEFINED_C1 = 1<<13
X86_FPU_FLAGS_UNDEFINED_C2 = 1<<14
X86_FPU_FLAGS_UNDEFINED_C3 = 1<<15
X86_FPU_FLAGS_TEST_C0 = 1<<16
X86_FPU_FLAGS_TEST_C1 = 1<<17
X86_FPU_FLAGS_TEST_C2 = 1<<18
X86_FPU_FLAGS_TEST_C3 = 1<<19
X86_OP_INVALID = 0
X86_OP_REG = 1
X86_OP_IMM = 2
X86_OP_MEM = 3
X86_XOP_CC_INVALID = 0
X86_XOP_CC_LT = 1
X86_XOP_CC_LE = 2
X86_XOP_CC_GT = 3
X86_XOP_CC_GE = 4
X86_XOP_CC_EQ = 5
X86_XOP_CC_NEQ = 6
X86_XOP_CC_FALSE = 7
X86_XOP_CC_TRUE = 8
X86_AVX_BCAST_INVALID = 0
X86_AVX_BCAST_2 = 1
X86_AVX_BCAST_4 = 2
X86_AVX_BCAST_8 = 3
X86_AVX_BCAST_16 = 4
X86_SSE_CC_INVALID = 0
X86_SSE_CC_EQ = 1
X86_SSE_CC_LT = 2
X86_SSE_CC_LE = 3
X86_SSE_CC_UNORD = 4
X86_SSE_CC_NEQ = 5
X86_SSE_CC_NLT = 6
X86_SSE_CC_NLE = 7
X86_SSE_CC_ORD = 8
X86_AVX_CC_INVALID = 0
X86_AVX_CC_EQ = 1
X86_AVX_CC_LT = 2
X86_AVX_CC_LE = 3
X86_AVX_CC_UNORD = 4
X86_AVX_CC_NEQ = 5
X86_AVX_CC_NLT = 6
X86_AVX_CC_NLE = 7
X86_AVX_CC_ORD = 8
X86_AVX_CC_EQ_UQ = 9
X86_AVX_CC_NGE = 10
X86_AVX_CC_NGT = 11
X86_AVX_CC_FALSE = 12
X86_AVX_CC_NEQ_OQ = 13
X86_AVX_CC_GE = 14
X86_AVX_CC_GT = 15
X86_AVX_CC_TRUE = 16
X86_AVX_CC_EQ_OS = 17
X86_AVX_CC_LT_OQ = 18
X86_AVX_CC_LE_OQ = 19
X86_AVX_CC_UNORD_S = 20
X86_AVX_CC_NEQ_US = 21
X86_AVX_CC_NLT_UQ = 22
X86_AVX_CC_NLE_UQ = 23
X86_AVX_CC_ORD_S = 24
X86_AVX_CC_EQ_US = 25
X86_AVX_CC_NGE_UQ = 26
X86_AVX_CC_NGT_UQ = 27
X86_AVX_CC_FALSE_OS = 28
X86_AVX_CC_NEQ_OS = 29
X86_AVX_CC_GE_OQ = 30
X86_AVX_CC_GT_OQ = 31
X86_AVX_CC_TRUE_US = 32
X86_AVX_RM_INVALID = 0
X86_AVX_RM_RN = 1
X86_AVX_RM_RD = 2
X86_AVX_RM_RU = 3
X86_AVX_RM_RZ = 4
X86_PREFIX_LOCK = 0xf0
X86_PREFIX_REP = 0xf3
X86_PREFIX_REPE = 0xf3
X86_PREFIX_REPNE = 0xf2
X86_PREFIX_CS = 0x2e
X86_PREFIX_SS = 0x36
X86_PREFIX_DS = 0x3e
X86_PREFIX_ES = 0x26
X86_PREFIX_FS = 0x64
X86_PREFIX_GS = 0x65
X86_PREFIX_OPSIZE = 0x66
X86_PREFIX_ADDRSIZE = 0x67
X86_INS_INVALID = 0
X86_INS_AAA = 1
X86_INS_AAD = 2
X86_INS_AAM = 3
X86_INS_AAS = 4
X86_INS_FABS = 5
X86_INS_ADC = 6
X86_INS_ADCX = 7
X86_INS_ADD = 8
X86_INS_ADDPD = 9
X86_INS_ADDPS = 10
X86_INS_ADDSD = 11
X86_INS_ADDSS = 12
X86_INS_ADDSUBPD = 13
X86_INS_ADDSUBPS = 14
X86_INS_FADD = 15
X86_INS_FIADD = 16
X86_INS_ADOX = 17
X86_INS_AESDECLAST = 18
X86_INS_AESDEC = 19
X86_INS_AESENCLAST = 20
X86_INS_AESENC = 21
X86_INS_AESIMC = 22
X86_INS_AESKEYGENASSIST = 23
X86_INS_AND = 24
X86_INS_ANDN = 25
X86_INS_ANDNPD = 26
X86_INS_ANDNPS = 27
X86_INS_ANDPD = 28
X86_INS_ANDPS = 29
X86_INS_ARPL = 30
X86_INS_BEXTR = 31
X86_INS_BLCFILL = 32
X86_INS_BLCI = 33
X86_INS_BLCIC = 34
X86_INS_BLCMSK = 35
X86_INS_BLCS = 36
X86_INS_BLENDPD = 37
X86_INS_BLENDPS = 38
X86_INS_BLENDVPD = 39
X86_INS_BLENDVPS = 40
X86_INS_BLSFILL = 41
X86_INS_BLSI = 42
X86_INS_BLSIC = 43
X86_INS_BLSMSK = 44
X86_INS_BLSR = 45
X86_INS_BNDCL = 46
X86_INS_BNDCN = 47
X86_INS_BNDCU = 48
X86_INS_BNDLDX = 49
X86_INS_BNDMK = 50
X86_INS_BNDMOV = 51
X86_INS_BNDSTX = 52
X86_INS_BOUND = 53
X86_INS_BSF = 54
X86_INS_BSR = 55
X86_INS_BSWAP = 56
X86_INS_BT = 57
X86_INS_BTC = 58
X86_INS_BTR = 59
X86_INS_BTS = 60
X86_INS_BZHI = 61
X86_INS_CALL = 62
X86_INS_CBW = 63
X86_INS_CDQ = 64
X86_INS_CDQE = 65
X86_INS_FCHS = 66
X86_INS_CLAC = 67
X86_INS_CLC = 68
X86_INS_CLD = 69
X86_INS_CLDEMOTE = 70
X86_INS_CLFLUSH = 71
X86_INS_CLFLUSHOPT = 72
X86_INS_CLGI = 73
X86_INS_CLI = 74
X86_INS_CLRSSBSY = 75
X86_INS_CLTS = 76
X86_INS_CLWB = 77
X86_INS_CLZERO = 78
X86_INS_CMC = 79
X86_INS_CMOVA = 80
X86_INS_CMOVAE = 81
X86_INS_CMOVB = 82
X86_INS_CMOVBE = 83
X86_INS_FCMOVBE = 84
X86_INS_FCMOVB = 85
X86_INS_CMOVE = 86
X86_INS_FCMOVE = 87
X86_INS_CMOVG = 88
X86_INS_CMOVGE = 89
X86_INS_CMOVL = 90
X86_INS_CMOVLE = 91
X86_INS_FCMOVNBE = 92
X86_INS_FCMOVNB = 93
X86_INS_CMOVNE = 94
X86_INS_FCMOVNE = 95
X86_INS_CMOVNO = 96
X86_INS_CMOVNP = 97
X86_INS_FCMOVNU = 98
X86_INS_FCMOVNP = 99
X86_INS_CMOVNS = 100
X86_INS_CMOVO = 101
X86_INS_CMOVP = 102
X86_INS_FCMOVU = 103
X86_INS_CMOVS = 104
X86_INS_CMP = 105
X86_INS_CMPPD = 106
X86_INS_CMPPS = 107
X86_INS_CMPSB = 108
X86_INS_CMPSD = 109
X86_INS_CMPSQ = 110
X86_INS_CMPSS = 111
X86_INS_CMPSW = 112
X86_INS_CMPXCHG16B = 113
X86_INS_CMPXCHG = 114
X86_INS_CMPXCHG8B = 115
X86_INS_COMISD = 116
X86_INS_COMISS = 117
X86_INS_FCOMP = 118
X86_INS_FCOMPI = 119
X86_INS_FCOMI = 120
X86_INS_FCOM = 121
X86_INS_FCOS = 122
X86_INS_CPUID = 123
X86_INS_CQO = 124
X86_INS_CRC32 = 125
X86_INS_CVTDQ2PD = 126
X86_INS_CVTDQ2PS = 127
X86_INS_CVTPD2DQ = 128
X86_INS_CVTPD2PS = 129
X86_INS_CVTPS2DQ = 130
X86_INS_CVTPS2PD = 131
X86_INS_CVTSD2SI = 132
X86_INS_CVTSD2SS = 133
X86_INS_CVTSI2SD = 134
X86_INS_CVTSI2SS = 135
X86_INS_CVTSS2SD = 136
X86_INS_CVTSS2SI = 137
X86_INS_CVTTPD2DQ = 138
X86_INS_CVTTPS2DQ = 139
X86_INS_CVTTSD2SI = 140
X86_INS_CVTTSS2SI = 141
X86_INS_CWD = 142
X86_INS_CWDE = 143
X86_INS_DAA = 144
X86_INS_DAS = 145
X86_INS_DATA16 = 146
X86_INS_DEC = 147
X86_INS_DIV = 148
X86_INS_DIVPD = 149
X86_INS_DIVPS = 150
X86_INS_FDIVR = 151
X86_INS_FIDIVR = 152
X86_INS_FDIVRP = 153
X86_INS_DIVSD = 154
X86_INS_DIVSS = 155
X86_INS_FDIV = 156
X86_INS_FIDIV = 157
X86_INS_FDIVP = 158
X86_INS_DPPD = 159
X86_INS_DPPS = 160
X86_INS_ENCLS = 161
X86_INS_ENCLU = 162
X86_INS_ENCLV = 163
X86_INS_ENDBR32 = 164
X86_INS_ENDBR64 = 165
X86_INS_ENTER = 166
X86_INS_EXTRACTPS = 167
X86_INS_EXTRQ = 168
X86_INS_F2XM1 = 169
X86_INS_LCALL = 170
X86_INS_LJMP = 171
X86_INS_JMP = 172
X86_INS_FBLD = 173
X86_INS_FBSTP = 174
X86_INS_FCOMPP = 175
X86_INS_FDECSTP = 176
X86_INS_FDISI8087_NOP = 177
X86_INS_FEMMS = 178
X86_INS_FENI8087_NOP = 179
X86_INS_FFREE = 180
X86_INS_FFREEP = 181
X86_INS_FICOM = 182
X86_INS_FICOMP = 183
X86_INS_FINCSTP = 184
X86_INS_FLDCW = 185
X86_INS_FLDENV = 186
X86_INS_FLDL2E = 187
X86_INS_FLDL2T = 188
X86_INS_FLDLG2 = 189
X86_INS_FLDLN2 = 190
X86_INS_FLDPI = 191
X86_INS_FNCLEX = 192
X86_INS_FNINIT = 193
X86_INS_FNOP = 194
X86_INS_FNSTCW = 195
X86_INS_FNSTSW = 196
X86_INS_FPATAN = 197
X86_INS_FSTPNCE = 198
X86_INS_FPREM = 199
X86_INS_FPREM1 = 200
X86_INS_FPTAN = 201
X86_INS_FRNDINT = 202
X86_INS_FRSTOR = 203
X86_INS_FNSAVE = 204
X86_INS_FSCALE = 205
X86_INS_FSETPM = 206
X86_INS_FSINCOS = 207
X86_INS_FNSTENV = 208
X86_INS_FXAM = 209
X86_INS_FXRSTOR = 210
X86_INS_FXRSTOR64 = 211
X86_INS_FXSAVE = 212
X86_INS_FXSAVE64 = 213
X86_INS_FXTRACT = 214
X86_INS_FYL2X = 215
X86_INS_FYL2XP1 = 216
X86_INS_GETSEC = 217
X86_INS_GF2P8AFFINEINVQB = 218
X86_INS_GF2P8AFFINEQB = 219
X86_INS_GF2P8MULB = 220
X86_INS_HADDPD = 221
X86_INS_HADDPS = 222
X86_INS_HLT = 223
X86_INS_HSUBPD = 224
X86_INS_HSUBPS = 225
X86_INS_IDIV = 226
X86_INS_FILD = 227
X86_INS_IMUL = 228
X86_INS_IN = 229
X86_INS_INC = 230
X86_INS_INCSSPD = 231
X86_INS_INCSSPQ = 232
X86_INS_INSB = 233
X86_INS_INSERTPS = 234
X86_INS_INSERTQ = 235
X86_INS_INSD = 236
X86_INS_INSW = 237
X86_INS_INT = 238
X86_INS_INT1 = 239
X86_INS_INT3 = 240
X86_INS_INTO = 241
X86_INS_INVD = 242
X86_INS_INVEPT = 243
X86_INS_INVLPG = 244
X86_INS_INVLPGA = 245
X86_INS_INVPCID = 246
X86_INS_INVVPID = 247
X86_INS_IRET = 248
X86_INS_IRETD = 249
X86_INS_IRETQ = 250
X86_INS_FISTTP = 251
X86_INS_FIST = 252
X86_INS_FISTP = 253
X86_INS_JAE = 254
X86_INS_JA = 255
X86_INS_JBE = 256
X86_INS_JB = 257
X86_INS_JCXZ = 258
X86_INS_JECXZ = 259
X86_INS_JE = 260
X86_INS_JGE = 261
X86_INS_JG = 262
X86_INS_JLE = 263
X86_INS_JL = 264
X86_INS_JNE = 265
X86_INS_JNO = 266
X86_INS_JNP = 267
X86_INS_JNS = 268
X86_INS_JO = 269
X86_INS_JP = 270
X86_INS_JRCXZ = 271
X86_INS_JS = 272
X86_INS_KADDB = 273
X86_INS_KADDD = 274
X86_INS_KADDQ = 275
X86_INS_KADDW = 276
X86_INS_KANDB = 277
X86_INS_KANDD = 278
X86_INS_KANDNB = 279
X86_INS_KANDND = 280
X86_INS_KANDNQ = 281
X86_INS_KANDNW = 282
X86_INS_KANDQ = 283
X86_INS_KANDW = 284
X86_INS_KMOVB = 285
X86_INS_KMOVD = 286
X86_INS_KMOVQ = 287
X86_INS_KMOVW = 288
X86_INS_KNOTB = 289
X86_INS_KNOTD = 290
X86_INS_KNOTQ = 291
X86_INS_KNOTW = 292
X86_INS_KORB = 293
X86_INS_KORD = 294
X86_INS_KORQ = 295
X86_INS_KORTESTB = 296
X86_INS_KORTESTD = 297
X86_INS_KORTESTQ = 298
X86_INS_KORTESTW = 299
X86_INS_KORW = 300
X86_INS_KSHIFTLB = 301
X86_INS_KSHIFTLD = 302
X86_INS_KSHIFTLQ = 303
X86_INS_KSHIFTLW = 304
X86_INS_KSHIFTRB = 305
X86_INS_KSHIFTRD = 306
X86_INS_KSHIFTRQ = 307
X86_INS_KSHIFTRW = 308
X86_INS_KTESTB = 309
X86_INS_KTESTD = 310
X86_INS_KTESTQ = 311
X86_INS_KTESTW = 312
X86_INS_KUNPCKBW = 313
X86_INS_KUNPCKDQ = 314
X86_INS_KUNPCKWD = 315
X86_INS_KXNORB = 316
X86_INS_KXNORD = 317
X86_INS_KXNORQ = 318
X86_INS_KXNORW = 319
X86_INS_KXORB = 320
X86_INS_KXORD = 321
X86_INS_KXORQ = 322
X86_INS_KXORW = 323
X86_INS_LAHF = 324
X86_INS_LAR = 325
X86_INS_LDDQU = 326
X86_INS_LDMXCSR = 327
X86_INS_LDS = 328
X86_INS_FLDZ = 329
X86_INS_FLD1 = 330
X86_INS_FLD = 331
X86_INS_LEA = 332
X86_INS_LEAVE = 333
X86_INS_LES = 334
X86_INS_LFENCE = 335
X86_INS_LFS = 336
X86_INS_LGDT = 337
X86_INS_LGS = 338
X86_INS_LIDT = 339
X86_INS_LLDT = 340
X86_INS_LLWPCB = 341
X86_INS_LMSW = 342
X86_INS_LOCK = 343
X86_INS_LODSB = 344
X86_INS_LODSD = 345
X86_INS_LODSQ = 346
X86_INS_LODSW = 347
X86_INS_LOOP = 348
X86_INS_LOOPE = 349
X86_INS_LOOPNE = 350
X86_INS_RETF = 351
X86_INS_RETFQ = 352
X86_INS_LSL = 353
X86_INS_LSS = 354
X86_INS_LTR = 355
X86_INS_LWPINS = 356
X86_INS_LWPVAL = 357
X86_INS_LZCNT = 358
X86_INS_MASKMOVDQU = 359
X86_INS_MAXPD = 360
X86_INS_MAXPS = 361
X86_INS_MAXSD = 362
X86_INS_MAXSS = 363
X86_INS_MFENCE = 364
X86_INS_MINPD = 365
X86_INS_MINPS = 366
X86_INS_MINSD = 367
X86_INS_MINSS = 368
X86_INS_CVTPD2PI = 369
X86_INS_CVTPI2PD = 370
X86_INS_CVTPI2PS = 371
X86_INS_CVTPS2PI = 372
X86_INS_CVTTPD2PI = 373
X86_INS_CVTTPS2PI = 374
X86_INS_EMMS = 375
X86_INS_MASKMOVQ = 376
X86_INS_MOVD = 377
X86_INS_MOVQ = 378
X86_INS_MOVDQ2Q = 379
X86_INS_MOVNTQ = 380
X86_INS_MOVQ2DQ = 381
X86_INS_PABSB = 382
X86_INS_PABSD = 383
X86_INS_PABSW = 384
X86_INS_PACKSSDW = 385
X86_INS_PACKSSWB = 386
X86_INS_PACKUSWB = 387
X86_INS_PADDB = 388
X86_INS_PADDD = 389
X86_INS_PADDQ = 390
X86_INS_PADDSB = 391
X86_INS_PADDSW = 392
X86_INS_PADDUSB = 393
X86_INS_PADDUSW = 394
X86_INS_PADDW = 395
X86_INS_PALIGNR = 396
X86_INS_PANDN = 397
X86_INS_PAND = 398
X86_INS_PAVGB = 399
X86_INS_PAVGW = 400
X86_INS_PCMPEQB = 401
X86_INS_PCMPEQD = 402
X86_INS_PCMPEQW = 403
X86_INS_PCMPGTB = 404
X86_INS_PCMPGTD = 405
X86_INS_PCMPGTW = 406
X86_INS_PEXTRW = 407
X86_INS_PHADDD = 408
X86_INS_PHADDSW = 409
X86_INS_PHADDW = 410
X86_INS_PHSUBD = 411
X86_INS_PHSUBSW = 412
X86_INS_PHSUBW = 413
X86_INS_PINSRW = 414
X86_INS_PMADDUBSW = 415
X86_INS_PMADDWD = 416
X86_INS_PMAXSW = 417
X86_INS_PMAXUB = 418
X86_INS_PMINSW = 419
X86_INS_PMINUB = 420
X86_INS_PMOVMSKB = 421
X86_INS_PMULHRSW = 422
X86_INS_PMULHUW = 423
X86_INS_PMULHW = 424
X86_INS_PMULLW = 425
X86_INS_PMULUDQ = 426
X86_INS_POR = 427
X86_INS_PSADBW = 428
X86_INS_PSHUFB = 429
X86_INS_PSHUFW = 430
X86_INS_PSIGNB = 431
X86_INS_PSIGND = 432
X86_INS_PSIGNW = 433
X86_INS_PSLLD = 434
X86_INS_PSLLQ = 435
X86_INS_PSLLW = 436
X86_INS_PSRAD = 437
X86_INS_PSRAW = 438
X86_INS_PSRLD = 439
X86_INS_PSRLQ = 440
X86_INS_PSRLW = 441
X86_INS_PSUBB = 442
X86_INS_PSUBD = 443
X86_INS_PSUBQ = 444
X86_INS_PSUBSB = 445
X86_INS_PSUBSW = 446
X86_INS_PSUBUSB = 447
X86_INS_PSUBUSW = 448
X86_INS_PSUBW = 449
X86_INS_PUNPCKHBW = 450
X86_INS_PUNPCKHDQ = 451
X86_INS_PUNPCKHWD = 452
X86_INS_PUNPCKLBW = 453
X86_INS_PUNPCKLDQ = 454
X86_INS_PUNPCKLWD = 455
X86_INS_PXOR = 456
X86_INS_MONITORX = 457
X86_INS_MONITOR = 458
X86_INS_MONTMUL = 459
X86_INS_MOV = 460
X86_INS_MOVABS = 461
X86_INS_MOVAPD = 462
X86_INS_MOVAPS = 463
X86_INS_MOVBE = 464
X86_INS_MOVDDUP = 465
X86_INS_MOVDIR64B = 466
X86_INS_MOVDIRI = 467
X86_INS_MOVDQA = 468
X86_INS_MOVDQU = 469
X86_INS_MOVHLPS = 470
X86_INS_MOVHPD = 471
X86_INS_MOVHPS = 472
X86_INS_MOVLHPS = 473
X86_INS_MOVLPD = 474
X86_INS_MOVLPS = 475
X86_INS_MOVMSKPD = 476
X86_INS_MOVMSKPS = 477
X86_INS_MOVNTDQA = 478
X86_INS_MOVNTDQ = 479
X86_INS_MOVNTI = 480
X86_INS_MOVNTPD = 481
X86_INS_MOVNTPS = 482
X86_INS_MOVNTSD = 483
X86_INS_MOVNTSS = 484
X86_INS_MOVSB = 485
X86_INS_MOVSD = 486
X86_INS_MOVSHDUP = 487
X86_INS_MOVSLDUP = 488
X86_INS_MOVSQ = 489
X86_INS_MOVSS = 490
X86_INS_MOVSW = 491
X86_INS_MOVSX = 492
X86_INS_MOVSXD = 493
X86_INS_MOVUPD = 494
X86_INS_MOVUPS = 495
X86_INS_MOVZX = 496
X86_INS_MPSADBW = 497
X86_INS_MUL = 498
X86_INS_MULPD = 499
X86_INS_MULPS = 500
X86_INS_MULSD = 501
X86_INS_MULSS = 502
X86_INS_MULX = 503
X86_INS_FMUL = 504
X86_INS_FIMUL = 505
X86_INS_FMULP = 506
X86_INS_MWAITX = 507
X86_INS_MWAIT = 508
X86_INS_NEG = 509
X86_INS_NOP = 510
X86_INS_NOT = 511
X86_INS_OR = 512
X86_INS_ORPD = 513
X86_INS_ORPS = 514
X86_INS_OUT = 515
X86_INS_OUTSB = 516
X86_INS_OUTSD = 517
X86_INS_OUTSW = 518
X86_INS_PACKUSDW = 519
X86_INS_PAUSE = 520
X86_INS_PAVGUSB = 521
X86_INS_PBLENDVB = 522
X86_INS_PBLENDW = 523
X86_INS_PCLMULQDQ = 524
X86_INS_PCMPEQQ = 525
X86_INS_PCMPESTRI = 526
X86_INS_PCMPESTRM = 527
X86_INS_PCMPGTQ = 528
X86_INS_PCMPISTRI = 529
X86_INS_PCMPISTRM = 530
X86_INS_PCONFIG = 531
X86_INS_PDEP = 532
X86_INS_PEXT = 533
X86_INS_PEXTRB = 534
X86_INS_PEXTRD = 535
X86_INS_PEXTRQ = 536
X86_INS_PF2ID = 537
X86_INS_PF2IW = 538
X86_INS_PFACC = 539
X86_INS_PFADD = 540
X86_INS_PFCMPEQ = 541
X86_INS_PFCMPGE = 542
X86_INS_PFCMPGT = 543
X86_INS_PFMAX = 544
X86_INS_PFMIN = 545
X86_INS_PFMUL = 546
X86_INS_PFNACC = 547
X86_INS_PFPNACC = 548
X86_INS_PFRCPIT1 = 549
X86_INS_PFRCPIT2 = 550
X86_INS_PFRCP = 551
X86_INS_PFRSQIT1 = 552
X86_INS_PFRSQRT = 553
X86_INS_PFSUBR = 554
X86_INS_PFSUB = 555
X86_INS_PHMINPOSUW = 556
X86_INS_PI2FD = 557
X86_INS_PI2FW = 558
X86_INS_PINSRB = 559
X86_INS_PINSRD = 560
X86_INS_PINSRQ = 561
X86_INS_PMAXSB = 562
X86_INS_PMAXSD = 563
X86_INS_PMAXUD = 564
X86_INS_PMAXUW = 565
X86_INS_PMINSB = 566
X86_INS_PMINSD = 567
X86_INS_PMINUD = 568
X86_INS_PMINUW = 569
X86_INS_PMOVSXBD = 570
X86_INS_PMOVSXBQ = 571
X86_INS_PMOVSXBW = 572
X86_INS_PMOVSXDQ = 573
X86_INS_PMOVSXWD = 574
X86_INS_PMOVSXWQ = 575
X86_INS_PMOVZXBD = 576
X86_INS_PMOVZXBQ = 577
X86_INS_PMOVZXBW = 578
X86_INS_PMOVZXDQ = 579
X86_INS_PMOVZXWD = 580
X86_INS_PMOVZXWQ = 581
X86_INS_PMULDQ = 582
X86_INS_PMULHRW = 583
X86_INS_PMULLD = 584
X86_INS_POP = 585
X86_INS_POPAW = 586
X86_INS_POPAL = 587
X86_INS_POPCNT = 588
X86_INS_POPF = 589
X86_INS_POPFD = 590
X86_INS_POPFQ = 591
X86_INS_PREFETCH = 592
X86_INS_PREFETCHNTA = 593
X86_INS_PREFETCHT0 = 594
X86_INS_PREFETCHT1 = 595
X86_INS_PREFETCHT2 = 596
X86_INS_PREFETCHW = 597
X86_INS_PREFETCHWT1 = 598
X86_INS_PSHUFD = 599
X86_INS_PSHUFHW = 600
X86_INS_PSHUFLW = 601
X86_INS_PSLLDQ = 602
X86_INS_PSRLDQ = 603
X86_INS_PSWAPD = 604
X86_INS_PTEST = 605
X86_INS_PTWRITE = 606
X86_INS_PUNPCKHQDQ = 607
X86_INS_PUNPCKLQDQ = 608
X86_INS_PUSH = 609
X86_INS_PUSHAW = 610
X86_INS_PUSHAL = 611
X86_INS_PUSHF = 612
X86_INS_PUSHFD = 613
X86_INS_PUSHFQ = 614
X86_INS_RCL = 615
X86_INS_RCPPS = 616
X86_INS_RCPSS = 617
X86_INS_RCR = 618
X86_INS_RDFSBASE = 619
X86_INS_RDGSBASE = 620
X86_INS_RDMSR = 621
X86_INS_RDPID = 622
X86_INS_RDPKRU = 623
X86_INS_RDPMC = 624
X86_INS_RDRAND = 625
X86_INS_RDSEED = 626
X86_INS_RDSSPD = 627
X86_INS_RDSSPQ = 628
X86_INS_RDTSC = 629
X86_INS_RDTSCP = 630
X86_INS_REPNE = 631
X86_INS_REP = 632
X86_INS_RET = 633
X86_INS_REX64 = 634
X86_INS_ROL = 635
X86_INS_ROR = 636
X86_INS_RORX = 637
X86_INS_ROUNDPD = 638
X86_INS_ROUNDPS = 639
X86_INS_ROUNDSD = 640
X86_INS_ROUNDSS = 641
X86_INS_RSM = 642
X86_INS_RSQRTPS = 643
X86_INS_RSQRTSS = 644
X86_INS_RSTORSSP = 645
X86_INS_SAHF = 646
X86_INS_SAL = 647
X86_INS_SALC = 648
X86_INS_SAR = 649
X86_INS_SARX = 650
X86_INS_SAVEPREVSSP = 651
X86_INS_SBB = 652
X86_INS_SCASB = 653
X86_INS_SCASD = 654
X86_INS_SCASQ = 655
X86_INS_SCASW = 656
X86_INS_SETAE = 657
X86_INS_SETA = 658
X86_INS_SETBE = 659
X86_INS_SETB = 660
X86_INS_SETE = 661
X86_INS_SETGE = 662
X86_INS_SETG = 663
X86_INS_SETLE = 664
X86_INS_SETL = 665
X86_INS_SETNE = 666
X86_INS_SETNO = 667
X86_INS_SETNP = 668
X86_INS_SETNS = 669
X86_INS_SETO = 670
X86_INS_SETP = 671
X86_INS_SETSSBSY = 672
X86_INS_SETS = 673
X86_INS_SFENCE = 674
X86_INS_SGDT = 675
X86_INS_SHA1MSG1 = 676
X86_INS_SHA1MSG2 = 677
X86_INS_SHA1NEXTE = 678
X86_INS_SHA1RNDS4 = 679
X86_INS_SHA256MSG1 = 680
X86_INS_SHA256MSG2 = 681
X86_INS_SHA256RNDS2 = 682
X86_INS_SHL = 683
X86_INS_SHLD = 684
X86_INS_SHLX = 685
X86_INS_SHR = 686
X86_INS_SHRD = 687
X86_INS_SHRX = 688
X86_INS_SHUFPD = 689
X86_INS_SHUFPS = 690
X86_INS_SIDT = 691
X86_INS_FSIN = 692
X86_INS_SKINIT = 693
X86_INS_SLDT = 694
X86_INS_SLWPCB = 695
X86_INS_SMSW = 696
X86_INS_SQRTPD = 697
X86_INS_SQRTPS = 698
X86_INS_SQRTSD = 699
X86_INS_SQRTSS = 700
X86_INS_FSQRT = 701
X86_INS_STAC = 702
X86_INS_STC = 703
X86_INS_STD = 704
X86_INS_STGI = 705
X86_INS_STI = 706
X86_INS_STMXCSR = 707
X86_INS_STOSB = 708
X86_INS_STOSD = 709
X86_INS_STOSQ = 710
X86_INS_STOSW = 711
X86_INS_STR = 712
X86_INS_FST = 713
X86_INS_FSTP = 714
X86_INS_SUB = 715
X86_INS_SUBPD = 716
X86_INS_SUBPS = 717
X86_INS_FSUBR = 718
X86_INS_FISUBR = 719
X86_INS_FSUBRP = 720
X86_INS_SUBSD = 721
X86_INS_SUBSS = 722
X86_INS_FSUB = 723
X86_INS_FISUB = 724
X86_INS_FSUBP = 725
X86_INS_SWAPGS = 726
X86_INS_SYSCALL = 727
X86_INS_SYSENTER = 728
X86_INS_SYSEXIT = 729
X86_INS_SYSEXITQ = 730
X86_INS_SYSRET = 731
X86_INS_SYSRETQ = 732
X86_INS_T1MSKC = 733
X86_INS_TEST = 734
X86_INS_TPAUSE = 735
X86_INS_FTST = 736
X86_INS_TZCNT = 737
X86_INS_TZMSK = 738
X86_INS_UCOMISD = 739
X86_INS_UCOMISS = 740
X86_INS_FUCOMPI = 741
X86_INS_FUCOMI = 742
X86_INS_FUCOMPP = 743
X86_INS_FUCOMP = 744
X86_INS_FUCOM = 745
X86_INS_UD0 = 746
X86_INS_UD1 = 747
X86_INS_UD2 = 748
X86_INS_UMONITOR = 749
X86_INS_UMWAIT = 750
X86_INS_UNPCKHPD = 751
X86_INS_UNPCKHPS = 752
X86_INS_UNPCKLPD = 753
X86_INS_UNPCKLPS = 754
X86_INS_V4FMADDPS = 755
X86_INS_V4FMADDSS = 756
X86_INS_V4FNMADDPS = 757
X86_INS_V4FNMADDSS = 758
X86_INS_VADDPD = 759
X86_INS_VADDPS = 760
X86_INS_VADDSD = 761
X86_INS_VADDSS = 762
X86_INS_VADDSUBPD = 763
X86_INS_VADDSUBPS = 764
X86_INS_VAESDECLAST = 765
X86_INS_VAESDEC = 766
X86_INS_VAESENCLAST = 767
X86_INS_VAESENC = 768
X86_INS_VAESIMC = 769
X86_INS_VAESKEYGENASSIST = 770
X86_INS_VALIGND = 771
X86_INS_VALIGNQ = 772
X86_INS_VANDNPD = 773
X86_INS_VANDNPS = 774
X86_INS_VANDPD = 775
X86_INS_VANDPS = 776
X86_INS_VBLENDMPD = 777
X86_INS_VBLENDMPS = 778
X86_INS_VBLENDPD = 779
X86_INS_VBLENDPS = 780
X86_INS_VBLENDVPD = 781
X86_INS_VBLENDVPS = 782
X86_INS_VBROADCASTF128 = 783
X86_INS_VBROADCASTF32X2 = 784
X86_INS_VBROADCASTF32X4 = 785
X86_INS_VBROADCASTF32X8 = 786
X86_INS_VBROADCASTF64X2 = 787
X86_INS_VBROADCASTF64X4 = 788
X86_INS_VBROADCASTI128 = 789
X86_INS_VBROADCASTI32X2 = 790
X86_INS_VBROADCASTI32X4 = 791
X86_INS_VBROADCASTI32X8 = 792
X86_INS_VBROADCASTI64X2 = 793
X86_INS_VBROADCASTI64X4 = 794
X86_INS_VBROADCASTSD = 795
X86_INS_VBROADCASTSS = 796
X86_INS_VCMP = 797
X86_INS_VCMPPD = 798
X86_INS_VCMPPS = 799
X86_INS_VCMPSD = 800
X86_INS_VCMPSS = 801
X86_INS_VCOMISD = 802
X86_INS_VCOMISS = 803
X86_INS_VCOMPRESSPD = 804
X86_INS_VCOMPRESSPS = 805
X86_INS_VCVTDQ2PD = 806
X86_INS_VCVTDQ2PS = 807
X86_INS_VCVTPD2DQ = 808
X86_INS_VCVTPD2PS = 809
X86_INS_VCVTPD2QQ = 810
X86_INS_VCVTPD2UDQ = 811
X86_INS_VCVTPD2UQQ = 812
X86_INS_VCVTPH2PS = 813
X86_INS_VCVTPS2DQ = 814
X86_INS_VCVTPS2PD = 815
X86_INS_VCVTPS2PH = 816
X86_INS_VCVTPS2QQ = 817
X86_INS_VCVTPS2UDQ = 818
X86_INS_VCVTPS2UQQ = 819
X86_INS_VCVTQQ2PD = 820
X86_INS_VCVTQQ2PS = 821
X86_INS_VCVTSD2SI = 822
X86_INS_VCVTSD2SS = 823
X86_INS_VCVTSD2USI = 824
X86_INS_VCVTSI2SD = 825
X86_INS_VCVTSI2SS = 826
X86_INS_VCVTSS2SD = 827
X86_INS_VCVTSS2SI = 828
X86_INS_VCVTSS2USI = 829
X86_INS_VCVTTPD2DQ = 830
X86_INS_VCVTTPD2QQ = 831
X86_INS_VCVTTPD2UDQ = 832
X86_INS_VCVTTPD2UQQ = 833
X86_INS_VCVTTPS2DQ = 834
X86_INS_VCVTTPS2QQ = 835
X86_INS_VCVTTPS2UDQ = 836
X86_INS_VCVTTPS2UQQ = 837
X86_INS_VCVTTSD2SI = 838
X86_INS_VCVTTSD2USI = 839
X86_INS_VCVTTSS2SI = 840
X86_INS_VCVTTSS2USI = 841
X86_INS_VCVTUDQ2PD = 842
X86_INS_VCVTUDQ2PS = 843
X86_INS_VCVTUQQ2PD = 844
X86_INS_VCVTUQQ2PS = 845
X86_INS_VCVTUSI2SD = 846
X86_INS_VCVTUSI2SS = 847
X86_INS_VDBPSADBW = 848
X86_INS_VDIVPD = 849
X86_INS_VDIVPS = 850
X86_INS_VDIVSD = 851
X86_INS_VDIVSS = 852
X86_INS_VDPPD = 853
X86_INS_VDPPS = 854
X86_INS_VERR = 855
X86_INS_VERW = 856
X86_INS_VEXP2PD = 857
X86_INS_VEXP2PS = 858
X86_INS_VEXPANDPD = 859
X86_INS_VEXPANDPS = 860
X86_INS_VEXTRACTF128 = 861
X86_INS_VEXTRACTF32X4 = 862
X86_INS_VEXTRACTF32X8 = 863
X86_INS_VEXTRACTF64X2 = 864
X86_INS_VEXTRACTF64X4 = 865
X86_INS_VEXTRACTI128 = 866
X86_INS_VEXTRACTI32X4 = 867
X86_INS_VEXTRACTI32X8 = 868
X86_INS_VEXTRACTI64X2 = 869
X86_INS_VEXTRACTI64X4 = 870
X86_INS_VEXTRACTPS = 871
X86_INS_VFIXUPIMMPD = 872
X86_INS_VFIXUPIMMPS = 873
X86_INS_VFIXUPIMMSD = 874
X86_INS_VFIXUPIMMSS = 875
X86_INS_VFMADD132PD = 876
X86_INS_VFMADD132PS = 877
X86_INS_VFMADD132SD = 878
X86_INS_VFMADD132SS = 879
X86_INS_VFMADD213PD = 880
X86_INS_VFMADD213PS = 881
X86_INS_VFMADD213SD = 882
X86_INS_VFMADD213SS = 883
X86_INS_VFMADD231PD = 884
X86_INS_VFMADD231PS = 885
X86_INS_VFMADD231SD = 886
X86_INS_VFMADD231SS = 887
X86_INS_VFMADDPD = 888
X86_INS_VFMADDPS = 889
X86_INS_VFMADDSD = 890
X86_INS_VFMADDSS = 891
X86_INS_VFMADDSUB132PD = 892
X86_INS_VFMADDSUB132PS = 893
X86_INS_VFMADDSUB213PD = 894
X86_INS_VFMADDSUB213PS = 895
X86_INS_VFMADDSUB231PD = 896
X86_INS_VFMADDSUB231PS = 897
X86_INS_VFMADDSUBPD = 898
X86_INS_VFMADDSUBPS = 899
X86_INS_VFMSUB132PD = 900
X86_INS_VFMSUB132PS = 901
X86_INS_VFMSUB132SD = 902
X86_INS_VFMSUB132SS = 903
X86_INS_VFMSUB213PD = 904
X86_INS_VFMSUB213PS = 905
X86_INS_VFMSUB213SD = 906
X86_INS_VFMSUB213SS = 907
X86_INS_VFMSUB231PD = 908
X86_INS_VFMSUB231PS = 909
X86_INS_VFMSUB231SD = 910
X86_INS_VFMSUB231SS = 911
X86_INS_VFMSUBADD132PD = 912
X86_INS_VFMSUBADD132PS = 913
X86_INS_VFMSUBADD213PD = 914
X86_INS_VFMSUBADD213PS = 915
X86_INS_VFMSUBADD231PD = 916
X86_INS_VFMSUBADD231PS = 917
X86_INS_VFMSUBADDPD = 918
X86_INS_VFMSUBADDPS = 919
X86_INS_VFMSUBPD = 920
X86_INS_VFMSUBPS = 921
X86_INS_VFMSUBSD = 922
X86_INS_VFMSUBSS = 923
X86_INS_VFNMADD132PD = 924
X86_INS_VFNMADD132PS = 925
X86_INS_VFNMADD132SD = 926
X86_INS_VFNMADD132SS = 927
X86_INS_VFNMADD213PD = 928
X86_INS_VFNMADD213PS = 929
X86_INS_VFNMADD213SD = 930
X86_INS_VFNMADD213SS = 931
X86_INS_VFNMADD231PD = 932
X86_INS_VFNMADD231PS = 933
X86_INS_VFNMADD231SD = 934
X86_INS_VFNMADD231SS = 935
X86_INS_VFNMADDPD = 936
X86_INS_VFNMADDPS = 937
X86_INS_VFNMADDSD = 938
X86_INS_VFNMADDSS = 939
X86_INS_VFNMSUB132PD = 940
X86_INS_VFNMSUB132PS = 941
X86_INS_VFNMSUB132SD = 942
X86_INS_VFNMSUB132SS = 943
X86_INS_VFNMSUB213PD = 944
X86_INS_VFNMSUB213PS = 945
X86_INS_VFNMSUB213SD = 946
X86_INS_VFNMSUB213SS = 947
X86_INS_VFNMSUB231PD = 948
X86_INS_VFNMSUB231PS = 949
X86_INS_VFNMSUB231SD = 950
X86_INS_VFNMSUB231SS = 951
X86_INS_VFNMSUBPD = 952
X86_INS_VFNMSUBPS = 953
X86_INS_VFNMSUBSD = 954
X86_INS_VFNMSUBSS = 955
X86_INS_VFPCLASSPD = 956
X86_INS_VFPCLASSPS = 957
X86_INS_VFPCLASSSD = 958
X86_INS_VFPCLASSSS = 959
X86_INS_VFRCZPD = 960
X86_INS_VFRCZPS = 961
X86_INS_VFRCZSD = 962
X86_INS_VFRCZSS = 963
X86_INS_VGATHERDPD = 964
X86_INS_VGATHERDPS = 965
X86_INS_VGATHERPF0DPD = 966
X86_INS_VGATHERPF0DPS = 967
X86_INS_VGATHERPF0QPD = 968
X86_INS_VGATHERPF0QPS = 969
X86_INS_VGATHERPF1DPD = 970
X86_INS_VGATHERPF1DPS = 971
X86_INS_VGATHERPF1QPD = 972
X86_INS_VGATHERPF1QPS = 973
X86_INS_VGATHERQPD = 974
X86_INS_VGATHERQPS = 975
X86_INS_VGETEXPPD = 976
X86_INS_VGETEXPPS = 977
X86_INS_VGETEXPSD = 978
X86_INS_VGETEXPSS = 979
X86_INS_VGETMANTPD = 980
X86_INS_VGETMANTPS = 981
X86_INS_VGETMANTSD = 982
X86_INS_VGETMANTSS = 983
X86_INS_VGF2P8AFFINEINVQB = 984
X86_INS_VGF2P8AFFINEQB = 985
X86_INS_VGF2P8MULB = 986
X86_INS_VHADDPD = 987
X86_INS_VHADDPS = 988
X86_INS_VHSUBPD = 989
X86_INS_VHSUBPS = 990
X86_INS_VINSERTF128 = 991
X86_INS_VINSERTF32X4 = 992
X86_INS_VINSERTF32X8 = 993
X86_INS_VINSERTF64X2 = 994
X86_INS_VINSERTF64X4 = 995
X86_INS_VINSERTI128 = 996
X86_INS_VINSERTI32X4 = 997
X86_INS_VINSERTI32X8 = 998
X86_INS_VINSERTI64X2 = 999
X86_INS_VINSERTI64X4 = 1000
X86_INS_VINSERTPS = 1001
X86_INS_VLDDQU = 1002
X86_INS_VLDMXCSR = 1003
X86_INS_VMASKMOVDQU = 1004
X86_INS_VMASKMOVPD = 1005
X86_INS_VMASKMOVPS = 1006
X86_INS_VMAXPD = 1007
X86_INS_VMAXPS = 1008
X86_INS_VMAXSD = 1009
X86_INS_VMAXSS = 1010
X86_INS_VMCALL = 1011
X86_INS_VMCLEAR = 1012
X86_INS_VMFUNC = 1013
X86_INS_VMINPD = 1014
X86_INS_VMINPS = 1015
X86_INS_VMINSD = 1016
X86_INS_VMINSS = 1017
X86_INS_VMLAUNCH = 1018
X86_INS_VMLOAD = 1019
X86_INS_VMMCALL = 1020
X86_INS_VMOVQ = 1021
X86_INS_VMOVAPD = 1022
X86_INS_VMOVAPS = 1023
X86_INS_VMOVDDUP = 1024
X86_INS_VMOVD = 1025
X86_INS_VMOVDQA32 = 1026
X86_INS_VMOVDQA64 = 1027
X86_INS_VMOVDQA = 1028
X86_INS_VMOVDQU16 = 1029
X86_INS_VMOVDQU32 = 1030
X86_INS_VMOVDQU64 = 1031
X86_INS_VMOVDQU8 = 1032
X86_INS_VMOVDQU = 1033
X86_INS_VMOVHLPS = 1034
X86_INS_VMOVHPD = 1035
X86_INS_VMOVHPS = 1036
X86_INS_VMOVLHPS = 1037
X86_INS_VMOVLPD = 1038
X86_INS_VMOVLPS = 1039
X86_INS_VMOVMSKPD = 1040
X86_INS_VMOVMSKPS = 1041
X86_INS_VMOVNTDQA = 1042
X86_INS_VMOVNTDQ = 1043
X86_INS_VMOVNTPD = 1044
X86_INS_VMOVNTPS = 1045
X86_INS_VMOVSD = 1046
X86_INS_VMOVSHDUP = 1047
X86_INS_VMOVSLDUP = 1048
X86_INS_VMOVSS = 1049
X86_INS_VMOVUPD = 1050
X86_INS_VMOVUPS = 1051
X86_INS_VMPSADBW = 1052
X86_INS_VMPTRLD = 1053
X86_INS_VMPTRST = 1054
X86_INS_VMREAD = 1055
X86_INS_VMRESUME = 1056
X86_INS_VMRUN = 1057
X86_INS_VMSAVE = 1058
X86_INS_VMULPD = 1059
X86_INS_VMULPS = 1060
X86_INS_VMULSD = 1061
X86_INS_VMULSS = 1062
X86_INS_VMWRITE = 1063
X86_INS_VMXOFF = 1064
X86_INS_VMXON = 1065
X86_INS_VORPD = 1066
X86_INS_VORPS = 1067
X86_INS_VP4DPWSSDS = 1068
X86_INS_VP4DPWSSD = 1069
X86_INS_VPABSB = 1070
X86_INS_VPABSD = 1071
X86_INS_VPABSQ = 1072
X86_INS_VPABSW = 1073
X86_INS_VPACKSSDW = 1074
X86_INS_VPACKSSWB = 1075
X86_INS_VPACKUSDW = 1076
X86_INS_VPACKUSWB = 1077
X86_INS_VPADDB = 1078
X86_INS_VPADDD = 1079
X86_INS_VPADDQ = 1080
X86_INS_VPADDSB = 1081
X86_INS_VPADDSW = 1082
X86_INS_VPADDUSB = 1083
X86_INS_VPADDUSW = 1084
X86_INS_VPADDW = 1085
X86_INS_VPALIGNR = 1086
X86_INS_VPANDD = 1087
X86_INS_VPANDND = 1088
X86_INS_VPANDNQ = 1089
X86_INS_VPANDN = 1090
X86_INS_VPANDQ = 1091
X86_INS_VPAND = 1092
X86_INS_VPAVGB = 1093
X86_INS_VPAVGW = 1094
X86_INS_VPBLENDD = 1095
X86_INS_VPBLENDMB = 1096
X86_INS_VPBLENDMD = 1097
X86_INS_VPBLENDMQ = 1098
X86_INS_VPBLENDMW = 1099
X86_INS_VPBLENDVB = 1100
X86_INS_VPBLENDW = 1101
X86_INS_VPBROADCASTB = 1102
X86_INS_VPBROADCASTD = 1103
X86_INS_VPBROADCASTMB2Q = 1104
X86_INS_VPBROADCASTMW2D = 1105
X86_INS_VPBROADCASTQ = 1106
X86_INS_VPBROADCASTW = 1107
X86_INS_VPCLMULQDQ = 1108
X86_INS_VPCMOV = 1109
X86_INS_VPCMP = 1110
X86_INS_VPCMPB = 1111
X86_INS_VPCMPD = 1112
X86_INS_VPCMPEQB = 1113
X86_INS_VPCMPEQD = 1114
X86_INS_VPCMPEQQ = 1115
X86_INS_VPCMPEQW = 1116
X86_INS_VPCMPESTRI = 1117
X86_INS_VPCMPESTRM = 1118
X86_INS_VPCMPGTB = 1119
X86_INS_VPCMPGTD = 1120
X86_INS_VPCMPGTQ = 1121
X86_INS_VPCMPGTW = 1122
X86_INS_VPCMPISTRI = 1123
X86_INS_VPCMPISTRM = 1124
X86_INS_VPCMPQ = 1125
X86_INS_VPCMPUB = 1126
X86_INS_VPCMPUD = 1127
X86_INS_VPCMPUQ = 1128
X86_INS_VPCMPUW = 1129
X86_INS_VPCMPW = 1130
X86_INS_VPCOM = 1131
X86_INS_VPCOMB = 1132
X86_INS_VPCOMD = 1133
X86_INS_VPCOMPRESSB = 1134
X86_INS_VPCOMPRESSD = 1135
X86_INS_VPCOMPRESSQ = 1136
X86_INS_VPCOMPRESSW = 1137
X86_INS_VPCOMQ = 1138
X86_INS_VPCOMUB = 1139
X86_INS_VPCOMUD = 1140
X86_INS_VPCOMUQ = 1141
X86_INS_VPCOMUW = 1142
X86_INS_VPCOMW = 1143
X86_INS_VPCONFLICTD = 1144
X86_INS_VPCONFLICTQ = 1145
X86_INS_VPDPBUSDS = 1146
X86_INS_VPDPBUSD = 1147
X86_INS_VPDPWSSDS = 1148
X86_INS_VPDPWSSD = 1149
X86_INS_VPERM2F128 = 1150
X86_INS_VPERM2I128 = 1151
X86_INS_VPERMB = 1152
X86_INS_VPERMD = 1153
X86_INS_VPERMI2B = 1154
X86_INS_VPERMI2D = 1155
X86_INS_VPERMI2PD = 1156
X86_INS_VPERMI2PS = 1157
X86_INS_VPERMI2Q = 1158
X86_INS_VPERMI2W = 1159
X86_INS_VPERMIL2PD = 1160
X86_INS_VPERMILPD = 1161
X86_INS_VPERMIL2PS = 1162
X86_INS_VPERMILPS = 1163
X86_INS_VPERMPD = 1164
X86_INS_VPERMPS = 1165
X86_INS_VPERMQ = 1166
X86_INS_VPERMT2B = 1167
X86_INS_VPERMT2D = 1168
X86_INS_VPERMT2PD = 1169
X86_INS_VPERMT2PS = 1170
X86_INS_VPERMT2Q = 1171
X86_INS_VPERMT2W = 1172
X86_INS_VPERMW = 1173
X86_INS_VPEXPANDB = 1174
X86_INS_VPEXPANDD = 1175
X86_INS_VPEXPANDQ = 1176
X86_INS_VPEXPANDW = 1177
X86_INS_VPEXTRB = 1178
X86_INS_VPEXTRD = 1179
X86_INS_VPEXTRQ = 1180
X86_INS_VPEXTRW = 1181
X86_INS_VPGATHERDD = 1182
X86_INS_VPGATHERDQ = 1183
X86_INS_VPGATHERQD = 1184
X86_INS_VPGATHERQQ = 1185
X86_INS_VPHADDBD = 1186
X86_INS_VPHADDBQ = 1187
X86_INS_VPHADDBW = 1188
X86_INS_VPHADDDQ = 1189
X86_INS_VPHADDD = 1190
X86_INS_VPHADDSW = 1191
X86_INS_VPHADDUBD = 1192
X86_INS_VPHADDUBQ = 1193
X86_INS_VPHADDUBW = 1194
X86_INS_VPHADDUDQ = 1195
X86_INS_VPHADDUWD = 1196
X86_INS_VPHADDUWQ = 1197
X86_INS_VPHADDWD = 1198
X86_INS_VPHADDWQ = 1199
X86_INS_VPHADDW = 1200
X86_INS_VPHMINPOSUW = 1201
X86_INS_VPHSUBBW = 1202
X86_INS_VPHSUBDQ = 1203
X86_INS_VPHSUBD = 1204
X86_INS_VPHSUBSW = 1205
X86_INS_VPHSUBWD = 1206
X86_INS_VPHSUBW = 1207
X86_INS_VPINSRB = 1208
X86_INS_VPINSRD = 1209
X86_INS_VPINSRQ = 1210
X86_INS_VPINSRW = 1211
X86_INS_VPLZCNTD = 1212
X86_INS_VPLZCNTQ = 1213
X86_INS_VPMACSDD = 1214
X86_INS_VPMACSDQH = 1215
X86_INS_VPMACSDQL = 1216
X86_INS_VPMACSSDD = 1217
X86_INS_VPMACSSDQH = 1218
X86_INS_VPMACSSDQL = 1219
X86_INS_VPMACSSWD = 1220
X86_INS_VPMACSSWW = 1221
X86_INS_VPMACSWD = 1222
X86_INS_VPMACSWW = 1223
X86_INS_VPMADCSSWD = 1224
X86_INS_VPMADCSWD = 1225
X86_INS_VPMADD52HUQ = 1226
X86_INS_VPMADD52LUQ = 1227
X86_INS_VPMADDUBSW = 1228
X86_INS_VPMADDWD = 1229
X86_INS_VPMASKMOVD = 1230
X86_INS_VPMASKMOVQ = 1231
X86_INS_VPMAXSB = 1232
X86_INS_VPMAXSD = 1233
X86_INS_VPMAXSQ = 1234
X86_INS_VPMAXSW = 1235
X86_INS_VPMAXUB = 1236
X86_INS_VPMAXUD = 1237
X86_INS_VPMAXUQ = 1238
X86_INS_VPMAXUW = 1239
X86_INS_VPMINSB = 1240
X86_INS_VPMINSD = 1241
X86_INS_VPMINSQ = 1242
X86_INS_VPMINSW = 1243
X86_INS_VPMINUB = 1244
X86_INS_VPMINUD = 1245
X86_INS_VPMINUQ = 1246
X86_INS_VPMINUW = 1247
X86_INS_VPMOVB2M = 1248
X86_INS_VPMOVD2M = 1249
X86_INS_VPMOVDB = 1250
X86_INS_VPMOVDW = 1251
X86_INS_VPMOVM2B = 1252
X86_INS_VPMOVM2D = 1253
X86_INS_VPMOVM2Q = 1254
X86_INS_VPMOVM2W = 1255
X86_INS_VPMOVMSKB = 1256
X86_INS_VPMOVQ2M = 1257
X86_INS_VPMOVQB = 1258
X86_INS_VPMOVQD = 1259
X86_INS_VPMOVQW = 1260
X86_INS_VPMOVSDB = 1261
X86_INS_VPMOVSDW = 1262
X86_INS_VPMOVSQB = 1263
X86_INS_VPMOVSQD = 1264
X86_INS_VPMOVSQW = 1265
X86_INS_VPMOVSWB = 1266
X86_INS_VPMOVSXBD = 1267
X86_INS_VPMOVSXBQ = 1268
X86_INS_VPMOVSXBW = 1269
X86_INS_VPMOVSXDQ = 1270
X86_INS_VPMOVSXWD = 1271
X86_INS_VPMOVSXWQ = 1272
X86_INS_VPMOVUSDB = 1273
X86_INS_VPMOVUSDW = 1274
X86_INS_VPMOVUSQB = 1275
X86_INS_VPMOVUSQD = 1276
X86_INS_VPMOVUSQW = 1277
X86_INS_VPMOVUSWB = 1278
X86_INS_VPMOVW2M = 1279
X86_INS_VPMOVWB = 1280
X86_INS_VPMOVZXBD = 1281
X86_INS_VPMOVZXBQ = 1282
X86_INS_VPMOVZXBW = 1283
X86_INS_VPMOVZXDQ = 1284
X86_INS_VPMOVZXWD = 1285
X86_INS_VPMOVZXWQ = 1286
X86_INS_VPMULDQ = 1287
X86_INS_VPMULHRSW = 1288
X86_INS_VPMULHUW = 1289
X86_INS_VPMULHW = 1290
X86_INS_VPMULLD = 1291
X86_INS_VPMULLQ = 1292
X86_INS_VPMULLW = 1293
X86_INS_VPMULTISHIFTQB = 1294
X86_INS_VPMULUDQ = 1295
X86_INS_VPOPCNTB = 1296
X86_INS_VPOPCNTD = 1297
X86_INS_VPOPCNTQ = 1298
X86_INS_VPOPCNTW = 1299
X86_INS_VPORD = 1300
X86_INS_VPORQ = 1301
X86_INS_VPOR = 1302
X86_INS_VPPERM = 1303
X86_INS_VPROLD = 1304
X86_INS_VPROLQ = 1305
X86_INS_VPROLVD = 1306
X86_INS_VPROLVQ = 1307
X86_INS_VPRORD = 1308
X86_INS_VPRORQ = 1309
X86_INS_VPRORVD = 1310
X86_INS_VPRORVQ = 1311
X86_INS_VPROTB = 1312
X86_INS_VPROTD = 1313
X86_INS_VPROTQ = 1314
X86_INS_VPROTW = 1315
X86_INS_VPSADBW = 1316
X86_INS_VPSCATTERDD = 1317
X86_INS_VPSCATTERDQ = 1318
X86_INS_VPSCATTERQD = 1319
X86_INS_VPSCATTERQQ = 1320
X86_INS_VPSHAB = 1321
X86_INS_VPSHAD = 1322
X86_INS_VPSHAQ = 1323
X86_INS_VPSHAW = 1324
X86_INS_VPSHLB = 1325
X86_INS_VPSHLDD = 1326
X86_INS_VPSHLDQ = 1327
X86_INS_VPSHLDVD = 1328
X86_INS_VPSHLDVQ = 1329
X86_INS_VPSHLDVW = 1330
X86_INS_VPSHLDW = 1331
X86_INS_VPSHLD = 1332
X86_INS_VPSHLQ = 1333
X86_INS_VPSHLW = 1334
X86_INS_VPSHRDD = 1335
X86_INS_VPSHRDQ = 1336
X86_INS_VPSHRDVD = 1337
X86_INS_VPSHRDVQ = 1338
X86_INS_VPSHRDVW = 1339
X86_INS_VPSHRDW = 1340
X86_INS_VPSHUFBITQMB = 1341
X86_INS_VPSHUFB = 1342
X86_INS_VPSHUFD = 1343
X86_INS_VPSHUFHW = 1344
X86_INS_VPSHUFLW = 1345
X86_INS_VPSIGNB = 1346
X86_INS_VPSIGND = 1347
X86_INS_VPSIGNW = 1348
X86_INS_VPSLLDQ = 1349
X86_INS_VPSLLD = 1350
X86_INS_VPSLLQ = 1351
X86_INS_VPSLLVD = 1352
X86_INS_VPSLLVQ = 1353
X86_INS_VPSLLVW = 1354
X86_INS_VPSLLW = 1355
X86_INS_VPSRAD = 1356
X86_INS_VPSRAQ = 1357
X86_INS_VPSRAVD = 1358
X86_INS_VPSRAVQ = 1359
X86_INS_VPSRAVW = 1360
X86_INS_VPSRAW = 1361
X86_INS_VPSRLDQ = 1362
X86_INS_VPSRLD = 1363
X86_INS_VPSRLQ = 1364
X86_INS_VPSRLVD = 1365
X86_INS_VPSRLVQ = 1366
X86_INS_VPSRLVW = 1367
X86_INS_VPSRLW = 1368
X86_INS_VPSUBB = 1369
X86_INS_VPSUBD = 1370
X86_INS_VPSUBQ = 1371
X86_INS_VPSUBSB = 1372
X86_INS_VPSUBSW = 1373
X86_INS_VPSUBUSB = 1374
X86_INS_VPSUBUSW = 1375
X86_INS_VPSUBW = 1376
X86_INS_VPTERNLOGD = 1377
X86_INS_VPTERNLOGQ = 1378
X86_INS_VPTESTMB = 1379
X86_INS_VPTESTMD = 1380
X86_INS_VPTESTMQ = 1381
X86_INS_VPTESTMW = 1382
X86_INS_VPTESTNMB = 1383
X86_INS_VPTESTNMD = 1384
X86_INS_VPTESTNMQ = 1385
X86_INS_VPTESTNMW = 1386
X86_INS_VPTEST = 1387
X86_INS_VPUNPCKHBW = 1388
X86_INS_VPUNPCKHDQ = 1389
X86_INS_VPUNPCKHQDQ = 1390
X86_INS_VPUNPCKHWD = 1391
X86_INS_VPUNPCKLBW = 1392
X86_INS_VPUNPCKLDQ = 1393
X86_INS_VPUNPCKLQDQ = 1394
X86_INS_VPUNPCKLWD = 1395
X86_INS_VPXORD = 1396
X86_INS_VPXORQ = 1397
X86_INS_VPXOR = 1398
X86_INS_VRANGEPD = 1399
X86_INS_VRANGEPS = 1400
X86_INS_VRANGESD = 1401
X86_INS_VRANGESS = 1402
X86_INS_VRCP14PD = 1403
X86_INS_VRCP14PS = 1404
X86_INS_VRCP14SD = 1405
X86_INS_VRCP14SS = 1406
X86_INS_VRCP28PD = 1407
X86_INS_VRCP28PS = 1408
X86_INS_VRCP28SD = 1409
X86_INS_VRCP28SS = 1410
X86_INS_VRCPPS = 1411
X86_INS_VRCPSS = 1412
X86_INS_VREDUCEPD = 1413
X86_INS_VREDUCEPS = 1414
X86_INS_VREDUCESD = 1415
X86_INS_VREDUCESS = 1416
X86_INS_VRNDSCALEPD = 1417
X86_INS_VRNDSCALEPS = 1418
X86_INS_VRNDSCALESD = 1419
X86_INS_VRNDSCALESS = 1420
X86_INS_VROUNDPD = 1421
X86_INS_VROUNDPS = 1422
X86_INS_VROUNDSD = 1423
X86_INS_VROUNDSS = 1424
X86_INS_VRSQRT14PD = 1425
X86_INS_VRSQRT14PS = 1426
X86_INS_VRSQRT14SD = 1427
X86_INS_VRSQRT14SS = 1428
X86_INS_VRSQRT28PD = 1429
X86_INS_VRSQRT28PS = 1430
X86_INS_VRSQRT28SD = 1431
X86_INS_VRSQRT28SS = 1432
X86_INS_VRSQRTPS = 1433
X86_INS_VRSQRTSS = 1434
X86_INS_VSCALEFPD = 1435
X86_INS_VSCALEFPS = 1436
X86_INS_VSCALEFSD = 1437
X86_INS_VSCALEFSS = 1438
X86_INS_VSCATTERDPD = 1439
X86_INS_VSCATTERDPS = 1440
X86_INS_VSCATTERPF0DPD = 1441
X86_INS_VSCATTERPF0DPS = 1442
X86_INS_VSCATTERPF0QPD = 1443
X86_INS_VSCATTERPF0QPS = 1444
X86_INS_VSCATTERPF1DPD = 1445
X86_INS_VSCATTERPF1DPS = 1446
X86_INS_VSCATTERPF1QPD = 1447
X86_INS_VSCATTERPF1QPS = 1448
X86_INS_VSCATTERQPD = 1449
X86_INS_VSCATTERQPS = 1450
X86_INS_VSHUFF32X4 = 1451
X86_INS_VSHUFF64X2 = 1452
X86_INS_VSHUFI32X4 = 1453
X86_INS_VSHUFI64X2 = 1454
X86_INS_VSHUFPD = 1455
X86_INS_VSHUFPS = 1456
X86_INS_VSQRTPD = 1457
X86_INS_VSQRTPS = 1458
X86_INS_VSQRTSD = 1459
X86_INS_VSQRTSS = 1460
X86_INS_VSTMXCSR = 1461
X86_INS_VSUBPD = 1462
X86_INS_VSUBPS = 1463
X86_INS_VSUBSD = 1464
X86_INS_VSUBSS = 1465
X86_INS_VTESTPD = 1466
X86_INS_VTESTPS = 1467
X86_INS_VUCOMISD = 1468
X86_INS_VUCOMISS = 1469
X86_INS_VUNPCKHPD = 1470
X86_INS_VUNPCKHPS = 1471
X86_INS_VUNPCKLPD = 1472
X86_INS_VUNPCKLPS = 1473
X86_INS_VXORPD = 1474
X86_INS_VXORPS = 1475
X86_INS_VZEROALL = 1476
X86_INS_VZEROUPPER = 1477
X86_INS_WAIT = 1478
X86_INS_WBINVD = 1479
X86_INS_WBNOINVD = 1480
X86_INS_WRFSBASE = 1481
X86_INS_WRGSBASE = 1482
X86_INS_WRMSR = 1483
X86_INS_WRPKRU = 1484
X86_INS_WRSSD = 1485
X86_INS_WRSSQ = 1486
X86_INS_WRUSSD = 1487
X86_INS_WRUSSQ = 1488
X86_INS_XABORT = 1489
X86_INS_XACQUIRE = 1490
X86_INS_XADD = 1491
X86_INS_XBEGIN = 1492
X86_INS_XCHG = 1493
X86_INS_FXCH = 1494
X86_INS_XCRYPTCBC = 1495
X86_INS_XCRYPTCFB = 1496
X86_INS_XCRYPTCTR = 1497
X86_INS_XCRYPTECB = 1498
X86_INS_XCRYPTOFB = 1499
X86_INS_XEND = 1500
X86_INS_XGETBV = 1501
X86_INS_XLATB = 1502
X86_INS_XOR = 1503
X86_INS_XORPD = 1504
X86_INS_XORPS = 1505
X86_INS_XRELEASE = 1506
X86_INS_XRSTOR = 1507
X86_INS_XRSTOR64 = 1508
X86_INS_XRSTORS = 1509
X86_INS_XRSTORS64 = 1510
X86_INS_XSAVE = 1511
X86_INS_XSAVE64 = 1512
X86_INS_XSAVEC = 1513
X86_INS_XSAVEC64 = 1514
X86_INS_XSAVEOPT = 1515
X86_INS_XSAVEOPT64 = 1516
X86_INS_XSAVES = 1517
X86_INS_XSAVES64 = 1518
X86_INS_XSETBV = 1519
X86_INS_XSHA1 = 1520
X86_INS_XSHA256 = 1521
X86_INS_XSTORE = 1522
X86_INS_XTEST = 1523
X86_INS_ENDING = 1524
X86_GRP_INVALID = 0
X86_GRP_JUMP = 1
X86_GRP_CALL = 2
X86_GRP_RET = 3
X86_GRP_INT = 4
X86_GRP_IRET = 5
X86_GRP_PRIVILEGE = 6
X86_GRP_BRANCH_RELATIVE = 7
X86_GRP_VM = 128
X86_GRP_3DNOW = 129
X86_GRP_AES = 130
X86_GRP_ADX = 131
X86_GRP_AVX = 132
X86_GRP_AVX2 = 133
X86_GRP_AVX512 = 134
X86_GRP_BMI = 135
X86_GRP_BMI2 = 136
X86_GRP_CMOV = 137
X86_GRP_F16C = 138
X86_GRP_FMA = 139
X86_GRP_FMA4 = 140
X86_GRP_FSGSBASE = 141
X86_GRP_HLE = 142
X86_GRP_MMX = 143
X86_GRP_MODE32 = 144
X86_GRP_MODE64 = 145
X86_GRP_RTM = 146
X86_GRP_SHA = 147
X86_GRP_SSE1 = 148
X86_GRP_SSE2 = 149
X86_GRP_SSE3 = 150
X86_GRP_SSE41 = 151
X86_GRP_SSE42 = 152
X86_GRP_SSE4A = 153
X86_GRP_SSSE3 = 154
X86_GRP_PCLMUL = 155
X86_GRP_XOP = 156
X86_GRP_CDI = 157
X86_GRP_ERI = 158
X86_GRP_TBM = 159
X86_GRP_16BITMODE = 160
X86_GRP_NOT64BITMODE = 161
X86_GRP_SGX = 162
X86_GRP_DQI = 163
X86_GRP_BWI = 164
X86_GRP_PFI = 165
X86_GRP_VLX = 166
X86_GRP_SMAP = 167
X86_GRP_NOVLX = 168
X86_GRP_FPU = 169
X86_GRP_ENDING = 170
|
""" Taller 2.2 Espacios de Color #
Tu nombre aquí
Mayo xx-XX """
# Definición de Funciones (Dividir)
#======================================================================
# E S P A C I O P R E _ _ C O N F I G U R A D O
# =====================================================================
def convertir_yiq_a_rva(y,i,q):
"""
Parameters
----------
y,i,q:float
valores del espacio de color YIQ
Returns
-------
r,v,a:float
valores del espacio de color RVA
"""
r = y+0.955*i+0.618*q
v = y-0.271*i-0.645*q
a = y-1.11*i+1.7*q
return r,v,a
#-------------------------------------------
def convertir_yiq_a_ycbcr(y,i,q):
"""
Parameters
----------
y,i,q:float
valores del espacio de color YIQ
Returns
-------
y,cb,cr:float
valores del espacio de color YCbCr
"""
#Se hace aqui la conversión intermedia
r = y+0.955*i+0.618*q
v = y-0.271*i-0.645*q
a = y-1.11*i+1.7*q
#Se hace aqui la conversión que se pide
y = 0.299*r+0.587*v+0.114*a
cb = 0.1687*r-0.3313*v-0.5*a
cr = 0.5*r-0.418*v+0.0813*a
return y,cb,cr
#======================================================================
# E S P A C I O D E T R A B A J O A L U M N O
# =====================================================================
def convertir_rva_a_yiq(r,v,a):
#TODO: comentarios
#TODO: instrucciones
y=0
i=0
q=0
return y,i,q
#-------------------------------------------
def convertir_rva_a_ycbcr(r,v,a):
#TODO: comentarios
#TODO: instrucciones
y=0
cb=0
cr=0
return y,cb,cr
#-------------------------------------------
def convertir_ycbcr_a_yiq(y,cb,cr):
#TODO: comentarios
#TODO: instrucciones
y=0
i=0
q=0
return y,i,q
def convertir_ycbcr_a_rva(y,cb,cr):
#TODO: comentarios
#TODO: instrucciones
r=0
v=0
a=0
return r,v,a
#======================================================================
# Algoritmo principal Punto de entrada a la aplicación (Conquistar)
# =====================================================================
#lectura espacio de color RVA
r = float(input("Digite el valor de r:"))
v = float(input("Digite el valor de v:"))
a = float(input("Digite el valor de a:"))
#lectura espacio de color YIQ
y = float(input("Digite el valor de Y:"))
i = float(input("Digite el valor de I:"))
q = float(input("Digite el valor de Q:"))
#lectura espacio de color YCbCr
y = float(input("Digite el valor de Y:"))
cb = float(input("Digite el valor de Cb:"))
cr = float(input("Digite el valor de Cr:"))
#Llamado/invocación de funciones
#Se utilizan otras variables para gurdar lo que retorna la funciòn
#para no cambiar el valor de las entradas por teclado
rt,vt,at= convertir_yiq_a_rva(y,i,q)
print("la conversión de yiq a rva es","r=",rt,"v=",vt,"a=",at)
yt,cbt,crt=convertir_yiq_a_ycbcr(y,i,q)
print("la conversión de yiq a ycbcr es","y=",yt,"cb=",cbt,"cr=",crt)
#======================================================================
# E S P A C I O D E T R A B A J O A L U M N O
# =====================================================================
#TODO: realizar los llamados a las funciones faltantes
|
n = int(input())
d = []
for i in range(n):
d.append(input())
# [d1, d2, d3, ..., dN]
a = [int(m) for m in d]#int型に直す
ans = 0
for i in range(n):
if i == n - 1:
ans += a[i] // 2
else:
ans += a[i] // 2
ans += (a[i + 1] + a[i] % 2) // 2
if a[i + 1] > 0:
a[i + 1] = a[i + 1] + a[i] % 2 - ((a[i + 1] + a[i] % 2) // 2) * 2
else:
a[i + 1] = 0
print(ans) |
class FileParser:
def __init__(self, filepath):
self.filepath = filepath
def GetNonEmptyLinesAsList(self):
with open(self.filepath, "r") as f:
return [line for line in f.readlines() if line and line != "\n"]
|
#Altere os exercicios e armazene em um vetor as idades.
a=int(input("Digite quantas vezes vc quer informar a idade"))
i=0
n=[]
for i in range(a):
n.append(int(input("Digite uma idade")))
i=i+1
print (n)
|
# -*- coding: utf-8 -*-
"""
Settings for the game that can be modified.
"""
__author__ = "Jakrin Juangbhanich"
__email__ = "juangbhanich.k@gmail.com"
N_HINT_TOKENS_MAX = 8
N_FUSE_TOKENS_MAX = 3
N_PLAYERS = 4
N_SIMULATIONS = 1
CARD_DECK_DISTRIBUTION = [1, 1, 1, 2, 2, 3, 3, 4, 4, 5]
|
num = int(input("Enter Any Number : "))
if num % 2 == 1:
print(num, " is odd!")
elif num % 2 == 0:
print(num, " is even!")
else:
print("Error")
|
def conference_picker(cities_visited, cities_offered):
for city in cities_offered:
if city not in cities_visited:
return city
return 'No worthwhile conferences this year!' |
#!/usr/bin/env python
"""
@package package_generator_template
@file functions.py
@author Anthony Remazeilles
@brief List of aditional functions that can be used in the template
Copyright (C) 2018 Tecnalia Research and Innovation
Distributed under the Apache 2.0 license.
"""
def get_package_type(context):
"""extract the package the type belong to
Args:
context (dict): context (related to an interface description)
Returns:
str: the package extracted from the type key
Examples:
>>> context = {name: "misc", type={std_msgs::String}, desc="an interface"}
>>> get_package_type(context)
std_msgs
"""
return context['type'].split("::")[0]
def get_class_type(context):
"""extract the Class related to the type, in C++ format
Args:
context (dict): context (related to an interface description)
Returns:
str: The class extracted from the type
Examples:
>>> context = {name: "misc", type={std_msgs::String}, desc="an interface"}
>>> get_class_type(context)
String
"""
return context['type'].split("::")[1]
def get_python_type(context):
"""extract the type of an object in python format
Args:
context (dict): context (related to an interface description)
Returns:
str: the type of the interface written in python format
Examples:
>>> context = {name: "misc", type={std_msgs::String}, desc="an interface"}
>>> get_python_type(context)
"std_msgs.String"
"""
return context['type'].replace("::", ".")
def get_cpp_path(context):
"""convert the type content into a path format
Args:
context (dict): context (related to an interface description)
Returns:
str: conversion in cpp path format of the type
Examples:
>>> context = {name: "misc", type={std_msgs::String}, desc="an interface"}
>>> get_cpp_path(context)
"std_msgs/String"
"""
return context['type'].replace("::", "/")
def get_py_param_type(context):
"""convert a param type into python accepted format.
Related to the formats accepted by the parameter under dynamic reconfigure
Args:
context (dict): context (related to an interface description)
Returns:
str: variable type in python format related to param components
Examples:
>>> context = {desc="an interface" name="misc" type="std::string"/>
>>> get_py_param_type(context)
"str_t"
"""
param_type = context['type']
if param_type not in ['std::string', 'string', 'int', 'double', 'bool']:
raise SyntaxError("Invalid type for param {}".format(param_type))
if param_type in ['std::string', 'string']:
return 'str_t'
if param_type == 'int':
return 'int_t'
if param_type == 'double':
return 'double_t'
if param_type == 'bool':
return 'bool_t'
def get_py_param_value(context):
"""Extract the value of a parameter.
Dedicated to parameters under dynamic reconfigure
Args:
context (dict): context (related to an param description)
Returns:
str: The value of the parameter as a string
Examples:
>>> context = {desc="an interface" type="std::string" value="Hello"/>
>>> get_py_param_value(context)
"\"Hello\""
>>> context = {desc="an interface" type="bool" value="1"/>
>>> get_py_param_value(context)
"True"
"""
param_type = context['type']
if param_type not in ['std::string', 'string', 'int', 'double', 'bool']:
msg = "Invalid type for param {}".format(param_type)
msg += "\n autorized type: std::string, string, int, double, bool]"
raise SyntaxError(msg)
if param_type in ['std::string', 'string']:
return "\"{}\"".format(context['value'])
if param_type == 'bool':
return "{}".format(str2bool(context['value']))
return context['value']
def get_cpp_param_value(context):
"""Extract the value of a parameter, in cpp format.
Similar to get_py_param_value, except for booleans that are true or false
Args:
context (dict): context (related to an param description)
Returns:
str: The value of the parameter as a string
Examples:
>>> context = {desc="an interface" type="bool" value="1"/>
>>> get_py_param_type(context)
"true"
"""
param_type = context['type']
if param_type not in ['std::string', 'string', 'int', 'double', 'bool']:
msg = "Invalid type for param {}".format(param_type)
msg += "\n autorized type: [std::string, string, int, double, bool]"
raise SyntaxError(msg)
if param_type in ['std::string', 'string']:
return "\"{}\"".format(context['value'])
if param_type == 'bool':
if str2bool(context['value']):
return "true"
else:
return "false"
return context['value']
def str2bool(strg):
"""convert a string into boolean value
Several format are accepted for True.
What is not True is considered as False
Args:
strg (str): string containing a boolean value
Returns:
Bool: corresponding boolean value
"""
return strg.lower() in ("yes", "true", "t", "1")
def capitalized_comp_name(context):
"""return the component name in capitalized format
Args:
context (dict): complete package and component transformation
Returns:
str: component name in capitalized format, underscore being removed.
Examples:
>>> context = {componentName="another_comp" frecuency="100"/>
>>> capitalized_comp_name(context)
"AnotherComp"
"""
return context['componentName'].title().replace("_", "")
def dependencies_from_template():
"""provides the dependencies required by the template
Returns:
list: list of ROS package dependency required by the template
"""
return ['roscpp']
def dependencies_from_interface(interface_name, context):
"""return package dependencies according to the interface name
Args:
interface_name (str): name of the interface to consider
context (dict): attributes assigned by the User to such instance
Returns:
list: List of dependencies that should be added according to
the interface used and the attributes values
"""
list_dep = []
type_field = ['publisher', 'directPublisher', 'directSubscriber',
'subscriber', 'serviceClient', 'serviceServer',
'actionServer', 'actionClient']
if interface_name in type_field:
pkg_dep = get_package_type(context)
list_dep.append(pkg_dep)
if interface_name in ['actionClient', 'actionServer']:
list_dep.append('actionlib')
list_dep.append('actionlib_msgs')
if interface_name in ['listener', 'broadcaster']:
list_dep.append('tf')
if interface_name == 'dynParameter':
list_dep.append('dynamic_reconfigure')
return list_dep
|
# -*- coding: utf-8 -*-
#
# Automatically generated from unicode.xml by gen_xml_dic.py
#
uni2latex = {
0x0023: '\\#',
0x0024: '\\textdollar',
0x0025: '\\%',
0x0026: '\\&',
0x0027: '\\textquotesingle',
0x002A: '\\ast',
0x005C: '\\textbackslash',
0x005E: '\\^{}',
0x005F: '\\_',
0x0060: '\\textasciigrave',
0x007B: '\\lbrace',
0x007C: '\\vert',
0x007D: '\\rbrace',
0x007E: '\\textasciitilde',
0x00A0: '~',
0x00A1: '\\textexclamdown',
0x00A2: '\\textcent',
0x00A3: '\\textsterling',
0x00A4: '\\textcurrency',
0x00A5: '\\textyen',
0x00A6: '\\textbrokenbar',
0x00A7: '\\textsection',
0x00A8: '\\textasciidieresis',
0x00A9: '\\textcopyright',
0x00AA: '\\textordfeminine',
0x00AB: '\\guillemotleft',
0x00AC: '\\lnot',
0x00AD: '\\-',
0x00AE: '\\textregistered',
0x00AF: '\\textasciimacron',
0x00B0: '\\textdegree',
0x00B1: '\\pm',
0x00B2: '{^2}',
0x00B3: '{^3}',
0x00B4: '\\textasciiacute',
0x00B5: '\\mathrm{\\mu}',
0x00B6: '\\textparagraph',
0x00B7: '\\cdot',
0x00B8: '\\c{}',
0x00B9: '{^1}',
0x00BA: '\\textordmasculine',
0x00BB: '\\guillemotright',
0x00BC: '\\textonequarter',
0x00BD: '\\textonehalf',
0x00BE: '\\textthreequarters',
0x00BF: '\\textquestiondown',
0x00C0: '\\`{A}',
0x00C1: "\\'{A}",
0x00C2: '\\^{A}',
0x00C3: '\\~{A}',
0x00C4: '\\"{A}',
0x00C5: '\\AA',
0x00C6: '\\AE',
0x00C7: '\\c{C}',
0x00C8: '\\`{E}',
0x00C9: "\\'{E}",
0x00CA: '\\^{E}',
0x00CB: '\\"{E}',
0x00CC: '\\`{I}',
0x00CD: "\\'{I}",
0x00CE: '\\^{I}',
0x00CF: '\\"{I}',
0x00D0: '\\DH',
0x00D1: '\\~{N}',
0x00D2: '\\`{O}',
0x00D3: "\\'{O}",
0x00D4: '\\^{O}',
0x00D5: '\\~{O}',
0x00D6: '\\"{O}',
0x00D7: '\\texttimes',
0x00D8: '\\O',
0x00D9: '\\`{U}',
0x00DA: "\\'{U}",
0x00DB: '\\^{U}',
0x00DC: '\\"{U}',
0x00DD: "\\'{Y}",
0x00DE: '\\TH',
0x00DF: '\\ss',
0x00E0: '\\`{a}',
0x00E1: "\\'{a}",
0x00E2: '\\^{a}',
0x00E3: '\\~{a}',
0x00E4: '\\"{a}',
0x00E5: '\\aa',
0x00E6: '\\ae',
0x00E7: '\\c{c}',
0x00E8: '\\`{e}',
0x00E9: "\\'{e}",
0x00EA: '\\^{e}',
0x00EB: '\\"{e}',
0x00EC: '\\`{\\i}',
0x00ED: "\\'{\\i}",
0x00EE: '\\^{\\i}',
0x00EF: '\\"{\\i}',
0x00F0: '\\dh',
0x00F1: '\\~{n}',
0x00F2: '\\`{o}',
0x00F3: "\\'{o}",
0x00F4: '\\^{o}',
0x00F5: '\\~{o}',
0x00F6: '\\"{o}',
0x00F7: '\\div',
0x00F8: '\\o',
0x00F9: '\\`{u}',
0x00FA: "\\'{u}",
0x00FB: '\\^{u}',
0x00FC: '\\"{u}',
0x00FD: "\\'{y}",
0x00FE: '\\th',
0x00FF: '\\"{y}',
0x0100: '\\={A}',
0x0101: '\\={a}',
0x0102: '\\u{A}',
0x0103: '\\u{a}',
0x0104: '\\k{A}',
0x0105: '\\k{a}',
0x0106: "\\'{C}",
0x0107: "\\'{c}",
0x0108: '\\^{C}',
0x0109: '\\^{c}',
0x010A: '\\.{C}',
0x010B: '\\.{c}',
0x010C: '\\v{C}',
0x010D: '\\v{c}',
0x010E: '\\v{D}',
0x010F: '\\v{d}',
0x0110: '\\DJ',
0x0111: '\\dj',
0x0112: '\\={E}',
0x0113: '\\={e}',
0x0114: '\\u{E}',
0x0115: '\\u{e}',
0x0116: '\\.{E}',
0x0117: '\\.{e}',
0x0118: '\\k{E}',
0x0119: '\\k{e}',
0x011A: '\\v{E}',
0x011B: '\\v{e}',
0x011C: '\\^{G}',
0x011D: '\\^{g}',
0x011E: '\\u{G}',
0x011F: '\\u{g}',
0x0120: '\\.{G}',
0x0121: '\\.{g}',
0x0122: '\\c{G}',
0x0123: '\\c{g}',
0x0124: '\\^{H}',
0x0125: '\\^{h}',
0x0126: '{\\fontencoding{LELA}\\selectfont\\char40}',
0x0128: '\\~{I}',
0x0129: '\\~{\\i}',
0x012A: '\\={I}',
0x012B: '\\={\\i}',
0x012C: '\\u{I}',
0x012D: '\\u{\\i}',
0x012E: '\\k{I}',
0x012F: '\\k{i}',
0x0130: '\\.{I}',
0x0131: '\\i',
0x0132: 'IJ',
0x0133: 'ij',
0x0134: '\\^{J}',
0x0135: '\\^{\\j}',
0x0136: '\\c{K}',
0x0137: '\\c{k}',
0x0138: '{\\fontencoding{LELA}\\selectfont\\char91}',
0x0139: "\\'{L}",
0x013A: "\\'{l}",
0x013B: '\\c{L}',
0x013C: '\\c{l}',
0x013D: '\\v{L}',
0x013E: '\\v{l}',
0x013F: '{\\fontencoding{LELA}\\selectfont\\char201}',
0x0140: '{\\fontencoding{LELA}\\selectfont\\char202}',
0x0141: '\\L',
0x0142: '\\l',
0x0143: "\\'{N}",
0x0144: "\\'{n}",
0x0145: '\\c{N}',
0x0146: '\\c{n}',
0x0147: '\\v{N}',
0x0148: '\\v{n}',
0x0149: "'n",
0x014A: '\\NG',
0x014B: '\\ng',
0x014C: '\\={O}',
0x014D: '\\={o}',
0x014E: '\\u{O}',
0x014F: '\\u{o}',
0x0150: '\\H{O}',
0x0151: '\\H{o}',
0x0152: '\\OE',
0x0153: '\\oe',
0x0154: "\\'{R}",
0x0155: "\\'{r}",
0x0156: '\\c{R}',
0x0157: '\\c{r}',
0x0158: '\\v{R}',
0x0159: '\\v{r}',
0x015A: "\\'{S}",
0x015B: "\\'{s}",
0x015C: '\\^{S}',
0x015D: '\\^{s}',
0x015E: '\\c{S}',
0x015F: '\\c{s}',
0x0160: '\\v{S}',
0x0161: '\\v{s}',
0x0162: '\\c{T}',
0x0163: '\\c{t}',
0x0164: '\\v{T}',
0x0165: '\\v{t}',
0x0166: '{\\fontencoding{LELA}\\selectfont\\char47}',
0x0167: '{\\fontencoding{LELA}\\selectfont\\char63}',
0x0168: '\\~{U}',
0x0169: '\\~{u}',
0x016A: '\\={U}',
0x016B: '\\={u}',
0x016C: '\\u{U}',
0x016D: '\\u{u}',
0x016E: '\\r{U}',
0x016F: '\\r{u}',
0x0170: '\\H{U}',
0x0171: '\\H{u}',
0x0172: '\\k{U}',
0x0173: '\\k{u}',
0x0174: '\\^{W}',
0x0175: '\\^{w}',
0x0176: '\\^{Y}',
0x0177: '\\^{y}',
0x0178: '\\"{Y}',
0x0179: "\\'{Z}",
0x017A: "\\'{z}",
0x017B: '\\.{Z}',
0x017C: '\\.{z}',
0x017D: '\\v{Z}',
0x017E: '\\v{z}',
0x0192: 'f',
0x0195: '\\texthvlig',
0x019E: '\\textnrleg',
0x01AA: '\\eth',
0x01BA: '{\\fontencoding{LELA}\\selectfont\\char195}',
0x01C2: '\\textdoublepipe',
0x01F5: "\\'{g}",
0x0258: '{\\fontencoding{LEIP}\\selectfont\\char61}',
0x025B: '\\varepsilon',
0x0261: 'g',
0x0278: '\\textphi',
0x027F: '{\\fontencoding{LEIP}\\selectfont\\char202}',
0x029E: '\\textturnk',
0x02BC: "'",
0x02C7: '\\textasciicaron',
0x02D8: '\\textasciibreve',
0x02D9: '\\textperiodcentered',
0x02DA: '\\r{}',
0x02DB: '\\k{}',
0x02DC: '\\texttildelow',
0x02DD: '\\H{}',
0x02E5: '\\tone{55}',
0x02E6: '\\tone{44}',
0x02E7: '\\tone{33}',
0x02E8: '\\tone{22}',
0x02E9: '\\tone{11}',
0x0300: '\\`',
0x0301: "\\'",
0x0302: '\\^',
0x0303: '\\~',
0x0304: '\\=',
0x0306: '\\u',
0x0307: '\\.',
0x0308: '\\"',
0x030A: '\\r',
0x030B: '\\H',
0x030C: '\\v',
0x030F: '\\cyrchar\\C',
0x0311: '{\\fontencoding{LECO}\\selectfont\\char177}',
0x0318: '{\\fontencoding{LECO}\\selectfont\\char184}',
0x0319: '{\\fontencoding{LECO}\\selectfont\\char185}',
0x0327: '\\c',
0x0328: '\\k',
0x032B: '{\\fontencoding{LECO}\\selectfont\\char203}',
0x032F: '{\\fontencoding{LECO}\\selectfont\\char207}',
0x0337: '{\\fontencoding{LECO}\\selectfont\\char215}',
0x0338: '{\\fontencoding{LECO}\\selectfont\\char216}',
0x033A: '{\\fontencoding{LECO}\\selectfont\\char218}',
0x033B: '{\\fontencoding{LECO}\\selectfont\\char219}',
0x033C: '{\\fontencoding{LECO}\\selectfont\\char220}',
0x033D: '{\\fontencoding{LECO}\\selectfont\\char221}',
0x0361: '{\\fontencoding{LECO}\\selectfont\\char225}',
0x0386: "\\'{A}",
0x0388: "\\'{E}",
0x0389: "\\'{H}",
0x038A: "\\'{}{I}",
0x038C: "\\'{}O",
0x038E: "\\mathrm{'Y}",
0x038F: "\\mathrm{'\\Omega}",
0x0390: '\\acute{\\ddot{\\iota}}',
0x0391: '\\Alpha',
0x0392: '\\Beta',
0x0393: '\\Gamma',
0x0394: '\\Delta',
0x0395: '\\Epsilon',
0x0396: '\\Zeta',
0x0397: '\\Eta',
0x0398: '\\Theta',
0x0399: '\\Iota',
0x039A: '\\Kappa',
0x039B: '\\Lambda',
0x039C: 'M',
0x039D: 'N',
0x039E: '\\Xi',
0x039F: 'O',
0x03A0: '\\Pi',
0x03A1: '\\Rho',
0x03A3: '\\Sigma',
0x03A4: '\\Tau',
0x03A5: '\\Upsilon',
0x03A6: '\\Phi',
0x03A7: '\\Chi',
0x03A8: '\\Psi',
0x03A9: '\\Omega',
0x03AA: '\\mathrm{\\ddot{I}}',
0x03AB: '\\mathrm{\\ddot{Y}}',
0x03AC: "\\'{$\\alpha$}",
0x03AD: '\\acute{\\epsilon}',
0x03AE: '\\acute{\\eta}',
0x03AF: '\\acute{\\iota}',
0x03B0: '\\acute{\\ddot{\\upsilon}}',
0x03B1: '\\alpha',
0x03B2: '\\beta',
0x03B3: '\\gamma',
0x03B4: '\\delta',
0x03B5: '\\epsilon',
0x03B6: '\\zeta',
0x03B7: '\\eta',
0x03B8: '\\texttheta',
0x03B9: '\\iota',
0x03BA: '\\kappa',
0x03BB: '\\lambda',
0x03BC: '\\mu',
0x03BD: '\\nu',
0x03BE: '\\xi',
0x03BF: 'o',
0x03C0: '\\pi',
0x03C1: '\\rho',
0x03C2: '\\varsigma',
0x03C3: '\\sigma',
0x03C4: '\\tau',
0x03C5: '\\upsilon',
0x03C6: '\\varphi',
0x03C7: '\\chi',
0x03C8: '\\psi',
0x03C9: '\\omega',
0x03CA: '\\ddot{\\iota}',
0x03CB: '\\ddot{\\upsilon}',
0x03CC: "\\'{o}",
0x03CD: '\\acute{\\upsilon}',
0x03CE: '\\acute{\\omega}',
0x03D0: '\\Pisymbol{ppi022}{87}',
0x03D1: '\\textvartheta',
0x03D2: '\\Upsilon',
0x03D5: '\\phi',
0x03D6: '\\varpi',
0x03DA: '\\Stigma',
0x03DC: '\\Digamma',
0x03DD: '\\digamma',
0x03DE: '\\Koppa',
0x03E0: '\\Sampi',
0x03F0: '\\varkappa',
0x03F1: '\\varrho',
0x03F4: '\\textTheta',
0x03F6: '\\backepsilon',
0x0401: '\\cyrchar\\CYRYO',
0x0402: '\\cyrchar\\CYRDJE',
0x0403: "\\cyrchar{\\'\\CYRG}",
0x0404: '\\cyrchar\\CYRIE',
0x0405: '\\cyrchar\\CYRDZE',
0x0406: '\\cyrchar\\CYRII',
0x0407: '\\cyrchar\\CYRYI',
0x0408: '\\cyrchar\\CYRJE',
0x0409: '\\cyrchar\\CYRLJE',
0x040A: '\\cyrchar\\CYRNJE',
0x040B: '\\cyrchar\\CYRTSHE',
0x040C: "\\cyrchar{\\'\\CYRK}",
0x040E: '\\cyrchar\\CYRUSHRT',
0x040F: '\\cyrchar\\CYRDZHE',
0x0410: '\\cyrchar\\CYRA',
0x0411: '\\cyrchar\\CYRB',
0x0412: '\\cyrchar\\CYRV',
0x0413: '\\cyrchar\\CYRG',
0x0414: '\\cyrchar\\CYRD',
0x0415: '\\cyrchar\\CYRE',
0x0416: '\\cyrchar\\CYRZH',
0x0417: '\\cyrchar\\CYRZ',
0x0418: '\\cyrchar\\CYRI',
0x0419: '\\cyrchar\\CYRISHRT',
0x041A: '\\cyrchar\\CYRK',
0x041B: '\\cyrchar\\CYRL',
0x041C: '\\cyrchar\\CYRM',
0x041D: '\\cyrchar\\CYRN',
0x041E: '\\cyrchar\\CYRO',
0x041F: '\\cyrchar\\CYRP',
0x0420: '\\cyrchar\\CYRR',
0x0421: '\\cyrchar\\CYRS',
0x0422: '\\cyrchar\\CYRT',
0x0423: '\\cyrchar\\CYRU',
0x0424: '\\cyrchar\\CYRF',
0x0425: '\\cyrchar\\CYRH',
0x0426: '\\cyrchar\\CYRC',
0x0427: '\\cyrchar\\CYRCH',
0x0428: '\\cyrchar\\CYRSH',
0x0429: '\\cyrchar\\CYRSHCH',
0x042A: '\\cyrchar\\CYRHRDSN',
0x042B: '\\cyrchar\\CYRERY',
0x042C: '\\cyrchar\\CYRSFTSN',
0x042D: '\\cyrchar\\CYREREV',
0x042E: '\\cyrchar\\CYRYU',
0x042F: '\\cyrchar\\CYRYA',
0x0430: '\\cyrchar\\cyra',
0x0431: '\\cyrchar\\cyrb',
0x0432: '\\cyrchar\\cyrv',
0x0433: '\\cyrchar\\cyrg',
0x0434: '\\cyrchar\\cyrd',
0x0435: '\\cyrchar\\cyre',
0x0436: '\\cyrchar\\cyrzh',
0x0437: '\\cyrchar\\cyrz',
0x0438: '\\cyrchar\\cyri',
0x0439: '\\cyrchar\\cyrishrt',
0x043A: '\\cyrchar\\cyrk',
0x043B: '\\cyrchar\\cyrl',
0x043C: '\\cyrchar\\cyrm',
0x043D: '\\cyrchar\\cyrn',
0x043E: '\\cyrchar\\cyro',
0x043F: '\\cyrchar\\cyrp',
0x0440: '\\cyrchar\\cyrr',
0x0441: '\\cyrchar\\cyrs',
0x0442: '\\cyrchar\\cyrt',
0x0443: '\\cyrchar\\cyru',
0x0444: '\\cyrchar\\cyrf',
0x0445: '\\cyrchar\\cyrh',
0x0446: '\\cyrchar\\cyrc',
0x0447: '\\cyrchar\\cyrch',
0x0448: '\\cyrchar\\cyrsh',
0x0449: '\\cyrchar\\cyrshch',
0x044A: '\\cyrchar\\cyrhrdsn',
0x044B: '\\cyrchar\\cyrery',
0x044C: '\\cyrchar\\cyrsftsn',
0x044D: '\\cyrchar\\cyrerev',
0x044E: '\\cyrchar\\cyryu',
0x044F: '\\cyrchar\\cyrya',
0x0451: '\\cyrchar\\cyryo',
0x0452: '\\cyrchar\\cyrdje',
0x0453: "\\cyrchar{\\'\\cyrg}",
0x0454: '\\cyrchar\\cyrie',
0x0455: '\\cyrchar\\cyrdze',
0x0456: '\\cyrchar\\cyrii',
0x0457: '\\cyrchar\\cyryi',
0x0458: '\\cyrchar\\cyrje',
0x0459: '\\cyrchar\\cyrlje',
0x045A: '\\cyrchar\\cyrnje',
0x045B: '\\cyrchar\\cyrtshe',
0x045C: "\\cyrchar{\\'\\cyrk}",
0x045E: '\\cyrchar\\cyrushrt',
0x045F: '\\cyrchar\\cyrdzhe',
0x0460: '\\cyrchar\\CYROMEGA',
0x0461: '\\cyrchar\\cyromega',
0x0462: '\\cyrchar\\CYRYAT',
0x0464: '\\cyrchar\\CYRIOTE',
0x0465: '\\cyrchar\\cyriote',
0x0466: '\\cyrchar\\CYRLYUS',
0x0467: '\\cyrchar\\cyrlyus',
0x0468: '\\cyrchar\\CYRIOTLYUS',
0x0469: '\\cyrchar\\cyriotlyus',
0x046A: '\\cyrchar\\CYRBYUS',
0x046C: '\\cyrchar\\CYRIOTBYUS',
0x046D: '\\cyrchar\\cyriotbyus',
0x046E: '\\cyrchar\\CYRKSI',
0x046F: '\\cyrchar\\cyrksi',
0x0470: '\\cyrchar\\CYRPSI',
0x0471: '\\cyrchar\\cyrpsi',
0x0472: '\\cyrchar\\CYRFITA',
0x0474: '\\cyrchar\\CYRIZH',
0x0478: '\\cyrchar\\CYRUK',
0x0479: '\\cyrchar\\cyruk',
0x047A: '\\cyrchar\\CYROMEGARND',
0x047B: '\\cyrchar\\cyromegarnd',
0x047C: '\\cyrchar\\CYROMEGATITLO',
0x047D: '\\cyrchar\\cyromegatitlo',
0x047E: '\\cyrchar\\CYROT',
0x047F: '\\cyrchar\\cyrot',
0x0480: '\\cyrchar\\CYRKOPPA',
0x0481: '\\cyrchar\\cyrkoppa',
0x0482: '\\cyrchar\\cyrthousands',
0x0488: '\\cyrchar\\cyrhundredthousands',
0x0489: '\\cyrchar\\cyrmillions',
0x048C: '\\cyrchar\\CYRSEMISFTSN',
0x048D: '\\cyrchar\\cyrsemisftsn',
0x048E: '\\cyrchar\\CYRRTICK',
0x048F: '\\cyrchar\\cyrrtick',
0x0490: '\\cyrchar\\CYRGUP',
0x0491: '\\cyrchar\\cyrgup',
0x0492: '\\cyrchar\\CYRGHCRS',
0x0493: '\\cyrchar\\cyrghcrs',
0x0494: '\\cyrchar\\CYRGHK',
0x0495: '\\cyrchar\\cyrghk',
0x0496: '\\cyrchar\\CYRZHDSC',
0x0497: '\\cyrchar\\cyrzhdsc',
0x0498: '\\cyrchar\\CYRZDSC',
0x0499: '\\cyrchar\\cyrzdsc',
0x049A: '\\cyrchar\\CYRKDSC',
0x049B: '\\cyrchar\\cyrkdsc',
0x049C: '\\cyrchar\\CYRKVCRS',
0x049D: '\\cyrchar\\cyrkvcrs',
0x049E: '\\cyrchar\\CYRKHCRS',
0x049F: '\\cyrchar\\cyrkhcrs',
0x04A0: '\\cyrchar\\CYRKBEAK',
0x04A1: '\\cyrchar\\cyrkbeak',
0x04A2: '\\cyrchar\\CYRNDSC',
0x04A3: '\\cyrchar\\cyrndsc',
0x04A4: '\\cyrchar\\CYRNG',
0x04A5: '\\cyrchar\\cyrng',
0x04A6: '\\cyrchar\\CYRPHK',
0x04A7: '\\cyrchar\\cyrphk',
0x04A8: '\\cyrchar\\CYRABHHA',
0x04A9: '\\cyrchar\\cyrabhha',
0x04AA: '\\cyrchar\\CYRSDSC',
0x04AB: '\\cyrchar\\cyrsdsc',
0x04AC: '\\cyrchar\\CYRTDSC',
0x04AD: '\\cyrchar\\cyrtdsc',
0x04AE: '\\cyrchar\\CYRY',
0x04AF: '\\cyrchar\\cyry',
0x04B0: '\\cyrchar\\CYRYHCRS',
0x04B1: '\\cyrchar\\cyryhcrs',
0x04B2: '\\cyrchar\\CYRHDSC',
0x04B3: '\\cyrchar\\cyrhdsc',
0x04B4: '\\cyrchar\\CYRTETSE',
0x04B5: '\\cyrchar\\cyrtetse',
0x04B6: '\\cyrchar\\CYRCHRDSC',
0x04B7: '\\cyrchar\\cyrchrdsc',
0x04B8: '\\cyrchar\\CYRCHVCRS',
0x04B9: '\\cyrchar\\cyrchvcrs',
0x04BA: '\\cyrchar\\CYRSHHA',
0x04BB: '\\cyrchar\\cyrshha',
0x04BC: '\\cyrchar\\CYRABHCH',
0x04BD: '\\cyrchar\\cyrabhch',
0x04BE: '\\cyrchar\\CYRABHCHDSC',
0x04BF: '\\cyrchar\\cyrabhchdsc',
0x04C0: '\\cyrchar\\CYRpalochka',
0x04C3: '\\cyrchar\\CYRKHK',
0x04C4: '\\cyrchar\\cyrkhk',
0x04C7: '\\cyrchar\\CYRNHK',
0x04C8: '\\cyrchar\\cyrnhk',
0x04CB: '\\cyrchar\\CYRCHLDSC',
0x04CC: '\\cyrchar\\cyrchldsc',
0x04D4: '\\cyrchar\\CYRAE',
0x04D5: '\\cyrchar\\cyrae',
0x04D8: '\\cyrchar\\CYRSCHWA',
0x04D9: '\\cyrchar\\cyrschwa',
0x04E0: '\\cyrchar\\CYRABHDZE',
0x04E1: '\\cyrchar\\cyrabhdze',
0x04E8: '\\cyrchar\\CYROTLD',
0x04E9: '\\cyrchar\\cyrotld',
0x2002: '\\hspace{0.6em}',
0x2003: '\\hspace{1em}',
0x2004: '\\hspace{0.33em}',
0x2005: '\\hspace{0.25em}',
0x2006: '\\hspace{0.166em}',
0x2007: '\\hphantom{0}',
0x2008: '\\hphantom{,}',
0x2009: '\\hspace{0.167em}',
0x200A: '\\mkern1mu ',
0x2010: '-',
0x2013: '\\textendash',
0x2014: '\\textemdash',
0x2015: '\\rule{1em}{1pt}',
0x2016: '\\Vert',
0x2018: '`',
0x2019: "'",
0x201A: ',',
0x201C: '\\textquotedblleft',
0x201D: '\\textquotedblright',
0x201E: ',,',
0x2020: '\\textdagger',
0x2021: '\\textdaggerdbl',
0x2022: '\\textbullet',
0x2024: '.',
0x2025: '..',
0x2026: '\\ldots',
0x2030: '\\textperthousand',
0x2031: '\\textpertenthousand',
0x2032: "{'}",
0x2033: "{''}",
0x2034: "{'''}",
0x2035: '\\backprime',
0x2039: '\\guilsinglleft',
0x203A: '\\guilsinglright',
0x2057: "''''",
0x205F: '\\mkern4mu ',
0x2060: '\\nolinebreak',
0x20AC: '\\mbox{\\texteuro} ',
0x20DB: '\\dddot',
0x20DC: '\\ddddot',
0x2102: '\\mathbb{C}',
0x210A: '\\mathscr{g}',
0x210B: '\\mathscr{H}',
0x210C: '\\mathfrak{H}',
0x210D: '\\mathbb{H}',
0x210F: '\\hslash',
0x2110: '\\mathscr{I}',
0x2111: '\\mathfrak{I}',
0x2112: '\\mathscr{L}',
0x2113: '\\mathscr{l}',
0x2115: '\\mathbb{N}',
0x2116: '\\cyrchar\\textnumero',
0x2118: '\\wp',
0x2119: '\\mathbb{P}',
0x211A: '\\mathbb{Q}',
0x211B: '\\mathscr{R}',
0x211C: '\\mathfrak{R}',
0x211D: '\\mathbb{R}',
0x2122: '\\texttrademark',
0x2124: '\\mathbb{Z}',
0x2126: '\\Omega',
0x2127: '\\mho',
0x2128: '\\mathfrak{Z}',
0x212B: '\\AA',
0x212C: '\\mathscr{B}',
0x212D: '\\mathfrak{C}',
0x212F: '\\mathscr{e}',
0x2130: '\\mathscr{E}',
0x2131: '\\mathscr{F}',
0x2133: '\\mathscr{M}',
0x2134: '\\mathscr{o}',
0x2135: '\\aleph',
0x2136: '\\beth',
0x2137: '\\gimel',
0x2138: '\\daleth',
0x2153: '\\textfrac{1}{3}',
0x2154: '\\textfrac{2}{3}',
0x2155: '\\textfrac{1}{5}',
0x2156: '\\textfrac{2}{5}',
0x2157: '\\textfrac{3}{5}',
0x2158: '\\textfrac{4}{5}',
0x2159: '\\textfrac{1}{6}',
0x215A: '\\textfrac{5}{6}',
0x215B: '\\textfrac{1}{8}',
0x215C: '\\textfrac{3}{8}',
0x215D: '\\textfrac{5}{8}',
0x215E: '\\textfrac{7}{8}',
0x2190: '\\leftarrow',
0x2191: '\\uparrow',
0x2192: '\\rightarrow',
0x2193: '\\downarrow',
0x2194: '\\leftrightarrow',
0x2195: '\\updownarrow',
0x2196: '\\nwarrow',
0x2197: '\\nearrow',
0x2198: '\\searrow',
0x2199: '\\swarrow',
0x219A: '\\nleftarrow',
0x219B: '\\nrightarrow',
0x219C: '\\arrowwaveleft',
0x219D: '\\arrowwaveright',
0x219E: '\\twoheadleftarrow',
0x21A0: '\\twoheadrightarrow',
0x21A2: '\\leftarrowtail',
0x21A3: '\\rightarrowtail',
0x21A6: '\\mapsto',
0x21A9: '\\hookleftarrow',
0x21AA: '\\hookrightarrow',
0x21AB: '\\looparrowleft',
0x21AC: '\\looparrowright',
0x21AD: '\\leftrightsquigarrow',
0x21AE: '\\nleftrightarrow',
0x21B0: '\\Lsh',
0x21B1: '\\Rsh',
0x21B6: '\\curvearrowleft',
0x21B7: '\\curvearrowright',
0x21BA: '\\circlearrowleft',
0x21BB: '\\circlearrowright',
0x21BC: '\\leftharpoonup',
0x21BD: '\\leftharpoondown',
0x21BE: '\\upharpoonright',
0x21BF: '\\upharpoonleft',
0x21C0: '\\rightharpoonup',
0x21C1: '\\rightharpoondown',
0x21C2: '\\downharpoonright',
0x21C3: '\\downharpoonleft',
0x21C4: '\\rightleftarrows',
0x21C5: '\\dblarrowupdown',
0x21C6: '\\leftrightarrows',
0x21C7: '\\leftleftarrows',
0x21C8: '\\upuparrows',
0x21C9: '\\rightrightarrows',
0x21CA: '\\downdownarrows',
0x21CB: '\\leftrightharpoons',
0x21CC: '\\rightleftharpoons',
0x21CD: '\\nLeftarrow',
0x21CE: '\\nLeftrightarrow',
0x21CF: '\\nRightarrow',
0x21D0: '\\Leftarrow',
0x21D1: '\\Uparrow',
0x21D2: '\\Rightarrow',
0x21D3: '\\Downarrow',
0x21D4: '\\Leftrightarrow',
0x21D5: '\\Updownarrow',
0x21DA: '\\Lleftarrow',
0x21DB: '\\Rrightarrow',
0x21DD: '\\rightsquigarrow',
0x21F5: '\\DownArrowUpArrow',
0x2200: '\\forall',
0x2201: '\\complement',
0x2202: '\\partial',
0x2203: '\\exists',
0x2204: '\\nexists',
0x2205: '\\varnothing',
0x2207: '\\nabla',
0x2208: '\\in',
0x2209: '\\not\\in',
0x220B: '\\ni',
0x220C: '\\not\\ni',
0x220F: '\\prod',
0x2210: '\\coprod',
0x2211: '\\sum',
0x2212: '-',
0x2213: '\\mp',
0x2214: '\\dotplus',
0x2216: '\\setminus',
0x2217: '{_\\ast}',
0x2218: '\\circ',
0x2219: '\\bullet',
0x221A: '\\surd',
0x221D: '\\propto',
0x221E: '\\infty',
0x221F: '\\rightangle',
0x2220: '\\angle',
0x2221: '\\measuredangle',
0x2222: '\\sphericalangle',
0x2223: '\\mid',
0x2224: '\\nmid',
0x2225: '\\parallel',
0x2226: '\\nparallel',
0x2227: '\\wedge',
0x2228: '\\vee',
0x2229: '\\cap',
0x222A: '\\cup',
0x222B: '\\int',
0x222C: '\\int\\!\\int',
0x222D: '\\int\\!\\int\\!\\int',
0x222E: '\\oint',
0x222F: '\\surfintegral',
0x2230: '\\volintegral',
0x2231: '\\clwintegral',
0x2234: '\\therefore',
0x2235: '\\because',
0x2237: '\\Colon',
0x223A: '\\mathbin{{:}\\!\\!{-}\\!\\!{:}}',
0x223B: '\\homothetic',
0x223C: '\\sim',
0x223D: '\\backsim',
0x223E: '\\lazysinv',
0x2240: '\\wr',
0x2241: '\\not\\sim',
0x2243: '\\simeq',
0x2244: '\\not\\simeq',
0x2245: '\\cong',
0x2246: '\\approxnotequal',
0x2247: '\\not\\cong',
0x2248: '\\approx',
0x2249: '\\not\\approx',
0x224A: '\\approxeq',
0x224B: '\\tildetrpl',
0x224C: '\\allequal',
0x224D: '\\asymp',
0x224E: '\\Bumpeq',
0x224F: '\\bumpeq',
0x2250: '\\doteq',
0x2251: '\\doteqdot',
0x2252: '\\fallingdotseq',
0x2253: '\\risingdotseq',
0x2254: ':=',
0x2255: '=:',
0x2256: '\\eqcirc',
0x2257: '\\circeq',
0x2259: '\\estimates',
0x225B: '\\starequal',
0x225C: '\\triangleq',
0x2260: '\\not =',
0x2261: '\\equiv',
0x2262: '\\not\\equiv',
0x2264: '\\leq',
0x2265: '\\geq',
0x2266: '\\leqq',
0x2267: '\\geqq',
0x2268: '\\lneqq',
0x2269: '\\gneqq',
0x226A: '\\ll',
0x226B: '\\gg',
0x226C: '\\between',
0x226D: '\\not\\kern-0.3em\\times',
0x226E: '\\not<',
0x226F: '\\not>',
0x2270: '\\not\\leq',
0x2271: '\\not\\geq',
0x2272: '\\lessequivlnt',
0x2273: '\\greaterequivlnt',
0x2276: '\\lessgtr',
0x2277: '\\gtrless',
0x2278: '\\notlessgreater',
0x2279: '\\notgreaterless',
0x227A: '\\prec',
0x227B: '\\succ',
0x227C: '\\preccurlyeq',
0x227D: '\\succcurlyeq',
0x227E: '\\precapprox',
0x227F: '\\succapprox',
0x2280: '\\not\\prec',
0x2281: '\\not\\succ',
0x2282: '\\subset',
0x2283: '\\supset',
0x2284: '\\not\\subset',
0x2285: '\\not\\supset',
0x2286: '\\subseteq',
0x2287: '\\supseteq',
0x2288: '\\not\\subseteq',
0x2289: '\\not\\supseteq',
0x228A: '\\subsetneq',
0x228B: '\\supsetneq',
0x228E: '\\uplus',
0x228F: '\\sqsubset',
0x2290: '\\sqsupset',
0x2291: '\\sqsubseteq',
0x2292: '\\sqsupseteq',
0x2293: '\\sqcap',
0x2294: '\\sqcup',
0x2295: '\\oplus',
0x2296: '\\ominus',
0x2297: '\\otimes',
0x2298: '\\oslash',
0x2299: '\\odot',
0x229A: '\\circledcirc',
0x229B: '\\circledast',
0x229D: '\\circleddash',
0x229E: '\\boxplus',
0x229F: '\\boxminus',
0x22A0: '\\boxtimes',
0x22A1: '\\boxdot',
0x22A2: '\\vdash',
0x22A3: '\\dashv',
0x22A4: '\\top',
0x22A5: '\\perp',
0x22A7: '\\truestate',
0x22A8: '\\forcesextra',
0x22A9: '\\Vdash',
0x22AA: '\\Vvdash',
0x22AB: '\\VDash',
0x22AC: '\\nvdash',
0x22AD: '\\nvDash',
0x22AE: '\\nVdash',
0x22AF: '\\nVDash',
0x22B2: '\\vartriangleleft',
0x22B3: '\\vartriangleright',
0x22B4: '\\trianglelefteq',
0x22B5: '\\trianglerighteq',
0x22B6: '\\original',
0x22B7: '\\image',
0x22B8: '\\multimap',
0x22B9: '\\hermitconjmatrix',
0x22BA: '\\intercal',
0x22BB: '\\veebar',
0x22BE: '\\rightanglearc',
0x22C2: '\\bigcap',
0x22C3: '\\bigcup',
0x22C4: '\\diamond',
0x22C5: '\\cdot',
0x22C6: '\\star',
0x22C7: '\\divideontimes',
0x22C8: '\\bowtie',
0x22C9: '\\ltimes',
0x22CA: '\\rtimes',
0x22CB: '\\leftthreetimes',
0x22CC: '\\rightthreetimes',
0x22CD: '\\backsimeq',
0x22CE: '\\curlyvee',
0x22CF: '\\curlywedge',
0x22D0: '\\Subset',
0x22D1: '\\Supset',
0x22D2: '\\Cap',
0x22D3: '\\Cup',
0x22D4: '\\pitchfork',
0x22D6: '\\lessdot',
0x22D7: '\\gtrdot',
0x22D8: '\\verymuchless',
0x22D9: '\\verymuchgreater',
0x22DA: '\\lesseqgtr',
0x22DB: '\\gtreqless',
0x22DE: '\\curlyeqprec',
0x22DF: '\\curlyeqsucc',
0x22E2: '\\not\\sqsubseteq',
0x22E3: '\\not\\sqsupseteq',
0x22E6: '\\lnsim',
0x22E7: '\\gnsim',
0x22E8: '\\precedesnotsimilar',
0x22E9: '\\succnsim',
0x22EA: '\\ntriangleleft',
0x22EB: '\\ntriangleright',
0x22EC: '\\ntrianglelefteq',
0x22ED: '\\ntrianglerighteq',
0x22EE: '\\vdots',
0x22EF: '\\cdots',
0x22F0: '\\upslopeellipsis',
0x22F1: '\\downslopeellipsis',
0x2305: '\\barwedge',
0x2306: '\\varperspcorrespond',
0x2308: '\\lceil',
0x2309: '\\rceil',
0x230A: '\\lfloor',
0x230B: '\\rfloor',
0x2315: '\\recorder',
0x2316: '\\mathchar"2208',
0x231C: '\\ulcorner',
0x231D: '\\urcorner',
0x231E: '\\llcorner',
0x231F: '\\lrcorner',
0x2322: '\\frown',
0x2323: '\\smile',
0x23B0: '\\lmoustache',
0x23B1: '\\rmoustache',
0x2423: '\\textvisiblespace',
0x2460: '\\ding{172}',
0x2461: '\\ding{173}',
0x2462: '\\ding{174}',
0x2463: '\\ding{175}',
0x2464: '\\ding{176}',
0x2465: '\\ding{177}',
0x2466: '\\ding{178}',
0x2467: '\\ding{179}',
0x2468: '\\ding{180}',
0x2469: '\\ding{181}',
0x24C8: '\\circledS',
0x2571: '\\diagup',
0x25A0: '\\ding{110}',
0x25A1: '\\square',
0x25AA: '\\blacksquare',
0x25AD: '\\fbox{~~}',
0x25B2: '\\ding{115}',
0x25B3: '\\bigtriangleup',
0x25B4: '\\blacktriangle',
0x25B5: '\\vartriangle',
0x25B8: '\\blacktriangleright',
0x25B9: '\\triangleright',
0x25BC: '\\ding{116}',
0x25BD: '\\bigtriangledown',
0x25BE: '\\blacktriangledown',
0x25BF: '\\triangledown',
0x25C2: '\\blacktriangleleft',
0x25C3: '\\triangleleft',
0x25C6: '\\ding{117}',
0x25CA: '\\lozenge',
0x25CB: '\\bigcirc',
0x25CF: '\\ding{108}',
0x25D7: '\\ding{119}',
0x25EF: '\\bigcirc',
0x2605: '\\ding{72}',
0x2606: '\\ding{73}',
0x260E: '\\ding{37}',
0x261B: '\\ding{42}',
0x261E: '\\ding{43}',
0x263E: '\\rightmoon',
0x263F: '\\mercury',
0x2640: '\\venus',
0x2642: '\\male',
0x2643: '\\jupiter',
0x2644: '\\saturn',
0x2645: '\\uranus',
0x2646: '\\neptune',
0x2647: '\\pluto',
0x2648: '\\aries',
0x2649: '\\taurus',
0x264A: '\\gemini',
0x264B: '\\cancer',
0x264C: '\\leo',
0x264D: '\\virgo',
0x264E: '\\libra',
0x264F: '\\scorpio',
0x2650: '\\sagittarius',
0x2651: '\\capricornus',
0x2652: '\\aquarius',
0x2653: '\\pisces',
0x2660: '\\ding{171}',
0x2662: '\\diamond',
0x2663: '\\ding{168}',
0x2665: '\\ding{170}',
0x2666: '\\ding{169}',
0x2669: '\\quarternote',
0x266A: '\\eighthnote',
0x266D: '\\flat',
0x266E: '\\natural',
0x266F: '\\sharp',
0x2701: '\\ding{33}',
0x2702: '\\ding{34}',
0x2703: '\\ding{35}',
0x2704: '\\ding{36}',
0x2706: '\\ding{38}',
0x2707: '\\ding{39}',
0x2708: '\\ding{40}',
0x2709: '\\ding{41}',
0x270C: '\\ding{44}',
0x270D: '\\ding{45}',
0x270E: '\\ding{46}',
0x270F: '\\ding{47}',
0x2710: '\\ding{48}',
0x2711: '\\ding{49}',
0x2712: '\\ding{50}',
0x2713: '\\ding{51}',
0x2714: '\\ding{52}',
0x2715: '\\ding{53}',
0x2716: '\\ding{54}',
0x2717: '\\ding{55}',
0x2718: '\\ding{56}',
0x2719: '\\ding{57}',
0x271A: '\\ding{58}',
0x271B: '\\ding{59}',
0x271C: '\\ding{60}',
0x271D: '\\ding{61}',
0x271E: '\\ding{62}',
0x271F: '\\ding{63}',
0x2720: '\\ding{64}',
0x2721: '\\ding{65}',
0x2722: '\\ding{66}',
0x2723: '\\ding{67}',
0x2724: '\\ding{68}',
0x2725: '\\ding{69}',
0x2726: '\\ding{70}',
0x2727: '\\ding{71}',
0x2729: '\\ding{73}',
0x272A: '\\ding{74}',
0x272B: '\\ding{75}',
0x272C: '\\ding{76}',
0x272D: '\\ding{77}',
0x272E: '\\ding{78}',
0x272F: '\\ding{79}',
0x2730: '\\ding{80}',
0x2731: '\\ding{81}',
0x2732: '\\ding{82}',
0x2733: '\\ding{83}',
0x2734: '\\ding{84}',
0x2735: '\\ding{85}',
0x2736: '\\ding{86}',
0x2737: '\\ding{87}',
0x2738: '\\ding{88}',
0x2739: '\\ding{89}',
0x273A: '\\ding{90}',
0x273B: '\\ding{91}',
0x273C: '\\ding{92}',
0x273D: '\\ding{93}',
0x273E: '\\ding{94}',
0x273F: '\\ding{95}',
0x2740: '\\ding{96}',
0x2741: '\\ding{97}',
0x2742: '\\ding{98}',
0x2743: '\\ding{99}',
0x2744: '\\ding{100}',
0x2745: '\\ding{101}',
0x2746: '\\ding{102}',
0x2747: '\\ding{103}',
0x2748: '\\ding{104}',
0x2749: '\\ding{105}',
0x274A: '\\ding{106}',
0x274B: '\\ding{107}',
0x274D: '\\ding{109}',
0x274F: '\\ding{111}',
0x2750: '\\ding{112}',
0x2751: '\\ding{113}',
0x2752: '\\ding{114}',
0x2756: '\\ding{118}',
0x2758: '\\ding{120}',
0x2759: '\\ding{121}',
0x275A: '\\ding{122}',
0x275B: '\\ding{123}',
0x275C: '\\ding{124}',
0x275D: '\\ding{125}',
0x275E: '\\ding{126}',
0x2761: '\\ding{161}',
0x2762: '\\ding{162}',
0x2763: '\\ding{163}',
0x2764: '\\ding{164}',
0x2765: '\\ding{165}',
0x2766: '\\ding{166}',
0x2767: '\\ding{167}',
0x2776: '\\ding{182}',
0x2777: '\\ding{183}',
0x2778: '\\ding{184}',
0x2779: '\\ding{185}',
0x277A: '\\ding{186}',
0x277B: '\\ding{187}',
0x277C: '\\ding{188}',
0x277D: '\\ding{189}',
0x277E: '\\ding{190}',
0x277F: '\\ding{191}',
0x2780: '\\ding{192}',
0x2781: '\\ding{193}',
0x2782: '\\ding{194}',
0x2783: '\\ding{195}',
0x2784: '\\ding{196}',
0x2785: '\\ding{197}',
0x2786: '\\ding{198}',
0x2787: '\\ding{199}',
0x2788: '\\ding{200}',
0x2789: '\\ding{201}',
0x278A: '\\ding{202}',
0x278B: '\\ding{203}',
0x278C: '\\ding{204}',
0x278D: '\\ding{205}',
0x278E: '\\ding{206}',
0x278F: '\\ding{207}',
0x2790: '\\ding{208}',
0x2791: '\\ding{209}',
0x2792: '\\ding{210}',
0x2793: '\\ding{211}',
0x2794: '\\ding{212}',
0x2798: '\\ding{216}',
0x2799: '\\ding{217}',
0x279A: '\\ding{218}',
0x279B: '\\ding{219}',
0x279C: '\\ding{220}',
0x279D: '\\ding{221}',
0x279E: '\\ding{222}',
0x279F: '\\ding{223}',
0x27A0: '\\ding{224}',
0x27A1: '\\ding{225}',
0x27A2: '\\ding{226}',
0x27A3: '\\ding{227}',
0x27A4: '\\ding{228}',
0x27A5: '\\ding{229}',
0x27A6: '\\ding{230}',
0x27A7: '\\ding{231}',
0x27A8: '\\ding{232}',
0x27A9: '\\ding{233}',
0x27AA: '\\ding{234}',
0x27AB: '\\ding{235}',
0x27AC: '\\ding{236}',
0x27AD: '\\ding{237}',
0x27AE: '\\ding{238}',
0x27AF: '\\ding{239}',
0x27B1: '\\ding{241}',
0x27B2: '\\ding{242}',
0x27B3: '\\ding{243}',
0x27B4: '\\ding{244}',
0x27B5: '\\ding{245}',
0x27B6: '\\ding{246}',
0x27B7: '\\ding{247}',
0x27B8: '\\ding{248}',
0x27B9: '\\ding{249}',
0x27BA: '\\ding{250}',
0x27BB: '\\ding{251}',
0x27BC: '\\ding{252}',
0x27BD: '\\ding{253}',
0x27BE: '\\ding{254}',
0x27E8: '\\langle',
0x27E9: '\\rangle',
0x27F5: '\\longleftarrow',
0x27F6: '\\longrightarrow',
0x27F7: '\\longleftrightarrow',
0x27F8: '\\Longleftarrow',
0x27F9: '\\Longrightarrow',
0x27FA: '\\Longleftrightarrow',
0x27FC: '\\longmapsto',
0x27FF: '\\sim\\joinrel\\leadsto',
0x2912: '\\UpArrowBar',
0x2913: '\\DownArrowBar',
0x294E: '\\LeftRightVector',
0x294F: '\\RightUpDownVector',
0x2950: '\\DownLeftRightVector',
0x2951: '\\LeftUpDownVector',
0x2952: '\\LeftVectorBar',
0x2953: '\\RightVectorBar',
0x2954: '\\RightUpVectorBar',
0x2955: '\\RightDownVectorBar',
0x2956: '\\DownLeftVectorBar',
0x2957: '\\DownRightVectorBar',
0x2958: '\\LeftUpVectorBar',
0x2959: '\\LeftDownVectorBar',
0x295A: '\\LeftTeeVector',
0x295B: '\\RightTeeVector',
0x295C: '\\RightUpTeeVector',
0x295D: '\\RightDownTeeVector',
0x295E: '\\DownLeftTeeVector',
0x295F: '\\DownRightTeeVector',
0x2960: '\\LeftUpTeeVector',
0x2961: '\\LeftDownTeeVector',
0x296E: '\\UpEquilibrium',
0x296F: '\\ReverseUpEquilibrium',
0x2970: '\\RoundImplies',
0x2993: '<\\kern-0.58em(',
0x299C: '\\Angle',
0x29CF: '\\LeftTriangleBar',
0x29D0: '\\RightTriangleBar',
0x29EB: '\\blacklozenge',
0x29F4: '\\RuleDelayed',
0x2A0F: '\\clockoint',
0x2A16: '\\sqrint',
0x2A3F: '\\amalg',
0x2A5E: '\\perspcorrespond',
0x2A6E: '\\stackrel{*}{=}',
0x2A75: '\\Equal',
0x2A7D: '\\leqslant',
0x2A7E: '\\geqslant',
0x2A85: '\\lessapprox',
0x2A86: '\\gtrapprox',
0x2A87: '\\lneq',
0x2A88: '\\gneq',
0x2A89: '\\lnapprox',
0x2A8A: '\\gnapprox',
0x2A8B: '\\lesseqqgtr',
0x2A8C: '\\gtreqqless',
0x2A95: '\\eqslantless',
0x2A96: '\\eqslantgtr',
0x2A9D: '\\Pisymbol{ppi020}{117}',
0x2A9E: '\\Pisymbol{ppi020}{105}',
0x2AA1: '\\NestedLessLess',
0x2AA2: '\\NestedGreaterGreater',
0x2AAF: '\\preceq',
0x2AB0: '\\succeq',
0x2AB5: '\\precneqq',
0x2AB6: '\\succneqq',
0x2AB7: '\\precapprox',
0x2AB8: '\\succapprox',
0x2AB9: '\\precnapprox',
0x2ABA: '\\succnapprox',
0x2AC5: '\\subseteqq',
0x2AC6: '\\supseteqq',
0x2ACB: '\\subsetneqq',
0x2ACC: '\\supsetneqq',
0x2AFD: '{{/}\\!\\!{/}}',
0x301A: '\\openbracketleft',
0x301B: '\\openbracketright',
0xFB00: 'ff',
0xFB01: 'fi',
0xFB02: 'fl',
0xFB03: 'ffi',
0xFB04: 'ffl',
0x1D400: '\\mathbf{A}',
0x1D401: '\\mathbf{B}',
0x1D402: '\\mathbf{C}',
0x1D403: '\\mathbf{D}',
0x1D404: '\\mathbf{E}',
0x1D405: '\\mathbf{F}',
0x1D406: '\\mathbf{G}',
0x1D407: '\\mathbf{H}',
0x1D408: '\\mathbf{I}',
0x1D409: '\\mathbf{J}',
0x1D40A: '\\mathbf{K}',
0x1D40B: '\\mathbf{L}',
0x1D40C: '\\mathbf{M}',
0x1D40D: '\\mathbf{N}',
0x1D40E: '\\mathbf{O}',
0x1D40F: '\\mathbf{P}',
0x1D410: '\\mathbf{Q}',
0x1D411: '\\mathbf{R}',
0x1D412: '\\mathbf{S}',
0x1D413: '\\mathbf{T}',
0x1D414: '\\mathbf{U}',
0x1D415: '\\mathbf{V}',
0x1D416: '\\mathbf{W}',
0x1D417: '\\mathbf{X}',
0x1D418: '\\mathbf{Y}',
0x1D419: '\\mathbf{Z}',
0x1D41A: '\\mathbf{a}',
0x1D41B: '\\mathbf{b}',
0x1D41C: '\\mathbf{c}',
0x1D41D: '\\mathbf{d}',
0x1D41E: '\\mathbf{e}',
0x1D41F: '\\mathbf{f}',
0x1D420: '\\mathbf{g}',
0x1D421: '\\mathbf{h}',
0x1D422: '\\mathbf{i}',
0x1D423: '\\mathbf{j}',
0x1D424: '\\mathbf{k}',
0x1D425: '\\mathbf{l}',
0x1D426: '\\mathbf{m}',
0x1D427: '\\mathbf{n}',
0x1D428: '\\mathbf{o}',
0x1D429: '\\mathbf{p}',
0x1D42A: '\\mathbf{q}',
0x1D42B: '\\mathbf{r}',
0x1D42C: '\\mathbf{s}',
0x1D42D: '\\mathbf{t}',
0x1D42E: '\\mathbf{u}',
0x1D42F: '\\mathbf{v}',
0x1D430: '\\mathbf{w}',
0x1D431: '\\mathbf{x}',
0x1D432: '\\mathbf{y}',
0x1D433: '\\mathbf{z}',
0x1D434: '\\mathmit{A}',
0x1D435: '\\mathmit{B}',
0x1D436: '\\mathmit{C}',
0x1D437: '\\mathmit{D}',
0x1D438: '\\mathmit{E}',
0x1D439: '\\mathmit{F}',
0x1D43A: '\\mathmit{G}',
0x1D43B: '\\mathmit{H}',
0x1D43C: '\\mathmit{I}',
0x1D43D: '\\mathmit{J}',
0x1D43E: '\\mathmit{K}',
0x1D43F: '\\mathmit{L}',
0x1D440: '\\mathmit{M}',
0x1D441: '\\mathmit{N}',
0x1D442: '\\mathmit{O}',
0x1D443: '\\mathmit{P}',
0x1D444: '\\mathmit{Q}',
0x1D445: '\\mathmit{R}',
0x1D446: '\\mathmit{S}',
0x1D447: '\\mathmit{T}',
0x1D448: '\\mathmit{U}',
0x1D449: '\\mathmit{V}',
0x1D44A: '\\mathmit{W}',
0x1D44B: '\\mathmit{X}',
0x1D44C: '\\mathmit{Y}',
0x1D44D: '\\mathmit{Z}',
0x1D44E: '\\mathmit{a}',
0x1D44F: '\\mathmit{b}',
0x1D450: '\\mathmit{c}',
0x1D451: '\\mathmit{d}',
0x1D452: '\\mathmit{e}',
0x1D453: '\\mathmit{f}',
0x1D454: '\\mathmit{g}',
0x1D456: '\\mathmit{i}',
0x1D457: '\\mathmit{j}',
0x1D458: '\\mathmit{k}',
0x1D459: '\\mathmit{l}',
0x1D45A: '\\mathmit{m}',
0x1D45B: '\\mathmit{n}',
0x1D45C: '\\mathmit{o}',
0x1D45D: '\\mathmit{p}',
0x1D45E: '\\mathmit{q}',
0x1D45F: '\\mathmit{r}',
0x1D460: '\\mathmit{s}',
0x1D461: '\\mathmit{t}',
0x1D462: '\\mathmit{u}',
0x1D463: '\\mathmit{v}',
0x1D464: '\\mathmit{w}',
0x1D465: '\\mathmit{x}',
0x1D466: '\\mathmit{y}',
0x1D467: '\\mathmit{z}',
0x1D468: '\\mathbit{A}',
0x1D469: '\\mathbit{B}',
0x1D46A: '\\mathbit{C}',
0x1D46B: '\\mathbit{D}',
0x1D46C: '\\mathbit{E}',
0x1D46D: '\\mathbit{F}',
0x1D46E: '\\mathbit{G}',
0x1D46F: '\\mathbit{H}',
0x1D470: '\\mathbit{I}',
0x1D471: '\\mathbit{J}',
0x1D472: '\\mathbit{K}',
0x1D473: '\\mathbit{L}',
0x1D474: '\\mathbit{M}',
0x1D475: '\\mathbit{N}',
0x1D476: '\\mathbit{O}',
0x1D477: '\\mathbit{P}',
0x1D478: '\\mathbit{Q}',
0x1D479: '\\mathbit{R}',
0x1D47A: '\\mathbit{S}',
0x1D47B: '\\mathbit{T}',
0x1D47C: '\\mathbit{U}',
0x1D47D: '\\mathbit{V}',
0x1D47E: '\\mathbit{W}',
0x1D47F: '\\mathbit{X}',
0x1D480: '\\mathbit{Y}',
0x1D481: '\\mathbit{Z}',
0x1D482: '\\mathbit{a}',
0x1D483: '\\mathbit{b}',
0x1D484: '\\mathbit{c}',
0x1D485: '\\mathbit{d}',
0x1D486: '\\mathbit{e}',
0x1D487: '\\mathbit{f}',
0x1D488: '\\mathbit{g}',
0x1D489: '\\mathbit{h}',
0x1D48A: '\\mathbit{i}',
0x1D48B: '\\mathbit{j}',
0x1D48C: '\\mathbit{k}',
0x1D48D: '\\mathbit{l}',
0x1D48E: '\\mathbit{m}',
0x1D48F: '\\mathbit{n}',
0x1D490: '\\mathbit{o}',
0x1D491: '\\mathbit{p}',
0x1D492: '\\mathbit{q}',
0x1D493: '\\mathbit{r}',
0x1D494: '\\mathbit{s}',
0x1D495: '\\mathbit{t}',
0x1D496: '\\mathbit{u}',
0x1D497: '\\mathbit{v}',
0x1D498: '\\mathbit{w}',
0x1D499: '\\mathbit{x}',
0x1D49A: '\\mathbit{y}',
0x1D49B: '\\mathbit{z}',
0x1D49C: '\\mathscr{A}',
0x1D49E: '\\mathscr{C}',
0x1D49F: '\\mathscr{D}',
0x1D4A2: '\\mathscr{G}',
0x1D4A5: '\\mathscr{J}',
0x1D4A6: '\\mathscr{K}',
0x1D4A9: '\\mathscr{N}',
0x1D4AA: '\\mathscr{O}',
0x1D4AB: '\\mathscr{P}',
0x1D4AC: '\\mathscr{Q}',
0x1D4AE: '\\mathscr{S}',
0x1D4AF: '\\mathscr{T}',
0x1D4B0: '\\mathscr{U}',
0x1D4B1: '\\mathscr{V}',
0x1D4B2: '\\mathscr{W}',
0x1D4B3: '\\mathscr{X}',
0x1D4B4: '\\mathscr{Y}',
0x1D4B5: '\\mathscr{Z}',
0x1D4B6: '\\mathscr{a}',
0x1D4B7: '\\mathscr{b}',
0x1D4B8: '\\mathscr{c}',
0x1D4B9: '\\mathscr{d}',
0x1D4BB: '\\mathscr{f}',
0x1D4BD: '\\mathscr{h}',
0x1D4BE: '\\mathscr{i}',
0x1D4BF: '\\mathscr{j}',
0x1D4C0: '\\mathscr{k}',
0x1D4C1: '\\mathscr{l}',
0x1D4C2: '\\mathscr{m}',
0x1D4C3: '\\mathscr{n}',
0x1D4C5: '\\mathscr{p}',
0x1D4C6: '\\mathscr{q}',
0x1D4C7: '\\mathscr{r}',
0x1D4C8: '\\mathscr{s}',
0x1D4C9: '\\mathscr{t}',
0x1D4CA: '\\mathscr{u}',
0x1D4CB: '\\mathscr{v}',
0x1D4CC: '\\mathscr{w}',
0x1D4CD: '\\mathscr{x}',
0x1D4CE: '\\mathscr{y}',
0x1D4CF: '\\mathscr{z}',
0x1D4D0: '\\mathbcal{A}',
0x1D4D1: '\\mathbcal{B}',
0x1D4D2: '\\mathbcal{C}',
0x1D4D3: '\\mathbcal{D}',
0x1D4D4: '\\mathbcal{E}',
0x1D4D5: '\\mathbcal{F}',
0x1D4D6: '\\mathbcal{G}',
0x1D4D7: '\\mathbcal{H}',
0x1D4D8: '\\mathbcal{I}',
0x1D4D9: '\\mathbcal{J}',
0x1D4DA: '\\mathbcal{K}',
0x1D4DB: '\\mathbcal{L}',
0x1D4DC: '\\mathbcal{M}',
0x1D4DD: '\\mathbcal{N}',
0x1D4DE: '\\mathbcal{O}',
0x1D4DF: '\\mathbcal{P}',
0x1D4E0: '\\mathbcal{Q}',
0x1D4E1: '\\mathbcal{R}',
0x1D4E2: '\\mathbcal{S}',
0x1D4E3: '\\mathbcal{T}',
0x1D4E4: '\\mathbcal{U}',
0x1D4E5: '\\mathbcal{V}',
0x1D4E6: '\\mathbcal{W}',
0x1D4E7: '\\mathbcal{X}',
0x1D4E8: '\\mathbcal{Y}',
0x1D4E9: '\\mathbcal{Z}',
0x1D4EA: '\\mathbcal{a}',
0x1D4EB: '\\mathbcal{b}',
0x1D4EC: '\\mathbcal{c}',
0x1D4ED: '\\mathbcal{d}',
0x1D4EE: '\\mathbcal{e}',
0x1D4EF: '\\mathbcal{f}',
0x1D4F0: '\\mathbcal{g}',
0x1D4F1: '\\mathbcal{h}',
0x1D4F2: '\\mathbcal{i}',
0x1D4F3: '\\mathbcal{j}',
0x1D4F4: '\\mathbcal{k}',
0x1D4F5: '\\mathbcal{l}',
0x1D4F6: '\\mathbcal{m}',
0x1D4F7: '\\mathbcal{n}',
0x1D4F8: '\\mathbcal{o}',
0x1D4F9: '\\mathbcal{p}',
0x1D4FA: '\\mathbcal{q}',
0x1D4FB: '\\mathbcal{r}',
0x1D4FC: '\\mathbcal{s}',
0x1D4FD: '\\mathbcal{t}',
0x1D4FE: '\\mathbcal{u}',
0x1D4FF: '\\mathbcal{v}',
0x1D500: '\\mathbcal{w}',
0x1D501: '\\mathbcal{x}',
0x1D502: '\\mathbcal{y}',
0x1D503: '\\mathbcal{z}',
0x1D504: '\\mathfrak{A}',
0x1D505: '\\mathfrak{B}',
0x1D507: '\\mathfrak{D}',
0x1D508: '\\mathfrak{E}',
0x1D509: '\\mathfrak{F}',
0x1D50A: '\\mathfrak{G}',
0x1D50D: '\\mathfrak{J}',
0x1D50E: '\\mathfrak{K}',
0x1D50F: '\\mathfrak{L}',
0x1D510: '\\mathfrak{M}',
0x1D511: '\\mathfrak{N}',
0x1D512: '\\mathfrak{O}',
0x1D513: '\\mathfrak{P}',
0x1D514: '\\mathfrak{Q}',
0x1D516: '\\mathfrak{S}',
0x1D517: '\\mathfrak{T}',
0x1D518: '\\mathfrak{U}',
0x1D519: '\\mathfrak{V}',
0x1D51A: '\\mathfrak{W}',
0x1D51B: '\\mathfrak{X}',
0x1D51C: '\\mathfrak{Y}',
0x1D51E: '\\mathfrak{a}',
0x1D51F: '\\mathfrak{b}',
0x1D520: '\\mathfrak{c}',
0x1D521: '\\mathfrak{d}',
0x1D522: '\\mathfrak{e}',
0x1D523: '\\mathfrak{f}',
0x1D524: '\\mathfrak{g}',
0x1D525: '\\mathfrak{h}',
0x1D526: '\\mathfrak{i}',
0x1D527: '\\mathfrak{j}',
0x1D528: '\\mathfrak{k}',
0x1D529: '\\mathfrak{l}',
0x1D52A: '\\mathfrak{m}',
0x1D52B: '\\mathfrak{n}',
0x1D52C: '\\mathfrak{o}',
0x1D52D: '\\mathfrak{p}',
0x1D52E: '\\mathfrak{q}',
0x1D52F: '\\mathfrak{r}',
0x1D530: '\\mathfrak{s}',
0x1D531: '\\mathfrak{t}',
0x1D532: '\\mathfrak{u}',
0x1D533: '\\mathfrak{v}',
0x1D534: '\\mathfrak{w}',
0x1D535: '\\mathfrak{x}',
0x1D536: '\\mathfrak{y}',
0x1D537: '\\mathfrak{z}',
0x1D538: '\\mathbb{A}',
0x1D539: '\\mathbb{B}',
0x1D53B: '\\mathbb{D}',
0x1D53C: '\\mathbb{E}',
0x1D53D: '\\mathbb{F}',
0x1D53E: '\\mathbb{G}',
0x1D540: '\\mathbb{I}',
0x1D541: '\\mathbb{J}',
0x1D542: '\\mathbb{K}',
0x1D543: '\\mathbb{L}',
0x1D544: '\\mathbb{M}',
0x1D546: '\\mathbb{O}',
0x1D54A: '\\mathbb{S}',
0x1D54B: '\\mathbb{T}',
0x1D54C: '\\mathbb{U}',
0x1D54D: '\\mathbb{V}',
0x1D54E: '\\mathbb{W}',
0x1D54F: '\\mathbb{X}',
0x1D550: '\\mathbb{Y}',
0x1D552: '\\mathbb{a}',
0x1D553: '\\mathbb{b}',
0x1D554: '\\mathbb{c}',
0x1D555: '\\mathbb{d}',
0x1D556: '\\mathbb{e}',
0x1D557: '\\mathbb{f}',
0x1D558: '\\mathbb{g}',
0x1D559: '\\mathbb{h}',
0x1D55A: '\\mathbb{i}',
0x1D55B: '\\mathbb{j}',
0x1D55C: '\\mathbb{k}',
0x1D55D: '\\mathbb{l}',
0x1D55E: '\\mathbb{m}',
0x1D55F: '\\mathbb{n}',
0x1D560: '\\mathbb{o}',
0x1D561: '\\mathbb{p}',
0x1D562: '\\mathbb{q}',
0x1D563: '\\mathbb{r}',
0x1D564: '\\mathbb{s}',
0x1D565: '\\mathbb{t}',
0x1D566: '\\mathbb{u}',
0x1D567: '\\mathbb{v}',
0x1D568: '\\mathbb{w}',
0x1D569: '\\mathbb{x}',
0x1D56A: '\\mathbb{y}',
0x1D56B: '\\mathbb{z}',
0x1D56C: '\\mathbfrak{A}',
0x1D56D: '\\mathbfrak{B}',
0x1D56E: '\\mathbfrak{C}',
0x1D56F: '\\mathbfrak{D}',
0x1D570: '\\mathbfrak{E}',
0x1D571: '\\mathbfrak{F}',
0x1D572: '\\mathbfrak{G}',
0x1D573: '\\mathbfrak{H}',
0x1D574: '\\mathbfrak{I}',
0x1D575: '\\mathbfrak{J}',
0x1D576: '\\mathbfrak{K}',
0x1D577: '\\mathbfrak{L}',
0x1D578: '\\mathbfrak{M}',
0x1D579: '\\mathbfrak{N}',
0x1D57A: '\\mathbfrak{O}',
0x1D57B: '\\mathbfrak{P}',
0x1D57C: '\\mathbfrak{Q}',
0x1D57D: '\\mathbfrak{R}',
0x1D57E: '\\mathbfrak{S}',
0x1D57F: '\\mathbfrak{T}',
0x1D580: '\\mathbfrak{U}',
0x1D581: '\\mathbfrak{V}',
0x1D582: '\\mathbfrak{W}',
0x1D583: '\\mathbfrak{X}',
0x1D584: '\\mathbfrak{Y}',
0x1D585: '\\mathbfrak{Z}',
0x1D586: '\\mathbfrak{a}',
0x1D587: '\\mathbfrak{b}',
0x1D588: '\\mathbfrak{c}',
0x1D589: '\\mathbfrak{d}',
0x1D58A: '\\mathbfrak{e}',
0x1D58B: '\\mathbfrak{f}',
0x1D58C: '\\mathbfrak{g}',
0x1D58D: '\\mathbfrak{h}',
0x1D58E: '\\mathbfrak{i}',
0x1D58F: '\\mathbfrak{j}',
0x1D590: '\\mathbfrak{k}',
0x1D591: '\\mathbfrak{l}',
0x1D592: '\\mathbfrak{m}',
0x1D593: '\\mathbfrak{n}',
0x1D594: '\\mathbfrak{o}',
0x1D595: '\\mathbfrak{p}',
0x1D596: '\\mathbfrak{q}',
0x1D597: '\\mathbfrak{r}',
0x1D598: '\\mathbfrak{s}',
0x1D599: '\\mathbfrak{t}',
0x1D59A: '\\mathbfrak{u}',
0x1D59B: '\\mathbfrak{v}',
0x1D59C: '\\mathbfrak{w}',
0x1D59D: '\\mathbfrak{x}',
0x1D59E: '\\mathbfrak{y}',
0x1D59F: '\\mathbfrak{z}',
0x1D5A0: '\\mathsf{A}',
0x1D5A1: '\\mathsf{B}',
0x1D5A2: '\\mathsf{C}',
0x1D5A3: '\\mathsf{D}',
0x1D5A4: '\\mathsf{E}',
0x1D5A5: '\\mathsf{F}',
0x1D5A6: '\\mathsf{G}',
0x1D5A7: '\\mathsf{H}',
0x1D5A8: '\\mathsf{I}',
0x1D5A9: '\\mathsf{J}',
0x1D5AA: '\\mathsf{K}',
0x1D5AB: '\\mathsf{L}',
0x1D5AC: '\\mathsf{M}',
0x1D5AD: '\\mathsf{N}',
0x1D5AE: '\\mathsf{O}',
0x1D5AF: '\\mathsf{P}',
0x1D5B0: '\\mathsf{Q}',
0x1D5B1: '\\mathsf{R}',
0x1D5B2: '\\mathsf{S}',
0x1D5B3: '\\mathsf{T}',
0x1D5B4: '\\mathsf{U}',
0x1D5B5: '\\mathsf{V}',
0x1D5B6: '\\mathsf{W}',
0x1D5B7: '\\mathsf{X}',
0x1D5B8: '\\mathsf{Y}',
0x1D5B9: '\\mathsf{Z}',
0x1D5BA: '\\mathsf{a}',
0x1D5BB: '\\mathsf{b}',
0x1D5BC: '\\mathsf{c}',
0x1D5BD: '\\mathsf{d}',
0x1D5BE: '\\mathsf{e}',
0x1D5BF: '\\mathsf{f}',
0x1D5C0: '\\mathsf{g}',
0x1D5C1: '\\mathsf{h}',
0x1D5C2: '\\mathsf{i}',
0x1D5C3: '\\mathsf{j}',
0x1D5C4: '\\mathsf{k}',
0x1D5C5: '\\mathsf{l}',
0x1D5C6: '\\mathsf{m}',
0x1D5C7: '\\mathsf{n}',
0x1D5C8: '\\mathsf{o}',
0x1D5C9: '\\mathsf{p}',
0x1D5CA: '\\mathsf{q}',
0x1D5CB: '\\mathsf{r}',
0x1D5CC: '\\mathsf{s}',
0x1D5CD: '\\mathsf{t}',
0x1D5CE: '\\mathsf{u}',
0x1D5CF: '\\mathsf{v}',
0x1D5D0: '\\mathsf{w}',
0x1D5D1: '\\mathsf{x}',
0x1D5D2: '\\mathsf{y}',
0x1D5D3: '\\mathsf{z}',
0x1D5D4: '\\mathsfbf{A}',
0x1D5D5: '\\mathsfbf{B}',
0x1D5D6: '\\mathsfbf{C}',
0x1D5D7: '\\mathsfbf{D}',
0x1D5D8: '\\mathsfbf{E}',
0x1D5D9: '\\mathsfbf{F}',
0x1D5DA: '\\mathsfbf{G}',
0x1D5DB: '\\mathsfbf{H}',
0x1D5DC: '\\mathsfbf{I}',
0x1D5DD: '\\mathsfbf{J}',
0x1D5DE: '\\mathsfbf{K}',
0x1D5DF: '\\mathsfbf{L}',
0x1D5E0: '\\mathsfbf{M}',
0x1D5E1: '\\mathsfbf{N}',
0x1D5E2: '\\mathsfbf{O}',
0x1D5E3: '\\mathsfbf{P}',
0x1D5E4: '\\mathsfbf{Q}',
0x1D5E5: '\\mathsfbf{R}',
0x1D5E6: '\\mathsfbf{S}',
0x1D5E7: '\\mathsfbf{T}',
0x1D5E8: '\\mathsfbf{U}',
0x1D5E9: '\\mathsfbf{V}',
0x1D5EA: '\\mathsfbf{W}',
0x1D5EB: '\\mathsfbf{X}',
0x1D5EC: '\\mathsfbf{Y}',
0x1D5ED: '\\mathsfbf{Z}',
0x1D5EE: '\\mathsfbf{a}',
0x1D5EF: '\\mathsfbf{b}',
0x1D5F0: '\\mathsfbf{c}',
0x1D5F1: '\\mathsfbf{d}',
0x1D5F2: '\\mathsfbf{e}',
0x1D5F3: '\\mathsfbf{f}',
0x1D5F4: '\\mathsfbf{g}',
0x1D5F5: '\\mathsfbf{h}',
0x1D5F6: '\\mathsfbf{i}',
0x1D5F7: '\\mathsfbf{j}',
0x1D5F8: '\\mathsfbf{k}',
0x1D5F9: '\\mathsfbf{l}',
0x1D5FA: '\\mathsfbf{m}',
0x1D5FB: '\\mathsfbf{n}',
0x1D5FC: '\\mathsfbf{o}',
0x1D5FD: '\\mathsfbf{p}',
0x1D5FE: '\\mathsfbf{q}',
0x1D5FF: '\\mathsfbf{r}',
0x1D600: '\\mathsfbf{s}',
0x1D601: '\\mathsfbf{t}',
0x1D602: '\\mathsfbf{u}',
0x1D603: '\\mathsfbf{v}',
0x1D604: '\\mathsfbf{w}',
0x1D605: '\\mathsfbf{x}',
0x1D606: '\\mathsfbf{y}',
0x1D607: '\\mathsfbf{z}',
0x1D608: '\\mathsfsl{A}',
0x1D609: '\\mathsfsl{B}',
0x1D60A: '\\mathsfsl{C}',
0x1D60B: '\\mathsfsl{D}',
0x1D60C: '\\mathsfsl{E}',
0x1D60D: '\\mathsfsl{F}',
0x1D60E: '\\mathsfsl{G}',
0x1D60F: '\\mathsfsl{H}',
0x1D610: '\\mathsfsl{I}',
0x1D611: '\\mathsfsl{J}',
0x1D612: '\\mathsfsl{K}',
0x1D613: '\\mathsfsl{L}',
0x1D614: '\\mathsfsl{M}',
0x1D615: '\\mathsfsl{N}',
0x1D616: '\\mathsfsl{O}',
0x1D617: '\\mathsfsl{P}',
0x1D618: '\\mathsfsl{Q}',
0x1D619: '\\mathsfsl{R}',
0x1D61A: '\\mathsfsl{S}',
0x1D61B: '\\mathsfsl{T}',
0x1D61C: '\\mathsfsl{U}',
0x1D61D: '\\mathsfsl{V}',
0x1D61E: '\\mathsfsl{W}',
0x1D61F: '\\mathsfsl{X}',
0x1D620: '\\mathsfsl{Y}',
0x1D621: '\\mathsfsl{Z}',
0x1D622: '\\mathsfsl{a}',
0x1D623: '\\mathsfsl{b}',
0x1D624: '\\mathsfsl{c}',
0x1D625: '\\mathsfsl{d}',
0x1D626: '\\mathsfsl{e}',
0x1D627: '\\mathsfsl{f}',
0x1D628: '\\mathsfsl{g}',
0x1D629: '\\mathsfsl{h}',
0x1D62A: '\\mathsfsl{i}',
0x1D62B: '\\mathsfsl{j}',
0x1D62C: '\\mathsfsl{k}',
0x1D62D: '\\mathsfsl{l}',
0x1D62E: '\\mathsfsl{m}',
0x1D62F: '\\mathsfsl{n}',
0x1D630: '\\mathsfsl{o}',
0x1D631: '\\mathsfsl{p}',
0x1D632: '\\mathsfsl{q}',
0x1D633: '\\mathsfsl{r}',
0x1D634: '\\mathsfsl{s}',
0x1D635: '\\mathsfsl{t}',
0x1D636: '\\mathsfsl{u}',
0x1D637: '\\mathsfsl{v}',
0x1D638: '\\mathsfsl{w}',
0x1D639: '\\mathsfsl{x}',
0x1D63A: '\\mathsfsl{y}',
0x1D63B: '\\mathsfsl{z}',
0x1D63C: '\\mathsfbfsl{A}',
0x1D63D: '\\mathsfbfsl{B}',
0x1D63E: '\\mathsfbfsl{C}',
0x1D63F: '\\mathsfbfsl{D}',
0x1D640: '\\mathsfbfsl{E}',
0x1D641: '\\mathsfbfsl{F}',
0x1D642: '\\mathsfbfsl{G}',
0x1D643: '\\mathsfbfsl{H}',
0x1D644: '\\mathsfbfsl{I}',
0x1D645: '\\mathsfbfsl{J}',
0x1D646: '\\mathsfbfsl{K}',
0x1D647: '\\mathsfbfsl{L}',
0x1D648: '\\mathsfbfsl{M}',
0x1D649: '\\mathsfbfsl{N}',
0x1D64A: '\\mathsfbfsl{O}',
0x1D64B: '\\mathsfbfsl{P}',
0x1D64C: '\\mathsfbfsl{Q}',
0x1D64D: '\\mathsfbfsl{R}',
0x1D64E: '\\mathsfbfsl{S}',
0x1D64F: '\\mathsfbfsl{T}',
0x1D650: '\\mathsfbfsl{U}',
0x1D651: '\\mathsfbfsl{V}',
0x1D652: '\\mathsfbfsl{W}',
0x1D653: '\\mathsfbfsl{X}',
0x1D654: '\\mathsfbfsl{Y}',
0x1D655: '\\mathsfbfsl{Z}',
0x1D656: '\\mathsfbfsl{a}',
0x1D657: '\\mathsfbfsl{b}',
0x1D658: '\\mathsfbfsl{c}',
0x1D659: '\\mathsfbfsl{d}',
0x1D65A: '\\mathsfbfsl{e}',
0x1D65B: '\\mathsfbfsl{f}',
0x1D65C: '\\mathsfbfsl{g}',
0x1D65D: '\\mathsfbfsl{h}',
0x1D65E: '\\mathsfbfsl{i}',
0x1D65F: '\\mathsfbfsl{j}',
0x1D660: '\\mathsfbfsl{k}',
0x1D661: '\\mathsfbfsl{l}',
0x1D662: '\\mathsfbfsl{m}',
0x1D663: '\\mathsfbfsl{n}',
0x1D664: '\\mathsfbfsl{o}',
0x1D665: '\\mathsfbfsl{p}',
0x1D666: '\\mathsfbfsl{q}',
0x1D667: '\\mathsfbfsl{r}',
0x1D668: '\\mathsfbfsl{s}',
0x1D669: '\\mathsfbfsl{t}',
0x1D66A: '\\mathsfbfsl{u}',
0x1D66B: '\\mathsfbfsl{v}',
0x1D66C: '\\mathsfbfsl{w}',
0x1D66D: '\\mathsfbfsl{x}',
0x1D66E: '\\mathsfbfsl{y}',
0x1D66F: '\\mathsfbfsl{z}',
0x1D670: '\\mathtt{A}',
0x1D671: '\\mathtt{B}',
0x1D672: '\\mathtt{C}',
0x1D673: '\\mathtt{D}',
0x1D674: '\\mathtt{E}',
0x1D675: '\\mathtt{F}',
0x1D676: '\\mathtt{G}',
0x1D677: '\\mathtt{H}',
0x1D678: '\\mathtt{I}',
0x1D679: '\\mathtt{J}',
0x1D67A: '\\mathtt{K}',
0x1D67B: '\\mathtt{L}',
0x1D67C: '\\mathtt{M}',
0x1D67D: '\\mathtt{N}',
0x1D67E: '\\mathtt{O}',
0x1D67F: '\\mathtt{P}',
0x1D680: '\\mathtt{Q}',
0x1D681: '\\mathtt{R}',
0x1D682: '\\mathtt{S}',
0x1D683: '\\mathtt{T}',
0x1D684: '\\mathtt{U}',
0x1D685: '\\mathtt{V}',
0x1D686: '\\mathtt{W}',
0x1D687: '\\mathtt{X}',
0x1D688: '\\mathtt{Y}',
0x1D689: '\\mathtt{Z}',
0x1D68A: '\\mathtt{a}',
0x1D68B: '\\mathtt{b}',
0x1D68C: '\\mathtt{c}',
0x1D68D: '\\mathtt{d}',
0x1D68E: '\\mathtt{e}',
0x1D68F: '\\mathtt{f}',
0x1D690: '\\mathtt{g}',
0x1D691: '\\mathtt{h}',
0x1D692: '\\mathtt{i}',
0x1D693: '\\mathtt{j}',
0x1D694: '\\mathtt{k}',
0x1D695: '\\mathtt{l}',
0x1D696: '\\mathtt{m}',
0x1D697: '\\mathtt{n}',
0x1D698: '\\mathtt{o}',
0x1D699: '\\mathtt{p}',
0x1D69A: '\\mathtt{q}',
0x1D69B: '\\mathtt{r}',
0x1D69C: '\\mathtt{s}',
0x1D69D: '\\mathtt{t}',
0x1D69E: '\\mathtt{u}',
0x1D69F: '\\mathtt{v}',
0x1D6A0: '\\mathtt{w}',
0x1D6A1: '\\mathtt{x}',
0x1D6A2: '\\mathtt{y}',
0x1D6A3: '\\mathtt{z}',
0x1D6A8: '\\mathbf{\\Alpha}',
0x1D6A9: '\\mathbf{\\Beta}',
0x1D6AA: '\\mathbf{\\Gamma}',
0x1D6AB: '\\mathbf{\\Delta}',
0x1D6AC: '\\mathbf{\\Epsilon}',
0x1D6AD: '\\mathbf{\\Zeta}',
0x1D6AE: '\\mathbf{\\Eta}',
0x1D6AF: '\\mathbf{\\Theta}',
0x1D6B0: '\\mathbf{\\Iota}',
0x1D6B1: '\\mathbf{\\Kappa}',
0x1D6B2: '\\mathbf{\\Lambda}',
0x1D6B3: '\\mathbf{M}',
0x1D6B4: 'N',
0x1D6B5: '\\mathbf{\\Xi}',
0x1D6B6: 'O',
0x1D6B7: '\\mathbf{\\Pi}',
0x1D6B8: '\\mathbf{\\Rho}',
0x1D6B9: '\\mathbf{\\vartheta}',
0x1D6BA: '\\mathbf{\\Sigma}',
0x1D6BB: '\\mathbf{\\Tau}',
0x1D6BC: '\\mathbf{\\Upsilon}',
0x1D6BD: '\\mathbf{\\Phi}',
0x1D6BE: '\\mathbf{\\Chi}',
0x1D6BF: '\\mathbf{\\Psi}',
0x1D6C0: '\\mathbf{\\Omega}',
0x1D6C1: '\\mathbf{\\nabla}',
0x1D6C2: '\\mathbf{\\alpha}',
0x1D6C3: '\\mathbf{\\beta}',
0x1D6C4: '\\mathbf{\\gamma}',
0x1D6C5: '\\mathbf{\\delta}',
0x1D6C6: '\\mathbf{\\epsilon}',
0x1D6C7: '\\mathbf{\\zeta}',
0x1D6C8: '\\mathbf{\\eta}',
0x1D6C9: '\\mathbf{\\theta}',
0x1D6CA: '\\mathbf{\\iota}',
0x1D6CB: '\\mathbf{\\kappa}',
0x1D6CC: '\\mathbf{\\lambda}',
0x1D6CD: '\\mathbf{\\mu}',
0x1D6CE: '\\mathbf{\\nu}',
0x1D6CF: '\\mathbf{\\xi}',
0x1D6D0: '\\mathbf{o}',
0x1D6D1: '\\mathbf{\\pi}',
0x1D6D2: '\\mathbf{\\rho}',
0x1D6D3: '\\mathbf{\\varsigma}',
0x1D6D4: '\\mathbf{\\sigma}',
0x1D6D5: '\\mathbf{\\tau}',
0x1D6D6: '\\mathbf{\\upsilon}',
0x1D6D7: '\\mathbf{\\phi}',
0x1D6D8: '\\mathbf{\\chi}',
0x1D6D9: '\\mathbf{\\psi}',
0x1D6DA: '\\mathbf{\\omega}',
0x1D6DB: '\\partial',
0x1D6DC: '\\mathbf{\\varepsilon}',
0x1D6DD: '\\mathbf{\\vartheta}',
0x1D6DE: '\\mathbf{\\varkappa}',
0x1D6DF: '\\mathbf{\\phi}',
0x1D6E0: '\\mathbf{\\varrho}',
0x1D6E1: '\\mathbf{\\varpi}',
0x1D6E2: '\\mathmit{\\Alpha}',
0x1D6E3: '\\mathmit{\\Beta}',
0x1D6E4: '\\mathmit{\\Gamma}',
0x1D6E5: '\\mathmit{\\Delta}',
0x1D6E6: '\\mathmit{\\Epsilon}',
0x1D6E7: '\\mathmit{\\Zeta}',
0x1D6E8: '\\mathmit{\\Eta}',
0x1D6E9: '\\mathmit{\\Theta}',
0x1D6EA: '\\mathmit{\\Iota}',
0x1D6EB: '\\mathmit{\\Kappa}',
0x1D6EC: '\\mathmit{\\Lambda}',
0x1D6ED: '\\mathmit{M}',
0x1D6EE: 'N',
0x1D6EF: '\\mathmit{\\Xi}',
0x1D6F0: 'O',
0x1D6F1: '\\mathmit{\\Pi}',
0x1D6F2: '\\mathmit{\\Rho}',
0x1D6F3: '\\mathmit{\\vartheta}',
0x1D6F4: '\\mathmit{\\Sigma}',
0x1D6F5: '\\mathmit{\\Tau}',
0x1D6F6: '\\mathmit{\\Upsilon}',
0x1D6F7: '\\mathmit{\\Phi}',
0x1D6F8: '\\mathmit{\\Chi}',
0x1D6F9: '\\mathmit{\\Psi}',
0x1D6FA: '\\mathmit{\\Omega}',
0x1D6FB: '\\mathmit{\\nabla}',
0x1D6FC: '\\mathmit{\\alpha}',
0x1D6FD: '\\mathmit{\\beta}',
0x1D6FE: '\\mathmit{\\gamma}',
0x1D6FF: '\\mathmit{\\delta}',
0x1D700: '\\mathmit{\\epsilon}',
0x1D701: '\\mathmit{\\zeta}',
0x1D702: '\\mathmit{\\eta}',
0x1D703: '\\mathmit{\\theta}',
0x1D704: '\\mathmit{\\iota}',
0x1D705: '\\mathmit{\\kappa}',
0x1D706: '\\mathmit{\\lambda}',
0x1D707: '\\mathmit{\\mu}',
0x1D708: '\\mathmit{\\nu}',
0x1D709: '\\mathmit{\\xi}',
0x1D70A: '\\mathmit{o}',
0x1D70B: '\\mathmit{\\pi}',
0x1D70C: '\\mathmit{\\rho}',
0x1D70D: '\\mathmit{\\varsigma}',
0x1D70E: '\\mathmit{\\sigma}',
0x1D70F: '\\mathmit{\\tau}',
0x1D710: '\\mathmit{\\upsilon}',
0x1D711: '\\mathmit{\\phi}',
0x1D712: '\\mathmit{\\chi}',
0x1D713: '\\mathmit{\\psi}',
0x1D714: '\\mathmit{\\omega}',
0x1D715: '\\partial',
0x1D716: '\\in',
0x1D717: '\\mathmit{\\vartheta}',
0x1D718: '\\mathmit{\\varkappa}',
0x1D719: '\\mathmit{\\phi}',
0x1D71A: '\\mathmit{\\varrho}',
0x1D71B: '\\mathmit{\\varpi}',
0x1D71C: '\\mathbit{\\Alpha}',
0x1D71D: '\\mathbit{\\Beta}',
0x1D71E: '\\mathbit{\\Gamma}',
0x1D71F: '\\mathbit{\\Delta}',
0x1D720: '\\mathbit{\\Epsilon}',
0x1D721: '\\mathbit{\\Zeta}',
0x1D722: '\\mathbit{\\Eta}',
0x1D723: '\\mathbit{\\Theta}',
0x1D724: '\\mathbit{\\Iota}',
0x1D725: '\\mathbit{\\Kappa}',
0x1D726: '\\mathbit{\\Lambda}',
0x1D727: '\\mathbit{M}',
0x1D728: '\\mathbit{N}',
0x1D729: '\\mathbit{\\Xi}',
0x1D72A: 'O',
0x1D72B: '\\mathbit{\\Pi}',
0x1D72C: '\\mathbit{\\Rho}',
0x1D72D: '\\mathbit{O}',
0x1D72E: '\\mathbit{\\Sigma}',
0x1D72F: '\\mathbit{\\Tau}',
0x1D730: '\\mathbit{\\Upsilon}',
0x1D731: '\\mathbit{\\Phi}',
0x1D732: '\\mathbit{\\Chi}',
0x1D733: '\\mathbit{\\Psi}',
0x1D734: '\\mathbit{\\Omega}',
0x1D735: '\\mathbit{\\nabla}',
0x1D736: '\\mathbit{\\alpha}',
0x1D737: '\\mathbit{\\beta}',
0x1D738: '\\mathbit{\\gamma}',
0x1D739: '\\mathbit{\\delta}',
0x1D73A: '\\mathbit{\\epsilon}',
0x1D73B: '\\mathbit{\\zeta}',
0x1D73C: '\\mathbit{\\eta}',
0x1D73D: '\\mathbit{\\theta}',
0x1D73E: '\\mathbit{\\iota}',
0x1D73F: '\\mathbit{\\kappa}',
0x1D740: '\\mathbit{\\lambda}',
0x1D741: '\\mathbit{\\mu}',
0x1D742: '\\mathbit{\\nu}',
0x1D743: '\\mathbit{\\xi}',
0x1D744: '\\mathbit{o}',
0x1D745: '\\mathbit{\\pi}',
0x1D746: '\\mathbit{\\rho}',
0x1D747: '\\mathbit{\\varsigma}',
0x1D748: '\\mathbit{\\sigma}',
0x1D749: '\\mathbit{\\tau}',
0x1D74A: '\\mathbit{\\upsilon}',
0x1D74B: '\\mathbit{\\phi}',
0x1D74C: '\\mathbit{\\chi}',
0x1D74D: '\\mathbit{\\psi}',
0x1D74E: '\\mathbit{\\omega}',
0x1D74F: '\\partial',
0x1D750: '\\in',
0x1D751: '\\mathbit{\\vartheta}',
0x1D752: '\\mathbit{\\varkappa}',
0x1D753: '\\mathbit{\\phi}',
0x1D754: '\\mathbit{\\varrho}',
0x1D755: '\\mathbit{\\varpi}',
0x1D756: '\\mathsfbf{\\Alpha}',
0x1D757: '\\mathsfbf{\\Beta}',
0x1D758: '\\mathsfbf{\\Gamma}',
0x1D759: '\\mathsfbf{\\Delta}',
0x1D75A: '\\mathsfbf{\\Epsilon}',
0x1D75B: '\\mathsfbf{\\Zeta}',
0x1D75C: '\\mathsfbf{\\Eta}',
0x1D75D: '\\mathsfbf{\\Theta}',
0x1D75E: '\\mathsfbf{\\Iota}',
0x1D75F: '\\mathsfbf{\\Kappa}',
0x1D760: '\\mathsfbf{\\Lambda}',
0x1D761: '\\mathsfbf{M}',
0x1D762: '\\mathsfbf{N}',
0x1D763: '\\mathsfbf{\\Xi}',
0x1D764: 'O',
0x1D765: '\\mathsfbf{\\Pi}',
0x1D766: '\\mathsfbf{\\Rho}',
0x1D767: '\\mathsfbf{\\vartheta}',
0x1D768: '\\mathsfbf{\\Sigma}',
0x1D769: '\\mathsfbf{\\Tau}',
0x1D76A: '\\mathsfbf{\\Upsilon}',
0x1D76B: '\\mathsfbf{\\Phi}',
0x1D76C: '\\mathsfbf{\\Chi}',
0x1D76D: '\\mathsfbf{\\Psi}',
0x1D76E: '\\mathsfbf{\\Omega}',
0x1D76F: '\\mathsfbf{\\nabla}',
0x1D770: '\\mathsfbf{\\alpha}',
0x1D771: '\\mathsfbf{\\beta}',
0x1D772: '\\mathsfbf{\\gamma}',
0x1D773: '\\mathsfbf{\\delta}',
0x1D774: '\\mathsfbf{\\epsilon}',
0x1D775: '\\mathsfbf{\\zeta}',
0x1D776: '\\mathsfbf{\\eta}',
0x1D777: '\\mathsfbf{\\theta}',
0x1D778: '\\mathsfbf{\\iota}',
0x1D779: '\\mathsfbf{\\kappa}',
0x1D77A: '\\mathsfbf{\\lambda}',
0x1D77B: '\\mathsfbf{\\mu}',
0x1D77C: '\\mathsfbf{\\nu}',
0x1D77D: '\\mathsfbf{\\xi}',
0x1D77E: '\\mathsfbf{o}',
0x1D77F: '\\mathsfbf{\\pi}',
0x1D780: '\\mathsfbf{\\rho}',
0x1D781: '\\mathsfbf{\\varsigma}',
0x1D782: '\\mathsfbf{\\sigma}',
0x1D783: '\\mathsfbf{\\tau}',
0x1D784: '\\mathsfbf{\\upsilon}',
0x1D785: '\\mathsfbf{\\phi}',
0x1D786: '\\mathsfbf{\\chi}',
0x1D787: '\\mathsfbf{\\psi}',
0x1D788: '\\mathsfbf{\\omega}',
0x1D789: '\\partial',
0x1D78A: '\\mathsfbf{\\varepsilon}',
0x1D78B: '\\mathsfbf{\\vartheta}',
0x1D78C: '\\mathsfbf{\\varkappa}',
0x1D78D: '\\mathsfbf{\\phi}',
0x1D78E: '\\mathsfbf{\\varrho}',
0x1D78F: '\\mathsfbf{\\varpi}',
0x1D790: '\\mathsfbfsl{\\Alpha}',
0x1D791: '\\mathsfbfsl{\\Beta}',
0x1D792: '\\mathsfbfsl{\\Gamma}',
0x1D793: '\\mathsfbfsl{\\Delta}',
0x1D794: '\\mathsfbfsl{\\Epsilon}',
0x1D795: '\\mathsfbfsl{\\Zeta}',
0x1D796: '\\mathsfbfsl{\\Eta}',
0x1D797: '\\mathsfbfsl{\\vartheta}',
0x1D798: '\\mathsfbfsl{\\Iota}',
0x1D799: '\\mathsfbfsl{\\Kappa}',
0x1D79A: '\\mathsfbfsl{\\Lambda}',
0x1D79B: '\\mathsfbfsl{M}',
0x1D79C: '\\mathsfbfsl{N}',
0x1D79D: '\\mathsfbfsl{\\Xi}',
0x1D79E: 'O',
0x1D79F: '\\mathsfbfsl{\\Pi}',
0x1D7A0: '\\mathsfbfsl{\\Rho}',
0x1D7A1: '\\mathsfbfsl{\\vartheta}',
0x1D7A2: '\\mathsfbfsl{\\Sigma}',
0x1D7A3: '\\mathsfbfsl{\\Tau}',
0x1D7A4: '\\mathsfbfsl{\\Upsilon}',
0x1D7A5: '\\mathsfbfsl{\\Phi}',
0x1D7A6: '\\mathsfbfsl{\\Chi}',
0x1D7A7: '\\mathsfbfsl{\\Psi}',
0x1D7A8: '\\mathsfbfsl{\\Omega}',
0x1D7A9: '\\mathsfbfsl{\\nabla}',
0x1D7AA: '\\mathsfbfsl{\\alpha}',
0x1D7AB: '\\mathsfbfsl{\\beta}',
0x1D7AC: '\\mathsfbfsl{\\gamma}',
0x1D7AD: '\\mathsfbfsl{\\delta}',
0x1D7AE: '\\mathsfbfsl{\\epsilon}',
0x1D7AF: '\\mathsfbfsl{\\zeta}',
0x1D7B0: '\\mathsfbfsl{\\eta}',
0x1D7B1: '\\mathsfbfsl{\\vartheta}',
0x1D7B2: '\\mathsfbfsl{\\iota}',
0x1D7B3: '\\mathsfbfsl{\\kappa}',
0x1D7B4: '\\mathsfbfsl{\\lambda}',
0x1D7B5: '\\mathsfbfsl{\\mu}',
0x1D7B6: '\\mathsfbfsl{\\nu}',
0x1D7B7: '\\mathsfbfsl{\\xi}',
0x1D7B8: '\\mathsfbfsl{o}',
0x1D7B9: '\\mathsfbfsl{\\pi}',
0x1D7BA: '\\mathsfbfsl{\\rho}',
0x1D7BB: '\\mathsfbfsl{\\varsigma}',
0x1D7BC: '\\mathsfbfsl{\\sigma}',
0x1D7BD: '\\mathsfbfsl{\\tau}',
0x1D7BE: '\\mathsfbfsl{\\upsilon}',
0x1D7BF: '\\mathsfbfsl{\\phi}',
0x1D7C0: '\\mathsfbfsl{\\chi}',
0x1D7C1: '\\mathsfbfsl{\\psi}',
0x1D7C2: '\\mathsfbfsl{\\omega}',
0x1D7C3: '\\partial',
0x1D7C4: '\\in',
0x1D7C5: '\\mathsfbfsl{\\vartheta}',
0x1D7C6: '\\mathsfbfsl{\\varkappa}',
0x1D7C7: '\\mathsfbfsl{\\phi}',
0x1D7C8: '\\mathsfbfsl{\\varrho}',
0x1D7C9: '\\mathsfbfsl{\\varpi}',
0x1D7CE: '\\mathbf{0}',
0x1D7CF: '\\mathbf{1}',
0x1D7D0: '\\mathbf{2}',
0x1D7D1: '\\mathbf{3}',
0x1D7D2: '\\mathbf{4}',
0x1D7D3: '\\mathbf{5}',
0x1D7D4: '\\mathbf{6}',
0x1D7D5: '\\mathbf{7}',
0x1D7D6: '\\mathbf{8}',
0x1D7D7: '\\mathbf{9}',
0x1D7D8: '\\mathbb{0}',
0x1D7D9: '\\mathbb{1}',
0x1D7DA: '\\mathbb{2}',
0x1D7DB: '\\mathbb{3}',
0x1D7DC: '\\mathbb{4}',
0x1D7DD: '\\mathbb{5}',
0x1D7DE: '\\mathbb{6}',
0x1D7DF: '\\mathbb{7}',
0x1D7E0: '\\mathbb{8}',
0x1D7E1: '\\mathbb{9}',
0x1D7E2: '\\mathsf{0}',
0x1D7E3: '\\mathsf{1}',
0x1D7E4: '\\mathsf{2}',
0x1D7E5: '\\mathsf{3}',
0x1D7E6: '\\mathsf{4}',
0x1D7E7: '\\mathsf{5}',
0x1D7E8: '\\mathsf{6}',
0x1D7E9: '\\mathsf{7}',
0x1D7EA: '\\mathsf{8}',
0x1D7EB: '\\mathsf{9}',
0x1D7EC: '\\mathsfbf{0}',
0x1D7ED: '\\mathsfbf{1}',
0x1D7EE: '\\mathsfbf{2}',
0x1D7EF: '\\mathsfbf{3}',
0x1D7F0: '\\mathsfbf{4}',
0x1D7F1: '\\mathsfbf{5}',
0x1D7F2: '\\mathsfbf{6}',
0x1D7F3: '\\mathsfbf{7}',
0x1D7F4: '\\mathsfbf{8}',
0x1D7F5: '\\mathsfbf{9}',
0x1D7F6: '\\mathtt{0}',
0x1D7F7: '\\mathtt{1}',
0x1D7F8: '\\mathtt{2}',
0x1D7F9: '\\mathtt{3}',
0x1D7FA: '\\mathtt{4}',
0x1D7FB: '\\mathtt{5}',
0x1D7FC: '\\mathtt{6}',
0x1D7FD: '\\mathtt{7}',
0x1D7FE: '\\mathtt{8}',
0x1D7FF: '\\mathtt{9}',
}
|
n1 = int(input('Enter number 1: '))
n2 = int(input('Enter number 2: '))
n3 = int(input('Enter number 3: '))
menor = n1
if n2 < n1 and n2 < n3:
menor = n2
if n3 < n1 and n3 < n2:
menor = n3
maior = n1
if n2 > n1 and n2 > n3:
maior = n2
if n3 > n1 and n3 > n2:
maior = n3
print("Menor e {}".format(menor))
print("Maior e {}".format(maior))
|
# *********************************
# ****** SECTION 1 - CLASSES ******
# *********************************
# A "Class" is like a blueprint for an object
# Objects can be many different things
# In a grade tracking program objects might be: Course, Period, Teacher, Student, Gradable Assignment, Comment, Etc.
# In Mario objects might be: Mario, Level, Enemy, Power Up (like star or mushroom), Hittable Block, Etc.
# In banking software objects might be: Customer, Account, Deposit, Withdrawal, Etc.
# Note: Classes are normally named with capital letters with no spaces. But that is not required, just recommended.
class UnknownStudent:
name = "Unknown"
age = "Unknown"
# Now that the blueprint exists we can create an INSTANCE of the class
first_student = UnknownStudent()
first_student.name = "John Smith"
first_student.age = 15
print(f"The student's name is {first_student.name} and he is {first_student.age} years old.")
# ********************************************
# ****** SECTION 2 - CONSTRUCTOR METHOD ******
# ********************************************
# A method is what we call a function that belongs to a class.
# A CONSTRUCTOR method runs when a new instance is created.
# The purpose of a constructor is to setup any initial values for a new instance.
# A constructor in python uses the name: __init__
# NOTE: It is considered good practice to always have a constructor even if it does nothing.
class Student:
# NOTE: For constructor input parameters I like to start them with an underscore.
def __init__(self, _name, _age):
self.name = _name
self.age = _age
# second_student = Student(_name="Jane", _age="Doe")
# print(f"The student's name is {second_student.name} and her age is {second_student.age}.")
# ***************************************
# ****** SECTION 3 - OTHER METHODS ******
# ***************************************
# A class can (and usually does) have other methods besides the constructor
class Dog:
def __init__(self, _name, _breed, _color):
self.name = _name
self.breed = _breed
self.color = _color
self.position = 0
def run(self, distance=1):
self.position += distance
print(f"{self.name} ran {distance} meters and is now at position {self.position}.")
def bark(self):
if self.breed == "Lab":
print("Woof")
elif self.breed == "Terrier":
print("Yap")
else:
print("Bark")
def get_color(self):
return self.color
# my_dog = Dog(_name="Ellie", _breed="Lab", _color="Yellow")
# my_dog.run(5)
# my_dog.run(-2)
# my_dog.bark()
# print(f"My dog is {my_dog.color}.")
# *************************************
# ****** SECTION 3 - INHERITANCE ******
# *************************************
# For the sake of organization it is often useful to have one class inherit another.
# Usually the parent class is something generic and the child is one type of the parent class
class Animal:
def __init__(self):
self.position = 0
self.speed = 0
self.noise = "[silence]"
def run(self):
self.position += self.speed
print(f"The animal ran {self.speed} meters and is now at position {self.position}.")
def make_noise(self):
print(self.noise)
class Jaguar(Animal):
def __init__(self):
self.position = 0
self.speed = 10
self.noise = "growwwl"
class Horse(Animal):
def __init__(self):
self.position = 0
self.speed = 8
self.noise = "neigggh"
class Snake(Animal):
def __init__(self):
self.position = 0
self.speed = 1
self.noise = "hssss"
def run(self):
self.position += self.speed
print(f"The snake slithered {self.speed} meters and is now at position {self.position}.")
# jax = Jaguar()
# jax.run()
# jax.make_noise()
#
# harvey = Horse()
# harvey.run()
# harvey.make_noise()
#
# steve = Snake()
# steve.run()
# steve.make_noise()
# ******************************************************
# ****** SECTION 4 - S.O.L.I.D. DESIGN PRINCIPLES ******
# ******************************************************
# S.O.L.I.D is an acronym. If we follow the 5 recommendations our code
# will be easier to modify and maintain in the future
# S - Single Responsibility: Classes should have a singular purpose. If you try to do everything in onc class it
# gets cluttered and difficult to maintain.
# O - Open for extension, Closed for modification: A class should be able to be added onto at a later time,
# In general it should be generic enough that future situations don't cause you to
# change existing code in the class.
# L - Liskov Substitution: Any inherited class should be substitutable with its parent class. In our example above
# a Horse should be able to do whatever an Animal can do.
# I - Interface Segregation: This one basically says that if a child class doesn't fit in the parent class then
# make a new parent class. (For example if I wanted an animal like snail it might need
# its own parent class becuase it doesn't make noise and it doesnt really run).
# D - Dependency Inversion: Means that child classes can (and should) depend on their parent classes to define
# Their behavior. But a parent should never be dependent on a child class. For example,
# an Animal should not have any of their behavior defined by a snake because snake is
# an Animal. You could have a jaguar react to a snake, but not a generic Animal.
|
_base_ = [
# './_base_/models/segformer.py',
'../configs/_base_/datasets/mapillary.py',
'../configs/_base_/default_runtime.py',
'./_base_/schedules/schedule_1600k_adamw.py'
]
norm_cfg = dict(type='BN', requires_grad=True)
backbone_norm_cfg = dict(type='LN', requires_grad=True)
model = dict(
type='EncoderDecoder',
pretrained=
'https://github.com/SwinTransformer/storage/releases/download/v1.0.0/swin_base_patch4_window12_384_22k.pth',
backbone=dict(
type='SwinTransformer',
pretrain_img_size=384,
embed_dims=128,
patch_size=4,
window_size=12,
mlp_ratio=4,
depths=[2, 2, 18, 2],
num_heads=[4, 8, 16, 32],
strides=(4, 2, 2, 2),
out_indices=(0, 1, 2, 3),
qkv_bias=True,
qk_scale=None,
patch_norm=True,
drop_rate=0.0,
attn_drop_rate=0.0,
drop_path_rate=0.3,
use_abs_pos_embed=False,
act_cfg=dict(type='GELU'),
norm_cfg=dict(type='LN', requires_grad=True),
pretrain_style='official'),
decode_head=dict(
type='UPerHead',
in_channels=[128, 256, 512, 1024],
in_index=[0, 1, 2, 3],
pool_scales=(1, 2, 3, 6),
channels=512,
dropout_ratio=0.1,
num_classes=66,
norm_cfg=dict(type='BN', requires_grad=True),
align_corners=False,
loss_decode=dict(
type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
auxiliary_head=dict(
type='FCNHead',
in_channels=512,
in_index=2,
channels=256,
num_convs=1,
concat_input=False,
dropout_ratio=0.1,
num_classes=66,
norm_cfg=dict(type='BN', requires_grad=True),
align_corners=False,
loss_decode=dict(
type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
train_cfg=dict(),
test_cfg=dict(mode='whole'))
log_config = dict(
interval=50,
hooks=[
dict(type='TextLoggerHook', by_epoch=False),
dict(type='WandbLoggerHook', by_epoch=False)
])
crop_size = (720, 720)
img_norm_cfg = dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
train_pipeline = [
dict(type='LoadImageFromFile'),
dict(type='LoadAnnotations'),
dict(type='Resize', img_scale=(1920, 1080), ratio_range=(0.5, 2.0)),
dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
dict(type='RandomFlip', prob=0.5),
dict(type='PhotoMetricDistortion'),
dict(type='Normalize', **img_norm_cfg),
dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
dict(type='DefaultFormatBundle'),
dict(type='Collect', keys=['img', 'gt_semantic_seg']),
]
data = dict(
samples_per_gpu=1,
workers_per_gpu=1,
train=dict(pipeline=train_pipeline, data_root='/workspace/Mapillary'),
val=dict(data_root='/workspace/Mapillary'),#, split='/workspace/mmsegmentation/splits/split.txt'),
test=dict(data_root='/workspace/Mapillary')#, split='/workspace/mmsegmentation/splits/split.txt')
)
# dist_params = dict(backend='nccl')
# log_level = 'INFO'
# load_from = None
# resume_from = None
# workflow = [('train', 1), ('val', 1)]
# cudnn_benchmark = True
optimizer = dict(
type='AdamW',
lr=1.5e-05,
betas=(0.9, 0.999),
weight_decay=0.01,
paramwise_cfg=dict(
custom_keys=dict(
absolute_pos_embed=dict(decay_mult=0.0),
relative_position_bias_table=dict(decay_mult=0.0),
norm=dict(decay_mult=0.0))))
optimizer_config = dict()
lr_config = dict(
policy='poly',
warmup='linear',
warmup_iters=1500,
warmup_ratio=1e-06,
power=1.0,
min_lr=0.0,
by_epoch=False)
evaluation = dict(interval=16000, metric='mIoU') |
"""
https://leetcode.com/problems/average-of-levels-in-binary-tree/
Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.
Example 1:
Input:
3
/ \
9 20
/ \
15 7
Output: [3, 14.5, 11]
Explanation:
The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].
Note:
The range of node's value is in the range of 32-bit signed integer.
"""
# time complexity: O(n), space complexity: O(width of the tree)
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
queue = [root]
result = []
levelnumber = 1
scannumber = 0
number = 0
levelsum = 0
while queue:
element = queue.pop(0)
scannumber += 1
if element is not None:
number += 1
levelsum += element.val
queue.append(element.left)
queue.append(element.right)
if scannumber == levelnumber:
if number == 0:
return result
else:
result.append(levelsum/number)
scannumber = 0
levelnumber = len(queue)
number = 0
levelsum = 0
return result |
M1, D1 = [int(x) for x in input().split()]
M2, D2 = [int(x) for x in input().split()]
if M1 != M2:
print(1)
else:
print(0)
|
def start_streaming_dataframe():
"Start a Spark Streaming DataFrame from a Kafka Input source"
schema = StructType(
[StructField(f["name"], f["type"], True) for f in field_metadata]
)
kafka_options = {
"kafka.ssl.protocol":"TLSv1.2",
"kafka.ssl.enabled.protocols":"TLSv1.2",
"kafka.ssl.endpoint.identification.algorithm":"HTTPS",
'kafka.sasl.mechanism': 'PLAIN',
'kafka.security.protocol': 'SASL_SSL'
}
return spark.readStream \
.format("kafka") \
.option("kafka.bootstrap.servers", ",".join(message_hub_creds["kafka_brokers_sasl"])) \
.option("subscribe", "enriched_tweets") \
.load(**kafka_options)
|
{
'targets': [
{
'target_name': 'rdpcred',
'conditions': [ [
'OS=="win"',
{
'sources': [ 'rdpcred.cc' ],
'msvs_settings': {
'VCLinkerTool': {
'AdditionalDependencies': [
'Crypt32.lib'
]
}
}
}
] ]
}
]
} |
# Unicode symbol in string:
print("Ѣ")
# Using the character name:
print("\N{Cyrillic Capital Letter Yat}")
# Using a 16-bit hex value code point:
print("\u0462")
# Using a 32-bit hex value code point:
print("\U00000462") |
class Fibo(object):
"""docstring for Fibo"""
def __init__(self):
self.memo = []
def fibonacci(self, n, debug=False):
if debug:
print(self.memo)
if self.memo[n] != 0:
return self.memo[n]
if n==1 or n==2:
self.memo[n] = 1
else:
self.memo[n] = self.fibonacci(n-1) + self.fibonacci(n-2)
return self.memo[n]
def main(self, n):
self.memo = [0 for i in range(n+1)]
print(self.fibonacci(n))
Fibo().main(30) |
"""
0944. Delete Columns to Make Sorted
Easy
We are given an array A of N lowercase letter strings, all of the same length.
Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.
For example, if we have an array A = ["abcdef","uvwxyz"] and deletion indices {0, 2, 3}, then the final array after deletions is ["bef", "vyz"], and the remaining columns of A are ["b","v"], ["e","y"], and ["f","z"]. (Formally, the c-th column is [A[0][c], A[1][c], ..., A[A.length-1][c]]).
Suppose we chose a set of deletion indices D such that after deletions, each remaining column in A is in non-decreasing sorted order.
Return the minimum possible value of D.length.
Example 1:
Input: A = ["cba","daf","ghi"]
Output: 1
Explanation:
After choosing D = {1}, each column ["c","d","g"] and ["a","f","i"] are in non-decreasing sorted order.
If we chose D = {}, then a column ["b","a","h"] would not be in non-decreasing sorted order.
Example 2:
Input: A = ["a","b"]
Output: 0
Explanation: D = {}
Example 3:
Input: A = ["zyx","wvu","tsr"]
Output: 3
Explanation: D = {0, 1, 2}
Constraints:
1 <= A.length <= 100
1 <= A[i].length <= 1000
"""
class Solution:
def minDeletionSize(self, A: List[str]) -> int:
return sum(list(col) != sorted(col) for col in zip(*A))
|
class Solution:
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return
d = collections.deque()
d.append(root)
while d:
node = d.popleft()
if node.left and node.right:
node.left.next = node.right
if node.next:
node.right.next = node.next.left
d.append(node.left)
d.append(node.right)
return root
## second solution, same to "117. Populating Next Right Pointers in Each Node II"
'''
class Solution:
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if not root:
return
d = collections.deque()
d.append(root)
res = []
while d:
temp = []
for _ in range(len(d)):
node = d.popleft()
temp.append(node)
d.append(node.left) if node.left else 0
d.append(node.right) if node.right else 0
res.append(temp)
for a in res:
for i in range(len(a)-1):
a[i].next = a[i+1]
return root
'''
|
pro = 1
tar = 1
cur = 1
pos = 1
i = 1
while i < 8 :
lcur = list(str(cur))
if len(lcur) > tar - pos:
pro *= int(lcur[tar-pos])
i += 1
tar *= 10
pos += len(lcur)
cur += 1
print(pro)
|
n = int(input())
for _ in range(n):
store = int(input())
loc = list(map(int, input().split()))
dist = 2 * (max(loc) - min(loc))
print(dist)
|
# Given head which is a reference node to a singly-linked list.
# The value of each node in the linked list is either 0 or 1.
# The linked list holds the binary representation of a number.
# Return the decimal value of the number in the linked list.
# Example 1:
# Input: head = [1,0,1]
# Output: 5
# Explanation: (101) in base 2 = (5) in base 10
# Example 2:
# Input: head = [0]
# Output: 0
# Example 3:
# Input: head = [1]
# Output: 1
# Example 4:
# Input: head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
# Output: 18880
# Example 5:
# Input: head = [0,0]
# Output: 0
# Constraints:
# The Linked List is not empty.
# Number of nodes will not exceed 30.
# Each node's value is either 0 or 1.
# Hints:
# Traverse the linked list and store all values in a string or array.
# convert the values obtained to decimal value.
# You can solve the problem in O(1) memory using bits operation.
# use shift left operation ( << ) and or operation ( | ) to get the decimal value in one operation.
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def getDecimalValue(self, head):
"""
:type head: ListNode
:rtype: int
"""
# M1. 模拟
res = 0
while head:
res = res * 2 + head.val
head = head.next
return res
# M2. 模拟
res = 0
while head:
res = res << 1 | head.val
head = head.next
return res
|
graph_file_name="/home/cluster_share/graph/soc-LiveJournal1_notmap.txt"
out_put_file_name='/home/amax/Graph_json/livejournal_not_mapped_json'
graph_file = open(graph_file_name)
output_file = open(out_put_file_name, 'w')
edge = dict()
for line in graph_file:
#line = line[:-2]
res = line.split()
#print(res)
source = int(res[0])
dest = int(res[1])
if edge.has_key(source):
edge[source].append(dest)
else:
edge[source] = [dest]
for source in edge:
edges = edge[source]
output_file.write("["+str(source)+",0,[")
output_file.write(",".join("["+str(i)+",0]" for i in edges))
output_file.write("]]\n")
graph_file.close()
output_file.close()
|
"""
Melwin memberships
==================
Connects the melwin code for membership with human readable description
"_id" : ObjectId("54970947a01ed2381196c9f5"),
"name" : "Familie Medlemsskap",
"id" : "FAM"
"""
_schema = {
'id': {'type': 'string',
'required': True,
},
'name': {'type': 'string',
},
}
definition = {
'item_title': 'membership',
#'item_url': 'clubs',
'url': 'melwin/memberships',
'description': 'Melwin passthrough',
'datasource': {'source': 'melwin_membership',
'default_sort': [('id', 1)],
},
'resource_methods': ['GET'],
'item_methods': ['GET'],
'versioning': False,
'additional_lookup': {
'url': 'regex("[\w{3}]+")',
'field': 'id',
},
'schema': _schema,
} |
class ParkingLot(object):
def __init__(self, commands: str, first_ticket_number: int = 5000, parking_lot_size: int = 10):
# Counter set to 5k by default.
self.counter = first_ticket_number
self.parking_lot_size = parking_lot_size
# Save as a dictionary. Keys will serve as the parking space number, from 0 to 9.
# Alternatively, could have used two lists, one for the car name and one for the ticket number.
# Or a dictionary with insertions to the beginning.
self.parking_lot = {i: '' for i in range(0, self.parking_lot_size)}
# Command list cleaning and split.
self.commands = [c for c in commands.replace(' ', '').split(';') if c != '']
self.cars = []
def __new__(cls, commands: str, first_ticket_number: int = 5000, parking_lot_size: int = 10):
"""
Returns an instance of its own class, ParkingLot
"""
instance = super(ParkingLot, cls).__new__(cls)
instance.__init__(commands, first_ticket_number, parking_lot_size)
instance.process_commands()
parked_cars = instance.return_cars()
return parked_cars
def process_commands(self):
# Processes sequence of commands.
for c in self.commands:
if c[0] == 'p':
# Parks the car in the closest place to the exit.
self.park(c[1:])
elif c[0] == 'u':
# Removes the car name from the parking lot.
self.unpark(c[1:])
elif c[0] == 'c':
# Checks command purity.
try:
assert len(c) == 1
except AssertionError:
raise ValueError(f"ERROR: Given command for compacting the parking lot is not correct. Should be 'c' not '{c}'")
# Compacts parking lot.
self.compact()
else:
raise NotImplementedError('ERROR: Command not recognised.')
def return_cars(self):
# Returns parked cars sorted by proximity to exit.
return ', '.join([c['car'] if isinstance(c, dict) else '' for c in self.parking_lot.values()])
def park(self, car_name: str):
# Adds a car to the position in the parking lot closer to 0.
if car_name in self.cars:
print(f'WARNING: Car {car_name} already parked at position {duplicates[0]}. Skipping command')
else:
# Park the car.
for key, value in self.parking_lot.items():
if value == '':
self.parking_lot[key] = {'car': car_name, 'ticket': self.counter}
self.counter += 1
# Keep track of parked car names.
self.cars.append(car_name)
break
def unpark(self, ticket_number: str):
# remove car from parking lot
try:
int(ticket_number)
except ValueError:
raise ValueError('ERROR: Ticket number is not a number')
if len(self.cars) == 0:
raise ValueError('ERROR: No cars to unpark.')
else:
for key, value in self.parking_lot.items():
if isinstance(value, dict):
if value['ticket'] == int(ticket_number):
# Clear the space
self.parking_lot[key] = ''
# Remove car from the list of parked cars.
self.cars.remove(value['car'])
break
def compact(self):
# Move all cars closer to the exit.
parked_cars = [car for i, car in self.parking_lot.items() if isinstance(car, dict)]
# Returns the parking lot dictionary of size 'size'
self.parking_lot = {i: '' for i in range(0, self.parking_lot_size)}
for i, car in enumerate(parked_cars):
# Recreate parking lot.
self.parking_lot[i] = car
|
text = input()
for i in range(len(text)):
if text[i] == ":":
print(text[i] + text[i + 1]) |
class ExternalFileUtils(object):
""" A utility class containing functions related to external file references. """
@staticmethod
def GetAllExternalFileReferences(aDoc):
"""
GetAllExternalFileReferences(aDoc: Document) -> ICollection[ElementId]
Gets the ids of all elements which are external file references.
aDoc: A Revit Document.
Returns: The ids of all elements which are external file references.
"""
pass
@staticmethod
def GetExternalFileReference(aDoc,elemId):
"""
GetExternalFileReference(aDoc: Document,elemId: ElementId) -> ExternalFileReference
Gets the external file referencing data for the given element.
aDoc: A Revit Document.
elemId: The element whose external file reference we want.
Returns: An object containing path and type information for the given element's external
file.
"""
pass
@staticmethod
def IsExternalFileReference(aDoc,elemId):
"""
IsExternalFileReference(aDoc: Document,elemId: ElementId) -> bool
Determines whether the given element represents an external file.
aDoc: A Revit Document.
elemId: The element to be checked for an external file reference.
Returns: True if the given element represents an external file; false otherwise.
"""
pass
__all__=[
'GetAllExternalFileReferences',
'GetExternalFileReference',
'IsExternalFileReference',
]
|
DEBUG = True
SERVE_MEDIA = DEBUG
TEMPLATE_DEBUG = DEBUG
EMAIL_DEBUG = DEBUG
THUMBNAIL_DEBUG = DEBUG
DEBUG_PROPAGATE_EXCEPTIONS = False
# DATABASE_ENGINE = 'postgresql_psycopg2' # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
# DATABASE_HOST = '192.168.0.2' # Set to empty string for localhost. Not used with sqlite3.
# DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3.
EMAIL_HOST = 'localhost'
EMAIL_PORT = 1025
#python -u -m smtpd -n -c DebuggingServer localhost:1025 |
# Example of Iterator Design Pattern
def count_to(count):
numbers = ["one", "two", "three", "four", "five"]
for number in numbers[:count]:
yield number
count_to_two = count_to(2)
count_to_five = count_to(5)
for count in [count_to_two, count_to_five]:
for number in count:
print(number, end=' ')
print()
|
"""AoC Day 10"""
pairs = (
"{",
"}",
"[",
"]",
"<",
">",
"(",
")",
)
openings = pairs[0::2]
closings = pairs[1::2]
def compose(*functions):
def inner(arg):
for f in reversed(functions):
arg = f(arg)
return arg
return inner
def find_corrupted(line):
"""Return the first bad char in line or None if the line isn't corrupted.
By "bad", we mean a closing bracket without a matching opening bracket."""
stack = []
for char in line:
if char in openings:
stack.append(char)
elif char in closings:
closing_index = closings.index(char)
if stack[-1] == openings[closing_index]:
stack.pop()
else:
return char
else:
raise RuntimeError(char + " not recognised")
def one(lines):
"""Score the corrupted lines."""
points = {
")": 3,
"]": 57,
"}": 1197,
">": 25137,
}
lookup = lambda x: points.get(x, 0)
total = sum(map(compose(lookup, find_corrupted), lines))
return total
def find_closings(line):
stack = []
for char in line:
if char in openings:
stack.append(char)
elif char in closings:
closing_index = closings.index(char)
if stack[-1] == openings[closing_index]:
stack.pop()
else:
raise RuntimeError(char + " not recognised")
result = ""
for x in stack[::-1]:
# If, e.g., "{" is the zeroth element in openings then we want "}",
# which will be the zeroth element in closings
result += closings[openings.index(x)]
return result
def get_score(string):
points = {
")": 1,
"]": 2,
"}": 3,
">": 4,
}
total = 0
for x in string:
total *= 5
total += points[x]
return total
def two(lines):
"""Score the incomplete lines."""
scores = sorted(map(compose(get_score, find_closings),
filter(lambda line: find_corrupted(line) is None, lines)))
return scores[len(scores)//2]
if __name__ == "__main__":
with open("input.txt", encoding="utf-8") as file:
input_list = file.read().splitlines()
answer = one(input_list)
print("one: ", answer)
answer = two(input_list)
print("two: ", answer)
|
n1 = int(input('Número 1: '))
n2 = int(input('Número 2: '))
n3 = int(input('Número 3: '))
if n1 > n2:
m = n1
else:
m = n2
if n3 > m:
m = n3
print('Maior: {}'.format(m))
|
class Layout:
def __init__(self, keyboard):
if keyboard == "azerty":
self.up = 'Z'
self.down = 'S'
self.left = 'Q'
self.right = 'D'
self.ok = 'C'
self.no = 'K'
self.drop = 'L'
self.change = 'P'
self.random = 'O'
else:
self.up = 'W'
self.down = 'S'
self.left = 'A'
self.right = 'D'
self.ok = 'C'
self.no = 'K'
self.drop = 'L'
self.change = 'P'
self.random = 'O'
|
# Factorial program with memoization using decorators.
# Memoization is a technique of recording the intermediate results so that it can be used to avoid repeated calculations and speed up the programs.
# memoization can be done with the help of function decorators.
def Memoize(func):
history={}
def wrapper(*args):
if args not in history:
history[args]=func(*args)
return history[args]
return wrapper
def factorial(n):
if type(n)!=int:
raise ValueError("passed value is not integer")
if(n<0):
raise ValueError("number cant be negative passed value{}".format(n))
if n==0 or n==1:
return 1
fact=n*factorial(n-1)
return fact
print(format(factorial(5)))
# Input : 5
# Output : 120 |
NUM, IMG_SIZE, FACE = 8, 720, False
def config(): return None
config.expName = None
config.checkpoint_dir = None
config.train = lambda: None
config.train.batch_size = 4
config.train.lr = 0.001
config.train.decay = 0.001
config.train.epochs = 10
config.latent_code_garms_sz = 1024
config.PCA_ = 35
config.garmentKeys = ['Pants', 'ShortPants',
'ShirtNoCoat', 'TShirtNoCoat', 'LongCoat']
config.NVERTS = 27554
|
# -*- coding: utf-8 -*-
def main():
n = int(input())
b = [0 for _ in range(n)]
for i in range(n):
ai = int(input())
ai -= 1
b[ai] += 1
y = 0
x = 0
for index, bi in enumerate(b, 1):
if bi == 0:
x = index
elif bi == 2:
y = index
if x == 0 and y == 0:
print('Correct')
else:
print(y, x)
if __name__ == '__main__':
main()
|
class VoteBreakdownTotals:
def __init__(self, headers: list[str]):
self.__headers = headers
self.__failures = {}
self.__current_row = 0
votes = "votes"
if votes in self.__headers:
self.__votes_index = self.__headers.index(votes)
else:
self.__votes_index = None
if "candidate" in self.__headers:
self.__candidate_index = self.__headers.index("candidate")
else:
self.__candidate_index = None
components = {"absentee", "early_voting", "election_day", "mail", "provisional"}
self.__component_indices = [i for i, x in enumerate(self.__headers) if x in components]
@property
def passed(self) -> bool:
return len(self.__failures) == 0
def get_failure_message(self, max_examples: int = -1) -> str:
components = [self.__headers[i] for i in self.__component_indices]
message = f"There are {len(self.__failures)} rows where the sum of {components} is greater than 'votes':\n\n" \
f"\tHeaders: {self.__headers}:"
count = 0
for row_number, row in self.__failures.items():
if (max_examples >= 0) and (count >= max_examples):
message += f"\n\t[Truncated to {max_examples} examples]"
return message
else:
message += f"\n\tRow {row_number}: {row}"
count += 1
return message
def test(self, row: list[str]):
self.__current_row += 1
if (len(row) == len(self.__headers)) and self.__votes_index is not None and self.__component_indices:
# There are cases where over votes and under votes are reported as a single aggregate. As such, it's
# possible for the votes to be negative. We will try and avoid these rows.
if self.__candidate_index is not None:
aggregates = {"over/under", "under/over"}
if any(x in row[self.__candidate_index].lower().replace(" ", "") for x in aggregates):
return
try:
# We use float instead of int to allow for values like "3.0".
votes = float(row[self.__votes_index])
except ValueError:
return
component_sum = 0
for component in (row[i] for i in self.__component_indices):
try:
component_value = float(component)
except ValueError:
component_value = 0
component_sum += component_value
if votes < component_sum:
self.__failures[self.__current_row] = row
|
print('=' * 20)
print('{:^20}'.format('CAIXA ELETRÔNICO'))
print('=' * 20)
print('O caixa apresenta cédulas de R$50, R$20, R$10 e R$1.')
ced = 50
totced = 0
valor = int(input('Qual valor você deseja sacar? R$ '))
total = valor
while True:
if total >= ced:
total -= ced
totced += 1
else:
if totced > 0:
print('Total de {} cédulas de R$ {}.'.format(totced, ced))
if ced == 50:
ced = 20
elif ced == 20:
ced = 10
elif ced == 10:
ced = 1
totced = 0
if total == 0:
break
print('OBRIGADO! VOLTE SEMPRE!')
|
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def rob(self, root: Optional[TreeNode]) -> int:
"""
subproblems:
1. rob current node
2. not rob current node
recurrence:
1. find max amount can be robbed for current node
2. pass to the parent:
current robbed
current not robbed
max so far
base cases:
if not root:
return current, max_so_far (0, float(-inf))
answer : rob(root) -> max amount can be robbed
Compelexity:
Time (V*E)
Space (V*E)
"""
return max(self.rob_houses(root))
def rob_houses(self, root):
if not root:
return 0, 0, float(-inf)
left_robbed, left_not_robbed, left_max = self.rob_houses(root.left) # 1, 0, 1
right_robbed, right_not_robbed, right_max = self.rob_houses(root.right) # 3, 0, 3
curren_robbed = left_not_robbed + right_not_robbed + root.val # 4
current_not_robbed = max(left_robbed, left_not_robbed) + max(right_robbed, right_not_robbed)
max_robbed = max(left_max + right_max, curren_robbed, current_not_robbed) # 1, 3, 4
return curren_robbed, current_not_robbed, max_robbed
|
def splitCols(saleRow):
'''this function will split a string with '. Some columns are quoted with
"". So we need to handle it'''
saleRow = saleRow.split(',')
result = []
flag = True # if flag is false, the current i is within a pair of "
for i in range(len(saleRow)):
if flag:
result.append(saleRow[i])
if '"' in saleRow[i]:
flag = False
else:
result[-1] = result[-1] + saleRow[i]
if '"' in saleRow[i]:
flag = True
return result
|
#
# PySNMP MIB module H3C-OBJECT-INFO-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/H3C-OBJECT-INFO-MIB
# Produced by pysmi-0.3.4 at Mon Apr 29 19:10:08 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
Integer, OctetString, ObjectIdentifier = mibBuilder.importSymbols("ASN1", "Integer", "OctetString", "ObjectIdentifier")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ValueSizeConstraint, ValueRangeConstraint, ConstraintsUnion, SingleValueConstraint, ConstraintsIntersection = mibBuilder.importSymbols("ASN1-REFINEMENT", "ValueSizeConstraint", "ValueRangeConstraint", "ConstraintsUnion", "SingleValueConstraint", "ConstraintsIntersection")
h3cCommon, = mibBuilder.importSymbols("HUAWEI-3COM-OID-MIB", "h3cCommon")
NotificationGroup, ModuleCompliance, ObjectGroup = mibBuilder.importSymbols("SNMPv2-CONF", "NotificationGroup", "ModuleCompliance", "ObjectGroup")
MibIdentifier, IpAddress, Unsigned32, Integer32, Counter32, ObjectIdentity, Bits, MibScalar, MibTable, MibTableRow, MibTableColumn, NotificationType, Gauge32, iso, TimeTicks, ModuleIdentity, Counter64 = mibBuilder.importSymbols("SNMPv2-SMI", "MibIdentifier", "IpAddress", "Unsigned32", "Integer32", "Counter32", "ObjectIdentity", "Bits", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "NotificationType", "Gauge32", "iso", "TimeTicks", "ModuleIdentity", "Counter64")
DisplayString, TextualConvention = mibBuilder.importSymbols("SNMPv2-TC", "DisplayString", "TextualConvention")
h3cObjectInfo = ModuleIdentity((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55))
h3cObjectInfo.setRevisions(('2004-12-27 00:00',))
if mibBuilder.loadTexts: h3cObjectInfo.setLastUpdated('200412270000Z')
if mibBuilder.loadTexts: h3cObjectInfo.setOrganization(' Huawei 3Com Technologies Co., Ltd. ')
h3cObjectInformation = MibIdentifier((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1))
h3cObjectInfoTable = MibTable((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1), )
if mibBuilder.loadTexts: h3cObjectInfoTable.setStatus('current')
h3cObjectInfoEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1, 1), ).setIndexNames((0, "H3C-OBJECT-INFO-MIB", "h3cObjectInfoOID"), (0, "H3C-OBJECT-INFO-MIB", "h3cObjectInfoType"), (0, "H3C-OBJECT-INFO-MIB", "h3cObjectInfoTypeExtension"))
if mibBuilder.loadTexts: h3cObjectInfoEntry.setStatus('current')
h3cObjectInfoOID = MibTableColumn((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1, 1, 1), ObjectIdentifier())
if mibBuilder.loadTexts: h3cObjectInfoOID.setStatus('current')
h3cObjectInfoType = MibTableColumn((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1, 1, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(1, 2, 3, 4, 5))).clone(namedValues=NamedValues(("reserved", 1), ("accessType", 2), ("dataType", 3), ("dataRange", 4), ("dataLength", 5))))
if mibBuilder.loadTexts: h3cObjectInfoType.setStatus('current')
h3cObjectInfoTypeExtension = MibTableColumn((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1, 1, 3), OctetString().subtype(subtypeSpec=ValueSizeConstraint(1, 10)))
if mibBuilder.loadTexts: h3cObjectInfoTypeExtension.setStatus('current')
h3cObjectInfoValue = MibTableColumn((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 1, 1, 1, 4), OctetString()).setMaxAccess("readonly")
if mibBuilder.loadTexts: h3cObjectInfoValue.setStatus('current')
h3cObjectInfoMIBConformance = MibIdentifier((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 2))
h3cObjectInfoMIBCompliances = MibIdentifier((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 2, 1))
h3cObjectInfoMIBCompliance = ModuleCompliance((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 2, 1, 1)).setObjects(("H3C-OBJECT-INFO-MIB", "h3cObjectInfoTableGroup"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
h3cObjectInfoMIBCompliance = h3cObjectInfoMIBCompliance.setStatus('current')
h3cObjectInfoMIBGroups = MibIdentifier((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 2, 2))
h3cObjectInfoTableGroup = ObjectGroup((1, 3, 6, 1, 4, 1, 2011, 10, 2, 55, 2, 2, 1)).setObjects(("H3C-OBJECT-INFO-MIB", "h3cObjectInfoValue"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
h3cObjectInfoTableGroup = h3cObjectInfoTableGroup.setStatus('current')
mibBuilder.exportSymbols("H3C-OBJECT-INFO-MIB", h3cObjectInfoEntry=h3cObjectInfoEntry, h3cObjectInfo=h3cObjectInfo, h3cObjectInfoTable=h3cObjectInfoTable, h3cObjectInfoType=h3cObjectInfoType, h3cObjectInfoValue=h3cObjectInfoValue, h3cObjectInfoMIBConformance=h3cObjectInfoMIBConformance, h3cObjectInformation=h3cObjectInformation, h3cObjectInfoTypeExtension=h3cObjectInfoTypeExtension, h3cObjectInfoTableGroup=h3cObjectInfoTableGroup, h3cObjectInfoMIBGroups=h3cObjectInfoMIBGroups, h3cObjectInfoMIBCompliances=h3cObjectInfoMIBCompliances, h3cObjectInfoOID=h3cObjectInfoOID, h3cObjectInfoMIBCompliance=h3cObjectInfoMIBCompliance, PYSNMP_MODULE_ID=h3cObjectInfo)
|
# Most football fans love it for the goals and excitement. Well, this problem does not.
# You are up to handle the referee's little notebook and count the players who were sent off for fouls and misbehavior.
# The rules: Two teams, named "A" and "B" have 11 players each. The players on each team are numbered from 1 to 11.
# Any player may be sent off the field by being given a red card. If one of the teams has less than 7 players remaining,
# the game is stopped immediately by the referee, and the team with less than 7 players loses.
# A card is a string with the team's letter ('A' or 'B') followed by a single dash and player's number.
# e.g. the card 'B-7' means player #7 from team B received a card.
# The task: You will be given a sequence of cards (could be empty), separated by a single space.
# You should print the count of remaining players on each team at the end of the game in the format:
# "Team A - {players_count}; Team B - {players_count}". If the game was terminated by the referee,
# print an additional line: "Game was terminated".
# Note for the random tests: If a player that has already been sent off receives another card - ignore it.
# # 01 solution
# team_a = 11
# team_b = 11
# cards = input().split()
# while True:
# found = True # value for breaking the while loop
# for i in range(len(cards)): # loop the whole list (0, end of str)
# test_digit = cards[i] # take the element on the current position
# for j in range(len(cards)): # loop the whole list for the comparison with the element and the whole list
# if test_digit == cards[j] and (not i == j): # compare the element in test_digit with the current one
# cards.remove(test_digit) # remove the match
# cards.append("") # replace the removed element to keep the integrity of the list
# found = False
# break
# if found:
# break
# stop = False
# for i in cards:
# x = "".join(i)
# if "A" in x:
# team_a -= 1
# elif "B" in x:
# team_b -= 1
# if team_a < 7 or team_b < 7:
# stop = True
# break
# print(f"Team A - {team_a}; Team B - {team_b}")
# if stop:
# print("Game was terminated")
# # 02 solution
team_a = 11
team_b = 11
cards = input().split()
card_list = set(cards)
stop = False
for i in cards:
x = "".join(i)
if "A" in x:
team_a -= 1
elif "B" in x:
team_b -= 1
if team_a < 7 or team_b < 7:
stop = True
break
print(f"Team A - {team_a}; Team B - {team_b}")
if stop:
print("Game was terminated")
# # INPUT 1
# A-1 A-5 A-10 B-2
# # INPUT 2
# A-1 A-5 A-10 B-2 A-10 A-7 A-3
# # INPUT END
|
K, X = tuple(map(int, input().split()))
start = X - K + 1
end = X + K
print(*range(start, end))
|
# -*- coding: utf-8 -*-
config = {
"consumer_key": "VALUE",
"consumer_secret": "VALUE",
"access_token": "VALUE",
"access_token_secret": "VALUE",
}
|
class Solution:
# @param {integer[]} nums
# @return {integer[][]}
def permuteUnique(self, nums):
if len(nums) == 0:
return nums
if len(nums) == 1:
return [nums]
res = []
bag = set()
for i in range(len(nums)):
if nums[i] not in bag:
tmp = nums[:]
head = tmp.pop(i)
tail = self.permuteUnique(tmp)
[t.insert(0, head) for t in tail]
res.extend(tail)
bag.add(nums[i])
return res
|
def benjHochFDR(pVals,pValColumn=1):
"""
pVals = 2D list(hypothesis,p-value) hypothesis could = geneName tested for enrichment
pValColumn = integer of column index containing the p-value.
returns _ALL_ items passed to it with no filtering at the moment.
"""
assert type(pValColumn) == type(1),\
"ERROR: pValColumn must be int type!"
# Sort pVals from highest to lowest after converting them all to floats.
for i in range(len(pVals)):
pVals[i][pValColumn] = float(pVals[i][pValColumn])
pVals.sort(key=lambda x: x[pValColumn])
pVals.reverse()
n = len(pVals)
lastPval = pVals[0][pValColumn]
for i in range(len(pVals)):
p = pVals[i][pValColumn]
adj = (float(n)/(n-i))
adjP = p*adj
miN = min(adjP,lastPval)
pVals[i].append(miN)
lastPval = pVals[i][-1]
pVals.reverse()
return pVals |
{
"targets": [
{
"target_name": "posix",
"sources": [ "src/posix.cc" ]
}
]
}
|
DATABASE_NAME = "glass_rooms.sqlite"
STARTING_ROOM_NUMBER = 1
ENDING_ROOM_NUMBER = 9
TABLE_NAME_HEADER = "Room_"
TABLE_NAME = "Bookings"
URL_HEADER = "https://www.scss.tcd.ie/cgi-bin/webcal/sgmr/sgmr"
URL_ENDER = ".pl"
URL_BOOKING = ".request"
# Regex Constants
# DATE_HEADER_REGEX: regex to match '4 Nov 2015 (Wednesday):'
# BOOKING_BODY_REGEX: regex to match '13:00-14:00 Sterling Archer [ba3] NATO phonetic alphabet practice'
DATE_HEADER_REGEX = "[0-9]{1,2} [A-Z][a-z]+ 20[0-9]{2,2} \([A-Z][a-z]+\):"
BOOKING_BODY_REGEX = "[0-9][0-9]:00-[0-9][0-9]:00 "
|
class TagsArgument(object):
"""Parse the tags argument"""
def __init__(self):
"""
Initialize the class
"""
super(TagsArgument, self).__init__()
def parse(self, configuration):
"""
Parse tags from the configuration file and return it formatted
:param configuration: dict
:return: dict
"""
return {
'Tags': [{'Key': tag, 'Value': configuration[tag]} for tag in configuration]
}
|
#!/usr/bin/python3
def bubbleSort(arr, reverse=False):
length = len(arr)
for i in range(0, length-1):
for j in range(0, length-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
if reverse:
arr.reverse()
return arr |
# 手机参数
# 无法通过activity启动的app前使用#标记
activities = {
'zhaoshang': 'cmb.pb/.app.mainframe.container.PBMainActivity',
'toutiao': 'com.ss.android.article.lite/.activity.SplashActivity',
'kuaishou': 'com.kuaishou.nebula/com.yxcorp.gifshow.HomeActivity',
'douyin': 'com.ss.android.ugc.aweme.lite/com.ss.android.ugc.aweme.splash.SplashActivity',
'jingdong': '#com.jd.jdlite/.MainFrameActivity',
'fanqie': '#com.dragon.read/.pages.main.MainFragmentActivity',
'fanchang': '#com.xs.fm/com.dragon.read.pages.main.MainFragmentActivity',
'kuchang': '#com.kugou.android.douge/com.kugou.android.app.MediaActivity',
'shuqi': '#com.shuqi.controller/com.shuqi.activity.MainActivity',
'yingke': '#com.ingkee.lite/com.meelive.ingkee.business.main.entry.legacy.MainActivity',
'kugou': '#com.kugou.android.elder/com.kugou.android.app.MediaActivity',
'zhongqing': '#cn.youth.news/.ui.splash.SplashAdActivity',
'kuaiyin': '#com.kuaiyin.player/.v2.ui.main.MainActivity',
'kuge': '#com.kugou.android.child/com.kugou.android.app.MediaActivity',
'momo': '#com.immomo.young/com.immomo.momo.maintab.MaintabActivity',
'qingtuanshe': '#com.qts.customer/com.qts.point.DailyEarnMoneyActivity',
'eleme': '#me.ele/.application.ui.splash.SplashActivity',
'changdou': '#com.zf.shuashua/.MainActivity',
'kuaikandian': '#com.yuncheapp.android.pearl/com.kuaishou.athena.MainActivity',
'qutoutiao': 'com.jifen.qukan/com.jifen.qkbase.main.MainActivity',
'baidu': 'com.baidu.searchbox.lite/com.baidu.searchbox.MainActivity',
'weishi': 'com.tencent.weishi/com.tencent.oscar.module.splash.SplashActivity',
'douhuo': 'com.ss.android.ugc.live/.main.MainActivity',
'chejia': 'com.autohome.speed/com.cubic.autohome.MainActivity',
'uc': 'com.UCMobile/com.uc.browser.InnerUCMobile',
'diantao': 'com.taobao.live/.home.activity.TaoLiveHomeActivity',
'huitoutiao': 'com.cashtoutiao/.account.ui.main.MainTabActivity',
'touda': 'com.ss.android.article.daziban/com.ss.android.article.news.activity.MainActivity',
'shuabao': 'com.jm.video/.ui.main.MainActivity',
# com.taobao.litetao/com.taobao.ltao.maintab.MainFrameActivity
# com.xunmeng.pinduoduo/.ui.activity.HomeActivity
# com.qq.reader/.activity.MainActivity
# com.ximalaya.ting.lite/com.ximalaya.ting.android.host.activity.MainActivity
}
# 所有程序名
apps = []
# 所有程序对应的包名(app:package)
packages = {}
# 手机运行信息(线程号)
contexts = {}
# 高配置手机
high_serials = ['9598552235004UD', 'ce7f96a00307']
# 程序的定时任务为30分钟
SCHEDULE_TIME = 30
|
# https://www.hackerrank.com/challenges/minimum-loss/problem
def minimumLoss(price):
min_loss = list()
price = [(i,j) for i,j in zip(range(len(price)), price)]
price = sorted(price,key=lambda x: x[1])
for i in range(len(price)-1):
if(price[i][0]>price[i+1][0] and price[i][1]<price[i+1][1]):
min_loss.append(price[i+1][1]-price[i][1])
min_loss.sort()
return min_loss[0]
if __name__ == '__main__':
n = int(input())
price = list(map(int, input().rstrip().split()))
print(minimumLoss(price))
|
# recursive function
# O(n) time | O(h) space
def nodedepth(root, depth=0):
if root is None:
return 0
return depth + nodedepth(root.left, depth + 1) + nodedepth(root.right, depth+1)
# iterative function
# O(n) time | O(h) space
def findtheddepth(root):
stack = [{"node": root, "depth": 0}]
sumOfDepth = 0
while len(stack) > 0:
nodeInfo = stack.pop()
node, depth = nodeInfo["node"], nodeInfo["depth"]
if node in None:
continue
sumOfDepth += depth
stack.append({"node": node.left, "depth": depth+1})
stack.append({"node": node.right, "depth": depth+1})
return sumOfDepth
|
#!/usr/bin/env python3
#
# Copyright (C) 2018 ETH Zurich and University of Bologna
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
class Condor_pool(object):
def __init__(self):
machines = [
'fenga1.ee.ethz.ch',
'pisoc1.ee.ethz.ch',
'pisoc3.ee.ethz.ch', 'pisoc4.ee.ethz.ch',
'pisoc5.ee.ethz.ch', 'pisoc6.ee.ethz.ch'
]
#'fenga2.ee.ethz.ch', 'fenga3.ee.ethz.ch', 'larain1.ee.ethz.ch',
# 'larain2.ee.ethz.ch', 'larain3.ee.ethz.ch',
# 'larain4.ee.ethz.ch', 'pisoc2.ee.ethz.ch',
#machines_string = []
#for machine in machines:
# machines_string.append('( TARGET.Machine == \"%s\" )' % (machine))
#self.env = {}
#self.env['CONDOR_REQUIREMENTS'] = ' || '.join(machines_string)
self.env = {}
# TRY this command for the timeout
# condor_run -a "periodic_remove = (RemoteWallClockTime - CumulativeSuspensionTime) > 1"
self.env['CONDOR_REQUIREMENTS'] = '( TARGET.OpSysAndVer == \"CentOS7\" )'
def get_cmd(self, cmd):
return 'condor_run %s' % cmd
def get_env(self):
return self.env
|
class Event:
# TODO: This gonna abstract the concept of row data in traditional ML approach
pass
|
def parse(file_path):
# Method to read the config file.
# Using a custom function for parsing so that we have only one config for
# both the scripts and the mapreduce tasks.
config = {}
with open(file_path) as f:
for line in f:
data = line.strip()
if(data and not data.startswith("#")):
(key, value) = data.split("=")
config[key] = value
return config |
# -*- coding: utf-8 -*-
###############################################################################
#
# Copyright (C) 2021-TODAY Prof-Dev Integrated(<http://www.prof-dev.com>).
###############################################################################
{
'name': 'Prof-Dev School MGMT',
'version': '1.0',
'license': 'LGPL-3',
'category': 'Education',
"sequence": 1,
'summary': 'Manage Students, School stages,levels, classes and fees',
'complexity': "easy",
'author': 'Prof-Dev Integrated Solutions',
'website': 'http://www.prof-dev.com',
'depends': [ 'hr'],
'data': [
'views/students.xml',
'views/parent.xml',
'views/class.xml',
'views/level.xml',
'views/stage.xml',
'views/study_year.xml',
'views/enrollment.xml',
'security/ir.model.access.csv'
]
} |
class Solution:
def xorOperation(self, n: int, start: int) -> int:
nums = [start + 2 * i for i in range(n)];
ret = 0;
for val in nums:
ret ^= val
return ret
|
text = ''
with open('/home/reagan/code/proj/familienanlichkeiten/data/DeReKo-2014-II-MainArchive-STT.100000.freq', 'r+') as f:
text = f.read()
def process_line(line: str):
parts = line.split('\t')
return (parts[1], parts[2])
known = set()
lemmas = []
for line in text.splitlines():
lemma = process_line(line)
if lemma[0]+lemma[1] not in known:
lemmas.append(lemma)
known.add(lemma[0]+lemma[1])
print(known)
|
EXCHANGE_COSMOS_BLOCKCHAIN = "cosmos_blockchain"
CUR_ATOM = "ATOM"
MILLION = 1000000.0
CURRENCIES = {
"ibc/14F9BC3E44B8A9C1BE1FB08980FAB87034C9905EF17CF2F5008FC085218811CC": "OSMO"
}
|
'''
Given an n-ary tree, return the level order traversal of its nodes' values.
Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).
Example:
1
/ | \
3 2 4
/ \
5 6
Input: root = [1,null,3,2,4,null,5,6]
Output: [[1],[3,2,4],[5,6]]
Approach:
1. Consider an 'ans' array (to store final answer) and a 'level' array to store all the nodes at one level.
2. Run an iterative approach where we keep adding the values of all nodes at that level to answer array and children of each node is added to another array 'temp'.
3. The new 'level' array for next iteration is the 'temp' array.
'''
class Node(object):
def __init__(self, val=None, children=None):
self.val = val
self.children = children
class Solution(object):
def levelOrder(self, root):
"""
:type root: Node
:rtype: List[List[int]]
"""
if not root:
return []
ans = []
level = [root]
while(level):
ans.append([node.val for node in level])
temp = []
for node in level:
for child in node.children:
if child:
temp.append(child)
level = temp
return ans
|
def secant(f, x_a, x_b, e=10**(-12)):
while True:
x = x_b - f(x_b) * ((x_b - x_a) / (f(x_b) - f(x_a)))
t_e = abs(x - x_b)
if t_e < e:
return x
x_a = x_b
x_b = x
if __name__ == "__main__":
f = lambda x: x**2 - 10
x_a = 3
x_b = 4
print('Secante Propio:', secant(f, x_a, x_b))
print('Raíz Exacta:', 10**(1/2))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.