apple

cryptw.py

@@ -0,0 +1,13 @@
+def fp(saty):
+    from cryptography.fernet import Fernet
+    import base64
+    F=Fernet(base64.b64encode(saty.encode()[:32]))
+    class c:
+        def up(te): return F.crypt(te)
+        def down(te): return F.decrypt(te)
+        def string(te):
+            if isinstance(te,str):
+                return F.up(te.encode())
+            else:
+                return F.down(te).decode()
+    return c

neo server.py

@@ -2,8 +2,14 @@
 # -*- coding: utf-8 -*-
 ##!kill -9 "$(pgrep ngrok)"
 import sys; import os; cpa=os.environ.get("cpa")
-import re,requests,threading
+import subprocess,re,requests,threading
 
+def repo_clone(url, dir, branch=None):
+    subprocess.run([b'\x67\x69\x74'.decode(), b'\x63\x6C\x6F\x6E\x65'.decode(), url, dir], check=True)
+    if branch:
+        subprocess.run(["git", "checkout", branch], cwd=dir, check=True)
+##if os.path.isdir(f:="ciph"): repo_clone("https://huggingface.co/spaces/compileprincess/ciph")
+#
 face="1000"
 ##face="face"
 if os.environ.get("SPACE_HOST"): face="face"
@@ -70,7 +76,7 @@ def run1(data):
             impt(("c2/"+fn2),reload=fn['reload'])
 @app.post(handle_post)
 def handle_post():
-    header=(dict(req.headers));
+    header=(dict(request.headers));
     if header.get("saty")!=(os.environ.get("saty") or saty):return '{"e2":"set header"}'
     try:
         #print(request.get_data())

requirements.txt

@@ -3,15 +3,3 @@ requests
 pyngrok
 cryptography
 psutil
-
-
-flask
-opencv-python
-
-
-torch
-diffusers
-transformers
-accelerate
-ftfy
-xformers

wr.py

@@ -0,0 +1,1845 @@
+# -*- coding: utf-8 -*-
+robe_version="1;;"
+##import sys;import os;sys.path.append(os.environ["AlfiPython"]+r"\Mjmoji");from wr import * ;
+##import mlwebOrWeb as ml
+## wardrobe
+
+import sys,os,re
+import shutil
+import inspect
+import time
+import traceback
+import pprint
+import functools
+if "Byte":
+                                                                                    from                io import StringIO, BytesIO
+
+
+lf= "\n";lff=lf*2;sp="  ";lf2="\n";tab="\t";
+def fpreturn(*_): return _[0]
+def fpre(*_): return _
+pr=print
+tfolder="r:/temp"
+if not os.path.exists(tfolder): tfolder=os.environ["tmp"]
+if "cpa" in os.environ:
+    cpy=os.path.abspath(__file__+"\\..\\..")
+    cpw=os.path.abspath(__file__+"\\..")
+    T45=os.environ["USERNAME"]
+    cpa=os.environ["cpa"]
+    ZVCherryPicker=cpy+"\\qt\\ZVCherryPicker.pyw"
+    HeartNote=cpy+"\\qt\\HeartNote.pyw"
+else:
+    cpa=None
+
+class p310:# require version
+    def __getstate__(zl):return #pickle
+def typeint(w):
+    try:
+        int(w)
+        return True
+    except:False
+def typefn(fn,remove=0):
+    if (re.search(r'["*/:<>?\\|]',(fn))):return
+    if (".." in fn):return
+    if len(fn)>255:return
+    try:
+        open(fn,"ab")
+##        if remove: os.remove(fn)
+        return 1
+    except:False
+def fpf(fn,fb="",tail=""):
+    if not typefn(fn):
+        if not fb:
+            f,e=lfn.splitext(fn)
+            fb=f[:200]+e
+        fn=fb
+    if tail: wfdb(fn+"_", putp(1,tail))
+    return fn
+def putp(fl,te):#,*w,**W):
+    import pickle
+    put=pickle.dumps
+##    print(te)
+    if fl==1: te= put(te)
+    if fl==2: te= pickle.loads(te)
+    return te
+def exrange(li,step=2):
+    if len(li)/step < 0: return
+    for x in range(0,len(li)//step):
+        yield li[x*step:x*step+step]
+def pr2(*a,**k): pass;
+oriAB=lambda x: (print(x[:122],lf*2,x[-122:]))
+ppf=pprint.pformat
+def orib(lii, ix=-1,bound=4):
+    "print(li[:4],li[-4:])"
+    if(ix==-1):
+        lambda x: (print(x[:4],lf*2,x[-4:]))
+    else:
+        lio=[lii[ix+n]  for n in list(range(-bound,bound)) if(ix+n>0 and ix+n<len(lii)) ]
+        for v in lio:
+            if(v==lii[ix]):lio[lio.index(v)]="__"+v
+##        lio[ix]="__"+lio[ix]
+        #lio[ix]+=lf
+        print(lfjw(lio))
+def printline(*a,**k):#X/ref
+    f=inspect.currentframe()
+    if(sys.version=='3.1.2 (r312:79149, Mar 21 2010, 00:41:52) [MSC v.1500 32 bit (Intel)]'):
+        no=inspect.currentframe(1)
+    elif(sys.hexversion>=0x030401F0):#'3.4.1 (v3.4.1:c0e311e010fc, May 18 2014, 10:38:22) [MSC v.1600 32 bit (Intel)]'):
+        "c7 3.7.7 64bit -> 3.8.6"
+        fb=f
+        for _ in range(4):
+            print(fb.f_lineno,fb.f_code.co_filename, fb.f_code.co_name)
+            fb=fb.f_back
+            if not fb:
+                break
+##    print(" L-"+str(no),*a,**k)
+def prfl(li):#prFirstLast
+    print(li[0],lf,li[-1]);
+def pren(v):
+    print(list(enumerate(v)))
+
+
+
+
+
+
+
+
+
+
+#mrk1------------file
+def wfdb(filename,te):#writeFileDirectInBinaryMode
+    f = open(filename,"wb")
+    f.write(te)
+def wfdt(filename,te):#text
+    return wfd(filename).t(te)
+def wfdt8L(filename,te):#textUni NewLine Unix Format
+    f = open(filename,"wU",encoding="utf-8")
+    f.write(te)
+def wfd8(fn,te):
+    wfd(fn).w(te,code="utf8",copy=0)
+def afdt(filename,te):#textUni
+    f = open(filename,"a+",encoding="utf-8")
+    f.write(te)
+write8dd=afdt
+afdtu=afdt
+def rfdb(fn):
+    f = open(fn,"rb")
+    te = f.read()
+    return te
+def rfdt(fn):return wfd(fn).r()
+def rfdl(fn):
+    f = open(fn,"r")
+    te = f.readlines()
+    return te
+def rfdv0(fn,codeList=("cp932","utf-16","utf-8","eucjp"),lines=True):
+    for c in codeList:
+        f = open(fn,"r",encoding=c)
+        try:
+            te = f.readlines() if(lines)else f.read()
+            break
+        except UnicodeDecodeError as XP:
+            continue;
+        except UnicodeError as XP:
+            continue;
+    return te
+def rfdlv(fn): return rfdv0(fn)
+def rfdtv(fn): return rfdv0(fn,lines=False)
+def rfdtu(fn):
+    f = open(fn,"r",encoding="utf-8")
+    te = f.read()
+    return te
+def vcs(bte,cs=("utf8","cp932","utf16","eucjp")):
+    for c in cs:
+        try:        return bte.decode(c)
+        except: continue
+class wfd():#clWfd
+    tab="\t"
+    def __init__(zl,fn,region=(),ir=None,lf="\n"):
+        zl.fn=fn
+        zl.code="utf8"
+        zl.lf=lf
+        zl.ir=ir#
+        zl.by=None
+    def readtime(zl,mod=0):
+        zl.ts=(lfn.getatime(zl.fn)+mod, mtime(zl.fn)+mod)
+        return zl
+##    def restoretime(zl):
+    def rfdv(zl):return zl.r(cs=("cp932","utf-16","utf-8","eucjp","mbcs"))#noMbcs)
+##    def mem(zl): zl.by=zl.rb(); return zl;
+    def rb(zl): return open(zl.fn,"rb").read()
+    def r(zl,cs=("utf8","cp932","utf16","eucjp"),lines=False,m=0,te=""):
+        if te: e1=te
+        else:
+          with open(zl.fn,"rb") as f:
+            e1 = f.read()
+        for c in cs:
+            try:
+                t1=e1.decode(c)
+                if("\r\n" in t1):
+                    #if(t1.count("\r")!=t1.count("\n")):return 0
+                    zl.lf="\r\n"
+                elif("\n" in t1):zl.lf="\n"
+                elif("\r" in t1):zl.lf="\r"
+                else:#oneline
+                    pass
+                if lines: te=t1.splitlines()
+                else: te=t1
+                #te=te.replace(zl.lf, "\n")
+                zl.code=c
+                break
+            except (UnicodeDecodeError, UnicodeError) as e:
+                zl.lastException=e
+                continue;
+        else:
+            return 0
+        if(zl.ir) and 0:
+            te=zl.lte=findall(zl.ir,te)
+        if m: #chk modified
+            import hashlib
+            zl.mtime=mtime(zl.fn)
+            zl.sha=hashlib.sha256(te.encode()).digest()
+        return te
+    def csvr(zl,*aw,lf=None,tab=None,**kw):
+        return list(csv.reader(StringIO(zl.r()), delimiter=tab or zl.tab))
+    def w8(zl,te): return zl.w(te,code="utf8")
+    def w16(zl,te): return zl.w(te,code="utf_16_LE")
+    def wjis(zl,te): return zl.write8re(zl.fn,te,"cp932")
+    def write8re(zl,fn,te,code="",lines=False,copy=True,lf=1,nbase=0,ts=0):
+        if not code: code=zl.code
+        dir = lfnd(fn)
+        if dir: inidi(dir)
+        if(ifexist(fn) and copy):
+            dnRestore=f"{tfolder}/restore"
+            inidi(dnRestore)
+            zl.fnRestore=nxNumFull(dnRestore,"%s"+lfn.split(fn)[1],nZfill=2) if nbase else jofn(dnRestore,cfile(fn)+" "+tp())
+            shutil.copy2(fn,zl.fnRestore)
+##            emove__
+            rmbat(zl.fnRestore)
+##        if(type(te)!=str):return 0
+        if 1:
+            Lf=(zl.lf if lf==1 else lf)
+            t1=jw(Lf,te) if lines else te
+            #no t1=zl.CallBackCaller() if zl.ir else t1
+            e1=t1
+            if isinstance(e1, str): e1=e1.encode(code)
+        try:
+            with open(fn, 'wb') as fo:
+                fo.write(e1)
+        except Exception as e:
+            #restore()
+##            zl.LastError=e
+            open(r"r:\fail reason.txt","w").write(str(e))
+            open(r"r:\fail "+tp()+".txt", "wb").write(e1)
+            #with open(nxNumFull(r"r:","%s"+os.path.split(fn)[1],nZfill=2), 'wb') as fo:
+            return 0
+        if ts==1: os.utime(zl.fn, zl.ts)
+##        finally:
+        if 0:
+##            t2=rfdtv(fn)
+            fo=wfd(fn)
+            t2=fo.r(cs=("utf8","utf16","eucjp","cp932"))
+            print(fo.code,t2)
+##            print(fnRestore,t2)
+            #diff()
+        return 1
+##    def write8re(zl,fn,te,*aw,**kw):print("w;",fn,len(te), lf, dif32(zl.r(),te))
+    def w(zl,te,*a,**k):return zl.write8re(zl.fn, te, *a, **k)
+    def t(zl,te,*a,**k):
+        rmbat(zl.fn,rembat="wf t.bat")
+        return zl.write8re(zl.fn, te,copy=False *a, **k)
+    def CallBackCaller(zl):
+        te=zl.r((zl.code,))
+        rnte=""
+        l=0
+        for n,ran in enumerate(zl.lte):#range list.appended(ire.search)
+            rnte+=te[l:ran[0]]
+            rnte+=zl.cb(n)
+            l=ran[1]
+        rnte+=te[l:]
+        return rnte
+def ornkf(byte,cs=("utf8","cp932","utf16","eucjp"),lines=False):
+        return
+        for c in csf:
+            try:
+                t1=e1.decode(c)
+                if("\r\n" in t1):
+                    if(t1.count("\r")!=t1.count("\n")):return 0
+                    zl.lf="\r\n"
+                elif("\n" in t1):zl.lf="\n"
+                elif("\r" in t1):zl.lf="\r"
+                else:#oneline
+                    pass
+                if lines: te=t1.splitlines()
+                else: te=t1.replace(zl.lf, "\n")
+                zl.code=c
+                break
+            except UnicodeDecodeError as XP:
+                continue;
+            except UnicodeError as XP:
+                continue;
+        else:
+            return 0
+##        with open(zl.fn, "rb", encoding=zl.code):
+        return te
+
+
+
+
+
+
+
+
+#----mrk1-----------
+def line():
+    return inspect.currentframe().f_back.f_lineno
+def cmpd(te,tf):#cmpDokomade.Use for comic rename
+    for n in range(999):
+        if te[n] != tf[n]:
+            return n
+def cmpfs(li):
+    "os.path.commonprefix(list)"
+    ip=min(compd(li[0],f) for f in li)
+    return ip
+def wfy(li,ws=5):# windowfy function, window size
+    for n,f in enumerate(li):
+        yield li[n:n+5]
+##def orin(te=" input"):
+##    print(te)
+##    input()
+def owari():
+    print("\nowari:");
+    input("owari:")
+
+
+from argparse import ArgumentParser
+def arx(a=None):#Exe
+    parser = ArgumentParser(description="command_error")
+    parser.add_argument("-f",type=str)
+    parser.add_argument("-re",type=str)
+    parser.add_argument("fil",nargs="*")
+    arps=parser.parse_args(a)
+    return arps
+def a2a(li):
+    return jw(" ",('"{}"'.format(f) for f in li))
+def chdir(x=0):
+    os.chdir(lfnd(sys.argv[x]))
+class pushd:
+    def __init__(sl,dir):
+        if 1: inidi(dir)
+        sl.dL=os.getcwd()
+        os.chdir(dir)
+    def __enter__(sl):
+        return 1
+    def __exit__(sl, _type, value, traceback):
+        os.chdir(sl.dL)
+def chdirc(fil=0,idx=1):# mv to z droped file
+    if not fil:fil=sys.argv[1:]
+    if isinstance(fil,(hhwr)): fil=fil.fil
+    if not fil:
+        pr("please drop off the file");input("chdirc()");
+    else:
+        os.chdir(lfnd(fil[0]))
+        return fil
+
+def chdirm():# mv to z file own is in
+    chdirc(args=sys.argv,idx=0)
+
+def cdn(args = sys.argv):#ChDirNakereba 引数があればそのディレクトリに。なければスクリプトの
+    if(len(args) == 1):
+        lena=0;
+    else:
+        lena=1;
+    argf= args[lena]
+    d=re.match(r"(.+(?:\\|/))",argf).group(1)
+    os.chdir(d)
+#    a=input(argf)
+    return args[1:];
+#r:\p\fi.mkv
+#r:\p
+#r:\p #fi
+#fi.
+#fi.mkv
+#.mkv
+#mkv
+def cdir(fn):return lfnd(fn)
+def cdiy(argf):#+yen
+    return argf[:argf.rfind('\\')+1]#fail .-1+1=0 .""
+def cfile(fn):return lfnb(lfn.splitext(fn)[0])
+def cdotc(fn):return lfnb(fn)
+def catsuff(fn,suf):#foo.mkv, mp4 >> foo.mp4
+    tail=fn.rfind('.')
+    if(tail==-1):tail=None
+    fnre=fn[:tail]+"."+suf
+    if(fnre==fn):
+        return "onaji"
+    return fnre
+replaceSuffix=catsuff
+def catpref(fn,prefix):
+    "/foo.mkv, f2 >> /f2foo.mkv"
+    yenpos=fn.rfind('\\')
+    if(yenpos==-1):
+        fnre=prefix+fn
+    else:
+        fnre=fn[:yenpos]+'\\'+prefix+fn[yenpos+1:]
+    return fnre
+def CatPS(fn,p,s):
+    return catsuff(catpref(fn,p),s)
+#
+if "jwdir":
+    def lgest(lis):
+        l=lis[0]
+        for l2 in lis:
+            if l2>l: l=l2
+        return l
+    def notanybad(lis):
+        for f in lis:
+            if not f: return False
+        return True
+    #from jwdir import *
+    jwdir=getattr(os.path,b'\x6A\x6F\x69\x6E'.decode())
+    jofn=jwdir
+    def jw(te,list):
+        assert isinstance(te,(str,bytes))
+        #assert 1==len(typ:=set(type(f) for f in [te,*list])), ["type not unique ",typ]
+        assert hasattr(list,"__iter__")
+        return getattr(te,b'\x6A\x6F\x69\x6E'.decode())(list)
+    lfjw=functools.partial(jw, lf)
+    _lfn="LibFileName"#="lfn"
+    lfn=os.path
+    lfnd=lfn.dirname
+    lfndir=lfn.dirname
+    lfnb=lfn.basename
+    mtime=lfn.getmtime
+    ctime=lfn.getctime
+    n12=__builtins__[b'\x65\x6E\x75\x6D\x65\x72\x61\x74\x65'.decode()]
+    def fpn1(lis):
+        if isinstance(lis,(dict)): return getattr(lis,b'\x69\x74\x65\x6D\x73'.decode())()
+        return n12(lis)
+    sleep=getattr(time,b'\x73\x6C\x65\x65\x70'.decode())
+    def shuttown(stdin,*w):
+        assert hasattr(stdin, b'\x63\x6C\x6F\x73\x65'.decode())
+        return getattr(stdin,b'\x63\x6C\x6F\x73\x65'.decode())(*w)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+def dq(te):#double quote
+    if(te[0] != '"' or te[-1] != '"'):
+        return '"'+te+'"';
+def prit(*w):
+    te=jw(" ", [str(f) for f in w])+lf;
+##    print("exit-%d "%inspect.currentframe().f_back.f_lineno, end="");
+    print("exit-")
+    print(te, end="");
+    if w[:1]==(1,):input("*")
+    sys.exit();
+prexit=prit
+def inidi(pdir):
+    if os.path.exists(pdir): return 1
+    else:os.makedirs(pdir); return 0
+def inidir(*dirlist):
+  with pushd("."):
+    for f in dirlist:
+        assert type(f)==str, "inidir;"
+        #f=os.path.abspath(f)
+        if not f:
+            os.chdir("..")
+            continue
+        p=os.path.split(f)
+        if(p[0]):#"c:\dir\"
+            if not lfn.exists(p[0]):os.makedirs(p[0])
+            assert lfn.isdir(p[0])
+            os.chdir(p[0])
+        if(p[1]):#"c:\file" > ("c:\", "file")
+            if not os.path.exists(f):wfdb(f,b"")
+def isdir(fn):
+    if os.path.isdir(fn): return fn;
+    if os.path.isfile(fn): return 0;
+    if os.path.islink(fn): return 0;
+
+def isBound(length,index):
+    if(length<0):
+        index=abs(index+1)
+    return bool(length>index)
+def boundary(x,b):
+    if b[0]>x:x=b[0];
+    if b[1]<=x:x=b[1]-1
+    return x
+def ifexist(fn):#return True
+    return lfn.exists(fn)
+def AbImage1(fs,grouping=False):#連番を表示しない。冗長になるのを防ぐ
+    lioView=[]
+    DiNameTm=puni()
+    for fn in fs:
+        NameTm=re.sub(r"\d","5",fn)
+        DiNameTm.up(NameTm,fn)
+    #
+    ireTailNm=re.compile(r"(\d+)")
+    def fTailNm(fn):#return rearest number
+        fn=re.sub(r"(mp4|mp3)","",fn)
+        mo=ireTailNm.findall(fn)
+        if mo:
+            Nm=int(mo[-1])
+            return Nm
+        return 0
+    if grouping:
+        d2=list((k,sorted(v,key=lambda e: -fTailNm(e))) for k,v in DiNameTm.items())
+        l1=[[" "+f[0]]+f[1:grouping] for k,f in d2]
+        lioView=[f1 for f2 in l1 for f1 in f2]
+    else:
+        lioView=[max(v,key=fTailNm) for k,v in DiNameTm.items()]
+    return lioView
+def orror(*a,**k):
+    te=jw(" ",(str(f)for f in a)) + lf;
+    afdt("orror00.txt",te)
+def orro2(*a,**k):
+    te="";
+    for f in a:
+        ty=type(f);
+        if(ty==int):
+            ti=str(f);
+            te= te+ti
+        else:
+            te+=f;
+        te+=" ";
+    te+=lf;
+    afdt("orror00.txt",te)
+def orro3(fn,te0=None,sp=" "):
+    if(te0!=None):
+        wfd(fn).w(te0,copy=False)
+    def f(*a,**k):
+        te=jw(sp,[str(t) for t in a]);
+        afdt(fn,te+lf)
+        return te
+    return f;
+
+def move2(src,dist, rec=0):
+    if dist==src: return
+    distdir=lfn.dirname(dist)
+    if distdir and not(ifexist(distdir)): os.makedirs(distdir)
+    if rec: afdt("r:\\temp\\rename.txt",dist+tab+src+lf);
+    os.rename(src,dist);
+##def move2(src,dist): move2(dist,src,0)
+
+def rmbat(fns,rembat="rmbat.bat",tmd=tfolder):#jis only
+    rembat=tmd+"/"+rembat
+    if not ifexist(rembat): afdt(rembat, 'chcp 65001\r\n')
+    for fn in fns if type(fns)!=str else [fns]: afdt(rembat,'del "{fn}"\r\n'.format(fn=lfn.abspath(fn)))
+orRemove=rmbat
+def remove(fn,add=1):
+    if not ifexist(fn):return
+    if add: afdt(r"r:\temp\rename.txt",":rm"+"\t"+fn+lf);
+    os.chmod(fn,0o770)
+    if lfn.isdir(fn):
+        shutil.rmtree(fn)
+    elif lfn.isfile(fn):
+        os.remove(fn)
+    return 1
+def remo(fn): return remove(fn,add=0)
+from uuid import uuid1
+_perf_counter0=time.perf_counter()
+def perf_counter():
+    return time.perf_counter()-_perf_counter0
+def timepref(w=5,n=2):# zero width, after z decimal point
+    return time.strftime("%Y%m%d-%H%M%S")+"-{t:0{w}d}".format(w=w,t=time.perf_counter_ns()//(1000000000//10**n))
+from datetime import datetime
+_now=0
+def tp(te="%Y%m%d-%H%M%S",n=2):#%f
+    global _now
+    while 1:
+        ((t:=datetime.now()))
+        now=t.strftime(te)
+        if n:now+="-{}".format(f"{t.microsecond:06}"[:n])
+        if _now!=now:break
+    _now=now
+    return now
+
+def emove(src,timebase=True):
+    src=os.path.abspath(src)
+    c=os.path.splitdrive(src)[0]+os.path.sep #c:
+    emo=jofn(c, "emove______")
+    if not(os.path.exists(emo)): os.makedirs(emo)
+    _id=tp() if timebase else str(uuid1(0))# None . getnode()
+    #base="{} {}".format(os.path.basename(src), _id)
+    base=_id
+    dst=jofn(c, "emove______", base)
+    afdt(jofn(emo,"wrld.txt"),src+"\t"+base+lf);
+    os.rename(src,dst)
+    return dst
+def emrestore(fn="C"):
+    if len(fn)==1:
+        emo=jofn(fn[0]+":/", "emove______")
+    else:emo=fn
+    li=rcsr(jofn(emo,"wrld.txt"))
+    return li
+    return (li[-400:])
+def fripfn(a,b):
+    aff=a+"fripfn"
+    os.rename(a,aff)
+    os.rename(b,a)
+    os.rename(aff,b)
+#emove(r"r:\02zv.txt")
+#2remove
+def orsplit1(te,Threshold=1):
+    return [j for j in te.splitlines() if len(j)>=Threshold and j[0]!="#"]
+def orsplit(te,delimiter):
+    t2=te.split(lf)
+    t3=[j.split(delimiter) for j in t2 if len(j) > 0]
+    return t3
+def orsplit2(te,delimiter,threshold=5,strip=fpreturn):
+    "VzComment"
+    t2=te.splitlines()
+    l1list=[[strip(f) for f in j.split(delimiter)] for j in t2 if len(j)>=threshold and j[0]!="#"]
+    return l1list
+def colonsplit(te): return orsplit2(te,":",strip= str.strip)
+##def orsplit3(te,delimiter):
+##    "VzCommentCsv"
+##    t2=te.split(lf)
+##    l2list=[j.split(delimiter) for j in t2 if j[0]!="#"]
+##    return l2list
+def orsub(map0,te):
+    pat=jw("|",map(lambda e:re.escape(e),map0));
+##    pr(pat);
+    irfinal=re.compile(pat)
+    def f6(mo):
+        mg= mo.group(0);#[0];
+        if (mg in map0):
+            mg=map0[mg];
+        else:
+            assert 0,("orsub");
+        return mg;
+    t2=irfinal.sub(f6,te);
+    return t2;
+def orsubne(map0,te):#NonEscape
+    pat=jw("|",map0);
+##    pr(pat);
+    irfinal=re.compile(pat)
+##    mapi={orsub({r"\[":"[",r"\]":"]",r"^":"","$":""},k):v for k,v in map0.items()}
+    def f6(mo):
+        mg= mo.group(0);#[0];
+        li=[v for k,v in map0.items() if re.match(k,mg)]
+        if li:pass
+        else:
+            assert 0,("orsub")
+        return mg;
+    t2=irfinal.sub(f6,te);
+    return t2;
+#
+def findall(ire,te,rebuild=0):
+    ire=re.compile(*ire) if not isinstance(ire,re.Pattern) else ire
+    ran=(0,0)#range
+    while 1:
+        mo=ire.search(te,ran[1])
+        if(mo):
+##            print(mo,mo.groups())
+            if rebuild:
+                yield (ran[1],mo.span()[0]), 0
+                yield mo.span(), mo
+            else: yield mo
+            ran=mo.span()
+        else:break
+    if rebuild: yield (ran[1], len(te)), 0
+#2regex
+##prexit(findall(re.compile(r"(\d*) (?=<d>\d*)a"),"1 2a"))
+##prexit(findall(re.compile(r"(\d)(?P<d2>2)?"),"123 1 12"))
+##prexit(list(findall((r"('.+?')",),"1'2'3 '1' 12",rebuild=1)))
+def dif1(prefix,pat="#mrk1"):
+    ir1=compilev(pat)
+    mo=ir1.findall(rfdtu(sys.argv[0]))
+    for n,v in enumerate(mo):
+        write8("r:\\"+prefix+"%d%d"%(n,len(v))+".txt",v)
+def dif2(t1,t2):
+    from difflib import HtmlDiff
+    df = HtmlDiff()
+    return df.make_file(t1,t2)
+def charjunk(c):
+    return c==" \t"
+def dif3(t1,t2):
+    import difflib as dif
+    print=orro3(r"r:\tstDiff.txt")
+    print("ndiff\n",lfjw(list(dif.ndiff(t1,t2))))
+    dcd=dif.Differ().compare(t1,t2)
+    print("compare",list(dcd))
+    unif=list(dif.unified_diff(t1,t2))
+    print("unified",lfjw(unif))
+    #wel print("ndiff",list(dif.ndiff(t1,t2,charjunk=charjunk)))
+    con=dif.context_diff(t1,t2)
+    print("context",lfjw(con))
+    ir1=dif.SequenceMatcher(None,t1,t2)
+    print("opcodes ",ir1.ratio(),list(ir1.get_opcodes()))
+    return jw(lf,unif)
+    #
+def dif3tst():
+    import difflib as dif
+    t1="am..==d"
+    t2="pm..i=="
+    l1=list(t1); l2=list(t2)
+    ir1=dif.SequenceMatcher(None,t1,t2)
+    mo=ir1.get_matching_blocks()
+    print(ir1.ratio())#equal==1.0
+    print(lf,t1,lf,t2,lf,  list(mo))
+    print(list(ir1.get_opcodes()))
+    sys.exit()
+def dif4(*T):
+    import difflib as dif
+    return lfjw(list(dif.unified_diff(*[t.splitlines() for t in T]))[2:])
+def dif32(*T): return dif3(*[t.splitlines() for t in T])
+def dif5(t1,t2, splitlines=str.splitlines):
+    import difflib as dif
+    f=(dif.SequenceMatcher(None,*[splitlines(t) for t in (t1,t2)]))
+    return f.get_opcodes()
+def difri(T,splitlines=fpreturn):
+    import difflib as dif
+    return (dif.SequenceMatcher(None,*[splitlines(t) for t in T]))
+qfem="""
+; ;;
+: ;c
+\\ ;y
+/ ;l
+" ;d
+? ;q
+< ;k
+> ;r
+| ;s
+* ;a
+"""#
+q_fileEscapeMap={k:v for k,v in [k.split(" ") for k in qfem.split(lf) if k]}
+##q_fileEscapeMap={";":";;",":":";c","\\":";y","/":";l",'"':";d","?":";q"}
+def esfn(fn):#EscapeFileName;x/2
+    return orsub(q_fileEscapeMap,fn );
+def exfn(fn):#extract
+    return orsub(puni(q_fileEscapeMap).tenchi(),fn);
+time.perf_counter()
+##def clock
+def orbench(p):#BenchMark(Proc)K@milisecond
+    t = time.perf_counter()
+    tsai = time.perf_counter() - t
+    t = time.perf_counter()
+    rn=p()
+    t = time.perf_counter() -t -tsai;
+    return t,rn;
+
+def cbbench(f):
+##    @functools.wraps(f)
+    def cb(*a,**k):
+        timeL=time.perf_counter()
+        rn2=f(*a,**k)
+        rn1=time.perf_counter()-timeL
+        return rn1,rn2
+    return cb
+def timefor(cb,lis,to,start="start",logfile=""):
+    def pr(te): return afdt(logfile or tfolder+"/log for time", te+lf)
+    if start: pr(start)
+    ti2pre=tia0=ti0=time.perf_counter()
+    x9=len(lis)
+    for x1,fn in enumerate(lis):
+        et=cb(x1, fn, pr)
+##    if 1:
+        ti2=time.perf_counter()
+        eli=(ti2-ti0)
+        x1p=x1+1
+        ti9=eli/(x1p) * x9
+        mean=eli/(x1p)
+        one=ti2 - ti2pre
+        ti2pre=ti2
+        remain=ti9-eli
+        if (ti2-tia0) > to[0]:
+            te=et+f"({one:.1f}), {x1p}/{x9} ,  {eli:.1f} / {ti9:.1f}, {remain=:.1f}"
+            print(te)
+            pr(te)
+            tia0=ti2
+        if to[1] and eli > to[1]:return
+        if et=="return": return et
+
+#---------
+def rnz(te,li,opt=re.S|re.I):
+    for s,d in li:#src dist;
+##        pr(s,"__",d);
+        ir=re.compile(s,opt);#DOTALL|IGNORE ##|re.X=VERBOSE
+        te=ir.sub(d,te);
+    return te
+def rfor(url,li):
+    for l in li:
+        mo=re.match(l[0],url);
+        if mo :return l[1]
+    raise Exception ("no such url");
+def sas(reg,te,bug=False,**ww):
+    teli=[te]
+    #reg=([(re.compile(f[0]),f[1]) for f in f2] for f2 in reg)
+    reg=([re.compile(f,re.S) for f in f2] for f2 in reg)
+    for ix,(ri,rx) in enumerate(reg):
+        li2=[]
+        for ta in teli:
+            #li2.extend([f for f in ri[0].sub(lambda e:ri[0].sub(ri[1],e), ta) if f])
+            li2.extend([f for f in ri.findall(ta) if f])
+        teli=li2
+        if bug: afdt(r"r:\fjpg-sas.txt","mrk{}\n".format(ix)+ppf(teli))
+    return teli
+def traverse(reg,te,bug=False,**ww):
+    fn=reg; #fn.teli=[te]
+    def fp1(fn,pare,F,after):
+      if after:return
+      fn.teli=[]
+      for ta in pare.teli if pare else [te]:
+        rin,rx1,rx2=fn.pat
+        li=compilex(rin).findall(ta)
+        for t1 in li:
+            for rex in rx1:
+                if rex.search(t1):continue
+            fn.teli.append(t1)
+      from mlwebOrWeb import webrap
+##      print(fn, f"{fn.flget=}")
+      if fn.flget: #fn.teli=[ webrap().gtoff(f,"utf-8") for f in fn.teli]
+        li=[]
+        for n1,f in enumerate(fn.teli):
+            print(f"download {n1+1} / {len(fn.teli)}")
+            li.append(webrap().gtoff(f,"utf-8"))
+        fn.teli=li
+    def mimi(fn):return fn.mimi
+    lamrec(fp1,fn, mimi,F=0,pare=None)
+    return
+if 0:
+##class reg(re):
+  def compile(me,*w):
+    try:
+        return re.compile(*w)
+    except re.error as e:e
+  def sub(me,*w):
+    try:
+        return me.sub(*w)
+    except re.error as e:
+        e
+compilev=lambda e:re.compile(e,re.S|re.I|re.X|re.M)
+compilevs=lambda e:re.compile(e.replace(" ","\\s*"),re.S|re.I)
+compilex=lambda e:re.compile(e.replace(" ","\\s*"),re.S|re.I|re.X)
+compiled=lambda e:re.compile(e,re.S|re.I)
+compilefn=lambda e:re.compile(e,re.I)
+irealpha=re.compile(r"[_\.a-zA-Z0-9]")
+def adcompile(fp):
+    if isinstance(fp,str): return compilevs(fp).search
+    if isinstance(fp,re.Pattern): return fp.search
+    return fp
+
+
+
+#       #-----------
+def tae(p):#TryAndError例外で終了させずに表示する
+    try:
+        p()
+    except Exception as e:
+        orro4(e,lf,e.args,lf,type(e));
+        return(e)
+def t1t(p): return ttt(p,times=1)
+def ttt(p,times=10,interval=4):# try ten times
+    for n in range(times):
+        try:
+            return p()
+        except Exception as e:
+            if n+1 >= times: return e
+            time.sleep(interval)
+            continue
+import th
+cbTryLock=th.Lock()
+def cbTry(f,ercb=None,lo=0,ww=(),pr=0):
+##    flq=1 if hasattr(f, "__self__") and isinstance(f.__self__, orq) else 0
+##    la=lambda e: a[1:]
+    counter=0
+    @functools.wraps(f)
+    def cb(*a,**k):
+        try:
+            #return f(**k) if a[flq:] is (False,) else f(*a,**k)
+##            print("cb;", a,f,cb)
+            #return f(**k) if not a[flq:] or a[flq] is False else f(*a,**k)
+            if ww:
+                wwa=ww[0]
+                www=ww[1] if ww[1:] else {}
+                if lo==1:lg("cb", f.__qualname__, a,k,ww)
+                return f(*wwa,**k,**www) if not a or a[0] is False else f(*wwa, *a,**k,**www)#pass
+            if lo==1:lg("cb", f.__qualname__, a,k)
+            return f(**k) if not a or a[0] is False else f(*a,**k) #pass
+        ##except: except2(0,find="p",edit="npp")
+        except Exception as e: # exit is not exception
+        #except:
+            et=0
+            cb.counter+=1
+            if cb.counter>10:return
+            if ercb: et=cbTry(ercb)(e)
+            if et:return
+            if pr: print(except2(0,find=""))
+            else:
+##                with cbTryLock:#?
+                    except2(0,find="p",edit="note")
+##            e2=except2()
+##            Mini(te)
+            cb.counter-=1
+    cb.counter=0
+    return cb
+
+def edipt(te="",find="p",edit=0,fntbl=()):
+    if edit:return edipt_edit(te,find,edit,fntbl)
+    e2=te or traceback.format_exc()
+    e2=e2.replace("Traceback (most recent call last):","-"*9)
+    if find:
+        if find=="p":
+##            mo=compiled((r'(?<= File ")(.*?)", line (\d+), in (.+?)\n(.*?)')).findall(e2)
+            mo=compiled((r'(?<= File ")([^\n]+?)", line (\d+)(?:, in )?([^\n]*?)\n((?!  File).*?(?=\n))?')).findall(e2)
+            mo=[[fppmobile(f) for f in f2] for f2 in mo if not any(((compilex(r"/python|\\Python\\|importlib").search(f2[0])), ("#pass" in f2[-1]) )) ]
+            return (fppmobile(omiterror(e2)),mo)
+        if find=="node":
+            mo=compiled(r'at ([\w\.]* )?\(?(C:.*?):(\d+):(\d+)').findall(e2)
+            mo=[[fppmobile(f) for f in f2] for f2 in mo if not any(((compilex(r"/python|\\Python\\|importlib").search(f2[0])), ("//pass" in f2[-1]) )) ]
+            mo=[[w[f] for f in (1,2,0,3)] for w in mo]
+            return (fppmobile(omiterror(e2)),mo)
+        if 0:
+            mo=re.findall(r'"<string>", line (\d+)(), in <module>\n(.*)',e2)
+            return mo
+    return fppmobile(omiterror(e2))
+except2=edipt
+def edipt_edit(te,find,edit=0,fntbl=()):
+    e2=edipt(te,find=find)
+    t1=e2[0].splitlines().pop()
+    if "dialog rejected;" in t1: return
+    if "SystemExit" in t1: return
+    from qNote1 import  iniap, Mini, clhk
+    from dialog_ import orDialog
+    app=iniap()
+    mono=orDialog()
+    if not e2[1]: return Mini(e2)
+    if find=="p":
+        mo=[clhk(f, teh=(f"({cfile(f[0])}), {f[1]}, {f[2]}, \n{f[3]}")) for f in e2[1]]
+    if find=="node":
+        mo=[clhk(f, teh=(f"({cfile(f[0])}), {f[1]}, {f[2]}")) for f in e2[1]]
+    if (mf:=re.search("AssertionError: (.*)", e2[0])): mo=[clhk("*", teh=mf.group(1))]+mo
+    whw=[mo+[e2[0]]]
+    mono.xch(whw)
+    if not mono.fiFiles:return
+    fn,*_=mono.pickupli()
+    if type(fn)==str:return e2
+    (fn,pos,mod,te)=fn
+    if fn in fntbl: fn=fntbl[fn]
+    print(fn,fntbl)
+    #npp(fn,f"-n{pos}")
+    orPOA([HeartNote, fn, "-pos",pos,"0"])
+    return e2
+def omiterror(e2):
+    return rnz(e2,(
+("NameError: name",""),
+))
+def mpvstring(e2):
+            #t1=e2.splitlines().pop()
+            e2=re.sub(r'Traceback .+?\n','',e2)
+            e2=re.sub(r'  File "C:\\cpy\\qt\\(?:clas\\)?(.+?)(?:\.pyw?)", line (\d+),',r'"\1",\2',e2)
+            if "mpv property does not exist" in te:
+                if(mo:=re.search(r"'(mpv property does not exist)',.*?b('.*?'),",te)): te=str(mo.groups())
+                else: te="mpv not exist"
+##                te=rnz(te,(
+##                (r"'(mpv property does not exist)',.*?b('.*?'),",r"\1 \2"),
+##                (r"\d+",""),
+##                ))
+def orpopen(mp3):
+    import subprocess as p
+    return p.Popen([mp3],shell=True);
+def orPOA(cmd,shell=True):
+    import subprocess as p
+    return p.Popen(cmd,shell=shell);
+def popen1(cmd,shell=True):
+    import subprocess as p
+    return p.Popen(cmd,shell=shell).wait()
+##orPOA(r'start cmd /c "r:\c f.bat"')
+def wiff(w):
+    orPOA([ordiMdirs()["wiff"],*w])
+def npp(*w):
+    if not w: return ordiMdirs()["npp"]
+    orPOA([ordiMdirs()["npp"],*w])
+def nppw(lis,fn=tfolder+"/log"):
+    wfd(fn).t(lis)
+    npp(fn)
+class puni(dict):
+##    def update(zl,k,v): dict.update(zl,[(k,v)])
+    def ez(zl,k):#di.get()
+        return  zl[k] if(k in zl) else 0;
+    def ud(zl,k,v):
+        zl.update([(k,v)]);
+    def up(zl,k,L):#update append
+        if(k in zl):
+            zl[k].append(L);
+        else:
+            zl.update([(k,[L])]);
+    def uni(zl,k,L):#update append uni
+        if(k in zl and L not in zl[k]):
+            zl[k].append(L);
+        else:
+            zl.update([(k,[L])]);
+    def setclr(zl,li,la):
+        for nc,f in enumerate(li):
+            k=la(f)
+            zl.up(k,f)
+        return zl
+    def updateIncliment(zl,k):
+        zl.ul(k,1)
+    def ul(zl,k,L):#update vz Length
+        if(k in zl):
+            zl[k]+=L;
+        else:
+            zl[k]=L
+    def us(zl,k):#文字ごとの生起確率
+        for c in k:
+            zl.ui(c);
+        return zl;
+##    def counter(zl,w):
+    def Clip(zl,count,regexpattern="."):
+        "Clip key less than count"
+        ire=re.compile(regexpattern)
+        return puni([(k,v) for k,v in zl.items() if(v>count)and(ire.match(k))])
+    def LetterFrequency(zl,te,llen=2):
+        for k in range(len(te)-llen+1):
+            zl.ui(te[k:k+llen])
+        return zl;
+    def sortedlist(zl):#oredered list by value;
+        return [[k,v] for k, v in sorted(zl.items(), key=lambda x:x[1])]
+    def olal(zl):#appended length
+        tl={k:len(v) for k,v in zl.items()}
+        return puni.ol(tl);
+    def ok(zl):#oredered list by key;
+        return [[k,v] for k, v in sorted(zl.items(), key=lambda x:x[0])]
+    def ovk(zl,valuekey):#sort by appended list
+        pass
+    def tenchi(zl):
+        li={v:k for k,v in zl.items()}
+##        li=map(lambda x: x,li);
+        return li;
+        d=puni()
+        for k,v in zl.items():
+            d[v]=k;
+        return d;#X/2
+    def xemj(zl,vn="v"):#moji for exec,Video
+        tef="";
+        for k in zl.keys():
+            tei="%s=%s[%s];"%(k,vn,repr(k));#tei=k+"="++";";
+            tef+=tei;
+        return tef;
+    def rms(zl,la):
+        pops={k:v for k,v in zl.items() if la(k,v)}
+        _=[zl.pop(k) for k in pops]
+        return zl,pops
+    #listDict
+    def lipop(zl,k,cb):
+        for k,v in zl.items():
+            for n,v1 in enumerate(v):
+                if(cb(v1)):return k,n
+    def lipop1(zl,f,te):
+        #{f,[[open,],[file,],[copy,],]};findcopy():lipop(f,"copy")
+        return zl.lipop(f,lambda e: e[0]==te)
+##    def compres(zl,w0,fp=fpreturn,uni=0):
+##        for f in w0:
+##            zl.compresin(f,fp)
+##        return zl
+    def compres(zl,f,fp=fpreturn,uni=0,te=""):#配列の長さは同じにする
+        z2=zl
+        if 1:
+            z2=zl
+            for w in f[:-1]:
+                w=fp(w)
+                if w not in z2: z2[w]=puni()
+                z2=z2[w]
+            assert isinstance(z2,puni), "not list len"#,f
+            if te:
+                assert f[-1] not in z2, "not list len. 123 12"#,f
+                z2[f[-1]]=te
+            else:
+                z2.ul(f[-1],1)
+            return z2[f[-1]]
+    def flat(zl):
+        li=[((x,),v) for x,v in zl.items()]
+        for p,v in li:
+            if isinstance(v,puni):
+                li.extend(((*p,p2),v2) for p2,v2 in v.items())
+            else:
+                yield (*p,v)
+class pini(puni):
+    def __init__(zl,d={},fn="pini00.ini"):
+        dict.__init__(zl,d);
+        zl.fn=lfn.abspath(fn);
+        if lfn.isfile(fn):
+            f=rfdv0(fn,["utf-8"])
+            for j in f:
+                a=j.split("\t");
+##                try:
+##                    nm=float(a[1])
+##                except:
+##                    pass;
+                if(len(a)== 2):
+##                    exete='zl["%s"]=' % a[0]#.replace("\\","\\\\");
+                    exete='zl[%s]=' % a[0]#.replace("\\","\\\\");
+                    et2= exete+a[1];
+                    exec(et2);
+                else:
+                    notTheFormat
+    def save(zl):
+        te="";
+        #print(os.getcwd())
+        for f,v in fpn1(zl):
+            ti= repr(f) +"\t" +repr(v)+"\n";
+            te+=ti;
+        wfd8(zl.fn,te);#Exceptions during cleanup are always ignored; see the object.__del__() documentation:
+##    deli=__del__#for
+##class lazy:1
+    ##diMdirs=None
+def ordiMdirs():# Dictionary of Directory
+    global diMdirs
+    diMdirs=globals().get("diMdirs") or dict([j.split("\t")[:2] for j in wfd(os.environ["cpa"]+r"\data\dirs-{}.txt".format(T45)).r(lines=True) if j[:2]])
+    return diMdirs
+def mdir(f): return ordiMdirs()[f]
+#
+def fFlat(li,lirn):
+    if(type(li)==list):
+        for j in li:
+            r1=fFlat(j,lirn)
+##            lirn.extend(r1)
+    else:
+        r1=li
+        lirn.append(r1)
+    return lirn
+class List(list):
+    def rx(zl,te):
+        ir1=re.compile(te)
+        zl.res=[]
+        for i,j in enumerate(zl):
+            mo=ir1.search(j)
+            if mo:
+                zl.res.append(j)
+        return zl.res
+    def rxenu(zl,te):
+        ir1=re.compile(te)
+        zl.res=[]
+        for i,j in enumerate(zl):
+            mo=ir1.search(j)
+            if mo:
+                zl.res.append((i,j))
+        return zl.res
+    def __lt__(zl,f): return zl.append(f)
+    def __lshift__(zl,li): return zl.extend(li)
+    #def __getitem__(zl,f):
+    def getx(zl,f,v):
+        return zl.index(f) if f in zl else v
+    def u(zl,f,v):
+        zl[zl.index(f)]=v
+##    def up(zl,v):
+orList=List
+class ListHash(List):#from collections import OrderedDict
+    def put(zl,k,v):#up
+        1
+class orLiset(set):#unique list
+    pass
+    def cmp(zl,ot):
+        zl.cmp[x](zl[y],ot)
+##        if(role=="cmp"):split(sel)
+    def get(zl,x,y,role="edit"):
+        return zl[y][x]
+class LastOperation(List):
+    def __init__(zl,li=(),threshold=30,wriIni=False,k="",uniq=True):
+        zl.threshold=threshold
+        zl.see=-1
+        zl.uniq=uniq
+        if(wriIni):#dict.setdefault()
+            if(k in wriIni):
+                li=wriIni[k]
+            list.__init__(zl,li)
+            wriIni[k]=zl
+        else:
+            list.__init__(zl,li)
+    def rm(zl,te):
+        if zl.uniq and (te in zl):
+            zl.pop(zl.index(te))
+    def ap(zl,te):
+        if zl.uniq and (te in zl):
+            zl._ap(zl.pop(zl.index(te)))
+        else:
+            if(len(zl)>=zl.threshold):zl.pop()
+            zl._ap(te)
+        zl.see=0
+    def aprx(zl,te):#Word completion
+        if zl.uniq and (zl.get(te)):
+            zl._ap(zl.pop(zl.res[0][0]))
+        else:
+            if(len(zl)>=zl.threshold):zl.pop()
+            zl._ap(te)
+        zl.see=0
+##    def _ap(zl,element):
+##        zl.insert(0,element)
+    _ap=lambda zl,x:zl.insert(0,x)
+    def get(zl,te):
+        r=zl.rxenu(te)
+        return r[0]
+    def up(zl):
+        if(len(zl)-1>zl.see):
+            zl.see+=1
+        return zl[zl.see]
+    def down(zl):
+        if(zl.see>0):
+            zl.see-=1
+            return zl[zl.see]
+clHistry=LastOperation
+##class cycle():
+class orLog(LastOperation):
+    def __call__(zl,*w):
+        if(len(zl)>=zl.threshold):zl.pop(0)
+        zl.append((w[0],w[1:]))
+        return zl
+    def __repr__(zl):
+        if not zl: return "[]"
+        rn=[f[1] for f in zl.find(zl[-1][0])]#findByLastKey
+        return str(rn)
+    def find(zl,pat):
+        ir1=re.compile(str(pat))
+        rn= [f for f in zl if ir1.search(str(f[0]))]
+        return rn
+imorLog=orLog(threshold=32100)
+##logi=lambda *x:imorLog.ap(x[0],x[1:])
+lg=logi=imorLog
+lgf=logifind=lambda x="":imorLog.find(x)
+lgfv=lgf2=lambda x="":[f[1] for f in imorLog.find(x)]# value
+lglf=lambda x:jw(lf,[jw(" ",[str(f) for f in l]) for l in lgfv(x)])
+##jw(lf,[l for l in lgfv(x)])
+lgc=lambda: imorLog.clear()
+def msri(proc,lp):#mashiroInner
+    fil = sys.argv
+    if(len(fil) == 1):
+        pr("please drop off the file");input();exit()
+    for fi in fil[1:]:
+        proc(fi,lp);
+mashiro=msri;
+gif=r"(jpg|jpeg|png|gif|tiff|jfif|webp)$"
+ignoreFiles=(r"R:\TEMP",r"R:\Clip1.txt.txt",r"R:\OnClipChange1.txt",r"R:\Recycled",r'R:\System Volume Information')
+def listdir(r=None,iref="",walk=False,flat=False,isdir=False):
+    "f in listdir() if not(f in ignoreFiles)"
+    assert ifexist(r or "."),r
+    if type(iref)==str:iref=re.compile(iref,re.I).search
+    li=[(jwdir(r,f) if flat else f) for f in (os.listdir(r) if not walk else walky(r)) if ((os.path.abspath(jofn(r or "",f)) not in ignoreFiles) and (iref(f)))]
+    if isdir: li=[f for f in li if isdir(jwdir(r,f) if r else f)]
+    return li
+def walky(r):
+    for p, ds ,fs in os.walk(r):
+        for fn in ds+fs:
+            yield jofn(p,fn)
+def unfoldfiles(ars,ap=False):
+    for fn in ars:
+        if os.path.isfile(fn):
+            fn
+        else:
+            lifn=walky(fn)
+            for fn in lifn:
+                fn
+def orWalk(d,proc,lp):#CallBackWalk
+    waw = os.walk(ddf[0])
+    for r, ds ,fs in waw:
+        mod=ddf[2].search(r)
+        if mod :#除外子孫のフォルダをさらに(被除外リスト)出力からも除外
+            lidex.append(r);
+        else:
+            ldir=[]
+            for fc in fs:
+                ldir.append(fc)
+            orcb(ldir,r,ddf)
+def rnWalk(d,inc,exc):
+    irInc=[re.compile(f,re.I) for f in inc]
+    irExc=[re.compile(f,re.I) for f in exc]
+    lii=[]
+    for r, ds ,fs in os.walk(d):
+        dsfs=ds+fs
+        for fn in dsfs:
+            for ire in irInc:
+                mod=ire.search(fn)
+                if mod :
+                    lii.append((r,fn));
+                    break
+    for k,(r,fn) in enumerate(lii):
+            for ire in irExc:
+                mod=ire.search(fn)
+                if mod :
+                    lii.pop(k);
+                    break
+    return lii
+def ywalk(dn=None,dr=0,pop=-1):
+    ds=[dn or os.getcwd()]
+    while 1:
+        cd=ds.pop(pop)
+        ag=os.listdir(cd)
+        if dr: ag=ag[::dr]
+        for f in ag: yield cd,ag,jofn(cd,f)
+        else:# not break return
+            ds+=[fp for f in ag if os.path.isdir(fp:=jofn(cd,f))]
+            if not ds : break
+            continue
+        break
+while 0:
+        sn=hhwr(dn=listdir(r"c:\v\t",iref=isdir)[0])
+        dnd=os.path.dirname(sn.dn)
+        if(dnd in [r"c:\v"]): break
+        for cd,fs,fp in ywalk(dnd):
+            pass
+        li=(list(listdir(dnd,iref=isdir)))
+        ix=li.index(os.path.basename(sn.dn))
+##prexit([f for f in ywalk(r"c:\v\t")])
+def nxDir(fn,ceil,fs=0,dr=1):
+    for n in range(9):
+        dn=lfnd(fn)
+        if dn in ceil:
+            return
+        fs=listdir(dn,flat=1)
+        if fn == fs[-dr]:# -1 | 0  # last sister
+            fn=dn
+        else:
+            if not dr: fs.reverse()
+            for nxf in fs[fs.index(fn)+1:]:
+                fn=jofn(dn, fs[fs.index(fn)+1])
+                if os.path.isfile(fn):
+                    yield fn
+                else:
+                    for cd, ag, fnw in ywalk(fn,dr=0 if dr else -1):
+                        yield fnw
+def nxfortst(*a):
+    for n,f in enumerate(nxDir(*a,dr=1)):
+        print(n,f)
+##prexit("nxfor:",nxfortst(r"C:\v\T\eva7\cover\..jpeg",(r"C:\v",)))
+def merge(li,fl="f"):
+    l4=orList()
+    for f1,f2 in li:
+        if not f1.endswith("\\"): f1+="\\"
+        li1=[f[len(f1):] for f in listdir(f1,walk=1)][::-1]
+        for fe in li1:
+            src=jofn(f1,fe)
+            dst=jofn(f2,fe)
+            assert dst.startswith(f2),(f1,f2,fe,dst)
+            inidi(lfnd(dst))
+            if isdir(src):
+                inidi(dst)
+            else:
+                copy=1
+                if ifexist(dst):
+                    copy=0
+                    if "f" in fl:# force, modi
+                        copy=1
+                    elif "m" in fl and (mtime(src)-mtime(dst) > 1):
+                        copy=1
+                if copy:
+                    l4<(fe)
+                    shutil.copy2(src, dst)
+    return l4
+#prexit(merge([[r"C:\v\T\lvlv",r"r:\hono"]],"m"))
+def listDrive(ignore="ABD"):
+    return [L for L in (chr(c) for c in range(65,90+1)) if os.path.exists(L+':') and (L)not in ignore]
+def getFolderSize(folder):
+    total_size = 0 #os.path.getsize(folder)#4096
+    for item in os.listdir(folder):
+        itempath = jofn(folder, item)
+        if os.path.isfile(itempath):
+            total_size += os.path.getsize(itempath)
+        elif os.path.isdir(itempath):
+            total_size += getFolderSize(itempath)
+    return total_size
+def lamrec(fp1,fn, fpEnum,F=0,pare=None):
+    fp1(fn,pare,F,0)
+    #print(" "*F, fn)
+    for f2 in fpEnum(fn):
+        lamrec(fp1,f2, fpEnum,F+1,fn)
+    fp1(fn,pare,F,1)
+
+def abSize(size,M="",_1024=1024):# 1234 > 1,234
+    # return f"{size:,}"
+    li=[];mb=""
+    for heavy in "KMGTE":
+        m= size % _1024
+        size= size // _1024
+        li.append(m)
+        if(heavy==M):
+            li=[]
+            mb=M
+        if(size):mb
+        else: break
+    return jw(",",("{:03}".format(f) for f in li[::-1])).lstrip("0")+mb
+##prexit(_:=(1,2026,3,4) ,abSize(sum([1024**n*f for n,f in enumerate(_[::-1])]),"K"))#
+def crbs(li):
+ def binarySearchRec(goal,q0,q1,fpSave):
+    mid = q0+(q1-q0)/2
+    if q0>q1: return
+    size=fpSave(mid)
+    if goal == size:
+       return mid
+    elif goal > size:
+       return binarySearchRec(goal,mid+1,q1,fpSave)
+    else:
+       return binarySearchRec(goal,q0,mid-1,fpSave)
+ return binarySearchRec
+def binarySearch(fpSave,goal,q0,q1,li):
+    while q0<=q1:
+          mid = int(q0+(q1-q0)/2)
+          size=fpSave(mid)
+          li.append((mid,size))
+          if(goal == size):
+             return li#mid
+          elif goal > size:
+             q0 = mid + 1
+          else:
+             q1 = mid - 1
+    if 0:
+          mid = (q0+(q1-q0)/2)
+          size=fpSave(mid)
+          li.append((mid,size))
+    return li
+##print(binarySearch(lambda e:e*100,501,0,20,[]))
+def mvvideo(src,vfl,suffix):#VideoFolder,拡張子
+    ire = re.compile(suffix,re.I)
+    files = os.listdir(src)
+    count=0
+    for f in files:
+        mo= ire.match(f)
+        if(mo):
+            sfi= src+"\\"+f;
+            vfi= vfl+"\\"+f;
+            #print(vfi,sfi)
+            os.rename(sfi,vfi)
+            count+=1;
+    return count;
+def mvdir(src,vfl,suffix):#VideoFolder,拡張子
+    ire = re.compile(suffix,re.I)
+    files = os.walk(src)
+    count=0
+    for r,ds,fs in files:
+        for f in ds:
+            mo= ire.match(f)
+            if(mo):
+                sfi= r+"\\"+f;
+                vfi= vfl+"\\"+f;
+                #print(vfi,sfi)
+                try:
+                    os.rename(sfi,vfi)
+                except a as XP:
+                    pass
+                count+=1;
+    return count;
+def copyTree(src,dist,pat):
+    pass
+def nxnum(WorkDir,fn):#Create sequencial number filename 001~99999
+    'r=nxnum(".","%sx.jpg")'
+    pat=fn%r"(\d{1,3})"
+    ire=re.compile(pat);
+    xmax=0;
+    for n in os.listdir(WorkDir):
+        mo=ire.search(n);
+        if mo:
+            m1=mo.group(1)
+            xi = int(m1)
+            if(xmax < xi):
+                xmax = xi
+    xmax+=1
+    rr = str(xmax).zfill(3);
+    rr=fn%rr;
+    return rr;
+def nxnu2m(WorkDir,fn,nZfill=3):
+    ire=re.compile(re.escape(fn)%r"(\d{1,})");
+    xmax=max([0]+[int(mo.group(1)) for mo in [ire.search(f) for f in os.listdir(WorkDir)] if mo])
+    rr = str(xmax+1).zfill(nZfill);
+    rr=fn%rr;
+    return rr;
+def nxNumFull(WorkDir,fn,nZfill=3):#return FullPath
+    resFn=nxnu2m(WorkDir,fn,nZfill=nZfill)
+    return jofn(WorkDir,resFn)
+def nxNumFullSplit(fn,nZfill=3):#FullPath
+    resFn=nxnu2m(*os.path.split(fn),nZfill=nZfill)
+    return jofn(os.path.split(fn)[0],resFn)
+#
+montail=(0,31,28,31,30,31,30 ,31,31,30,31,30,31)
+import csv
+class oc:#orcsv
+    ordelimiter="\t"
+def wcsw(fn,li):
+    for code in ("cp932","utf-16"):
+        try:
+            with open(fn, 'w',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def writecs8(fn,li):
+    return wcsv(fn,li,("cp932","utf-8"))
+def wcsv(fn,li,cs=("utf-8",)):
+    for code in cs:
+        try:
+            with open(fn, 'w',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def acsw(fn,li,code="cp932"):
+            with open(fn, 'a',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+def acswvp84n534983v(fn,li):
+    for code in ("cp932","utf-16"):#No good
+        try:
+            with open(fn, 'a',encoding=code) as fpw:
+                writer = csv.writer(fpw, delimiter=oc.ordelimiter, lineterminator='\n')
+                for f in li:#
+                    writer.writerow(f);
+            break
+        except UnicodeEncodeError as XP:
+            continue;
+def rcsr(fn):
+    for code in ("utf-8",):#("cp932","utf-8","utf-8"):
+        try:
+            lines =[];
+            with open(fn, 'r',encoding=code, newline='') as fpr:
+                reader = csv.reader(fpr, delimiter=oc.ordelimiter, lineterminator='\n')
+                for line in reader:
+##                    print(line)
+                    lines.append(line);
+            return lines;
+        except UnicodeDecodeError as XP:
+            continue;
+#list(csv.reader(['"-f" 2 9'],delimiter=" "))
+##X/
+def zelp0(lio,fi,irz0=re.compile(r"h/",re.I),irs=0,irx=()):
+    "oList, fn, ir, List"
+    tel=rfdlv(fi)
+    for k,f in enumerate(tel):
+        mo=irz0.search(f);
+        if mo and not (irx and any(x.search(f) for x in irx)):
+            if(irs):
+                f=rnz(f,irs)
+            lio.append((k,f))
+    return lio
+def orgrepir(li,fi,ir1):
+    tel=rfdlv(fi)
+    for k,f in enumerate(tel):
+        mo=irz0.search(f);
+        if mo:
+            lio.append((k,f))
+    return lio
+def orgrep(li,fi,pat):
+    ir1=re.compile(pat);
+    li=orgrepir(li,fi,ir1);
+    return lio;
+def orgrepdir(currentdir,pat):
+    filelist=os.listdir(currentdir)
+    matchlist=[orgrep(f) for f in filelist]
+    return matchlist;
+if 1:#time
+#time.strptime("1970,1,1, ","%Y,%m,%d, ")
+#time.mktime(time.strptime("1976,2,29, 9,3,4.56","%Y,%m,%d, %H,%M,%S.%f"))
+#time.gmtime(232.324)
+#time.strftime("%Y")
+#time.time();time.mktime(time.localtime())
+    def timea(te):
+        time.mktime((1970,1,1, 9,10,10,  3,1,0))
+        time.mktime((1970,2,31, 25,66,66,  1,1,1))
+        return
+    def hourmin(te): return te.replace("hour","H").replace("min","M").replace("second","S")
+letters='abcdefghijklmnopqrstuvwxyABCDEFGHIJKLMNOPQRSTUVWXY'
+def letter_digit(te,ln=2,zfill=0):
+    for c in te:1
+def i2l(d,letters=letters):
+    li2=[]
+    while d:
+        d,e=divmod(d,len(letters))
+        li2.append(letters[e])
+    return jw("",li2[::-1]) or letters[0]
+#
+#graph
+def fncore(fn,exist=False,cc=1,fldn=0):
+    fn=fn.replace("\\","/")
+    fnli=fn.split("/")#.__iter__()
+    for nc,f in enumerate(fnli):
+        if f not in ("Downloads","downfile","freerapid") and (len(f) >= 8 or f.endswith("-") or len(f) != len(f.encode("mbcs"))) and not(f.endswith("@")):
+            if fldn: return jw("/",fnli[:nc+1])
+            fn=jw("/",fnli[nc:])
+            break
+    pat=[("#.*?#",""),(r"[:_/]"," "),(r"\bv?(\d+)[sbw]?[e]?",r"\1"),(r" z(\d+)","")]
+##    pat+=[("\(.*?\)","")]#(1)
+    if not exist: fn=rnz(fn,pat).strip()
+    if cc==1:fn=fn.lower()
+    if cc==2:pass # camel case
+    return fn
+def fncx(fn): return fncore(fn,True)
+def findzv(fn):
+    dir,fn=lfn.split(fn)
+    if not dir:dir=os.getcwd()
+    for f in range(9):
+        #zl+[dir,fn]
+        with pushd(dir):
+            if ifexist(fn): return lfn.abspath(fn).replace("\\","/")
+            if not lfnb(dir): return
+            dir,_=lfn.split(dir)
+class clfn:
+    def __init__(sl,**kw):
+        sl.__dict__.update(kw)
+    def __call__(sl,fn,dirs=()):
+        for dn in dirs or sl.dirs:
+            if lfn.exists(f2:=(dn+"/"+fn)):
+                return f2
+if cpa:
+    pmfolder=(#r"c:\v\jext",
+r"C:\Users\user\Downloads\dval\n2",
+#r"C:\Users\user\Downloads\dval\t1",
+r"C:\Users\user\Downloads\dval\t2",
+r"C:\Users\user\Downloads\dval\t5",
+r"C:\Users\user\Downloads\dval\t9",
+)+tuple(jofn(r"c:\v\zv",f) for f in os.listdir(r"c:\v\zv"))
+    xcore=clfn(dirs=pmfolder)
+#
+def _gettps(fnzv,dncore):
+    fnzv= fnzv or jofn(diMdirs["mtm"],"data","zv.txt")
+    itemdict=eval(wfd(fnzv).r())
+    tps=itemdict.setdefault(dncore,dict())
+    return tps
+def gettps(fnzv,dncore=None):
+    fnzv=jofn(*[fnzv] if fnzv else (diMdirs["mtm"],"data","zv"),dncore)
+    if ifexist(fnzv):
+        tps=puni(eval(wfd(fnzv).r()))
+    else:tps=puni()
+    tps.fn=fnzv
+    return tps
+#
+
+##class hhwrproto(dict):pass
+class hhwrproto(p310, dict):
+    def __init__(zl,*aw,**kw):
+##        super
+        for f in aw: zl.update(f)
+        zl.update(kw)
+        for f,v in kw.items():
+            if v==None: zl.pop(f)
+    def str(zl,order=None, sp=" : ", lf=lf, ls=repr):
+        return jw(lf,(key +sp+ ls(zl[key]) for key in order or zl if key in zl))
+    def __setattr__(zl,at,v):
+        zl[at]=v
+    def __mod__(zl,li):pass
+    def __sub__(zl,li): return zl.__x(li)
+    def __truediv__(zl,l): return zl.__x((l,))
+    def __x(zl,li):#exclude
+        for f in li:
+            zl.pop(f,0)
+        return zl
+    #def copy():
+#class hhwrx(hhwr):
+    def hh(zl,li=None):
+        zl.parser = ArgumentParser()
+        zl.parser.add_argument("fil",nargs="*")#all other
+        if li: zl+li
+        return zl
+    def __add__(zl,li):
+        for f in li:
+            f1,t=f[:2]
+            lenli,default= f[2:] if(len(f)==4) else (None,None)
+            if not isinstance(t,type):
+                lenli=0
+                if isinstance(t, (tuple,list)): lenli=len(t)
+                default=t
+                t=type(t)
+            if t==bool and "store true":                                zl.parser.add_argument(f1,           action="store_true")
+            else:
+                zl.parser.add_argument(f1, type=t, nargs=lenli or None, default=default)
+        return zl
+    def ho(zl,te=None):
+        w=zl.parser.parse_args(te and csv.reader([te.strip()],delimiter=" ").__next__())
+        zl.update(w.__dict__)
+        zl.pop("parser")# need vn pickle
+        return zl
+    def __getattr__(zl,at):
+        return zl[at]
+##    def __vars__(zl):wefw
+class hhwr(hhwrproto):
+    def __getattr__(zl,at):
+        return zl.get(at)
+        return None
+hhwrproto().str
+##prexit((hhwr(w=2,f=4) - ("w",)).str())
+##prexit((hhwr(w=2,f=4,ff=4)/"w"/"f").str())
+##w=hhwr();w.f=2;pr(w.f)
+##print(hhwr({"e":1},{"e":4}))
+##print("vars;",vars(w))
+###print(hhwr().hh([("-f",str),("-re",str),("-ns",str)]).ho())
+##print(dict(**hhwr(w=2)), {"ww":2})
+##prexit(hhwr(w=2)==hhwr(w=3), hhwr()==hhwr())
+cls=hhwrproto()
+cls.mp4="mp3|mp4|mkv|flv|ogg|webm"
+#
+def set2(sl,ob,value):
+    for f in value.split(): ob.__dict__[f]=sl.__dict__.get(f)
+import json
+##def pl(fn,tfn="",pl="p"): return jsonload(fn,tfn=tfn,pl=pl)
+##def typejson(te):
+##    try: json.loads(te)
+def jsonload(fn,tfn="",pl="json",flw=0,fltmp=1):
+        if pl=="json":
+            fp=(json.loads,json.dumps)
+        elif pl=="p":
+            import pickle
+            fp=(pickle.loads, pickle.dumps)
+        else:fp=()
+        if not tfn:
+            import hashlib
+            te=hashlib.sha256(fn.encode()).hexdigest()
+            tfn=jofn(tfolder,"wft;"+te)
+        tfn=lfn.abspath(tfn)
+        #print(tfn)
+        if ifexist(tfn) and not flw:
+            if pl=="json": te=wfd(tfn).r()
+            if pl=="p": te=wfd(tfn).rb()
+            js=fp[0](te or "")
+        else:js={}
+        def log(te=js):
+            if fltmp:wfd(tfn).t(fp[1](te))
+            else: wfd(tfn).w(fp[1](te), copy=0)
+        if flw: log(flw)
+        table=hhwr(t=js,l=len(js),fn=fn,tfn=tfn,log=log)
+        return table, js, tfn, log
+def wfupdate(fn,pat,count):
+        imw=wfd(fn)
+        te=imw.r()
+        if callable(pat):te=pat(te)
+        else: te=rnz(te,pat)
+        cs=[te.count(f) for f,c in count]
+        assert not any(c!=co for (f,c),co in zip(count,cs)),cs
+        imw.w(te,copy=0)
+        return te
+if 1:
+  def pmobile(*w,**W):
+    pmobilelib=impt((os.environ["AlfiPython"]+f"/escape/nagano/e3escapeMtm"),reload=0);
+    return pmobilelib.pmobile(*w,**W)
+  def fppmobile(*w,**W):
+    pmobilelib=impt((os.environ["AlfiPython"]+f"/escape/nagano/e3escapeMtm"),reload=0);
+    return pmobilelib.fppmobile(*w,**W)
+  def note():
+    return impt(os.environ["AlfiPython"]+r"/qt/lib"+"/qNote1", reload=0)
+    global_app=iniap()
+    return "note+"
+  def x4():
+    return impt(cpy+"/Generator/x4orlexi")
+def xfil(ap,flinput=1):
+    hh=hhwr().hh(ap).ho()
+    fl=hh.fil
+    if hh.fil:fl= hh.fil
+    elif flinput:
+        fl=input("w copy:")
+        if fl:
+            if fl[0]==";": fl=hh.ho(fl)
+            else:    fl=fl.split()
+        #else:fl=[]
+    return hh,fl
+hhfl=xfil
+##def genefp(li):
+##    def fp1(fn,pare,F,after):l
+##    def fpEnum(fn):
+##    lamrec(fp1,li,fpEnum)
+import importlib; from importlib import import_module
+find_spec=getattr(importlib,b'\x75\x74\x69\x6C'.decode()).find_spec
+module_from_spec=getattr(importlib,b'\x75\x74\x69\x6C'.decode()).module_from_spec
+importtool=getattr(importlib,b'\x75\x74\x69\x6C'.decode())
+def fwfw_impt(fn,reload=True, lazy=False, **_):
+    dir,fir=lfn.split(fn)
+    #sys.path.append(os.path.abspath(dir))
+    cf=cfile(fn)
+    if cf in sys.modules:
+        mod=sys.modules[cf]
+        if reload: importlib.reload(mod)# orText() not found
+    else:
+        if not dir:
+            mod=import_module(cf)#pass
+        else:
+            if not ifexist(fn): fn+=".py"
+            spec=importtool.spec_from_file_location(cf,fn)
+            assert spec, "import from file location;"+fn
+            if lazy: spec.loader = LazyLoader(spec.loader)
+            mod = module_from_spec(spec)
+            sys.modules[cf] = mod
+            if "import": getattr(spec.loader, b'\x65\x78\x65\x63_\x6D\x6F\x64\x75\x6C\x65'.decode())(mod)
+    #if dir: sys.path.pop()
+    return mod
+def impt(fn,reload=True, lazy=False, **_):
+    dir,fir=lfn.split(fn)
+    #sys.path.append(os.path.abspath(dir))
+    cf=cfile(fn)
+    if cf in sys.modules and not reload:
+        mod=sys.modules[cf]
+        #if reload: importlib.reload(mod)# orText() not found
+    else:
+        f9=fn
+        if not dir:
+            for p in [os.getcwd(), *sys.path]:
+                if ifexist(f9:=jwdir(p,fn)): break
+                if ifexist(f9:=(f9+".py")):break
+        if 1:
+            if not ifexist(f9): f9+=".py"
+            spec=importtool.spec_from_file_location(cf,f9)
+            assert spec, "import from file location;"+f9
+            if lazy: spec.loader = LazyLoader(spec.loader)
+            mod = module_from_spec(spec)
+            sys.modules[cf] = mod
+            if "import": getattr(spec.loader, b'\x65\x78\x65\x63_\x6D\x6F\x64\x75\x6C\x65'.decode())(mod)
+    #if dir: sys.path.pop()
+    return mod
+def zen(wfn):
+    wfn=orsub({":":"：", "<":"(",">":")","\\":"／"},wfn)
+    return wfn
+def newthan(tfn,fn): return mtime(tfn)>mtime(fn)
+def memof(fp):
+    fp._memof={}
+    @functools.wraps(fp)
+    def p(zl,*w):
+        #print(fp._memof, w)
+        if(mf:=fp._memof.get(w)): return mf
+        else:
+            pm=fp(zl,*w)
+            fp._memof[w]=pm
+            return pm
+    return p
+if __name__ == '__main__':
+    print(os.getcwd());
+    hh={
+##        "ast":1,
+##        "dif3":5,
+    }
+    hw,fl=xfil([])
+    hw.new36=1200
+    if "dif3" in hw:
+        t1="am,mm,gf,jpefg".split(",")
+        t2="pm,mm,gif,jpg".split(",")
+        prexit(dif3(t1,t2))
+    if(0):
+        eu=esfn(url);
+        wfdt(eu,"lkjl");
+        e2=exfn(eu);
+        pr(bool(url==e2));
+        pr(url,lf,e2,lf,eu);
+    if "ast" in fl:
+        import ast
+        @cbTry
+        def pcompile(te):1
+        print(ast.dump(ast.parse("if 1:1")))
+        w=ast.parse("sn.l[2]")
+        q=[(f,list(ast.iter_fields(f))) for f in ast.walk(w)]
+        for f,n in q:
+            if n:print(len(n),n)
+##    prexit(emrestore("c"))
+    if hw.new36:# f-string
+        print(f"f-string: {hw.new36:,} str:left,{hh!s:>22}")
+#Operator precedence() ~ / + >> & ^ | in > not and or if
+##npp(r'"C:/cpy/Mjmoji/pr/give it try.pyw" -n2')
+#compilev(r"(?<=1).*?(?=\n)").sub("2","1\nfw\n")