diff -Nru /sys/src/cmd/ptrace/T /sys/src/cmd/ptrace/T --- /sys/src/cmd/ptrace/T Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/T Mon Mar 14 00:00:00 2016 @@ -0,0 +1,6 @@ +#!/bin/rc +cd /sys/src/cmd/ptrace +test -e /dev/ptracectl || bind -a '#σ' /dev +mk clean +tron -s 32 -o Tpm.dev pm +ptrace -d Tpm.dev>Tpm.txt diff -Nru /sys/src/cmd/ptrace/all.h /sys/src/cmd/ptrace/all.h --- /sys/src/cmd/ptrace/all.h Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/all.h Mon Mar 14 00:00:00 2016 @@ -0,0 +1,75 @@ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +typedef struct St St; +typedef struct Proc Proc; + +enum +{ + Dump = 1, + Plot = 2, + + Stack = 32*1024, + Incr = 4096, + + Wx = 718, /* default window sizes */ + Wy = 400, + Wid = 3, /* line width */ + Scroll = 10, /* fraction of screen in scrolls */ +}; + +struct St +{ + PTraceevent; + int state; /* Sready, Srun, Ssleep */ + char *name; + + /* help for browsing */ + int x; /* min x in screen when shown */ + int pnext; /* next event index in graph[] for this proc */ +}; + +struct Proc +{ + int pid; + int* state; /* indexes in graph[] for state changes */ + int nstate; + + int row; /* used to plot this process */ + int s0, send; /* slice in state[] shown */ + + int *pnextp; /* help for building St.next list */ +}; + +#define NS(x) ((vlong)x) +#define US(x) (NS(x) * 1000ULL) +#define MS(x) (US(x) * 1000ULL) +#define S(x) (MS(x) * 1000ULL) + +#pragma varargck type "T" vlong +#pragma varargck type "G" St* + +extern Biobuf *bout; +extern int what, verb, newwin; +extern St **graph; +extern int ngraph; +extern Proc *proc; +extern int nproc; + +/* + | c/f2p st.c + */ +extern int Gfmt(Fmt *f); +extern int Tfmt(Fmt *f); +extern void makeprocs(void); +extern St* pgraph(Proc *p, int i); +extern void readall(char *f, int isdev); diff -Nru /sys/src/cmd/ptrace/guide /sys/src/cmd/ptrace/guide --- /sys/src/cmd/ptrace/guide Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/guide Mon Mar 14 00:00:00 2016 @@ -0,0 +1,59 @@ +Example from T.txt (mk all) +trace for pid 195 +>awk '$2 == 195' + +number of page faults +>awk '$2 == 195 && $6 == "pfault"' | wc -l +500 + +number of sleeps +>awk '$2 == 195 && $5 == "Sleep"' | wc -l +197 + +number of core switches +awk 'BEGIN{nsw = 0; last = -3;} + $2 == 195 {if($3 != last) nsw++; last=$3} + END{print nsw}' $target + +T:V: + $O.ptrace -d T.dev >T.out + cmp T.txt T.out && rm -f T.out diff -Nru /sys/src/cmd/ptrace/mksystab /sys/src/cmd/ptrace/mksystab --- /sys/src/cmd/ptrace/mksystab Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/mksystab Mon Mar 14 00:00:00 2016 @@ -0,0 +1,4 @@ +BEGIN{ printf("char* scname[] = {\n"); max = 0} +{ printf("[%d]\t\"%s\",\n", $3, $2); if(max < $3) max = $3} +END{ printf("};\nint maxscval = %d;\n", max); } + diff -Nru /sys/src/cmd/ptrace/pm.c /sys/src/cmd/ptrace/pm.c --- /sys/src/cmd/ptrace/pm.c Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/pm.c Mon Mar 14 00:00:00 2016 @@ -0,0 +1,152 @@ +/* + * Program to cause a synthesized load for profiling. + * Spawns n processes each of which would do r rounds of + * io + compute. + */ + +#include +#include + +enum +{ + Nprocs = 10, + Nrounds = 4, + Ncpu = 10000, + Nio = 10000, + Nstack = 10, + Nsleep = 10, + Bufsz = 1024, +}; + +#include "rnd.c" + +int nprocs, nrounds, ncpu, nio, nstack, nsleep; + + +static void +docpu(void) +{ + int *dv; + int i, j, x; + + dv = malloc(sizeof vals); + for(i = 0; i < nelem(vals); i++) + dv[i] = vals[i]; + for(i = 0; i < nelem(dv); i++) + for(j = i; j < nelem(dv); j++) + if(dv[i] > dv[j]){ + x = dv[i]; + dv[i] = dv[j]; + dv[j] = x; + } + free(dv); +} + +static void +doio(char buf[], int sz) +{ + int i, p[2]; + long n; + + if(pipe(p) < 0) + sysfatal("pipe"); + switch(fork()){ + case -1: + sysfatal("fork: %r"); + case 0: + close(p[1]); + for(i = 0; i < nio; i++){ + n = readn(p[0], buf, sz); + if(n != sz) + sysfatal("read: %r"); + } + close(p[0]); + exits(nil); + default: + close(p[0]); + for(i = 0; i < nio; i++){ + n = write(p[1], buf, sz); + if(n != sz) + sysfatal("write: %r"); + } + close(p[1]); + waitpid(); + } +} + +static void +stk(int lvl) +{ + int i, c; + char buf[Bufsz]; + + if(lvl < Nstack){ + stk(lvl+1); + return; + } + for(i = 0; i + +/* + * See st.c for a description of the data structures. + * + * Pos is the time and pixel slice into the time window shown + * and the rectangle plotted. + */ +typedef struct Pos Pos; + +struct Pos +{ + vlong t0; + vlong ival; + int p0; + int pend; + vlong npp; /* ns per pix at this scale */ +}; + +static char *plumbfname = "ptrace.out"; +static char *infname; +int what, verb, newwin; +Biobuf *bout; +static St *(*readst)(Biobuf*); + +int mainstacksize = Stack; + +static int piddx, graphdy; +static Rectangle plotr; +static Image *im, *bgcol, *rdycol, *waitcol, *runcol; +// These are aliases: +static Image *setcol, *sccol, *pfcol, *faultcol; + +static Channel *eventc; +static Mousectl *mousectl; +static Keyboardctl *keyboardctl; +static Proc *current; + +static Cursor crosscursor = { + {-7, -7}, + {0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, + 0x03, 0xC0, 0x03, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xC0, 0x03, 0xC0, + 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, }, + {0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, + 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x7F, 0xFE, + 0x7F, 0xFE, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, + 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x00, 0x00, } +}; + +Cursor busycursor ={ + {-1, -1}, + {0xff, 0x80, 0xff, 0x80, 0xff, 0x00, 0xfe, 0x00, + 0xff, 0x00, 0xff, 0x80, 0xff, 0xc0, 0xef, 0xe0, + 0xc7, 0xf0, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xc0, + 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, }, + {0x00, 0x00, 0x7f, 0x00, 0x7e, 0x00, 0x7c, 0x00, + 0x7e, 0x00, 0x7f, 0x00, 0x6f, 0x80, 0x47, 0xc0, + 0x03, 0xe0, 0x01, 0xf0, 0x00, 0xe0, 0x00, 0x40, + 0x00, 0x00, 0x01, 0xb6, 0x01, 0xb6, 0x00, 0x00, } +}; + +Cursor leftcursor = { + {-8, -7}, + {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58, + 0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02, + 0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58, + 0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x07, 0xc0, }, + {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, + 0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc, + 0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80, + 0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, } +}; + +Cursor rightcursor = { + {-7, -7}, + {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20, + 0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20, + 0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20, + 0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x03, 0xe0, }, + {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0, + 0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x00, 0x00, } +}; + +static void +busy(void) +{ + setcursor(mousectl, &busycursor); +} + +enum{Browsing, Paused}; +static void +ready(int state) +{ + if(state == Paused) + setcursor(mousectl, nil); + else + setcursor(mousectl, &crosscursor); +} + +static void +clear(void) +{ + if(im != nil) + if(Dx(screen->r) != Dx(im->r) || Dy(screen->r) != Dy(im->r)){ + freeimage(im); + im = nil; + } + if(im == nil) + im = allocimage(display, screen->r, screen->chan, 0, -1); + if(im == nil) + sysfatal("allocimage: %r"); + draw(im, im->r, bgcol, nil, ZP); + plotr = im->r; + plotr.min.x += piddx; + plotr.min.y += font->height+1; +} + +enum{ All, TimeAndPids, JustTime }; +static void +flush(int justtime) +{ + Rectangle r; + + r = screen->r; + if(justtime) + r.max.y = r.min.y + font->height; + draw(screen, r, im, nil, im->r.min); + if(justtime == TimeAndPids){ + r = screen->r; + r.min.y += font->height; + r.max.x = r.min.x + piddx; + draw(screen, r, im, nil, r.min); + } + flushimage(display, 1); +} + +static int +proclocate(Proc *p, vlong t, int *ip) +{ + int i, id; + + for(i = 0; i < p->nstate; i++){ + id = p->state[i]; + if(graph[id]->time > t) + break; + } + if(i == 0) + *ip = i; + else + *ip = --i; + return p->state[i]; +} + +/* + * Fill up pp, after the user changes Pos.t0 and/or Pos.ival. + * Locate sets [s0:send] in procs, used later to plot them. + */ +static void +locate(Pos *pp) +{ + int i, pmin, pmax, x; + + pmin = 0; + pmax = ngraph; + for(i = 0; i < nproc; i++){ + Proc *p = &proc[i]; + x = proclocate(p, pp->t0, &p->s0); + if(x < pmin) + pmin = x; + x = proclocate(p, pp->t0+pp->ival, &p->send); + p->send++; + if(x > pmax) + pmax = x; + } + pp->p0 = pmin; + pp->pend = pmax+1; + if(Dx(plotr) > 0) + pp->npp = pp->ival / (vlong)Dx(plotr); +} + +static int infominx, infomaxx; + +static void +drawtime(vlong t, vlong ival) +{ + Rectangle r; + char s[80]; + Point p; + + r = im->r; + r.max.y = r.min.y + font->height; + draw(im, r, bgcol, nil, ZP); + seprint(s, s+sizeof s, "t: %#T", t); + p = Pt(im->r.max.x - stringwidth(font, s) - 1, r.min.y); + string(im, p, display->black, ZP, font, s); + infomaxx = p.x-1; + infominx = im->r.min.x; + if(ival > 0){ + seprint(s, s+sizeof s, "ival: %#T", ival); + infominx = im->r.min.x+1 + stringwidth(font, s)+1; + if(infomaxx < infominx) + return; + p = Pt(im->r.min.x+1, r.min.y); + string(im, p, display->black, ZP, font, s); + } +} + +static void +drawpid(Proc *pp) +{ + Point p; + St *g; + char spid[80]; + + p.x = im->r.min.x; + p.y = im->r.min.y + graphdy * (pp->row+1); + if(p.y >= im->r.max.y) + return; + g = pgraph(pp, pp->s0); + draw(im, Rpt(p, addpt(p, Pt(piddx, font->height))), bgcol, nil, ZP); + if(g->pid > 0){ + seprint(spid, spid+sizeof spid, "%-4.4s% udm%ud", g->name, g->pid, g->machno); + if(pp == current) + string(im, p, setcol, ZP, font, spid); + else + string(im, p, display->black, ZP, font, spid); + } +} + +static void +drawnotice(char *s) +{ + Point p; + int dx, w, n; + char buf[80]; + Rectangle r; + + dx = infomaxx - infominx; + r = Rect(infominx, im->r.min.y, infomaxx, im->r.min.y+graphdy); + draw(im, r, bgcol, nil, ZP); + w = stringwidth(font, s); + if(w + 2 > dx){ + seprint(buf, buf+sizeof buf, s); + s = buf; + for(n = strlen(s); n > 0; n--){ + w = stringwidth(font, s); + if(dx > w+2) + break; + s[n-1] = 0; + } + if(n == 0) + return; + } + p = Pt(infominx + dx/2 - w/2, im->r.min.y); + string(im, p, setcol, ZP, font, s); +} + +static void +drawinfo(St *g) +{ + char s[80]; + + seprint(s, s+sizeof s, "%#G", g); + drawnotice(s); +} + +static int +dtwidth(vlong dt, vlong nsperpix) +{ + if(dt < 0) + return 0; + if(nsperpix <= 0) + return Dx(plotr); + return (int)(dt / nsperpix); +} + +/* + * Try to draw events within the state represented by g + * ending in eg, if the scale permits. + */ +static void +drawgraphs(St *g, St *eg, Point pt, Pos p) +{ + int x, faults, scs, pfs; + vlong t, t0, dt; + Rectangle r; + + x = pt.x; + t0 = g->time; + t = t0; + pfs = faults = scs = 0; + while(g->pnext != 0 && graph[g->pnext] != eg){ + g = graph[g->pnext]; + g->x = x; + if(g->etype == STrap) + if(g->arg&(STrapRPF|STrapWPF)) + pfs++; + else if(g->arg&STrapSC) + scs++; + else + faults++; + dt = g->time - t; + if(dt < p.npp) + continue; + if(scs){ + r = Rect(x, pt.y-3*Wid/2, x+Wid, pt.y-Wid/2); + draw(im, r, sccol, nil, ZP); + } + if(faults || pfs){ + r = Rect(x, pt.y+3*Wid/2, x+Wid, pt.y+5*Wid/2); + draw(im, r, pfs?pfcol:faultcol, nil, ZP); + } + faults = pfs = scs = 0; + t = g->time; + x = plotr.min.x + dtwidth(t-p.t0, p.npp); + } +} + +static void +drawproc(Proc *pp, Pos p) +{ + St *g, *ng; + int s; + Image *c; + vlong t0, tn, frac; + int x0, xn; + Rectangle r; + + frac = 0; + r = plotr; + r.min.y += graphdy * pp->row + graphdy/2; + r.max.y = r.min.y + Wid; + for(s = pp->s0; s < pp->send; s++){ + g = pgraph(pp, s); + switch(g->state){ + case SRun: + c = runcol; + break; + case SDead: + c = bgcol; + break; + case SReady: + c = rdycol; + break; + default: + c = waitcol; + } + t0 = g->time - p.t0; + if(s < pp->nstate-1){ + ng = pgraph(pp, s+1); + tn = ng->time - p.t0; + }else + break; + x0 = dtwidth(t0, p.npp); + xn = dtwidth(tn+frac, p.npp); + g->x = plotr.min.x + x0; + r.min.x = g->x; + if(xn == x0){ + frac += tn-t0; + continue; + } + frac = 0; + if(xn - x0 < Wid) + xn = x0 + Wid; + r.max.x = plotr.min.x + xn; + draw(im, r, c, nil, ZP); + drawgraphs(g, ng, r.min, p); + } + if(s < pp->nstate) + pgraph(pp, s)->x = r.max.x; +} + +/* + * Plot for the range indicated in pos. + * Processes must be located before. + * This updates St.x in the states shown for procs. + */ +static void +plotallat(Pos p) +{ + int i; + + clear(); + for(i = 0; i < nproc; i++){ + drawpid(&proc[i]); + drawproc(&proc[i], p); + } + drawtime(p.t0, p.ival); +} + +static Point +ptinplot(Point pt) +{ + if(pt.y < plotr.min.y) + pt.y = plotr.min.y; + if(pt.y > plotr.max.y-1) + pt.y = plotr.max.y-1; + if(pt.x < plotr.min.x) + pt.x = plotr.min.x; + if(pt.x > plotr.max.x-1) + pt.x = plotr.max.x-1; + return pt; +} + +static int +ptrow(Point pt) +{ + return (pt.y - plotr.min.y) / graphdy; +} + +static Proc* +procat(Point pt) +{ + int row, i; + Proc *pp; + + row = ptrow(pt); + for(i = 0; i < nproc; i++){ + pp = &proc[i]; + if(pp->s0 < pp->send && pp->row == row) + return pp; + } + return nil; +} + +static int +stateat(Proc *pp, Point pt) +{ + int s, last; + St *g; + + last = pp->s0; + for(s = pp->s0; s < pp->send; s++){ + g = pgraph(pp, s); + if(pt.x < g->x) + break; + last = s; + } + return last; +} + +static St* +graphat(Proc *pp, int s, Point pt, vlong npp) +{ + St *g0, *g, *ng, *eg; + + g0 = pgraph(pp, s); + + /* If all's in a pixel, don't bother */ + if(s < pp->send-1){ + eg = pgraph(pp, s+1); + if(eg->time - g0->time < npp) + return g0; + }else + eg = nil; + for(g = g0; g->pnext != 0 && graph[g->pnext] != eg; g = ng){ + ng = graph[g->pnext]; + if(ng->x > pt.x) + break; + } + return g; +} + +static void +tplumb(vlong t) +{ + static int fd = -1; + Plumbmsg *pm; + static char wd[128]; + Plumbattr *attr; + + if(fd < 0) + fd = plumbopen("send", OWRITE); + if(fd < 0){ + fprint(2, "%s: plumbopen: %r\n", argv0); + return; + } + if(wd[0] == 0) + getwd(wd, sizeof wd); + + pm = mallocz(sizeof *pm, 1); + attr = mallocz(sizeof *attr, 1); + if(pm == nil || attr == nil){ + free(pm); + fprint(2, "%s: no memory\n", argv0); + return; + } + pm->src = strdup(argv0); + pm->dst = strdup("edit"); + pm->wdir = strdup(wd); + pm->type = strdup("text"); + pm->data = strdup(plumbfname); + pm->ndata = strlen(pm->data); + attr->name = strdup("addr"); + attr->value = smprint("/^%T .*\\n", t); + + pm->attr = plumbaddattr(pm->attr, attr); + plumbsend(fd, pm); +} + +static void +cursorat(Point pt, int doplumb, Pos p) +{ + Proc *pp, *old; + St *g; + int gi, dx; + + pt = ptinplot(pt); + pp = procat(pt); + if(pp == nil) + return; + gi = stateat(pp, pt); + g = graphat(pp, gi, pt, p.npp); + + dx = pt.x - plotr.min.x; + drawtime(p.t0 + dx * p.npp, p.ival); + drawinfo(g); + old = current; + current = pp; + if(old != nil) + drawpid(old); + drawpid(current); + flush(TimeAndPids); + if(doplumb) + tplumb(g->time); +} + +static void +printproc(Biobuf *b, Proc *pp, vlong t0, vlong ival) +{ + St *g0, *ge, *g; + vlong tend; + + if(t0 < 0 || ival < 0){ + t0 = 0; + tend = graph[ngraph-1]->time + 1; + }else + tend = t0+ival; + ge = pgraph(pp, pp->send-1); + g0 = pgraph(pp, pp->s0); + + for(g = g0; g != ge; g = graph[g->pnext]) + if(g->time >= t0 && g->time < tend) + Bprint(b, "%G\n", g); +} + +static void +printallat(Biobuf *b, vlong t0, vlong ival, int rmin, int rend) +{ + Biobuf *bout; + int i; + + if(rmin < 0 || rend < 0){ + rmin = 0; + rend = nproc; + }else if(rend > nproc) + rend = nproc; + + if(b != nil) + bout = b; + else{ + bout = Bopen("ptrace.out", OWRITE); + if(bout == nil){ + drawnotice("write failed"); + flush(JustTime); + return; + } + } + for(i = rmin; i < rend; i++) + printproc(bout, &proc[i], t0, ival); + + Bprint(bout, "\n"); + + if(b == nil){ + drawnotice("written ptrace.out"); + flush(JustTime); + Bterm(bout); + }else + Bflush(b); +} + +static void +flagsweep(Point p0) +{ + line(screen, Pt(p0.x, p0.y-8), Pt(p0.x, p0.y+8), + ARROW(4, 4, 2), ARROW(4, 4, 2), 1, display->black, ZP); + line(screen, Pt(p0.x-10, p0.y), Pt(p0.x+10, p0.y), + ARROW(4, 4, 2), ARROW(4, 4, 2), 1, display->black, ZP); + flushimage(display, 1); +} + +static void +sweep(int b, Point p0, Pos *p) +{ + enum{None, Left, Right}; + int where, rmin, rend; + Point pt; + Rectangle r; + Mouse m; + Pos np; + + p0 = ptinplot(p0); + flagsweep(p0); + where = None; + do{ + recv(mousectl->c, &m); + pt = ptinplot(m.xy); + if(pt.x > p0.x && where != Right){ + setcursor(mousectl, &rightcursor); + where = Right; + }else if(pt.x <= p0.x && where != Left){ + setcursor(mousectl, &leftcursor); + where = Left; + } + r = canonrect(Rpt(p0, pt)); + }while(m.buttons); + + np = *p; + np.t0 += (r.min.x-plotr.min.x) * np.npp; + if(np.t0 > graph[ngraph-1]->time) + np.t0 = graph[ngraph-1]->time; + + np.ival = np.npp * Dx(r); + if(np.ival < US(1)) + np.ival = US(1); + if(np.ival > graph[ngraph-1]->time + US(1)) + np.ival = graph[ngraph-1]->time + US(1); + + rmin = ptrow(r.min); + rend = ptrow(r.max) + 1; + switch(b){ + case 1: + *p = np; + locate(p); + break; + case 2: + printallat(nil, np.t0, np.ival, rmin, rend); + break; + case 4: + printallat(bout, np.t0, np.ival, rmin, rend); + break; + } +} + +static void +setrows(void) +{ + int i; + + for(i = 0; i < nproc; i++) + proc[i].row = i; +} + +static void +debugdump(Pos p) +{ + Proc *pp; + int i; + + Bprint(bout, "pos p0 %d pend %d t0 %T ival %T\n", + p.p0, p.pend, p.t0, p.ival); + for(i = 0; i < nproc; i++){ + pp = &proc[i]; + Bprint(bout, "proc %d pid %d s0 %d send %d ns %d\n", + i, pp->pid, pp->s0, pp->send, pp->nstate); + } + // XXX + pp = &proc[13]; + Bprint(bout, "%R\n", plotr); + for(i = pp->s0; i < pp->send; i++) + Bprint(bout, "x %d %G\n", pgraph(pp, i)->x, pgraph(pp, i)); + Bflush(bout); +} + +static void +browse(void) +{ + Rune r; + Mouse m; + Pos p; + vlong tmax; + int paused, b; + Point lastxy; + enum{Ptr, Rsz, Kbd}; + Alt a[] = { + {mousectl->c, &m, CHANRCV}, + {mousectl->resizec, nil, CHANRCV}, + {keyboardctl->c, &r, CHANRCV}, + {nil, nil, CHANEND} + }; + + + setrows(); +restart: + p.p0 = 0; + p.pend = ngraph; + p.ival = graph[ngraph-1]->time + US(1); + p.t0 = 0; + busy(); + clear(); /* set plotr; locate uses that */ + locate(&p); + tmax = p.ival; + paused = Browsing; + plotallat(p); + flush(All); + for(;;){ + ready(paused); + switch(alt(a)){ + case Rsz: + if(getwindow(display, Refnone) < 0) + sysfatal("getwindow: %r"); + if(im != nil) + freeimage(im); + im = nil; + redraw: + busy(); + plotallat(p); + flush(All); + while(nbrecv(keyboardctl->c, &r) != 0) + ; + break; + case Ptr: + b = 0; + if(m.buttons){ + b = m.buttons; + lastxy = m.xy; + recv(mousectl->c, &m); + if(m.buttons == 0){ + if(b == 1 && lastxy.y < plotr.min.y) + if(lastxy.x < plotr.min.x + Dx(plotr)) + goto right; + else + goto left; + }else { + busy(); + sweep(b, lastxy, &p); + goto redraw; + } + }else + while(nbrecv(mousectl->c, &m) != 0) + ; + if(paused) + break; + + if(ptinrect(m.xy, plotr) && (b==4 || !eqpt(lastxy, m.xy))){ + cursorat(m.xy, b==4, p); + lastxy = m.xy; + } + break; + case Kbd: + switch(r){ + case 'D': + debugdump(p); + break; + case Kesc: + busy(); + goto restart; + case ' ': + paused = !paused; + break; + case 'q': + Bterm(bout); + threadexitsall(nil); + case '+': + case Kup: + busy(); + p.ival /= 2; + if(p.ival < US(1)) + p.ival = US(1); + locate(&p); + goto redraw; + case '-': + case Kdown: + if(p.ival > tmax) + break; + busy(); + p.ival *= 2; + locate(&p); + goto redraw; + case Kright: + right: + busy(); + p.t0 += p.ival/Scroll; + if(p.t0 > graph[ngraph-1]->time) + p.t0 = graph[ngraph-1]->time; + locate(&p); + goto redraw; + break; + case Kleft: + left: + if(p.t0 < p.ival/Scroll) + break; + busy(); + p.t0 -= p.ival/Scroll; + locate(&p); + goto redraw; + break; + case 's': + busy(); + printallat(nil, -1, -1, -1, -1); + break; + case 'p': + busy(); + printallat(bout, -1, -1, -1, -1); + break; + } + break; + default: + sysfatal("alt: %r"); + } + } +} + +static void +mkwin(int dx, int dy) +{ + char *wsys, line[256]; + int wfd; + + if((wsys = getenv("wsys")) == nil) + sysfatal("no wsys: %r"); + if((wfd = open(wsys, ORDWR)) < 0) + sysfatal("open wsys: %r"); + snprint(line, sizeof(line), "new -pid %d -dx %d -dy %d", + getpid(), dx, dy); + line[sizeof(line) - 1] = '\0'; + rfork(RFNAMEG); + if(mount(wfd, -1, "/mnt/wsys", MREPL, line) < 0) + sysfatal("mount wsys: %r"); + if(bind("/mnt/wsys", "/dev", MBEFORE) < 0) + sysfatal("mount wsys: %r"); +} + +static void +colors(void) +{ + piddx = stringwidth(font, "XXXXX" "XXXXXmXX"); /* 5 for name, 5 for pid */ + graphdy = font->height + 1; + bgcol = allocimagemix(display, DPalebluegreen, DWhite); + rdycol = allocimage(display, Rect(0,0,1,1), CMAP8, 1, DGreen); + waitcol = allocimage(display, Rect(0,0,1,1), CMAP8, 1, DRed); + runcol = allocimage(display, Rect(0,0,1,1), CMAP8, 1, DBlue); + if(bgcol == nil || rdycol == nil || waitcol == nil || runcol == nil) + sysfatal("color: %r"); + setcol = runcol; + sccol = runcol; + pfcol = waitcol; + faultcol = display->black; +} + +static void +usage(void) +{ + fprint(2, "Usage: %s [-dgpw] file\n", argv0); + exits(nil); +} + +void +threadmain(int argc, char **argv) +{ + int isdev, i; + + isdev = 0; + + ARGBEGIN { + case 'd': + isdev = 1; + break; + case 'g': + what |= Plot; + break; + case 'p': + what |= Dump; + break; + case 'v': + verb++; + break; + case 'w': + newwin++; + break; + default: + usage(); + } + ARGEND; + + if(argc != 1) + usage(); + infname = argv[0]; + if(!isdev) + plumbfname = argv[0]; + if(what == 0) + what = Dump; + + bout = Bopen("/fd/1", OWRITE); + if(bout == nil) + sysfatal("stdout: Bopen: %r"); + + fmtinstall('T', Tfmt); + fmtinstall('G', Gfmt); + + readall(infname, isdev); + if(ngraph == 0) + sysfatal("nothing to plot"); + + makeprocs(); + + if(what&Dump) + for(i = 0; i < ngraph; i++) + if(Bprint(bout, "%G\n", graph[i]) < 0) + sysfatal("out: %r"); + + if((what&Plot) == 0){ + Bterm(bout); + exits(nil); + } + + if(Bflush(bout) < 0) + sysfatal("out: %r"); + eventc = chancreate(sizeof(ulong), 10); + if(eventc == nil) + sysfatal("no memory"); + if(newwin) + mkwin(Wx, Wy); + if(initdraw(nil, "/lib/font/bit/pelm/unicode.8.font", argv0) < 0) + if(initdraw(nil, nil, argv0) < 0) + sysfatal("initdraw: %r"); + colors(); + if((mousectl = initmouse(nil, screen)) == nil) + sysfatal("mouse: %r"); + if((keyboardctl = initkeyboard(nil)) == nil) + sysfatal("keyboard: %r"); + browse(); + Bterm(bout); +} diff -Nru /sys/src/cmd/ptrace/rnd.c /sys/src/cmd/ptrace/rnd.c --- /sys/src/cmd/ptrace/rnd.c Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/rnd.c Mon Mar 14 00:00:00 2016 @@ -0,0 +1,1370 @@ +int vals[] = +{ +7705, 2262, 2142, 7373, 9059, 7194, 5147, 2540, 8904, 2072, 7264, +1529, 1476, 6606, 1323, 9135, 193, 1695, 8118, 9617, 2963, 8050, 135, +3734, 955, 7832, 1982, 5828, 1134, 190, 6640, 697, 4575, 3371, 1238, +1162, 7903, 3962, 9512, 1483, 474, 3537, 3598, 8449, 303, 5133, 1659, +7538, 6491, 5972, 1726, 715, 923, 8918, 9498, 7003, 8624, 4412, 6782, +6315, 1853, 940, 8890, 8402, 1891, 6200, 9272, 2500, 394, 3868, 1384, +927, 3686, 2019, 3308, 6873, 3830, 2281, 6874, 4608, 2108, 8261, 9851, +8563, 9772, 8099, 8320, 3185, 7776, 4040, 3324, 7561, 9792, 1887, +5743, 8421, 9441, 2900, 3572, 292, 8591, 7575, 5984, 9562, 2788, 9176, +1517, 1851, 8780, 7671, 155, 4375, 247, 5508, 5309, 9718, 6160, 4794, +4183, 5593, 7068, 8353, 9333, 8137, 1904, 58, 1079, 1513, 1248, 4266, +2518, 6108, 1304, 2027, 6377, 2984, 9904, 2375, 6724, 9637, 1485, +4722, 524, 114, 1060, 5849, 6948, 5018, 8979, 5025, 1160, 6529, 379, +617, 9834, 9159, 6057, 6566, 6487, 4738, 3880, 8628, 4956, 6478, 6437, +3735, 8425, 7407, 54, 1023, 7446, 1953, 3145, 1490, 652, 1778, 5071, +2343, 9349, 6422, 4426, 9611, 3811, 6875, 1101, 2206, 8122, 795, 6823, +6437, 7177, 1125, 706, 9826, 2410, 4089, 2338, 1147, 9323, 5033, 7844, +8723, 4948, 3710, 2086, 2247, 6267, 8810, 8641, 8209, 1240, 1119, +2225, 6330, 5047, 1326, 3713, 7239, 2034, 8384, 1640, 3758, 5124, +1610, 4326, 3193, 1905, 8454, 3695, 2519, 8586, 262, 365, 3396, 8402, +8932, 271, 149, 2863, 683, 9560, 848, 3522, 7520, 5945, 4881, 5869, +6237, 5710, 3820, 9552, 3310, 4432, 2796, 2851, 4979, 9127, 9730, +5825, 5813, 3620, 5407, 7932, 7947, 2141, 4305, 8636, 8498, 9465, +8407, 7577, 1093, 1835, 640, 7926, 6356, 5229, 9069, 1837, 3310, 9029, +2732, 7024, 5734, 6401, 4718, 2569, 9923, 9495, 1800, 7788, 1215, +7806, 3656, 5358, 9785, 1965, 1396, 7014, 7285, 2001, 9657, 5258, +5393, 1858, 8295, 55, 5584, 3820, 5389, 5608, 150, 7086, 2317, 4836, +3657, 3072, 6007, 8324, 504, 7752, 6695, 7443, 8329, 3693, 577, 9500, +5766, 7341, 8134, 3657, 1588, 2985, 829, 6993, 7830, 1104, 802, 313, +4942, 7568, 1702, 4469, 1731, 2732, 9714, 9615, 8666, 5953, 7547, +6597, 1435, 2611, 1123, 8692, 4882, 1029, 3639, 4559, 1931, 1956, 358, +9604, 9483, 4138, 3111, 5821, 2124, 4439, 2166, 9220, 3082, 5311, +8200, 1854, 8110, 5858, 9809, 1630, 7278, 4411, 4866, 1696, 4563, +2651, 3052, 5627, 4958, 503, 100, 5596, 2985, 9879, 4354, 8006, 7497, +4058, 9010, 2150, 3703, 2038, 1249, 6209, 7390, 6334, 8154, 2551, +1006, 9501, 4726, 2562, 4074, 7141, 6613, 2719, 935, 722, 7926, 8554, +2890, 7742, 9101, 6500, 7549, 2124, 612, 4267, 9448, 719, 2605, 9124, +2946, 7295, 145, 8245, 6117, 3527, 423, 6796, 5969, 8992, 789, 9537, +6304, 8867, 3462, 7669, 3578, 2038, 4780, 606, 1088, 1037, 7336, 5337, +9521, 8689, 5693, 3385, 7827, 2370, 3844, 2681, 5815, 6899, 6361, +2338, 61, 5572, 4834, 3805, 5160, 4957, 128, 1956, 9668, 2875, 1384, +7007, 1172, 202, 7009, 5159, 4057, 6253, 1315, 8536, 8690, 2847, 2448, +6381, 2615, 5265, 7165, 8788, 6763, 920, 3881, 1127, 8389, 7397, 5330, +299, 7728, 1398, 2975, 7256, 8705, 2299, 4712, 9860, 3229, 770, 5717, +810, 7356, 5474, 4219, 8395, 2128, 9989, 2312, 9275, 563, 4794, 9113, +6760, 4991, 6548, 9172, 1424, 7396, 9705, 1570, 376, 2831, 659, 1957, +1893, 9949, 6289, 2451, 6789, 5876, 4096, 6543, 6976, 7642, 5778, +4210, 6470, 2326, 8574, 1089, 3298, 1605, 8085, 2858, 6900, 5811, +2894, 5561, 7960, 5077, 335, 7244, 9309, 7340, 9794, 2140, 9219, 5977, +9538, 317, 1315, 3212, 5401, 4519, 6105, 3610, 3481, 9910, 9975, 8190, +3190, 703, 8613, 9574, 4413, 131, 6300, 4102, 3793, 4700, 5871, 3226, +7999, 8861, 6497, 7794, 5471, 5016, 7985, 3722, 7095, 8466, 9170, +4699, 92, 3246, 8176, 9372, 2136, 2716, 4242, 3374, 3804, 9996, 1243, +1091, 5272, 7276, 6682, 6790, 3131, 729, 740, 1655, 2931, 1164, 7373, +5514, 9763, 3939, 6187, 739, 9674, 778, 3809, 396, 5495, 5677, 3328, +7124, 7045, 4824, 9683, 2329, 1647, 9456, 8259, 1934, 2412, 6070, +2404, 8187, 535, 4377, 3768, 6550, 3876, 2, 7104, 4220, 7398, 6661, +669, 9860, 8438, 2948, 7412, 4042, 9904, 1310, 3750, 6603, 1258, 7718, +9082, 6237, 3025, 2810, 1599, 6393, 6356, 4015, 1222, 4828, 9197, 573, +6490, 8327, 989, 6062, 2287, 4276, 1590, 5449, 8174, 4059, 1335, 6463, +1026, 8566, 5847, 868, 437, 6836, 3692, 9512, 9985, 9584, 5145, 510, +2640, 8317, 3975, 9023, 7838, 7917, 9086, 7348, 4498, 6766, 5882, +5220, 2928, 2404, 7874, 8022, 3830, 5290, 7885, 3449, 5357, 3929, 82, +9417, 2469, 3642, 2088, 1950, 7818, 3709, 7535, 1681, 9765, 3442, +4390, 3399, 1499, 8067, 7022, 7151, 2028, 4138, 9083, 7413, 7845, +8915, 9308, 2681, 1607, 2439, 9181, 1752, 1904, 2669, 5391, 5876, 359, +7565, 2124, 5822, 2737, 353, 8751, 8845, 4929, 402, 195, 2951, 6491, +4932, 5572, 120, 2138, 5236, 6967, 9285, 1094, 9497, 4335, 8112, 3107, +6098, 7001, 1971, 238, 7466, 4817, 8958, 3261, 3762, 8544, 9028, 6604, +8221, 1554, 5608, 5668, 3979, 2197, 2556, 1261, 5431, 4085, 5337, +7663, 9201, 3972, 826, 5537, 184, 9565, 608, 9473, 4939, 5364, 3209, +4468, 1226, 9005, 4800, 4015, 1655, 7596, 8922, 7506, 9675, 737, 8196, +1072, 9491, 6126, 2402, 1001, 875, 4060, 8923, 2039, 2050, 8492, 9351, +6147, 5686, 2010, 2742, 4014, 3045, 2370, 7265, 5111, 5428, 3833, +9619, 513, 9492, 8634, 5932, 6809, 8639, 2099, 4107, 3514, 7450, 2130, +4672, 9560, 1006, 5340, 8018, 9602, 3405, 8442, 3974, 6027, 3272, +6106, 828, 5730, 7644, 5810, 7842, 7199, 6177, 8591, 919, 1945, 8546, +5312, 8290, 949, 9339, 6910, 6777, 1224, 8189, 396, 4932, 6172, 5667, +8691, 5551, 1262, 7148, 2513, 2654, 4975, 6769, 4646, 6483, 3114, +1331, 7942, 736, 6575, 156, 4882, 7979, 2706, 7461, 7127, 3376, 5768, +4445, 2354, 1055, 8250, 3654, 689, 5431, 778, 8517, 4845, 217, 6252, +1319, 8306, 5728, 9450, 1814, 5951, 2641, 1476, 7553, 3940, 2953, +5451, 3833, 5951, 7889, 5455, 7519, 1966, 5548, 7993, 4243, 4635, +1194, 4932, 2312, 7170, 7157, 8587, 5466, 732, 5067, 3951, 5749, 5036, +5547, 7623, 5843, 9394, 6776, 7789, 7052, 3183, 5671, 3586, 489, 970, +4713, 2306, 5001, 6867, 1478, 8206, 2808, 6759, 5880, 5519, 7889, +4300, 36, 7152, 7396, 5179, 6291, 6807, 8803, 1796, 4640, 2957, 7320, +8435, 98, 5756, 6906, 56, 7109, 4335, 2222, 5993, 5576, 41, 9770, +3240, 5583, 4962, 9970, 9528, 3575, 2129, 2327, 5044, 8305, 4699, +9200, 2815, 3636, 1993, 3887, 7989, 8920, 1792, 1730, 1142, 8288, +5149, 3796, 3864, 7865, 6530, 8530, 9712, 6179, 1208, 3176, 2572, +2303, 8807, 9783, 5190, 7720, 5939, 5477, 9943, 9682, 7787, 7137, +3828, 7156, 9020, 8834, 8596, 2349, 4188, 1561, 8349, 3511, 5276, +8543, 5364, 9204, 3729, 1464, 2440, 9244, 9394, 3916, 517, 2508, 9516, +8384, 2632, 5946, 3223, 4738, 2104, 4153, 9973, 5389, 5108, 132, 3189, +1413, 6985, 7896, 6649, 8904, 2651, 7994, 6901, 3371, 4203, 5986, +5632, 1771, 6592, 4871, 6279, 7514, 6269, 6887, 1479, 6136, 7998, +1286, 3306, 8808, 2158, 9131, 2256, 1658, 4600, 5257, 7015, 219, 1062, +9011, 8764, 7468, 596, 3992, 4057, 9804, 9902, 8919, 548, 3656, 7549, +2316, 5660, 5381, 7616, 4912, 6300, 4601, 4361, 9404, 2434, 3815, 502, +2710, 3653, 93, 1738, 6551, 5997, 2280, 5790, 4622, 5631, 744, 1479, +6130, 2753, 762, 8506, 1712, 8144, 1573, 186, 4796, 9161, 4743, 7058, +2489, 844, 8165, 7472, 3259, 6058, 7528, 1463, 4242, 4839, 368, 4857, +754, 1205, 706, 6323, 3625, 1170, 1239, 9461, 339, 4778, 5345, 2121, +9860, 131, 870, 1763, 3021, 9590, 8388, 4035, 2548, 9102, 3254, 1810, +7194, 3733, 6748, 4829, 621, 9744, 8582, 4563, 6691, 9545, 8387, 8684, +9340, 1063, 7756, 8183, 822, 1933, 4606, 3091, 979, 7553, 4082, 1143, +4060, 2192, 996, 573, 4719, 7876, 9270, 5299, 7653, 8710, 201, 3122, +5588, 3859, 4122, 4867, 4738, 1264, 6183, 5004, 3971, 5699, 5604, +9469, 7428, 5740, 3957, 837, 1713, 4078, 7056, 8706, 8930, 2894, 8066, +6522, 878, 877, 5983, 130, 35, 6491, 2112, 921, 1278, 1937, 3532, +2795, 2483, 3903, 1030, 5832, 5527, 9859, 6552, 5418, 7702, 7634, +3465, 8790, 6070, 6871, 546, 68, 3252, 473, 5686, 3400, 7975, 8505, +6937, 2240, 3783, 6606, 9124, 2819, 1702, 5783, 5616, 5878, 4210, +2945, 7091, 8397, 5501, 4708, 6682, 7805, 9021, 3011, 3824, 8927, +5300, 3611, 7869, 6555, 6297, 798, 1109, 784, 6415, 6058, 1724, 3242, +8114, 6953, 9666, 1942, 6864, 7271, 751, 8615, 4469, 3383, 8478, 1330, +8362, 1423, 8825, 1066, 4240, 8385, 2404, 6491, 4008, 6822, 5364, +1265, 5468, 7698, 5313, 7236, 9723, 8249, 5401, 7749, 7580, 8396, +7097, 6323, 695, 918, 1204, 1892, 8731, 108, 3246, 6799, 7364, 6384, +5814, 4248, 1106, 7384, 307, 779, 2396, 6598, 7074, 617, 7861, 9019, +5559, 9248, 7667, 7231, 318, 3076, 6264, 7972, 6254, 2360, 1163, 4351, +4633, 8993, 5212, 1517, 9633, 6207, 3153, 5096, 5865, 5209, 3834, +4343, 7799, 7025, 4971, 3937, 2658, 4893, 5754, 8207, 3593, 1202, +3296, 4297, 6368, 8941, 2551, 5621, 8880, 3165, 9507, 2587, 2204, 497, +2226, 6847, 7653, 4094, 3205, 8175, 2855, 907, 1486, 6305, 8429, 4793, +6574, 9670, 8672, 9987, 5370, 246, 9839, 6638, 3132, 2264, 3269, 5347, +2976, 7790, 6909, 17, 1681, 866, 5471, 8889, 1366, 6426, 8032, 2362, +62, 5821, 5208, 4083, 7541, 4838, 9543, 4590, 2028, 6799, 8336, 9502, +6508, 5237, 4857, 6677, 9634, 8679, 7974, 4533, 9407, 9011, 2330, +9538, 9263, 6646, 6245, 9633, 2406, 1209, 4705, 3650, 5548, 1488, +2522, 5754, 8413, 8984, 6652, 938, 9697, 5745, 8741, 2100, 7574, 2200, +8391, 9559, 772, 8416, 8053, 6660, 7719, 1082, 6430, 9389, 1615, 230, +8923, 7274, 4958, 249, 1200, 3794, 5972, 2692, 6828, 8624, 1606, 7588, +431, 5066, 6372, 5112, 7888, 1421, 8251, 2, 5870, 6579, 3826, 9771, +4495, 7747, 350, 14, 4805, 621, 7378, 1536, 7603, 5614, 4019, 9002, +5509, 1233, 1022, 3818, 7899, 3712, 30, 835, 9789, 4795, 6406, 2192, +6753, 330, 8184, 9212, 9813, 8570, 6603, 8309, 1467, 2562, 3324, 6910, +7311, 3860, 6079, 2696, 8791, 4160, 3362, 5101, 2595, 5749, 3741, +3735, 4494, 1822, 8999, 5020, 7009, 6776, 6277, 9086, 3265, 6328, +8656, 4239, 6623, 4061, 6293, 8332, 951, 2400, 3195, 6567, 3429, 709, +1190, 3208, 9637, 9001, 3259, 9356, 5687, 4234, 9028, 1453, 9392, +3689, 2898, 1377, 2260, 4963, 2853, 9225, 631, 7384, 3100, 1907, 2681, +5550, 5606, 7147, 1574, 3535, 187, 6584, 7327, 9990, 8566, 9534, 426, +4230, 9638, 6695, 7616, 7908, 3436, 9228, 5580, 3829, 8353, 4807, +3336, 5459, 6089, 2627, 6791, 3878, 8388, 9129, 2035, 2141, 5724, +1537, 7729, 1812, 8433, 8573, 6448, 1952, 6998, 360, 9046, 2790, 8083, +7167, 5193, 1489, 7852, 2200, 6949, 4362, 5842, 5923, 9825, 4866, +8797, 1279, 9180, 7076, 6776, 9740, 3116, 4540, 5574, 9342, 6174, +4141, 4214, 295, 8464, 7560, 7050, 8233, 4270, 3929, 7003, 5590, 1309, +8850, 5402, 600, 2860, 7261, 9404, 2780, 7691, 5828, 566, 5337, 8416, +7787, 4549, 6748, 4042, 2945, 8662, 4664, 182, 4613, 6517, 1356, 5340, +2253, 8244, 2122, 8537, 4887, 5499, 8788, 1027, 9479, 2308, 378, 158, +4104, 7287, 170, 7517, 4042, 7682, 836, 6833, 1042, 8794, 7150, 8268, +7194, 4495, 3714, 8961, 5782, 1812, 5941, 447, 894, 5777, 65, 602, +9495, 3306, 8281, 8523, 2016, 729, 2011, 7878, 8392, 1438, 3064, 3203, +6290, 9520, 2486, 1994, 1944, 6864, 3347, 4284, 3749, 2897, 9227, +4503, 4022, 2357, 8355, 2417, 1053, 4810, 4954, 9675, 4580, 966, 6638, +8687, 5210, 7643, 1582, 7954, 5317, 9681, 4957, 3106, 5785, 8175, +1460, 2680, 1663, 7806, 5016, 9576, 229, 9109, 293, 9118, 5551, 2422, +231, 3957, 5377, 8655, 528, 7060, 1492, 1594, 4367, 4216, 3784, 4268, +2207, 7779, 8896, 8303, 7282, 7748, 9025, 7939, 3136, 1402, 7720, +7055, 1428, 1623, 3474, 6626, 9724, 3865, 4529, 8314, 1111, 5941, +8288, 8713, 9810, 1882, 5748, 231, 9687, 71, 2150, 3920, 2845, 3751, +8653, 34, 6660, 5358, 9500, 7581, 1737, 3276, 2890, 9475, 8945, 2756, +3662, 2739, 5965, 3694, 3175, 295, 2023, 4197, 3963, 746, 8469, 5103, +4841, 329, 192, 304, 8182, 258, 2288, 4952, 596, 6546, 4012, 5511, +2628, 3602, 6435, 6089, 6723, 5029, 747, 7479, 4031, 3967, 5161, 2471, +3695, 783, 8019, 6750, 200, 2730, 6841, 1242, 1260, 7261, 6866, 459, +398, 3564, 4549, 2603, 1969, 197, 837, 5064, 456, 8774, 2363, 1626, +4514, 489, 3396, 4404, 4916, 9738, 3252, 9950, 4529, 2757, 2939, 2246, +520, 5785, 2, 3171, 7911, 7184, 23, 6539, 480, 924, 1388, 3591, 7280, +1525, 4522, 1074, 860, 4158, 4124, 8850, 2131, 2949, 2562, 4837, 8976, +6082, 5721, 3677, 9125, 5233, 5658, 5141, 8855, 179, 5200, 4331, 3628, +9305, 4182, 2955, 7196, 8041, 4528, 9874, 4017, 8956, 4316, 8382, 311, +6191, 902, 7016, 4291, 3094, 9092, 9990, 4324, 3776, 8677, 9319, 2709, +9725, 6167, 3335, 7025, 6630, 9887, 1333, 9059, 7889, 6447, 1244, +1473, 5370, 7350, 4622, 448, 2088, 241, 734, 7022, 564, 4449, 53, +5973, 9742, 3145, 4919, 1655, 4281, 3999, 7358, 854, 6182, 8348, 3082, +4885, 7157, 4991, 1375, 3361, 8370, 4896, 5710, 4347, 9571, 8106, +3310, 2044, 8860, 1900, 2946, 4446, 7852, 3147, 4456, 6183, 9818, +5824, 3315, 8320, 3888, 5616, 6116, 7361, 4329, 2011, 4495, 2369, +2431, 4421, 1094, 5086, 2873, 2511, 8666, 5124, 1717, 1632, 6048, +7531, 4536, 9074, 1170, 3655, 1122, 7396, 2629, 4634, 3692, 9986, +3926, 4988, 2200, 2321, 8867, 5498, 9978, 4733, 6671, 9363, 9255, +6862, 410, 6361, 7969, 8256, 5223, 7596, 6167, 3454, 8348, 5472, 2117, +8745, 6177, 2314, 3400, 6601, 1231, 133, 5751, 6102, 6266, 3897, 1921, +8415, 592, 4102, 8668, 4840, 7282, 2736, 1036, 5184, 7351, 7296, 1892, +4984, 178, 3779, 7481, 638, 9678, 3725, 4010, 84, 6819, 603, 6156, +7499, 8800, 3288, 4053, 143, 8762, 6907, 6491, 1726, 4851, 8277, 7506, +3858, 7873, 1590, 5324, 2392, 595, 9451, 1825, 7625, 6496, 1220, 7766, +8461, 6984, 1470, 8715, 7792, 4795, 3028, 9287, 5995, 3169, 9899, +5500, 3885, 926, 6752, 8731, 4516, 6949, 5799, 8537, 3627, 1546, 6255, +3665, 8411, 1364, 4885, 3870, 6176, 7631, 3432, 6370, 9130, 6942, +2849, 5906, 5018, 7903, 5099, 9746, 6416, 7386, 6272, 9818, 9865, +5573, 2146, 7627, 2499, 4923, 3779, 3864, 8853, 4512, 9641, 395, 4584, +8355, 8488, 8826, 564, 470, 8274, 8205, 1662, 9551, 2030, 3932, 8569, +1117, 1230, 1482, 6971, 9078, 2719, 2757, 1340, 6323, 8680, 8734, +5771, 6340, 8307, 2591, 5404, 6268, 5380, 672, 5237, 3693, 5099, 1459, +8287, 581, 7842, 6525, 725, 3038, 5161, 8633, 9551, 1034, 2132, 8304, +5810, 6963, 8110, 8799, 1005, 987, 6818, 816, 1543, 1491, 8836, 743, +552, 7802, 7784, 5255, 4834, 8379, 7056, 1562, 1051, 1996, 322, 2255, +7141, 1260, 6762, 3635, 3874, 4176, 3649, 222, 5572, 2779, 5925, 108, +2413, 7841, 4372, 9012, 9754, 2718, 9827, 3401, 4200, 4154, 1190, +6569, 6389, 8034, 9955, 4971, 845, 5303, 5624, 8698, 4047, 9721, 3404, +7531, 1846, 6053, 2177, 3206, 9264, 5463, 9888, 2236, 1140, 9706, +3161, 8839, 679, 7414, 7860, 3473, 4983, 9969, 6948, 3721, 1724, 6891, +5935, 2915, 2215, 2002, 4656, 7000, 79, 714, 306, 8563, 3182, 1024, +6192, 1849, 1249, 8807, 7275, 9709, 2254, 2005, 8121, 6823, 670, 7476, +705, 3827, 4535, 9799, 988, 7268, 3075, 1181, 2198, 6771, 4438, 1311, +3909, 5480, 9875, 3733, 274, 9059, 1774, 625, 5458, 4196, 3716, 6848, +5158, 2311, 1468, 5213, 9288, 4072, 6599, 6190, 2100, 3957, 7968, +5462, 5474, 1131, 3216, 8991, 393, 7655, 8269, 3927, 3031, 9114, 4270, +622, 3154, 5560, 5254, 2883, 5812, 4727, 6727, 113, 7650, 880, 3448, +1099, 3122, 945, 1632, 2991, 5298, 2581, 4657, 6080, 3508, 2837, 1169, +1744, 3401, 9586, 5571, 6035, 4847, 9598, 2482, 3169, 6984, 2459, +3895, 3127, 9127, 7993, 6942, 1301, 839, 3830, 6626, 9839, 370, 9397, +65, 2305, 7238, 4872, 103, 8982, 8649, 3569, 4849, 1257, 7716, 6464, +122, 8048, 5832, 4434, 2580, 3095, 1470, 7791, 9375, 1481, 8114, 6076, +6484, 1307, 3384, 9235, 6305, 4596, 4438, 3435, 676, 5358, 334, 49, +682, 8770, 3848, 8072, 2725, 8232, 6340, 9585, 3216, 1739, 9888, 3228, +1337, 7740, 6538, 9144, 7655, 5861, 5043, 7743, 2298, 9751, 4182, +8496, 5863, 3204, 320, 1095, 6475, 5255, 5796, 8101, 879, 71, 6819, +2135, 1475, 3721, 4147, 8134, 5338, 1485, 1911, 8207, 4407, 8824, +3017, 3358, 1817, 1413, 1959, 1908, 4106, 6965, 1328, 9618, 6400, 27, +8078, 6044, 5933, 6266, 6493, 2421, 8776, 2729, 4355, 8849, 4554, +9201, 2084, 107, 3064, 9609, 5883, 8901, 8886, 3771, 1675, 4143, 1783, +4512, 345, 2092, 3585, 681, 1129, 9048, 4962, 5169, 9080, 4301, 8017, +6756, 9447, 9571, 867, 8872, 2683, 2064, 4540, 8323, 3352, 6336, 3480, +2614, 5076, 511, 3460, 1127, 9502, 8102, 4207, 2005, 533, 1397, 3774, +7697, 6633, 9081, 7835, 3870, 6284, 8655, 4358, 933, 6897, 8654, 1646, +8067, 8181, 1184, 3225, 4610, 7177, 2171, 5419, 6602, 1576, 6226, 133, +2715, 6336, 2606, 6774, 8982, 7651, 4135, 1725, 9258, 999, 8022, 87, +2758, 5200, 9526, 1596, 7236, 8062, 2285, 3555, 4143, 3056, 9879, +5290, 8802, 9721, 7670, 978, 6593, 6931, 919, 120, 4130, 726, 1175, +5127, 1623, 6584, 2870, 3760, 7851, 2683, 379, 1582, 3257, 6128, 5352, +7982, 9769, 600, 7888, 2231, 4617, 2138, 2674, 5137, 3089, 8083, 5906, +6104, 1044, 7267, 6577, 9294, 7104, 5109, 4044, 8759, 6971, 9480, 109, +4069, 1303, 7495, 9503, 5853, 9469, 7956, 3263, 191, 6584, 1838, 1824, +9742, 6631, 4163, 4311, 5344, 4238, 3194, 5823, 4008, 405, 7320, 1008, +9075, 3790, 6315, 7322, 1691, 707, 5138, 6148, 2368, 8137, 5311, 7859, +5226, 7030, 4539, 7558, 9286, 857, 601, 5328, 5664, 965, 6806, 507, +6671, 5936, 3132, 1010, 5731, 7526, 2362, 2899, 419, 2146, 4073, 8127, +4845, 3710, 8058, 9843, 1241, 2624, 3731, 225, 512, 9969, 469, 4404, +177, 7137, 6277, 165, 690, 3911, 9527, 3454, 9107, 7183, 3622, 358, +6126, 9295, 9574, 9450, 8037, 9325, 1161, 815, 6003, 5978, 9817, 3236, +9521, 7748, 3539, 4012, 3707, 7484, 9113, 4411, 3130, 8186, 2688, +1870, 7871, 1458, 1808, 6544, 263, 2594, 5791, 1893, 89, 4674, 8232, +9741, 5595, 7963, 198, 5063, 3538, 6, 4211, 1326, 7928, 7273, 1958, +3425, 6431, 1744, 8343, 1654, 5241, 7192, 6362, 7080, 412, 7163, 5184, +5582, 5785, 8684, 2140, 9417, 9629, 2804, 1694, 9806, 7340, 3178, +5389, 8997, 605, 2999, 7176, 8493, 9027, 2650, 7122, 4358, 7323, 299, +3430, 6620, 2002, 2297, 1870, 54, 5904, 1992, 7261, 5367, 9777, 831, +9260, 7684, 1077, 8158, 6126, 3425, 9916, 1121, 4568, 771, 2830, 5295, +8290, 3754, 3963, 9150, 4719, 9591, 12, 9792, 5613, 1330, 8945, 9960, +6117, 536, 6760, 7964, 5551, 4041, 2170, 1680, 4229, 1845, 3326, 5711, +1457, 9248, 9247, 5000, 4767, 9909, 8339, 5732, 7350, 2321, 5342, +5179, 1038, 861, 7376, 4140, 5432, 7610, 8334, 7981, 7603, 5710, 1144, +2075, 5345, 8309, 9762, 9696, 766, 4899, 2382, 6238, 257, 6207, 6067, +8288, 8333, 3783, 8912, 8424, 6467, 3388, 1481, 2412, 2798, 337, 7912, +4225, 7867, 7938, 4053, 0, 932, 9645, 3843, 9748, 4240, 2555, 1291, +6267, 8074, 1933, 815, 9762, 4949, 7831, 6996, 465, 5643, 3612, 2449, +5200, 828, 7879, 1160, 502, 6549, 4662, 1037, 3295, 4478, 3918, 7198, +1176, 7747, 4283, 2785, 7166, 1838, 8355, 5139, 2762, 5793, 3580, +1786, 8258, 6144, 8810, 8181, 2440, 6418, 5855, 8211, 1476, 5692, +3534, 621, 4322, 6816, 6581, 2110, 8854, 8471, 3994, 5891, 5717, 4728, +8731, 4207, 8353, 6548, 9227, 1587, 4642, 2210, 9303, 6260, 5359, +9567, 2952, 7574, 7162, 9596, 172, 3292, 9818, 1904, 6469, 4756, 9947, +1013, 248, 198, 6497, 8693, 9639, 1755, 5275, 4197, 1265, 9797, 4652, +9548, 4667, 4494, 7237, 4212, 3662, 2060, 9539, 1919, 1693, 7506, +4600, 5977, 2063, 3352, 5986, 7534, 8292, 7851, 3648, 1830, 2096, +6489, 4527, 8110, 8908, 5099, 5929, 8013, 880, 3833, 7387, 8078, 6937, +9559, 4268, 6859, 5175, 5164, 6319, 4973, 9681, 9394, 1779, 6336, +4018, 2941, 5455, 4907, 7483, 5334, 9967, 7180, 8003, 2621, 9949, +3899, 8170, 5061, 3136, 1279, 6268, 9069, 7425, 5135, 8652, 2214, +3174, 784, 2460, 5843, 9235, 8506, 7838, 5444, 5019, 5655, 3687, 1467, +7864, 3901, 1367, 2332, 1105, 449, 5660, 7712, 9155, 4202, 2059, 9691, +6409, 3542, 3344, 3500, 7186, 4144, 2844, 2955, 6048, 9257, 7784, +9200, 5896, 8693, 4499, 5101, 621, 4104, 7900, 5048, 7105, 56, 9136, +4722, 3299, 728, 9192, 7014, 2406, 12, 9475, 6004, 8694, 4572, 5634, +8781, 1022, 7797, 1890, 644, 8695, 1515, 4519, 3476, 2452, 4651, 8893, +8737, 7837, 6083, 1811, 7715, 1677, 3473, 9119, 6006, 6395, 8777, +8602, 8770, 8666, 4893, 4615, 7141, 2964, 6942, 9979, 1850, 7093, +9608, 9692, 7998, 8659, 4583, 8218, 6939, 9488, 451, 8001, 653, 389, +2605, 7706, 8626, 1494, 3883, 5965, 1813, 2291, 4289, 8162, 4692, +6016, 9289, 6546, 5067, 5058, 2750, 9198, 7756, 5505, 5079, 6119, +6682, 881, 8172, 7528, 1255, 7968, 4215, 4598, 8049, 7924, 2352, 2874, +5907, 9370, 36, 5599, 6206, 7823, 3142, 7375, 6838, 7915, 3610, 4127, +8579, 8782, 328, 8649, 473, 349, 4150, 829, 6623, 8704, 228, 2920, +7625, 9377, 5431, 7765, 1098, 1000, 9761, 3487, 5702, 3688, 8463, 617, +530, 9083, 4145, 8063, 8772, 4216, 8622, 9758, 9536, 9412, 8986, 9338, +6804, 7455, 4130, 7248, 707, 7950, 5770, 5021, 654, 7518, 7505, 7768, +3429, 8071, 2598, 5889, 1972, 4936, 801, 1916, 2804, 9805, 5096, 9439, +692, 6600, 7098, 1205, 2551, 8107, 9929, 1641, 3028, 158, 6493, 4206, +4228, 984, 4658, 7562, 9622, 8851, 7427, 8529, 1055, 9172, 4056, 2858, +4591, 1891, 7230, 9320, 9561, 3290, 4493, 7371, 5143, 5634, 723, 5151, +6817, 5671, 1944, 7027, 7929, 2468, 8910, 4014, 4666, 8956, 326, 3306, +7298, 2195, 9400, 1937, 7495, 6223, 3951, 7283, 2247, 8886, 661, 4656, +6400, 5754, 7187, 4492, 9945, 4957, 3646, 1637, 6025, 8132, 6890, +3527, 5146, 3275, 4408, 4165, 3962, 8124, 2998, 538, 335, 5944, 8897, +9797, 23, 9890, 1472, 7081, 3351, 7712, 8513, 2072, 117, 4913, 9473, +5688, 9528, 7543, 7550, 3934, 1692, 1463, 7701, 4516, 5064, 233, 2687, +5841, 7820, 6863, 2716, 357, 1996, 8709, 2212, 7352, 2653, 1393, 7691, +5178, 8634, 5958, 9516, 6824, 4540, 7766, 3052, 8839, 4819, 6907, +9073, 6654, 1189, 607, 7891, 1987, 3803, 4977, 7045, 3249, 9950, 5267, +4080, 9854, 6760, 4897, 2092, 4809, 5737, 1709, 3735, 9773, 5274, 140, +847, 3571, 8842, 2718, 8249, 4596, 8010, 2553, 818, 9397, 7961, 6770, +925, 9366, 5670, 4177, 5536, 6053, 7646, 6043, 4136, 7616, 3873, 6150, +5263, 8536, 1546, 9834, 4968, 1089, 4931, 5106, 7827, 421, 1298, 7720, +1742, 5549, 1668, 6688, 5579, 2550, 2580, 5653, 3634, 3496, 4949, +1252, 7679, 9798, 5295, 6973, 2722, 5525, 3613, 7095, 4123, 9678, +2415, 6912, 2565, 9240, 7073, 6940, 3737, 5632, 3241, 9421, 9042, +8140, 7145, 5493, 7315, 9484, 7764, 2031, 645, 3604, 3235, 9942, 6243, +9754, 6884, 8605, 1016, 4960, 7826, 3722, 2047, 5618, 223, 5179, 3024, +1434, 4539, 7632, 5335, 5290, 7751, 7256, 2612, 6808, 8317, 5132, +1436, 4703, 8945, 1176, 2355, 5383, 3055, 3811, 3291, 5941, 4679, +8597, 3386, 6883, 7697, 6837, 5410, 5279, 3645, 8969, 3963, 8140, +3118, 8721, 3692, 7114, 8528, 1044, 7565, 6769, 6416, 8093, 2845, +3318, 4246, 5783, 7903, 8263, 1211, 1139, 1119, 8818, 3962, 1771, +2593, 753, 2730, 4710, 8586, 8298, 2312, 6414, 5843, 5237, 6845, 9833, +8937, 3666, 3961, 5679, 9204, 524, 9804, 5991, 1834, 1155, 7213, 1692, +7488, 3748, 1936, 1795, 3553, 5156, 1893, 613, 9416, 9248, 4031, 1864, +6651, 1152, 6238, 2002, 195, 242, 9513, 2680, 1568, 2259, 7813, 5792, +220, 9487, 5066, 8445, 4853, 3996, 5726, 8037, 770, 5306, 4468, 1429, +4649, 8072, 6340, 6976, 88, 4638, 2007, 4501, 7224, 6944, 5714, 8029, +5482, 642, 9971, 9971, 7716, 8021, 5809, 5000, 4866, 5337, 307, 5896, +6879, 7274, 488, 3933, 7662, 6760, 2603, 3769, 4610, 1731, 9999, 5325, +227, 8896, 8074, 3325, 4745, 4517, 1673, 6845, 4295, 9359, 9852, 7705, +6344, 9378, 4354, 400, 927, 1792, 9010, 962, 6956, 1783, 1218, 9279, +5054, 7235, 6959, 9418, 2985, 3802, 9619, 8100, 502, 7449, 492, 6703, +7052, 5920, 18, 2065, 4670, 5974, 6471, 5727, 3313, 258, 9353, 8374, +5235, 1150, 22, 3886, 5625, 1268, 7230, 6119, 5469, 3749, 2112, 2728, +6996, 8471, 9116, 2814, 2240, 5219, 8001, 6319, 5580, 4316, 386, 8663, +7464, 1349, 5174, 8422, 371, 3686, 6193, 4072, 5575, 1492, 4192, 8507, +1711, 1264, 2641, 9358, 6891, 4415, 6333, 6682, 6633, 1736, 4290, +7825, 7639, 5981, 7629, 7597, 3494, 7968, 9873, 370, 9737, 9272, 5099, +7119, 5907, 8057, 2045, 1174, 6767, 5709, 976, 7115, 268, 7115, 677, +2973, 4378, 780, 6940, 9618, 3751, 2016, 6171, 5923, 4784, 3868, 4776, +2533, 9731, 9486, 2627, 1297, 4050, 8262, 4753, 3091, 9410, 9497, +3764, 7822, 5972, 224, 4798, 1307, 963, 3989, 4060, 3973, 7619, 4436, +8489, 7268, 9551, 315, 5818, 8756, 3965, 5191, 6146, 1847, 5858, 3944, +4318, 4008, 9271, 3605, 1951, 9674, 1756, 1649, 7900, 8107, 9835, +1366, 4970, 1352, 4468, 8123, 7711, 1298, 5753, 2647, 2693, 975, 7081, +9645, 1616, 9732, 700, 9859, 8042, 7309, 3760, 5264, 9227, 9811, 7582, +9461, 8684, 2737, 3711, 6358, 4962, 6989, 52, 108, 5848, 1129, 3070, +9202, 9260, 6167, 3644, 3224, 400, 6006, 6886, 5796, 3243, 2472, 3354, +9843, 8338, 2493, 6975, 5908, 3168, 9782, 895, 5361, 7197, 1698, 749, +4210, 1362, 833, 4347, 5232, 273, 2731, 9653, 4041, 2615, 7659, 5056, +3411, 3111, 8881, 3985, 2382, 6977, 6135, 8307, 2164, 7533, 9707, +7834, 4374, 3497, 4440, 1216, 9909, 5647, 3265, 8425, 1010, 7485, +7187, 9817, 172, 3853, 1721, 4962, 770, 2649, 8563, 372, 9441, 2634, +4260, 1869, 306, 7502, 7353, 939, 1263, 7737, 7907, 759, 6980, 1673, +2691, 6360, 8405, 4947, 5472, 1490, 3102, 8715, 9093, 3788, 30, 4993, +8042, 637, 8745, 7384, 7719, 6581, 9735, 6208, 9159, 1568, 1134, 7121, +2069, 8732, 7231, 9860, 2235, 1239, 8279, 2661, 4922, 1297, 4103, +9707, 1629, 9553, 1536, 6238, 2169, 1653, 7059, 2126, 7074, 2973, +6770, 4924, 8278, 651, 1268, 6327, 2219, 1672, 322, 8953, 273, 3927, +2335, 6389, 6284, 3316, 7448, 2973, 6377, 9131, 2165, 4556, 7180, 253, +5475, 4454, 2540, 2421, 5649, 8534, 8447, 6995, 1455, 4738, 798, 9736, +5408, 3449, 635, 3172, 3553, 4100, 6181, 8790, 640, 1858, 6240, 5651, +1815, 6949, 5645, 4063, 9309, 5887, 4767, 39, 5049, 9737, 7914, 1472, +6453, 556, 355, 5083, 2311, 5139, 6261, 4793, 8999, 9514, 2432, 2889, +4706, 6470, 6487, 3347, 9585, 7319, 8921, 985, 3379, 901, 6625, 3213, +4692, 1377, 2226, 2900, 2793, 9737, 4860, 6896, 1111, 684, 3461, 1331, +3623, 5976, 4964, 7612, 2507, 3548, 8195, 9429, 8641, 255, 8917, 3068, +7661, 5088, 7018, 6971, 4691, 3302, 735, 2733, 291, 279, 8028, 6265, +4832, 6901, 4228, 6540, 9018, 4991, 9479, 2012, 2705, 6440, 1582, +5194, 637, 3272, 1975, 8678, 8391, 4955, 8348, 3873, 7749, 6945, 1258, +6408, 6716, 8172, 3223, 4307, 6762, 1946, 4092, 3121, 5414, 6841, 809, +9241, 9770, 7936, 1184, 5812, 1221, 1692, 1072, 8046, 2106, 6501, +8316, 516, 4711, 5981, 3956, 1587, 7078, 9942, 8860, 1029, 1965, 455, +8459, 2896, 1901, 3244, 2049, 2547, 7947, 8062, 6182, 6659, 8111, +8156, 9368, 863, 5047, 6067, 986, 8189, 3152, 1704, 9200, 8421, 318, +1623, 6901, 6435, 3848, 2037, 504, 2873, 1200, 2773, 2845, 8805, 9886, +2122, 4203, 6519, 9683, 6099, 7722, 6840, 6005, 9708, 2590, 1902, +6485, 5017, 2443, 7997, 828, 9835, 9597, 3544, 7831, 79, 8803, 3731, +5796, 4532, 2217, 4986, 6352, 6773, 2866, 8362, 6553, 9706, 3924, +7181, 7377, 6134, 1987, 7407, 9040, 3128, 6740, 9509, 1727, 2212, 324, +1682, 3900, 7872, 4317, 3360, 9552, 6862, 6465, 1065, 9728, 384, 6871, +1591, 4647, 3616, 9219, 7637, 503, 8973, 2671, 1596, 6027, 722, 9880, +2066, 2937, 3298, 3346, 8067, 4535, 6727, 8027, 3613, 6091, 1583, +7541, 982, 9873, 3575, 4956, 9990, 2913, 2352, 5587, 4368, 7014, 3520, +9409, 6773, 6208, 1134, 6763, 894, 2525, 1927, 9336, 7332, 8813, 4527, +7484, 7508, 2881, 7934, 2418, 9394, 6176, 2038, 2882, 3238, 9156, +7864, 1977, 3133, 9474, 2772, 6137, 4672, 5470, 974, 2603, 7611, 9967, +7422, 9886, 6118, 9083, 8778, 2046, 7980, 7539, 8092, 9031, 185, 3627, +2737, 7793, 1041, 9547, 1374, 8010, 3963, 7191, 618, 7376, 841, 4525, +8709, 4178, 1429, 1205, 3993, 5713, 4235, 2711, 9626, 9455, 6252, +1474, 9816, 7022, 4626, 4044, 4775, 5357, 4133, 7648, 7665, 7681, +1516, 9674, 9910, 4031, 45, 2436, 756, 1686, 8097, 1316, 1550, 4722, +8965, 4640, 4002, 490, 9844, 9948, 3729, 2683, 1473, 2442, 6212, 927, +8572, 8671, 9057, 7909, 5247, 469, 689, 5791, 7660, 2796, 4031, 1497, +4408, 8940, 4170, 807, 6000, 5387, 1618, 3795, 5128, 131, 5229, 963, +4677, 9997, 1781, 8257, 9966, 8417, 2819, 5816, 5322, 6558, 8431, +4411, 6982, 8741, 3264, 6208, 1107, 5589, 2876, 325, 1693, 4163, 7679, +8762, 6041, 4701, 5420, 1916, 4632, 90, 4858, 3650, 447, 6873, 5890, +5416, 5558, 3383, 7308, 1676, 7010, 2283, 4978, 5108, 9707, 2134, +7368, 6418, 6070, 9206, 5893, 9009, 0, 9763, 2156, 9453, 7565, 5178, +8499, 6683, 8498, 5071, 6268, 5912, 7805, 5195, 2527, 584, 3807, 4907, +8664, 4427, 4035, 4004, 8528, 4185, 6259, 7602, 4011, 1829, 6277, +1473, 5434, 3691, 6306, 4158, 3512, 4442, 4152, 4940, 8747, 961, 1114, +3006, 6168, 3429, 233, 7329, 7166, 6298, 5328, 845, 6739, 6679, 6638, +4919, 1449, 5347, 7642, 4241, 3210, 3989, 8661, 272, 4763, 842, 2978, +9098, 3379, 1661, 1143, 9803, 843, 4057, 326, 9741, 7227, 3088, 6432, +8561, 1563, 3074, 643, 9698, 8966, 7364, 4987, 4983, 956, 2990, 4331, +1752, 4733, 101, 9144, 2981, 5367, 2703, 7897, 8015, 4595, 660, 6567, +7192, 1048, 5766, 5762, 169, 7804, 9231, 6522, 9102, 7805, 1591, 4419, +9477, 1325, 9517, 9037, 5259, 6549, 5746, 2907, 9597, 3748, 1626, +3872, 3938, 2186, 9094, 208, 5071, 9356, 2705, 4382, 4369, 3823, 1409, +6479, 3159, 4, 1868, 9958, 5597, 6727, 1627, 3485, 8417, 9732, 3039, +3026, 9376, 2972, 5704, 5634, 6168, 2004, 3730, 1121, 7685, 3347, +2799, 3009, 353, 7656, 8606, 7663, 6485, 285, 426, 7172, 1082, 3293, +1728, 6990, 7403, 4441, 9950, 9081, 9783, 350, 2229, 8139, 8653, 1672, +6634, 7033, 4104, 901, 8795, 9490, 9359, 2380, 6618, 7389, 7943, 8929, +9560, 513, 5892, 7593, 42, 1288, 6149, 7094, 3903, 483, 9037, 5023, +6932, 4290, 4145, 3800, 1066, 1918, 6684, 8848, 2949, 7418, 1104, +5095, 2842, 3471, 8225, 8192, 1210, 6899, 221, 7334, 5887, 3477, 410, +3576, 5402, 9103, 285, 9476, 5998, 6500, 1387, 3617, 9142, 5158, 8595, +8392, 4219, 7780, 1032, 4181, 7432, 4621, 1072, 1672, 53, 4287, 3720, +8849, 4568, 3807, 513, 1731, 1181, 9426, 3955, 3541, 1386, 1824, 7879, +5357, 1674, 3180, 8016, 3298, 9014, 4423, 6841, 572, 1397, 9223, 5502, +6362, 4311, 7905, 190, 6143, 4314, 8019, 4306, 3511, 3043, 5296, 9789, +8863, 252, 1504, 3978, 2864, 9558, 6151, 6714, 6061, 6907, 3731, 9521, +3522, 7982, 1638, 4368, 340, 172, 2553, 2308, 4308, 9611, 6009, 7182, +3993, 4357, 6581, 1938, 6530, 5587, 6616, 6952, 7747, 3174, 527, 8676, +5424, 4322, 6548, 415, 7087, 2016, 3875, 783, 4475, 1282, 526, 9077, +6821, 219, 7667, 852, 2392, 2746, 542, 5344, 2184, 5224, 3917, 6267, +8157, 5108, 904, 723, 8502, 2697, 3160, 9520, 7200, 5942, 9342, 1105, +4618, 3096, 6655, 8850, 6905, 2548, 81, 4031, 3, 2002, 9700, 9696, +3932, 558, 7494, 7975, 494, 9486, 3132, 4394, 3419, 1166, 1144, 1281, +5942, 2391, 9244, 9422, 2130, 8141, 393, 6524, 8816, 1386, 2129, 2845, +6610, 3783, 5121, 930, 4951, 1422, 5642, 7680, 7716, 1891, 5945, 3206, +1186, 3617, 7960, 1541, 3138, 7710, 1500, 7061, 3374, 9721, 5953, +5378, 4962, 7340, 2717, 9154, 5577, 8777, 9938, 2256, 4448, 4241, +5324, 4936, 9689, 4989, 7419, 2190, 3968, 7793, 3308, 5107, 3501, +2688, 7905, 9029, 286, 7680, 9106, 6944, 1760, 3483, 1703, 911, 4790, +6345, 2103, 8008, 6708, 8513, 8763, 6912, 9245, 8498, 5701, 6168, +9990, 6909, 7100, 8606, 4922, 7778, 3670, 4025, 3942, 8136, 3450, +1858, 7047, 8986, 4123, 4908, 1522, 4642, 5592, 627, 863, 277, 4155, +1411, 6818, 9331, 5554, 3097, 7681, 4445, 2685, 6714, 7244, 1960, +9932, 8253, 5767, 7709, 3050, 6768, 7966, 993, 5672, 6410, 5418, 3663, +1578, 5915, 281, 6490, 5535, 9331, 5755, 3146, 2072, 8623, 1562, 1516, +0, 8017, 6403, 322, 7010, 19, 1441, 303, 9853, 8483, 1864, 8789, 1855, +2513, 3670, 3017, 4471, 7212, 9514, 7707, 7954, 8594, 7649, 6572, +6784, 841, 9297, 1491, 4443, 3134, 1154, 821, 4311, 9800, 2563, 3478, +1460, 8115, 5605, 4185, 6810, 9935, 8389, 9847, 8298, 9415, 2923, +7169, 2497, 6608, 9847, 5216, 2146, 9317, 3131, 6382, 4874, 7973, +4224, 8941, 9701, 867, 831, 4440, 1231, 2471, 7354, 2088, 8971, 3924, +8628, 4757, 5457, 5505, 3783, 5131, 6457, 3916, 6834, 3158, 1222, +9768, 9792, 4475, 1046, 2682, 8530, 4386, 5398, 6166, 7535, 891, 7818, +6811, 1256, 9990, 419, 6444, 6852, 1964, 15, 9569, 5150, 2537, 6701, +1687, 3705, 3458, 3545, 3353, 2935, 895, 4569, 2089, 2541, 3212, 6706, +3594, 8474, 4155, 6943, 8447, 657, 5047, 3565, 3662, 1403, 727, 6816, +297, 692, 8748, 2012, 7883, 7960, 2580, 7311, 693, 4769, 9773, 2382, +3604, 513, 7477, 1658, 6893, 3688, 9588, 2881, 8500, 2592, 6095, 1225, +6486, 1737, 8043, 1632, 3171, 6295, 7619, 2178, 9523, 4615, 3782, +7408, 466, 4425, 8361, 4704, 6910, 8369, 9294, 9093, 7451, 9256, 4722, +1758, 5305, 4960, 2345, 2257, 9920, 5597, 6256, 2181, 8468, 7957, +9731, 7963, 1112, 4338, 22, 1790, 5710, 620, 4705, 7157, 432, 6461, +797, 8742, 8253, 6658, 7698, 5941, 5852, 9634, 580, 2451, 949, 6006, +9453, 3569, 5058, 8874, 4372, 1279, 923, 15, 1401, 937, 3674, 5894, +3900, 3733, 178, 3486, 533, 7403, 3855, 7948, 4548, 4018, 8565, 6331, +6497, 6446, 6159, 5142, 7940, 7016, 8901, 5896, 690, 4798, 342, 5321, +4907, 8445, 217, 8680, 2940, 8791, 6344, 8497, 4957, 8397, 114, 6360, +4499, 3445, 1928, 8144, 8421, 5143, 7208, 5965, 2789, 7250, 2974, +7419, 1052, 875, 2381, 4635, 3793, 8266, 5939, 9580, 1955, 6196, 7446, +8526, 3152, 4938, 8950, 6417, 4154, 2055, 9494, 4144, 3804, 1852, +1755, 9660, 9567, 3256, 5633, 3791, 6715, 2595, 9538, 5977, 4625, +9047, 2504, 1010, 9462, 3699, 8794, 4002, 9083, 4596, 386, 5337, 7492, +132, 7775, 5413, 9424, 8556, 6114, 5750, 5005, 3811, 538, 3536, 911, +7414, 9055, 5406, 8846, 12, 1373, 920, 5119, 8160, 80, 7039, 1161, +2602, 702, 5106, 8054, 8712, 8998, 6892, 5608, 3010, 1814, 5591, 14, +1174, 4521, 8782, 4215, 1317, 1618, 4080, 7754, 9889, 1760, 478, 5440, +1082, 3961, 1124, 9275, 4296, 3931, 9487, 2148, 1753, 8878, 9821, +6655, 6516, 9566, 1245, 9856, 173, 9606, 260, 6666, 416, 8092, 71, +4180, 7581, 7047, 3766, 1027, 6464, 1252, 8058, 6666, 2229, 7558, +8019, 7985, 2666, 3346, 5885, 7309, 5700, 9759, 1058, 8488, 1256, +2735, 5016, 1318, 188, 9470, 5620, 4388, 8261, 6134, 8176, 4214, 8665, +9702, 8720, 259, 6948, 3618, 9233, 2280, 3387, 3817, 8396, 212, 3887, +336, 4632, 5520, 4506, 5910, 3163, 7585, 7881, 1904, 2852, 7711, 399, +3711, 547, 5911, 3572, 8664, 7854, 5041, 6377, 2260, 1922, 5297, 5952, +6114, 9026, 5451, 7706, 8457, 599, 7470, 4417, 5209, 6876, 1764, 5986, +3100, 2823, 5706, 219, 872, 6393, 7051, 4222, 4758, 7238, 1764, 3425, +9061, 4732, 1126, 384, 8521, 6481, 4516, 2052, 8995, 2815, 5960, 4608, +2124, 7292, 3854, 5442, 6872, 7888, 4986, 7594, 777, 3577, 3902, 9927, +8981, 5905, 9049, 5652, 2023, 4936, 5080, 196, 1464, 3142, 1221, 5627, +4487, 5331, 2741, 7097, 2414, 8010, 1988, 8047, 2292, 9033, 6402, +3986, 8683, 7795, 5467, 1443, 5206, 5411, 9848, 9333, 9934, 3552, +8069, 797, 3958, 1486, 6181, 7964, 120, 879, 337, 9961, 8256, 2849, +6680, 560, 1118, 5224, 2196, 7177, 8881, 7086, 9868, 6012, 9103, 8480, +8268, 8712, 3374, 6397, 5252, 194, 4120, 5910, 7946, 8127, 9414, 8869, +1531, 7723, 6728, 6949, 3696, 6177, 943, 754, 3935, 7336, 363, 8095, +8388, 4261, 8099, 8768, 1086, 5834, 3974, 9778, 7329, 920, 4093, 7028, +9072, 242, 3169, 2201, 7478, 7469, 1575, 2890, 921, 3136, 4564, 403, +4049, 1181, 4044, 1006, 4959, 6537, 576, 7788, 8747, 8121, 6681, 4832, +62, 7227, 688, 2227, 6737, 2809, 8966, 8190, 864, 8595, 9186, 3251, +4921, 8575, 2236, 4782, 5436, 9075, 6860, 7409, 947, 263, 7359, 3063, +6631, 6590, 4905, 9413, 9544, 9271, 3097, 6775, 2757, 3274, 263, 3308, +2217, 3497, 711, 3429, 8641, 9001, 688, 193, 7759, 7534, 3061, 1998, +9251, 457, 21, 5435, 4856, 1233, 4328, 4517, 6515, 3993, 5040, 7866, +1473, 5234, 7022, 2627, 6842, 4157, 8053, 610, 9222, 6897, 7195, 4089, +4118, 6425, 4483, 4510, 7051, 9091, 4643, 3807, 8815, 6656, 739, 2300, +4647, 5090, 9656, 8448, 9865, 9273, 1586, 5363, 6397, 1064, 3335, +4607, 5117, 8001, 6113, 1876, 4560, 8635, 4850, 6416, 8866, 3744, +6610, 1161, 2591, 9113, 9110, 9185, 7415, 7768, 5110, 3957, 8888, +9648, 3946, 5680, 134, 6400, 4989, 645, 8776, 655, 4735, 2236, 8897, +8658, 7113, 8649, 7613, 9627, 2976, 4616, 7706, 1003, 3789, 7039, +4447, 9132, 903, 9744, 9470, 3378, 58, 654, 5297, 5453, 2019, 9139, +8281, 811, 8296, 8275, 4998, 6500, 4908, 6745, 6695, 386, 5156, 3809, +5399, 1141, 1224, 744, 7513, 1209, 5054, 2145, 5973, 3101, 2386, 2315, +823, 2112, 4606, 3388, 4952, 5899, 7905, 6004, 4153, 8101, 5991, 7632, +9494, 3921, 432, 4538, 3938, 7130, 3970, 9574, 4448, 5395, 8835, 2628, +4128, 7603, 576, 2520, 6162, 5870, 3072, 2782, 819, 46, 9498, 9636, +5884, 2123, 6660, 7923, 415, 3817, 6525, 617, 2356, 4105, 3269, 7354, +5885, 432, 3619, 7418, 1747, 4038, 1498, 5851, 9199, 4152, 6016, 3304, +6886, 4733, 2758, 3055, 7165, 1200, 2195, 8473, 3223, 9257, 9064, +2514, 2172, 6280, 6208, 5959, 9451, 452, 4888, 2627, 3765, 3302, 7772, +8357, 8669, 9989, 761, 5999, 7202, 2405, 5063, 3728, 2726, 7697, 4539, +835, 6888, 9556, 1371, 4492, 4080, 8492, 2469, 8533, 1447, 6497, 2387, +5902, 5847, 4459, 4552, 6862, 3829, 7940, 85, 6323, 1108, 9741, 4266, +6442, 7659, 7017, 1928, 2398, 9545, 7319, 4684, 2521, 5331, 8872, +9025, 5269, 7120, 2756, 7034, 1623, 843, 7696, 4407, 9534, 205, 9133, +8454, 8180, 158, 9331, 7496, 1182, 8037, 5558, 6340, 2383, 3229, 5514, +885, 648, 877, 3288, 825, 7037, 3802, 1363, 2939, 2268, 1927, 840, +976, 4949, 3978, 5878, 6903, 9924, 5592, 1012, 216, 3918, 8104, 2746, +6144, 2887, 4054, 3525, 4911, 6311, 4963, 9431, 518, 1442, 5537, 6004, +1325, 1, 5024, 3209, 8073, 293, 9457, 1607, 2401, 5878, 2880, 119, +1803, 3276, 3390, 149, 7133, 7095, 1851, 762, 3653, 2418, 9657, 8648, +706, 2434, 6937, 2869, 1416, 6307, 834, 8246, 6276, 9124, 497, 5031, +6834, 1327, 7314, 7316, 8348, 3235, 1564, 1325, 236, 6069, 426, 8265, +7528, 1115, 3631, 9806, 8010, 5579, 5160, 1207, 8616, 9605, 7020, 186, +3664, 6007, 8675, 8710, 7048, 820, 317, 5359, 8240, 197, 186, 7660, +3064, 6521, 6696, 3627, 235, 505, 9851, 4431, 3700, 9857, 6732, 6032, +8989, 6371, 9375, 8052, 8722, 3611, 6223, 5026, 4494, 3042, 1854, +4253, 1160, 2196, 7964, 2999, 1862, 5097, 9958, 2969, 1876, 3351, +4680, 3124, 419, 6536, 7128, 8287, 3162, 6926, 8224, 7692, 7934, 4485, +7231, 6661, 5700, 562, 7850, 9396, 9723, 5574, 6270, 4380, 9042, 8349, +7550, 7350, 3575, 4841, 3045, 6235, 9369, 4239, 2948, 1613, 2162, +8005, 1351, 9179, 3766, 9161, 7041, 5848, 8995, 7662, 9916, 8430, +4668, 8912, 1847, 2106, 9833, 4277, 6756, 3410, 1939, 1069, 592, 3886, +4181, 8109, 8318, 6925, 2838, 7441, 6560, 8321, 7629, 7260, 906, 1607, +4784, 4406, 6847, 5991, 8037, 9639, 3205, 7455, 4889, 7722, 8728, +5567, 2408, 333, 4029, 5261, 3328, 6084, 4585, 557, 4890, 3782, 2500, +2052, 495, 8201, 3778, 8023, 5112, 317, 6659, 7644, 6088, 5771, 8356, +9305, 8650, 6354, 6189, 1213, 9785, 6106, 1866, 4013, 9897, 1885, +7003, 1781, 2023, 9375, 1317, 4722, 9734, 1546, 2364, 2081, 6565, +1299, 8921, 3805, 3302, 9633, 8770, 7558, 8120, 887, 4264, 4491, 3591, +9677, 5077, 893, 9031, 1841, 3545, 3164, 9130, 1825, 8500, 7828, 5795, +5652, 2993, 4964, 155, 7091, 3151, 1413, 6588, 1543, 2901, 9869, 8844, +63, 713, 8634, 2779, 4083, 3276, 5287, 6518, 290, 3791, 169, 5036, +1042, 4878, 3568, 312, 9562, 810, 6451, 2147, 6384, 7553, 1872, 6197, +8510, 3652, 3986, 3165, 7221, 6428, 1977, 735, 2889, 1541, 7856, 874, +3118, 3281, 8550, 5641, 6056, 8225, 4509, 1405, 2466, 9661, 6048, +5835, 7287, 5160, 5069, 2072, 6343, 7771, 4371, 2107, 2657, 668, 4817, +9655, 8481, 8878, 8607, 5549, 61, 7072, 2010, 3317, 2165, 8821, 6431, +7236, 2800, 8832, 5037, 4076, 1930, 265, 3306, 4788, 2827, 9619, 8962, +3616, 1116, 7625, 1842, 9990, 7878, 6019, 3322, 3733, 8857, 10, 1213, +5672, 3270, 3697, 6590, 6489, 57, 854, 5077, 1647, 9476, 4724, 2934, +7586, 9583, 4354, 8469, 162, 4866, 5668, 8031, 8031, 2633, 304, 8283, +8347, 3231, 9938, 9251, 5800, 3981, 1374, 6146, 7672, 4721, 2075, +1178, 1125, 5737, 8735, 2706, 1160, 8975, 5982, 4269, 6979, 6882, +5449, 8003, 3758, 8136, 1106, 3737, 1494, 4589, 1273, 1647, 9237, +3948, 3561, 7821, 4434, 8822, 7013, 7838, 9738, 9327, 8199, 7188, +7948, 5877, 8200, 4562, 3460, 8630, 3505, 7153, 9554, 6967, 5045, +7136, 841, 3792, 3130, 3978, 4389, 5603, 4452, 6346, 5627, 3921, 1762, +9866, 5377, 5305, 1539, 5253, 6185, 4764, 4439, 7299, 2615, 9214, +6516, 8205, 7976, 6638, 7820, 3999, 7903, 9695, 2353, 9794, 1327, +1999, 5050, 9418, 700, 3253, 6971, 551, 7778, 1873, 5611, 5253, 3728, +1956, 2386, 8074, 9972, 9349, 2338, 1891, 4409, 5789, 2677, 9089, +3079, 8404, 1535, 3126, 8081, 3767, 3704, 3984, 7534, 6028, 7331, +3308, 8394, 5008, 444, 5635, 8983, 7671, 8169, 7547, 9427, 478, 8339, +5932, 9066, 4977, 6284, 3052, 4691, 9625, 3593, 3079, 1287, 1264, +6833, 7417, 7855, 4248, 8560, 4830, 2267, 8390, 7383, 5398, 1155, +8111, 2955, 2301, 556, 3638, 3046, 825, 1792, 5880, 8738, 9286, 3102, +518, 8696, 9265, 4631, 2306, 5715, 5049, 3055, 4235, 4069, 9992, 6369, +6394, 2735, 7314, 2625, 1613, 6177, 2367, 4893, 4676, 4482, 6221, 819, +7569, 6897, 9201, 9459, 5383, 8344, 6564, 5972, 1427, 8300, 5377, +8987, 176, 9089, 3915, 7258, 6161, 6182, 5580, 1127, 4618, 7912, 9396, +49, 1086, 6065, 8398, 2011, 8341, 5374, 6894, 6725, 6693, 4408, 1234, +915, 6956, 2049, 2068, 6583, 8178, 2977, 6752, 6057, 5468, 1879, 1279, +4261, 9648, 6526, 6725, 5757, 670, 1726, 1427, 7520, 6506, 1517, 9974, +5715, 6986, 5088, 7688, 6405, 8962, 6792, 3072, 6170, 9151, 908, 4591, +4539, 589, 3131, 3195, 9147, 1662, 2439, 8314, 3861, 3507, 4438, 8554, +8855, 2821, 4167, 5038, 2153, 6347, 3431, 9123, 1998, 1443, 1096, +6975, 2903, 1346, 6635, 9046, 790, 3675, 509, 5685, 8509, 3610, 2567, +4807, 3594, 8227, 621, 262, 8019, 8612, 2001, 2283, 1432, 657, 3848, +1507, 880, 1593, 3580, 9359, 9385, 5912, 8876, 63, 9660, 3418, 1599, +5381, 505, 4234, 90, 5464, 3672, 7970, 2079, 6293, 905, 2614, 3295, +2387, 830, 2858, 582, 7462, 428, 3227, 4701, 1262, 828, 2455, 9145, +3481, 5648, 165, 6564, 92, 3046, 1022, 2873, 7190, 8239, 851, 1308, +4516, 7799, 2678, 1178, 8816, 8578, 7741, 9102, 5967, 8213, 7694, 303, +279, 4165, 5575, 4062, 2219, 2352, 6728, 2758, 4277, 2961, 5001, 9676, +6859, 7199, 1397, 5329, 4374, 567, 4641, 2088, 1333, 1244, 8441, 7636, +2114, 7715, 5241, 999, 8481, 5274, 2188, 5126, 3058, 5270, 8155, 6046, +747, 6265, 3096, 238, 9613, 9136, 9276, 182, 8483, 6861, 3787, 3316, +7329, 5618, 1633, 2271, 3673, 5147, 8926, 6034, 3471, 1169, 9512, +7416, 1605, 8655, 6745, 4852, 2831, 6932, 3659, 9893, 8635, 1171, 106, +2299, 719, 8640, 5948, 7029, 5449, 6595, 5420, 6317, 634, 1291, 5290, +200, 6038, 6947, 1395, 9172, 4298, 3255, 9157, 9167, 8073, 5898, 5897, +8463, 5928, 1043, 3003, 8547, 7474, 8389, 4472, 9255, 4095, 1029, +1980, 5140, 9244, 1007, 409, 7574, 2771, 7123, 4029, 4488, 6757, 9460, +763, 9721, 8845, 2480, 5288, 3629, 1893, 7184, 516, 6863, 9445, 2276, +5794, 524, 2362, 1631, 7394, 4629, 5124, 3136, 3610, 7340, 8076, 9789, +7914, 3634, 9691, 3946, 2185, 2647, 2461, 4317, 9062, 4363, 2391, +3092, 8996, 5536, 730, 3745, 4629, 3471, 8197, 5538, 5831, 5199, 6743, +1878, 9700, 5658, 5203, 9539, 6918, 6034, 4547, 971, 4530, 8324, 4094, +7035, 7733, 1428, 9717, 5100, 9226, 8357, 6748, 1288, 820, 7874, 8333, +9776, 1736, 6384, 711, 977, 1056, 6982, 5297, 8512, 8128, 2572, 6184, +5924, 1220, 69, 612, 8140, 4037, 1934, 5734, 1140, 1443, 1870, 9520, +4778, 4578, 8184, 69, 9416, 239, 989, 524, 9539, 4384, 6353, 9186, +4964, 4860, 2703, 253, 331, 9340, 6002, 110, 8926, 1209, 896, 1642, +5619, 768, 2109, 6383, 1443, 1803, 9374, 2374, 5984, 2903, 3633, 270, +9218, 4384, 2871, 7724, 9067, 9028, 5291, 9852, 4072, 3688, 8855, +5066, 2652, 8906, 6416, 2672, 3405, 9852, 9389, 8340, 9915, 1774, +5516, 4737, 9102, 1178, 3413, 3801, 1547, 550, 3917, 707, 155, 1161, +9564, 3136, 5489, 703, 8551, 4883, 1340, 5613, 1777, 2930, 5126, 4375, +2419, 2025, 7718, 2168, 1587, 6626, 2402, 7036, 2054, 504, 8363, 6810, +3409, 2231, 5511, 704, 394, 2853, 8828, 5653, 7481, 8159, 5121, 4681, +7786, 1219, 7023, 7971, 1427, 3598, 5672, 197, 8344, 6734, 6725, 8141, +62, 5194, 3479, 4267, 1998, 8580, 4788, 9319, 1734, 9866, 7984, 3509, +1997, 6708, 6509, 1318, 5038, 108, 3853, 8131, 8546, 4398, 4401, 4996, +9275, 7734, 2066, 4278, 4704, 7565, 9306, 3699, 4792, 8151, 5745, +4067, 3444, 7890, 6407, 9382, 8936, 7614, 2451, 4674, 7524, 3946, +3720, 4622, 5059, 6427, 508, 7840, 7826, 5430, 7019, 5684, 8859, 6755, +5146, 6842, 6162, 876, 6956, 5436, 7589, 4185, 5531, 231, 1341, 8655, +5325, 1015, 5080, 3627, 2880, 327, 6658, 9261, 7431, 8851, 8659, 395, +2311, 3858, 7907, 3, 6085, 6682, 9499, 5272, 4075, 494, 1429, 9257, +7067, 7574, 5218, 6355, 8299, 642, 3831, 2930, 3580, 3883, 2395, 1171, +8170, 178, 5077, 4645, 5379, 8628, 834, 3292, 708, 7154, 111, 9452, +8713, 4948, 7130, 1478, 804, 1166, 7624, 369, 5090, 6663, 7714, 4599, +5026, 4184, 2970, 7300, 7668, 3027, 3124, 3565, 3476, 1489, 4880, +8629, 1651, 7803, 2499, 4331, 260, 4666, 762, 7691, 6404, 2866, 2870, +9391, 6026, 6295, 4552, 3899, 7055, 4504, 7928, 7394, 9486, 6331, +7456, 2523, 8337, 5872, 9451, 7242, 842, 3462, 2536, 5148, 1773, 1366, +9524, 4758, 5150, 57, 9322, 964, 9205, 5611, 6841, 1528, 8721, 9415, +2026, 5632, 1714, 315, 1359, 5775, 9071, 5702, 8075, 6082, 3527, 4581, +9373, 7364, 8677, 5220, 3713, 11, 899, 4027, 114, 7408, 6952, 1916, +4058, 6948, 5395, 2950, 2686, 4293, 5394, 5128, 9909, 3302, 6620, +9031, 1224, 9224, 6555, 7089, 6085, 9056, 9117, 1431, 1077, 5449, 900, +7205, 668, 3324, 4640, 1014, 4555, 2417, 9485, 2985, 4498, 2482, 3732, +3065, 8073, 4237, 4687, 4656, 4185, 6043, 3018, 5392, 5745, 527, 9181, +7994, 1871, 6025, 2071, 8331, 2487, 9227, 6277, 6850, 9014, 6922, +4476, 5827, 4108, 8276, 2889, 3783, 4546, 6164, 4155, 8851, 1538, +4086, 6594, 743, 7787, 4958, 1710, 6185, 8178, 2237, 1506, 9183, 2505, +9114, 9039, 6490, 6330, 519, 6175, 9702, 6393, 2419, 2807, 305, 2180, +66, 339, 871, 7125, 8714, 6046, 2453, 129, 5201, 709, 2690, 4287, +6661, 3222, 3903, 3105, 1920, 215, 3825, 5169, 3444, 7063, 9290, 9357, +4006, 5681, 1181, 313, 7331, 388, 4372, 7041, 6245, 931, 383, 3063, +8273, 2315, 5218, 9651, 6252, 3733, 5179, 1046, 5299, 5210, 4460, +4301, 5255, 5815, 8629, 4492, 9198, 5293, 6285, 2720, 6446, 6668, +3246, 4792, 4684, 8414, 6235, 5648, 1116, 2252, 6761, 6571, 4874, +5934, 2127, 1357, 785, 5644, 7426, 4273, 6106, 6626, 520, 7873, 1841, +3702, 8283, 9925, 7234, 3482, 3200, 1705, 6590, 2241, 525, 11, 104, +5657, 8719, 8556, 4899, 5115, 1889, 3629, 5247, 3094, 8192, 5389, +4756, 959, 8105, 6614, 8016, 2239, 8992, 5879, 2288, 2245, 3894, 4357, +4709, 9877, 9052, 5328, 7188, 8453, 389, 8687, 7644, 2895, 2592, 5234, +1673, 2024, 2958, 4529, 2994, 8354, 3536, 2616, 1329, 6942, 6501, +8666, 2075, 2067, 7807, 5913, 495, 9289, 3474, 4151, 6358, 8698, 633, +5329, 1942, 754, 7079, 6164, 3315, 6453, 9589, 8648, 1136, 7511, 5455, +6414, 9052, 7138, 509, 9879, 7885, 5492, 1248, 1404, 9637, 1231, 969, +4640, 8255, 1446, 8887, 7650, 5198, 8392, 7266, 2470, 7465, 8872, +3578, 5197, 9325, 3541, 7609, 9555, 764, 3608, 2908, 6275, 1049, 3916, +1821, 1685, 1409, 4790, 6902, 7315, 9595, 4534, 5536, 2656, 174, 3186, +1594, 9369, 5942, 4285, 3106, 5439, 4057, 7141, 8320, 4927, 3404, 427, +5890, 3117, 4812, 9555, 4473, 7846, 5943, 9713, 926, 3398, 5139, 8133, +2693, 9523, 2419, 6774, 3865, 4167, 4023, 50, 8405, 8520, 3648, 7343, +7569, 2652, 3086, 4636, 511, 1450, 7942, 6120, 1274, 9321, 3667, 2940, +57, 4066, 3846, 4727, 816, 9421, 1456, 4894, 8595, 1728, 4111, 4587, +4394, 6932, 4583, 7103, 2393, 1375, 5489, 5524, 9455, 4685, 5641, +5906, 1104, 5543, 3115, 2314, 703, 2062, 8227, 6602, 8001, 5044, 2193, +1415, 8491, 2888, 5029, 4204, 4025, 7915, 7038, 5472, 451, 9567, 520, +512, 2930, 8964, 7852, 7592, 4049, 5084, 7635, 9761, 5731, 1888, 7556, +6617, 248, 4569, 8155, 3386, 4362, 3027, 8894, 4194, 4568, 4020, 4787, +723, 1372, 812, 4099, 8384, 3207, 4386, 1392, 5183, 5697, 4652, 2978, +4256, 4870, 9741, 3809, 5459, 3169, 1372, 7993, 728, 1685, 6947, 8381, +9682, 1528, 3713, 6945, 2918, 2341, 9956, 6852, 3432, 8404, 1402, +6967, 5541, 3247, 2905, 4087, 5131, 6457, 544, 8954, 6263, 8174, 1819, +8269, 5083, 7618, 7366, 4045, 6868, 899, 9388, 8191, 6147, 152, 3897, +442, 1392, 9375, 4324, 9403, 7682, 9883, 9646, 5754, 5218, 8113, 8948, +3533, 2315, 5856, 5888, 8109, 6877, 749, 4708, 786, 1507, 2019, 1146, +4045, 703, 2901, 1099, 6622, 7650, 9400, 2927, 2864, 1306, 5828, 2111, +6133, 3108, 8378, 7448, 1254, 9978, 4167, 4188, 3674, 5320, 482, 2755, +4082, 2079, 263, 4075, 3355, 9375, 372, 9878, 3056, 7440, 3730, 5301, +4900, 2921, 2209, 6579, 4055, 8065, 1262, 6657, 8497, 3761, 3424, +7477, 2253, 3830, 1469, 5004, 9042, 7096, 1064, 5431, 4612, 6922, +3367, 9063, 2528, 4871, 7326, 2051, 9089, 961, 4058, 295, 7806, 232, +2508, 2559, 8574, 1553, 1127, 4634, 4160, 3472, 9167, 3953, 6641, +3719, 1787, 1665, 2188, 515, 7630, 555, 1373, 525, 9086, 8290, 2074, +360, 1846, 2705, 423, 6447, 6889, 1274, 1119, 5940, 4108, 5354, 3915, +6599, 30, 1862, 8047, 8214, 4546, 3813, 8070, 6974, 7345, 498, 5876, +756, 9026, 9113, 3184, 5278, 5805, 6266, 322, 8661, 5562, 1919, 6368, +5125, 9143, 6812, 6417, 7569, 1601, 4876, 5107, 8554, 3597, 3692, +9372, 297, 91, 7148, 8562, 8507, 8059, 1230, 1243, 6221, 8473, 4027, +7116, 524, 3903, 7718, 9166, 1879, 3218, 948, 2391, 2865, 9580, 8727, +2456, 4304, 5059, 9095, 3119, 6703, 9131, 8135, 1678, 8378, 7549, 690, +3598, 3740, 4795, 2485, 6075, 7338, 5892, 3476, 2066, 5385, 524, 5088, +195, 4489, 7116, 3791, 3619, 4404, 564, 3274, 4725, 2264, 2308, 4411, +697, 5432, 4385, 71, 451, 6499, 9747, 9830, 4595, 1896, 3834, 3606, +7162, 2206, 4851, 4973, 776, 6235, 2275, 6348, 5637, 8033, 3746, 5735, +1790, 1340, 2582, 9492, 3836, 4471, 8194, 4730, 2859, 4173, 5914, +4426, 5553, 3449, 6129, 2916, 2576, 8506, 1169, 6154, 5204, 6820, 639, +9351, 9191, 6728, 4113, 5821, 992, 2650, 2475, 4567, 8061, 1989, 866, +9229, 1200, 295, 8886, 730, 1823, 237, 8235, 1535, 352, 8212, 5781, +8126, 7773, 4565, 8576, 4742, 4802, 4905, 7575, 6635, 6409, 6065, +3011, 2418, 4353, 6658, 3119, 8483, 3105, 9973, 8534, 9067, 9304, +5563, 8950, 5730, 5849, 2274, 7469, 5019, 5034, 1460, 5989, 8389, +2117, 2048, 3320, 6019, 7546, 8794, 7279, 6919, 6455, 3107, 3393, +8450, 5110, 8886, 2448, 1068, 372, 4845, 9064, 3143, 7029, 2000, 1625, +4059, 3785, 8149, 9538, 4696, 6006, 9030, 3537, 9402, 4118, 6896, +6875, 4554, 9584, 1281, 4383, 8867, 1257, 9208, 6882, 3069, 5388, +1239, 9637, 2482, 406, 6230, 2367, 2923, 9176, 7644, 6930, 6682, 7694, +1883, 404, 6972, 3782, 3323, 1764, 1483, 3936, 1393, 1087, 5144, 2720, +7, 3590, 9306, 3746, 1181, 9069, 7495, 734, 1625, 3412, 3872, 7354, +5680, 6529, 8109, 4106, 8784, 7032, 75, 3029, 5005, 6964, 7214, 1056, +7225, 5977, 5157, 6454, 1904, 7782, 9318, 9998, 8012, 6938, 7543, +9161, 8213, 3994, 7654, 833, 7693, 5225, 3496, 7575, 4452, 1624, 2872, +786, 5716, 4067, 4416, 3740, 8042, 3922, 9042, 5851, 1859, 1403, 5637, +7723, 6257, 7033, 3603, 8778, 862, 2824, 8708, 6438, 688, 9356, 2217, +2771, 2189, 9829, 5491, 6810, 4873, 3062, 8462, 5425, 6132, 1405, +9739, 8203, 2883, 4806, 1980, 9982, 8790, 6217, 1228, 8379, 8013, +1336, 5148, 377, 7119, 3639, 7798, 9936, 152, 118, 26, 5977, 1556, +2043, 2862, 2144, 5298, 3958, 2061, 208, 5164, 7251, 7044, 6389, 9267, +9124, 7304, 552, 9663, 5948, 784, 1207, 2241, 907, 3103, 4, 6766, +3436, 6046, 2323, 6909, 9257, 3549, 4188, 1284, 5337, 3685, 9534, +2824, 3075, 9325, 9541, 9566, 9847, 9534, 3545, 3759, 748, 8900, 6545, +2364, 3462, 6574, 2951, 1268, 6375, 2259, 4412, 6897, 4947, 1865, +4987, 6693, 9978, 2045, 6994, 3521, 9584, 3774, 8854, 9459, 1513, +6958, 4424, 6330, 8619, 4520, 9553, 8751, 6020, 9863, 5851, 2757, +8060, 86, 4024, 6352, 2878, 2622, 4197, 5761, 6108, 7904, 1993, 4024, +4094, 5739, 102, 2652, 8827, 35, 5257, 3017, 1436, 1511, 2166, 7699, +2691, 7721, 8311, 5831, 7431, 2796, 6133, 4993, 8533, 8202, 6287, +8486, 3793, 2597, 5458, 2884, 7889, 9734, 936, 4535, 2857, 324, 6204, +8026, 176, 7583, 105, 7019, 7996, 3497, 2204, 8985, 4208, 7248, 173, +7086, 1319, 3015, 6177, 3767, 8688, 891, 2461, 4573, 419, 6042, 8244, +9659, 399, 1012, 8762, 7957, 5958, 3759, 6347, 4154, 3202, 4821, 8924, +7667, 6694, 5987, 8066, 4929, 6586, 7646, 7371, 5009, 7838, 7566, +1257, 4159, 9103, 5665, 7702, 8824, 684, 5571, 5205, 5171, 4215, 1644, +6998, 6396, 4069, 9493, 2085, 8383, 9276, 5066, 6119, 512, 2200, 5588, +9550, 2507, 571, 5512, 9097, 289, 2847, 8155, 1127, 0, 1646, 1866, +7215, 9363, 6117, 3813, 3387, 8416, 6271, 5440, 4942, 2827, 6332, +5997, 9403, 7697, 4564, 1826, 2085, 4612, 7531, 8153, 9544, 2886, +6216, 6740, 5306, 6468, 2551, 7403, 431, 7318, 6002, 7899, 2465, 4155, +5371, 8938, 9219, 4451, 5246, 4589, 5017, 4008, 9149, 5128, 641, 5545, +710, 2585, 6353, 7522, 4825, 7754, 2717, 1978, 1994, 8747, 6352, 3533, +3845, 9490, 324, 6069, 8704, 605, 1369, 203, 6529, 5201, 8282, 8681, +9191, 4367, 7569, 291, 6985, 8290, 9184, 3770, 610, 8339, 3650, 788, +969, 3364, 7407, 5064, 5861, 6555, 2749, 1454, 5044, 935, 1927, 1737, +1974, 8936, 7426, 4329, 5309, 9150, 6663, 5434, 3041, 1913, 4919, +4070, 8847, 943, 3389, 3662, 6156, 7082, 979, 3515, 4542, 1100, 4523, +6721, 1308, 5645, 7297, 9373, 6765, 430, 8544, 6741, 3351, 4179, 5670, +2689, 3065, 8676, 9165, 9276, 1303, 9396, 755, 1828, 5099, 1658, 7896, +9597, 8493, 9851, 1427, 6607, 5845, 6714, 7094, 2392, 492, 8968, 2077, +7907, 8450, 9648, 9188, 6232, 5569, 1403, 8541, 6427, 9172, 6640, +8331, 2806, 7050, 1882, 4449, 2424, 1652, 8424, 5446, 8608, 9560, +6594, 191, 7154, 7715, 4993, 2892, 4345, 3615, 9712, 9971, 9172, 6070, +3209, 8536, 1984, 6152, 7950, 2149, 8681, 1761, 2798, 8403, 9780, +5619, 617, 3313, 3184, 9505, 5673, 9674, 9297, 2250, 1793, 864, 995, +3640, 9723, 1605, 7194, 5389, 6249, 3287, 6231, 2976, 992, 5220, 2337, +2543, 5319, 6869, 2244, 3686, 4241, 4781, 5345, 1848, 3041, 752, 764, +3459, 2949, 6453, 3705, 5227, 9476, 511, 6766, 1967, 7713, 7571, 6830, +9230, 8001, 9793, 6537, 1092, 75, 8522, 5623, 7785, 3394, 1962, 2994, +5066, 1785, 6870, 3934, 1374, 1829, 4720, 5979, 3358, 8236, 9394, 763, +2483, 2052, 8097, 9583, 2286, 5293, 1457, 317, 5099, 3965, 7324, 5346, +9799, 114, 9321, 1167, 9181, 8501, 3219, 3172, 9757, 251, 8160, 3134, +2192, 9962, 7921, 4376, 3964, 3286, 9028, 3844, 1190, 3357, 3579, +8995, 2264, 9478, 7722, 6251, 4527, 8276, 9595, 1981, 1223, 206, 2353, +6618, 702, 7164, 4490, 4135, 6840, 4824, 5765, 9655, 9522, 1156, 6960, +346, 1188, 4678, 7184, 5549, 9566, 6280, 5057, 2994, 3075, 7315, 917, +2349, 3098, 2932, 2409, 1491, 9334, 2836, 149, 587, 9408, 8333, 4596, +683, 4392, 9747, 4226, 231, 3772, 2299, 7244, 2105, 3671, 7816, 3125, +1756, 7228, 8785, 3809, 488, 2792, 735, 5283, 8069, 5172, 1245, 4796, +9725, 6050, 8829, 9734, 9607, 4890, 4535, 5095, 2315, 8663, 4920, +8219, 8163, 4519, 1245, 5798, 7415, 9399, 2743, 1986, 587, 9603, 5495, +9478, 9629, 4750, 3273, 3840, 6416, 6320, 7692, 8663, 9880, 9133, +5651, 1320, 3844, 382, 9701, 2092, 2334, 9711, 5850, 3481, 530, 8438, +2815, 5876, 1334, 1456, 2638, 932, 4526, 9917, 5103, 4228, 1616, 5752, +8713, 6206, 8178, 2340, 595, 5641, 5197, 1324, 8198, 789, 8909, 5182, +2511, 7863, 6567, 9413, 2128, 1890, 7840, 6210, 8602, 6405, 9950, +1217, 3064, 6731, 8121, 5759, 5006, 7408, 3662, 5639, 6186, 9129, +7022, 4300, 5173, 9369, 9334, 3047, 5356, 8431, 7734, 9384, 6275, +8146, 3743, 3617, 7838, 5484, 7713, 5099, 7383, 273, 7381, 1970, 3079, +3644, 4047, 2372, 7800, 8337, 8306, 3755, 5853, 1940, 7472, 3067, 159, +8873, 8184, 3561, 9592, 7942, 4986, 1907, 1514, 7962, 4304, 9364, +7426, 597, 5460, 6564, 166, 2536, 2650, 6861, 7296, 8101, 8699, 3206, +7890, 414, 9958, 6492, 7271, 769, 1078, 1182, 1547, 8915, 6039, 8995, +9536, 2003, 8082, 1655, 4944, 6626, 8516, 5625, 531, 4952, 1856, 1329, +3861, 1923, 3282, 9106, 6147, 4268, 2523, 5988, 8105, 6168, 9914, +9160, 7823, 5181, 4745, 780, 9564, 4971, 5760, 1942, 5221, 7445, 8131, +9509, 8892, 2182, 4263, 4566, 7469, 4648, 1937, 7895, 1525, 4672, +3663, 1474, 3309, 8590, 1630, 1684, 6822, 7676, 6691, 9724, 6390, +7331, 6337, 5167, 8619, 1445, 9808, 8501, 2315, 4679, 8830, 7415, +6781, 5643, 1174, 6807, 6463, 5732, 7189, 7790, 8040, 5759, 8741, +7489, 8737, 533, 4714, 2414, 1493, 2945, 2127, 8836, 3935, 2633, 442, +6972, 9078, 8768, 9796, 9508, 4103, 5134, 9128, 9655, 9694, 2940, +9181, 9427, 2011, 5187, 529, 2658, 189, 5254, 3946, 4854, 6692, 4374, +444, 2193, 1243, 2058, 9921, 69, 1380, 6898, 214, 6910, 871, 4778, +9643, 6906, 9723, 8812, 690, 1192, 972, 5699, 6007, 4831, 3033, 1954, +3032, 783, 3889, 7984, 5648, 8170, 8318, 9422, 1931, 2183, 4033, 489, +3061, 5698, 7118, 914, 9343, 7086, 1187, 4270, 920, 2270, 3384, 4375, +2906, 3462, 7344, 9432, 9538, 767, 2415, 4147, 9248, 91, 7259, 4665, +4489, 6141, 4714, 1860, 6945, 5991, 6161, 6027, 2406, 7668, 3937, +8849, 3199, 3485, 3508, 7975, 3170, 380, 9762, 9805, 82, 2300, 1430, +7696, 473, 2338, 4804, 5462, 432, 6418, 5056, 7001, 4468, 992, 943, +4953, 6924, 7585, 811, 2882, 3990, 457, 711, 230, 5977, 6681, 7177, +5290, 8723, 7029, 1158, 9311, 9213, 5451, 914, 4227, 7509, 4947, 2086, +8660, 8990, 9355, 7516, 2584, 525, 6609, 9008, 8201, 7503, 1580, 2099, +8668, 5678, 9298, 2256, 1771, 4213, 5172, 6536, 9339, 8606, 5859, +5398, 9281, 4253, 6649, 5355, 6572, 2175, 2756, 4895, 7051, 6389, +1696, 4495, 4731, 8420, 1713, 8669, 8833, 4253, 9875, 2519, 5939, 266, +8239, 7230, 7725, 342, 8106, 4616, 93, 4900, 4274, 4325, 8484, 6812, +7843, 2857, 349, 9855, 4155, 3941, 3168, 7029, 7787, 1533, 328, 8430, +8709, 8395, 8926, 2672, 7607, 20, 5659, 4149, 1976, 2138, 4299, 3878, +9938, 7688, 8062, 5765, 3739, 9996, 8932, 6375, 5025, 3646, 9817, +2743, 8476, 6594, 324, 8706, 8166, 9887, 4598, 4804, 8044, 7896, 3079, +7162, 882, 5512, 6364, 7929, 6467, 8265, 6780, 831, 1155, 5114, 3386, +5558, 8855, 6810, 9904, 9714, 3216, 5634, 4666, 2702, 2379, 6996, +7070, 4825, 404, 4893, 3454, 2732, 3082, 8536, 7947, 6324, 2485, 3234, +8689, 5204, 8659, 7149, 8262, 9714, 8805, 2253, 2171, 6477, 4152, +7208, 3311, 5077, 7608, 6683, 5379, 8898, 4745, 5835, 1035, 6420, +1371, 3870, 1218, 5966, 4321, 4090, 5272, 8378, 6970, 6250, 3967, +8774, 3323, 5749, 5382, 5052, 5964, 3192, 5381, 7318, 8485, 8320, +8905, 8830, 265, 6780, 4717, 4881, 2808, 9924, 7350, 4686, 1642, 4330, +3292, 7942, 8736, 5395, 5140, 1604, 1691, 7272, 7832, 2224, 273, 6051, +484, 9320, 493, 4888, 6985, 716, 3318, 5875, 4321, 6750, 1481, 1086, +8477, 4691, 7326, 5887, 2100, 3368, 4445, 9283, 924, 7375, 5913, 2366, +349, 9408, 5578, 1778, 1059, 2446, 3747, 6179, 1220, 1782, 8125, 5081, +4936, 6135, 119, 2312, 4787, 5336, 6624, 9678, 3145, 2593, 9840, 3939, +1242, 8668, 8792, 2558, 8511, 6747, 1361, 7961, 5684, 9228, 4316, +9679, 2531, 9979, 6223, 1153, 265, 1000, 9585, 4996, 2714, 3909, 8724, +7398, 7917, 3383, 14, 9444, 8667, 8082, 7806, 1189, 96, 7982, 2815, +1577, 6486, 556, 1670, 2590, 3519, 5041, 9260, 4058, 9018, 2211, 8362, +1885, 1918, 1352, 1562, 1065, 3829, 7778, 3776, 143, 6404, 8217, 529, +8021, 6262, 9557, 8105, 3723, 4943, 2824, 7725, 8379, 1998, 2063, +7979, 7919, 8373, 857, 4612, 6180, 1163, 4105, 5709, 6095, 1413, 6235, +7189, 6660, 9718, 3890, 8023, 6652, 3381, 834, 4187, 5570, 4325, 5023, +1575, 2574, 7599, 864, 4045, 2474, 338, 4924, 3061, 1840, 8696, 2139, +4265, 5439, 3605, 6309, 14, 9246, 7673, 1507, 252, 7082, 5927, 3593, +4340, 47, 5978, 4734, 2106, 7509, 4028, 1989, 8460, 1420, 121, 8110, +4693, 3078, 8396, 2492, 1705, 3123, 9334, 5892, 7819, 9384, 5547, +3826, 525, 7560, 1742, 7850, 4390, 5375, 654, 5396, 7954, 527, 6668, +7457, 5217, 4667, 7498, 3256, 2674, 3307, 9087, 6157, 1239, 3477, +5916, 3645, 9786, 2742, 8838, 4995, 1899, 5284, 3374, 5103, 5289, +2077, 2172, 6203, 5039, 2816, 3678, 9720, 8282, 9000, 2920, 2688, +5159, 2613, 7424, 774, 5237, 9055, 2938, 3173, 3093, 1723, 1933, 2870, +6056, 9018, 3034, 1319, 323, 3211, 8908, 3553, 8817, 5442, 366, 4322, +3764, 411, 4126, 2800, 2045, 3870, 4524, 4795, 1298, 4631, 6453, 7259, +4235, 5460, 6581, 3142, 9510, 5747, 8834, 1839, 7408, 7693, 6319, +6514, 7994, 3539, 1008, 8547, 6071, 4224, 6102, 9010, 4240, 9223, +8926, 7830, 7098, 4726, 3056, 1542, 381, 1277, 7786, 5890, 5479, 5702, +9211, 2003, 5671, 6109, 730, 3107, 4452, 9541, 4244, 6970, 9369, 7114, +2739, 8843, 9712, 754, 3282, 8328, 9855, 3062, 3478, 782, 130, 5737, +868, 9147, 6572, 3749, 9218, 3298, 2395, 370, 401, 357, 8260, 4250, +9486, 8855, 8623, 584, 4343, 3908, 9545, 6042, 1850, 6335, 2019, 6656, +4388, 3581, 1490, 791, 4748, 6866, 318, 1476, 2673, 5819, 6471, 6956, +4531, 1356, 7016, 3824, 2317, 8336, 6409, 8564, 5533, 4821, 8721, +8730, 7067, 3989, 9028, 3411, 2012, 6720, 269, 8335, 9700, 1624, 1, +3015, 7102, 9027, 3222, 7289, 7132, 3824, 1771, 8840, 3689, 6111, +6191, 4369, 5084, 768, 3752, 9774, 7186, 6326, 2898, 6224, 4155, 4962, +2933, 2855, 1248, 3623, 7279, 3347, 6787, 2771, 7400, 3385, 1080, +6198, 322, 2343, 6094, 5345, 7495, 838, 7615, 6362, 1204, 7066, 5635, +9370, 6002, 4984, 5502, 7640, 2263, 3173, 4301, 5854, 7253, 8046, +7776, 2267, 9219, 6186, 1762, 8227, 2726, 4786, 7978, 2670, 6818, 190, +9935, 7177, 8750, 8169, 9240, 9703, 7767, 3694, 4589, 9530, 9384, +4719, 3805, 9364, 3791, 6880, 3200, 4276, 7478, 876, 8817, 9474, 5394, +6973, 7186, 9026, 3845, 9302, 9243, 9656, 3641, 8718, 9117, 3863, +8642, 1716, 8028, 1850, 1697, 5614, 782, 338, 6091, 9637, 7621, 1722, +7616, 1360, 6162, 3803, 8200, 1524, 542, 3891, 9039, 2018, 9887, 4094, +8287, 6479, 7282, 788, 9681, 5960, 8733, 6250, 6953, 4990, 5914, 1286, +550, 5887, 267, 770, 9216, 7219, 3143, 7209, 1337, 9993, 195, 7009, +8030, 9987, 9836, 5111, 4409, 2497, 5175, 5386, 5395, 1681, 2224, +2986, 9048, 719, 2771, 3928, 3198, 3373, 2437, 5753, 4382, 7107, 644, +7473, 2880, 5458, 5190, 3248, 1920, 2370, 3104, 26, 7792, 4348, 51, +1109, 1639, 862, 754, 5175, 5195, 1052, 3428, 9215, 1427, 3358, 8372, +4510, 3750, 4086, 1995, 5548, 8768, 7062, 5440, 4925, 2658, 3148, +1004, 2215, 6178, 5271, 7341, 2560, 6419, 4405, 5973, 9491, 9349, +2879, 9691, 894, 5245, 5245, 4967, 2804, 4730, 2945, 7335, 5824, 4995, +8023, 732, 9176, 2222, 4119, 24, 8833, 2865, 2414, 8166, 661, 9233, +668, 885, 8251, 7598, 7530, 9403, 8279, 7536, 8236, 5606, 442, 3417, +1346, 4699, 5653, 7134, 3508, 4066, 3692, 3666, 2174, 6005, 1852, 659, +1511, 7003, 8493, 4182, 8513, 9762, 8464, 6989, 8907, 6518, 1448, +3503, 4302, 8819, 9912, 7264, 6457, 5369, 4670, 5765, 6466, 3683, +5910, 3724, 816, 9608, 4170, 4406, 1600, 937, 9054, 4812, 7376, 1329, +9603, 4349, 3887, 3941, 2751, 8789, 3841, 7384, 5354, 9403, 6513, +3050, 5977, 8247, 3122, 8419, 7198, 435, 9832, 2763, 9279, 7784, 8667, +1391, 4830, 3875, 3516, 7603, 5880, 5991, 4163, 9011, 9487, 6606, +4725, 6850, 5957, 589, 5191, 1047, 4548, 3357, 9914, 2273, 4948, 5797, +9180, 9930, 1778, 6190, 9101, 8609, 1828, 6016, 7173, 7714, 7388, +9846, 1803, 5899, 392, 2048, 2993, 7838, 1232, 1500, 4184, 4226, 2304, +1496, 2337, 857, 3382, 9302, 2247, 8026, 8042, 1096, 9370, 7121, 1035, +7420, 2018, 3231, 1961, 1770, 3594, 6094, 8269, 1312, 2228, 3513, +9003, 5312, 9161, 128, 4579, 7172, 6683, 8972, 8988, 3912, 9014, 1853, +6552, 5635, 2501, 8816, 6440, 8847, 2292, 3738, 4657, 6146, 9870, +2616, 1097, 7737, 8005, 7450, 5413, 1677, 5528, 3243, 2510, 8419, +3496, 8655, 6415, 8864, 1312, 5326, 2010, 5728, 7886, 5715, 4670, +9212, 6573, 8476, 7727, 7830, 6554, 3310, 5684, 290, 6559, 5178, 3472, +2248, 4841, 5059, 8264, 2640, 5216, 5122, 5289, 165, 4577, 4035, 3847, +6899, 7129, 3922, 9484, 8234, 4461, 4678, 8695, 7721, 2658, 7640, 812, +990, 9134, 1385, 9205, 5336, 6785, 5948, 3050, 6086, 701, 67, 8639, +7191, 2872, 1664, 209, 4952, 5930, 6022, 9201, 6641, 4079, 7084, 2375, +498, 1049, 9460, 5329, 9363, 6003, 6570, 6804, 3400, 8325, 3129, 4264, +8057, 1791, 245, 5264, 5387, 2289, 2211, 1266, 9528, 5384, 3420, 4882, +3981, 6747, 240, 1277, 6552, 4148, 4453, 9152, 5195, 1379, 479, 3435, +806, 6406, 1017, 5717, 2607, 3941, 9839, 6859, 1555, 7661, 9295, 9893, +4201, 7858, 8055, 3090, 5197, 2721, 7601, 1214, 282, 7665, 6814, 3629, +8921, 5251, 5321, 2306, 6494, 8068, 4724, 9153, 211, 6256, 7936, 2956, +5710, 9201, 958, 2819, 394, 9097, 753, 4260, 4228, 1461, 9661, 3855, +2310, 3935, 7870, 66, 9801, 565, 1459, 4828, 5763, 5969, 4654, 1484, +8010, 4851, 2656, 419, 8242, 5887, 236, 7873, 4215, 5692, 5788, 9012, +2502, 3708, 3752, 72, 3247, 7722, 9015, 2819, 3388, 7046, 6025, 8465, +9317, 882, 9949, 3682, 1552, 3376, 5428, 1507, 8053, 171, 2135, 647, +243, 1094, 5426, 3178, 3740, 8836, 5764, 5238, 4617, 2581, 382, 4548, +4648, 7590, 7683, 8353, 4221, 6917, 8610, 9230, 5109, 6732, 8740, +3123, 6020, 2923, 9659, 5494, 5134, 6071, 9448, 3348, 6315, 9088, +4496, 2733, 5189, 7074, 7388, 2855, 9366, 5151, 9354, 5790, 9179, +3848, 6191, 603, 4721, 4875, 2204, 6583, 134, 3436, 1822, 3122, 9376, +9952, 9234, 6407, 7977, 937, 2281, 4928, 6289, 494, 5002, 8637, 9483, +5605, 2522, 2500, 5717, 8107, 968, 8968, 728, 4845, 1749, 4358, 6387, +7240, 8423, 173, 3341, 8613, 6893, 9401, 5321, 7911, 8282, 2794, 4833, +8411, 8644, 3259, 9788, 3183, 9108, 4162, 7307, 51, 8671, 2322, 327, +4181, 7917, 3603, 5444, 6967, 712, 1632, 3685, 3635, 3945, 8190, 6700, +1257, 9905, 601, 6424, 8479, 3994, 7286, 3043, 6281, 7711, 8097, 8626, +7028, 7984, 6073, 2707, 127, 1316, 1417, 882, 8865, 7066, 6132, 3095, +3269, 4977, 2658, 8702, 1801, 1756, 952, 3911, 4045, 5798, 6010, 9723, +3247, 5039, 2165, 7635, 8492, 2316, 3, 5614, 9580, 6494, 5059, 5745, +4735, 1923, 5435, 2330, 9980, 3363, 5880, 2510, 3567, 5889, 4229, +7522, 2801, 1954, 9786, 2780, 8048, 8866, 2497, 7, 2559, 9877, 5473, +5164, 1542, 418, 4474, 7496, 1171, 2213, 6951, 4094, 9973, 8560, 2059, +8874, 3888, 8055, 51, 5252, 3829, 3892, 9720, 7176, 944, 5432, 158, +7076, 5735, 8034, 3823, 5234, 8561, 9759, 9987, 4928, 5113, 9713, +7259, 1385, 1713, 2214, 5406, 8303, 5407, 1008, 4876, 6174, 462, 1622, +1788, 4993, 2076, 8544, 6322, 2593, 4247, 7740, 895, 9384, 1218, 4185, +9971, 7525, 2264, 2172, 742, 8980, 9765, 9171, 2519, 7122, 2207, 6958, +3289, 4922, 4687, 5552, 5714, 148, 5236, 9287, 9153, 2323, 7661, 4341, +6541, 2248, 1181, 148, 238, 555, 5069, 8439, 113, 9125, 8558, 5333, +9171, 8390, 2032, 2944, 7086, 4866, 7271, 2894, 6857, 2353, 3527, +3930, 9176, 2955, 8783, 2202, 7443, 4161, 6525, 901, 3323, 6864, 3918, +4969, 487, 6896, 4200, 6561, 3994, 7580, 6216, 1108, 9944, 981, 226, +8396, 9548, 517, 6995, 9823, 8002, 5763, 64, 5215, 8012, 2223, 7986, +1781, 5251, 3581, 5692, 8326, 2128, 6732, 2188, 887, 7050, 1630, 7321, +6837, 4022, 6684, 9944, 411, 2464, 1305, 1586, 8228, 1052, 6606, 4413, +5283, 9520, 9544, 462, 9649, 4313, 1420, 8552, 9872, 52, 6388, 927, +6680, 9957, 5488, 3301, 2186, 4420, 3322, 7436, 4631, 5844, 9006, +9299, 3170, 1829, 2617, 7297, 3519, 6347, 4133, 2501, 75, 2792, 482, +437, 5915, 6051, 472, 9040, 9577, 1731, 5291, 493, 1694, 9389, 3625, +1870, 9538, 6403, 9569, 1362, 6542, 180, 2730, 6208, 875, 2794, 4018, +8811, 7940, 4190, 9231, 7178, 9528, 9587, 7507, 7222, 9729, 6089, +2569, 4901, 6720, 7288, 7007, 2694, 6755, 4956, 5220, 737, 4869, 6659, +9637, 9780, 8583, 8822, 2564, 6252, 9464, 1597, 341, 7189, 2262, 3611, +6888, 5162, 3614, 2945, 8920, 4165, 7253, 4202, 9283, 5955, 5609, +5963, 6175, 5231, 181, 7610, 7346, 9161, 1381, 7165, 2881, 115, 9174, +5201, 6139, 5959, 6263, 8553, 1101, 4712, 9158, 3256, 5723, 3746, +7748, 8832, 8484, 205, 9999, 6092, 5614, 5479, 3825, 5146, 2276, 7139, +6379, 9241, 2644, 4806, 6595, 6195, 2153, 8543, 6685, 7560, 9024, 627, +9614, 6817, 3168, 5472, 5512, 9350, 2728, 3611, 9965, 347, 4837, 9224, +8077, 5740, 7632, 6821, 2157, 6373, 8600, 7035, 2856, 4368, 5240, +4723, 3422, 7241, 954, 1736, 8316, 4473, 964, 5469, 7542, 5781, 7221, +7048, 6814, 4553, 2797, 184, 4138, 5859, 9440, 1513, 7889, 8833, 9211, +9879, 2818, 9561, 632, 8051, 5887, 5255, 1020, 2736, 7337, 2696, 7422, +3812, 8356, 9693, 5145, 7609, 267, 212, 2294, 6817, 6945, 9143, 9210, +7100, 1791, 9185, 6179, 2684, 3213, 9064, 7702, 1332, 6289, 4355, +7666, 9997, 3045, 1784, 6594, 6542, 5460, 9141, 8884, 5712, 3746, +6768, 1388, 7651, 9494, 9834, 5422, 5716, 6339, 8569, 3222, 2158, +5366, 4627, 5886, 7395, 2559, 1454, 6604, 7066, 4492, 5059, 54, 8988, +9939, 2449, 7970, 5216, 3643, 392, 6252, 8284, 3585, 5669, 7236, 1078, +4047, 5006, 6123, 5836, 4275, 2995, 9045, 9984, 6034, 7376, 1494, 710, +290, 3997, 995, 8360, 5089, 2349, 5677, 8809, 7900, 8240, 1222, 6338, +9084, 209, 6229, 2305, 3559, 5292, 6003, 9707, 5448, 7554, 2669, 7573, +5422, 7983, 9883, 8628, 507, 9021, 2008, 2091, 3863, 2260, 8288, 3698, +5176, 1604, 7640, 5768, 3169, 4327, 1431, 7654, 7352, 2869, 8200, +4400, 6623, 5050, 4000, 852, 7695, 1553, 5699, 5652, 5953, 6543, 8139, +4328, 4899, 2177, 6711, 8308, 2102, 8910, 3004, 482, 9855, 4908, 8564, +1054, 8821, 5948, 7246, 833, 3352, 313, 4203, 8825, 4767, 3678, 2682, +3277, 3241, 8653, 2244, 3886, 3328, 8808, 4637, 5330, 5234, 4088, +7293, 4198, 1533, 56, 4067, 3205, 2091, 9359, 1822, 6078, 7370, 7860, +5058, 7480, 4699, 1660, 2878, 4282, 6216, 9722, 9339, 654, 7645, 1460, +3638, 4593, 7143, 1993, 8821, 9138, 9865, 2340, 930, 4076, 3979, 9015, +7540, 2388, 6507, 2125, 384, 9057, 9702, 3034, 2151, 4683, 3397, 2746, +8395, 3704, 1721, 8084, 8300, 7509, 2294, 7321, 7915, 9018, 1509, 352, +5540, 7454, 1674, 7516, 7214, 9514, 3795, 7190, 8361, 9020, 5520, +2794, 9611, 1113, 6769, 3990, 5497, 8229, 343, 1214, 1594, 7474, 5336, +3123, 7394, 8970, 9866, 7747, 4674, 345, 5311, 7273, 6968, 3234, 8142, +5640, 8104, 8430, 8689, 4530, 155, 6767, 9398, 5261, 2288, 838, 3140, +9539, 3391, 6950, 7996, 1175, 403, 364, 2655, 738, 1328, 9875, 2074, +5269, 4120, 6837, 2516, 167, 3991, 3552, 9832, 383, 3828, 4437, 1426, +3895, 2004, 675, 6804, 1817, 7495, 9764, 2257, 8588, 9751, 3371, 2397, +5922, 9696, 4325, 7509, 1685, 13, 1937, 6237, 2882, 7092, 2999, 6074, +4806, 9720, 865, 2073, 5997, 3920, 182, 7460, 6541, 4452, 9439, 8521, +8208, 1532, 7025, 9160, 1139, 6913, 4015, 471, 2930, 1577, 8056, 4705, +7871, 214, 2103, 8304, 6070, 2575, 4073, 8357, 8418, 5236, 1045, 4340, +4848, 274, 1444, 317, 5783, 3277, 7784, 4957, 9029, 3246, 994, 9701, +2154, 171, 770, 5679, 2138, 6343, 8846, 6114, 547, 2204, 8699, 6163, +6482, 3191, 5868, 6821, 9775, 8740, 6714, 7174, 6896, 3331, 7849, +8713, 8043, 3603, 3872, 904, 4083, 2480, 2379, 5609, 1441, 9845, 326, +8749, 8221, 9613, 1342, 4152, 1108, 8209, 6174, 2312, 2473, 2205, +2083, 7401, 2954, 8449, 7322, 3625, 3835, 751, 118, 4877, 5239, 2718, +2259, 5008, 8533, 9147, 3939, 3275, 6954, 678, 4175, 1733, 4804, 5451, +3835, 4379, 4264, 6265, 4943, 5999, 6110, 8171, 9762, 269, 6601, 5039, +4586, 7068, 2206, 8882, 2607, 371, 8786, 4623, 6059, 7942, 4652, 4155, +393, 9550, 2363, 2730, 3690, 5797, 9502, 2121, 9514, 2899, 6543, 5268, +7004, 3985, 6849, 9314, 2647, 2668, 6590, 8196, 5765, 7628, 2317, +6911, 5648, 7906, 1004, 4040, 3910, 3471, 8469, 2552, 8097, 6628, +8856, 9513, 6921, 4619, 4555, 7632, 6389, 4716, 9934, 3149, 4625, +7574, 6621, 7506, 8770, 4370, 2492, 7737, 3246, 7062, 8827, 1420, +1593, 3566, 951, 8603, 1219, 4116, 2142, 4887, 1054, 9586, 7955, 2079, +3564, 9430, 296, 4183, 4789, 5990, 7714, 5157, 9770, 3585, 2566, 733, +7801, 188, 5869, 3150, 3357, 7297, 2833, 399, 8481, 6104, 287, 7560, +3485, 6248, 675, 2305, 6977, 1205, 7757, 4890, 7414, 793, 786, 2119, +2144, 8911, 2391, 9364, 9547, 6457, 4025, 8866, 4309, 4317, 5055, +8772, 3889, 9230, 1837, 7435, 7585, 3159, 6719, 1564, 2832, 1498, +6870, 934, 2980, 8254, 7095, 7542, 7057, 3561, 9496, 9810, 2276, 9876, +2605, 4150, 4720, 9651, 816, 5025, 8477, 6168, 8370, 8240, 8705, 3199, +6650, 5615, 4790, 7120, 2407, 9203, 6503, 6459, 5970, 6067, 5621, +5858, 4952, 4961, 696, 187, 3224, 560, 4020, 8212, 1706, 3435, 2771, +7618, 379, 4745, 9586, 9564, 2923, 4312, 5538, 5397, 1565, 9534, 8903, +300, 2718, 7614, 6696, 3759, 6218, 5470, 3130, 8318, 4791, 4991, 2384, +7106, 3426, 5180, 6917, 3519, 5949, 9122, 7650, 8879, 7027, 9920, +6756, 5374, 4654, 1425, 5879, 7702, 243, 8932, 9904, 5340, 5148, 9468, +3298, 8523, 7990, 1282, 106, 324, 8623, 9292, 7534, 7531, 9855, 6140, +4311, 5410, 881, 4946, 8167, 9814, 7677, 6107, 4569, 1922, 3158, 5583, +1185, 3197, 3742, 6895, 9314, 6096, 2667, 7963, 1441, 6547, 3639, +1879, 1340, 4089, 1700, 4255, 2391, 7456, 5268, 6606, 5505, 7658, +4371, 9638, 2318, 7612, 3641, 304, 108, 6937, 7689, 6692, 7629, 5868, +2508, 7811, 4223, 8424, 5904, 7025, 5123, 1912, 2549, 7903, 8135, +8595, 9915, 7423, 1548, 6079, 1831, 1143, 1678, 9327, 588, 4281, 7282, +2562, 5716, 2356, 5881, 6905, 1265, 4186, 4747, 1010, 1912, 8754, +9166, 6445, 8783, 3139, 5240, 3984, 9396, 2700, 4876, 6630, 9428, +9973, 2436, 4906, 9940, 3109, 7636, 1315, 2906, 1605, 6248, 2680, +7754, 6736, 2030, 3047, 8407, 7093, 1944, 5905, 360, 4373, 8162, 3805, +3530, 101, 1665, 1895, 3969, 1623, 435, 834, 2340, 552, 6547, 6103, +5693, 6537, 2121, 6566, 4404, 7796, 9854, 807, 4164, 9693, 3814, 7329, +6746, 5211, 6565, 4930, 8008, 300, 5915, 9334, 7272, 1412, 4885, 2341, +6068, 5139, 5635, 8300, 9815, 3285, 9115, 5104, 824, 9312, 2771, 708, +553, 5689, 1430, 579, 6173, 7215, 6245, 253, 5223, 329, 5685, 2697, +1665, 7926, 8499, 6806, 32, 9372, 3548, 9981, 1940, 1655, 8165, 8016, +9560, 5321, 6236, 9881, 3603, 7014, 8270, 5529, 8448, 2282, 1278, +1773, 579, 2807, 8583, 5788, 9849, 8505, 4792, 1080, 4015, 7661, 1987, +7915, 216, 2381, 239, 4589, 5113, 143, 7003, 8174, 9316, 6295, 6710, +1460, 5093, 5891, 7043, 588, 313, 4655, 3852, 9579, 851, 9218, 1544, +7936, 8038, 5656, 7065, 8381, 1026, 3609, 2640, 3458, 7971, 5388, +7644, 5858, 411, 4052, 9081, 7896, 2288, 8670, 1897, 8810, 9280, 8299, +3637, 7775, 5554, 7251, 7772, 9369, 1098, 2063, 9640, 8525, 5560, +9669, 3632, 2382, 7806, 1299, 6457, 94, 8688, 8666, 9903, 7196, 3060, +8672, 5808, 6723, 2094, 3928, 1261, 3324, 9540, 2588, 3010, 9862, +8300, 1366, 4126, 7923, 9739, 9508, 8700, 1116, 2829, 8414, 1429, +9287, 787, 3118, 5319, 3549, 1261, 8243, 542, 6402, 93, 6020, 5913, +1550, 6782, 8015, 5441, 5851, 5481, 3851, 1964, 5332, 6634, 2078, +9338, 7597, 4118, 4633, 5305, 1090, 7045, 7237, 1049, 5383, 6831, +1949, 6020, 6918, 2045, 2847, 9290, 5816, 1709, 9655, 5631, 2836, +7583, 5441, 5920, 9551, 6461, 5748, 3133, 3430, 2710, 3726, 9139, +1350, 2155, 9158, 2969, 1477, 1669, 4015, 7040, 4642, 3788, 2547, +3480, 6422, 5939, 8966, 9547, 900, 6836, 8148, 6285, 4394, 5778, 2098, +2890, 1447, 8026, 9875, 7272, 4705, 9073, 535, 4087, 8514, 1210, 6617, +4292, 7026, 9031, 8106, 8181, 8865, 3014, 1341, 4443, 3126, 606, 8314, +1267, 8323, 3360, 2261, 6321, 2670, 6842, 3667, 9830, 1120, 2562, +4397, 5016, 5850, 2483, 1897, 8986, 1506, 9848, 4838, 9510, 8127, +6037, 3061, 347, 7942, 6524, 2418, 2878, 3723, 9312, 1773, 9805, 3573, +5466, 7227, 6802, 4200, 2332, 8787, 9760, 5981, 6880, 6454, 3917, +6213, 1964, 9803, 2957, 6115, 715, 9741, 1843, 4034, 1166, 2916, 2618, +9069, 280, 2085, 3119, 8557, 3089, 1934, 8531, 1953, 4078, 7556, 4013, +6340, 679, 7263, 9298, 5579, 3199, 6159, 6572, 4379, 7280, 9763, 8839, +4265, 3455, 9422, 4460, 2058, 6947, 3205, 5525, 8547, 8896, 2679, +9050, 3762, 2152, 3145, 6154, 722, 513, 3831, 7472, 8639, 5479, 5095, +9218, 6561, 8191, 3302, 3485, 5245, 7609, 2692, 5039, 8460, 884, 8888, +220, 7451, 6136, 993, 1869, 8548, 4425, 4070, 5419, 6045, 6978, 2058, +3710, 3743, 5436, 6720, 7921, 4592, 3485, 6256, 9856, 6857, 2942, +1826, 9512, 8164, 3530, 1460, 6284, 283, 1941, 2646, 8236, 8732, 1036, +7633, 9326, 2827, 2858, 8443, 2889, 5728, 7477, 4996, 5126, 344, 3393, +2869, 7826, 3491, 6107, 5213, 5520, 4856, 4467, 7705, 6637, 1269, +2671, 8911, 7122, 7570, 6323, 6850, 1395, 568, 2976, 2662, 5718, 5684, +4784, 5385, 9192, 7112, 4800, 9933, 602, 7327, 8879, 4225, 4957, 3928, +382, 4579, 4769, 904, 1523, 1142, 7360, 6901, 1864, 212, 2661, 6967, +1923, 6278, 1578, 8790, 8419, 8769, 8639, 9662, 6447, 5776, 1844, +5800, 1393, 4152, 273, 2778, 3229, 3495, 3248, 4669, 5733, 4060, 1470, +2309, 1248, 9294, 205, 7852, 6060, 8258, 6578, 3188, 1204, 6945, 5086, +3975, 1086, 3408, 7966, 5399, 9258, 2249, 8299, 3176, 1731, 4196, +2448, 6636, 6418, 9345, 5212, 4208, 4449, 579, 4185, 12, 8, 4693, 668, +5032, 7408, 7889, 877, 6984, 679, 9241, 9166, 7587, 6856, 1589, 4677, +1742, 9874, 1728, 842, 3799, 8990, 7724, 5882, 8382, 4207, 4725, 1468, +8938, 8100, 8474, 7968, 287, 1051, 4161, 3734, 5785, 5328, 5560, 4454, +7560, 308, 7497, 275, 5209, 1293, 4277, 4692, 120, 354, 5042, 259, +7448, 6315, 3629, 1698, 6927, 7739, 1151, 575, 4184, 4586, 7714, 9020, +8312, 5606, 2402, 8651, 7524, 6353, 2943, 2741, 2696, 1646, 7893, +4886, 759, 1551, 7244, 2193, 7307, 5880, 9115, 5493, 3845, 5791, 2164, +2105, 4907, 9404, 9090, 7722, 4275, 5343, 6062, 8310, 6350, 7860, +1667, 3388, 9604, 9452, 3582, 3725, 2327, 7937, 6758, 4085, 2695, +8969, 1164, 7792, 883, 4487, 6690, 108, 3518, 4618, 1157, 2673, 6979, +115, 9049, 6905, 9781, 2772, 2372, 874, 5473, 5562, 2696, 9599, 3867, +8327, 8257, 3831, 4290, 6550, 4020, 2508, 7771, 3097, 8278, 7336, +3871, 4518, 4930, 9742, 9728, 545, 3769, 6049, 1398, 427, 8944, 820, +7552, 5027, 7746, 9094, 4419, 8718, 9901, 9031, 3202, 383, 1328, 4575, +5978, 9562, 4938, 806, 5864, 9148, 3173, 3595, 6547, 8465, 7108, 1163, +4608, 6657, 315, 4770, 7533, 1622, 5404, 4746, 3683, 9238, 4873, 1472, +4998, 3983, 8421, 3160, 4746, 4363, 2573, 9302, 1701, 9391, 8520, +2750, 516, 3598, 4015, 6961, 2575, 2203, 7981, 1237, 6048, 5567, 1767, +7408, 5722, 5639, 7732, 3002, 3673, 2719, 9681, 2093, 8179, 2251, +9457, 5638, 144, 7167, 5519, 2076, 12, 2286, 1929, 4611, 6077, 3084, +7162, 3347, 2258, 5427, 6568, 2843, 1467, 6095, 6602, 4660, 6671, +9208, 7118, 8495, 1868, 1991, 6527, 9259, 3448, 9250, 1222, 7581, +4933, 5255, 1069, 1793, 6566, 1269, 1723, 435, 2257, 1445, 5499, 5963, +1016, 1962, 6028, 1611, 2714, 7880, 6697, 3705, 2587, 6639, 6311, +2078, 6749, 3028, 2776, 1140, 1138, 7491, 3007, 5158, 3553, 7525, +8129, 9074, 8037, 7541, 7177, 6202, 3138, 2953, 5141, 3116, 1756, +2835, 4532, 583, 9674, 4750, 4875, 6460, 1290, 5708, 6594, 1890, 6053, +7308, 4184, 5724, 2717, 9995, 7627, 9747, 9332, 7983, 402, 2144, 2908, +3544, 2031, 8177, 9607, 2291, 2767, 6579, 2034, 9653, 50, 5528, 9258, +5838, 7621, 1266, 6101, 4957, 7968, 563, 1727, 4426, 1381, 8365, 4756, +1703, 896, 4965, 7977, 5742, 4777, 3671, 1953, 9746, 8914, 7218, 3759, +7336, 5690, 4005, 4834, 8769, 738, 5391, 2699, 1377, 9257, 7155, 9192, +9555, 4739, 958, 6417, 1482, 8729, 7145, 4672, 7338, 8404, 2903, 2072, +3321, 7575, 7273, 3389, 6720, 1959, 3084, 8071, 2697, 5391, 1441, +1155, 7558, 8682, 1253, 2688, 5802, 6859, 210, 7910, 1847, 563, 361, +3187, 5034, 2396, 3857, 536, 31, 1091, 9309, 7022, 9492, 9385, 8034, +9504, 820, 4888, 1003, 7768, 758, 553, 6294, 7990, 7099, 7769, 3664, +1183, 6348, 6537, 2050, 5088, 9810, 7035, 3577, 6285, 959, 8366, 9734, +1786, 9849, 1951, 2353, 8772, 7300, 1697, 8776, 5654, 6422, 1843, +2855, 882, 4677, 1107, 3421, 5898, 9068, 9403, 4466, 139, 6805, 8074, +6316, 4738, 8421, 7312, 3112, 6235, 6773, 3454, 872, 9904, 4401, 1715, +6145, 4767, 7508, 1851, 2051, 9349, 8368, 3876, 6464, 4038, 1306, +2045, 2508, 4952, 6622, 5140, 5185, 3115, 5140, 2293, 5864, 5470, +2881, 112, 5421, 719, 1291, 8604, 2019, 7815, 9963, 2064, 7837, 5515, +378, 3217, 4172, 983, 3521, 603, 7686, 1471, 4530, 7709, 2211, 4043, +8834, 8442, 8334, 2381, 4866, 5857, 8396, 673, 791, 6226, 5651, 818, +6836, 6215, 6403, 7487, 2159, 9322, 2930, 3475, 2926, 542, 3664, 5628, +8865, 8218, 5102, 497, 5518, 1667, 2439, 7588, 6915, 9335, 8808, 6551, +7706, 7799, 907, 2304, 1533, 788, 1846, 1935, 7199, 4424, 7450, 4365, +1051, 3041, 2385, 6644, 7932, 1329, 8063, 7665, 8235, 794, 569, 2977, +9462, 5274, 9583, 4982, 4967, 8295, 803, 1478, 3529, 431, 7039, 8562, +2254, 8756, 6239, 2627, 186, 6476, 2779, 6587, 6727, 322, 5082, 2936, +7147, 6715, 4605, 1946, 5343, 4123, 5555, 7419, 3317, 9104, 3124, +8239, 6484, 2546, 4696, 3955, 5701, 1624, 3159, 7878, 6678, 1214, +7853, 5318, 2233, 5304, 5978, 5057, 8995, 2503, 6523, 719, 8260, 5831, +6817, 7464, 6689, 9830, 9949, 2251, 694, 6175, 8850, 7500, 9714, 7598, +5852, 9218, 5702, 5019, 4503, 5012, 4540, 7296, 6143, 7671, 5786, +1717, 3703, 7048, 3557, 6209, 6205, 7607, 5631, 8543, 9555, 1857, +5803, 6733, 1323, 1912, 432, 7228, 9703, 9738, 9652, 5525, 4936, 5100, +9187, 1597, 4292, 7439, 8595, 8543, 9163, 6346, 3830, 9068, 6904, +4153, 9657, 487, 7372, 3115, 4766, 73, 8865, 9988, 1847, 3895, 9730, +2547, 7449, 8751, 9250, 4221, 8476, 9958, 5469, 6971, 9930, 9974, +8677, 8891, 4703, 3326, 1624, 5628, 3255, 5552, 6580, 8984, 8594, +8667, 3270, 2793, 8396, 636, 2364, 2866, 8759, 929, 5083, 6209, 4514, +4110, 7326, 5391, 4834, 4143, 1443, 6690, 8537, 3557, 3249, 2478, +8294, 9189, 1428, 1492, 1784, 400, 6465, 1227, 4853, 5654, 8343, 5569, +4444, 9716, 8272, 5426, 408, 3688, 5976, 4570, 3892, 4886, 5151, 484, +4923, 1126, 6673, 4495, 5830, 5148, 751, 5795, 6388, 8268, 4287, 6924, +6345, 6003, 2707, 6194, 2464, 1994, 3189, 2698, 4954, 4168, 7558, +7788, 9193, 3541, 6743, 9249, 4833, 3797, 8790, 8607, 5468, 3397, +5370, 8497, 5243, 334, 6264, 9304, 3360, 1867, 1890, 7821, 178, 7611, +9847, 4690, 7045, 2553, 9479, 5975, 2070, 9782, 7811, 3194, 4234, +6145, 6866, 4930, 9098, 546, 6682, 2877, 933, 3894, 4509, 8480, 3246, +2592, 8001, 7272, 4783, 6730, 2663, 2560, 9504, 8721, 8723, 8833, +6205, 2548, 3228, 6059, 2547, 5322, 6998, 8308, 285, 2689, 1013, 7685, +8126, 6149, 7493, 4741, 2616, 8339, 3036, 2962, 9634, 852, 9302, 1244, +8258, 7421, 872, 8584, 196, 4458, 242, 615, 1247, 1642, 6100, 2222, +2084, 4776, 9662, 700, 5055, 2881, 4353, 805, 459, 5350, 7061, 8814, +9590, 9579, 2177, 1274, 5594, 4720, 7121, 2526, 4059, 8579, 5884, +7257, 6436, 6418, 8893, 8845, 5127, 9462, 6930, 3835, 9620, 7846, +7928, 8047, 7043, 2717, 6903, 8435, 438, 2365, 3751, 3356, 7098, 9086, +5467, 2044, 5228, 6898, 4644, 4512, 9825, 6366, 8461, 5749, 3294, +8797, 1984, 1406, 634, 4617, 3502, 678, 9877, 2858, 3550, 4038, 6353, +5813, 2302, 6500, 2037, 7835, 3902, 5673, 4892, 5048, 3187, 8750, +2373, 1922, 9266, 8420, 4728, 2805, 312, 1213, 1276, 4595, 3424, 6588, +2625, 1380, 2030, 8790, 4546, 7202, 3363, 5397, 850, 7788, 1398, 4322, +1019, 4697, 6707, 4138, 7666, 9847, 1355, 9072, 9653, 8606, 8547, +4212, 3430, 9120, 4117, 118, 8605, 8372, 4647, 7357, 6482, 4143, 1165, +935, 6075, 6571, 3062, 4070, 7366, 9297, 6957, 2186, 2045, 8078, 8390, +3564, 8996, 8517, 6837, 4691, 2106, 6494, 4804, 8081, 2461, 3986, +9973, 6935, 2937, 3626, 6672, 5001, 2435, 7276, 9898, 3974, 6192, +4606, 802, 7173, 7638, 9243, 9151, 8965, 8032, 9767, 1901, 1775, 5597, +6931, 2133, 9994, 772, 1270, 8907, 5979, 5100, 2305, 9777, 3517, 2704, +5705, 3701, 3191, 321, 1613, 8164, 2879, 349, 7294, 9684, 4632, 3180, +9825, 5905, 3197, 9866, 2686, 2563, 6469, 9830, 2230, 5668, 4619, +8269, 7935, 5252, 693, 3306, 9656, 6865, 8157, 3535, 1117, 8362, 6646, +4942, 8771, 9410, 4887, 1698, 7419, 3576, 1522, 7876, 2470, 8202, +7194, 270, 1715, 2765, 7556, 7276, 4539, 4930, 8095, 1916, 944, 5995, +7790, 4535, 5937, 3507, 7849, 3900, 4529, 3636, 9653, 4064, 5546, +1814, 5962, 3504, 3299, 6480, 8168, 9462, 3360, 7918, 6391, 252, 2635, +2045, 7158, 9951, 55, 8194, 3805, 21, 2992, 7080, 1196, 1488, 6902, +4817, 1552, 5230, 7909, 9715, 8112, 1855, 1974, 6223, 109, 2603, 3658, +2385, 5356, 3321, 4629, 1556, 5346, 2532, 6019, 1401, 3860, 7140, +5931, 941, 459, 4266, 6659, 6408, 182, 6804, 3283, 5344, 7090, 4911, +3218, 8952, 479, 3679, 2180, 2022, 2613, 8760, 9833, 8845, 9988, 8636, +5380, 3785, 1778, 4853, 6419, 7036, 8468, 3953, 5331, 8572, 9203, +2303, 3036, 737, 228, 5252, 4206, 1131, 4536, 1804, 8015, 2892, 2898, +8177, 1415, 5767, 1446, 4581, 9191, 9387, 5954, 8250, 4677, 5057, +1007, 7388, 126, 2095, 3138, 4186, 8477, 598, 7733, 3809, 9050, 2214, +7903, 2694, 6994, 5458, 7184, 6039, 4722, 1745, 265, 347, 3872, 7454, +6987, 7616, 9208, 463, 4350, 945, 4753, 1032, 4549, 7346, 8308, 8109, +4298, 2882, 1418, 9243, 352, 2532, 367, 4011, 1657, 2613, 6530, 5644, +787, 1254, 8950, 2232, 8048, 4051, 6368, 1633, 1604, 4765, 972, 6483, +6652, 1976, 2191, 6533, 7423, 5687, 2187, 7847, 5149, 4958, 7905, +4247, 9828, 3948, 4869, 3498, 5506, 499, 9262, 4871, 2406, 4517, 4612, +8751, 495, 443, 8868, 9725, 529, 631, 3137, 4137, 7666, 6909, 184, +8514, 4291, 7627, 30, 1096, 8536, 7335, 1765, 8304, 6701, 6437, 3599, +9772, 7978, 3822, 4608, 1317, 7690, 3597, 6331, 3913, 7417, 2123, +8173, 7799, 112, 4335, 6541, 3361, 5660, 4381, 9283, 4226, 757, 3043, +8687, 1602, 3285, 7772, 1616, 3266, 5240, 36, 2449, 3214, 9964, 9790, +2164, 9394, 4547, 3197, 2977, 7910, 5230, 9551, 465, 7238, 9885, 2264, +9474, 8732, 5189, 1331, 1278, 5186, 8341, 1647, 2690, 3136, 9104, +3050, 9435, 4044, 7057, 6296, 9768, 2603, 9840, 36, 1353, 1181, 8096, +4002, 99, 7326, 9091, 9711, 9430, 6031, 264, 3588, 7832, 6186, 1314, +7341, 8355, 1832, 3915, 2099, 1912, 787, 648, 2006, 6364, 455, 9470, +2701, 603, 930, 7169, 2086, 5984, 7189, 1060, 4067, 1254, 4852, 7606, +6409, 368, 1990, 3489, 5782, 1264, 4968, 6694, 2871, 7817, 968, 3470, +3239, 2405, 7960, 1568, 8818, 6715, 5143, 1656, 3465, 8062, 1077, +7103, 7408, 9508, 3964, 3982, 6236, 5096, 7035, 8283, 110, 52, 7553, +657, 3979, 1966, 3736, 5793, 3110, 9606, 5012, 1590, 9886, 8866, 6829, +2482, 2477, 354, 2689, 1362, 6167, 1702, 1717, 3446, 4534, 4134, 1934, +1493, 7426, 6281, 8971, 7223, 2601, 1116, 2312, 219, 5579, 1738, 7097, +9258, 620, 9597, 5429, 5897, 9549, 9791, 8079, 8843, 9351, 5814, 5916, +2682, 3885, 2260, 3720, 288, 715, 9406, 503, 4327, 3346, 9330, 9714, +8744, 8916, 6384, 2097, 9120, 3211, 6082, 4405, 364, 7471, 4916, 3030, +7681, 8623, 5157, 4623, 7124, 3096, 7238, 5118, 4006, 3526, 4031, +9392, 1211, 9457, 2289, 3405, 7810, 2018, 9111, 8775, 473, 6529, 6989, +6695, 8794, 7031, 7312, 267, 4348, 3294, 1897, 3584, 5890, 7103, 1224, +8751, 6418, 342, 1799, 7940, 9378, 9136, 9178, 7349, 7567, 6787, 1026, +302, 7120, 2663, 2274, 7388, 7578, 2679, 8501, 2700, 4379, 3273, 9499, +7669, 7138, 7275, 779, 6795, 3363, 5768, 1987, 9895, 2909, 5934, 8961, +2864, 9906, 6607, 9140, 4622, 5822, 9646, 4354, 6219, 7163, 4383, +9716, 3688, 4038, 561, 7671, 5590, 9459, 9847, 838, 9622, 852, 9208, +8941, 1129, 7426, 4315, 5098, 4753, 3507, 2161, 1685, 459, 8011, 1156, +1171, 5453, 3832, 7494, 1109, 4795, 7890, 4046, 5349, 5881, 3458, 717, +1214, 2314, 4393, 4351, 5980, 4401, 5783, 9665, 5941, 4550, 1047, 783, +6566, 6569, 7156, 1321, 5380, 4050, 4300, 8200, 8840, 8525, 9493, 970, +4206, 6513, 5368, 5033, 461, 8559, 5730, 9420, 1416, 1252, 2153, 6889, +6278, 2126, 8807, 9639, 288, 3178, 7459, 2776, 6833, 8811, 2128, 2146, +1339, 8464, 3906, 4433, 1778, 9054, 9503, 2631, 6379, 5667, 4868, +8000, 6876, 2058, 2024, 7115, 632, 2677, 8648, 4955, 9946, 6230, 539, +463, 5327, 5899, 4217, 6618, 8282, 2254, 6986, 8339, 8304, 3858, 7575, +3649, 1059, 3162, 5225, 2695, 7927, 1157, 242, 9500, 9602, 6978, 8685, +4457, 8700, 463, 5293, 5021, 8553, 7058, 5038, 8075, 6091, 9481, 4466, +7512, 8827, 141, 6111, 3154, 3542, 1576, 6579, 6878, 1987, 1920, 3901, +2541, 5965, 6687, 340, 9115, 8502, 270, 1757, 1023, 1374, 8428, 4676, +2515, 2730, 2248, 2356, 5669, 4501, 1184, 5357, 746, 383, 7798, 3667, +4076, 7488, 5588, 4400, 2156, 3948, 6311, 9658, 4571, 8602, 9453, +4835, 5696, 1516, 8055, 2800, 8540, 8864, 8685, 9700, 3197, 2913, +9985, 7643, 5888, 4515, 3296, 793, 7936, 4114, 2250, 2962, 8950, 7127, +4722, 505, 7844, 9245, 5215, 2961, 1342, 8753, 9082, 9624, 613, 8848, +1489, 9098, 289, 7797, 8786, 5556, 8586, 9599, 3528, 8294, 2321, 7819, +5576, 7648, 5428, 773, 6573, 270, 8997, 1922, 8854, 5233, 4747, 7284, +1157, 283, 3668, 2919, 1567, 8050, 2313, 8000, 35, 3946, 9278, 7568, +565, 7630, 877, 3090, 5792, 6599, 8014, 6180, 1777, 1906, 9350, 2231, +4865, 8647, 1943, 4809, 7499, 9539, 4328, 3345, 6345, 121, 115, 4079, +1348, 5646, 2038, 3066, 5593, 5196, 2375, 1886, 2215, 1090, 1148, +5293, 8838, 2362, 4016, 6009, 5401, 2423, 7921, 5143, 3885, 3216, +5224, 9021, 7915, 8751, 7993, 4123, 3958, 8223, 392, 982, 3632, 8148, +7379, 4697, 3983, 8692, 5329, 9120, 5492, 8386, 841, 1561, 4500, 2906, +8776, 5197, 4963, 9557, 4055, 6635, 3746, 6331, 7346, 2686, 6657, +1288, 4603, 103, 6242, 1917, 971, 9034, 4836, 6375, 437, 686, 2063, +8363, 2593, 9384, 1225, 728, 3381, 3165, 6967, 386, 781, 7817, 4720, +7314, 7558, 1136, 5980, 5108, 1459, 1159, 7690, 8973, 8416, 7559, +9787, 6266, 1893, 1644, 3423, 9902, 4316, 3944, 7373, 1966, 6416, +4370, 8569, 7446, 5407, 9835, 2374, 503, 3580, 4528, 1842, 3256, 2155, +287, 250, 8985, 5050, 4912, 8170, 3165, 5897, 5952, 5722, 9145, 1022, +5264, 7152, 3548, 5721, 2365, 6433, 6550, 6480, 5145, 7031, 7358, +7843, 1846, 8682, 4792, 1718, 3509, 9435, 9927, 2745, 7076, 70, 9089, +8473, 6166, 3031, 1894, 2738, 3592, 9833, 9657, 1864, 9634, 8484, +7420, 454, 7781, 8666, 7908, 3720, 1629, 8146, 9567, 6366, 5893, 9741, +9421, 9264, 9584, 193, 9339, 3700, 2526, 3999, 532, 3155, 1229, 226, +4852, 1402, 4915, 6359, 4520, 1778, 7823, 6009, 722, 7074, 6908, 1337, +4851, 4079, 1263, 7346, 301, 2243, 4941, 8503, 5836, 2558, 6772, 4650, +8631, 9415, 8692, 7691, 841, 4913, 6206, 479, 2672, 7817, 2306, 9887, +4244, 7701, 2825, 2146, 8922, 6978, 5142, 9518, 5489, 6655, 1094, +1043, 2065, 1315, 9153, 7648, 8628, 5199, 6698, 600, 191, 3207, 6937, +5124, 3132, 1185, 4397, 1574, 4092, 1661, 270, 4301, 5250, 8888, 1419, +3990, 3796, 1017, 8126, 2704, 1394, 5636, 8639, 3603, 4530, 6851, +4596, 7693, 9639, 2019, 3699, 9970, 8451, 6871, 789, 9484, 5936, 6996, +316, 1264, 1351, 268, 8498, 2861, 5625, 3389, 4318, 3129, 8064, 4697, +5309, 2721, 6564, 1717, 7925, 3400, 1188, 8250, 5662, 1262, 1234, +9002, 7187, 4345, 9400, 136, 7275, 7607, 9918, 7654, 8194, 9026, 2099, +7526, 5464, 7383, 4147, 7261, 4995, 2360, 9347, 9273, 7743, 673, 4307, +4002, 2936, 2145, 6504, 2127, 4225, 956, 5450, 858, 2100, 6460, 9151, +1473, 5190, 4194, 4224, 48, 3053, 7395, 2381, 1900, 8835, 6998, 4461, +1495, 5576, 5708, 8767, 2663, 3440, 4595, 6698, 6322, 3773, 5553, +2041, 4954, 2817, 3342, 9452, 2208, 6443, 2692, 4206, 6469, 885, 1100, +8694, 7346, 466, 8671, 6769, 6286, 3933, 9328, 3345, 4709, 93, 9896, +6875, 3718, 714, 6017, 9670, 401, 6302, 7066, 5059, 9443, 8023, 4759, +5362, 9434, 4200, 2724, 9928, 381, 4533, 4493, 8580, 7890, 4945, 9051, +1464, 9136, 6897, 1349, 1312, 1171, 7386, 8378, 7435, 6802, 4803, +9100, 7186, 9721, 1150, 4814, 7986, 1840, 8969, 4132, 297, 4984, 7764, +3850, 5102, 5702, 2708, 4767, 7006, 6213, 7579, 9204, 1794, 627, 9528, +1118, 2436, 7348, 422, 9826, 9694, 8941, 679, 1211, 8456, 9233, 3619, +6523, 5247, 3405, 8461, 9953, 4434, 610, 1258, 2290, 3521, 9549, 7216, +3019, 4492, 8393, 5655, 7842, 4225, 2289, 4163, 8843, 1044, 1801, +9246, 7112, 3765, 7133, 9685, 449, 8715, 2215, 3341, 881, 2994, 5402, +65, 4662, 5556, 8745, 8885, 8182, 2892, 9305, 4776, 8810, 3593, 2977, +2243, 5495, 3200, 6013, 7627, 8811, 2219, 7231, 4652, 1533, 6297, +1707, 1262, 9738, 3664, 1996, 9870, 4097, 4772, 7006, 1646, 7913, 190, +9765, 2184, 2212, 1926, 7910, 3267, 1088, 1655, 8521, 358, 9144, 1447, +3775, 2066, 7557, 9036, 8392, 1101, 3323, 583, 7299, 8361, 9888, 9774, +3733, 5782, 5873, 9850, 950, 3796, 6792, 5182, 3444, 8965, 1967, 8557, +8838, 1270, 5579, 1719, 8487, 571, 3158, 8148, 8472, 9408, 5945, 4930, +4153, 570, 5237, 6659, 7401, 171, 1221, 6885, 7486, 8220, 5824, 9903, +5190, 3318, 2063, 5397, 327, 9039, 6902, 1711, 1579, 4138, 6390, 2616, +9117, 1501, 2475, 6473, 9849, 8473, 4347, 1071, 9529, 2206, 7746, +8499, 2217, 7067, 387, 6570, 6110, 2263, 4143, 8543, 7675, 738, 1197, +1015, 469, 6896, 8000, 3629, 3910, 6548, 6657, 9819, 5720, 4238, 2524, +3546, 6164, 8912, 1040, 3734, 435, 5840, 4591, 71, 8903, 452, 9577, +6430, 7814, 2838, 8853, 9512, 8330, 787, 6840, 8105, 8542, 9673, 9650, +3951, 3510, 7464, 7046, 3364, 2356, 7058, 7591, 1669, 5163, 5686, +9940, 5730, 4396, 4270, 575, 3161, 614, 2444, 2896, 7087, 7964, 9115, +5673, 2432, 4630, 6103, 7283, 2130, 9130, 5891, 4700, 5936, 8572, +2783, 9912, 559, 8346, 7411, 123, 3230, 5545, 1627, 5236, 6025, 1942, +8407, 7667, 8167, 9046, 3075, 4674, 1183, 1376, 4782, 5025, 4612, +1629, 3002, 31, 4698, 6964, 9191, 3679, 1981, 9981, 9191, 9664, 6261, +3369, 7404, 6785, 2419, 1199, 9128, 7606, 975, 9699, 7762, 4807, 8012, +5886, 5983, 3766, 9500, 9637, 5424, 3014, 5685, 6071, 971, 8955, 561, +4554, 1236, 9173, 9858, 841, 7204, 8774, 8923, 4881, 5246, 5235, 3620, +6587, 5236, 9723, 6527, 5190, 7229, 6306, 8636, 673, 7972, 2685, 2530, +5223, 1123, 1810, 1861, 9093, 5755, 7049, 8075, 1803, 7424, 3991, +5234, 8823, 5706, 1795, 2893, 4894, 2222, 4722, 5500, 9687, 3365, +6166, 9691, 8014, 5774, 2906, 9287, 8834, 9247, 8119, 5167, 2918, +5868, 660, 1387, 6389, 2279, 7903, 116, 5808, 3042, 9733, 2738, 9275, +4990, 9202, 4801, 5980, 4212, 8455, 3690, 2157, 838, 8041, 4493, 8008, +5591, 7887, 8945, 3700, 8355, 6760, 2234, 2813, 9531, 2636, 4474, +7300, 6121, 8036, 1145, 1629, 4754, 761, 8444, 3595, 2525, 3303, 2406, +1282, 9061, 2312, 7485, 173, 9492, 8568, 952, 6817, 4317, 2835, 7920, +9837, 4283, 5532, 2026, 1255, 2720, 6031, 9327, 1069, 7542, 8112, +6366, 4770, 9499, 657, 4617, 9289, 1702, 3003, 7383, 6886, 7375, 3614, +4412, 7041, 536, 6363, 4586, 5334, 3599, 4961, 2697, 8938, 6632, 3113, +8375, 7744, 9121, 5426, 775, 9208, 7426, 146, 43, 921, 4781, 5240, +4727, 7346, 6510, 371, 7231, 4624, 6840, 4938, 6379, 4977, 5713, 4934, +4101, 3100, 903, 9020, 8923, 1695, 4183, 1772, 1048, 6300, 4501, 3563, +9719, 5894, 6120, 1136, 799, 7830, 856, 3421, 2049, 8352, 4808, 6668, +2944, 140, 5359, 1496, 7573, 1267, 1629, 564, 8779, 7707, 4838, 4658, +7364, 9377, 3167, 9481, 6234, 4332, 3899, 9452, 5077, 6048, 8888, +1080, 7444, 2469, 4634, 2613, 4135, 9052, 146, 1770, 2020, 1650, 47, +1551, 1312, 8546, 958, 6347, 4741, 4792, 6860, 6066, 7397, 2696, 5999, +8862, 65, 2563, 435, 2463, 6228, 443, 5958, 4490, 7040, 5175, 2423, +7690, 5189, 2545, 380, 4563, 1656, 4445, 8688, 6889, 2150, 2583, 7421, +2284, 126, 7947, 2932, 8672, 5975, 4662, 9941, 4390, 8496, 72, 9696, +3233, 7076, 2589, 719, 5533, 4707, 4292, 9041, 2331, 2008, 1345, 5441, +4978, 8898, 109, 4428, 2918, 2438, 1390, 211, 8192, 4398, 8497, 1629, +7118, 2932, 5913, 34, 4163, 1028, 6512, 1417, 7470, 8127, 3961, 9640, +7800, 6777, 950, 304, 9295, 2456, 6503, 1854, 3739, 6512, 822, 760, +93, 2949, 5551, 5232, 3324, 9704, 9362, 2920, 6807, 6866, 2423, 9725, +3705, 1417, 8142, 6862, 7206, 3857, 3756, 6819, 6394, 6786, 3378, +6190, 8484, 7192, 3722, 2510, 1949, 9738, 4477, 8308, 2731, 8650, +2101, 6112, 8341, 5267, 5797, 3162, 1051, 2468, 9707, 3333, 6190, +5300, 2276, 5380, 3833, 9318, 9132, 8087, 9682, 8333, 3137, 9030, +6244, 745, 1187, 925, 5938, 4053, 2385, 399, 4167, 9807, 1393, 8627, +6579, 6504, 7468, 8094, 82, 7957, 2978, 9177, 1476, 6736, 3166, 2759, +7225, 4564, 8208, 3834, 5719, 9808, 3551, 7301, 2156, 3798, 3968, +4517, 8351, 1601, 8946, 902, 7268, 3899, 183, 5154, 2357, 4300, 613, +6159, 1439, 2641, 4899, 8568, 3395, 7857, 5451, 448, 6743, 128, 9697, +7041, 1111, 5261, 3140, 2, 2614, 599, 3061, 8085, 6800, 889, 2549, +8776, 975, 3412, 8192, 241, 7191, 665, 3006, 5576, 9356, 5639, 9116, +8740, 1378, 2779, 5207, 4283, 3903, 9172, 8312, 2464, 2644, 1034, +5675, 5707, 8467, 8569, 3912, 6034, 2987, 5201, 472, 6856, 7445, 5617, +3990, 7089, 2622, 1515, 3285, 7061, 4706, 1516, 4588, 8629, 6576, +9584, 4859, 503, 9560, 9881, 2099, 5386, 9063, 4889, 4414, 4443, 812, +9577, 4861, 9742, 9363, 1218, 7124, 155, 2104, 7627, 1914, 383, 1688, +8886, 1310, 5751, 5585, 8305, 7633, 5442, 7467, 2527, 771, 119, 1120, +1520, 8254, 9866, 9552, 1414, 6018, 2648, 8869, 7244, 8759, 4573, 500, +2736, 5908, 196, 2927, 8779, 8703, 7825, 6745, 7475, 3114, 1959, 7208, +1377, 5084, 6020, 6624, 6354, 3680, 5135, 9040, 4548, 5440, 1421, +4910, 5156, 3588, 2176, 3611, 7100, 2124, 5577, 6295, 7532, 8432, +3297, 3837, 8670, 7256, 1567, 615, 7499, 4540, 5757, 8316, 5182, 8439, +269, 1354, 3376, 1936, 3837, 6445, 6165, 3921, 4506, 5794, 7878, 940, +8535, 2778, 7649, 4070, 1198, 8648, 8587, 6664, 3378, 482, 3794, 9093, +3479, 3347, 1585, 4016, 9684, 4826, 9157, 5164, 6407, 5041, 7173, 861, +6288, 169, 1824, 4405, 9150, 4187, 144, 2691, 9789, 8397, 9874, 8175, +1502, 6227, 1085, 7523, 6999, 879, 3520, 2683, 5298, 7778, 7696, 4108, +6044, 8317, 5078, 9992, 9306, 6093, 8856, 9921, 3045, 1787, 556, 2086, +9296, 8743, 2387, 9546, 7201, 831, 9358, 2948, 2180, 3979, 7456, 948, +1621, 6450, 9382, 5402, 6249, 8327, 3727, 5399, 1438, 6247, 5856, +2154, 728, 6752, 1164, 1131, 1583, 5376, 4569, 20, 8219, 6299, 3986, +9054, 1374, 4604, +}; diff -Nru /sys/src/cmd/ptrace/st.c /sys/src/cmd/ptrace/st.c --- /sys/src/cmd/ptrace/st.c Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/st.c Mon Mar 14 00:00:00 2016 @@ -0,0 +1,462 @@ +#include "all.h" +/* + * The main data structures are kept here. + * + * All events are converted into St (sched trace) + * structures and kept allocated at graph[] + * If input is from device, this array is sorted by time. + * Most other data structures rely on indexes on graph[]. + * + * All events for a process are linked together using the + * St.pnext index. + * + * There is a Proc per process, with an array of indexes in graph[] + * for events that changed state. These are usually log of the + * size of the trace for the process. + * + * For browsing, each proc is noted with the row used and + * the first and last slots in Proc.state shown in the current view. + * This narrows the events to be considered for a plot. + * + * Starting with a Proc.state[i], all following events can + * be retrieved by following the St.pnext-linked list. + * + * As a further aid, the code plotting processes decorates + * St's with the x for its start point, so that we can scan + * a series of St's (or state[]s) and determine which one is + * at the mouse. + * + */ +typedef struct Name Name; +struct Name +{ + int pid; + char name[10]; +}; + +static int lno = 1; +static char *fname; +St **graph; +int ngraph; + +static Name *name; +static int nname; + +Proc *proc; +int nproc; + +static char *etname[Nevent] = { + [SAdmit] = "Admit", + [SRelease] = "Release", + [SEdf] = "Edf", + [SRun] = "Run", + [SReady] = "Ready", + [SSleep] = "Sleep", + [SYield] = "Yield", + [SSlice] = "Slice", + [SDeadline] = "Deadline", + [SExpel] = "Expel", + [SDead] = "Dead", + [SInts] = "Ints", + [SInte] = "Inte", + [STrap] = "Trap", + [SUser] = "User", + [SName] = "Name", +}; + +/* Should be generated */ +static char *ssnames[] = +{ + "Dead", + "Moribund", + "Ready", + "Scheding", + "Running", + "Queueing", + "QueueingR", + "QueueingW", + "Wakeme", + "Broken", + "Stopped", + "Rendez", + "Waitrelease", +}; + +static char* +ssname(int i) +{ + if(i >= 0 && i < nelem(ssnames)) + return ssnames[i]; + return "unknown"; +} + +static void +error(char* msg, ...) +{ + char buf[500]; + va_list arg; + + va_start(arg, msg); + vseprint(buf, buf+sizeof(buf), msg, arg); + va_end(arg); + Bflush(bout); + fprint(2, "%s: %s:%d: %s\n", argv0, fname, lno, msg); +} + +int +Tfmt(Fmt *f) +{ + vlong t, i; + static char *u[] = {"s", "m", "µ", "n"}; + static vlong d[] = {S(1), MS(1), US(1), 1}; + static char spc[3+2+1]; + + t = va_arg(f->args, vlong); + if((f->flags&FmtSharp) == 0) + return fmtprint(f, "%011lld", t); + + if(spc[0] == 0) + memset(spc, ' ', sizeof spc - 1); + + for(i = 0; i < nelem(u); i++){ + fmtprint(f, "%3lld%s ", t/d[i], u[i]); + t %= d[i]; + } + return 0; +} + +/* + * This tries to combine printing the state information for + * the text file format so it keeps all the information and + * is easy to parse, with a compact representation amenable + * for an editor. + * %#G is intended to print the state in the window. + * %G is intended to print the full state for the file. + * If the output of %G is changed, readgraph() must be updated + * to parse it properly. + * As of now it uses the (awk) fields 1, 2, 3, 4, NF-1, and NF. + * all other fields are ignored for reading. + */ +int +Gfmt(Fmt *f) +{ + St *g; + vlong arg; + u64int addr; + extern char *scname[]; + extern int maxscval; + + g = va_arg(f->args, St*); + if(f->flags&FmtSharp) + fmtprint(f, " %s", etname[g->state]); + else{ + fmtprint(f, "%T %6d %02d", g->time, g->pid, g->machno); + fmtprint(f, " %-4s", (g->name && g->name[0]) ? g->name : "_"); + fmtprint(f, " %-6s", etname[g->state]); + } + switch(g->etype){ + case SSleep: + arg = g->arg&0xFF; + fmtprint(f, " %s pc %#ullx", ssname(arg), g->arg>>8); + if(f->flags&FmtSharp) + return 0; + break; + case STrap: + arg = g->arg; + addr = g->arg & STrapMask; + if(arg&STrapRPF) + fmtprint(f, " %-10s r %#ullx", "pfault", addr); + else if(arg&STrapWPF) + fmtprint(f, " %-10s w %#ullx", "pfault", addr); + else if(arg&STrapSC){ + arg &= ~STrapSC; + if(arg <= maxscval) + fmtprint(f, " %-10s", scname[arg]); + else + fmtprint(f, " sc%ulld", arg); + }else + fmtprint(f, " %-10s", etname[g->etype]); + if(f->flags&FmtSharp) + return 0; + break; + default: + fmtprint(f, " %-10s", etname[g->etype]); + } + + if(f->flags&FmtSharp) + return fmtprint(f, " %#ullx", g->arg); + else + return fmtprint(f, " %2d %#ullx", g->etype, g->arg); +} + +static void +addname(St *g) +{ + int i; + + for(i = 0; i < nname; i++) + if(name[i].pid == 0 || name[i].pid == g->pid) + break; + if(i == nname){ + if((nname%Incr) == 0){ + name = realloc(name, (nname+Incr)*sizeof name[0]); + if(name == nil) + sysfatal("malloc: %r"); + } + nname++; + } + name[i].pid = g->pid; + assert(sizeof g->arg <= sizeof name[i].name); + memmove(name[i].name, &g->arg, sizeof g->arg); + name[i].name[sizeof g->arg] = 0; +} + +static char* +pidname(int pid) +{ + int i; + + for(i = 0; i < nname; i++) + if(name[i].pid == pid) + return name[i].name; + return "_"; +} + +static St* +readdev(Biobuf *bin) +{ + uchar buf[PTsize], *p; + long nr; + uvlong x; + St *g; + + nr = Bread(bin, buf, sizeof buf); + if(nr == 0) + return nil; + if(nr < 0){ + error("read: %r"); + return nil; + } + if(nr != sizeof buf){ + error("wrong event size"); + return nil; + } + lno++; /* count events instead of lines */ + + g = mallocz(sizeof *g, 1); + if(g == nil) + sysfatal("no mem"); + g->pid = le32get(buf, &p); + g->etype = le32get(p, &p); + g->state = g->etype; + g->machno = le32get(p, &p); + x = le64get(p, &p); + g->time = x; + g->arg = le64get(p, &p); + if(g->etype == SName) + addname(g); + g->name = pidname(g->pid); + + if(verb) + fprint(2, "pid %ud etype %ud mach %ud time %lld arg %lld\n", + g->pid, g->etype, g->machno, g->time, g->arg); + return g; +} + +static St* +readfile(Biobuf *bin) +{ + char *s; + char *toks[18]; + int ntoks, et; + St* g; + + while((s = Brdstr(bin, '\n', 1)) != nil){ + lno++; + if(s[0] == '#') + goto next; + ntoks = tokenize(s, toks, nelem(toks)); + if(ntoks == 0) + goto next; + if(ntoks < 8){ + error("wrong event at %s\n", toks[0]); + goto next; + } + g = mallocz(sizeof *g, 1); + if(g == nil) + sysfatal("no memory"); + g->time = (vlong)strtoull(toks[0], nil, 10); + g->pid = strtoul(toks[1], nil, 0); + g->machno = strtoul(toks[2], nil, 0); + g->name = strdup(toks[3]); + + et = strtoul(toks[ntoks-2], 0, 0); + if(et < 0 || et >= Nevent || etname[et] == nil){ + error("unknown state id %d\n", et); + goto next; + } + g->etype = et; + g->state = et; + g->arg = strtoull(toks[ntoks-1], nil, 0); + free(s); + return g; + next: + free(s); + } + return nil; +} + +static void +addgraph(St *g) +{ + if((ngraph%Incr) == 0){ + graph = realloc(graph, (ngraph+Incr)*sizeof graph[0]); + if(graph == nil) + sysfatal("malloc: %r"); + } + graph[ngraph++] = g; +} + +static int +graphcmp(void *e1, void *e2) +{ + St **s1, **s2; + vlong d; + + s1 = e1; + s2 = e2; + d = (*s1)->time - (*s2)->time; + if(d < 0) + return -1; + if(d > 0) + return 1; + return 0; +} + +void +readall(char *f, int isdev) +{ + Biobuf *bin; + St *g; + St *(*rd)(Biobuf*); + vlong t0; + int i; + + fname = f; + bin = Bopen(f, OREAD); + if(bin == nil) + sysfatal("%s: Bopen: %r", f); + + if(isdev) + rd = readdev; + else + rd = readfile; + + while((g = rd(bin)) != nil) + addgraph(g); + Bterm(bin); + + if(ngraph == 0) + return; + + if(isdev) + qsort(graph, ngraph, sizeof graph[0], graphcmp); + + t0 = graph[0]->time; + for(i = 0; i < ngraph; i++) + graph[i]->time -= t0; +} + +static Proc* +getproc(St *g) +{ + int i; + + for(i = 0; i < nproc; i++) + if(proc[i].pid == g->pid) + break; + if(i == nproc){ + if((nproc%Incr) == 0){ + proc = realloc(proc, (nproc+Incr)*sizeof proc[0]); + if(proc == nil) + sysfatal("malloc: %r"); + } + memset(&proc[nproc], 0, sizeof proc[nproc]); + nproc++; + } + proc[i].pid = g->pid; + return &proc[i]; +} + +St* +pgraph(Proc *p, int i) +{ + int id; + + if(i < 0 || i >= p->nstate) + return nil; + id = p->state[i]; + if(id >= ngraph) + return nil; + return graph[id]; +} + +static void +appstate(Proc *p, int i) +{ + if((p->nstate%Incr) == 0){ + p->state = realloc(p->state, (p->nstate+Incr)*sizeof p->state[0]); + if(p->state == nil) + sysfatal("malloc: %r"); + } + p->state[p->nstate++] = i; +} + +void +makeprocs(void) +{ + Proc *p, *lastp; + St *g, *sg; + int i, j; + + lastp = nil; + for(i = 0; i < ngraph; i++){ + g = graph[i]; + if(lastp != nil && lastp->pid == g->pid) + p = lastp; + else + p = getproc(g); + + if(p->pnextp != nil) + *p->pnextp = i; + p->pnextp = &g->pnext; + + switch(g->etype){ + case SReady: + case SRun: + case SSleep: + case SDead: + appstate(p, i); + break; + default: + if(p->nstate == 0){ + appstate(p, i); + g->state= SRun; + }else{ + sg = graph[p->state[p->nstate-1]]; + g->state = sg->state; + } + } + lastp = p; + } + + if(0) + for(i = 0; i < nproc; i++){ + p = &proc[i]; + Bprint(bout, "proc pid %d:\n", p->pid); + for(j = 0; j < p->nstate; j++) + Bprint(bout, "%G\n", graph[p->state[j]]); + Bprint(bout, "\n\n"); + } +} + diff -Nru /sys/src/cmd/ptrace/tron.c /sys/src/cmd/ptrace/tron.c --- /sys/src/cmd/ptrace/tron.c Thu Jan 1 00:00:00 1970 +++ /sys/src/cmd/ptrace/tron.c Mon Mar 14 00:00:00 2016 @@ -0,0 +1,161 @@ +#include +#include + +static void +usage(void) +{ + fprint(2, "usage: %s [-s nkevs] [-f dev] [-o file] [-p pid] cmd [args...]\n", argv0); + exits("usage"); +} + +char buf[1*1024*1024]; +int done; +int pids[128]; +int npids; + +void +main(int argc, char *argv[]) +{ + int fd, cfd, pid, ofd, i; + char file[128], *f; + char *dev, *devctl, *out; + long tot, nr; + int sz; + + sz = 8; + dev = "/dev/ptrace"; + out = nil; + ARGBEGIN{ + case 'f': + dev = EARGF(usage()); + break; + case 'o': + out = EARGF(usage()); + break; + case 's': + sz = strtoul(EARGF(usage()), 0, 0); + break; + case 'p': + if(npids > nelem(pids)) + sysfatal("too many pids"); + pids[npids++] = strtoul(EARGF(usage()), 0, 0); + break; + default: + usage(); + }ARGEND + if(argc == 0) + usage(); + + sz *= 1024; + if(sz < 1024) + sz = 1024; + if(sz > 64*1024) /* perhaps we shouldn't limit it */ + sz = 64*1024; + + devctl = smprint("%sctl", dev); + if(devctl == nil) + sysfatal("no memory"); + + if(access(argv[0], AEXIST) < 0){ + seprint(file, file+sizeof file, "/bin/%s", argv[0]); + f = file; + }else + f = argv[0]; + if(access(f, AEXIST) < 0) + sysfatal("%s: %r", argv[0]); + + + /* prepage; don't want interference while tracing */ + for(i = 0; i < sizeof buf; i += 4096) + buf[i] = 0; + + rfork(RFREND); + pid = 0; + + /* play a dance with the traced command so it starts when we want, + * or issue the trace command for the traced pids. + */ + cfd = open(devctl, OWRITE); + if(cfd < 0) + sysfatal("can't trace: %r"); + if(npids == 0){ + pid = rfork(RFPROC|RFFDG); + switch(pid){ + case -1: + sysfatal("fork: %r"); + case 0: + /* wait until traced */ + if(rendezvous(usage, 0) == 0) + exits("no trace"); + rfork(RFREND); + exec(f, argv); + sysfatal("exec: %r"); + } + if(fprint(cfd, "size %d\n", sz) < 0 || fprint(cfd, "trace %d 1\n", pid) < 0){ + rendezvous(usage, 0); + sysfatal("can't trace"); + } + + if(out == nil){ + rendezvous(usage, usage); + waitpid(); + exits(nil); + } + }else{ + for(i = 0; i < npids; i++) + if(fprint(cfd, "trace %d 1\n", pids[i]) < 0) + fprint(2, "%s: trace %d: %r\n", argv0, pids[i]); + } + close(cfd); + + /* ready: open the trace and collect what we can. */ + fd = open(dev, OREAD); + ofd = create(out, OWRITE, 0664); + if(fd < 0 || ofd < 0){ + if(npids == 0) + rendezvous(usage, 0); + sysfatal("can't trace: %r"); + } + + done = 0; + switch(rfork(RFPROC|RFMEM)){ + case -1: + sysfatal("fork"); + default: + if(npids == 0){ + /* let the traced go! */ + rendezvous(usage, usage); + } + + while(waitpid() != pid) + ; + done = 1; + exits(nil); + case 0: + /* The damn device won't block us. We must insist upon eof. + * Besides, when done, we must give time for the events to + * arrive. + */ + for(;;){ + for(tot = 0; tot < sizeof buf - 128; tot += nr){ + nr = read(fd, buf+tot, sizeof buf - tot); + if(nr < 0) + sysfatal("read: %r"); + if(nr == 0){ + sleep(100); + if(done) + break; + } + } + if(tot > 0 && write(ofd, buf, tot) != tot) + sysfatal("write: %r"); + /* try to read more if we were done; but just once. */ + if(done && tot == 0 && done++ == 2) + break; + } + close(fd); + close(ofd); + rendezvous(main, nil); + exits(nil); + } +} --- /sys/include/ptrace.h Mon Mar 14 17:26:17 2016 +++ /sys/include/ptrace.h Mon Mar 14 00:00:00 2016 @@ -0,0 +1,59 @@ +typedef enum PTevent { + SAdmit = 0, /* Edf admit */ + SRelease, /* Edf release, waiting to be scheduled */ + SEdf, /* running under EDF */ + SRun, /* running best effort */ + + SReady, /* runnable but not running */ + SSleep, /* blocked; arg is PSstate| pc<<8 */ + SYield, /* blocked waiting for release */ + SSlice, /* slice exhausted */ + + SDeadline, /* proc's deadline */ + SExpel, /* Edf expel */ + SDead, /* proc dies */ + SInts, /* Interrupt start */ + + SInte, /* Interrupt end */ + STrap, /* fault */ + SUser, /* user event */ + SName, /* used to report names for pids */ + Nevent, +} Tevent; + +enum { + PTsize = 4 + 4 + 4 + 8 + 8, + + /* STrap arg flags */ + STrapRPF = 0x1000000000000000ULL, /* page fault (read) STrap arg */ + STrapWPF = 0x1000000000000000ULL, /* page fault (write) STrap arg */ + STrapSC = 0x2000000000000000ULL, /* sys call STrap arg */ + STrapMask = 0x0FFFFFFFFFFFFFFFULL, /* bits available in arg */ + + /* Sleep states; keep in sync with the kernel schedstate + * BUG: generate automatically. + */ + PSDead = 0, /* not used */ + PSMoribund, /* not used */ + PSReady, /* not used */ + PSScheding, /* not used */ + PSRunning, /* not used */ + PSQueueing, + PSQueueingR, + PSQueueingW, + PSWakeme, + PSBroken, /* not used */ + PSStopped, /* not used */ + PSRendezvous, + PSWaitrelease, + +}; + +typedef struct PTraceevent PTraceevent; +struct PTraceevent { + u32int pid; /* for the process */ + u32int etype; /* Event type */ + u32int machno; /* where the event happen */ + vlong time; /* time stamp */ + u64int arg; /* for this event type */ +}; --- /sys/man/1/ptrace Mon Mar 14 17:26:17 2016 +++ /sys/man/1/ptrace Mon Mar 14 00:00:00 2016 @@ -0,0 +1,225 @@ +.TH PTRACE 1 +.SH NAME +ptrace, tron, pm \- trace processes +.SH SYNOPSIS +.B ptrace +[ +.B -dgpw +] +.I file +.PP +.B tron +[ +.B -f +.I file +] +[ +.B -o +.I ofile +] +.I cmd +[ +.I arg... +] +.PP +.B pm +[ +.B -p +.I nproc +] +[ +.B -r +.I nround +] +[ +.B -c +.I ncpu +] +[ +.B -i +.I nio +] +[ +.B -s +.I nstk +] +[ +.B -w +.I sleep +] +.SH DESCRIPTION +.I Ptrace +plots and dumps generic process traces previously retrieved from +.IR ptrace (3). +Unlike with +.IR trace (1) +and +.IR trace (3), +the tracing and traced machines can be of different architectures, +and tracing is designed for processes in general, and not just real-time ones. +.PP +Events are retrieved from +.IR file , +which is a text file with trace events. Flag +.B -d +indicates that +.I file +uses the raw format provided by the +.IR ptrace (3) +device. +But note that +.I ptrace +stops reading upon EOF, which makes it unsuitable for reading +.IR ptrace (3) +directly. +.PP +By default, the program prints events to standard output in a readable format. +The output can be used later as input. +.PP +Under flag +.B -g +the program draws a plot that can be inspected using the mouse and +the keyboard. +A new window +is used to plot the diagram if +.B -w +is given, otherwise, the program uses the window it runs on. +It is advisable to use +.B -w +if commands causing prints are also used. +Flag +.B -p +makes the program print events even when +.B -g +is given. +.PP +Typing +.LR q +makes the program quit. +.PP +In the plot, the left column shows pids and the machine they are running +on. Red lines indicate waiting processes, green lines ready processes, and +blue lines running processes. Traps and faults are shown below the process line +and system calls are shown above. +.PP +The plot scale reflects actual time. You might have too zoom in to +see some interesting events otherwise merged due to the scale. +Placing the mouse near a process line updates the +status information shown, including time. +.PP +Arrow keys can be used +to zoom in (up), out (down), and to move left (left) and right (right). +A click on the left (or right) part of the top line with the mouse +moves left (or right). +A sweep with mouse button 1 zooms into the time window selected. +.PP +The +.LR Esc +key restarts the plot using the original position and scale. +.PP +A sweep with button 2 saves the events selected in the file +.BR ptrace.out . +A sweep with button 3 +prints on the standard output +the events in the rectangle selected (excluding +processes out of the rectangle). Horizontal sweeps select the process +where the sweep happens. +.PP +A click with the mouse +button 3 plumbs the clicked event to the editor. +The file name used is +.B ptrace.out +when the input uses a device format. +.PP +The +.LR space +key freezes the statistics reported when moving the mouse. +.PP +The +.LR p +key prints the events currently shown in the window. Those too small +to be individually plotted are also printed. +.PP +The +.LR s +key saves the events shown into the file named +.BR ptrace.out . +.PP +.I Tron +is a helper to collect traces for commands. It executes +.I cmd +with +.I args +activating the trace for it (and descendant processes). +Flag +.B -f +selects an alternate tracing device. +.PP +Flag +.B -o +causes +.I tron +to read events from the trace device and dump the output to +.I file +in the format used by the device. Such output file can later be used +with +.I ptrace +to inspect what happen, and also to convert it to a textual format. +The program ceases collecting events one second +after the traced command exits. +.PP +.I Pm +is a profile-me program generating a deterministic load with the given numbers +of processes, rounds, etc. +.SH EXAMPLE +Capture a trace for a compilation: +.EX +term% troff -o tr.out mk all +.EE +.LP +Print the events contained in the trace. +.EX +term% ptrace -d tr.out + 00048526953 121 06 mk Ready Ready 4 0x0 + 00048537030 121 04 mk Run Run 3 0x0 + ... +.EE +.LP +This output can be saved and later used as input for +.IR +.PP +Convert the dump to a textual format and run +.I ptrace +on it +using a different window, so we can +still use standard output for printing: +.EX +term% ptrace -d tr.out >tr.txt +term% ptrace -wg tr.txt +.EE +.SH FILES +.TF /sys/include/ptrace.h +.TP +.B /dev/ptrace +trace event file +.TP +.B /sys/include/ptrace.h +trace event data structures. +.TP +.B ptrace.out +output for save command. +.PD +.SH SOURCE +.B /sys/src/cmd/ptrace +.SH SEE ALSO +.IR proc (3), +.IR trace (1). +.SH BUGS +To avoid extra interference from the tracing tools, the device +does not block the reader, and thus the tools must poll the device. +.PP +To honor the plot scale, some events do not show up unless you +zoom enough; although the picture is still accurate. +.PP +Should probably replace +.IR trace (1). --- /sys/man/2/ptrace Mon Mar 14 17:26:18 2016 +++ /sys/man/2/ptrace Mon Mar 14 00:00:00 2016 @@ -0,0 +1,96 @@ +.TH PTRACE 2 +.SH NAME +ptrace \- interface for the process trace device +.SH SYNOPSIS +.EX +#include +#include +#include +.sp +typedef enum { + CHANEND, + CHANSND, + CHANRCV, + CHANNOP, + CHANNOBLK, +} ChanOp; +.sp +typedef enum PTevent { + SAdmit = 0, /* Edf admit */ + SRelease, /* Edf release, waiting to be scheduled */ + SEdf, /* running under EDF */ + SRun, /* running best effort */ + SReady, /* runnable but not running */ + SSleep, /* blocked */ + SYield, /* blocked waiting for release */ + SSlice, /* slice exhausted */ + SDeadline, /* proc's deadline */ + SExpel, /* Edf expel */ + SDead, /* proc dies */ + SInts, /* Interrupt start */ + SInte, /* Interrupt end */ + STrap, /* fault */ + SUser, /* user event */ + SName, /* used to report names for pids */ + Nevent, +} Tevent; +.sp +enum { + PTsize = 4 + 4 + 4 + 8 + 8, + + /* STrap arg flags */ + STrapRPF = 0x1000000000000000ULL, /* page fault (read) STrap arg */ + STrapWPF = 0x1000000000000000ULL, /* page fault (write) STrap arg */ + STrapSC = 0x2000000000000000ULL, /* sys call STrap arg */ + STrapMask = 0x0FFFFFFFFFFFFFFFULL, /* bits available in arg */ +}; +.sp +typedef struct PTraceevent PTraceevent; +struct PTraceevent { + u32int pid; /* for the process */ + u32int etype; /* Event type */ + u32int machno; /* where the event happen */ + vlong time; /* time stamp */ + u64int arg; /* for this event type */ +}; +.EE +.SH DESCRIPTION +This include file documents the format of the +.IR ptrace (3) +device. The device reports trace events for processes with the +fields documented in the +.B PTraceevent +structure. Events are read using little endian format for all +values. The type of event is one of those in +.BR PTevent . +.PP +Traps report also system calls made. They have set in the +.B arg +field the +.B STrapRPF +or +.B STrapWPF +bit if they correspond to a read or write page fault, and the +.B STrapSC +bit if they correspond to a system call (OR'ed with the +system call number). For page faults, the +.B STrapMask +bits are set to the faulting address using the +endianness of the faulting system. +Otherwise the argument is the trap number. +.PP +The +.B SName +event uses the space of the argument to store up to 8 characters +with the process name for the pid reported in the event. +.PP +The +.B SSleep +state reports as its argument both the scheduling state for the +sleep (in the low byte) and the program counter for the kernel +(upper bytes, shifted). +.SH SOURCE +.B /sys/src/9/port/devptrace.c +.SH SEE ALSO +.IR ptrace (3), +.IR ptrace (1). --- /sys/man/3/ptrace Mon Mar 14 17:26:18 2016 +++ /sys/man/3/ptrace Mon Mar 14 00:00:00 2016 @@ -0,0 +1,48 @@ +.TH UART 3 +.SH NAME +ptrace \- process scheduling traces +.SH SYNOPSIS +.nf +.B bind -a #σ /dev + +.B /dev/ptrace +.B /dev/ptracectl +.fi +.SH DESCRIPTION +.PP +The process trace device is a replacement for the trace facility in +.IR proc (3) +to report more information about process events. +.PP +The +.B ptracectl +admits the following requests: +.TP +.BI size " n +Set the size of the buffer to +.I n +entries. Before issuing this request tracing is not enabled. +.TP +.BI trace " pid value" +Set the trace on or off for the process with the given pid. +.PP +The +.B ptrace +file reports an integral number of events when read. To avoid +too much interference with scheduling, it does not block readers. +When no more events are available the read returns an EOF indication, +but the program is expected to poll the device for further events. +This behavior mimics what +.IR proc (3) +does with the trace interface. +.SH SOURCE +.B /sys/src/9/port/devptrace.c +.br +.B /sys/src/9k/port/devptrace.c +.SH "SEE ALSO +.IR ptrace (1), +.IR ptrace (2). +.SH BUGS +If the buffer size is too small, events will be discarded. +.PP +The reader must poll the trace device.