import sys
import time
sys.stdin = open("in.txt", "r")
sys.stdout = open("out.txt", "w")
__tstart = time.time()

 # code here

__trange = time.time() - __tstart
print("time used: %f" % __trange)

os.startfile(filename)
	# 调用系统默认程序打开文件，类似于鼠标双击
	# linux下没有实现
int = os.system(command(str))
	# 运行shell命令，返回命令执行退出状态
	# 和普通shell命令一样默认阻塞，除非后台运算符`&`

pipe = os.popen(cmd(str), mode="r"/"w", buffering=-1)
	# 运行shell命令并重定向其输出、输入流到管道开放

def execv(path, args=tuple/list)
def execl(path, *args=*list/*tuple)
	# 以参数执行指定可执行文件，**代替**当前进程

def execvp(file, args)
def execlp(file, *args)
	# `p` for `$PATH`
	# 在系统搜索路径`$PATH`中定位可执行程序

def execve(path, args=tuple/list, env=dict)
def execle(path, args=*tuple/*list, env=dict)
	# `e` for `environ`
	# 将`env`字典作为环境环境变量传递

def execvpe(path, args=tuple/list, env=dict)
def execlpe(path, args=*tuple/*list, env=dict)
	# 在系统搜索路径`$PATH`中定位可执行程序
	# 将`env`字典作为环境环境变量传递

os.spawn
	# 启动带有底层控制的新程序

read_fd, write_fd = os.pipe()
	# 创建管道，返回管道写入、读取描述符
	# 可以使用`os.fdopen()`封装管道描述符，方便读、写
os.mkfifo(path, mode=438, *, dir_fd=None)
	# 创建命名管道，win不支持
	# 仅创建外部文件，使用需要像普通文件一样打开、处理

class Popen:
	def __init__(self,
		args(str,[str]),
		bufsize=-1/0/1/int,
		executable=None/str,
		stdin=None/stream,
		stdout=None/stream,
		stderr=None/stream,
		preexec_fn=None/callable,
		close_fd=obj,
		shell=False/True,
		cwd=None/path,
		env=None/dict,
		universal_newlines=False/True,
		startupinfo=None,
		creationflags=0,
		restore_signals=True/False,
		start_new_session=False/True,
		pass_fds=(),
		encoding=None/str,
		errors=None
	)

(stdout, stderr) = communicate(self, input=None, timeout=None)

def kill(self):
	# kill进程通过*SIGKILL*信号

def terminate(self):
	# 终止进程通过*ISGTERM*信号

def send_signal(self, sig):
	# 向进程传递信号

def poll(self):
	# 检查子进程是否终止，设置、返回`.returncode`属性

def wait(self, timeout=None, endtime=None):
	# 等待直到子进程终止，返回`.returncode`属性

pipe.stdin
pipe.stdout
pipe.stderr
	# 管道标准输入、输出、错误流
	# 创建子进程时，可以选择和子进程相应流连接
	# 支持读、写、迭代
pipe.returncode
	# 子进程退出状态

subprocess.call(
	"type hello.py",
	shell=True/False
)

Lock = _thread.alloacate_lock()
	# 获取一个`Lock`锁
	# 等价于`threading.Lock()`
Lock = _thread.allocate()
	# deprecated，同上

RLock = _thread.RLock()
	# 获取一个`RLock`可重入锁
	# 等价于`threading.RLock()`

def _thread.exit()
	# 退出当前线程，可捕捉
	# 等价于显式`raise SystemExit`、`sys.exit()`
def _thread.exit_thread()
	# 同上

import _thread as thread

stdoutmutex = thread.allocate_lock()
	# 创建全局标准输出锁锁对象
exitmutexes = [thread.allocate_lock() for _ in range(10)]
	# 为每个线程创建锁
exitmutexes_bool = [False] * 10
	# 线程共享内存，同样可以使用全局变量作为信号量，而不用
		# 额外开销

def counter(myId, count):
	for i in range(count):

		stdoutmutex.acquire()
			# 线程向标准输出流写入时，获得锁
		print("[%s] => %s" % (myId, i))
		stdoutmutex.release()
			# 向标准输出流写入完毕后，释放锁

		with stdoutmutex:
			# 线程锁同样支持`with`上下文管理器
			print("[%s] => %s again" % (myId, i))

	exitmutexes[myID].acquire()
		# 线程执行完毕后获取对应自身id的锁，通知主线程

for i in range(10):
	thread.start_new_thread(counter, (i, 100))
	# 创建、启动新线程

for mutex in existmutexes:
	# 检查所有信号锁
	while not mutex.locked():
		# 直到信号锁被获取，结束死循环
		pass
print("main thread exiting")

import _thread as thread
import time

stdoutmutex = thread.allocate_lock()
exitmutexes_bool = [False] * 10

def counter(myId, count):
	for i in range(count):
		with stdoutmutex:
			# 线程锁同样支持`with`上下文管理器
			print("[%s] => %s again" % (myId, i))
	exitmutexes[myID] = True

for i in range(10):
	thread.start_new_thread(counter, (i, 100))

while not all(exitmutexes):
	time.sleep(0.25)
	# 暂停主线程，减少占用CPU进行无价值循环
print("main thread exiting")

class Thread:
	def __init__(self,
		group=None,
		target=callable,
		name=None/str,
		args=(),
		kwargs={},
		*,
		daemon=None/True/daemon):
		pass

def run(self):
	pass

def start(self):
	pass

def join(self,
	timeout=None/float):
	pass

bool = is_alive(self):
	# 返回线程是否存活

def setDaemon(self, daemonic):
	# 设置守护进程
bool = isDaemon(self):

def setName(self, name):
	# 设置线程名
def getName(self):

class Event():
	def set(self):
		# 设置信标值为`True`，发送信号

	bool = is_set(self):
		# 查看信标是否被设置

	bool = wait(self, timeout):
		# 阻塞，直到超时、信标被设置为`True`
		# 返回信标值，即因超时返回时返回`False`

	def clear():
		# 重置Event对象，设置信标值为`False`

class Condition():
	def __init__(self, lock=None)
		# `lock`：`Lock`、`RLock`对象，被用作底层锁
		# 缺省创建新`RLock`对象作为底层锁

	bool accquire():
		# 获取一次condition内部锁

	bool release():
		# 释放一次condition内部锁

	def notify(self, n=1):
		# 唤醒至多`n`个on this condition的线程

	def notify_all(self):
		# 唤醒所有on this condition的线程

	bool = wait(self, timeout=None):
		# 释放底层锁，阻塞
		# 直到被唤醒再次获取底层锁、超时，返回

	bool = wait_for(self, predicate(callable), timeout=None):
		# `wait`直到`predicate`返回`True`

with c:
	c.wait()

with c:
	c.notify()

class Semaphore(builtins.object):
	def __init__(self, value):
		# `value`：起始许可证数量（最多允许同时执行线程数目）

	bool = acquire(self, blocking=True, timeout=None):
		# 获取信号量，内部计数（许可证）减1

	def release():
		# 释放信号量，内部计数（许可证）加1

class BoundedSemaphore(Semaphore):
	def release(self):
		# 释放信号量，内部计数加1
		# 当信号量总数超过初始化值时`raise ValueError`

class lock:
	bool = acquire(blocking=True/False, timeout=-1)
		# 尝试获得锁，返回是否获得锁
	bool = acquire_lock
		# deprecated，同`acquire`

	bool = locked()
		# 返回锁状态
	bool = lockec_lock()
		# deprecated，同`lock`

	bool = release()
		# 释放锁，若锁本身未获取`raise RuntimeError`
	bool = release_lock()
		# deprected，同`release`

class RLock:
	bool =  acquire(block=True):
		# 尝试获取锁，返回是否获取锁
		# 每次获取锁，内部计数器加1
	bool = release()
		# 释放锁，若锁本身未获取`raise RuntimeError`
		# 每次释放锁，内部计数器减1

from threading import Thread
import time

class CountDownTask:

	def __init__(self):
		self._running = True

	def terminate(self):
		self._runing = False

	def run(self, n):
		while self._running and n > 0:
			# 设置轮询点，告诉线程何时应该终止
			print("T-minus", n)
			n -= 1
			time.sleep(5)

def test():
	c = CountdownTask()
	t = Thread(karget=c.run, args=(10,0))
		# 创建Thread
	t.start()
		# 启动线程
	c.terminate()
	c.join()

class IOTask:
	def terminate(self):
		self._running = False
	
	def run(self, sock):
		sock.settimeout(5)
			# 设置超时
		while self._running:
			try:
				data = sock.recv(8192)
				break
			except socket.timeout:
				continue
			...continued processing...
		...terminated...
		return

from threading import Event, Threading

def send_signal(start_evt):
	start_evt.set()
		# 设置事件

def recv_signal():
	start_evt = Event()
		# 创建新事件
	t = Thread.threading(target=send_signal, start_evt)
	start_evt.wait()
		# 阻塞直到接收到信号

import heapq
from threading import Condition

class PriortyQueue:
	def __init__(self):
		self._queue = [ ]
		self._count = 0
		self._cv = Condition()
			# 封装`Condition`实例实现线程间同步

	def put(self, item, priority):
		with self._cv:
			heapq.heappush(self._queue, (-priority, self._count, item))
			self._count += 1
			self._cv.notify()

	def get(self):
		with self._cv:
			# 阻塞，直到空闲
			while len(self._queue) == 0:
				self._cv.wait()
				# `Condition`默认使用`RLock`，可重入
			return heapq.heappop(self._queue)[-1]

from threading import local
from contextlib import contextmanager

_local = local()

@contextmanager
	# 使支持`with`上下文管理器语法
def acquire(*locks):

	locks = sorted(locks, key=lambda x: id(x))
		# 根据*object identifier*对locks排序
		# 之后根据此list请求锁都会按照固定顺序获取

	acquired = getattr(_local, "acquired", [ ])
		# 为每个线程创建独立属性保存锁
	if acquired and max(id(lock)) for lock in acquired >= id(locks[0]):
		# `_local`中已有锁不能比新锁`id`大，否则有顺序问题
		raise RuntimeError("lock order violation")

	acquired.extend(locks)
	_local.acquired = acquired
		# 更新线程环境中锁

	try:
		for lock in locks:
			# 只允许升序获取锁
			lock.acquire()
		yield
			# `with`语句进入处
	finally:
		# `with`语句退出处
		for lock in reversed(locks):
			# 只允许降序释放锁
			lock.release()
		del acquired[-len(locks):]

def thread_1(x_lock, y_lock):
	while True:
		with acquire(y_xlock, y_lock):
			print("Thread_1")

def thread_2(x_lock, y_lock):
	while True:
		with acquire(y_lock, x_lock):
			print("Thread_2")

def test():
	x_lock = threading.Lock()
	y_lock = threading.Lock()

	t1 = threading.Thread(target=thread_1, args=(x_lock, y_lock)):
	t1.daemon = True
	t1.start()

	t1 = threading.Thread(target=thread_2, args=(x_lock, y_lock))
	t2.daemon = True
	t2.start()

class Queue(builtins.object):
	def __init__(self, maxsize=0):
		# `maxsize`；限制可以添加到队列中的元素数量

obj =  get(self,
	block=True,
	timeout=None/num)

obj =  get_nowait(self):
	# 等同于`get(block=False)`

def task_done(self):
	# 指示前一个队列“任务”完成
def join(self):
	# 阻塞直到队列中所有元素被获取（消费）、**处理**

def put(self,
	item,
	block=True,
	timeout=None/num):
	pass

def put_nowait(self, item):
	# 等价于`put(self, item, block=False)`

int = qsize(self):
	# 返回队列大概大小（不可靠）
	# 非线程安全，在其使用结果时队列状态可能已经改变

bool = empty(self):
	# deprecated，使用`qsize() == 0`替代
	# 和`qsize()`一样非线程安全

bool = full(self):
	# deprecated，使用`qsize() > n`替代，非线程安全

from queue import Queue
from threading import Thread, Event

def producer(out_q):
	while running:
		evt = Event()
		out_q.put((data, evt))
			# 将`Event`实例放入队列
		evt.wait()
			# 阻塞直到收到消费者信号

 # A thread that consumes data
def consumer(in_q):
	while True:
		data, evt = in_q.get()
		evt.set()
			# 告知生产者消费完成

_sentinel = object()

def producer(out_q):
	while running:
		out_q.put(data)
	out_q.put(_sentinel)
		# 将特殊值放入队列，结束生产、通知消费者
def consumer(in_q):
	while True:
		data = in_q.get()
		if data is _sentinel:
			# 消费者接收到特殊值，结束生产
			in_q.put(_sentinel)
				# 特殊信号放回队列，继续传递
			break

from socket import socket, AF_INET, SOCK_STREAM
from threading import Thread
from queue import Queue

def echo_client(q):
	sock, client_addr = q.get()
	while True:
		msg = sock.recv(65536)
		if not msg:
			break
		sock.sendall(msg)
	print("closed")

def echo_server(addr, nworkers):
	q = Queue()
	for n in range(nworkers):
		t = Thread(target=echo_client, args=(q,))
		t.daemon = True
		t.start()
	socket = socket(AF_INET, SOCK_STREAM)
	socket.bind(addr)
	sock.listen(5)
	while True:
		client_sock, client_addr = sock.accept()
		q.put((client_sock, client_addr))

class Process():
	def __init__(self,
		group=None,
		target=None/callable,
		name=None/str,
		args=()/list,
		kwargs={}/dict,
		daemon=None
	):
		self.authkey
		self.daemon
		self.exitcode
		self.name
		self.pid

	def is_alive(self):

	def join(self,
		timeout=None/num
	):

	def start(self):
		# 启动进程

	def run(self):
		# `start`方法调用`run`方法，若进程实例未传入`target`，
		# `start`默认执行`run`方法

	def terminate():
		# 立即结束进程

from multiprocessing import Process
import os

def test(name):
	print("Process ID: %s" % (os.getpid())
	print("Parent Process ID: %s" % (os.getppid()))

if __name__ == "__main__":
	proc = Process(target=test, args=("nmask",))
	proc.start()
	proc.join()

class Pool:
	def __init__(self,
		processes=None/int,
		initializer=None,
		initargs=(),
		maxstacksperchild=None/int,
		context=None
	):

def apply(self, func, args=(), kwds={}):
	# 分配进程执行`func(*args, **kwds)`，阻塞
	# 返回值：`func(item)`返回值

def apply_async(self, func, args=(), kwds={},
	callback=None, error_callback=None)
	# 异步分配进程执行调用，非阻塞
	# 返回值：`ApplyResult`对象

class ApplyResult:
	def __init__(self, cache, chunksize, length,
		callback, error_callback):

	def get(self, timeout=None):

	bool = ready(self):

	bool = successful(self):

	bool = wait(self, timeout=None):

def map(self, func, iterable, chunksize=None):
	# 同步多进程`map(func, iterable)`，阻塞直到全部完成
	# 返回值：结果列表，结果按调用顺序

def map_async(self, func, iterable, chunksize=None,
	callback=None, error_callback=None):
	# 异步多进程`map`，非阻塞
	# 返回值：`MapResult(ApplyResult)`对象

def imap(self, func, iterable, chunksize=1):
	# 迭代器版`map`，更慢、耗内存更少
def imap_unordered(self, func, iterable, chunksize=1):
	# 返回结果无序版`imap`

def starmap(self, func, iterable, chunksize=1):
	# 同步`map`，参数被解构`func(*item)`，阻塞

def starmap_async(self, func, iterable, chuncksize=None,
	callback=None, error_callback=None):
	# 异步`startmap`，阻塞

def close(self):
	# 关闭进程池，不允许添加新进程

def join(self):
	# 阻塞，直至进程池中所有进程执行完毕
	# 必须先`.close`进程池

def terminate(self):
	# 终止进程池

class SimpleQueue():
	bool empty(self):
	def get(self):
	def put(self):
class Queue:
	def __init__(self, maxsize=0, *, ctx):
	def join_thread(self):
		# join feeder线程
	def cancel_join_thread(self):
		# 控制在进程退出时，不自动join feeder线程
		# 有可能导致部分数据在feeder中未被写入pipe而丢失
	def close(self):
		# 关闭feeder线程
	def qsize(self):
	def empty(self):
	def full(self):
	def get(self, block=True, timeout=None):
	def get_nowait(self):
	def put(self, obj, block=True, timeout=None):
	def put(self):
class JoinableQueue(Queue):
	def task_done():
	def join():

class Connection():
	def __init__(self, handle,
		readable=True,
		writable=True):

	def close(self):
	def fileno(self):
		# 返回描述符或连接处理器
	bool = poll(self, timeout=0):
		# 是否有输入可以读取
	obj =  recv(self):
		# 接收pickable对象
		# 若接收字节流不能被pickle解析则报错
	bytes = recv_bytes(self, maxlength=None):
		# 接收字节流作为`bytes`
	int = recv_bytes_into(self, buf, offset=0):
		# 接收字节流存入可写`buf`
		# 返回读取的字节数量
	def send(self, obj):
		# 发送对象
	def send_bytes(self, buf, offset=0, size=None):
		# 发送bytes-like对象中字节数据

class SynchronizedBase:
	def __init__(self, obj, lock=None, ctx=None):

	def get_lock(self):
		# 获取`multiprocessing.synchronize.RLock`

	def get_obj(self):
		# 获取数据对象，C数据结构`ctypes.`

def Value(typecode_or_type, *args, lock=True):
	# 返回同步共享对象
class Synchronized(SynchronizedBase):
	value

def Array(typecode_or_type, size_or_initializer, *,
	lock=True)

def SynchronizedArray(SynchronizedBase):
	def __getitem__(self, i):
	def __getslice__(self, start, stop):
	def __len__(self):
	def __setitem(self, i, value):
	def __setslice__(self, start, stop, values):

import multiprocessing as mltp
l1 = mltp.Lock()
	# 获取进程锁
rl1 = mltp.RLock()
	# 获取可重入锁
s1 = mltp.Semaphore(value=int)
	# 获取信号量对象
bs1 = mltp.BoundedSemaphore(value=int)
	# 获取有上限信号量对象
e1 = mltp.Event()
	# 获取事件对象
cv1 = mltp.Condition(lock=None)
	# 获取Condition对象
cp = mltp.current_process()
	# 获取当前Process对象

class ThreadPoolExecutor:
	def __init__(self,
		max_workers=None,
		thread_name_prefix=''):

	def shutdown(self, wait=True):
		# 清理和该执行器相关资源

	def submit(self, fn(callable), *args, **kwargs):
		# 以指定参数执行`fn`
		# 返回：代表调用的future，可以用于获取结果

	def map(self, fn, *iterables,
		timeout=None,
		chunksize=1/int)
		# 并行`map(fn, iterables)`
		# 返回：按调用顺序的结果迭代器

class ProcessPoolExecutor:
	def __init__(self,
		max_workers=None):

	def shutdown(self, wait=True):
		# 清理和该执行器相关资源

	def submit(self, fn(callable), *args, **kwargs):
		# 以指定参数执行`fn`
		# 返回：代表调用的`Future`实例，可以用于后续处理

	def map(self, fn,
		*iterables,
		timeout=None,
		chunksize=1/int)
		# 并行`map(fn, iterables)`
		# 返回：按调用顺序的结果迭代器

class Future:
	def add_done_callback(self, fn):
		# 添加future完成的回调函数
		# 多次调用添加的回调函数按添加顺序执行

	bool =  cancel(self):
		# 尝试取消当前future，返回是否成功取消
		# 正在运行、执行完成的future不能被取消

	bool = cancelled(self):
		# 查看当前future是否被取消

	bool = done(self):
		# 查看当前future是否被取消、完成

	def exception(self, timeout=None):
		# 返回当前future代表的调用的exception

	def result(self, timeout=None):
		# 返回当前future代表调用的返回值

class = type(
	name=cls_name,
	bases=(pls_name,..),
	dict={attr1: val1,...}
)

class UpperAttrMeta(type):
	def __new__(cls, cls_name, bases, attrs):
		upper_attrs=dict((name.upper(), val)
			for name,val in attrs.items()
			if not name.startswith('__')
		);
		return super(UpperAttrMeta,cls).__new__(
			cls,
			cls_name,
			bases,
			upper_attrs);
	// 使用元类创建新类

class Foo(metaclass=UpperAttrMeta):
	b=1;

		
def upper_attr(cls_name, bases, attrs):
	upper_attrs=dict((name.upper(), val) for name,val in attrs.items());
	return type(cls_name, bases, upper_attrs);

class Foo():
	bar=1;
	__metaclass__=upper_attr;

	# 函数版本

class UpperAttrMeta(type):
	def __new__(clsf, cls_name, bases, attrs):
		upper_attrs=dict((name.upper(), val) for name,val in attrs.items());
		return type(cls_name, bases, upper_attrs); 

class Foo():
	bar=1;
	__metaclass__=UpperAttrMeta;

	# 类版本1

class UpperAttrMeta(type):
	def __new__(cls, cls_name, bases, attrs):
		upper_attrs=dict((name.upper(), val) for name,val in attrs.items());
		return type.__new__(cls, cls_name, bases, upper_attrs); 

	# 类版本2

class UpperAttrMeta(type):
	def __new__(cls, cls_name, bases, attrs):
		upper_attrs=dict((name.upper(), val) for name,val in attrs.items());
		return super(UpperAttrMeta,cls).__new__(cls, cls_name, bases, upper_attrs); 

	# 类版本3

import weakref

class Cached(type):
	def __init__(self, *args, **kwargs):
		super().__init__(*args, **kwargs)
		self.__cache = weakref.WeakValueDictionary()

	def __call__(self, *args):
		if args in self.__cache:
			return self.__cache[args]
		else:
			obj = super().__call__(*args)
			self.__cache[args] = obj
			return obj

class Spam(metaclass=Cached):
	def __init__(self, name):
		print("Creating Spam({!r})".format(name))
		self.name = name

from collection import OrderedDict

class Typed:
	_expected_type = type(None)
	def __init__(self, name=None):
		self._name = name

	def __set__(self, instance, value):
		if not instance(value, self_expected_type):
			raise TypeError("expected" + str(self._expected_type))
		instance.__dict__[self._name] = value

class Integer(Typed):
	_expected_type = int

class Float(Typed):
	_expected_type = float

class String(Typed):
	_expected_type = str

class OrderedMate(type):
	def __new__(cls, clsname, bases, clsdict):
		d = dict(clsdict)
		order = [ ]
		for name, value in clsdict.items():
			if isinstance(value, Typed):
				value._name = name
				order.append(name)
		d["_order"] = order
		return type.__new__(cls, clsname, bases, d)

	@classmethod
	def __prepare__(cls, clsname, bases):
		# 此方法会在开始定义类、其父类时执行
		# 必须返回一个映射对象，以便在类定义体中使用
		return OrderedDict()

class Structure(metaclass=OrderedMeta):
	def as_csv(self):
		return ",".join(str(getattr(self, name)) for name in self._order)

class Stock(Structure):
	name = String()
	shares = Integer()
	price = Float()

	def __init__(self, name, shares, price):
		self.name = name
		self.shares = shares
		self.price = price