content
stringlengths 7
1.05M
|
|---|
"""
@no 169
@name Majority Element
"""
class Solution:
def majorityElement(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
count = {}
for num in nums:
if count.get(str(num)):
count[str(num)] += 1
else:
count[str(num)] = 1
if count[str(num)] > len(nums) // 2:
return num
return None
|
#Linear Search
class LinearSerach:
def __init__(self):
self.elements = [10,52,14,8,1,400,900,200,2,0]
def SearchEm(self,elem):
y = 0
if elem in self.elements:
print("{x} is in the position of {y}".format(x = elem,y = self.elements.index(elem)))
else:
print("The element {x} not presented in the list".format(x = elem))
linear = LinearSerach()
task_elem = int(input("Enter the element:"))
linear.SearchEm(task_elem)
|
for t in range(int(input())):
L=list(map(int,input().split()))
sum=0
for i in L:
if i<40:
sum+=40
else :
sum+=i
print(f"#{t+1} {sum//5}")
|
"""
For strings, return its length.
For None return string 'no value'
For booleans return the boolean
For integers return a string showing how it compares to hundred e.g.
For 67 return 'less than 100' for 4034 return 'more than 100' or
equal to 100 as the case may be
For lists return the 3rd item, or None if it doesn't exist
"""
def data_type(datatype):
if datatype is None:
return 'no value'
elif isinstance(datatype, str):
return len(datatype)
elif isinstance(datatype, bool):
return datatype
elif isinstance(datatype, int):
if datatype < 100:
return 'less than 100'
return 'more than 100'
elif isinstance(datatype, list):
if len(datatype) > 2:
return datatype[2]
else:
return None
|
class AgeBean:
def __init__(self, judgement_id=0,
age=''):
self._judgement_id = judgement_id
self._age = age
@property
def judgement_id(self):
return int(self.judgement_id)
@judgement_id.setter
def judgement_id(self, id):
self._judgement_id = id
@property
def age(self):
return str(self._age)
@age.setter
def age(self, age):
self._age = age |
def reverse(head):
cur = head
pre = None
while cur:
nxt = cur.next
cur.next = pre
cur.pre = nxt
pre = cur
cur = nxt
return pre |
names = ['Anddy', 'Christian', 'Lucero', 'Yamile', 'Evelyn']
print(names)
print(names[0])
print(names[0:2])
#
numbers = [6, 2, 3, 45, 23, 3, 4, 55, 3, 2, 4456, 7, 98, 6, 64, 4, 321, 4, 323, 6, 68, 2, 2, 12, 4, 5]
largeNumber = numbers[0]
for number in numbers:
if number > largeNumber:
largeNumber = number
print('The largest number is: ' + str(largeNumber))
numbers.append(1000)
print(numbers)
number2 = [0, 0, 0, 0, ]
number3 = numbers.__add__(number2) # this method is immutable
print(number3)
numbersNoRepeted=[]
for item in numbers:
if not numbersNoRepeted.__contains__(item):
#if item in numbersNoRepeted
numbersNoRepeted.append(item)
print(numbersNoRepeted)
datos = ["gato", 2]
print(datos)
# datos.append(3,2,2) doesn't work
datos.append([2,2,2,2,2]) # this add an array as element of the existing array,
print(datos)
datos.extend([2,3,4,5,6,]) # this join arrays
print(datos)
|
class placeholder_optimizer(object):
done=False
self_managing=False
def __init__(self,max_iter):
self.max_iter=max_iter
def update(self):
pass |
#
# Copyright (c) 2017-2018 Joy Diamond. All rights reserved.
#
@gem('Sapphire.LineMarker')
def gem():
def construct_token__line_marker__many(t, s, newlines):
assert (t.ends_in_newline is t.line_marker is true) and (newlines > 1)
t.s = s
t.newlines = newlines
class LineMarker(PearlToken):
class_order = CLASS_ORDER__LINE_MARKER
display_name = 'line-marker'
ends_in_newline = true
is_end_of_arithmetic_expression = true
is_end_of_boolean_and_expression = true
is_end_of_boolean_or_expression = true
is_end_of_compare_expression = true
is_end_of_comprehension_expression_list = true
is_end_of_comprehension_expression = true
is_end_of_logical_and_expression = true
is_end_of_logical_or_expression = true
is_end_of_multiply_expression = true
is_end_of_normal_expression_list = true
is_end_of_normal_expression = true
is_end_of_ternary_expression_list = true
is_end_of_ternary_expression = true
is_end_of_unary_expression = true
is_line_marker = true
line_marker = true
newlines = 1
def __init__(t, s):
assert (t.ends_in_newline is t.line_marker is true) and (t.newlines is 1)
assert (s.count('\n') == 1) and (s[-1] == '\n')
t.s = s
def count_newlines(t):
assert (t.ends_in_newline is t.line_marker is true) and (t.newlines is 1)
assert (t.s.count('\n') == 1) and (t.s[-1] == '\n')
return 1
def display_token(t):
return arrange('<line-marker %s>', portray_string(t.s))
def dump_token(t, f, newline = true):
assert (t.ends_in_newline is t.line_marker is true) and (t.newlines is 1)
assert (t.s.count('\n') == 1) and (t.s[-1] == '\n')
f.partial('{%s}', portray_string(t.s)[1:-1])
if newline:
f.line()
return false
return true
order = order__s
@share
def conjure_line_marker(s):
r = lookup_line_marker(s)
if r is not none:
return r
s = intern_string(s)
return provide_line_marker(s, LineMarker(s))
@share
def produce_conjure_action_word__line_marker(name, Meta):
@rename('conjure_%s__line_marker', name)
def conjure_action_word__line_marker(s):
assert s[-1] == '\n'
r = lookup_line_marker(s)
if r is not none:
return r
s = intern_string(s)
newlines = s.count('\n')
return provide_line_marker(
s,
(
Meta(s)
if newlines is 1 else
conjure_ActionWord_LineMarker_Many(
Meta, construct_token__line_marker__many,
)(s, s.count('\n'))
),
)
return conjure_action_word__line_marker
LINE_MARKER = conjure_line_marker('\n')
LineMarker.mutate = produce_mutate__uncommented ('line_marker', LINE_MARKER)
LineMarker.transform = produce_transform__uncommented('line_marker', LINE_MARKER)
share(
'LINE_MARKER', LINE_MARKER,
)
|
casos = int(input())
dentro = 0
fora = 0
for i in range(casos):
num = int(input())
if num >= 10 and num <= 20:
dentro += 1
else:
fora += 1
print('{} in\n{} out'.format(dentro, fora))
|
#Desafio 8
#Programa Conversor de Unidades
# (Dá para aprimorar mais tarde)
medida = float(input("Digite aqui uma medida em metros para obtê-la em centímetros e milímetros: "))
print(f"Sobre a medida {medida} metros, ela possui:\n {medida*100} centímetros,\n {medida*1000} milímetros ")
|
#https://www.hackerrank.com/challenges/quicksort2
'''
def quickSort(ar):
if len(ar) <2 : # 0 or 1
return(ar)
else:
p = ar[0]
less = []
more = []
for item in ar[1:]:
if item < p:
less.append(item)
else:
more.append(item)
l = quickSort(less)
m = quickSort(more)
subarray = l + [p] + m
print(' '.join([str(x) for x in subarray]))
return subarray
m = int(input())
ar = [int(i) for i in input().strip().split()]
quickSort(ar)
'''
def partition(a, first, last):
if len(a)<2:
return first
pivot = a[first]
wall = last+1
for j in range(last, first,-1):
if a[j] > pivot:
wall -= 1
if j!=wall: a[j],a[wall] = a[wall], a[j]
a[wall-1],a[first] = a[first], a[wall-1]
return wall-1
def quickSort(a, first, last):
if first < last:
q = partition(a, first, last)
quickSort(a, first, q-1)
if len(a[first:q]) > 1: print(" ".join(map(str, a[first:q])))
quickSort(a, q+1, last)
if len(a[q+1:last+1]) > 1: print(" ".join(map(str, a[q+1:last+1])))
a = [int(x) for x in input().strip().split(' ')]
quickSort(a,0,len(a)-1)
print(a)
|
class User:
def __init__(self,username,password):
self.is_authenticated = False
self.username = username
self.password = password
|
def add(x):
def do_add(y):
return x + y
return do_add
add_to_five = add(5)
# print(add_to_five(7))
# print(add(5)(3))
def Person(name, age):
def print_hello():
print('Hello! My name is {}'.format(name))
def get_age():
return age
return {'print_hello': print_hello, 'get_age': get_age}
john = Person('John', 32)
john['print_hello']()
print(john['get_age']()) |
class Solution:
def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
nums.sort()
n=len(nums)
if n==0:
return []
dp=[[i,1] for i in range(n)]
last=0
maxm=0
for i in range(1,n):
for j in range(i-1,-1,-1):
if nums[i]%nums[j]==0 and dp[j][1]>=dp[i][1]:
dp[i][1]=dp[j][1]+1
dp[i][0]=j
if maxm<dp[i][1]:
maxm=dp[i][1]
last=i
res=[]
while dp[last][0]!=last:
res.append(nums[last])
last=dp[last][0]
res.append(nums[last])
res.reverse()
return res
|
class Book:
def __init__(self, title, author, price):
self.title = title
self.author = author
self.price = price
def __str__(self):
return f'{self.title} {self.author} {self.price}'
def __call__(self, title, author, price):
self.title = title
self.author = author
self.price = price
book = Book('War and Peace', 'Lev Tolstoi', 23.24)
print(book)
book('The Catcher', 'JD Salinger', 12.32)
print(book)
book(title='JSD', author='JDS', price=232.2)
print(book) |
class Solution:
@staticmethod
def naive(nums):
return nums+nums
|
ISCOUNTRY = 'isCountry'
def filter_country_locations(api_response, is_country=True):
"""
Filter the response to only include the elements that are countries.
This uses the 'api_response' object as input. Plain `list`s are also
valid, but they must contain the location elements, not the `items` wrapper.
"""
return [item for item in api_response if item[ISCOUNTRY]==is_country]
__all__= ['filter_country_locations'] |
"""
-------------------------------------------------------
config
flask config file
-------------------------------------------------------
Author: Dallas
ID: 110242560
Email: [email protected]
Version: 2014-09-18
-------------------------------------------------------
"""
DEBUG = True
|
aut = float(input('Digite a autura da parede em Metros: '))
lar = float(input('Digite a largura da parede em Metros: '))
are = aut * lar
print(f'A área da parede é {are}², considerando que cada litro de tinta pinta 2m² vc vai usar {are/2} Litros de tinta') |
"""
时间: 2019/12/31
作者: [email protected]
更改记录:
重要说明:
""" |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
class DFUPrefix:
"""Generates the DFU prefix block"""
DFU_PREFIX_LENGTH = 11
DFU_PREFIX_SIZE_POS = 6
DFU_PREFIX_IMG_COUNT_POS = 10
def __init__(self, imageSize = 0, targetCount = 0):
# It looks like the DFU image size includes the DFU Prefix block but excludes the DFU Suffix block
if imageSize != 0:
imageSize += self.DFU_PREFIX_LENGTH
self.data = [
ord("D"), # Bytes 0-4 are the file signature
ord('f'),
ord('u'),
ord('S'),
ord('e'),
0x01, # Version number (currently always 1)
(imageSize >> 0x00) & 0xFF,
(imageSize >> 0x08) & 0xFF,
(imageSize >> 0x10) & 0xFF,
(imageSize >> 0x18) & 0xFF,
targetCount
]
|
'''
Created on 25 Mar 2020
@author: bogdan
'''
class s1010hy_wiki2text(object):
'''
parsing wikipedia xml, extracting textual input
'''
def __init__(self):
'''
Constructor
'''
|
def pickform(num: int, wordforms: list):
"""
NOTE: Аргумент wordforms должен выглядеть так: ['(1) ключ', '(2) ключа', '(5) ключей']
-> Возвращает нужную форму слова для данного числа, например "1 велосипед" или "2 велосипеда"
"""
# Числа-исключения от 11 до 14
if 10 < num < 15: return wordforms[2]
num = num % 10 # Далее важна только последняя цифра
if num == 1: return wordforms[0]
if 1 < num < 5: return wordforms[1]
return wordforms[2]
def visdelta(delta):
"""
NOTE: Аргумент delta может быть как секундами, так и объектом <datetime.timedelta>
-> Возвращает читаемый промежуток времени на русском языке, например "3 минуты 30 секунд"
"""
# Если delta это просто число, то оно считывается как секунды
if not isinstance(delta, int): delta = int(delta.total_seconds())
# Вычисляем и записываем каждую единицу времени
nt = {}
nt['s'] = delta % 60; delta //= 60 # Секунды
nt['m'] = delta % 60; delta //= 60 # Минуты
nt['h'] = delta % 24; delta //= 24 # Часы
nt['d'] = delta % 7; delta //= 7 # Дни
nt['w'] = delta # Недели
# Далее идут все возможные формы слов в связке с числом (1 банан, 2 банана, 5 бананов)
wforms = {
's': ['секунда', 'секунды', 'секунд'],
'm': ['минута', 'минуты', 'минут'],
'h': ['час', 'часа', 'часов'],
'd': ['день', 'дня', 'дней'],
'w': ['неделя', 'недели', 'недель']
}
# Формируем читаемые сочетания для каждой единицы времени
l = [f'{n} {pickform(n, wforms[k])}' for k, n in nt.items() if n > 0]
l.reverse() # Чтобы время писалось начиная с недель и заканчивая секундами
# Склеиваем словосочетания
return '0.1 секунды' if len(l) == 0 else ' '.join(l) |
"""
GCD
"""
# Find the greatest common denominator (GCD) of two number input by a user. Then print out 'The GCD of <first number> and <second number> is <your result>.'
print('Enter two numbers to find their greatest common denominator.')
user_input1 = input('First number: ')
user_input2 = input('Second number: ')
a = int(user_input1)
b = int(user_input2)
print(f'The GCD of {a} and {b} is: ')
while b != 0:
a, b = b, a % b
print(a)
|
#
# PySNMP MIB module CISCO-HSRP-EXT-CAPABILITY (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/CISCO-HSRP-EXT-CAPABILITY
# Produced by pysmi-0.3.4 at Mon Apr 29 17:42:35 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)
#
OctetString, ObjectIdentifier, Integer = mibBuilder.importSymbols("ASN1", "OctetString", "ObjectIdentifier", "Integer")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ConstraintsUnion, ConstraintsIntersection, ValueRangeConstraint, SingleValueConstraint, ValueSizeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "ConstraintsUnion", "ConstraintsIntersection", "ValueRangeConstraint", "SingleValueConstraint", "ValueSizeConstraint")
ciscoAgentCapability, = mibBuilder.importSymbols("CISCO-SMI", "ciscoAgentCapability")
ModuleCompliance, AgentCapabilities, NotificationGroup = mibBuilder.importSymbols("SNMPv2-CONF", "ModuleCompliance", "AgentCapabilities", "NotificationGroup")
Gauge32, Counter32, MibScalar, MibTable, MibTableRow, MibTableColumn, Unsigned32, MibIdentifier, ObjectIdentity, TimeTicks, Counter64, NotificationType, Integer32, ModuleIdentity, IpAddress, iso, Bits = mibBuilder.importSymbols("SNMPv2-SMI", "Gauge32", "Counter32", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "Unsigned32", "MibIdentifier", "ObjectIdentity", "TimeTicks", "Counter64", "NotificationType", "Integer32", "ModuleIdentity", "IpAddress", "iso", "Bits")
TextualConvention, DisplayString = mibBuilder.importSymbols("SNMPv2-TC", "TextualConvention", "DisplayString")
ciscoHsrpExtCapability = ModuleIdentity((1, 3, 6, 1, 4, 1, 9, 7, 10001))
ciscoHsrpExtCapability.setRevisions(('2007-11-27 00:00', '1998-08-25 00:00',))
if mibBuilder.loadTexts: ciscoHsrpExtCapability.setLastUpdated('200711270000Z')
if mibBuilder.loadTexts: ciscoHsrpExtCapability.setOrganization('Cisco Systems, Inc.')
ciscoHsrpExtCapabilityV1R0 = AgentCapabilities((1, 3, 6, 1, 4, 1, 9, 7, 10001, 1))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
ciscoHsrpExtCapabilityV1R0 = ciscoHsrpExtCapabilityV1R0.setProductRelease('Cisco IOS/ENA 1.0')
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
ciscoHsrpExtCapabilityV1R0 = ciscoHsrpExtCapabilityV1R0.setStatus('current')
ciscoHsrpExtCapabilityV3R6CRS1 = AgentCapabilities((1, 3, 6, 1, 4, 1, 9, 7, 10001, 2))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
ciscoHsrpExtCapabilityV3R6CRS1 = ciscoHsrpExtCapabilityV3R6CRS1.setProductRelease('Cisco IOS XR 3.6 on CRS-1')
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
ciscoHsrpExtCapabilityV3R6CRS1 = ciscoHsrpExtCapabilityV3R6CRS1.setStatus('current')
mibBuilder.exportSymbols("CISCO-HSRP-EXT-CAPABILITY", ciscoHsrpExtCapabilityV3R6CRS1=ciscoHsrpExtCapabilityV3R6CRS1, PYSNMP_MODULE_ID=ciscoHsrpExtCapability, ciscoHsrpExtCapability=ciscoHsrpExtCapability, ciscoHsrpExtCapabilityV1R0=ciscoHsrpExtCapabilityV1R0)
|
"""Compute the square root of a number."""
def sqrt(x):
y = (1 + x)/2
tolerance = 1.0e-10
for i in range(10):
error = abs(y*y - x)
print(i, y, y*y, error)
if error <= tolerance:
break
# improve the accuracy of y
y = (y + x/y)/2
return y
|
# Definition for a binary tree node.
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def findTarget(self, root, k):
"""
:type root: TreeNode
:type k: int
:rtype: bool
"""
result = self.helper_find_target(root, k)
print(result)
return True if result[1] else False
def helper_find_target(self, node, k, compliments=None, pairs=None):
"""
Helper function to traverse the tree and find the pairs
"""
if compliments is None and pairs is None:
# to store the compliments
compliments = set()
# to store all the pairs
pairs = []
if node is None:
return False, pairs
# check if node.val is in compliments set
if node.val in compliments:
pairs.append((node.val, k-node.val))
return True, pairs
# otherwise we add the val into the compliments
compliments.add(k-node.val)
left = self.helper_find_target(node.left, k, compliments, pairs)
right = self.helper_find_target(node.right, k, compliments, pairs)
return left or right
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(6)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(5)
root.right.right = TreeNode(18)
tree = Solution()
result = tree.findTarget(root, 19)
print(result)
|
master_doc = 'index'
project = u'Infrastructure-Components'
copyright = '2019, Frank Zickert'
htmlhelp_basename = 'Infrastructure-Components-Doc'
language = 'en'
gettext_compact = False
html_theme = 'sphinx_rtd_theme'
#html_logo = 'img/logo.svg'
html_theme_options = {
'logo_only': True,
'display_version': False,
}
# sphinx-notfound-page
# https://github.com/rtfd/sphinx-notfound-page
notfound_context = {
'title': 'Page Not Found',
'body': '''
<h1>Page Not Found</h1>
<p>Sorry, we couldn't find that page.</p>
<p>Try using the search box or go to the homepage.</p>
''',
} |
a, b = input().split()
a = int(a[::-1])
b = int(b[::-1])
print(a if a > b else b)
|
ENDCODER_BANK_CONTROL1 = ['ModDevice_knob0', 'ModDevice_knob1', 'ModDevice_knob2', 'ModDevice_knob3']
ENDCODER_BANK_CONTROL2 = ['ModDevice_knob4', 'ModDevice_knob5', 'ModDevice_knob6', 'ModDevice_knob7']
ENDCODER_BANKS = {'NoDevice':[ENDCODER_BANK_CONTROL1 + ['CustomParameter_'+str(index+(bank*24)) for index in range(8)] for bank in range(4)] + [ENDCODER_BANK_CONTROL2 + ['CustomParameter_'+str(index+(bank*24)) for index in range(8)] for bank in range(4)]}
MOD_BANK_DICT = {'EndCoders':['']}
MOD_TYPES = {'EndCoders':ENDCODER_BANKS}
MOD_CNTRL_OFFSETS = {}
|
# Time: O(nlogk)
# Space: O(k)
# You have k lists of sorted integers in ascending order.
# Find the smallest range that includes at least one number from each of the k lists.
#
# We define the range [a,b] is smaller than range [c,d] if b-a < d-c or a < c if b-a == d-c.
#
# Example 1:
# Input:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
# Output: [20,24]
# Explanation:
# List 1: [4, 10, 15, 24,26], 24 is in range [20,24].
# List 2: [0, 9, 12, 20], 20 is in range [20,24].
# List 3: [5, 18, 22, 30], 22 is in range [20,24].
# Note:
# The given list may contain duplicates, so ascending order means >= here.
# 1 <= k <= 3500
# -10^5 <= value of elements <= 10^5.
# For Java users, please note that the input type has been changed to List<List<Integer>>.
# And after you reset the code template, you'll see this point.
class Solution(object):
def smallestRange(self, nums):
"""
:type nums: List[List[int]]
:rtype: List[int]
"""
left, right = float("inf"), float("-inf")
min_heap = []
for row in nums:
left = min(left, row[0])
right = max(right, row[0])
it = iter(row)
heapq.heappush(min_heap, (next(it, None), it))
result = (left, right)
while min_heap:
(val, it) = heapq.heappop(min_heap)
val = next(it, None)
if val is None:
break
heapq.heappush(min_heap, (val, it))
left, right = min_heap[0][0], max(right, val);
if right - left < result[1] - result[0]:
result = (left, right)
return result
|
"""
This script is used for course notes.
Author: Erick Marin
Date: 10/05/2020
"""
# Arithemtic Operators
print(4 + 5) # Addition
print(9 * 7) # Multiplication
print(-1 / 4) # Divsion
# Division with repeating or periodic numbers
print(1 / 3)
# Floor division "//" rounds the result down to the nearest whole number
print(1 // 3)
# Exponentation, calculating to the power of 5
print((((1 + 2) * 3) / 4) ** 5)
|
# -*- coding: utf-8 -*-
class LoginError(Exception):
pass
|
''' maze block counts for horizontal and vertical dimensions'''
HN = 25
VN = 25
''' screen width and height '''
WIDTH = 600
HEIGHT = 600
''' configurations to fit the maze size regarding the block counts and its ratio with respect to the screen size '''
HSIZE = int(WIDTH*2./3.)
VSIZE = int(HEIGHT*2./3.)
HOFFSET = int((WIDTH-HSIZE)/2)
VOFFSET = int((HEIGHT-VSIZE)/2)
HSTEPSIZE = int(HSIZE/HN)
VSTEPSIZE = int(VSIZE/VN)
''' maze wall width '''
LINEWIDTH = 1
''' frames per second setting for pygame rendering '''
FPS = 60
''' color settings '''
WHITE = (255,255,255)
GRAY = (0,200,200)
BLACK = (0, 0, 0)
RED = (255,0,0)
YELLOW = (255,255,0)
GREEN = (0,180,0)
BLUE = (0,0,180)
PURPLE = (200,0,200)
''' dict used for searching neighbors or available paths by all directions '''
DIRS = {'down':(0,1), 'up':(0,-1), 'right':(1,0), 'left':(-1,0), 'ul':(-1,-1), 'ur':(1,-1), 'll':(-1,1), 'lr':(1,1)}
#DIRS = {'down':(0,1), 'up':(0,-1), 'right':(1,0), 'left':(-1,0)}
DIAG = ['ul', 'ur', 'll', 'lr']
''' output directory for generating mazes '''
OUTPUT_DIR = './mazes' |
# -*- coding: utf-8 -*-
"""Top-level package for Needlestack."""
__author__ = """Cung Tran"""
__email__ = "[email protected]"
__version__ = "0.1.0"
|
# md5 : 506fc4d9b83c53f867e483f9235de8f3
# sha1 : 0e90c892528abee5127e047b6ca037991267b9e0
# sha256 : 04deb949dd7601ee92a1868b2591c2829ff8d80e42511691bad64fd01374d7fe
ord_names = {
733: b'mF_ld_load_ldnames',
734: b'mFt_os_mm_set_cushion',
735: b'mFt_os_resource_delete_ru_entry',
795: b'mFt_os_thread_id_valid',
796: b'ASCII2HEX',
797: b'ASCII2OCTAL',
798: b'CBL_ABORT_RUN_UNIT',
799: b'CBL_ALLOC_DYN_MEM',
800: b'CBL_ALLOC_MEM',
801: b'CBL_ALLOC_SHMEM',
802: b'CBL_ALLOC_THREAD_MEM',
803: b'CBL_AND',
804: b'CBL_ARG_GET_INFO',
805: b'CBL_ASC_2_EBC',
806: b'CBL_AUDIT_CONFIG_PROPERTY_GET',
807: b'CBL_AUDIT_CONFIG_PROPERTY_SET',
808: b'CBL_AUDIT_EMITTER_PROPERTY_GET',
809: b'CBL_AUDIT_EMITTER_PROPERTY_SET',
810: b'CBL_AUDIT_EVENT',
811: b'CBL_AUDIT_FILE_CLOSE',
812: b'mF_rt_switches_addr',
837: b'CBL_AUDIT_FILE_OPEN',
838: b'CBL_AUDIT_FILE_READ',
839: b'CBL_AUDIT_HANDLE_GET',
840: b'CBL_CALL',
841: b'CBL_CANCEL',
842: b'CBL_CANCEL_PROC',
843: b'CBL_CES_GET_ERROR_MSG',
844: b'CBL_CES_GET_ERROR_MSG_LEN',
845: b'CBL_CES_GET_FEATURE_AVAILABILITY',
846: b'CBL_CES_GET_LICENSE',
847: b'CBL_CES_GET_LICENSE_SERIAL_NUMBER',
848: b'CBL_CES_GET_UPDATE_ALL_INTERVAL',
849: b'CBL_CES_RELEASE_LICENSE',
850: b'CBL_CES_SET_AUTOHANDLE_ERRORS',
851: b'CBL_CES_SET_AUTOHANDLE_TRIAL_WARNING',
852: b'CBL_CES_SET_CALLBACK',
853: b'CBL_CES_TRIAL_DAYS_LEFT',
854: b'CBL_CES_UPDATE_ALL',
855: b'CBL_CHANGE_DIR',
856: b'CBL_CHECK_FILE_EXIST',
857: b'CBL_CLASSIFY_DBCS_CHAR',
858: b'CBL_CLEAR_SCR',
859: b'CBL_CLOSE_FILE',
860: b'CBL_CLOSE_VFILE',
861: b'CBL_CMPNLS',
862: b'CBL_CMPTYP',
863: b'CBL_COPY_FILE',
864: b'CBL_COPY_VFILE',
865: b'CBL_CREATE_DIR',
866: b'CBL_CREATE_FILE',
867: b'CBL_CTF_COMP_PROPERTY_GET',
868: b'CBL_CTF_COMP_PROPERTY_SET',
869: b'CBL_CTF_DEST',
870: b'CBL_CTF_EMITTER',
871: b'CBL_CTF_EMITTER_PROPERTY_GET',
872: b'CBL_CTF_EMITTER_PROPERTY_SET',
873: b'CBL_CTF_LEVEL',
874: b'CBL_CTF_TRACE',
875: b'CBL_CTF_TRACER_GET',
876: b'CBL_CTF_TRACER_LEVEL_GET',
877: b'CBL_CTF_TRACER_NOTIFY',
878: b'CBL_CULL_RUN_UNITS',
879: b'CBL_DATA_CONTEXT_ATTACH',
880: b'CBL_DATA_CONTEXT_CREATE',
886: b'CBL_DATA_CONTEXT_DESTROY',
887: b'CBL_DATA_CONTEXT_DETACH',
891: b'CBL_DATA_CONTEXT_GET',
892: b'CBL_DATA_CONTEXT_SET',
893: b'CBL_DATETIME',
894: b'CBL_DBCS_ASC_2_EBC',
895: b'CBL_DBCS_EBC_2_ASC',
896: b'CBL_DBG_INIT',
897: b'CBL_DBG_ISDEBUGGED',
898: b'CBL_DBG_SENDNOTIF',
899: b'CBL_DEBUGBREAK',
900: b'CBL_DEBUG_START',
903: b'CBL_DEBUG_STOP',
904: b'CBL_DELETE_DIR',
905: b'CBL_DELETE_FILE',
906: b'CBL_DIR_SCAN_END',
907: b'CBL_DIR_SCAN_READ',
908: b'CBL_DIR_SCAN_START',
909: b'CBL_EBC_2_ASC',
910: b'CBL_EQ',
914: b'CBL_ERROR_API_REPORT',
915: b'CBL_ERROR_PROC',
916: b'CBL_EVENT_CLEAR',
917: b'CBL_EVENT_CLOSE',
918: b'CBL_EVENT_OPEN_INTRA',
919: b'CBL_EVENT_POST',
920: b'CBL_EVENT_WAIT',
921: b'CBL_EXEC_RUN_UNIT',
922: b'CBL_EXITPRC',
923: b'CBL_EXIT_PROC',
924: b'CBL_FFND_REPORT',
925: b'CBL_FHINIT',
926: b'CBL_FILENAME_CONVERT',
927: b'CBL_FILENAME_MAX_LENGTH',
928: b'CBL_FILE_ERROR',
929: b'CBL_FLUSH_FILE',
930: b'CBL_FN_ABS',
931: b'CBL_FN_ACOS',
932: b'CBL_FN_ANNUITY',
933: b'CBL_FN_ASIN',
952: b'CBL_FN_ATAN',
953: b'CBL_FN_CHAR',
954: b'CBL_FN_CHAR0NATIONAL',
955: b'CBL_FN_CHAR2',
956: b'CBL_FN_COS',
957: b'CBL_FN_CURRENT0DATE',
958: b'CBL_FN_DATE0OF0INTEGER',
959: b'CBL_FN_DATE0TO0YYYYMMDD',
960: b'CBL_FN_DAY0OF0INTEGER',
962: b'CBL_FN_DAY0TO0YYYYDDD',
963: b'CBL_FN_DISPLAY0OF',
964: b'CBL_FN_E',
968: b'mF_ld_load_ldnames_lock',
969: b'mF_ld_load_ldnames_unlock',
974: b'CBL_FN_EXP',
975: b'CBL_FN_EXP10',
976: b'CBL_FN_FACTORIAL',
977: b'CBL_FN_FRACTION0PART',
978: b'CBL_FN_INTEGER',
979: b'CBL_FN_INTEGER0OF0DATE',
980: b'CBL_FN_INTEGER0OF0DAY',
981: b'CBL_FN_INTEGER0PART',
982: b'CBL_FN_LOG',
983: b'CBL_FN_LOG10',
984: b'CBL_FN_LOWER0CASE',
985: b'CBL_FN_MAX',
986: b'CBL_FN_MEAN',
987: b'CBL_FN_MEDIAN',
988: b'CBL_FN_MIDRANGE',
989: b'CBL_FN_MIN',
990: b'CBL_FN_MOD',
991: b'CBL_FN_NATIONAL0OF',
992: b'CBL_FN_NUMVAL',
993: b'CBL_FN_NUMVAL0C',
994: b'CBL_FN_NUMVAL0C_IBM',
995: b'CBL_FN_NUMVAL0F',
996: b'CBL_FN_NUMVAL0G',
997: b'CBL_FN_NUMVAL_IBM',
998: b'CBL_FN_ORD',
999: b'CBL_FN_ORD0MAX',
1000: b'CBL_FN_ORD0MIN',
1001: b'_mF0101',
1002: b'_mF0102',
1003: b'_mF0103',
1004: b'_mF0104',
1005: b'_mF0105',
1006: b'_mF0106',
1007: b'_mF0202',
1008: b'_mF0203',
1009: b'_mF0301',
1010: b'_mF0302',
1011: b'_mF0303',
1012: b'_mF0401',
1013: b'_mF0402',
1014: b'_mF0403',
1015: b'_mF0601',
1016: b'_mF0602',
1017: b'_mF0603',
1018: b'_mF0604',
1019: b'_mF0605',
1020: b'_mF0608',
1021: b'_mF0701',
1022: b'_mF0702',
1023: b'_mF0703',
1024: b'_mF0705',
1025: b'_mF0801',
1026: b'_mF0802',
1027: b'_mF0803',
1028: b'_mF0805',
1029: b'_mF1001',
1030: b'_mF1002',
1031: b'_mF1003',
1032: b'_mF1101',
1033: b'_mF1102',
1034: b'_mF1201',
1035: b'_mF1202',
1036: b'_mF1301',
1037: b'_mF1302',
1038: b'_mF1303',
1039: b'_mF1401',
1040: b'_mF1402',
1041: b'_mF1403',
1042: b'_mF1501',
1043: b'_mF1502',
1044: b'_mF1503',
1045: b'_mF1602',
1046: b'_mF1603',
1047: b'_mF1701',
1048: b'_mF1702',
1049: b'_mF1801',
1050: b'_mF1802',
1051: b'_mF1901',
1052: b'_mF1902',
1053: b'_mF1903',
1054: b'_mF2001',
1055: b'_mF2002',
1056: b'_mF2003',
1057: b'_mF2101',
1058: b'_mF2102',
1059: b'_mF2103',
1060: b'_mF2201',
1061: b'_mF2202',
1062: b'_mF2205',
1063: b'_mF2206',
1064: b'_mF2302',
1065: b'_mF2306',
1066: b'_mF2401',
1067: b'_mF2402',
1068: b'_mF2405',
1069: b'_mF2406',
1070: b'_mF2501',
1071: b'_mF2502',
1072: b'_mF2509',
1073: b'_mF2510',
1074: b'_mF2601',
1075: b'_mF2602',
1076: b'_mF2603',
1077: b'_mF2609',
1078: b'_mF2610',
1079: b'_mF2611',
1080: b'_mF2701',
1081: b'_mF2702',
1082: b'_mF2703',
1083: b'_mF2704',
1084: b'_mF2705',
1085: b'_mF2706',
1086: b'_mF2709',
1087: b'_mF2710',
1088: b'_mF2711',
1089: b'_mF2712',
1090: b'_mF2713',
1091: b'_mF2714',
1092: b'_mF2801',
1093: b'_mF2802',
1094: b'_mF2901',
1095: b'_mF2902',
1096: b'_mF2903',
1097: b'_mF2904',
1098: b'_mF2905',
1099: b'_mF2906',
1100: b'_mF2907',
1101: b'_mF2908',
1102: b'_mF2909',
1103: b'_mF2910',
1104: b'_mF2911',
1105: b'_mF2912',
1106: b'_mF3001',
1107: b'_mF3002',
1108: b'_mF3003',
1109: b'_mF3004',
1110: b'_mF3005',
1111: b'_mF3102',
1112: b'_mF3104',
1113: b'_mF3201',
1114: b'_mF3203',
1115: b'_mF3301',
1116: b'_mF3302',
1117: b'_mF3303',
1118: b'_mF3304',
1119: b'_mF3305',
1120: b'_mF3306',
1121: b'_mF3307',
1122: b'_mF3308',
1123: b'_mF3309',
1124: b'_mF3310',
1125: b'_mF3311',
1126: b'_mF3312',
1127: b'_mF3313',
1128: b'_mF3314',
1129: b'_mF3315',
1130: b'_mF3316',
1131: b'_mF3317',
1132: b'_mF3318',
1133: b'_mF3319',
1134: b'_mF3320',
1135: b'_mF3321',
1136: b'_mF3322',
1137: b'_mF3323',
1138: b'_mF3324',
1139: b'_mF3325',
1140: b'_mF3326',
1141: b'_mF3327',
1142: b'_mF3328',
1143: b'_mF3329',
1144: b'_mF3330',
1145: b'_mF3331',
1146: b'_mF3332',
1147: b'_mF3333',
1148: b'_mF3334',
1149: b'_mF3335',
1150: b'_mF3336',
1151: b'_mF3337',
1152: b'_mF3338',
1153: b'_mF3339',
1154: b'_mF3340',
1155: b'_mF3341',
1156: b'_mF3342',
1157: b'_mF3343',
1158: b'_mF3347',
1159: b'_mF3348',
1160: b'_mF3349',
1161: b'_mF3350',
1162: b'_mF3351',
1163: b'_mF3352',
1164: b'_mF3353',
1165: b'_mF3354',
1166: b'_mF3355',
1167: b'_mF3356',
1168: b'_mF3358',
1169: b'_mF3359',
1170: b'_mF3403',
1171: b'_mF3404',
1172: b'_mF3407',
1173: b'_mF3408',
1174: b'_mF3413',
1175: b'_mF3414',
1176: b'_mF3417',
1177: b'_mF3418',
1178: b'_mF3423',
1179: b'_mF3424',
1180: b'_mF3427',
1181: b'_mF3428',
1182: b'_mF3433',
1183: b'_mF3434',
1184: b'_mF3437',
1185: b'_mF3438',
1186: b'_mF3501',
1187: b'_mF3502',
1188: b'_mF3503',
1189: b'_mF3504',
1190: b'_mF3511',
1191: b'_mF3512',
1192: b'_mF3513',
1193: b'_mF3514',
1194: b'_mF3521',
1195: b'_mF3522',
1196: b'_mF3523',
1197: b'_mF3524',
1198: b'_mF3531',
1199: b'_mF3532',
1200: b'_mF3533',
1201: b'_mF3534',
1202: b'_mF3535',
1203: b'_mF3536',
1204: b'_mF3537',
1205: b'_mF3538',
1206: b'_mF3601',
1207: b'_mF3602',
1208: b'_mF3603',
1209: b'_mF3604',
1210: b'_mF3611',
1211: b'_mF3612',
1212: b'_mF3613',
1213: b'_mF3614',
1214: b'_mF3621',
1215: b'_mF3622',
1216: b'_mF3623',
1217: b'_mF3624',
1218: b'_mF3631',
1219: b'_mF3632',
1220: b'_mF3633',
1221: b'_mF3634',
1222: b'_mF3701',
1223: b'_mF3702',
1224: b'_mF3705',
1225: b'_mF3706',
1226: b'_mF3711',
1227: b'_mF3712',
1228: b'_mF3715',
1229: b'_mF3716',
1230: b'_mF3721',
1231: b'_mF3722',
1232: b'_mF3725',
1233: b'_mF3726',
1234: b'_mF3731',
1235: b'_mF3732',
1236: b'_mF3733',
1237: b'_mF3734',
1238: b'_mF3735',
1239: b'_mF3736',
1240: b'_mF3801',
1241: b'_mF3802',
1242: b'_mF3803',
1243: b'_mF3804',
1244: b'_mF3811',
1245: b'_mF3812',
1246: b'_mF3813',
1247: b'_mF3814',
1248: b'_mF3831',
1249: b'_mF3832',
1250: b'_mF3833',
1251: b'_mF3834',
1252: b'_mF3835',
1253: b'_mF3836',
1254: b'_mF3837',
1255: b'_mF3838',
1256: b'_mF3901',
1257: b'_mF3902',
1258: b'_mF3903',
1259: b'_mF3905',
1260: b'_mF3910',
1261: b'_mF3911',
1262: b'_mF4001',
1263: b'_mF4002',
1264: b'_mF4101',
1265: b'_mF4102',
1266: b'_mF4103',
1267: b'_mF4104',
1268: b'_mF4201',
1269: b'_mF4202',
1270: b'_mF4301',
1271: b'_mF4302',
1272: b'CBL_FN_PI',
1273: b'_mF4406',
1274: b'_mF4407',
1275: b'_mF4501',
1276: b'_mF4601',
1277: b'_mF4602',
1278: b'_mF4603',
1279: b'_mF4604',
1280: b'_mF4701',
1281: b'CBL_FN_PRESENT0VALUE',
1282: b'_mF4703',
1283: b'_mF4801',
1284: b'_mF4802',
1285: b'_mF4803',
1286: b'_mF4804',
1287: b'_mF4901',
1288: b'_mF4902',
1289: b'_mF4903',
1290: b'_mF4904',
1291: b'_mF5101',
1292: b'_mF5102',
1293: b'_mF5103',
1294: b'_mF5104',
1295: b'_mF5105',
1296: b'_mF5106',
1297: b'_mF5107',
1298: b'_mF5108',
1299: b'_mF5109',
1300: b'_mF5110',
1301: b'_mF5111',
1302: b'_mF5112',
1303: b'_mF5113',
1304: b'_mF5114',
1305: b'_mF5115',
1306: b'_mF5116',
1307: b'_mF5117',
1308: b'_mF5118',
1309: b'_mF5119',
1310: b'_mF5120',
1311: b'_mF5121',
1312: b'_mF5122',
1313: b'_mF5123',
1314: b'_mF5124',
1315: b'_mF5125',
1316: b'_mF5126',
1317: b'_mF5127',
1318: b'_mF5201',
1319: b'_mF5202',
1320: b'_mF5203',
1321: b'_mF5204',
1322: b'_mF5205',
1323: b'_mF5206',
1324: b'_mF5207',
1325: b'_mF5208',
1326: b'_mF5209',
1327: b'_mF5210',
1328: b'_mF5211',
1329: b'_mF5212',
1330: b'_mF5213',
1331: b'_mF5214',
1332: b'_mF5215',
1333: b'_mF5216',
1334: b'_mF5217',
1335: b'_mF5218',
1336: b'_mF5219',
1337: b'_mF5220',
1338: b'_mF5221',
1339: b'_mF5222',
1340: b'_mF5223',
1341: b'_mF5224',
1342: b'_mF5225',
1343: b'_mF5232',
1344: b'_mF5233',
1345: b'_mF5234',
1346: b'_mF5235',
1347: b'_mF5236',
1348: b'_mF5237',
1349: b'_mF5238',
1350: b'_mF5239',
1351: b'_mF5240',
1352: b'_mF5241',
1353: b'_mF5302',
1354: b'_mF5304',
1355: b'_mF5307',
1356: b'_mF5309',
1357: b'_mF5312',
1358: b'_mF5314',
1359: b'_mF5318',
1360: b'_mF5319',
1361: b'_mF5322',
1362: b'_mF5323',
1363: b'_mF5401',
1364: b'_mF5402',
1365: b'_mF5403',
1366: b'_mF5404',
1367: b'_mF5405',
1368: b'_mF5406',
1369: b'_mF5407',
1370: b'_mF5501',
1371: b'_mF5502',
1372: b'_mF5503',
1373: b'_mF5504',
1374: b'_mF5601',
1375: b'_mF5602',
1376: b'_mF5603',
1377: b'_mF5604',
1378: b'_mF5605',
1379: b'_mF5606',
1380: b'_mF5607',
1381: b'_mF5608',
1382: b'_mF5609',
1383: b'_mF5610',
1384: b'_mF5611',
1385: b'_mF5612',
1386: b'_mF5613',
1387: b'_mF5614',
1388: b'_mF5615',
1389: b'_mF5616',
1390: b'_mF5617',
1391: b'_mF5618',
1392: b'_mF5619',
1393: b'_mF5620',
1394: b'_mF5621',
1395: b'_mF5622',
1396: b'_mF5623',
1397: b'_mF5624',
1398: b'_mF5625',
1399: b'_mF5632',
1400: b'_mF5633',
1401: b'_mF5634',
1402: b'_mF5635',
1403: b'_mF5636',
1404: b'_mF5637',
1405: b'_mF5638',
1406: b'_mF5639',
1407: b'_mF5640',
1408: b'_mF5641',
1409: b'_mF5702',
1410: b'_mF5704',
1411: b'_mF5707',
1412: b'_mF5709',
1413: b'_mF5712',
1414: b'_mF5714',
1415: b'_mF5718',
1416: b'_mF5719',
1417: b'_mF5722',
1418: b'_mF5723',
1419: b'_mF5801',
1420: b'_mF5802',
1421: b'_mF5803',
1422: b'_mF5804',
1423: b'_mF5805',
1424: b'_mF5806',
1425: b'_mF5807',
1426: b'_mF5808',
1427: b'_mF5809',
1428: b'_mF5810',
1429: b'_mF5811',
1430: b'_mF5812',
1431: b'_mF5901',
1432: b'_mF5902',
1433: b'_mF5903',
1434: b'_mF5904',
1435: b'CBL_FN_RANDOM',
1436: b'CBL_FN_RANGE',
1437: b'CBL_FN_REM',
1438: b'CBL_FN_REVERSE',
1439: b'CBL_FN_REVERSE_DBCS',
1440: b'CBL_FN_SIGN',
1441: b'CBL_FN_SIN',
1442: b'CBL_FN_SQRT',
1443: b'CBL_FN_STANDARD0DEVIATION',
1444: b'CBL_FN_SUM',
1445: b'_mF6201',
1446: b'_mF6202',
1447: b'_mF6203',
1448: b'_mF6304',
1449: b'_mF6305',
1450: b'_mF6306',
1451: b'_mF6307',
1452: b'_mF6308',
1453: b'_mF6309',
1454: b'_mF6310',
1455: b'_mF6311',
1456: b'_mF6312',
1457: b'_mF6313',
1458: b'_mF6314',
1459: b'_mF6315',
1460: b'_mF6501',
1461: b'_mF6601',
1462: b'_mF6602',
1463: b'_mF6801',
1464: b'_mF6802',
1465: b'_mF6803',
1466: b'_mF6804',
1467: b'_mF6903',
1468: b'_mF6904',
1469: b'_mF6905',
1470: b'_mF6906',
1471: b'_mF7001',
1472: b'_mF7002',
1473: b'_mF7003',
1474: b'_mF7004',
1475: b'_mF7801',
1476: b'_mF7802',
1477: b'_mF7803',
1478: b'_mF7804',
1479: b'_mF7805',
1480: b'_mF7806',
1481: b'_mF7807',
1482: b'_mF7808',
1483: b'_mF7810',
1484: b'_mF7811',
1485: b'_mF7812',
1486: b'_mF7813',
1487: b'_mF7821',
1488: b'_mF7822',
1489: b'_mF7823',
1490: b'_mF7824',
1491: b'_mF7825',
1492: b'_mF7826',
1493: b'_mF7830',
1494: b'_mF7831',
1495: b'_mF7832',
1496: b'_mF7833',
1497: b'_mF7901',
1498: b'_mF7902',
1499: b'_mF7903',
1500: b'_mF7904',
1501: b'_mF7905',
1502: b'_mF7906',
1503: b'_mF7907',
1504: b'_mF7908',
1505: b'_mF7910',
1506: b'_mF7911',
1507: b'_mF7912',
1508: b'_mF7913',
1509: b'_mF7921',
1510: b'_mF7922',
1511: b'_mF7923',
1512: b'_mF7924',
1513: b'_mF7925',
1514: b'_mF7926',
1515: b'CBL_FN_TAN',
1516: b'_mF7928',
1517: b'_mF7930',
1518: b'_mF7931',
1519: b'_mF7932',
1520: b'_mF7933',
1521: b'_mF8001',
1522: b'_mF8002',
1523: b'_mF8003',
1524: b'_mF8004',
1525: b'_mF8005',
1526: b'_mF8006',
1527: b'_mF8007',
1528: b'_mF8008',
1529: b'_mF8010',
1530: b'_mF8011',
1531: b'_mF8012',
1532: b'_mF8013',
1533: b'_mF8101',
1534: b'_mF8102',
1535: b'_mF8103',
1536: b'_mF8104',
1537: b'_mF8105',
1538: b'_mF8106',
1539: b'_mF8107',
1540: b'_mF8108',
1541: b'_mF8110',
1542: b'_mF8111',
1543: b'_mF8112',
1544: b'_mF8113',
1545: b'_mF8301',
1546: b'_mF8302',
1547: b'_mF8303',
1548: b'_mF8304',
1549: b'_mF8401',
1550: b'_mF8402',
1551: b'_mF8403',
1552: b'_mF8404',
1553: b'_mF8405',
1554: b'_mF8406',
1555: b'_mF8501',
1556: b'_mF8502',
1557: b'_mF8503',
1558: b'_mF8601',
1559: b'_mF8602',
1560: b'CBL_FN_TEST0DATE0YYYYMMDD',
1561: b'CBL_FN_TEST0DAY0YYYYDDD',
1562: b'CBL_FN_TEST0NUMVAL',
1563: b'_mFa101',
1564: b'_mFa102',
1565: b'_mFa103',
1566: b'_mFa104',
1567: b'_mFa105',
1568: b'_mFa106',
1569: b'_mFa107',
1570: b'_mFa108',
1571: b'_mFa201',
1572: b'_mFa202',
1573: b'_mFa301',
1574: b'_mFa302',
1575: b'_mFa303',
1576: b'_mFa304',
1577: b'_mFa305',
1578: b'_mFa401',
1579: b'_mFa402',
1580: b'_mFa403',
1581: b'_mFa404',
1582: b'_mFa405',
1583: b'_mFa501',
1584: b'_mFa502',
1585: b'_mFa601',
1586: b'_mFa602',
1587: b'_mFa603',
1588: b'_mFa604',
1589: b'_mFa605',
1590: b'_mFa606',
1591: b'_mFa701',
1592: b'_mFa702',
1593: b'_mFa801',
1594: b'_mFa802',
1595: b'_mFa803',
1596: b'_mFa804',
1597: b'_mFa901',
1598: b'_mFa902',
1599: b'_mFb001',
1600: b'_mFb002',
1601: b'_mFb101',
1602: b'_mFb102',
1603: b'_mF4503',
1604: b'_mF4505',
1605: b'_mF5408',
1606: b'_mF5409',
1607: b'_mF5410',
1608: b'_mF5411',
1609: b'_mF5412',
1610: b'CBL_FN_TEST0NUMVAL0C',
1611: b'_mF8416',
1612: b'_mF8417',
1613: b'CBL_FN_TEST0NUMVAL0F',
1614: b'CBL_FN_TEST0NUMVAL0G',
1615: b'CBL_FN_UPPER0CASE',
1616: b'CBL_FN_VARIANCE',
1617: b'CBL_FN_YEAR0TO0YYYY',
1618: b'CBL_FREE_DYN_MEM',
1619: b'CBL_FREE_LOCK',
1620: b'CBL_FREE_MEM',
1621: b'CBL_FREE_RECORD_LOCK',
1622: b'CBL_FREE_SEMAPHORE',
1623: b'CBL_FREE_SHMEM',
1624: b'CBL_FREE_THREAD_MEM',
1625: b'CBL_GET_A2E_TABLE',
1626: b'CBL_GET_COBOL_SWITCH',
1627: b'CBL_GET_CSR_POS',
1628: b'CBL_GET_CURRENT_DIR',
1629: b'CBL_GET_DATETIME',
1630: b'CBL_GET_E2A_TABLE',
1631: b'CBL_GET_EXIT_INFO',
1632: b'CBL_GET_FILE_INFO',
1633: b'CBL_GET_FILE_SYSTEM_INFO',
1634: b'CBL_GET_INSTALL_DIR',
1635: b'CBL_GET_INSTALL_VER',
1636: b'CBL_GET_KBD_STATUS',
1637: b'CBL_GET_LOCK',
1638: b'CBL_GET_MOUSE_MASK',
1639: b'CBL_GET_MOUSE_POSITION',
1640: b'CBL_GET_MOUSE_STATUS',
1641: b'CBL_GET_OS_INFO',
1642: b'CBL_GET_PROGRAM_INFO',
1643: b'CBL_GET_RECORD_LOCK',
1644: b'CBL_GET_SCR_DRAW_CHARS',
1645: b'CBL_GET_SCR_GRAPHICS',
1646: b'CBL_GET_SCR_LINE_DRAW',
1647: b'CBL_GET_SCR_SIZE',
1648: b'CBL_GET_SHMEM_PTR',
1649: b'CBL_HIDE_MOUSE',
1650: b'_mF7809',
1651: b'_mF7909',
1652: b'_mF8009',
1653: b'_mF8109',
1654: b'CBL_IMP',
1655: b'CBL_INIT_MOUSE',
1656: b'CBL_JOIN_FILENAME',
1657: b'CBL_LCKFILE',
1658: b'CBL_LOCATE_FILE',
1659: b'CBL_MBCS_CHAR_LEN',
1660: b'CBL_MEMCK',
1661: b'CBL_MEM_STRATEGY',
1662: b'CBL_MEM_VALIDATE',
1663: b'CBL_MFIO',
1664: b'CBL_MF_DEREGISTER_MEM',
1665: b'CBL_MF_GET_AMODE',
1666: b'CBL_MF_GET_SIZE',
1667: b'CBL_MF_LINEAR_TO_NATIVE',
1668: b'CBL_MF_MF_TO_NATIVE',
1669: b'CBL_MF_NATIVE_TO_LINEAR',
1670: b'CBL_MF_NATIVE_TO_MF',
1671: b'CBL_MF_REGISTER_MEM',
1672: b'CBL_MF_SET_AMODE',
1673: b'CBL_MONITOR_BROWSE',
1674: b'CBL_MONITOR_BROWSE_TO_READ',
1675: b'CBL_MONITOR_BROWSE_TO_WRITE',
1676: b'CBL_MONITOR_CLOSE',
1677: b'CBL_MONITOR_OPEN_INTRA',
1678: b'CBL_MONITOR_READ',
1679: b'CBL_MONITOR_RELEASE',
1680: b'CBL_MONITOR_UNBROWSE',
1681: b'CBL_MONITOR_UNREAD',
1682: b'CBL_MONITOR_UNWRITE',
1683: b'CBL_MONITOR_WRITE',
1684: b'CBL_MONITOR_WRITE_TO_BROWSE',
1685: b'CBL_MUTEX_ACQUIRE',
1686: b'CBL_MUTEX_CLOSE',
1687: b'CBL_MUTEX_OPEN_INTRA',
1688: b'CBL_MUTEX_RELEASE',
1689: b'CBL_NLS_CLOSE_MSG_FILE',
1690: b'CBL_NLS_COMPARE',
1691: b'CBL_NLS_GET_MSG',
1692: b'CBL_NLS_INFO',
1693: b'CBL_NLS_OPEN_MSG_FILE',
1694: b'CBL_NLS_READ_MSG',
1695: b'CBL_NLS_TRANSFORM',
1696: b'CBL_NOT',
1697: b'CBL_OPEN_FILE',
1698: b'CBL_OPEN_VFILE',
1699: b'CBL_OR',
1700: b'_mF0501',
1701: b'_mF0901',
1702: b'_mF0902',
1703: b'_mF0905',
1704: b'_mF0908',
1705: b'_mF5001',
1706: b'_mF5002',
1707: b'_mF5005',
1708: b'_mF5006',
1709: b'_mF8201',
1710: b'_mFb201',
1711: b'_mFb202',
1712: b'_mFb203',
1713: b'_mFb205',
1714: b'_mFb206',
1715: b'_mFb207',
1716: b'_mFb209',
1717: b'_mFb210',
1718: b'_mFb211',
1719: b'_mFb213',
1720: b'_mFb214',
1721: b'_mFb215',
1722: b'_mFb217',
1723: b'_mFb218',
1724: b'_mFb221',
1725: b'_mFb222',
1726: b'_mFb223',
1727: b'_mFb225',
1728: b'_mFb226',
1729: b'_mFb227',
1730: b'_mFb240',
1731: b'_mFb241',
1732: b'_mFb242',
1733: b'_mFb243',
1734: b'CBL_PROF',
1735: b'CBL_PROGRAM_DIR_SEARCH_GET',
1736: b'CBL_PROGRAM_DIR_SEARCH_SET',
1737: b'CBL_PURE_DBCS_ASC_2_EBC',
1738: b'CBL_PURE_DBCS_EBC_2_ASC',
1739: b'CBL_PUT_SHMEM_PTR',
1740: b'CBL_READ_DIR',
1741: b'CBL_READ_FILE',
1742: b'CBL_READ_KBD_CHAR',
1743: b'CBL_READ_MOUSE_EVENT',
1744: b'CBL_READ_SCR_ATTRS',
1745: b'CBL_READ_SCR_CHARS',
1746: b'CBL_READ_SCR_CHATTRS',
1747: b'CBL_READ_VFILE',
1748: b'CBL_REF_EXT_DATA',
1749: b'CBL_RELSEMA',
1750: b'_mF0305',
1751: b'_mF0306',
1752: b'_mF8413',
1753: b'_mF8414',
1754: b'_mF8415',
1755: b'_mF0107',
1756: b'_mF0108',
1757: b'_mF0109',
1758: b'_mF0110',
1759: b'_mF0111',
1760: b'_mF0112',
1761: b'_mF0113',
1762: b'_mF0307',
1763: b'_mF8407',
1764: b'_mF8408',
1765: b'_mF8409',
1766: b'_mF8410',
1767: b'_mF8411',
1768: b'_mF8412',
1769: b'_mF0208',
1770: b'_mF0209',
1771: b'_mF0609',
1772: b'_mF4905',
1773: b'_mF7704',
1774: b'_mF7705',
1775: b'CBL_RENAME_FILE',
1776: b'CBL_RESNAME',
1777: b'CBL_SCR_ALLOCATE_ATTR',
1778: b'CBL_SCR_ALLOCATE_COLOR',
1779: b'CBL_SCR_ALLOCATE_VC_COLOR',
1780: b'CBL_SCR_CONTEXT_ATTACH',
1781: b'CBL_SCR_CONTEXT_CREATE',
1782: b'CBL_SCR_CONTEXT_DESTROY',
1783: b'CBL_SCR_CONTEXT_DETACH',
1784: b'CBL_SCR_CONTEXT_GET',
1785: b'CBL_SCR_CREATE_VC',
1786: b'CBL_SCR_DESTROY_VC',
1787: b'CBL_SCR_FREE_ATTR',
1788: b'CBL_SCR_FREE_ATTRS',
1789: b'CBL_SCR_GET_ATTRIBUTES',
1790: b'CBL_SCR_GET_ATTR_DETAILS',
1791: b'CBL_SCR_GET_ATTR_INFO',
1792: b'CBL_SCR_NAME_TO_RGB',
1793: b'CBL_SCR_QUERY_COLORMAP',
1794: b'CBL_SCR_RESTORE',
1795: b'CBL_SCR_RESTORE_ATTRIBUTES',
1796: b'CBL_SCR_SAVE',
1797: b'CBL_SCR_SAVE_ATTRIBUTES',
1798: b'CBL_SCR_SET_ATTRIBUTES',
1799: b'CBL_SCR_SET_PC_ATTRIBUTES',
1800: b'_mF7601',
1801: b'_mF7602',
1802: b'_mF7603',
1803: b'CBL_SEMAPHORE_ACQUIRE',
1804: b'_mF7701',
1805: b'_mF7702',
1806: b'_mF7703',
1807: b'CBL_SEMAPHORE_CLOSE',
1808: b'_mF7828',
1809: b'_mF0610',
1810: b'_mF0611',
1811: b'_mF0631',
1812: b'_mF3635',
1813: b'_mF3636',
1814: b'_mF3637',
1815: b'_mF3638',
1816: b'_mF0304',
1817: b'CBL_SEMAPHORE_OPEN_INTRA',
1818: b'CBL_SEMAPHORE_RELEASE',
1819: b'CBL_SETSEMA',
1820: b'CBL_SET_COBOL_SWITCH',
1821: b'CBL_SET_CSR_POS',
1822: b'CBL_SET_DATETIME',
1823: b'CBL_SET_MOUSE_MASK',
1824: b'CBL_SET_MOUSE_POSITION',
1825: b'CBL_SET_SEMAPHORE',
1826: b'CBL_SHIFT_LEFT',
1827: b'_tMc35a0',
1828: b'CBL_SHIFT_RIGHT',
1829: b'CBL_SHOW_MOUSE',
1830: b'_tMc0106',
1831: b'_tMc0401',
1832: b'_tMc0402',
1833: b'_tMc0403',
1834: b'_tMc0501',
1835: b'_tMc0601',
1836: b'_tMc0602',
1837: b'_tMc0603',
1838: b'_tMc0604',
1839: b'_tMc0605',
1840: b'_tMc0608',
1841: b'_tMc0701',
1842: b'_tMc0702',
1843: b'_tMc0703',
1844: b'_tMc0705',
1845: b'_tMc0801',
1846: b'_tMc0802',
1847: b'_tMc0803',
1848: b'_tMc0805',
1849: b'_tMc0901',
1850: b'_tMc0902',
1851: b'_tMc0905',
1852: b'_tMc0908',
1853: b'_tMc1002',
1854: b'_tMc1102',
1855: b'_tMc1302',
1856: b'_tMc1402',
1857: b'_tMc2201',
1858: b'_tMc2205',
1859: b'_tMc3312',
1860: b'_tMc3314',
1861: b'_tMc3316',
1862: b'_tMc3318',
1863: b'_tMc3320',
1864: b'_tMc3332',
1865: b'_tMc3334',
1866: b'_tMc3336',
1867: b'_tMc3338',
1868: b'_tMc3340',
1869: b'_tMc3343',
1870: b'_tMc3348',
1871: b'_tMc3350',
1872: b'_tMc3352',
1873: b'_tMc3354',
1874: b'_tMc3356',
1875: b'_tMc3359',
1876: b'_tMc3512',
1877: b'_tMc3514',
1878: b'_tMc3532',
1879: b'_tMc3534',
1880: b'_tMc3536',
1881: b'_tMc3538',
1882: b'_tMc3612',
1883: b'_tMc3614',
1884: b'_tMc3634',
1885: b'_tMc3712',
1886: b'_tMc3716',
1887: b'_tMc3732',
1888: b'_tMc3734',
1889: b'_tMc3736',
1890: b'_tMc3902',
1891: b'_tMc3903',
1892: b'_tMc3905',
1893: b'_tMc4002',
1894: b'_tMc4102',
1895: b'_tMc4104',
1896: b'_tMc4202',
1897: b'_tMc4302',
1898: b'_tMc4405',
1899: b'_tMc4406',
1900: b'_tMc4501',
1901: b'_tMc4602',
1902: b'_tMc4604',
1903: b'_tMc4701',
1904: b'_tMc4703',
1905: b'_tMc4802',
1906: b'_tMc4804',
1907: b'_tMc4901',
1908: b'_tMc4902',
1909: b'_tMc4903',
1910: b'_tMc4904',
1911: b'_tMc5001',
1912: b'_tMc5002',
1913: b'_tMc5005',
1914: b'_tMc5006',
1915: b'_tMc6001',
1916: b'_tMc6009',
1917: b'_tMc6013',
1918: b'_tMc6501',
1919: b'_tMc6601',
1920: b'_tMc7001',
1921: b'_tMc7002',
1922: b'_tMc7003',
1923: b'_tMc7004',
1924: b'_tMc7601',
1925: b'_tMc7602',
1926: b'_tMc7603',
1927: b'_tMc7701',
1928: b'_tMc7702',
1929: b'_tMc7703',
1930: b'_tMc8201',
1931: b'_tMc8302',
1932: b'_tMc8304',
1933: b'_tMc8406',
1934: b'_tMc8501',
1935: b'_tMc8502',
1936: b'_tMc8503',
1937: b'_tMca301',
1938: b'_tMca302',
1939: b'_tMca303',
1940: b'_tMca304',
1941: b'_tMca401',
1942: b'_tMca402',
1943: b'_tMca403',
1944: b'_tMca404',
1945: b'_tMca501',
1946: b'_tMca502',
1947: b'_tMca601',
1948: b'_tMca603',
1949: b'_tMca604',
1950: b'_tMca606',
1951: b'_tMca701',
1952: b'_tMca702',
1953: b'_tMca801',
1954: b'_tMca802',
1955: b'_tMca803',
1956: b'_tMca804',
1957: b'_tMca901',
1958: b'_tMcb001',
1959: b'_tMcb101',
1960: b'_tMcb102',
1961: b'_tMcb201',
1962: b'_tMcb202',
1963: b'_tMcb203',
1964: b'_tMcb205',
1965: b'_tMcb206',
1966: b'_tMcb207',
1967: b'_tMcb209',
1968: b'_tMcb210',
1969: b'_tMcb211',
1970: b'_tMcb213',
1971: b'_tMcb214',
1972: b'_tMcb215',
1973: b'_tMcb217',
1974: b'_tMcb218',
1975: b'_tMcb221',
1976: b'_tMcb222',
1977: b'_tMcb223',
1978: b'_tMcb225',
1979: b'_tMcb226',
1980: b'_tMcb227',
1981: b'_tMcb240',
1982: b'_tMcb241',
1983: b'_tMcb242',
1984: b'_tMcb243',
1985: b'_tMc0609',
1986: b'_tMc4905',
1987: b'_tMc7704',
1988: b'_tMc7705',
1989: b'_tMc4505',
1990: b'CBL_SPLIT_FILENAME',
1991: b'CBL_SRV_SERVICE_FLAGS_GET',
1992: b'CBL_SRV_SERVICE_FLAGS_SET',
1993: b'CBL_STREAM_CLOSE',
1994: b'CBL_STREAM_OPEN',
1995: b'CBL_STREAM_READ',
1996: b'CBL_STREAM_WRITE',
1997: b'CBL_STRING_CONVERT',
1998: b'CBL_SUBSYSTEM',
1999: b'CBL_SWAP_SCR_CHATTRS',
2000: b'CBL_TERM_MOUSE',
2006: b'mF_ld_dynlnk_lib_check',
2007: b'mF_ld_dynlnk_lib_term',
2022: b'mF_MFid',
2038: b'mF_ld_dynlnk_lib_init',
2040: b'mF_ld_dynlnk_lib_deinit',
2050: b'CBL_TEST_LOCK',
2059: b'CBL_TEST_RECORD_LOCK',
2061: b'mF_ld_dynlnk_check_active',
2062: b'mF_db_cf_date',
2063: b'mFt_rt_savarea_ldhdr_find',
2064: b'mFt_rt_savarea_step_p',
2065: b'mFt_ld_tab_atomic_end',
2066: b'mFt_ld_tab_atomic_start',
2067: b'mFt_rt_switch_register',
2068: b'mFt_rt_switch_deregister',
2079: b'CBL_THREAD_CLEARC',
2081: b'CBL_THREAD_CREATE',
2085: b'CBL_THREAD_CREATE_P',
2086: b'CBL_THREAD_DETACH',
2088: b'CBL_THREAD_EXIT',
2093: b'CBL_THREAD_IDDATA_ALLOC',
2094: b'CBL_THREAD_IDDATA_GET',
2099: b'CBL_THREAD_KILL',
2100: b'CBL_THREAD_LIST_END',
2101: b'CBL_THREAD_LIST_NEXT',
2102: b'CBL_THREAD_LIST_START',
2105: b'CBL_THREAD_LOCK',
2119: b'CBL_THREAD_PROG_LOCK',
2145: b'CBL_THREAD_PROG_UNLOCK',
2148: b'CBL_THREAD_RESUME',
2157: b'CBL_THREAD_SELF',
2161: b'CBL_THREAD_SETC',
2168: b'CBL_THREAD_SLEEP',
2169: b'CBL_THREAD_SUSPEND',
2170: b'CBL_THREAD_TESTC',
2179: b'CBL_THREAD_UNLOCK',
2200: b'CBL_THREAD_WAIT',
2201: b'CBL_THREAD_YIELD',
2202: b'CBL_TOLOWER',
2203: b'CBL_TOUPPER',
2204: b'CBL_TSTORE_CLOSE',
2205: b'CBL_TSTORE_CREATE',
2206: b'CBL_TSTORE_GET',
2207: b'CBL_UNLFILE',
2208: b'CBL_UNLOCK',
2209: b'CBL_UPDATE_INSTALL_INFO',
2210: b'CBL_VALIDATE_DBCS_STR',
2211: b'CBL_WRITE_FILE',
2212: b'CBL_WRITE_SCR_ATTRS',
2213: b'CBL_WRITE_SCR_CHARS',
2214: b'CBL_WRITE_SCR_CHARS_ATTR',
2215: b'CBL_WRITE_SCR_CHATTRS',
2216: b'CBL_WRITE_SCR_N_ATTR',
2217: b'CBL_WRITE_SCR_N_CHAR',
2218: b'CBL_WRITE_SCR_N_CHATTR',
2219: b'CBL_WRITE_SCR_TTY',
2220: b'CBL_WRITE_VFILE',
2221: b'CBL_XMLIO',
2222: b'CBL_XMLIO_INTERFACE',
2223: b'CBL_XMLPARSE_EXCEPTION',
2224: b'CBL_XMLPARSE_INTERFACE',
2225: b'CBL_XMLP_CLOSE',
2226: b'CBL_XMLP_INIT',
2227: b'CBL_XMLP_NEXTEVENT',
2228: b'CBL_XOR',
2229: b'CBL_YIELD_RUN_UNIT',
2230: b'CICS',
2231: b'COBENTMP',
2232: b'DELETE',
2233: b'DWGetFlags',
2234: b'DWGetTitle',
2235: b'DWMsgBox',
2236: b'DWSetFlags',
2237: b'DWSetFocus',
2238: b'DWSetTitle',
2239: b'DWShow',
2240: b'DWVioGetMode',
2241: b'DWVioSetMode',
2242: b'EXTERNL',
2243: b'EXTFH',
2244: b'HEX2ASCII',
2245: b'JNI_COB_TIDY',
2246: b'JNI_COB_WAIT',
2247: b'_Java_com_microfocus_nativeruntime_RtCes_jniGetErrorMsg@16',
2248: b'_Java_com_microfocus_nativeruntime_RtCes_jniGetLicense@28',
2249: b'_Java_com_microfocus_nativeruntime_RtCes_jniReleaseLicense@16',
2250: b'_Java_com_microfocus_nativeruntime_RtCes_jniSetAutoHandleErrors@12',
2251: b'Java_com_microfocus_nativeruntime_RuntimeControl_jniWinRtCobTidy',
2252: b'Java_com_microfocus_nativeruntime_RuntimeControl_jniWinWaitForNativeRuntime',
2253: b'KEISEN',
2254: b'KEISEN1',
2255: b'KEISEN2',
2256: b'KEISEN_SELECT',
2257: b'MFEXTMAP',
2258: b'MFPM',
2259: b'MFPRGMAP',
2260: b'MFregetblk',
2261: b'MVS_CONSOLE_IO',
2262: b'MVS_CONTROL_BLOCK_GET',
2263: b'MVS_CONTROL_BLOCK_INIT',
2264: b'MVS_CONTROL_BLOCK_TERM',
2265: b'MVS_JOB_STEP_EXECUTION_MGR',
2266: b'OCTAL2ASCII',
2267: b'PC_EXIT_PROC',
2268: b'PC_FIND_DRIVES',
2269: b'PC_GET_MOUSE_SHAPE',
2270: b'PC_LOCATE_FILE',
2271: b'PC_PRINTER_REDIRECTION_PROC',
2272: b'PC_READ_DRIVE',
2273: b'PC_READ_KBD_SCAN',
2274: b'PC_SET_DRIVE',
2275: b'PC_SET_MOUSE_HIDE_AREA',
2276: b'PC_SET_MOUSE_SHAPE',
2277: b'PC_SUBSYSTEM',
2278: b'PC_TEST_PRINTER',
2279: b'PC_WIN_ABOUT',
2280: b'PC_WIN_CHAR_TO_OEM',
2281: b'PC_WIN_HANDLE',
2282: b'PC_WIN_INIT',
2283: b'PC_WIN_INSTANCE',
2284: b'PC_WIN_OEM_TO_CHAR',
2285: b'PC_WIN_SET_CHARSET',
2286: b'PC_WIN_YIELD',
2287: b'REG_CLOSE_KEY',
2288: b'REG_CREATE_KEY',
2289: b'REG_CREATE_KEY_EX',
2290: b'REG_DELETE_KEY',
2291: b'REG_DELETE_VALUE',
2292: b'REG_ENUM_KEY',
2293: b'REG_ENUM_VALUE',
2294: b'REG_OPEN_KEY',
2295: b'REG_OPEN_KEY_EX',
2296: b'REG_QUERY_VALUE',
2297: b'REG_QUERY_VALUE_EX',
2298: b'REG_SET_VALUE',
2299: b'REG_SET_VALUE_EX',
2300: b'RENAME',
2301: b'SYSID',
2302: b'SYSTEM',
2303: b'_CODESET',
2304: b'_COYIELD',
2305: b'_EXTNAME',
2306: b'_MFSTOP',
2307: b'_PTRFN1',
2308: b'_PTRFN2',
2309: b'_TGETVAL',
2310: b'_USRSCRN',
2311: b'_mFbldrtsmsg',
2312: b'_mFddexpand',
2313: b'_mFdllinit',
2314: b'_mFdllterm',
2315: b'_mFdonothing',
2316: b'_mFdynload',
2317: b'_mFerr',
2318: b'_mFerr2',
2319: b'_mFerr3',
2320: b'_mFfindp',
2321: b'_mFflattosel',
2322: b'_mFg2FB',
2323: b'_mFg2fullentry',
2324: b'_mFg2progswitch',
2325: b'_mFg3216ret',
2326: b'_mFg3216stack',
2327: b'_mFgAE',
2328: b'_mFgCE',
2329: b'_mFgF800',
2330: b'_mFgF801',
2331: b'_mFgF802',
2332: b'_mFgF803',
2333: b'_mFgF804',
2334: b'_mFgF805',
2335: b'_mFgF806',
2336: b'_mFgF807',
2337: b'_mFgF808',
2338: b'_mFgF809',
2339: b'_mFgF80A',
2340: b'_mFgF80B',
2341: b'_mFgF80C',
2342: b'_mFgF80D',
2343: b'_mFgF80E',
2344: b'_mFgF80F',
2345: b'_mFgF810',
2346: b'_mFgF811',
2347: b'_mFgF812',
2348: b'_mFgF813',
2349: b'_mFgF814',
2350: b'_mFgF815',
2351: b'_mFgF816',
2352: b'_mFgF817',
2353: b'_mFgF818',
2354: b'_mFgF819',
2355: b'_mFgF81A',
2356: b'_mFgF81B',
2357: b'_mFgFA',
2358: b'_mFgFB',
2359: b'_mFgFC',
2360: b'_mFgMFPMgetlinear',
2361: b'_mFgMFPMgetnative',
2362: b'_mFgWinMain',
2363: b'_mFgWinMain2',
2364: b'_mFgallocdata',
2365: b'_mFgetmsg',
2366: b'_mFgetrtsmsg',
2367: b'_mFginitdat_dll',
2368: b'_mFgkdrtfix',
2369: b'_mFgkdrtinit',
2370: b'_mFgkdrtunfix',
2371: b'_mFgmain',
2372: b'_mFgmain2',
2373: b'_mFgprogchain',
2374: b'_mFgprogcheckexit',
2375: b'_mFgproglink',
2376: b'_mFgproglock',
2377: b'_mFgprogrecurse',
2378: b'_mFgprogregister',
2379: b'_mFgprogswitch',
2380: b'_mFgprogthreaddata',
2381: b'_mFgprogunchain',
2382: b'_mFgprogunlock',
2383: b'_mFgtypecheck',
2384: b'_mFiD781',
2385: b'_mFiD782',
2386: b'_mFiD783',
2387: b'_mFiD784',
2388: b'_mFiD785',
2389: b'_mFiD786',
2390: b'_mFiD787',
2391: b'_mFiD788',
2392: b'_mFiD789',
2393: b'_mFiD78B',
2394: b'_mFiD78C',
2395: b'_mFiD78D',
2396: b'_mFiD78E',
2397: b'_mFiD78F',
2398: b'_mFiD790',
2399: b'_mFiD791',
2400: b'_mFiD794',
2401: b'_mFiD795',
2402: b'_mFiD796',
2403: b'_mFiD797',
2404: b'_mFiD7A0',
2405: b'_mFiD7A1',
2406: b'_mFiD7A2',
2407: b'_mFiD7A7',
2408: b'_mFiD7AA',
2409: b'_mFiD7AB',
2410: b'_mFiD7AD',
2411: b'_mFiD7AE',
2412: b'_mFiD7AF',
2413: b'_mFiD7B0',
2414: b'_mFiD7B1',
2415: b'_mFiD7B2',
2416: b'_mFiD7B3',
2417: b'_mFiD7B4',
2418: b'_mFiD7B5',
2419: b'_mFiD7B6',
2420: b'_mFiD7B7',
2421: b'_mFiD7B8',
2422: b'_mFiD7B9',
2423: b'_mFiD7BA',
2424: b'_mFiD7BC',
2425: b'_mFiD7BD',
2426: b'_mFiD7BE',
2427: b'_mFiD7BF',
2428: b'_mFiD7C0',
2429: b'_mFiD7C1',
2430: b'_mFiD7C2',
2431: b'_mFiD7C3',
2432: b'_mFiD7C4',
2433: b'_mFiD7C5',
2434: b'_mFiD7C7',
2435: b'_mFiD7C9',
2436: b'_mFiD7CB',
2437: b'_mFiD7CC',
2438: b'_mFiD7CD',
2439: b'_mFiD7CE',
2440: b'_mFiD7CF',
2441: b'_mFiD7D0',
2442: b'_mFiD7D7',
2443: b'_mFiD7D8',
2444: b'_mFiD7D9',
2445: b'_mFiD7DC',
2446: b'_mFiD7DD',
2447: b'_mFiD7DE',
2448: b'_mFiD7E1',
2449: b'_mFiD7E2',
2450: b'_mFiD7E3',
2451: b'_mFiD7E4',
2452: b'_mFiD7E5',
2453: b'_mFiD7E6',
2454: b'_mFiD7F1',
2455: b'_mFiD7F4',
2456: b'_mFiD7F5',
2457: b'_mFiD7F6',
2458: b'_mFiD7FB',
2459: b'_mFinit',
2460: b'_mFldyn',
2461: b'_mFprtmsg',
2462: b'_mFprtrtsmsg',
2463: b'_mFseltoflat',
2464: b'_mFundef',
2465: b'_mFxssd',
2466: b'cob_COYIELD',
2467: b'cob_db_runquery',
2468: b'cob_file_external',
2469: b'cobaudit_event',
2470: b'cobaudit_file_read',
2471: b'cobcall',
2472: b'cobcancel',
2473: b'cobchangemessageproc',
2474: b'cobcols',
2475: b'cobcommandline',
2476: b'cobctf_trace',
2477: b'cobctf_tracer_notify',
2478: b'cobdefinemessagetype',
2479: b'cobdlgetsym',
2480: b'cobdlload',
2481: b'cobdlunload',
2482: b'cobexit',
2483: b'cobfindprog',
2484: b'cobfunc',
2485: b'cobget_pointer',
2486: b'cobget_ppointer',
2487: b'cobget_sx1_comp5',
2488: b'cobget_sx2_comp5',
2489: b'cobget_sx4_comp5',
2490: b'cobget_sx8_comp5',
2491: b'cobget_sxn_comp5',
2492: b'cobget_x1_comp5',
2493: b'cobget_x1_compx',
2494: b'cobget_x2_comp5',
2495: b'cobget_x2_compx',
2496: b'cobget_x4_comp5',
2497: b'cobget_x4_compx',
2498: b'cobget_x8_comp5',
2499: b'cobget_x8_compx',
2500: b'cobget_xn_comp5',
2501: b'cobget_xn_compx',
2502: b'_mF0114',
2503: b'_mF0115',
2504: b'_mF0214',
2505: b'_mF0215',
2506: b'_mF0216',
2507: b'_mF0217',
2508: b'_mF0308',
2509: b'_mF3006',
2510: b'_mF3106',
2511: b'_mF3107',
2512: b'_mF3204',
2513: b'_mF3360',
2514: b'_mF3361',
2515: b'_mF3370',
2516: b'_mF3371',
2517: b'_mF3390',
2518: b'_mF3391',
2519: b'_mF3392',
2520: b'_mF3393',
2521: b'_mF3394',
2522: b'_mF3395',
2523: b'_mF3460',
2524: b'_mF3461',
2525: b'_mF3462',
2526: b'_mF3463',
2527: b'_mF3470',
2528: b'_mF3471',
2529: b'_mF3472',
2530: b'_mF3473',
2531: b'_mF3488',
2532: b'_mF3489',
2533: b'_mF3490',
2534: b'_mF3491',
2535: b'_mF3492',
2536: b'_mF3493',
2537: b'_mF3494',
2538: b'_mF3495',
2539: b'_mF3496',
2540: b'_mF3497',
2541: b'_mF3498',
2542: b'_mF3499',
2543: b'_mF3740',
2544: b'_mF3741',
2545: b'_mF3750',
2546: b'_mF3751',
2547: b'_mF3770',
2548: b'_mF3771',
2549: b'_mF3772',
2550: b'_mF3773',
2551: b'_mF3774',
2552: b'_mF3775',
2553: b'_mF5260',
2554: b'_mF5270',
2555: b'_mF5272',
2556: b'_mF5274',
2557: b'_mF5360',
2558: b'_mF5363',
2559: b'_mF5370',
2560: b'_mF5372',
2561: b'_mF5374',
2562: b'_mF5376',
2563: b'_mF5378',
2564: b'_mF5380',
2565: b'_mF5420',
2566: b'_mF5430',
2567: b'_mF5432',
2568: b'_mF5434',
2569: b'_mF5660',
2570: b'_mF5661',
2571: b'_mF5670',
2572: b'_mF5671',
2573: b'_mF5672',
2574: b'_mF5673',
2575: b'_mF5674',
2576: b'_mF5675',
2577: b'_mF5760',
2578: b'_mF5761',
2579: b'_mF5763',
2580: b'_mF5764',
2581: b'_mF5770',
2582: b'_mF5771',
2583: b'_mF5772',
2584: b'_mF5773',
2585: b'_mF5774',
2586: b'_mF5775',
2587: b'_mF5776',
2588: b'_mF5777',
2589: b'_mF5778',
2590: b'_mF5779',
2591: b'_mF5780',
2592: b'_mF5781',
2593: b'_mF5820',
2594: b'_mF5821',
2595: b'_mF5830',
2596: b'_mF5831',
2597: b'_mF5832',
2598: b'_mF5833',
2599: b'_mF5834',
2600: b'_mF5835',
2601: b'cobgetdatetime',
2602: b'cobgetenv',
2603: b'cobgetfuncaddr',
2604: b'cobinit',
2605: b'coblines',
2606: b'coblongjmp',
2607: b'cobmemalloc',
2608: b'cobmemfree',
2609: b'cobmemrealloc',
2610: b'cobposterrorproc',
2611: b'cobpostexitproc',
2612: b'cobpostmessageproc',
2613: b'cobpostsighandler',
2614: b'cobput_pointer',
2615: b'cobput_ppointer',
2616: b'cobput_sx1_comp5',
2617: b'cobput_sx2_comp5',
2618: b'cobput_sx4_comp5',
2619: b'cobput_sx8_comp5',
2620: b'cobput_sxn_comp5',
2621: b'cobput_x1_comp5',
2622: b'cobput_x1_compx',
2623: b'cobput_x2_comp5',
2624: b'cobput_x2_compx',
2625: b'cobput_x4_comp5',
2626: b'cobput_x4_compx',
2627: b'cobput_x8_comp5',
2628: b'cobput_x8_compx',
2629: b'cobput_xn_comp5',
2630: b'cobput_xn_compx',
2631: b'cobputenv',
2632: b'cobremoveexitproc',
2633: b'cobremovemessageproc',
2634: b'cobremovesighandler',
2635: b'cobrescanenv',
2636: b'cobsavenv',
2637: b'cobsavenv2',
2638: b'cobsendmessage',
2639: b'cobstringconvert',
2640: b'cobsync_mutex_deinit',
2641: b'cobsync_mutex_init',
2642: b'cobsync_mutex_lock',
2643: b'cobsync_mutex_unlock',
2644: b'cobthread_copy',
2645: b'cobthread_create',
2646: b'cobthread_equal',
2647: b'cobthread_exit',
2648: b'cobthread_isself',
2649: b'cobthread_join',
2650: b'cobthread_once',
2651: b'cobthread_self',
2652: b'cobthread_yield',
2653: b'cobthreadkey_deinit',
2654: b'cobthreadkey_getdata',
2655: b'cobthreadkey_init',
2656: b'cobthreadkey_setdata',
2657: b'cobthreadtidy',
2658: b'cobthreadtidydll',
2659: b'cobtidy',
2660: b'mF_32bit_integer_of_boolean',
2661: b'mF_64bit_integer_of_boolean',
2662: b'mF_ADIS',
2663: b'mF_BoolNOT32',
2664: b'mF_BoolNOT64',
2665: b'mF_COPYIN_VFILE',
2666: b'mF_COPYOUT_VFILE',
2667: b'mF_CTF_TRACE',
2668: b'mF_GETFILEINFO',
2669: b'mF_GETIXBLKSZ',
2670: b'mF_GETLOCKMODE',
2671: b'mF_GETRETRY',
2672: b'mF_GETSKIPONLOCK',
2673: b'mF_GetFloatingPointFormat',
2674: b'mF_Load32bitBoolBit',
2675: b'mF_Load32bitBoolDisplay',
2676: b'mF_Load64bitBoolBit',
2677: b'mF_Load64bitBoolDisplay',
2678: b'mF_RTSERR',
2679: b'mF_SERVER_CANCEL_HANDLER_POST',
2680: b'mF_SERVER_DEREGISTER_EVENT_CALLBACK',
2681: b'mF_SERVER_DEREGISTER_SELF_FROM_SHM',
2682: b'mF_SERVER_ES_INFO_INIT',
2683: b'mF_SERVER_LOAD',
2684: b'mF_SERVER_REGISTER_EVENT_CALLBACK',
2685: b'mF_Store32bitBoolBit',
2686: b'mF_Store32bitBoolDisplay',
2687: b'mF_Store64bitBoolBit',
2688: b'mF_Store64bitBoolBitRef',
2689: b'mF_Store64bitBoolDisplay',
2690: b'mF_Store64bitBoolDisplayRef',
2691: b'mF_boolean_of_integer',
2692: b'mF_boolean_of_integer_ref',
2693: b'mF_call2',
2694: b'mF_cf_block_create',
2695: b'mF_cf_block_destroy',
2696: b'mF_cf_block_getsize',
2697: b'mF_cf_block_write_buffer',
2698: b'mF_cf_key_create',
2699: b'mF_cf_rts_switch_set',
2700: b'mF_cf_tune_set',
2701: b'mF_directory_to_internal',
2702: b'mF_eloc',
2703: b'mF_enable_ime',
2704: b'mF_exception_filter',
2705: b'mF_fh_set_fe_stat',
2706: b'mF_fh_set_id_stat',
2707: b'mF_fh_set_lasterror',
2708: b'mF_get_arg_val',
2709: b'mF_get_dynmem',
2710: b'mF_get_errno',
2711: b'mF_get_num_arg',
2712: b'mF_getrtsconf',
2713: b'mF_gnt_epoints',
2714: b'mF_ieee_to_longibm',
2715: b'mF_ieee_to_shortibm',
2716: b'mF_integer_of_boolean',
2717: b'mF_ld_disk_search',
2718: b'mF_load_hook_deregister',
2719: b'mF_load_hook_register',
2720: b'mF_load_installf',
2721: b'mF_longibm_to_ieee',
2722: b'mF_numeric_UD_info',
2723: b'mF_pp_error',
2724: b'mF_pp_error_addr',
2725: b'mF_rt_cmdline_read',
2726: b'mF_setrtsconf',
2727: b'mF_shortibm_to_ieee',
2728: b'mF_shortibm_to_shortieee',
2729: b'mF_shortieee_to_shortibm',
2730: b'mF_tmpfilename',
2731: b'mF_trace_callback',
2732: b'mF_trace_install_component',
2733: b'mF_xe_MFPM_register',
2734: b'mF_xe_cgi_load',
2735: b'mF_xe_chk_load',
2736: b'mF_xe_com_load',
2737: b'mF_xe_oci_load',
2738: b'mF_xe_odbc_load',
2739: b'mF_xe_onecycle',
2740: b'mF_xe_prt_load',
2741: b'mF_xtrint',
2742: b'mFt_Pop_error_message',
2743: b'mFt_execerr',
2744: b'mFt_init_ru_ctl_area',
2745: b'mFt_ld_error_name',
2746: b'mFt_os_resource_lock_ru_ctl_area',
2747: b'mFt_os_resource_unlock_ru_ctl_area',
2748: b'mFt_rt_error_exec_extra',
2749: b'mFt_rt_print_version',
2750: b'mFt_rt_register_cancel_sort_comparison',
2751: b'mFt_rt_rtsfunc_srv_trace',
2752: b'mFt_ru_ctl_get_ru_addr',
2753: b'mFt_sv_server_es_notify',
2801: b'_mF3380',
2802: b'_mF3381',
2803: b'_mF3480',
2804: b'_mF3481',
2805: b'_mF3482',
2806: b'_mF3483',
2807: b'_mF3760',
2808: b'_mF3761',
2809: b'_mF5261',
2810: b'_mF5262',
2811: b'_mF5271',
2812: b'_mF5273',
2813: b'_mF5275',
2814: b'_mF5361',
2815: b'_mF5362',
2816: b'_mF5364',
2817: b'_mF5365',
2818: b'_mF5371',
2819: b'_mF5373',
2820: b'_mF5375',
2821: b'_mF5377',
2822: b'_mF5379',
2823: b'_mF5381',
2824: b'_mF5421',
2825: b'_mF5422',
2826: b'_mF5431',
2827: b'_mF5433',
2828: b'_mF5435',
2829: b'_mF5662',
2830: b'_mF5762',
2831: b'_mF5765',
2832: b'_mF5822',
} |
#Crie um programa que leia quanto dinheiro uma pessoa tem na carteira e mostre quantos dólares ela pode comprar
n=float(input('Quantos reais voce tem na carteira?'))
s=n/5.51
print('com a quantidade de {} reais que voce tem,voce tem {:.2f} dólares atualmente'.format(n,s))
|
people = int(input())
name_doc = input()
grade_sum = 0
average_grade = 0
total_grade = 0
numbers = 0
while name_doc != "Finish":
for x in range(people):
grade = float(input())
grade_sum += grade
average_grade = grade_sum / people
print(f"{name_doc} - {average_grade:.2f}.")
name_doc = input()
grade_sum = 0
total_grade += average_grade
numbers += 1
print(f"Student's final assessment is {total_grade / numbers:.2f}.") |
year = int(input("Inserire l'anno: "))
if year % 4 == 0 and (year <= 1582 or year % 100 != 0 or year % 400 == 0):
print("L'anno è bisestile.")
else:
print("L'anno non è bisestile.") |
# Desenvolva um programa que leia as notas de um aluno, calcule e mostre a sua média.
primeira_nota = float(input("Primeira nota: "))
segunda_nota = float(input('Segunda nota: '))
media_aritmetica = (primeira_nota + segunda_nota)/2
print(f"A sua média foi de {media_aritmetica:.4f}")
|
neopixel = Runtime.createAndStart("neopixel","NeoPixel")
def startNeopixel():
neopixel.attach(i01.arduinos.get(rightPort),23,16)
neopixel.setAnimation("Ironman",0,0,255,1)
pinocchioLying = False
def onStartSpeaking(data):
if (pinocchioLying):
neopixel.setAnimation("Ironman",0,255,0,1)
else:
neopixel.setAnimation("Ironman",255,0,0,1)
def onEndSpeaking(data):
if (pinocchioLying):
neopixel.setAnimation("Ironman",0,127,127,1)
global pinocchioLying
pinocchioLying = False
else:
neopixel.setAnimation("Ironman",0,0,255,1)
i01.mouth.addListener("publishStartSpeaking","python","onStartSpeaking")
i01.mouth.addListener("publishEndSpeaking","python","onEndSpeaking")
|
def pprint_matcher(node, *args, **kwargs):
print(matcher_to_str(node, *args, **kwargs))
def matcher_to_str(
node, indent_nr: int = 0, indent: str = " ", first_line_prefix=None
) -> str:
ind = indent * indent_nr
ind1 = indent * (indent_nr + 1)
if first_line_prefix is None:
first_line_prefix = ind
if isinstance(node, type):
return first_line_prefix + node.__name__ + "\n"
elif hasattr(node, "_fields"):
if 0 == len(node._fields):
return first_line_prefix + type(node).__name__ + "()\n"
out = ""
out += first_line_prefix + type(node).__name__ + "(\n"
for field in node._fields:
out += matcher_to_str(
getattr(node, field),
indent_nr=indent_nr + 1,
indent=indent,
first_line_prefix=ind1 + field + " = ",
)
out += ind + ")\n"
return out
if isinstance(node, list):
out = ""
out += first_line_prefix + "[\n"
for elem in node:
out += matcher_to_str(elem, indent_nr=indent_nr + 1, indent=indent)
out += ind + "]\n"
return out
else:
return first_line_prefix + repr(node) + "\n"
|
class model4:
def __getattr__(self,x):
var_name = 'var_'+x
v = self.__dict__[var_name] if var_name in self.__dict__ else self.__dict__[x]
return v() if callable(v) else v
def chain(self,other):
for k,v in other.__dict__.items():
self.__dict__[k]=v
return self
if __name__=="__main__":
x = model4()
x.var_a = lambda: 20
x.var_b = lambda: x.a+1
y = model4().chain(x)
y.var_c = lambda: y.b*y.d
y.d = 2
print(y.c)
|
salario = float(input('Insira o salário do funcionário que receberá um aumento: '))
if salario <= 1250:
novoSalario = salario + (salario * 15 / 100)
else:
novoSalario = salario + (salario * 10 / 100)
print(f'Um funcionário com o salário de {salario}, após o aumento, passa a receber R${novoSalario:.2f}')
|
ACTION_GOAL = "goal"
ACTION_RED_CARD = "red-card"
ACTION_YELLOW_RED_CARD = "yellow-red-card"
actions = {ACTION_GOAL: "GOAL",
ACTION_RED_CARD: "RED CARD",
ACTION_YELLOW_RED_CARD: "RED CARD"}
class PlayerAction(object):
def __init__(self, player, action):
if not type(player) == dict:
player = dict()
nm = player.get("name", dict())
self._fullname = nm.get("full", u"")
self._abbreviatedname = nm.get("abbreviation", u"")
self._firstname = nm.get("first", u"")
self._lastname = nm.get("last", u"")
if not type(action) == dict:
action = dict()
self._actiontype = action.get("type", None)
self._actiondisplaytime = action.get("displayTime", None)
self._actiontime = action.get("timeElapsed", 0)
self._actionaddedtime = action.get("addedTime", 0)
self._actionowngoal = action.get("ownGoal", False)
self._actionpenalty = action.get("penalty", False)
def __lt__(self, other):
normal = self._actiontime < other._actiontime
added = ((self._actiontime == other._actiontime) and
(self._actionaddedtime < other._actionaddedtime))
return normal or added
def __eq__(self, other):
normal = self._actiontime == other._actiontime
added = self._actionaddedtime == other._actionaddedtime
return normal and added
def __repr__(self):
return "<{}: {} ({})>".format(actions[self._actiontype],
self._abbreviatedname.encode("ascii",
"replace"),
self._actiondisplaytime)
@property
def FullName(self):
return self._fullname
@property
def FirstName(self):
return self._firstname
@property
def LastName(self):
return self._lastname
@property
def AbbreviatedName(self):
return self._abbreviatedname
@property
def ActionType(self):
return self._actiontype
@property
def DisplayTime(self):
return self._actiondisplaytime
@property
def ElapsedTime(self):
return self._actiontime
@property
def AddedTime(self):
return self._actionaddedtime
@property
def isGoal(self):
return self._actiontype == ACTION_GOAL
@property
def isRedCard(self):
return (self._actiontype == ACTION_RED_CARD or
self._actiontype == ACTION_YELLOW_RED_CARD)
@property
def isStraightRed(self):
return self._actiontype == ACTION_RED_CARD
@property
def isSecondBooking(self):
return self._actiontype == ACTION_YELLOW_RED_CARD
@property
def isPenalty(self):
return self._actionpenalty
@property
def isOwnGoal(self):
return self._actionowngoal
|
##!FAIL: TypeExprParseError[Paramètre 'dico' : Je ne comprends pas le type dictionnaire déclaré : il manque le type des clés et/ou des valeurs]@3:0
def dict_ajout(dico : Dict[int], k : K, v : V) -> Dict[K, V]:
""""""
rd : Dict[K, V]
rd = dico[:]
rd[k] = v
return rd
|
def main():
# Open file for output
outfile = open("Presidents.txt", "w")
# Write data to the file
outfile.write("Bill Clinton\n")
outfile.write("George Bush\n")
outfile.write("Barack Obama")
outfile.close() # Close the output file
main() # Call the main function
|
class NoCurrentVersionFound(KeyError):
"""
No version node of the a particular parent node could be found
"""
pass
class VersionDoesNotBelongToNode(AssertionError):
"""
The version that is trying to be attached does not belong to the parent node
"""
pass
|
def fb_python_library(name, **kwargs):
native.python_library(
name = name,
**kwargs
)
|
class Solution(object):
def findLUSlength(self, a, b):
"""
:type a: str
:type b: str
:rtype: int
"""
if len(a) > len(b):
return len(a)
elif len(a) < len(b):
return len(b)
elif a == b:
return -1
else:
return len(a)
|
def square_of_two_count(num):
if(num == 2):
return 0
num //= 2
print("num is now", num)
return square_of_two_count(num) + 1
count = square_of_two_count(512)
print("final count:", count)
# That was a brief refresher because recursion can be messy
# : Define a function called multiply. Have it do multiplication only using addition and recursion
def multiply(a, b):
"""
:param a: A non-negative number
:param b: A non-negative number
:return: The product of a multiplied by b
"""
if b == 0 or a == 0:
return 0
elif b <= 1:
return a
return a + multiply(a, b-1)
product = multiply(5, 6)
print("product:", product)
# : Define a function called gcd (or greatest common divisor). It should find the largest number that divides evenly into two given numeric inputs.
def gcd(a, b):
"""
Get the greatest common denominator among the two inputs
:param a: An integer
:param b: Another integer
:return: The greatest common denominator as an integer among the two inputs
"""
print("a:", a, "- b:", b)
if a % b == 0:
return b
return gcd(b, a % b)
divisor = gcd(96, 81)
print("divisor:", divisor)
# : CHALLENGE: Solve the Tower of Hanoi with a function called hanoi
"""
It consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape.
The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:
1) Only one disk can be moved at a time.
2) Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3) No disk may be placed on top of a smaller disk.
With three disks, the puzzle can be solved in seven moves. The minimum number of moves required to solve a Tower of Hanoi puzzle is 2n - 1, where n is the number of disks.
"""
A = [3, 2, 1]
B = []
C = []
def hanoi(a, b, c):
return hanoiHelper(len(a), a, b, c, 0)
def hanoiHelper(n, a, b, c, count):
cnt = count
if n > 0:
# move tower of size n - 1 to helper:
cnt += hanoiHelper(n - 1, a, c, b, count)
# move disk from source peg to target peg
if len(a) > 0:
c.append(a.pop())
cnt += 1
print("MOVE FINISHED =============")
print("n:", n)
# Scope hijacking! Woo! :3
print("A:", A)
print("B:", B)
print("C:", C)
print("count:", cnt)
# move tower of size n-1 from helper to target
cnt += hanoiHelper(n - 1, b, a, c, count)
return cnt
num_steps = hanoi(A, B, C)
print("num_steps:", num_steps)
# : CHALLENGE: Create a binary search function called bsearch. Binary search takes in a sorted collection and keeps cutting it in half until if finds the desired value. It should take in an array and the value being searched for.
collection = [17, 24, 39, 40, 143, 145, 171, 192, 196, 253, 333, 372, 584, 602, 632, 635, 763, 882, 891, 934, 999, 1009, 1131, 1140, 1154, 1222, 1257, 1376, 1408, 1422, 1574, 1647, 1668, 1732, 1889, 1936, 2003, 2023, 2185, 2191, 2207, 2227, 2279, 2284, 2289, 2419, 2448, 2512, 2530, 2539, 2546, 2643, 2647, 2650, 2663, 2676, 2800, 2822, 2838, 2843, 2948, 2980, 2991, 2993, 3000, 3163, 3190, 3202, 3253, 3276, 3281, 3296, 3393, 3474, 3533, 3552, 3576, 3681, 3722, 3791, 3800, 3828, 3849, 3869, 3872, 3939, 3964, 3992, 4016, 4186, 4229, 4232, 4349, 4520, 4541, 4619, 4741, 4856, 4861, 4958]
def bsearch(coll, num):
"""
ASSUMES THE VALUE IS IN THE COLLECTION. (I'm being lazy) Counts the number
of steps doing a binary search for the given num in the given coll
:param coll:
:param num:
:return:
"""
return bsearchHelper(coll, num, 0)
def bsearchHelper(coll, num, steps):
midpoint = len(coll) // 2
if coll[midpoint] == num or len(coll) == 0:
return 1
if coll[midpoint] < num:
return 1 + bsearchHelper(coll[midpoint:], num, steps)
if coll[midpoint] > num:
return 1 + bsearchHelper(coll[:midpoint], num, steps)
position = bsearch(collection, 1140)
print("position:", position)
|
#program to display your details like name, age, address in three different lines.
name = 'Chibuzor darlington'
age = '19yrs'
address = 'imsu junction'
print(f'Name:{name}')
print(f'Age:{age}')
print(f'Address:{address}')
def personal_details():
name, age = "Chibuzor Darlington", '19yrs'
address = "imsu junction"
print("Name: {}\nAge: {}\nAddress: {}".format(name, age, address))
personal_details()
|
# Definition einer eigenen Klasse, hier die Klasse "Ding"
# ohne Attribute und Methoden
# im Anschluss wird ein Objekt mit zwei Attributen zugefügt
# --> Dynamische Erzeugung von Attributen
class Ding(object):
pass # Es wurden keine Attribute und Methoden definiert
#Hauptprogramm
kugel=Ding() # Definition eines Objektes
kugel.masse=100 # mit dem 1. Attribut (Name: "Masse" und Wert: "100")
kugel.material="Gold" # mit dem 2. Attribut (Name: "Material" und Wert: "Gold")
print(kugel.masse,kugel.material)
|
cache = {}
def get_page(url):
if cache.get(url):
return cache[url]
else:
data = get_data_from_server(url)
cache[url] = data
return data
|
"""This file contains all the code required to use the POSTGRES server so that bot has access to permanent storage"""
def createTable(cursor):
"""Creates specified table if it does not exist"""
command = "CREATE TABLE IF NOT EXISTS leaderboard (username varchar(50) NOT NULL, score INT NOT NULL)"
cursor.execute(command)
def checkExists(cursor, user):
"""Checks if a user is present in the table"""
command = "SELECT EXISTS(SELECT 1 FROM leaderboard WHERE username = %s)"
cursor.execute(command, (user,))
# The function returns a tuple
return cursor.fetchone()[0]
def createScore(cursor, user, value):
"""Creates an entry for a new user"""
command = "INSERT into leaderboard Values (%s, %s)"
cursor.execute(command, (user,value))
def getSQLScore(cursor, user):
"""Gets the score of a user"""
command = "SELECT score from leaderboard where username = %s"
cursor.execute(command, (user,))
return cursor.fetchone()[0]
def incrementScore(cursor, user, score):
"""Increments the score of a user by 1"""
command = "UPDATE leaderboard set score = %s where username = %s"
cursor.execute(command, (score + 1, user))
def getSQLLeaderboard(cursor):
"""Gets the top 10 players globally"""
command = "Select * from leaderboard order by score DESC LIMIT 10"
cursor.execute(command)
return cursor.fetchall() |
##write a program that will print the song "99 bottles of beer on the wall".
##for extra credit, do not allow the program to print each loop on a new line.
bottles = 99
while bottles > 0:
if bottles == 1:
print(str(bottles) + " bottles of beer on the wall, " + str(bottles) + " bottle of beer.", end=" ")
else:
print(str(bottles) + " bottles of beer on the wall, " + str(bottles) + " bottles of beer.", end=" ")
bottles -= 1
if bottles == 1:
print("Take one down and pass it around, " + str(bottles) + " bottle of beer on the wall.", end=" ")
elif bottles == 0:
print("Take one down and pass it around, no more bottles of beer on the wall.", end=" ")
else:
print("Take one down and pass it around, " + str(bottles) + " bottles of beer on the wall.", end=" ")
print("No more bottles of beer on the wall, no more bottles of beer.", end=" ")
print("Go to the store and buy some more, 99 bottles of beer on the wall.", end=" ")
|
#Aula 9 do Curso Python em Video!
#Exercício da Aula 09!
#By Rafabr
''''''
print('\n'+'*'*80)
print('Aula 09 - Exemplos e Testes'.center(80)+'\n')
frase = input("Digite uma Frase para testar alguns métodos utilizados com Strings: ")
print(f'\nA frase digitada possui {len(frase)} caracteres!\n')
print('\t',end = "")
for k in range(len(frase)):
print(frase[k].center(4),end = "")
print('\n\t',end = "")
for k in range(len(frase)):
print(str(k).center(4),end = "")
print("\n")
print(f"O primeiro caractere (frase[0]) é: ".ljust(50)+f"'{frase[0]}'")
print(f"O quinto caractere (frase[4]) é: ".ljust(50)+f"'{frase[4]}'")
print(f"Os primeiros 10 caracteres (frase[:10]) são: ".ljust(50)+f"'{frase[:10]}'")
print("Caracteres 5º a 15º (frase[4:14]) são: ".ljust(50)+f"'{frase[4:14]}'")
print()
print(f"O último caractere (frase[-1]) é: ".ljust(60)+f"'{frase[-1]}'")
print(f"Os últimos 10 caracteres (frase[-10:]) são: ".ljust(60)+f"'{frase[-10:]}'")
print(f"10 caracteres iniciais pulando de 2 em 2 (frase[:10:2]) é: ".ljust(60)+f"'{frase[:10:2]}'")
print()
print(f"A quantidade de Espaços (frase.count(' ')) na frase digitada é: ".ljust(110)+f"'{frase.count(' ')}'")
print(f"Podemos procurar uma string(Ex.:frase.find('no')) na frase digitada (Retorna índice): ".ljust(110)+f"'{frase.find('no')}'")
print(f"Podemos verificar se existe uma string na frase digitada ('no' in frase): ".ljust(110)+f"'{'no' in frase}'")
print()
print(f"Podemos substituir parte de uma string(frase.replace('a','y')) na frase digitada: ".ljust(85)+f"'{frase.replace('a','y')}'")
print()
print(f"A primeira palavra (frase.split[0]) da frase digitada é: ".ljust(85)+f"'{frase.split()[0]}'")
print(f"A última palavra (frase.split[-1]) da frase digitada é: ".ljust(85)+f"'{frase.split()[-1]}'")
join_teste = " ".join([frase.split()[0],frase.split()[-1]])
print(f"Juntando as duas palavras(" ".join(['frase.split[0]','frase.split[-1]'])) teremos: ".ljust(85)+"'"+" ".join([frase.split()[0],frase.split()[-1]])+"'")
print('\nFim da execução\n')
print('************************************************************')
|
#!/usr/bin/env python
"""credentials - the login credentials for all of the modules are stored here and imported into each module.
Please be sure that you are using restricted accounts (preferably with read-only access) to your servers.
"""
__author__ = '[email protected] (Scott Vintinner)'
# VMware
VMWARE_VCENTER_USERNAME = "domain\\username"
VMWARE_VCENTER_PASSWORD = "yourpassword"
# SNMP Community String (Read-Only)
SNMP_COMMUNITY = "public"
# Tintri
TINTRI_USER = "youraccount"
TINTRI_PASSWORD = "yourpassword"
# Workdesk MySQL
WORKDESK_USER = 'youraccount'
WORKDESK_PASSWORD = 'yourpassword'
# Rubrik
RUBRIK_USER = 'youraccount'
RUBRIK_PASSWORD = 'yourpassword'
# Nutanix
NUTANIX_USER = 'youraccount'
NUTANIX_PASSWORD = 'yourpassword'
|
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
class Tree:
def __init__(self):
self.head = None
def bft(self):
if self.head == None:
return
print("Bredth First Traversal")
ptr = self.head
stack = [self.head]
while stack:
ptr = stack[0]
stack = stack[1:]
print(ptr.data)
if ptr.left:
stack.append(ptr.left)
if ptr.right:
stack.append(ptr.right)
def pre_order_Traverse(self):
if self.head == None:
return
temp = self.head
stack = [self.head]
print('Pre-Order')
while stack:
temp = stack[0]
print(temp.data)
stack = stack[1:]
if temp.right != None:
stack.insert(0,(temp.right))
if temp.left != None:
stack.insert(0,(temp.left))
def in_order_Traverse(self):
if self.head == None:
return
def trav(node):
if node == None:
return
trav(node.left)
print(node.data)
trav(node.right)
print('In-order')
trav(self.head)
def post_order_Traverse(self):
if self.head == None:
return
def trav(node):
if node == None:
return
trav(node.left)
trav(node.right)
print(node.data)
print('Post-order')
trav(self.head)
def insert(self, data):
ptr = Node(data)
if self.head == None:
self.head = ptr
return
stack = [self.head]
while stack:
temp = stack[0]
stack = stack[1:]
if not temp.right:
temp.right = ptr
break
else:
stack.insert(0, temp.right)
if not temp.left:
temp.left = ptr
break
else:
stack.insert(0, temp.left)
def delete_val(self, val):
'''
method to delete a given value from binary tree.
Metodology: Copy the value of right most nodes` value in right subtree to the vnode whose value is to be deleted and delete the rightmost node
'''
if self.head == None:
return
if self.head.left == None and self.head.right==None:
if self.head.data==val:
self.head = None
return
return
def delete_deepest(node, delnode):
stack = [node]
while stack:
temp = stack[0]
stack = stack [1:]
if temp.right:
if temp.right == delnode:
temp.right = None
else:
stack.insert(0, temp.right)
if temp.left:
if temp.left == delnode:
temp.left = None
else:
stack.insert(0, temp.left)
stack = [self.head]
temp = None
key_node = None
while stack:
temp = stack.pop(0)
if temp.data == val:
key_node = temp
if temp.right!=None:
stack.insert(0, temp.right)
if temp.left!=None:
stack.insert(0, temp.left)
if key_node:
x = temp.data
delete_deepest(self.head, temp)
key_node.data = x
if __name__ == "__main__":
tree = Tree()
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n4 = Node(4)
n5 = Node(5)
n6 = Node(6)
n7 = Node(7)
n8 = Node(8)
tree.head = n1
n1.left = n2
n1.right = n3
n2.left = n4
n2.right = n5
n4.left = n6
n5.right = n7
n7.left = n8
tree.pre_order_Traverse()
tree.in_order_Traverse()
tree.post_order_Traverse()
tree.insert(9)
tree.in_order_Traverse()
tree.bft()
|
"""Embed utils."""
def recurse_while_none(element):
"""Recursively find the leaf node with the ``href`` attribute."""
if element.text is None and element.getchildren():
return recurse_while_none(element.getchildren()[0])
href = element.attrib.get('href')
if not href:
href = element.attrib.get('id')
return {element.text: href}
|
# Each frame has a name, and various associated roles. These roles have facet(s?) which take on values which are themselves sets of one or more frames.
class Frame:
# relations: a dictionary, key is role, value is other frames
def __init__(self, name, isstate=False, iscenter=False):
self.name = name
self.isstate = isstate
self.iscenter = iscenter
self.roles = {} # to contain multiple instances of the class Role. Keys are roles' names
class Role:
def __init__(self):
# Looking through the example XP, there are two types of facets:
self.facetvalue = []
self.facetrelation = []
|
class Contact:
def __init__(self, firstname, middlename, address, mobile, email):
self.firstname = firstname
self.middlename = middlename
self.address = address
self.mobile = mobile
self.email = email |
"""
Remove duplicates from Sorted Array
Given a sorted array, remove the duplicates in place such that each element appears only once and return the new length.
Note that even though we want you to return the new length, make sure to change the original array as well in place
Do not allocate extra space for another array, you must do this in place with constant memory.
Example:
Given input array A = [1,1,2],
Your function should return length = 2, and A is now [1,2].
"""
class Solution:
# @param A : list of integers
# @return an integer
def removeDuplicates(self, A):
if not A:
return 0
last, i = 0, 1
while i < len(A):
if A[last] != A[i]:
last += 1
A[last] = A[i]
i += 1
return last + 1
|
# Copyright 2021 Edoardo Riggio
#
# 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.
# Complexity O(n)
def minimal_contiguous_sum(A):
if len(A) < 1:
return None
dp = A[0]
m_sum = A[0]
for i in range(len(A)-1):
dp = min(dp + A[i+1], A[i+1])
m_sum = min(dp, m_sum)
return m_sum
array = [-1, 2, -2, -4, 1, -2, 5, -2, -3, 1, 2, -1]
print(minimal_contiguous_sum(array))
|
class Path(object):
@staticmethod
def db_dir(database):
if database == 'ucf101':
# folder that contains class labels
# root_dir = '/data/dataset/ucf101/UCF-101/'
root_dir = '/data/dataset/ucf101/UCF-5/'
# Save preprocess data into output_dir
output_dir = '/data/dataset/VAR/UCF-5/'
# output_dir = '/data/dataset/VAR/UCF-101/'
bbox_output_dir = '/data/dataset/UCF-101-result/UCF-5-20/'
return root_dir, output_dir, bbox_output_dir
elif database == 'hmdb51':
# folder that contains class labels
root_dir = '/Path/to/hmdb-51'
output_dir = '/path/to/VAR/hmdb51'
return root_dir, output_dir
elif database == 'something':
root_dir = '/data/dataset/something-something-v2-lite/20bn-something-something-v2-frames'
label_dir = '/data/dataset/something-something-v2-lite/label/something-something-v2-'
bbox_output_dir = '/data/dataset/something-something-v2-lite/20bn-something-something-det'
# root_dir = '/data/dataset/something-somthing-v2/20bn-something-something-v2-frames'
# label_dir = '/data/dataset/something-somthing-v2/label/something-something-v2-'
return root_dir, label_dir, bbox_output_dir
elif database == 'volleyball':
root_dir = '/mnt/data8tb/junwen/volleyball/videos'
# bbox_dir = '/data/dataset/volleyball/'
bbox_output_dir = '/mnt/data8tb/junwen/volleyball/volleyball-extra/'
return root_dir, bbox_output_dir
else:
print('Database {} not available.'.format(database))
raise NotImplementedError
@staticmethod
def group_dir(net):
if net == 'vgg19':
return '/mnt/data8tb/junwen/checkpoints/group_gcn/volleyball/vgg19_64_4096fixed_gcn2layer_lr0.01_pre71_mid5_lstm2/model_best.pth.tar'
@staticmethod
def model_dir(net):
if net == 'vgg19':
return '/home/junwen/opengit/player-classification-video/checkpoints/volleyball/vgg19_64_mid5_preImageNet_flip_drop/model_best.pth.tar'
elif net == 'vgg19bn':
return '/home/junwen/opengit/player-classification/checkpoints/volleyball/vgg19_bn_dropout/model_best.pth.tar'
elif net == 'alexnet':
return '/home/junwen/opengit/player-classification/checkpoints/volleyball/alexnet/model_best.pth.tar'
|
HEALTH_CHECKS_ERROR_CODE = 503
HEALTH_CHECKS = {
'db': 'django_healthchecks.contrib.check_database',
}
|
DEFAULT_STEMMER = 'snowball'
DEFAULT_TOKENIZER = 'word'
DEFAULT_TAGGER = 'pos'
TRAINERS = ['news', 'editorial', 'reviews', 'religion',
'learned', 'science_fiction', 'romance', 'humor']
DEFAULT_TRAIN = 'news' |
def check(kwds, name):
if kwds:
msg = ', '.join('"%s"' % s for s in sorted(kwds))
s = '' if len(kwds) == 1 else 's'
raise ValueError('Unknown attribute%s for %s: %s' % (s, name, msg))
def set_reserved(value, section, name=None, data=None, **kwds):
check(kwds, '%s %s' % (section, value.__class__.__name__))
value.name = name
value.data = data
|
# Copyright (C) 2016 The Android Open Source Project
#
# 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.
# GWT Rules Skylark rules for building [GWT](http://www.gwtproject.org/)
# modules using Bazel.
load('//tools/bzl:java.bzl', 'java_library2')
def gwt_module(gwt_xml=None, resources=[], srcs=[], **kwargs):
if gwt_xml:
resources += [gwt_xml]
java_library2(
srcs = srcs,
resources = resources,
**kwargs)
|
'''
changes to both lists
that means, they point to same object
once and then thrice
'''
'''
a = [1,2,3]
b = ([a]*3)
print(a)
print(b)
# same effect
# a[0]=11
b[0][0] = 9
print(a)
print(b)
#'''
'''
a = [1,2,3]
b = (a,)
print(a)
print(b)
#'''
|
# -*- coding: utf-8 -*-
# ==============================================================================
# AUTOGENERATED
# python.sdk.version - AUTOGENERATED
# VERSION.py - MAINTAINER's. Don't edit, if you don't know what are you doing
# ==============================================================================
VERSION = (0, 1, 0, 0)
RELEASE_SUFFIX = ''
VERSION_STRING = '.'.join([str(x) for x in VERSION])
RELEASE_STRING = "v{}{}".format(VERSION_STRING, RELEASE_SUFFIX)
PROJECT = 'Route4Me Python SDK'
COPYRIGHT = '2016-2021 © Route4Me Python Team'
AUTHOR = 'Route4Me Python Team (SDK)'
AUTHOR_EMAIL = '[email protected]'
TITLE = 'route4me'
LICENSE = 'ISC'
BUILD = None # TRAVIS_COMMIT
COMMIT = None # TRAVIS_BUILD_NUMBER
|
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
class BotAssert(object):
@staticmethod
def activity_not_null(activity):
if not activity:
raise TypeError()
@staticmethod
def context_not_null(context):
if not context:
raise TypeError()
@staticmethod
def conversation_reference_not_null(reference):
if not reference:
raise TypeError()
@staticmethod
def adapter_not_null(adapter):
if not adapter:
raise TypeError()
@staticmethod
def activity_list_not_null(activity_list):
if not activity_list:
raise TypeError()
@staticmethod
def middleware_not_null(middleware):
if not middleware:
raise TypeError()
@staticmethod
def middleware_set_not_null(middleware):
if not middleware:
raise TypeError()
|
CHIP8_STANDARD_FONT = [
0xF0, 0x90, 0x90, 0x90, 0xF0,
0x20, 0x60, 0x20, 0x20, 0x70,
0xF0, 0x10, 0xF0, 0x80, 0xF0,
0xF0, 0x10, 0xF0, 0x10, 0xF0,
0x90, 0x90, 0xF0, 0x10, 0x10,
0xF0, 0x80, 0xF0, 0x10, 0xF0,
0xF0, 0x80, 0xF0, 0x90, 0xF0,
0xF0, 0x10, 0x20, 0x40, 0x40,
0xF0, 0x90, 0xF0, 0x90, 0xF0,
0xF0, 0x90, 0xF0, 0x10, 0xF0,
0xF0, 0x90, 0xF0, 0x90, 0x90,
0xE0, 0x90, 0xE0, 0x90, 0xE0,
0xF0, 0x80, 0x80, 0x80, 0xF0,
0xE0, 0x90, 0x90, 0x90, 0xE0,
0xF0, 0x80, 0xF0, 0x80, 0xF0,
0xF0, 0x80, 0xF0, 0x80, 0x80
]
class Chip8State:
def __init__(self):
self.memory = bytearray(0x1000)
self.PC = 0x200
self.SP = 0x00
self.DT = 0x00
self.ST = 0x00
self.stack = [0 for _ in range(20)]
self.registers = bytearray(0x10)
self.I = 0
self.screen_buffer_length = 0x100
self.screen_buffer_start = 0x1000 - self.screen_buffer_length
self.keys = [False] * 16
self.timer_counter = 9
self.load_font(CHIP8_STANDARD_FONT)
def load_program(self, program):
rest = len(self.memory) - len(program) - 0x200
self.memory[0x200: 0x200 + len(program)] = program
self.memory[0x200 + len(program):] = [0x00] * rest
def load_font(self, font):
self.memory[:0x50] = font
def reset(self):
self.registers[:] = [0] * len(self.registers)
self.memory[:] = [0] * (len(self.memory))
self.DT = 0
self.ST = 0
self.I = 0
self.PC = 0x200
self.SP = 0
self.stack[:] = [0] * len(self.stack)
self.load_font(CHIP8_STANDARD_FONT)
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
def get_day():
return __day
def get_area():
return __area
__day = {
'월요일' : '월요일', '화요일' : '화요일', '수요일' : '수요일',
'목요일' : '목요일', '금요일' : '금요일', '토요일' : '토요일',
'일요일' : '일요일', '내일' : '내일', '모레' : '모레',
'글피' : '글피', '주' : '주', '주말' : '주말', '달' : '달',
}
__area = {
'진북동' : '진북동', '진북' : '진북동', '인후동' : '인후동', '인후' : '인후동',
'덕진동' : '덕진동', '덕진' : '덕진동', '금암동' : '금암동', '금암' : '금암동',
'팔복동' : '팔복동', '팔복' : '팔복동', '산정동' : '산정동', '산정' : '산정동',
'상동' : '금상동', '우아동' : '우아동', '우아' : '우아동', '호성동' : '효성동',
'호성' : '효성동', '미동' : '전미동', '송천동' : '송천동', '송천' : '송천동' ,
'반월동' : '반월동', '반월' : '반월동', '화전동' : '화전동', '화전' : '화전동',
'용' : '용정동', '성덕동' : '성덕동', '성덕' : '성덕동', '원동' : '원동',
'동산동' : '동산동', '동산' : '동산동', '고랑' : '고랑동', '여의동' : '여의동',
'여의' : '여의동', '성동' : '만성동', '장동' : '장동', '도도' : '도도동',
'흥동' : '강흥동', '도덕' : '도덕동', '남' : '남정동', '조촌동' : '조촌동',
'조촌' : '조촌동',
}
|
with open('pi_digits.txt') as file_object:
contnts = file_object.read()
print(contnts.rstrip())
|
class Solution:
def _lengthOfLastWord(self, s):
"""
:type s: str
:rtype: int
"""
temp = s.split(" ")
arr = list(filter(lambda x: x != '', temp))
if not arr:
return 0
return len(arr[-1])
def lengthOfLastWord(self, s):
l, r = len(s) - 1, len(s) - 1
if r == -1:
return 0
while r >= 0 and not s[r].isalpha():
r -= 1
l = r
while l >= 0 and s[l].isalpha():
l -= 1
if s[l + 1].isalpha():
return len(s[l+1:r+1])
if r < 0:
return 0
|
f=open('T.txt')
fw=open('foursquare.embedding.update.2SameAnchor.1.foldtrain.twodirectionContext.number.100_dim.10000000','w')
for i in f:
ii=i.split()
strt=ii[0]+'_foursquare'+' '
for iii in ii[1:]:
strt=strt+iii+'|'
fw.write(strt+'\n')
|
a = int(input("Enter a number1: "))
b = int(input("Enter a number2: "))
temp = b
b = a
a = temp
print("Value of number1: ", a , " Value of number2: ",b) |
"""
Initializes the view_helpers package
"""
|
""" Each module provides a `Simulation` class
based on `sapphire.Simulation`, but with specified governing equations.
The mesh, initial values, and boundary conditions are unspecified.
Therefore, the constructors have those as required arguments.
"""
|
"""Dependency specific initialization."""
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
load("@com_github_3rdparty_eventuals//bazel:deps.bzl", eventuals_deps = "deps")
load("@com_github_3rdparty_stout_borrowed_ptr//bazel:deps.bzl", stout_borrowed_ptr_deps = "deps")
load("@com_github_3rdparty_stout_notification//bazel:deps.bzl", stout_notification_deps = "deps")
load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
load("@com_github_reboot_dev_pyprotoc_plugin//bazel:deps.bzl", pyprotoc_plugin_deps = "deps")
def deps(repo_mapping = {}):
eventuals_deps(
repo_mapping = repo_mapping,
)
stout_borrowed_ptr_deps(
repo_mapping = repo_mapping,
)
stout_notification_deps(
repo_mapping = repo_mapping,
)
pyprotoc_plugin_deps(
repo_mapping = repo_mapping,
)
# !!! Here be dragons !!!
# grpc is currently (2021/09/06) pulling in a version of absl and boringssl
# that does not compile on linux with neither gcc (11.1) nor clang (12.0).
# Here we are front running the dependency loading of grpc to pull
# compatible versions.
#
# First of absl:
if "com_google_absl" not in native.existing_rules():
http_archive(
name = "com_google_absl",
url = "https://github.com/abseil/abseil-cpp/archive/refs/tags/20210324.2.tar.gz",
strip_prefix = "abseil-cpp-20210324.2",
sha256 = "59b862f50e710277f8ede96f083a5bb8d7c9595376146838b9580be90374ee1f",
)
# and then boringssl
if "boringssl" not in native.existing_rules():
git_repository(
name = "boringssl",
commit = "fc44652a42b396e1645d5e72aba053349992136a",
remote = "https://boringssl.googlesource.com/boringssl",
shallow_since = "1627579704 +0000",
)
grpc_deps()
if "com_github_gflags_gflags" not in native.existing_rules():
http_archive(
name = "com_github_gflags_gflags",
url = "https://github.com/gflags/gflags/archive/v2.2.2.tar.gz",
sha256 = "34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf",
strip_prefix = "gflags-2.2.2",
)
if "com_github_google_glog" not in native.existing_rules():
http_archive(
name = "com_github_google_glog",
url = "https://github.com/google/glog/archive/v0.4.0.tar.gz",
sha256 = "f28359aeba12f30d73d9e4711ef356dc842886968112162bc73002645139c39c",
strip_prefix = "glog-0.4.0",
)
if "com_github_google_googletest" not in native.existing_rules():
http_archive(
name = "com_github_google_googletest",
url = "https://github.com/google/googletest/archive/release-1.10.0.tar.gz",
sha256 = "9dc9157a9a1551ec7a7e43daea9a694a0bb5fb8bec81235d8a1e6ef64c716dcb",
strip_prefix = "googletest-release-1.10.0",
)
|
# Created by MechAviv
# Kinesis Introduction
# Map ID :: 331003200
# Subway :: Subway Car #3
GIRL = 1531067
sm.removeNpc(GIRL)
sm.warpInstanceIn(331003300, 0) |
model_parallel_size = 1
pipe_parallel_size = 0
distributed_backend = "nccl"
DDP_impl = "local" # local / torch
local_rank = None
lazy_mpu_init = False
use_cpu_initialization = False
|
"""
WaveletNode class represents one node in Wavelet tree data structure.
"""
class WaveletNode:
def __init__(self, alphabet, parent=None):
self.bit_vector = ''
self.alphabet = alphabet
self.left = None
self.right = None
self.parent = parent
""" Method for adding new bit to bit_vector """
def add(self, bit):
self.bit_vector += bit
""" Method for calculating index of nth_occurence of bit_type in bit_vector """
def nth_occurence(self, nth_occurence, bit_type):
occurences = 0
last_index = -1
for idx, bit in enumerate(self.bit_vector):
if bit == bit_type:
occurences += 1
last_index = idx
if occurences == nth_occurence:
break
# there is no 'nth_occurence' bits of 'bit_type' in 'bit_vector'
if occurences != nth_occurence:
last_index = -1
return last_index
|
#Kunal Gautam
#Codewars : @Kunalpod
#Problem name: Mumbling
#Problem level: 7 kyu
def accum(s):
li = []
for i in range(len(s)):
li.append(s[i].upper() + s[i].lower()*i)
return '-'.join(li)
|
# 0. Paste the code in the Jupyter QtConsole
# 1. Execute: bfs_tree( root )
# 2. Execute: dfs_tree( root )
root = {'value': 1, 'depth': 1}
def successors(node):
if node['value'] == 5:
return []
elif node['value'] == 4:
return [{'value': 5, 'depth': node['depth']+1}]
else:
return [
{'value': node['value']+1, 'depth':node['depth']+1},
{'value': node['value']+2, 'depth':node['depth']+1}
]
def bfs_tree(node):
nodes_to_visit = [node]
visited_nodes = []
while len(nodes_to_visit) > 0:
current_node = nodes_to_visit.pop(0)
visited_nodes.append(current_node)
nodes_to_visit.extend(successors(current_node))
return visited_nodes
def dfs_tree(node):
nodes_to_visit = [node]
visited_nodes = []
while len(nodes_to_visit) > 0:
current_node = nodes_to_visit.pop()
visited_nodes.append(current_node)
nodes_to_visit.extend(successors(current_node))
return visited_nodes
|
AUTHOR = 'Zachary Priddy. ([email protected])'
TITLE = 'Event Automation'
METADATA = {
'title': TITLE,
'author': AUTHOR,
'commands': ['execute'],
'interface': {
'trigger_types': {
'index_1': {
'context': 'and / or'
},
'index_3': {
'context': 'and / or'
},
'index_2': {
'context': 'and / or'
}
},
'trigger_devices': {
"index_1": {
'context': 'device_list_1',
'type': 'deviceList',
'filter': {}
},
"index_2": {
'context': 'device_list_2',
'type': 'deviceList',
'filter': {}
},
"index_3": {
'context': 'device_list_2',
'type': 'deviceList',
'filter': {}
}
},
'action_devices': {
"index_1": {
'context': 'device_list_1',
'type': 'deviceList',
'filter': {}
},
"index_2": {
'context': 'device_list_2',
'type': 'deviceList',
'filter': {}
},
"index_3": {
'context': 'device_list_2',
'type': 'deviceList',
'filter': {}
}
},
'trigger_actions': {
'index_1': {
'context': ''
},
'index_2': {
'context': ''
},
'index_3': {
'context': ''
}
},
'commands_actions': {
'index_1': {
'context': ''
},
'index_2': {
'context': ''
},
'index_3': {
'context': ''
}
},
'messages': {
"index_1": {
'context': 'Message to send when alert is started.',
'type': 'string'
},
"index_2": {
'context': 'Message to send when alert is stopped.',
'type': 'string'
},
"index_3": {
'context': 'Message to send when alert is stopped.',
'type': 'string'
}
},
'delays': {
'index_1': {
'context': 'Time to delay after door opens before triggering alert. (seconds)',
'type': 'number'
},
'index_2': {
'context': 'Time to delay after door opens before triggering alert. (seconds)',
'type': 'number'
},
'index_3': {
'context': 'Time to delay after door opens before triggering alert. (seconds)',
'type': 'number'
}
}
}
}
|
#Y
for row in range(11):
for col in range(11):
if (row==col) or (row==0 and col==10)or (row==1 and col==9)or (row==2 and col==8)or (row==3 and col==7)or (row==4 and col==6):
print("*",end=" ")
else:
print(" ",end=" ")
print()
|
def can_send(user, case):
return user.is_superuser or user == case.created_by
def nl2br(text):
return text.replace("\n", "\n<br>")
|
class Solution:
def removeKdigits(self, num: str, k: int) -> str:
stack, i = [], 0
while i < len(num):
if not stack:
if num[i] != "0":
stack.append(num[i])
elif stack[-1] <= num[i]:
stack.append(num[i])
else:
while stack and stack[-1] > num[i] and k > 0:
stack.pop()
k -= 1
if not stack and num[i] == "0":
continue
stack.append(num[i])
i += 1
while stack and k > 0:
stack.pop()
k -= 1
return ''.join(stack) if stack else "0"
def removeKdigitsLeetcode(self, num: str, k: int) -> str:
stack = []
for i in num:
while stack and k > 0 and stack[-1] > i:
stack.pop()
k -= 1
stack.append(i)
while stack and k > 0:
stack.pop()
k -= 1
while stack and stack[0] == "0":
stack.pop(0)
return ''.join(stack) if stack else "0"
sol = Solution()
print(sol.removeKdigitsLeetcode(num="1432219", k=3))
|
# Create a function named stringcases that takes a string and
# returns a tuple of four versions of the string:
# uppercased, lowercased, titlecased (where every word's first letter
# is capitalized), and a reversed version of the string.
# Handy functions:
# .upper() - uppercases a string
# .lower() - lowercases a string
# .title() - titlecases a string
# There is no function to reverse a string.
# Maybe you can do it with a slice?
def stringcases(aString):
aUpper = aString.upper()
aLower = aString.lower()
aTitle = aString.title()
aRev = aString[::-1]
return aUpper, aLower, aTitle, aRev
myString = "This is my tuple of my string's variants"
tup = stringcases(myString)
print(tup[0])
print(tup[1])
print(tup[2])
print(tup[3]) |
# Leo colorizer control file for eiffel mode.
# This file is in the public domain.
# Properties for eiffel mode.
properties = {
"lineComment": "--",
}
# Attributes dict for eiffel_main ruleset.
eiffel_main_attributes_dict = {
"default": "null",
"digit_re": "",
"escape": "\\",
"highlight_digits": "true",
"ignore_case": "true",
"no_word_sep": "",
}
# Dictionary of attributes dictionaries for eiffel mode.
attributesDictDict = {
"eiffel_main": eiffel_main_attributes_dict,
}
# Keywords dict for eiffel_main ruleset.
eiffel_main_keywords_dict = {
"alias": "keyword1",
"all": "keyword1",
"and": "keyword1",
"as": "keyword1",
"check": "keyword1",
"class": "keyword1",
"creation": "keyword1",
"current": "literal2",
"debug": "keyword1",
"deferred": "keyword1",
"do": "keyword1",
"else": "keyword1",
"elseif": "keyword1",
"end": "keyword1",
"ensure": "keyword1",
"expanded": "keyword1",
"export": "keyword1",
"external": "keyword1",
"false": "literal2",
"feature": "keyword1",
"from": "keyword1",
"frozen": "keyword1",
"if": "keyword1",
"implies": "keyword1",
"indexing": "keyword1",
"infix": "keyword1",
"inherit": "keyword1",
"inspect": "keyword1",
"invariant": "keyword1",
"is": "keyword1",
"like": "keyword1",
"local": "keyword1",
"loop": "keyword1",
"not": "keyword1",
"obsolete": "keyword1",
"old": "keyword1",
"once": "keyword1",
"or": "keyword1",
"precursor": "literal2",
"prefix": "keyword1",
"redefine": "keyword1",
"rename": "keyword1",
"require": "keyword1",
"rescue": "keyword1",
"result": "literal2",
"retry": "keyword1",
"select": "keyword1",
"separate": "keyword1",
"strip": "literal2",
"then": "keyword1",
"true": "literal2",
"undefine": "keyword1",
"unique": "literal2",
"until": "keyword1",
"variant": "keyword1",
"void": "literal2",
"when": "keyword1",
"xor": "keyword1",
}
# Dictionary of keywords dictionaries for eiffel mode.
keywordsDictDict = {
"eiffel_main": eiffel_main_keywords_dict,
}
# Rules for eiffel_main ruleset.
def eiffel_rule0(colorer, s, i):
return colorer.match_eol_span(s, i, kind="comment1", seq="--",
at_line_start=False, at_whitespace_end=False, at_word_start=False,
delegate="", exclude_match=False)
def eiffel_rule1(colorer, s, i):
return colorer.match_span(s, i, kind="literal1", begin="\"", end="\"",
at_line_start=False, at_whitespace_end=False, at_word_start=False,
delegate="",exclude_match=False,
no_escape=False, no_line_break=True, no_word_break=False)
def eiffel_rule2(colorer, s, i):
return colorer.match_span(s, i, kind="literal1", begin="'", end="'",
at_line_start=False, at_whitespace_end=False, at_word_start=False,
delegate="",exclude_match=False,
no_escape=False, no_line_break=True, no_word_break=False)
def eiffel_rule3(colorer, s, i):
return colorer.match_keywords(s, i)
# Rules dict for eiffel_main ruleset.
rulesDict1 = {
"\"": [eiffel_rule1,],
"'": [eiffel_rule2,],
"-": [eiffel_rule0,],
"0": [eiffel_rule3,],
"1": [eiffel_rule3,],
"2": [eiffel_rule3,],
"3": [eiffel_rule3,],
"4": [eiffel_rule3,],
"5": [eiffel_rule3,],
"6": [eiffel_rule3,],
"7": [eiffel_rule3,],
"8": [eiffel_rule3,],
"9": [eiffel_rule3,],
"@": [eiffel_rule3,],
"A": [eiffel_rule3,],
"B": [eiffel_rule3,],
"C": [eiffel_rule3,],
"D": [eiffel_rule3,],
"E": [eiffel_rule3,],
"F": [eiffel_rule3,],
"G": [eiffel_rule3,],
"H": [eiffel_rule3,],
"I": [eiffel_rule3,],
"J": [eiffel_rule3,],
"K": [eiffel_rule3,],
"L": [eiffel_rule3,],
"M": [eiffel_rule3,],
"N": [eiffel_rule3,],
"O": [eiffel_rule3,],
"P": [eiffel_rule3,],
"Q": [eiffel_rule3,],
"R": [eiffel_rule3,],
"S": [eiffel_rule3,],
"T": [eiffel_rule3,],
"U": [eiffel_rule3,],
"V": [eiffel_rule3,],
"W": [eiffel_rule3,],
"X": [eiffel_rule3,],
"Y": [eiffel_rule3,],
"Z": [eiffel_rule3,],
"a": [eiffel_rule3,],
"b": [eiffel_rule3,],
"c": [eiffel_rule3,],
"d": [eiffel_rule3,],
"e": [eiffel_rule3,],
"f": [eiffel_rule3,],
"g": [eiffel_rule3,],
"h": [eiffel_rule3,],
"i": [eiffel_rule3,],
"j": [eiffel_rule3,],
"k": [eiffel_rule3,],
"l": [eiffel_rule3,],
"m": [eiffel_rule3,],
"n": [eiffel_rule3,],
"o": [eiffel_rule3,],
"p": [eiffel_rule3,],
"q": [eiffel_rule3,],
"r": [eiffel_rule3,],
"s": [eiffel_rule3,],
"t": [eiffel_rule3,],
"u": [eiffel_rule3,],
"v": [eiffel_rule3,],
"w": [eiffel_rule3,],
"x": [eiffel_rule3,],
"y": [eiffel_rule3,],
"z": [eiffel_rule3,],
}
# x.rulesDictDict for eiffel mode.
rulesDictDict = {
"eiffel_main": rulesDict1,
}
# Import dict for eiffel mode.
importDict = {}
|
"""container_pull macro with improved API"""
load("@io_bazel_rules_docker//container:container.bzl", _container_pull = "container_pull")
load("//bazel/workspace:image_digests.bzl", "IMAGE_DIGESTS")
def container_pull(
name,
registry,
repository,
tag = None,
digest = None,
**kwargs):
"""container_pull macro that improves the API around tags & digests.
This improves the API misconception when both a tag and digest are specified that the tag
is load bearing, when it isn't.
To prevent from users updating a tag and forgetting to update a digest, this macro allows
for either a tag or a digest to be specified but not both. If a tag is specified, the digest
must exist in the IMAGE_DIGESTS map in bazel/workspace/image_digests.bzl.
Args:
name: A unique name for this repository.
registry: The registry from which we are pulling.
repository: The name of the image.
tag: The tag to lookup in the IMAGE_DIGESTS map. `tag` cannot be specified if `digest` is set.
digest: The digest of the image to pull. `digest` cannot be specified if `tag` is set.
**kwargs: additional args
"""
if not digest and not tag:
msg = """Either tag or digest must be specified in container_pull target %s.
Unpinned container_pull targets are not allowed.""" % name
fail(msg)
if tag:
key = "%s:%s" % (repository, tag)
# digest and tag cannot both be specified since tag is silently ignored if digest is set in the upstream API
if digest:
msg = """Both tag and digest cannot be specified in container_pull target %s.
This usage is unsafe as tag is ignored if digest is specified.
To specify a tag, add the corresponding digest to bazel/workspace/image_digests.bzl under the key %s:%s""" % (name, repository, key)
fail(msg)
# fail if tag is set and it is not in digests
if not key in IMAGE_DIGESTS:
msg = """Could not find repository:tag key %s in IMAGE_DIGESTS dict for container_pull target %s.
Please add the digest for this key to IMAGE_DIGESTS in bazel/workspace/image_digests.bzl""" % (key, name)
fail(msg)
digest = IMAGE_DIGESTS.get(key)
_container_pull(
name = name,
registry = registry,
repository = repository,
digest = digest,
**kwargs
)
|
"""
Telescope Spectral Response Class
===================================
This class calculates the output flux of an astronomical object as a funtion
of the 1.6 m Perkin-Elmer spectral response.
"""
class Telescope_Spectral_Response:
pass
|
"""Main module."""
def say(num: int):
"""
Convert large number to sayable text format.
Arguments:
num : A (large) number
"""
under_20 = [
"zero",
"one",
"two",
"three",
"four",
"five",
"six",
"seven",
"eight",
"nine",
"ten",
"eleven",
"twelve",
"thirteen",
"fourteen",
"fifteen",
"sixteen",
"seventeen",
"eighteen",
"nineteen",
]
tens = [
"twenty",
"thirty",
"forty",
"fifty",
"sixty",
"seventy",
"eighty",
"ninety",
]
above_100 = {
100: "hundred",
1000: "thousand",
1000000: "million",
1000000000: "billion",
}
if num < 20:
return under_20[num]
if num < 100:
return tens[(int)(num / 10) - 2] + (
"" if num % 10 == 0 else " " + under_20[num % 10]
)
# find the appropriate pivot - 'Million' in 3,603,550, or 'Thousand' in 603,550
pivot = max([key for key in above_100.keys() if key <= num])
return (
say((int)(num / pivot))
+ " "
+ above_100[pivot]
+ ("" if num % pivot == 0 else " " + say(num % pivot))
)
|
#!/usr/local/bin/python
# Code Fights Array Change Problem
def arrayChange(inputArray):
count = 0
for i in range(1, len(inputArray)):
diff = inputArray[i] - inputArray[i - 1]
if diff <= 0:
inputArray[i] += abs(diff) + 1
count += abs(diff) + 1
return count
def main():
tests = [
[[1, 1, 1], 3]
]
for t in tests:
res = arrayChange(t[0])
if t[1] == res:
print("PASSED: arrayChange({}) returned {}".format(t[0], res))
else:
print("FAILED: arrayChange({}) returned {}, answer: {}"
.format(t[0], res, t[1]))
if __name__ == '__main__':
main()
|
class LanguageSpecification:
def __init__(self):
pass
@staticmethod
def java_keywords():
keywords = ['abstract', 'assert', 'boolean', 'break', 'byte', 'case', 'catch', 'char', 'class', 'const']
keywords += ['continue', 'default', 'do', 'double', 'else', 'enum', 'extends', 'final', 'finally', 'float']
keywords += ['for', 'goto', 'if', 'implements', 'import', 'instanceof', 'int', 'interface', 'long', 'native']
keywords += ['new', 'package', 'private', 'protected', 'public', 'return', 'short', 'static', 'strictfp',
'super']
keywords += ['switch', 'synchronized', 'this', 'throw', 'throws', 'transient', 'try', 'void', 'volatile',
'while']
return keywords
|
class MODAK_sql:
CREATE_INFRA_TABLE = "create external table \
infrastructure(infra_id int, \
name string, \
num_nodes int, \
is_active boolean, \
description string) \
stored as PARQUET location \
'%s/infrastructure'"
CREATE_QUEUE_TABLE = "create external table \
queue(queue_id int, \
name string, \
num_nodes int, \
is_active boolean, \
node_spec string, \
description string, \
infra_id int) \
stored as parquet location \
'%s/queue'"
CREATE_BENCH_TABLE = "create external table \
benchmark(run_id int, \
queue_id int, \
num_cores int, \
compute_flops double, \
memory_bw double, \
network_bw double, \
io_bw double, \
acc_compute_flops double, \
acc_memory_bw double, \
PCIe_bw double) \
stored as parquet location \
'%s/benchmark'"
CREATE_MODEL_TABLE = "create external table \
model(model_id int, \
queue_id int, \
compute_flops string, \
memory_bw string, \
network_bw string, \
io_bw string, \
acc_compute_flops string, \
acc_memory_bw string, \
PCIe_bw string) \
stored as parquet location \
'%s/model'"
CREATE_APPMODEL_TABLE = "create external table \
appmodel(appmodel_id int, \
queue_id int, \
app_id int, \
compute_flops double, \
memory_bw double, \
network_bw double, \
io_bw double, \
acc_compute_flops double, \
acc_memory_bw double, \
PCIe_bw double, \
acc_share double) \
stored as parquet location \
'%s/appmodel'"
CREATE_APP_TABLE = "create external table \
application(app_id int, \
name string, \
app_type string, \
description string, \
src string) \
stored as parquet location \
'%s/application'"
CREATE_AUDIT_TABLE = "create external table \
audit_log(file_line bigint, \
start_time timestamp, \
end_time timestamp, \
run_time_sec bigint, \
queue_id int, \
app_id int, \
aprun_id bigint, \
job_id string, \
num_nodes int, \
run_stat int, \
command string, \
command_uniq string) \
stored as parquet location \
'%s/audit_log'"
CREATE_OPT_TABLE = "create external table \
optimisation(opt_id int, \
opt_dsl_code string, \
app_name string, \
target string, \
optimisation string) \
stored as parquet location \
'%s/optimisation'"
CREATE_MAPPER_TABLE = "create external table \
mapper(map_id int, \
opt_dsl_code string, \
container_file string, \
image_type string, \
image_hub string, \
src string) \
stored as parquet location \
'%s/mapper'"
table_create_stmt = {
"infrastructure": CREATE_INFRA_TABLE,
"queue": CREATE_QUEUE_TABLE,
"benchmark": CREATE_BENCH_TABLE,
"model": CREATE_MODEL_TABLE,
"appmodel": CREATE_APPMODEL_TABLE,
"application": CREATE_APP_TABLE,
"audit_log": CREATE_AUDIT_TABLE,
"optimisation": CREATE_OPT_TABLE,
"mapper": CREATE_MAPPER_TABLE,
}
def main():
print("Test MODAK sql")
print(MODAK_sql.CREATE_APP_TABLE.format("dir"))
print(MODAK_sql.table_create_stmt["mapper"].format("dir"))
if __name__ == "__main__":
main()
|
"""
ZODB Browser has the following submodules:
diff -- compute differences between two dictionaries
testing -- doodads to make writing tests easier
cache -- caching logic
history -- extracts historical state information from the ZODB
state -- IStateInterpreter adapters for making sense of unpickled data
value -- IValueRenderer adapters for pretty-printing objects to HTML
btreesupport -- special handling of OOBTree objects
interfaces -- interface definitions
browser -- browser views
standalone -- standalone application that starts a web server
"""
__version__ = '0.17.2.dev0'
__homepage__ = 'https://github.com/mgedmin/zodbbrowser'
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.