5s_accuracy.sagews

1+1
reset()
2+2

2 4

from rna_poly import RNAPolytope
from glob import glob
from os.path import basename,splitext,isfile
from datetime import datetime
import pickle
import __main__
from basic_sec_struct import sec_struct
__main__.RNAPolytope = RNAPolytope
load('rna_poly.py')
load('polytope_plots.sage')
load('main.sage')

get_bname = lambda fname:splitext(basename(fname))[0]
def timestamp(message=''):
    return "[{0}] {1}".format(datetime.now(),message)
def load_obj(name):
    with open(name, 'rb') as f:
        return pickle.load(f)
def my_hot(x):
    return colormaps['hot_r'](x/2+0.25)
def my_Greys(x):
    return colormaps['Greys'](x/4+0.5)

_5S_dir='/home/user/data/bio/5S'
_5S_st_tuples_dir = '{0}/st_tuples'.format(_5S_dir)
pkl_names = glob.glob('{0}/*.pkl'.format(_5S_st_tuples_dir))
names= sorted([get_bname(n)[:-3] for n in pkl_names])
sobj_names = ['{0}/sobjs/{1}.sobj'.format(_5S_dir,name) for name in names]

len(sobj_names)

88

from itertools import combinations,chain
from numpy import average as avg, median as med, std
from collections import defaultdict

def get_sobj_name(name):
    return '5s/sobjs/{0}.sobj'.format(name)

def get_suboptimal_ranking(name,P,b):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    region_density = {}
    slices = sliced_cones_b(P, b)
    relevant_signatures = [tuple(sl.original_vertex) for sl in slices]
    max_relevant_subopt = 0
    total_relevant_structs=0
    for k in K:
        #k is a tuple: (a,b,c,d,default_ss)
        #D[k] is a list of (ss,(x,y,z,w,t1,t2,t3,t4,acc))'s
        for S,(x,y,z,w,t1,t2,t3,t4,acc) in D[k]:
            break
        x,y,z,w = (QQ(e) for e in (x,y,z,w))
        if (x,y,z,w) in relevant_signatures:
            n=len(D[k])
            total_relevant_structs +=n
            region_density[(x,y,z,w)] = n
            if n > max_relevant_subopt:
                max_relevant_subopt = n

    for k in region_density:
        region_density[k] /= float(max_relevant_subopt)

    total_structures = sum([len(D[k]) for k in K])
    max_structures = max([len(D[k]) for k in K])
    return region_density, (total_relevant_structs,total_structures), (max_relevant_subopt,max_structures)

def get_average_accuracy_ranking(name):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    avg_accuracy = {}
    max_accuracy = {}
    b_avg = {}
    b_max = {}
    for k in K:
        #k is a tuple: (a,b,c,d,default_ss)
        #D[k] is a list of (ss,(x,y,z,w,t1,t2,t3,t4,acc))'s
        avg_acc = 0
        n = len(D[k])
        max_acc = 0
        #print D[k][0]
        for S,(x,y,z,w,t1,t2,t3,t4,acc) in D[k]:
            avg_acc += acc
            if acc>max_acc:
                max_acc = acc
        avg_acc /= n
        x,y,z,w = (QQ(e) for e in (x,y,z,w))
        avg_accuracy[(x,y,z,w)] = avg_acc
        b_avg[avg_acc] = QQ(k[1])
        max_accuracy[(x,y,z,w)] = max_acc
        b_max[max_acc] = QQ(k[1])
    return avg_accuracy,b_avg

remove_dangles = lambda s: s.replace('<','.').replace('<','.')

def compute_subopt_similarities(name,omit_singletons=True):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    min_accs = {}
    signs = []
    n_subopts = []
    structs={}
    for k in K:
        subopts = list(set([remove_dangles(s[0]) for s in D[k]]))
        n_subopts.append(len(subopts))
        _,(x,y,z,w,_,_,_,_,_) = D[k][0]
        if n_subopts[-1]==1:
            if omit_singletons:
                continue
            min_acc = 1.0
        else:
            min_acc = min([min([f_measure(s,t) for s,t in combinations(subopts,2)]),min([f_measure(t,s) for s,t in combinations(subopts,2)])])
        min_accs[(x,y,z,w)]=min_acc
        signs.append((x,y,z,w))
        structs[(x,y,z,w)]=subopts
    print timestamp("{0}: max_subopts={1}, avg_subopts={2}; std_subopts={3}".format(name,max(n_subopts),avg(n_subopts),std(n_subopts)))
    return min_accs,structs,signs
def get_subopt_structures(name,default_ss,sign=False):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    for k in K:
        ss =  k[4]
        if ss==default_ss:
            if sign:
                S,(x,y,z,w,t1,t2,t3,t4,acc) = D[k][0]
                return [s[0] for s in D[k]],(x,y,z)
            else:
                return [x[0] for x in D[k]]
    #print "Returning no structures?"
    if sign:
        return [], (0,0,0)
    return []
def get_accuracies_from_struct(name,default_ss):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    for k in K:
        ss =  k[4]
        if ss==default_ss:
            return [x[1][-1] for x in D[k]]

def get_accuracies(name,default_ss):
    D = load_obj("{0}/{1}_ss.pkl".format(_5S_st_tuples_dir,name))
    K=D.keys()
    for k in K:
        ss =  k[4]
        if ss==default_ss:
            n = len(D[k])
            return [acc for S,(x,y,z,w,t1,t2,t3,t4,acc) in D[k]]
    return None

classic_pt = (34/10,0,4/10)
common_pt = (489/40, 51/320, -231/80)

def get_classic_slice(P,name):
    classic_slices=[]
    for sl in P.d1_slices():
        if (34/10,0,4/10) in sl:
            classic_slices.append(sl)

    return classic_slices

def classic_slices_and_accuracy(names):
    classic_slices = {}
    accuracies = {}
    for i in range(len(names)):
        name = names[i]
        sobj_name = get_sobj_name(name)

        P =RNAPolytope.construct_from_file(sobj_name)
        classic_slices[name] = get_classic_slice(P,name)
        accs = []
        for sl in classic_slices[name]:
            ss = sl.original_structure
            accs.extend(get_accuracies(name,ss))
        accuracies[name] = accs

    return classic_slices, accuracies

def get_slice_containing_pt(P,pt):
    slices = []
    for sl in P.d1_slices():
        if pt in sl:
            slices.append(sl)
    return slices

def pt_slices_and_accuracy(names,pt):
    slices={}
    accuracies={}
    for i in range(len(names)):
        name = names[i]
        sobj_name = get_sobj_name(name)

        P =RNAPolytope.construct_from_file(sobj_name)
        slices[name] = get_slice_containing_pt(P,pt)
        accs = []
        for sl in slices[name]:
            ss = sl.original_structure
            accs.extend(get_accuracies(name,ss))
        accuracies[name] = accs

    return slices, accuracies



def get_max_average_slice(P,name):
    avg_accuracy, b_avg = get_average_accuracy_ranking(name)
    max_avg_acc = 0
    max_sigs = []
    for sig in avg_accuracy:
        if avg_accuracy[sig]>max_avg_acc:
            max_avg_acc = avg_accuracy[sig]
            max_sigs = [sig]
        elif avg_accuracy[sig]==max_avg_acc:
            max_sigs.append(sig)
    out_slices = []
    for sl in P.d1_slices():
        x,y,z,w = sl.original_vertex
        if (x,y,z,w) in max_sigs:
            out_slices.append(sl)
    return out_slices

def get_neighboring_slices(P,sl):
    neighbors = []
    bounded_nbrs = []
    for s in P.d1_slices():
        if s==sl:
            print "Avoiding self"
            continue
        inter = sl.intersection(s)
        if not inter.is_empty():
            neighbors.append(s)
            if len(inter.rays())==0:
                bounded_nbrs.append(s)
    return neighbors, bounded_nbrs

def f_measure(s,t):
    S = sec_struct(s)
    T = sec_struct(t)
    acc = S.relative_accuracy(T)
    return acc

def get_similarity_matrices(P,name,sl):
    nbrs,bdd_nbrs = get_neighboring_slices(P,sl)
    subopts = {}

    for nbr in nbrs:
        subopts[nbr] = get_subopt_structures(name,nbr.original_structure)

    subopts[sl] = get_subopt_structures(name,sl.original_structure)

    matrices={}
    bdd_matrices={}
    for nbr in nbrs:
        matrix = []
        for s in subopts[nbr]:
            row = []
            for t in subopts[sl]:
                row.append(f_measure(s,t))
            matrix.append(row)
        matrices[nbr] = matrix
        if nbr in bdd_nbrs:
            bdd_matrices[nbr]=minteract
    return matrices,bdd_matrices

def get_neighbors_accuracies(P,name,sl):
    nbrs,bdd_nbrs = get_neighboring_slices(P,sl)
    accuracies={}
    bdd_accuracies={}
    for nbr in nbrs:
        accs = get_accuracies(name, nbr.original_structure)
        matrices[nbr] = accs
        if nbr in bdd_nbrs:
            bdd_accuracies[nbr]=accs
    return accuracies,bdd_accuracies

def neighbors_accuracies(names,pt):
    accuracies = {}
    bdd_accuracies = {}
    for i in range(len(names)):
        print timestamp("{0}".format(i+1)),
        name = names[i]
        sobj_name = get_sobj_name(name)

        accuracies[name]={}
        bdd_accuracies[name]={}

        P =RNAPolytope.construct_from_file(sobj_name)
        slice_list = get_slice_containing_pt(P,pt)
        for sl in slice_list:
            if len(sl.rays())==0:
                accuracies[name][sl],_ = get_neighbors_accuracies(P,name,sl)
            else:
                accuracies[name][sl],bdd_accuracies[name][sl] = get_neighbor_accuracies(P,name,sl)
    return accuracies,bdd_accuracies

def similarity_matrices(names,pt):
    matrices = {}
    bdd_matrices = {}
    for i in range(len(names)):
        print timestamp("{0}".format(i)),
        name = names[i]
        sobj_name = get_sobj_name(name)

        matrices[name]={}
        bdd_matrices[name]={}

        P =RNAPolytope.construct_from_file(sobj_name)
        slice_list = get_slice_containing_pt(P,pt)
        for sl in slice_list:
            if len(sl.rays())==0:
                matrices[name][sl],_ = get_similarity_matrices(P,name,sl)
            else:
                matrices[name][sl],bdd_matrices[name][sl] = get_similarity_matrices(P,name,sl)
    return matrices,bdd_matrices

def get_max_average_slices(names=names):
    slices = {}
    sl2na = {}
    for i in range(len(names)):
        name = names[i]
        sobj_name = get_sobj_name(name)

        P =RNAPolytope.construct_from_file(sobj_name)
        P_slices = get_max_average_slice(P,name)
        slices[name]=P_slices
        for sl in P_slices:
            sl2na[sl] = name
        if len(P_slices)>1:
            print "*"*40
            print "Found more than one max avg slice in {0}".format(name)
    return slices, sl2na

def max_avg_intersection_graph(slices):
    slice_to_label = {sl:i for i,sl in enumerate(slices)}
    label_to_slice = {i:sl for i,sl in enumerate(slices)}
    n = len(slice_to_label.keys())
    G=Graph(n)
    edges = []
    for sl1,sl2 in combinations(slices,2):
        inter = sl1.intersection(sl2)
        # Bug! Change this to inter.is_empty()
        if len(inter.rays())>0 or inter.volume()>0:
            edges.append([slice_to_label[sl1],slice_to_label[sl2]])
    G.add_edges(edges)
    return G,label_to_slice

def greedy_clique_partition(G):
    H=G.copy()
    cliques = []
    while H.num_verts()>0:
        c = H.clique_maximum()
        H.delete_vertices(c)
        cliques.append(c)
    return cliques

def plot_max_avg_acc_slice(name,P,colormap):
    avg_accuracy, b_avg = get_average_accuracy_ranking(name)
    max_avg = max(avg_accuracy.values())
    return accuracy_cone_plots_b(P,avg_accuracy,b=b_avg[max_avg],abounds=(-200,200),cbounds=(-200,200),plot_title=name,colormap=colormap)#.show(figsize=12)

def plot_suboptimal_density_slice(name,P,b=0,colormap=my_hot):
    region_density, totals, maxes = get_suboptimal_ranking(name,P,b)
    title = '{0}; total structs: {1}; max per region: {3}'.format(name, totals[0],totals[1], maxes[0],maxes[1])
    return accuracy_cone_plots_b(P,region_density,b=b,abounds=(-200,200),cbounds=(-200,200),plot_title=title,colormap=colormap)#.show(figsize=12)

def plot_max_avg_slices(names):
    for i in range(len(names)):
        name = names[i]
        sobj_name = get_sobj_name(name)

        P = P=RNAPolytope.construct_from_file(sobj_name)
        plot_max_avg_acc_slice(name,P)

def slice_center(sl,delta=1/2):
    vertex_sum = vector(sl.base_ring(), [0]*sl.ambient_dim())
    for v in sl.vertex_generator():
        vertex_sum += v.vector()
    vertex_sum=vertex_sum / (sl.n_vertices())
    for v in sl.ray_generator():
        vertex_sum += delta*v.vector()
    vertex_sum.set_immutable()
    return vertex_sum

classic = (34/10,0,4/10)
def get_classic_slices(P):
    slices = []
    for i,sl in enumerate(P.d1_slices()):
        if classic in sl:
            slices.append(sl)
    return slices

plot_slice = lambda sl: sum(sl.plot().all[1:])

def get_slice_width_height_depth_intervals(sl):
    from sage.numerical.mip import MIPSolverException
    I = []
    for i in range(3):
        lp,V=sl.to_linear_program(return_variable=True)
        var = V[i]
        lp.set_objective(var)
        try:
            o1 = lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o1 = infinity
            else:
                raise e
        lp.set_objective(-var)
        try:
            o2 = -lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o2 = -infinity
            else:
                print e
        I.append((o2,o1))
    return I

def is_bounded(sl):
    return len(sl.rays())==0
def is_unbounded(sl):
    return len(sl.rays())>0
def is_wedge(sl):
    return len(sl.rays())==2
def is_strip(sl):
    return len(sl.rays())==1

def get_slice_width_height_depth(sl):
    from sage.numerical.mip import MIPSolverException
    I = []
    for i in range(3):
        lp,V=sl.to_linear_program(return_variable=True)
        var = V[i]
        lp.set_objective(var)
        try:
            o1 = lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o1 = infinity
            else:
                raise e
        lp.set_objective(-var)
        try:
            o2 = -lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o2 = -infinity
            else:
                print e
        I.append(o1-o2)
    return I

def get_slice_width_interval(sl):
    return get_slice_width_height_depth(sl)[0]
def get_slice_height_interval(sl):
    return get_slice_width_height_depth(sl)[1]
def get_slice_depth_interval(sl):
    return get_slice_width_height_depth(sl)[2]

def get_slice_width(sl):
    a,b=get_slice_width_interval(sl)
    return b-a
def get_slice_height(sl):
    a,b=get_slice_height_interval(sl)
    return b-a
def get_slice_depth(sl):
    a,b=get_slice_depth_interval(sl)
    return b-a


def get_var_intervals(sl,pt=None):
    if pt is None:
        pt = slice_center(sl)
    elif pt=='classic':
        pt=classic
    from sage.numerical.mip import MIPSolverException
    I = []
    for i in range(3):
        lp,V=sl.to_linear_program(return_variable=True)
        var = V[i]
        lp.set_objective(var)
        for j in range(3):
            if j!=i:
                lp.add_constraint(V[j]==pt[j])
        try:
            o1 = lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o1 = infinity
            else:
                print e
        lp.set_objective(-var)
        try:
            # Check if this should have a negative sign!
            o2 = lp.solve()
        except MIPSolverException as e:
            if str(e).find("unbounded")>-1:
                o2 = -infinity
            else:
                print e
        w = min([abs(o1-pt[i]),abs(o2-pt[i])])
        I.append(w)
    return I

def get_bounded_partitions(sname,pct=False):
    P=RNAPolytope.construct_from_file(sname)
    bounded = defaultdict(lambda:0)
    dirs = 'abc'
    for sl in P.d1_slices():
        if sl.dimension()!=3:
            continue
        rays = sl.rays()
        unb = ''
        for i in range(3):
            unb= unb + (dirs[i] if any([v[i] for v in rays]) else '')

        bounded[unb] += 1
        if unb=='a':
            print timestamp("Unbounded only in a: {0}; {1}; {2}".format(sname, sl.original_vertex, slice_center(sl)))
        elif unb=='c':
            print timestamp("Unbounded only in c: {0}; {1}; {2}".format(sname, sl.original_vertex, slice_center(sl)))
        elif unb=='ab':
            print timestamp("Unbounded only in ab: {0}; {1}; {2}".format(sname, sl.original_vertex, slice_center(sl)))
        elif unb == 'bc':
            print timestamp(sname)

    n = len(P.d1_slices())

    total_bounded = bounded['']
    total_unbounded = n-total_bounded

    if pct:
        for k in bounded:
            bounded[k] *= 100.0/n

    bounded['bounded'] = (100.0*total_bounded)/n
    bounded['unbounded'] = (100.0*total_unbounded)/n

    return bounded

sname = sobj_names[0]

Error in lines 1-1 Traceback (most recent call last): File "/cocalc/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 1009, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> NameError: name 'sobj_names' is not defined

mas = []
n = len(names)
for i,(sname,name) in enumerate(zip(sobj_names,names)):
    stname = "{0}/st_tuples/{1}_ss.pkl".format(_5S_dir,name)
    if isfile(stname):
        P = RNAPolytope.construct_from_file(sname)
        sl=get_max_average_slice(P,name)
        mas.append(sl)
    if i%5==0:
        print timestamp("{0}/{1}".format(i,n))
    #if i == 20:
    #    break

[2017-11-16 12:36:32.685494] 0/88 [2017-11-16 12:38:08.835928] 5/88

save(mas,'max_average_accuracy_slices_5s_1-20.sobj')

mas=load('max_average_accuracy_slices_5s.sobj')

Error in lines 1-1 Traceback (most recent call last): File "/cocalc/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 1009, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> File "sage/structure/sage_object.pyx", line 1089, in sage.structure.sage_object.load (/ext/sage/sage-8.0/src/build/cythonized/sage/structure/sage_object.c:13196) X = loads(open(filename).read(), compress=compress) File "sage/structure/sage_object.pyx", line 1489, in sage.structure.sage_object.loads (/ext/sage/sage-8.0/src/build/cythonized/sage/structure/sage_object.c:15916) return unpickler.load() File "/ext/sage/sage-8.0/local/lib/python2.7/site-packages/sage/geometry/polyhedron/base.py", line 145, in __hash__ return hash((self.dim(), File "/ext/sage/sage-8.0/local/lib/python2.7/site-packages/sage/geometry/polyhedron/base.py", line 1849, in dim if self.n_Vrepresentation() == 0: File "sage/misc/cachefunc.pyx", line 2401, in sage.misc.cachefunc.CachedMethodCallerNoArgs.__call__ (/ext/sage/sage-8.0/src/build/cythonized/sage/misc/cachefunc.c:13462) self.cache = f(self._instance) File "/ext/sage/sage-8.0/local/lib/python2.7/site-packages/sage/geometry/polyhedron/base.py", line 1373, in n_Vrepresentation return len(self.Vrepresentation()) File "/ext/sage/sage-8.0/local/lib/python2.7/site-packages/sage/geometry/polyhedron/base.py", line 1351, in Vrepresentation return self._Vrepresentation File "sage/structure/element.pyx", line 459, in sage.structure.element.Element.__getattr__ (/ext/sage/sage-8.0/src/build/cythonized/sage/structure/element.c:4230) return self.getattr_from_category(name) File "sage/structure/element.pyx", line 472, in sage.structure.element.Element.getattr_from_category (/ext/sage/sage-8.0/src/build/cythonized/sage/structure/element.c:4339) return getattr_from_other_class(self, cls, name) File "sage/structure/misc.pyx", line 299, in sage.structure.misc.getattr_from_other_class (/ext/sage/sage-8.0/src/build/cythonized/sage/structure/misc.c:1933) raise dummy_attribute_error AttributeError: <unprintable AttributeError object>

g,l2s = max_avg_intersection_graph(mas)

Error in lines 1-1 Traceback (most recent call last): File "/cocalc/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 995, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> File "", line 2, in max_avg_intersection_graph File "", line 2, in <dictcomp> TypeError: unhashable type: 'list'

print mas

[[A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 17 vertices and 1 ray], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 41 vertices and 1 ray], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]

for sl in mas:
    print sl

[A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 17 vertices and 1 ray] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [A 3-dimensional polyhedron in QQ^3 defined as the convex hull of 41 vertices and 1 ray] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] [] []

def append_mas(i,mas_list):
    sname=sobj_names[i]
    name = names[i]
    stname = "{0}/st_tuples/{1}_ss.pkl".format(_5S_dir,name)
    P = RNAPolytope.construct_from_file(sname)
    sl=get_max_average_slice(P,name)
    mas_list.append(sl)
    print timestamp("Done!")

mas2 = []
append_mas(0,mas2)

[2017-11-16 12:47:44.536660] Done!

print len(mas2)
append_mas(1,mas2)

1 [2017-11-16 12:48:17.957873] Done!

print len(mas2)
append_mas(2,mas2)

2 [2017-11-16 12:49:00.375359] Done!

print len(mas2)
append_mas(3,mas2)

3 [2017-11-16 12:49:27.295639] Done!

print len(mas2)
append_mas(4,mas2)

4 [2017-11-16 12:49:49.459949] Done!

print len(mas2)
append_mas(5,mas2)

5 [2017-11-16 12:50:14.148979] Done!

print len(mas2)
append_mas(6,mas2)

6 [2017-11-16 12:50:38.948622] Done!

print len(mas2)
append_mas(7,mas2)

7 [2017-11-16 12:51:18.105413] Done!

print len(mas2)
append_mas(8,mas2)

8 [2017-11-16 12:51:52.052390] Done!

print len(mas2)
append_mas(9,mas2)

9

print len(mas2)
append_mas(10,mas2)
︠1dc1dc22-1c79-4071-bba0-eceb40273fcd︠
print len(mas2)
append_mas(11,mas2)
︠1cc01f99-797c-46ae-9c15-8ea5a23b150e︠
print len(mas2)
append_mas(12,mas2)
︠ed56ac94-3204-4606-ad7b-523a5c758134︠
print len(mas2)
append_mas(13,mas2)
︠599b2ac7-32a2-47d1-a269-6c089e2231cf︠
print len(mas2)
append_mas(14,mas2)
︠ea8298de-480a-4eb8-9796-76bc97e58bdd︠
print len(mas2)
append_mas(15,mas2)
︠3da0c6ef-01ad-405e-be5f-bee3d72e8b77︠
print len(mas2)
append_mas(16,mas2)
︠9dfbb826-6486-4598-8e35-6ab39390e2c5︠
print len(mas2)
append_mas(17,mas2)
︠40ab925b-30f8-4d20-81a6-bd34ab8e28c0︠
print len(mas2)
append_mas(18,mas2)
︠65059a29-42fb-410b-887b-164a0e6b2be4︠
print len(mas2)
append_mas(18,mas2)
︠0aae25e2-c106-4f96-b180-dd27ea6f8024︠
print len(mas2)
append_mas(18,mas2)
︠2cb4e88f-572d-4637-ab95-bf7dcced9eb5︠
print len(mas2)
append_mas(18,mas2)
︠5d46669b-f1d9-4848-ae52-a6a262390348︠
print len(mas2)
append_mas(18,mas2)
︠3767ce65-aaa6-432f-a4da-0ec29c807662︠
print len(mas2)
append_mas(18,mas2)
︠0c2cd2b7-a211-4df1-9eb1-5e6668dd4aaa︠
print len(mas2)
append_mas(18,mas2)
︠d1f6dab0-6ec7-44de-bec3-0cabc89979dd︠

︠5420db70-0284-4473-8afc-c7862202eab9︠

︠93a6ce65-8e79-4928-aee5-0a61ed3dd677︠

︠01de13b3-7369-4c83-ad39-9d611922eda5︠

︠913f334a-70f4-483b-b4bd-a5f81107e714︠

︠d39863c7-60f1-49b6-ba3f-c7919a579d59︠

︠10f14fdc-73ff-459b-8a3a-8a93aebc5b85︠

︠6b6518c9-fdfd-4051-a383-9533744bd64c︠

︠0194a18e-5aca-4440-8e84-4a2fc4298fd9︠

︠e5b40e0e-a23c-4ed3-a138-fce2eb53a690︠

︠e25b839e-b185-4fb1-91ab-0d78601be9c1︠

︠592cde63-a858-45ae-be2a-44253508d599︠

︠ebb7fb32-39b2-4592-840e-cc5e1e0a6b16︠

︠b1984930-3cd5-4f5d-961e-38377e1a5d16︠

︠ea2fd1c5-ece3-48eb-ba01-ea56749b7b34︠

︠48e6b400-c2ad-4bbb-86a1-3e2c8e312076︠

︠242f8780-da37-487a-80eb-4a88c3decc59︠

︠a0bd6df9-627b-44b1-b6ee-34d31ed4722b︠

︠2de2448e-0412-4792-a91c-cdee52bd9a3b︠

︠ea43cbdf-8200-4218-937d-2774e1883cd9︠

︠805e3111-9f93-4e96-a6fa-2e35c14e8dc0︠

︠c24e11d0-784d-44e0-941a-6e0b550fb189︠

︠36773643-0bfd-47ed-8eba-8f5b0e6f5617︠

︠8db78bbe-1680-4862-8c64-3ad11aae6859︠
print len(mas2)
append_mas(2,mas2)