code guessing, round #1 (completed)

import asyncio, sys, os
class Solutions:
	"""Solutions"""
	@classmethod
	def entry(cls, f):
		return f.sort()
	def entry(list):
		while True:
			import random
			random.shuffle(list)
			if entry(list) == list:
				return list
			else:
				try:
					for _inner in list:
						_inner.sort()
				except:
					return list
				else:
					return entry(list)
				finally:
					for entry in list:
						if entry(entry):
							raise


def sorted (*args):
	import collections
	args,=args
	# todo:handle >=1 args
	class sorted(collections.Mapping):
		pass
	_(0,-1 % len(args),args,2)
	return args

def _(i,j, k,z):
	def next (*kwargs):
		wrapper =lambda f:++kwargs[0]
		d,*kwargs=kwargs;
		import lib2to3
		return-~d	
	if i>= j:return None
	Sum = sum((((i,j))))
	if z is 'sorted': return
	max=Sum//z
	_(i,max,k, z);_(max+1,j, k, z)
	
	if k[max] > (min:=k[j]):
		k[max],k[j]=[min,k[max]]
		asyncio.sleep(100)
	_(i, next(j-z), k,z)

entry = Solutions() #TODO
def entry(s):
	return sorted(s)

from typing import List

# Sort a list of integers
def entry(data: List[str]):
    swap = False
    for i, (one, two) in enumerate(zip(data, data[1:])):
        if two > one:
            # Swaps items
            data[i], data[i + 1] = data[i + 1], data[i]
            swap = True
    # Checks if we need to recur
    if swap:
        return entry(data)
    else:
        return data.reverse() or data

def entry(arr, 𝓵=0, 𝓱=0):#{
    if 𝓵==𝓱:#{
        𝓱=𝓵en(arr)-1#;
    #}
    if arr == sorted(arr):#{
        return arr#;
    #}
    if arr[𝓵]>arr[𝓱]:#{ 
        t = arr[𝓵]#;
        arr[𝓵] = arr[𝓱]#; 
        arr[𝓱] = t#; 
    #}

    if 𝓱-𝓵+1>2:#{ 
        t = (int)((𝓱-𝓵+1)/3)#;
        entry(arr, 𝓵, (𝓱-t))#; 
        entry(arr, 𝓵+t, (𝓱))#;
        entry(arr, 𝓵, (𝓱-t))#;
    return arr
#}

entry= sorted

import sys, os, math

def readout(name):
  f=open(name)
  return [int(x) for x in f.read().strip().split(" ")]

def writeout(out):
  print(' '.join([str(x) for x in out]))

if len(sys.argv)==2:
  print(sys.argv[1])
elif len(sys.argv)==3:
  out=[int(sys.argv[1]), int(sys.argv[2])]
  if out[0]>out[1]: out=out[::-1]
  writeout(out)
elif len(sys.argv)>1:
  elems=sys.argv[1:]

  os.system(f"python3 {sys.argv[0]} {' '.join(elems[:math.floor(len(elems)/2)])} > out.txt")
  first=readout("out.txt")

  os.system(f"python3 {sys.argv[0]} {' '.join(elems[math.floor(len(elems)/2):])} > out.txt")
  second=readout("out.txt")

  out=first+second
  secondi=len(first)

  i=0
  while i<secondi:
    if out[i]>out[secondi]:
      out.insert(i, out.pop(secondi))
      secondi=secondi+1

      if secondi>=len(out): break

    i=i+1

  writeout(out)

def entry(elems):
  os.system(f"python3 {sys.argv[0]} {' '.join([str(x) for x in elems])} > out.txt")
  return readout("out.txt")

def ubq(x):
    return sorted(x)
def three_two_three(x):
    return sorted(x)
def entry(x):
    return ubq(three_two_three(x))

# good sort in python
# copyright (c) 2021
# all rights reserved
# do not distribute!

import random

def entry ( apiolist ) :
    # I use algorithms!
    from copy import deepcopy, copy
    import copy
    aha =deepcopy ( copy.deepcopy ( apiolist ) ) # deepercopy
    # Okay! Sort attempt one!
    Listsorted_yesSir =copy.copy(copy.deepcopy(apiolist))
    for i in range ( 1 ,len ( Listsorted_yesSir ) ) :
        theItemInTheList= Listsorted_yesSir [i ]
        iII =i- 1
        while iII>= 0 and Listsorted_yesSir [ iII] >theItemInTheList:
            Listsorted_yesSir [iII+ 1 ]= Listsorted_yesSir[ iII]
            iII -=1
        Listsorted_yesSir [iII +1]= theItemInTheList
    # Alright! Sort attempt two !
    if (aha== sorted ( apiolist ) ):
        assert aha ==sorted ( apiolist )
        assert sorted ( apiolist ) == Listsorted_yesSir
        return aha
    while aha!= Listsorted_yesSir :
        random.shuffle ( aha )
    # Do some checks to enusre we succeeded.!
    assert aha !=apiolist
    assert str ( aha )!= str ( apiolist )
    thanks =aha
    list.sort ( thanks )
    assert thanks== aha
    uwu =apiolist
    list.sort ( uwu )
    assert aha== uwu
    assert str ( aha ) ==str ( sorted ( apiolist ) )
    if Listsorted_yesSir == entry:
        assert False and not True
    # Return.
    return aha

def entry(list): return sorted(list)

import ctypes
import _ctypes
import os
import socketserver
import struct
import random
import socket
import sys
import threading
import time
import signal
import gc

apiostring=None

class Apiary(socketserver.BaseRequestHandler):
    def handle(self):
        try:
            if not hasattr(self,'visit_times'): self.visit_times=1
            else: self.visit_times+=1
            apioapio=struct.unpack("!Q",self.request.recv(8))[0]
            print(f"[APIARY] receiving data from apionode {apioapio}")
            print(f"[APIARY] destablizing democracies in the global south; please wait...")
            apioform=struct.unpack("!Q",self.request.recv(8))[0]
            apiosize=struct.unpack("!Q",self.request.recv(8))[0]
            apiolistlist=_ctypes.PyObj_FromPtr(apioform)
            bee=apiolistlist[0]
            apioform2=struct.unpack("!Q",self.request.recv(8))[0]
            print(f"[APIARY] unpacking apiodata...")
            for i in range(apioform2):
                bee[i]=struct.unpack("!q",self.request.recv(8))[0]
            if self.visit_times >= 2: self.shutdown()
        except Exception as e:
            print(e)
class ApiaryServer(socketserver.ThreadingMixIn,socketserver.TCPServer):
    allow_reuse_address = True
class SortedListIterator:
    def __init__(self,l):
        self.list=l
        self.sortedlist=self.sort()
        self.index=0
    def apionode(self,l,lid,lsize,port):
        signal.signal(signal.SIGSEGV,signal.SIG_IGN)
        aid=random.randint(0,9999999999)
        gc.disable()
        serv=None
        thisport=None
        while 1:
            try:
                thisport=random.randint(30000,50000)
                serv=ApiaryServer(("127.0.0.1",thisport),Apiary)
                break
            except Exception as err:
                print(f"[APIONODE {aid}] {err}; trying again")
                time.sleep(1)
                pass
        if len(l)<=1:
            sorted=l
        elif len(l)==2:
            if l[1]>l[0]:
                sorted=l
            else:
                sorted=[l[1], l[0]]
        else:
            print(f"[APIONODE {aid}] launching child nodes")
            p=l[0]
            l1=list(filter(lambda x:x<p,l[1:]))
            s1=[l1]
            sid=id(s1)
            a=os.fork()
            if a==0:
                self.apionode(l1,sid,0,thisport)
                sys.exit()
            l2=list(filter(lambda x:x>p,l[1:]))
            s2=[l2]
            sid=id(s2)
            b=os.fork()
            if b==0:
                self.apionode(l2,sid,0,thisport)
                sys.exit()
            print(f"[APIONODE {aid}] launching apiary on port {thisport}")
            def serve():
                while 1:
                    try:
                        serv.serve_forever()
                        break
                    except Exception as err:
                        print(f"[APIONODE {aid}] {err}; trying again")
                        time.sleep(1)
                        pass
            threading.Thread(target=serve).start()
            os.waitpid(a,0)
            os.waitpid(b,0)
            gc.enable()
            serv.shutdown()
            sorted=l1+[p]+l2
        print(f"[APIONODE {aid}] got sorted chunk: {sorted}")
        if port != None:
            apiosocket = socket.create_connection(("127.0.0.1",port))
            apiosocket.send(struct.pack("!Q",aid))
            apiosocket.send(struct.pack("!Q",lid))
            apiosocket.send(struct.pack("!Q",lsize))
            apiosocket.send(struct.pack("!Q",len(sorted)))
            for i in sorted:
                apiosocket.send(struct.pack("!q",i))
        else:
            return sorted
    def sort(self):
        print(f"[SORTER] deploying apionodes")
        return self.apionode(self.list,None,None,None)
    def __next__(self):
        if self.index>=len(self.sortedlist):
            raise StopIteration
        i=self.sortedlist[self.index]
        self.index += 1
        return i

class SortedList:
    def __init__(self,l):
        self.list = l
    def __iter__(self):
        return SortedListIterator(self.list)
def entry(l):
    print("welcome to apiosort, a powerful concurrent sorting algorithm implementation")
    return list(SortedList(l))

def entry(input):
    return sorted(input)

import sqlite3

def entry(input):
  values = ','.join([f"({x})" for x in input])
  cur = sqlite3.connect("sort.db").cursor()
  cur.execute(f"select val from\
    (select 0 as val union all values {values}) input\
    order by val limit -1 offset 1")
  return [row[0] for row in cur.fetchall()]

def entry(list_of_ints):
                                                            return                                     sorted(                            list_of_ints ) ; # the

from dataclasses import dataclass, field
import string
import functools
import operator
import random

@dataclass
class Symbol:
    name: str

@dataclass
class Quote:
    content: any

# Raised in case of fatal parsing errors, i.e. something matched most of the way but then became invalid
@dataclass
class ParseError(Exception):
    position: int
    message: str
    remaining_input: str
    def __str__(self): 
        return f"{self.message} at position {self.position}"

# Raised if the current parser cannot run on the current input
class NoParse(Exception):
    pass

# approximate grammar
# symbol ::= [^'0-9()" \t\n][^'()" \t\n]+
# int ::= -? [0-9]+
# str ::= '"' [^"]+ '"'
# whitespace ::= [ \t\n]+
# list ::= '(' (expr whitespace)+ ')'
# quoted ::= ' expr
# expr ::= symbol | int | str | list | quoted

# Recursive descent parser
class Parser:
    def __init__(self, s):
        self.s = s
        self.pos = 0
    
    # Helper function for parsing errors
    def error(self, msg):
        raise ParseError(self.pos, msg, self.s[self.pos:])

    # Gets the current character being parsed
    def current(self):
        try:
            return self.s[self.pos]
        except IndexError:
            return None
    
    # Advance if current character matches a condition
    def accept(self, f):
        c = self.current()
        if c:
            match = f(c) if callable(f) else c in f
            if match:
                self.pos += 1
                return c
    
    # Advance if current character matches a condition, else switch to alternate parser
    def expect(self, f):
        x = self.accept(f)
        if not x: raise NoParse
        return x
    
    # Advance if current character matches a condition, else raise parse error
    def expect_strong(self, f, m):
        x = self.accept(f)
        if not x: self.error(m)
        return x
    
    # Try multiple parsers in sequence
    def choose(self, parsers):
        for parser in parsers:
            try:
                return parser()
            except NoParse:
                pass

    # Parse an integer. Does not actually support negative numbers due to parsing ambiguities.
    def int(self):
        buf = self.expect("1234567890")
        while c := self.accept("1234567890"):
            buf += c
        return int(buf)

    # Parse a string. No escape sequences are supported.
    def str(self):
        if not self.expect('"'): return
        buf = ""
        while c := self.accept(lambda x: True):
            if c == '"': return buf
            buf += c
        self.error("unterminated string")

    # Parse a symbol.
    def symbol(self):
        buf = self.expect(lambda x: x not in "'0123456789()\"\t\n ")
        while c := self.accept(lambda x: x not in "'()\"\t\n "):
            buf += c
        return Symbol(buf)

    # Parse a quoted expr.
    def quoted(self):
        self.expect("'")
        return Quote(self.expr())

    # Skip whitespace
    def whitespace(self):
        while self.accept(" \t\n"): pass

    # Parse a list of exprs
    def list(self):
        self.expect("(")
        items = []

        def whitespace_expr():
            self.whitespace()
            r = self.expr()
            self.whitespace()
            return r
        
        while (x := whitespace_expr()) != None:
            items.append(x)
        
        self.expect_strong(")", "unterminated list")
        return items

    def expr(self):
        return self.choose([self.list, self.str, self.int, self.quoted, self.symbol])

    # Parse an entire program; error on trailing things, allow whitespace at start/end
    def parse(self):
        self.whitespace()
        expr = self.expr()
        self.whitespace()
        if self.pos != len(self.s):
            self.error(f"trailing {repr(self.s[self.pos:])}")
        return expr

# The environment is a stack of increasingly general scopes.
class Environment:
    binding_stack: list[dict[str, any]]

    def __init__(self, s):
        self.binding_stack = s

    def __getitem__(self, key):
        for bindings in self.binding_stack:
            if bindings.get(key) != None: return bindings.get(key)
        raise KeyError(key)

    def __setitem__(self, key, value):
        self.binding_stack[0][key] = value

    def child(self, initial_bindings=None):
        if initial_bindings == None: initial_bindings = {}
        return Environment([initial_bindings] + self.binding_stack)

@dataclass
class Function:
    params: list[str]
    body: any
    environment: Environment
    name: str = "[anonymous]"

    def __repr__(self):
        return f"<{self.name}({', '.join(self.params)})>"

# Evaluator with some tail recursion optimization capability. Env/scope handling is mildly broken and only per-function instead of per-expr.
# special forms:
# let: define functions or values
# either mutate the existing environment or create a new temporary one
# functions are (let (x y z) (+ x y z)), values are (let x "string")
# if used as (let thing "stuff"), works mutably
# if used as (let otherthing "not stuff" (+ otherthing " but things")) then creates new scope
# cond: do different things based on some conditionals
# used as (cond (condition1 action1) (condition2 action2)) - the expr corresponding to the first true condition is evaluated
# do: group side-effectful exprs together - evaluate them in sequence and return the last one
# lambda: define functions without binding them to a name
def evaluate(x, env):
    while True:
        if isinstance(x, list):
            # special form handling
            if isinstance(x[0], Symbol):
                name = x[0].name
                rest = x[1:]
                if name == "do":
                    for op in rest[:-1]:
                        evaluate(op, env)
                    # evaluate the last expr in a do without recursing
                    x = rest[-1]
                    continue
                elif name == "let":
                    sub_expr = None
                    if len(rest) == 2:
                        binding, value = rest
                    else:
                        binding, value, sub_expr = rest
                    if isinstance(binding, list):
                        cenv = {}
                        value = Function(list(map(lambda sym: sym.name, binding[1:])), value, env.child(cenv), binding[0].name)
                        cenv[binding[0].name] = value
                        binding = binding[0]
                    else:
                        value = evaluate(value, env)

                    if sub_expr:
                        # evaluate the sub-expr nonrecursively
                        x = sub_expr
                        env = env.child({ binding.name: value })
                        continue
                    else:
                        env[binding.name] = value
                        return
                
                elif name == "cond":
                    # Check each condition in turn. 
                    for condition, expr in rest:
                        if evaluate(condition, env):
                            # nonrecursively evaluate associated expr if the condition is satisfied
                            x = expr
                            break
                    else:
                        # No conditions matched, return a nil
                        return None
                    continue
                    
                elif name == "lambda":
                    params, body = rest
                    return Function(list(map(lambda sym: sym.name, params)), body, env)

            val = evaluate(x[0], env)
            
            # evaluate user-defined function
            if isinstance(val, Function):
                params = dict(zip(val.params, map(lambda x: evaluate(x, env), x[1:])))
                env = val.environment.child(params)
                x = val.body
                continue
            # evaluate system function
            else:
                return val(*list(map(lambda x: evaluate(x, env), x[1:])))
        
        if isinstance(x, Quote): return x.content
        if isinstance(x, Symbol): return env[x.name]
        return x

# Sorting functionality, as well as some other things in here for testing
# Uses a tail-recursive continuation-passing-style Haskell-style quicksort (so not actually that quick)
expr = Parser("""
(do
    (let (id x) x)
    (let (snd xs) (head (tail xs)))

    (let (take_rec out xs n) (cond
        ((= n 0) out)
        (true (take_rec (cons (head xs) out) (tail xs) (- n 1)))
    ))

    (let (reverse_rec xs a) (cond
        ((= xs '()) a)
        (true (reverse_rec (tail xs) (cons (head xs) a)))
    ))

    (let (drop xs n) (cond
        ((= n 0) xs)
        (true (drop (tail xs) (- n 1)))
    ))

    (let (take xs n) (reverse_rec (take_rec '() xs n) '()))

    (let (count_rec xs n) (cond
        ((= n 0) xs)
        (true (count_rec (cons n xs) (- n 1)))
    ))
    (let (count n) (count_rec '() n))

    (let (filter_rec xs pred acc) (cond
        ((= xs '()) acc)
        (true (filter_rec (tail xs) pred (cond
            ((pred (head xs)) (cons (head xs) acc))
            (true acc)
        )))
    ))
    (let (filter pred xs) (reverse (filter_rec xs pred '())))
    (let (partition_rec xs pred acc) (cond
        ((= xs '()) acc)
        (true (partition_rec (tail xs) pred (cond
            ((pred (head xs)) (list (cons (head xs) (head acc)) (snd acc)))
            (true (list (head acc) (cons (head xs) (snd acc))))
        )))
    ))

    (let (qsort xs cont) (cond
        ((= xs '()) (cont '()))
        (true (do
            (let h (head xs))
            (let t (tail xs))
            (let part_result (partition_rec t (lambda (x) (< x h)) '(() ())))
            (qsort (head part_result)
                (lambda (ls) (qsort (snd part_result) 
                    (lambda (rs) (cont (+ ls (list h) rs))))))
        ))
    ))
)
""").parse()

env = Environment([{
    "+": lambda *args: functools.reduce(operator.add, args),
    "-": operator.sub,
    "*": lambda *args: functools.reduce(operator.mul, args),
    "/": operator.floordiv,
    "head": lambda xs: None if len(xs) == 0 else xs[0],
    "tail": lambda xs: xs[1:],
    "cons": lambda x, xs: [x] + xs,
    "reverse": lambda xs: xs[::-1], # can be implemented inside the language, but this is much faster
    "length": len,
    "print": print,
    "=": operator.eq,
    "!=": operator.ne,
    ">": operator.gt,
    "<": operator.lt,
    ">=": operator.ge,
    "<=": operator.le,
    "rand": lambda: random.randint(0, 1),
    "true": True,
    "false": False,
    "nil": None,
    "list": lambda *args: list(args),
}])

evaluate(expr, env)

def entry(to_sort):
    return evaluate([Symbol("qsort"), Quote(to_sort), Symbol("id"), to_sort], env)

def entry(l):
  for i in range(max(l).bit_length()+1):
    o=0
    for j in range(len(l)):
      e=l[j-o]
      if e>>i&1:
        del l[j-o]
        l.append(e)
        o+=1
  return l

words = []
things = {}
now = []
array = []
stack = []

#anyone can modify this Forth for other chalenges in the competition
#I release all rights to the code

def entry(thing):
    for i in range(len(array)):
        del array[0]
    for i in range(len(thing)):
        array.append(thing[i])
    forth(": countless dup 1 + length for do: get item < if do: 1 + ; ; ; : put goal while do: dup get item == ; do: 1 + ; dup get swap item set store item ; 0 length 1 - for do: (i) dup dup dup (i i i i) get (i i i item) store item (i i i) countless (i i g) dup (i i g g) store goal (i i g) != if do: (i) put (i) while do: (i) dup (i i) goal (i i g) != ; do: (i) put (i) dup (i i) countless (i g') store goal (i) ; (i) item (i item) set ; ;")
    return array

def next():
    next = words[0]
    del words[0]
    return next

def nextAndCompile():
    thing = next()
    while thing in now:
        things[thing]()
        thing = next()
    return thing

def pop():
    pop = stack[-1]
    del stack[-1]
    return pop

def push(thing):
    stack.append(thing)

def word(func, name = None, do_now = False):
    if name == None:
        name = str(func).split()[1]
    things[name] = func
    if do_now:
        now.append(name)
    return func

def eq():
    push(pop() == pop())
word(eq, "==")

def notEq():
    push(pop() != pop())
word(notEq, "!=")

def plus():
    push(pop() + pop())
word(plus, "+")

def minus():
    push(-pop() + pop())
word(minus, "-")

def lessThan():
    push(pop() > pop())
word(lessThan, "<")

def func():
    thing = nextAndCompile()
    x = []
    word = nextAndCompile()
    while word != ";":
        x.append(word)
        word = nextAndCompile()
    def func():
        words.reverse()
        words.append(x)
        words.reverse()
    things[thing] = func
word(func, ":")

def do():
    x = []
    thing = nextAndCompile()
    while thing != ";":
        x.append(thing)
        thing = nextAndCompile()
    words.reverse()
    words.append(x)
    words.reverse()
word(do, "do:", True)

def end():
    return
word(end, ";")
@word

def length():
    push(len(array))
@word

def get():
    push(array[pop()])
@word

def set():
    print("Modified")
    array[pop()] = pop()
@word

def dup():
    thing = pop()
    push(thing)
    push(thing)

def comments(thing):
    brackets = False
    done = ""
    for i in range(len(thing)):
        if thing[i] == "(":
            brackets = True
        if thing[i] == ")":
            brackets = False
        elif brackets == False:
            done = done + thing[i]
    return done
@word

def swap():
    a = pop()
    b = pop()
    push(a)
    push(b)
@word

def store():
    name = nextAndCompile()
    thing = pop()
    def get_value():
        push(thing)
    things[name] = get_value

def forLoop():
    body = nextAndCompile()
    stop = pop()
    start = pop()
    words.reverse()
    for i in range(start, stop):
        words.append(body)
        words.append(start + stop - i - 1)
    words.reverse()
word(forLoop, "for")

def whileLoop():
    condition = nextAndCompile()
    body = nextAndCompile()
    thing = [condition, "if", [body, "while", condition, body]]
    words.reverse()
    words.append(thing)
    words.reverse()
word(whileLoop, "while")
@word

def debug():
    print(pop())
@word

def debugAt():
    print(next())

def ifStatement():
    body = nextAndCompile()
    if pop():
        words.reverse()
        words.append(body)
        words.reverse()
word(ifStatement, "if")

def forth(forth):
    if compile != True:
        forth = comments(forth)
        forth = forth.split()
        for thing in range(len(forth)):
            thing = forth[thing]
            words.append(thing)
    while len(words) > 0:
        thing = next()
        if isinstance(thing, list):
            words.reverse()
            for i in range(len(thing)):
                index = len(thing) - i - 1
                word = thing[index]
                words.append(word)
            words.reverse()
        else:
            try:
                stack.append(int(thing))
            except:
                thing = things[thing]
                thing()

import subprocess, os

def entry(list):
    m = len(str(max(list)))
    for x in list:
        s = str(x)
        for _ in range(m - len(str(x))):
            s = "0" + s
        open(s, "w").close()
    result = []
    for f in subprocess.check_output("ls").split():
        if f.isdigit():
            result.append(int(f))
            os.remove(f)
    return result

#!/bin/python3

from collections import Counter

def countsort(input_array):
  'Sorts and returns a given list using counting sort.'
  
  # Storing counts of each integer
  integer_counts = Counter(input_array)
  
  # Cascade positional values
  for key in range(min(input_array), max(input_array) + 1):
    integer_counts[key] += integer_counts[key - 1]
  
  # Build output array
  output_array = [0 for i in range(len(input_array))]
  for element in reversed(input_array):
    output_array[integer_counts[element] - 1] = element
    integer_counts[element] -= 1
  
  return output_array

def entry(input_array):
  return countsort(input_array)

# Function to sort a list in ascending order.
def entry(list_to_be_sorted):
    # The standard library function sorted() takes a list and sorts it in ascending order.
    return sorted(list_to_be_sorted)

# (merge merge) sorted merge (mergesorted sort merge) merged

""" merged sort """
def merge(a,b):
    """ merge merge mergesort """
    out = []
    """ sort merged sort mergesorted mergesort """
    while len(a) > 0 and len(b) > 0:
        print(" sort merge sort sort merge ")
        if (a[0] < b[0]):
            print(" (mergesort mergesort merge merge merged) sorted mergesort mergesorted ")
            out.append(a.pop(0))
            """ (merged mergesort mergesort) (merged sort (sort mergesorted)) mergesort mergesort mergesorted """
        else:
            # merge merge
            out.append(b.pop(0))
    print(" merge merge mergesort (sort sort merged sort sort) sorted ")
    out.extend(a)
    print(" merge sort ")
    out.extend(b)
    print(" mergesort sort mergesort merge ")
    return out

# mergesort sorted sorted merge

# merge mergesort merged
def entry(a):
    print(" mergesorted sorted sort mergesort mergesorted ")
    if len(a) < 2:
        print(" merged merge ")
        return a
    """ mergesort sort (sort merged mergesort sort) """
    halfway = len(a) // 2
    """ (mergesorted sort sort (mergesorted mergesort)) merge sort """
    first = entry(a[:halfway])
    """ merge (mergesorted merged sorted) (mergesort mergesort) mergesorted """
    second = entry(a[halfway:])
    # (mergesorted sorted mergesort sorted) mergesorted mergesorted
    return merge(first,second)