harvey/sys/man/searchindex

 0,shift 0cd 0x5065726c 0x726c 0xaf 1,&wnohang 1pub 4th a_hash aaaa ab abcd abcdefg abelaxedcainpunishedcatchaseddoggonetoxyz abelcaincatdogx able abort abs absence absolute accept accepts access accident accidentally accommodate account accumulate accumulator acos active actual actually add added addition additional additionally addr addr,addrtype address addresses addrs addrtype administrative admission advanced advantage advice advisory ae aeq af af_inet af_unix affected affects afs afterwards afunc age aggregate aggregates aging alarm aliases aliasing alive allocated allows alphabetical alphanumeric alrm altered altering alternative alternatives amongst amount an_array analyzed anonymous ans answer anticipation antisocial anydbm_file anymore anyway anywhere apparently appended appender appending applicable application applications approach approaches appropriately arbitrarily arbitrary archaic arctangent aren't arg arg1 arg2 args argv arithmetic arrange arranged arrangements arranges array array,list array,offset array,offset,length array,offset,length,list arrays article articles ary ascending ascii asin asks assertion assign assigned assigning assignment associates assume assumed assumes assuming assumption asterisk at_least_ atan2 atime attached attaches attaching attempt attempts authentication author autoflush autoload automatic automatically autovivification auxiliary availability avoid avoided aware awk axww axyz backslash backslashed backtick backticks backward backwards bad bak bar bar.pm bareword base based bbar bblurfl becomes behave behaves behavior behooves bell benefit ber berkeley beware bfoo bidirectional bin binary bind binding binds binmode bintodec bit bite bitmaps bits bits,fileno bizarre bless blessed blessing blessings blksize block blocking blocks blurfl boolean bother bound boundaries bourne break breaking breaks broken browser bsd bsd_style buckets buffer buffered buffering buffers build built builtin bus busy by_address by_name byage bypassed bypasses byte bytes c's caesar calculation callback caller caller's calling can't canasta cancel cantankerous capabilities capable caps capture care careful cases cat categories category causing caveats cbreak cccc ccccs ccxxcc cd cgi chance channel char character characters chars chdir check checked checking checksum checksumming child child1 child2 chld chmod choice chomp chomped chomps choose chop chopped chops chown chr chroot class classes classname clean clear clearerr client clobber clobbers clones closed closedir closes closing closure cmd cmp cnt code codes collation collected colon combination combined comes comma commas comment comments common commonly communication compaction compare compared comparison compatibility compilation compile compiled compiler compiling complain complaints complete complex complex_calculation compliance complicated composed compressed computed computes concatenates concerned concise condition conditional conditions config configuration configure confused confusing confusion connect connected connection cons consider considered considers consist consistency consistently consisting constant constants construct constructed constructing construction constructor constructs consult contained contains context contexts continuation continue continued contributed control convenience conventions conversion conversions convert converted converting converts cookies coordination copies copying core correct correspond corresponds cos cosine cost couldn't count counted counter counterintuitive counterparts counting counts cpan cr create created creates creation critical croaks crypt cryptographic cryptography csh csystem ctime curpos current cuser customary cw cwd d_pwage d_pwchange d_pwcomment d_pwexpire d_pwquota damage damaged dash dashes data database date db db::args db_file dbase dbase.mine dbm dbm_open dbmclose dbmopen dbname dc deadlock deal dealing deallocated debugger debugging deceased decides decimal decisions declaration declare declared declares decrypt deed default defaults defaults.rc defined definitely definition definitions del delay delays delete deleted deletes deleting delimit delimiter delimiters delivered demands dependent depends deprecated derive derived descending described describing descriptions descriptor descriptors designated desired despite destination destroy destroys destructors detaching detail detailed details detect determination determine determined determining dev device diagnostics didn't die die__ died differ differing digit digits dimensional dir directives directly directories directory dirhandle dirhandle,expr dirhandle,pos dirhandles disabled disables discard discarded discover discretionary discussed disk display distinction distinguish distinguishes distribution divide do_something do_something_else document documentabove documentation documented documentfor documentfunction documentif documentthe doesn't dog','cat','x','cain','abel doing domain don't dos dots double doubles dowarn ds due dummy dump dumped_core dup duped duping duplicate duplicated dups dynamic dynamically e.g easily easy echo ed effective effects efficiency efficient efficiently eggs eight ein eintr elapsed eldest elsewhere email embedded emulate emulates emulating emulation enabled enchanted enclosing encode encodes encrypts endgrent endhostent endian ending endless endnetent endprotoent endpwent ends endservent enforce english ensuring entertaining entire entirely entries entry env environment eof eol eout epoch eq equal equally equivalences equivalent equivalently erase errmsg errno error errors escape escapes especially essentially established etc eval evaltext evaluated evaluates evaluating evaluation eventually everything everywhere exact exactly exactly_ examined excempt except exception exceptional exceptions exclusive exec executable executables execute executed executes executing execution execvp exempt exercise exist existence existing exists exit exit_value exited exits exp expand expanding expands expansions expect expected expects expiration expire explanation explicit explicitly export exporter expr expr,length expr,limit expr,list expr,offset expr,offset,bits expr,offset,len expr,offset,len,replacement expressed expression expressions extended extending extends extension extensions extirpated extra extract extracts extremely f_getfl facility fail failed fails failure fall falls false familiar fast faster fatal fcntl fd fdopen feature features feed feeding fetch fetching fewer fgrep fh fh00 fhbits fhlist fields fifo file file's file::stat filedescriptor filehandle filehandle's filehandle,expr filehandle,filename,mode filehandle,filename,mode,perms filehandle,function,scalar filehandle,length filehandle,operation filehandle,position,whence filehandle,scalar,length filehandle,scalar,length,offset filehandles filename filename,mode filenames fileno files filesystem filetest filetypes fill filled final finally finding finds finer finish firstkey fit fix fixed flag flags flexible float floating floats flock flow flush flushes fnctl folks follow foo foo.out foo::bar foopack foopack::a foopack::b fopen for_a_while forces foreach forever fork forked forking format formats formatted formatting formed forming formline formlines forms fortran forward fractional frame frames fread freedom frequencies frequency frequently fri front fseek full fully func funny further furthermore future gain games gcos gdbm generalized generally generate generated george getall getc getgr getgrent getgrgid getgrnam gethost gethostbyaddr gethostbyname gethostent getkey getlogin getnet getnetbyaddr getnetbyname getnetent getopt getopt.pl getp getpeername getpgrp getppid getpriority getproto getprotobyname getprotobynumber getprotoent getpw getpwent getpwnam getpwuid gets getserv getservbyname getservbyport getservent getsockname getsockopt gid gids glance glarch glob global globals gmt gmtime gobble goes gone','chased','yz','punished','axed goners goto granularity greater greenwich grep groups grow grown grows guarantee guaranteed guarantees guys gz gzip h2ph h:i:t:h:e:r:e h_errno handle handled handler handler's handlers handles handling handy hap
 00000000.0bbbbbbb 00000bbb.bbbbbbbb 0bbbbbbb 10bbbbbb 110bbbbb 1110bbbb ascii backward based bbbbbbbb.bbbbbbbb binary bit bits byte bytes character characters compatible conversion conversions convert converted deal described descriptions designed encode encoding except external ff files format graphic hexadecimal higher incorrect independent input interface internally inverse iso keyboard letting lib machine manifestation manual mapping multibyte non perform plan presented processing programs properly proposed provides quantity represent representation representing represents rune runes semantic sequences shortened shortest spans standard store stream streams suitable support table tcs textual throughout transformation unicode uninterpreted universal utf value valued values ways wide written utf	6/utf
 0000929b1b54 0152415320704e7266238ebf01030 217e5f27 add address addresses arp assume assumes attr binary bootp bugs bytes canonical checksum checksums ck clientid cmd comparisons complete completed compute consists contained contains context correct corrected data decimal default depends destination device df dhcp digits display doesn't dump dumps entered ether ether's ether0 ethernet expr expression expressions exression ffffffffffff fields file files fill filter filtering filters fl format frag grammar header headers hex hl hp ht id indented input interrupt ip ip6 keyboard length lines list listing ln match matches matching media milliseconds ms msb multiline multiplex nanosecond necessary net network obtained ones optimize option options output packet packets port ports pr protocol protocols quux ramfs rarp read readable reads redundant reinput remove req request save sd sec shows snoopy soon source specific specifying spy src standard started stdc stream string subprotocols subprotos sys tab tcp tf there's time tmp trace traced type udp using value values writes xid xxxx snoopy	8/snoopy
 0:0:0:0:0:0:ffff 0xffff addr address addresses addressses adv advertisement assigned backwards bit bits broadcast buffer byte bytes char chars checksum cksum class colons compatibility complement concession configured contains convert converts data decimal default defined defmask described describing dev device digits dir eaddr eipfmt elided embedded endian equal equivalent equivip errin errors errout ethernet exactly ffff:0:0:0:0:0:0:1111 ffff::1111 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ff00 file fit fmt format formatter freed hdr hex hexadecimal hnputl hnputs ifc include includes index indicates int integer integers interface interfaces internet interval invoked ip ip.h ipaddr ipaddr1 ipaddr2 ipaddrlen ipallbits ipifc iplifc ipnoaddr ipv4 ipv4allrouter ipv4allsys ipv4bcast ipv6 ipv6rp isv4 leading len libc.h libip lifc lifetime linked linkmtu list manipulate mask maskip masks max maxraint mflag min minraint mount mtu multicast multipoint myetheraddr myipaddr negative net network nhgetl nhgets non notation null oflag one's packets params parseether parseip parseipmask parses particular pctlbsum periods physical pktin pktout places plan pointed points preferred prefix preflt print programs protocol protocols ptclbsum puts quantities rcv reachtime read readipifc reads recvra6 remote representation return returned returns rooted route router routerlt routers routines rp rxmitra send sendra6 slash source space src stack standard starts stats store stored str string strings struct structure structures superset sys systems third time transfer ttl typedef typically u.h uchar uint ulong unit unsigned ushort using v4ip v4parsecidr v4parseip v4prefix v4tov6 v6ip v6tov4 valid validlt value verb void wise write written ip	2/ip
 0:alen 0:blen abs addition adds alen allocate allocated allocation allow architecture arithmetic array arrays ascii assembler assume base bases basic basis betomp bit bits blen btomp buf buffer bufp byte bytes char character check chinese common compares computations computes computing constants conversions convert converted converting converts copy cover cputype cre creates crepre crt crtin crtout crtpre crtprefree crtres crtresfree defaults defined denominator dependent deposited destination diff digit digits dividend divisor doesn't dynamically encountering endian equal except explicitly exponentiation extended factors fails faster fill filled fit flags fmt fmtinstall former freed frees fromo gen generator greater greatest grow grows hexadecimal i.e ignores include includes increases indicated input int integer inverse itomp largest latter leading length letomp libc.h libmp list location magnitudes mathematical mod modulo modulus mp mp.h mpadd mpassign mpbits mpcmp mpcopy mpdigdiv mpdigit mpdiv mpexp mpextendedgcd mpfmt mpfmt,mptoa mpfree mpint mpinverse mpinvert mpleft mplowbits0 mpmagadd mpmagcmp mpmagsub mpmod mpmul mpnew mpnorm mpone mprand mpright mpsetminbits mpsignif mpsub mptoa mptobe mptoi mptole mptoui mptouv mptov mptwo mpvecadd mpveccmp mpvecdigmuladd mpvecdigmulsub mpvecmul mpvecsub mpzero multiplication multiplicative multiplies necessary needed negative newly nfactors nil non normalized normalizes offset operations parameter parameters parse perform pointed pointer points portable positive preallocated precision precomputes prime print prod product pterminates quotient random refers remainder remaining representation representations res residue residues rest restrict results return returned returns rewritten routines rptr saves scalar scan shift sign significant size skips smaller source spaces specifies src stops stored string strtomp struct structure structures subtracts sum supported sys tabs takes theorem times trimming type typedef types u.h uchar uchar's uint uitomp unless unsigned using uvlong uvtomp valid value values version vlong void vtomp whatever writing yourself mp	2/mp
 0:none:adm 10000:sys 10001:map:map 10002:doc 10003:upas:upas 10004:font 10005:bootes:bootes 1:adm:adm 1:tor:tor abandoned abandons aborts absolute accepting accounting acct activity acts actual actually add address addresses adds adesw adjusted adm advanced affected allocate allocated altered anywhere appearing append apply arcane arp assumes attach attached attachxx background backwards bad becomes behavior bits block blocks boot boots bucket buffer builds buy byte cache cached caused cfs chain channel character characters chat check checking checks clear clearacct cleared clears clri clunks cmd compiled conclusion config configuration connected connection connections consequence consistency console contained control controllers controls convention copied copy cpu create creates current cwcmd data date default delete dest determined device diagnostic directories directory dirty disables disasters discover discredited disk display don't dskno du duallow dump dump1 dumped dumping duplicate enable enables endian endianness enter enters entries entry error errors ethernet except execute existing explicitly exsort exsort.c fids file files filesystem filled final fix flag flags flush flushes format formatted forward freelist fs fsconfig fstat functional garbage gate gateway gid gmt groups guesses halt halts hangup hit holes idea identified identifying ignores ignoring incomplete incorrect incorrectly indirect initialize initially input integers internal internally ip jan ken key knee kprof kprofdata lad leader leaderxx leaves limits list loadcache locked locks longwords looking looks lot low machine machine's magnetic main maintains maintenance mask megabytes member memory menus message messages minimal minus missing mode modified modify moves mvstate names native necessary newname newuser noattach noisy non none note numbered numeric octal operating option optional options output overall overwrites owned packets parameters particular passwd password path pdir percent perm permission permissions pfile plan platter pointer prchain previously print printconf printed prints proc process processes prof profile profiling qid queue quiescent ram range rdall read readable reads reallocated ream rebooted rebuild received recently reclaim records recover referenced reflect regular remembered remove removes removing rename report reported reports representation request required requires restart resumes retried returning rip ripoff ripon ro rom roots route routing rules run running sanity savecache scanned scsi search seconds selects server server's shelf short sign size slot slots sorted sorts source space src stack startdump starts stat stata state1 state2 static statistics stats status stop stops storage string structure subcommand subcommands subnet successful summary superblock superblocks suspend suspended suspends sync sys systems table tag tags takes targets therein thompson time times toggles touch touchsb trace traceback tree trims try tunit type typed typing uid unaffected units updated usage user users using usr usual utilization valid verifies verify version volatile wiser working worm wormeject wormingest write writes wuid fs	8/fs
 0ctl 1ctl bind control corresponds ctl current decimal descriptor devdup.c device directory discover dup dups fd file files format identical length level longer mode names note operation points port proc process properties read reading results returned returns serves source src stat sys target writing dup	3/dup
 0digits 1pub 4dos absolute accompanying activeware actual actually add added additional administrators ae allocation allows alternate alternative alternative_shebang ane another's apart append appended applicable application applied arg argv argv:q argvout array ascii asks assignment assigns associate assume attempted attempting automatic automatically autosplit availability avoid avoids awk backslash backtick backup bak bar bash_env bat batch behalf behavior bell besides beta bin binary bizarre blocks boundary bourne bug build built builtin can't capture care careful cdpath cgi character characters chdir check checks child chomps chop cleaning clicking cmd cmd.exe cmd.exe's code codify colon columns combinations combined comes command.com commandline comments common compare compatible compilation compile compiled compiler compiles compiling complete completion comspec concerns configuration configure configvar considered consistent construct contained contains context continue contributed control controls convenient conversions copy core correct cpp create creator csh ctrl current cw d:dprof dash data date ddebugging debugger debugging deep default define defined degree delete delimited delimiter depends described desired destination destruction determined devel::dprof devel::foo devious die digits dimudmw dir directives directories directory disable discarded disk dispatch displays disposal distinction distribution dleaktest documentation doesn't doing don't dos dosish.h double dp dr ds dtls due dummy dump dumped dumping dx e.g easily edited effects efficient embedded emulate enables encouraged end__ ending enter entire entirely entry env environment eof equivalent error errors etc eval examined except exec executable execute executed executes executing execution exists exit expected expense explicitly expression expressions extension extensions extproc extra fails fall faster fatal feeds file filehandle filehandles filename filenames files finally finding fit flag flags follow foo foo,bar forces format full functionality functioning garbage generate generated getting global gnufind goes greater handles handling hash header hello helps hitting holds honest hooks hv hy i.bak i.e idea ideas ifs ignores impede implicit implicitly importing inc inclined include included indicate innumerable input inside install installation installed instance integer interactive interfere internal internally interpretation interpreter interpreters invoke invoked ip it's item iterate jun kernel languages larger leading leaks learn legal letter letters levels lib library liners lines list lists ln0e load locate locates locating location log logdir logo looking looks lookup loop lot lpe m'module machine machines macintosh macintosh's macperl malloc manpage meaningful memory mentioned mess message method methods minimize mm mmodule mode modify module modules moves mpw ms mtime multi myscript n0e na names natural ne necessary needs neither newline nice nle nobody non none notation note nt null numbering numeric objects obvious occuring occurring octal octnum odd oe oldargv older omitted ones opened opening operating operations operator optimizer option options ordinarily original os output outside overloading overrides paragraph parentheses parsed parses parsing partial particular pass patch patchlevel path pathname pattern perl perl5db perl5db.pl perl5lib perl5opt perl5shell perl_debug_mstats perl_destruct_level perldebug perldiag perldoc perlfunc perllib perllocale perlrun perlsec perltrap perlvar pi pi.bak pl places plan9 platform platforms pna politely pop port portability portable portion precede prepended preprocessor print print0 printed printing prints proceeds process processed processes processing produced profiler programfile programs progresses proper protect protected provided purpose quote quotes quoting qw rcsfile read reasons recognize recognized record recurse redefined redundantly references regardless registry regular relative relevant reliable removed removes rename renaming replace replaced require reset resolution restored results revision rudimentary rules run running running_under_some_shell runs saying scalar scans scratchpad script scripts search searched searches searching section security sed seem select selected selecting semicolons separator separators sequences setgid setting setuid sh shell shells shift shortcut shows silently simulated slightly slipped slurp snapshots solution somewhat source sp space spaces specific specifically specifies specify speeds spi.bak split ss stack stand standard starts startup statements statistics stdin stdout strictly string stripping strongly stuu subprocesses subroutines subsection substr successful suffixes sugar summary superseded superuser support supporting suppress surrounded switch switches symbols symlinks syntactic syntactically syntax systems taint tainting technique tells test th theory they're title token tokenizing totally tr trace tracing translation tree trim try turns twice type typical typically unbreakable undefined understand undump unix unix's unless unlike unlink unlinking unsafe user user's users using usr usurps utilities v:d_mymalloc value values variability variable variables variants version via vms warn warn__ warnings warns watch whatever wherever whitespace win32 win95 windows windows95 windowsnt works worse write ws xx xyz you'll you're you've your_switches yourself perlrun	1pub/perlrun
 0ics accessed accumulated addresses addressing allow allows applies arm arwe assist assumptions binaries binary breakpoints bugs cache caches cancels cmd code compared compatible compilers complete continuation controls conversions copy count counts cpu's cycle data db debugger delay detailed disassembly discussion distribution enable endian environment equality equals etc except execute execution existing extended extra faster fills floating formats frequency gatherer generated hundred id instruction instructions interface interpret interpreting itsp ki level load location loss machine machine's main memory mips mirrors mmipsco mmu mnemonics monitor nm offers optimization options performed pid plan precision print printing prints process produced profile programs read reference refers report rfork run running session similar simulate simulated simulates simulation simulators size slower source sparc src statistics stepping sun support supported sys textfile times tlb tracing traps triggered unimplemented unusual value vi working written vi	1/vi
 0intro 9fs abnormal access accessed accessible accessing acid acme acting address administering affairs aid alike allows alpha apc appeared architecture arm arriving aspects assembled axp backspace backup backups bapc belongs bin bind binding bindings binds bit boot booted booting bootstrapped bound bourne broke broken builds built causing character characters chess child cleans clue command's compiling complete completely compute computing con connected connections connects cons consctl control convention conventionally copies cp cpu cpu's cputype created creation current customary customized daily database databases db debugging deepthought default defaults del delete dependent descendent described desired details determined dev devices diagnostics dialog dies differences digit directories directory display distributed doc draw dump dumps e.g editor editors en encodes enters env environment error etc euro.9.font exec executed execution exit exits extra faces facility failure file files flag flags font fork formats fs full generic glue goes graphical graphics happen hardware heavy hierarchically historical holds il independently index init initially instructions integrated intent interface internet interpreter interrupt intro introduction january june kernel kernel's keyboard keyboards kill kremvax letter level lib library lines lingers list loads locally login machine machines macro mail manipulating manual mapping member middle mips mnt month mount moving names namespace navigate net network newly news non note noticeable notification object objects objtype operating operations ordered outside overridden papers password path pc pelm pentium perform permits permuted personal pid plan plumber powered prefixed proc proceeds process processes processing profile programming programs prompt protocol provides publicly quick raster rc read reading reasons recover referenced related reminiscent remote replace replaces reports represents requests research reset resident respond retrieved returns rfork rio root run running runs rx sam saying searched searches section sends server servers services setting shell sign sometimes space spaces sparc specifies specify srv standard starts status stop storage string structured subdirectories subtrees successful switch sys system's systems tab tabstop tail tcp telnet term terminal terminal's terminals termination third time tmp tour tree type typed typical typically typing union unioned unix upas user user's using usr value values variable variables variant various version via visible volume ways window windows works writing written wsys yesterday 0intro	1/0intro
 0sa1 account add altered arbitrary array base bases bc bracketed bugs calculator character clear cmd compare constructions current dc dc.c decimal depth desk determines diagnostics digit digits distinguish divide dividend division divisor dsa duplicate entries error exceeds execute executed executing execution existing exit exponent exponentiate exponentiation factor file fractional further greater headers hexadecimal hoc input integer integers interaction internal interpret interprets kept la1 larger length letter level levels lower lyx main maintained max min multiplication multiply negative nested nesting non notation obey octal onto operand operates operation operations ordinarily output overall pla10 places points polish pop popped precision print printed prints push pushed quotient reasonable recognized recursion register registers relation remainder remains removes replace rest results reverse root s,sa s,sa,sb sa sa,sb sb scale scales shell sign source specify square src stack stacking standard stated store string structure subtract sy sys ten terminal text time treat truncated unbroken unchanged underscore unimplemented value values dc	1/dc
 0th 0x00f 0x0f0 0xf00 0xffff 1pub 29th 4_294_967_296 a','b','c','d','e','f a','c abc accidentally actual actually addition additional advantage ae algorithm alias aliases allocate allocated alphanumeric alphanumerics ambiguity anonymous anywhere apply aren't argv arrange arranges array arrays assign assigned assigning assignment assigns associative assume assumed automatic automatically avoid awk backslash bad bar bar,&somesub bareword barewords based basis bell bit block blue boolean bottom bracketed brackets brand break bucked buckets built builtin can't care cases cat cc chain character characters check choose class closing code collide comes comma commas compilation compile compiled complicated conflict considered consisting consists constructors contains context contexts contextually contributed control conversion conversions converted correct count countermand counting create csh curlies curly current customary cw dash data data_ date decimal declare default defined delimit delimited delimiter denoted depends deprecated described destroys destructor destructors detail details determine determines dev digit digits directive directly directory discussion distinctive doc documentation doesn't don't double doubt ds due dummy e.g earlier echo ee eenie','meenie','minie efficiency element_count embed enclosing end_ english entire entirely entries entry eoc eof equivalent error etc evaluate evaluated evaluates evaluating except execute executed exist exists exited exotic expected explicit export expression expressions extend extending false fashion fear feb feel ferocious fh file file_ filehandle filehandles filename files final finds finish finished fish flatten float floating fluffy follow foo forced forget forgot formats forms further future gain gets gid glarch grammar green group_name guess handle handles handy happen hash hashes hashing header here's here::blue hex hexdigit hi hiding hint hold holds hy i.e id identifier identifiers identity ieee ilk import improves included includes index indexed indicate indirect infinity initialized initializing inner ino inside instance int integer interchangeable internal interpolate interpolated interpolating interpolation interpretation intervening invocation io io::handle ip isn't it's item items join joining jun key key1 key2 keys kinds label labels language lasts legal legibility length lengthening letter letters levels lexical likewise limited line_ linebreak lines list list_separator lists literal literals lo locate log log,'logfile logical logo longer looking lose lowercase mable main main::data manipulations manpage map match matches material mean measure meenie member mentioned merciless method miniscule modern module modules mostly myfunc na names namespace nan natural ne nearly necessarily needed negative newline newlines newopen nice noises nondigits nor notation notations note nothing's null numeric object objects obviously oct octal oe okay oops operand operation operations operator operators optional ordering ordinarily oriented outlaw output overloads package package_ packages packname packname::data pairs parameter parameters paranoid parentheses parenthesis parenthesized particular parts pass passing passwd patch path patterns performing perl perl's perldata perlfunc perlmod perlop perlre perlref perlsub perlvar pi plain plural pointers polymorphic poorly pop posix::strtod pre preallocate precedence preceding predefined prefer preferable preferred prefix presumably pretty previously price print prints prior proceed process produced produces programmers properly protects provide provides punctuation purposes query quote quoted quotelike quotes quoting quotish radio_group rcsfile read readability readable reading real rec reciprocal records recovers red red',0x00f,'blue',0x0f0,'green',0xf00 redundant refer reference references referred referring refers regular rejects replace reported represent representation representations represents requirements requires requiring reserved respect responds rest restriction resulting return returned returning returns reveals reverse revision righthand risks rounds routine rules runtime safer save saved saying scalar scalars script search section seem segment seldom selfloader semantics semicolon separating sh sheep shell shells shift shortened shortening significance significant similarly singular sixteen slash slice slices soak somesub sometimes soon sort sp space specify split ss stack stat statement stdin stdout stick str strange strict string strings strongly structure structures sub subject sublists subroutine subroutines subs subscript subscripted subscripts subsection substitute substitution supposed surrounding switch symbol synonym synonyms syntax tab table tables takes tells temp temporarily terminate test text th that's there's there::green they're throwing time times title token tokens touched tr translation transparent treat treatment truncate try type typed typeglob typeglobs types uid unambiguous unbreakable uncastable undef undefined undergo underline underscore underscores uninitialized unix unless unquoted uppercase user users using usual val1 val2 valid value values variable variables varieties various version via visually wantarray wanting warn weird whatever whitespace windows wish witch won't working works worry written wrong xx you're perldata	1pub/perldata
 0th accept access active additional age agefont ages allocimage array ascent attached baseline bigger bits bottom cache cachechars cached cachefont cachefonts cacheimage cacheinfo caches cachesubf caching calculated candidates cf char character characters chars clears collection common connects consists contains contiguous cooperate cooperation copy corresponds counter current data described describing destroying details device diagnostics display displayed draw draw.h draws edge emitted emitting entry error exist extent extents fields file fill fills font fontchar fontchars fonts freefont full graphics guarantees height hold horizontal ht image image;interline images include inclusive increased increasing indicate indices info initdraw int internally length libdraw library list load loadchar loaded loadfont loading loads lru maintain maintaining maintains max maximum memory min missing ncache needs nil noclr non nsub nsubf offset openfont overall owns p.x p.y parts permitting pixels plus pointed pointers posn proceed processed programs progress purposes range ranges read recently record rectangle replacement represent resets resize return returns routines rows rune runes scan schar selection server sfname short simultaneously size slot smaller solve source space src stored string stringwidth struct structures sub subf subfont subfontname subfonts success sufficient sum support sys tells time total translates typedef u.h uchar ulong unable unless updates updating ushort utf utilities value variable void widest widp width cachechars	2/cachechars
 0ul active attribute authorization authpass authuser bin bodylen buf buffer bugs byte char character chunked client clients closeit configuration connection connections continue contlen creating current custom data descriptor desirability details encoding entity enum etag expect expectcont expectfail expectother experimental extern fd file float fmt fresh_have fresh_thresh generic halloc hbodypush hbuflen hbufsize hcheckcontent hclose hconnect hcontent hcontents hdate2sec hdatefmt header headers hend herr hetag hf hfail hfields hflush hgetc hgethead hh hin hinit hio hiserror hload hlower hmkcontent hmkhfields hmkmimeboundary hmkspairs hmoved hmydomain hnone hokheaders host hout hparseheaders hparsequery hparsereq hpos hprint hputc hrange hread hreadbuf hredirected hreqcleanup hrevhfields hrevspairs hsize hspairs hstop hstrdup htmlesc http http1.1 http11 httpd httpd.h httpfmt httphead httpreq httpunesc hunallowed hungetc hunload hurlfmt hurlunesc hversion hwrite hxferenc ifmatch ifmodsince ifnomatch ifrangedate ifrangeetag ifunmodsince implementation include included info initialization input int io layer len length libc.h libhttpd library lines list lower max message meth mxb nil okchar okencode oklang oktype optional pairs parameters params particular persist persistent pos private range ranges reads reject remaining replog reply req reqtime request requests rough routines rune search seek sent server size source sp specific src stop string strings struct submission suffix supports sys tag tags te time timeout tokens transenc transfer transferring type typedef u.h uchar uchars ulong uri urihost val value vermaj vermin void vsave weak worthless xferbuf xferenc httpd	2/httpd
 0x000000ff 0x000055ff 0x000099ff 0x0000bbff 0x0000ffff 0x005dbbff 0x008888ff 0x00ff00ff 0x00ffffff 0x448844ff 0x4993ddff 0x55aaaaff 0x7f 0x7f00007f 0x8888ccff 0x88cc88ff 0x99994cff 0x9eeeeeff 0xaaffaaff 0xaaffffff 0xeeee9eff 0xff00007f 0xff0000ff 0xff00ffff 0xffff00ff 0xffffaaff 0xffffff00 0xffffffff access accommodate aligned allocate allocated allocating allocimage allocimagemix alpha applications array background bit bits black block blue bu bugs byte bytes bytesperline cache chan channel channels char clip cloadimage cmap8 col color colored colors components compressed comprising computation contained convenient coordinate copied correspond creates data dblack dblue dbluegreen dcyan ddarkblue ddarkgreen ddarkyellow deal depth described descriptor dev dgreen dgreyblue dgreygreen diagnostics display displays divisor dmagenta dmedblue dmedgreen dnofill dnotacolor dolock dopaque dpaleblue dpalebluegreen dpalegreen dpalegreyblue dpalegreygreen dpaleyellow dpurpleblue draw draw.h dred dtransparent due dwhite dyellow dyellowgreen enum equals error errstr exchange execute external extracted failure false fd file files filled fixed flag format freeimage freeing frees getwindow graphics green grey1 grey2 groups horizontal id identifying ignoring illumination image image's images include increases initialization insufficient int integer leave leaving leftmost length libc.h libdraw loadimage mapped mechanism memory mixing mod moving multiplying multithreaded namedimage nameimage ndata necessary non obtained occupied offset onto opaque opening overall packed paint partially particular performs permit pixel pixels pointer predefined premultiplied presented processed programs provide publication published publishes range ratio readimage reading reads rect rectangle red reference regardless region remaining repl replaces replicated replication representative resources return returned returns rgb rgb16 rgb24 rgba32 routines run scan server setalpha share sharing significant similarly simulates source space specifies src starts storage synchronized sys tfor threaded tightly time tones transparent u.h uchar ulong unloadimage unrelated user using value values void wider withdrawn wordsperline writeimage writes writing allocimage	2/allocimage
 0x000016f5 0x0000a988 0x0000bf1b 8.out acid acidleak.c address algorithm allocated allocation allocator ansi ape arenas aux bin binaries binary block blocks blue bright bs bss bugs bytes cmd code color comment completely contains counting created dark data default depends determine directed echoes editing environment examine examines fields file fill finding graphic graphically headers ids image images indicate inspect inspecting instance internal leak leaked leaks leaky lens lib libc list longer looking lost magnifying malloc mark memory necessary option output padding page pid pixel pixels plan pointers pool posix print prints process process's processes programs rc reachable realloc red registers representing represents res rio root running segment segments sending shared sharing shell site size source space specifies src started string stripped structure style summarizing sweep sys tags unless usage view width window yellow leak	1/leak
 0x0000f8cc 0x14,r29 0x16c8,r29 0x7fffd7c4 0x7fffeeac 8.out accessed acid acidinit active add address addresses addsrcdir adjacent admit allocation allow append architecture args argv argv0 array asm assignments assume attached attaching attributed automatically bin binary block blocks bpdel bpset bptab breakpoint breakpoints bsrc bugs bytes casts char character cmd codes commas complete complex conflict consecutive cont continue convert core counted counter cpu creating ctl current data db debug debugged debugger debugging declared default defined definitions defn defunct delete dependent determined diagnostics directories directory disassemble display distinguishing don't dump e.g edt env escape est etc examining except executable execute executed executing execution exits expr expression expressions extant facilities false file filepc files finished float floating floats fmt forks format formats fpr func further gpr halt hard headstr higher id image indirection inferred input inspect instruction instructions intb integer integers invoked kernel kill language level lib libfile libraries library linenumber lines linked list listed lists load loaded loop ls ls:386 lstk machine magic main main:argv manual manufacturer mar mem memory mips mipsco mk modified modules movw near nearest newproc nonempty notable notation note objtype obtained obtains operand operator operators option options output outside override partial pcfile pcline phil pick pid plan pointer port pread prefixed previously print prints proc process processes processors profile progargs program's programmable prompt proposed provide pwrite qualified r31,0x0 rc redirect registers regs renamings repeated repeatedly replaceable reported require resume return returns rob run running rw s.next s.val sam scaffolding segment select selection sequences setproc setting share shell signs source sourcefile space spr src stack standard startup stat statement statements step stepping stk stop stopped stopping stops store str string strings structures subscript subscripts sunsparc suppresses surrounded symbolic symbols sys tail termination text textfile timezone trace tracing trump truss truth type types unary untrump untruss user using val value values variable variables wait whatis win window winterbottom wq yield acid	1/acid
 0x003e 0x1bb0 48x48x1 48x48x2 48x48x4 48x48x8 512x512x24 512x512x8 astro bell bill bill.1 bit bits blanks character chooses color com comma commas constants contains correspondence deep depths dict directory display displayed distinguish divided domain eight endian entries entry equal exist expression faces file files finally firstly forgiving format further gates grey hexadecimal hierarchy highest historical hold icons image images joy labs letter lib list log machine machinelist machines mail map mapped maps message microsoft.com names odd pairs pixel pixels programs purpose read recorded regular research running scan seemail sending serve shorthand size sizes somewhat stored subdirectories subdirectory sys text times tweak twenty typically user users various ver face	6/face
 0x0a 0x0d 0x7f abbreviations accent acme acts additional ae alt alternate arrow ascii asterisk backspace backward bishop bit block capital caps carriage character characters chess co compose comprising cons contained control convenience crlfs currency cyrillic del delete denominator design difference digits digraph digraphs dollar e.g enter escape eschews exactly extreme feed file files format forward fraction full generally generated generates gnot graph greek grep guiding hexadecimal idiosyncratic illustrated interpret intro key keyboard keyboards keys king knight labeled latin letter letters lib lie ligature list lock looks lower machines magnum main mathematical micron mnemonic names near newline note num numerator obvious operator operators option ordinary pad pair particular pawn pc pg piece pieces plan programs queen regular related repeat repeated return rio rook rules rune runes sam script scroll scrolls sequences shorthands sign slc sloppy sometimes somewhere sorted sparcstation ss suitable superimposition superscript superscripts symbol symbols tab table tcs terminals type typed typing typists unicode upper using usual utf value variant view windows wk ya yields keyboard	6/keyboard
 0x13b540 0x13b558 0x13b5a0 0x1f0a24 0x83c38 0x8b194 0x8b1d0 1pub access accessing accidental accidentally accustomed actually add additional address advise ae afresh age alas annoying anonymous another_list answer append apt aref arg arg1 arg2 array arrays arrows assign assigning assignment assume attempt attributed author autoflush avoid awk backslash bambam barney bart base based beginner beginners bell berkeley betty beyond bin bind blah blame block borrowed braces brackets brand briefly broken build calling can't careful caveat character check christiansen clear clobbering cmp code columns comment common compile compiler complex concatenated confused confusing consider construct constructing constructor constructors constructs contained contains contributed cookbook copied copy count counting counts cpan create cw daemon dangerous dash data database date daughter db dbm debugger debugging declaration declare declared defined demonstrated depends deref dereference dereferencer dereferencers dereferencing described designed desperate detail detailed develop didn't difference difficult dimensional dimensions dino direct directly disallow disk distinction distinguishing disturbingly document documentation doesn't double doubt dp drop ds dst due dummy dump duplicate dynamic easiest easily easy editing efficient elaborate elroy elt emulate entity equivalent error es establish evaluated everywhere except existing experienced experimental explicit extra eye faint feature features fh fields file filehandle finally find_days fine first_k first_v flag flintstones forced foreach format fragments fred friday friend gdbm generation george get_family getnextpairset getpwnam getting gimme golly hacked handle happy hard harder hash hashes header heart helper here's hidden hoh hol hold holds homer href hy i'th illustrating implementation implicitly include includes indicators indices indirection interesting internal internally interpretation intriguing ip isn't issues it's item jane jetsons join judy jun key key,value keys kid kids lack lacking language lead leading let's level levels lexical likewise limitations lines list listref lists location log logo loh lol looking looks lookup loop maggie main maintain malloc manage manpage manpages map marge matrix maybe mean meant meets memory merely met method mildly misleading mistakes mldbm module monday multidimensional multilevel na ne nearest needing nested new_folks nice nights notation note noticed notion nroot numeric ob object objects occasionally oct oe old_values older operator optimally output page pal parse parsepairs partially pass passing passwd patch pebbles perilous perl perl's perl.com perldata perldsc perllol perlmodlib perlobj perlref person pet pi piece pilfer pinch pitfalls pointed pointer pointers pop populated portion postfix precedence preceding prefix presented print printf printing prior produce programmer programmers programming proved purloin push pw_name pwd.h quote qw rank raw rcsfile read reading real rec record records ref refer reference references referring refs relax release relying remade remember remind repeatedly rest returns revision risk role root row rows rp rules run sample santa's saturday save says scalar scarier scenes scoping se sections seemingly seldom series serve sh shock short showing shown similar simpsons site size some_function some_table someday somefunc someone sometimes somewhat son sorely sort sorted sorting sorts sound source sp speaking split square ss standard statement stdout stored strategy strict string struct structure structures sub subscript subscripting subsection subtle sudden summary support surprisingly swearing symbol symbolic syntax table tad taking tchrist teaching temp temps text th that's thatcode thereby therefore they're thiscode thursday tie ties tightly time title tmp tom tr translation traversal treatment tricky truly try turns tv type types typing unbreakable uncopied undeclared undefined underlying underneath understand understandable understood unfortunately unless unused update user using usr valiant value values variable variables various vars version via wanted wed wednesday what's whatever wife wilma won't worth write wrong xx you'd you'll you've yourself perldsc	1pub/perldsc
 0x15eca4 0x1aa444 1pub abbreviated able access actions active add additional adds ae affect affects afterinit alias aliases allows alter alternative ambulation.pm ambulation::legs angle appearance application applications applied args array arraydepth arrays arrive ask assuming auto autotrace backslash backslashing backtrace backtraces backwards bactrian bar baserev behaviour bell bet bit block brackets break break_condition breakable breakpoint breakpoints bugs builtin calculates caller calling camel_flea capabilities careful carp.pm cases caught cf character characters check checked checks choice cmd code colon compact compactdump compile compiled compiler completion condition conditions config config.pm config.pm:0 config.pm:2 config.pm:574 config.pm:628 config.pm:644 config::begin config::fetch config::myconfig config::tiehash config_vars connect connects considered consists constructs cont contained contains context continue contrary contributed control convenient copy correctly correspondingly corresponds count count237 cpan cr created csh current current_file currentpackage customization customize cw d:dprof dash data date db db.out db::alias db::args db::db db::dbline db::deep db::dump_trace db::in db::out db::parse_options db::postponed db::print_trace db::signal db::single db::sub db::trace dbcmd de debug debugged debugger debugger's debuggers debugging deep default defaulting defaults define defined defines definition delete deletes delivered dependency depth descending designed destruction detach details dev devel::dprof di didn't die dielevel directed directly directory disable disabled discovered display displays distribution documentation doesn't don't double dprof dprofpp ds dummy dump dumpdbfiles dumped dumppackages dumps e.g easy ed editing editor emacs enable enabled endline ends enter entered entering entries entry env environment equivalent escape escaping etc eval evals evaluate evaluated evaluates exact examine except exception exclamation exec executable execute executed executes executing execution existence exists exit exited expanded expect expectations expected explicit exporter.pm exporter.pm:171 exporter::export exporter::import expr expression extensions external extra false fashion feature features fetch fh file filehandle filehandles filename filename:startline files final finding finished fire fit flag flavors flow foo forget format formatted forwards frame frames full functional global globprint globs gnu goes governed halt halts handy happen happens harmless hash hashdepth hashes header here's highbit historically holding holds hooks hy implement inc include included includes incr indentation indicates infested info ing inhibit_exit initialization initialized input insert inserting inserts inside inspect install installed instance instant integrated inter interact interacting interactions interactive interactively interesting internal internals interpret interpretation interpreter interrupt interrupted intervention invoke ip isa issuing it's item izable jun key keyed keys leading legible len length letter level levels lexical li lib library lineinfo lines list listed listing lists load loading log logdir logo longer looks lost magical main main::bar main::begin main::foo main::infested main::pests maintain maintained maintains mandatory manpage matching maurice max maxtracelen meanwhile mechanism memory message messages method methods min minimal missing mistakes mode modify module modules multi multiline mycode.pl myconfig myperl5db.pl myprogram na names ne necessary needs negative nested newline newlines noninteractive noninteractively nonstop note notty nul:0 null:0 number'th numeric object objects oe ok omitted op'val opened opposed opt option option's optional optionally options original ornaments osname osvers output outside overloaded pack pack,1 package packages pager parse parse_options parses particular patch patchlevel pattern performed perl perl's perl5db perl5db.pl perldb perldb_notty perldb_opts perldbtty perldebug perlfunc perllib perlvar pi pipe piped piping pkg pointer points pop popular positive postpone precede preloads preserved pretty prevpack print printable printed printer printing printout printret prints processed processing produce produces profile profiler programmatically programming programs prompt prompting proper properly provide provided provides ps ption ptions purpose putting query quit quote quotish ran rc rcsfile reached reaches read readline reads realized recall recallcommand recognized recursion recursively redirected redo ref reference references regarding regardless regexp regexps remember reminiscent repeat require reset resets resort resources rest restart return returning returns revision routines rudimentally rudimentary run running runs runtime sane satisfy says scalar screen script scrolls search section select selected semicolon sequential session settable setting settings setup sh shell shellbang shift shipped short shows signallevel signals similar simplify simplistic simulate size skip skips sleep software soon source sp space spawn specific specifier spent spersed ss stack standard started starts startup statement statements stdin stdout step stepped stepping steps stop stopped stops string stringify strings structures style styles sub subname subprocess subroutine subroutines subsection subversion supply support supported surprise surrounding switch symbol synonymous syntax tables tells temporarily term term::readkey term::readline term::rendezvous terminates test th thusly tie tied time title tk tkrunning tmon.out tmp toggle tool total tr trace traced tracing transfer translation tree trees tried tries truncated try tty ttyc twice type typed typical typing unbreakable uncaught undef undefprint understands unfortunately uniquely unix unless unlike usage usageonly user using val value values variable variables vars verbose verbosity verycompact vi via viewing visual_perl_db wait warnings warnlevel wasn't what's whenever whereas wilkes window wish working works writes writing written xx you'd you'll you've perldebug	1pub/perldebug
 0x1b58 1pub able absolutely access accessible actual actually add adding additional adds ae affects aggregate aggregates ahash aid alias aliases aliasing allowing allows alone alphanumeric alphanumerics alter alternatively alternatives am anonymous answer anywhere apackage appended applies applying appropriately aref aren't arg args argv arrange array arrays ary assign assigned assigning assignment assignments assigns assume atan2 attempting auto autoload autoloadable autoloader autoloading automatic automatically autosplit avoid aware backslashed bar bare base base12 baz_val becomes behaves behavior bell bestday beta beware beyond bit block blocks bottom bounded bpackage braces brand bref briefly buf builtin builtins bumpx bundling c's caller caller's calling can't candidates capitals care careful catch catching caveats certainly character characters chdir cheat checking chmod chomp chown chroot chunks claiming class clause clauses cleaner clears closure closures code collapse collection combining comma common commonly compilation compile compiled compiler complaining complete completely composite concatenating conditional conditionals confined considered constant constant.pm constants construct constructors constructs context contexts continuation continue contributed control controlled convenient convention copies copy core core::open countermand create created creates creating cref cube_root current custom cut cw dash date deal decide declaration declarations declare declared declares default defaults define defined definition delayed delete deleted delimit depends described desired despite destroy destructors detailed details diagnostics didn't die difference differing digits direct directive directory disables ditto document documentation doesn't doing don't double doubleary dref drill dropping ds dummy duration dynamic dynamically dynamics e.g earlier easier easy eats effectively efficiency efficient elem eligible else's elsewhere elsif emulate encapsulated enclose enclosing encourage ends ensure entries entry env environments equal equivalent er erases error especially etc eval evaluated everyone everything exact exactly except exception exceptions execute executed exist existence exists exit exited exiting expensive explain explicit explicitly export export_ok express expression expressions extending extends extra extract falls false fancy fashioned faster fatal fed feels fh fields file filehandle filehandles files filling fine flag_bar flag_foo flag_mask flat flattened flurp fly folding folks foo forces foreach foregoing formal format formats former forward frame fred frederick freed fri front full fully func funct functionality funny future garbage gee generally generate generated generating get_line get_rec gets getstring gimme_another global globally globals goal gory goto grave greatly grep grow handle happened happens harder hash hashes hashref header here's hidden hide historical hmmm hold holds href hy i'm i.e identifiers identities iff ignore ignoring illegal immediate implementation implicit implicitly import imported importing imports impositions inaccessible include incoming indeterminate index indirect indirectly indistinguishable influence influenced inheritance init initialization initialize initializer inlined inlining inner instance int integrity intent intentionally inter interesting interpretation interruptibility introduced intrude invisible invocations io io::handle ioqueue ip isn't issues it's item ize ized joe join jun kept key keys keyword keywords language's languages larry lc leak learn legal length let's lets level levels lexical lexically lexicals library lifetime likely likewise lines lispish list list1 list2 listed lists literal load loaded localize locals located log logo lookahead loop loosely losing lower ls lvalue lvalues magic magical magically main maintain managed mandatory manipulating manipulation manner manpage map match max maybeset mean meanings meat mechanism mechanism's mechanisms member memory mentioned merely merge merlyn method methods misbehave missing model moderation modern modifications modified modifier modifiers modifies modify module modules mon motd move mygrep myindex myjoin mykeys mylink myopen myownenv mypipe mypop mypush myrand myreverse mysplice mysyswrite mytime myvec n_factorial na name1 name2 name3 names namespace naming naturally ne necessarily needs neither newlist nice noise non none nor not_inlined notation note notice null object objects obtained occasion occasionally occlude occurred occurring occurs oe offset ok older omitted ones oof openit operation operator opt_baz optimization optional optionally ordinarily ordinary original originally outermost outside overridden override overrides overriding pack::var package package's packages parameter parameters parentheses parms parse parse_num parsed parser particular partly pass passing patch path perfectly peristent perl perl's perldata perlfunc perlmod perlref perls perlsub perltie perlxs permanent perspective phooey pi pill pipe places placing planning plus pointer pop popmany possibly potential powerful practice pragma pre precede precedence precisely predeclaration predeclare predeclared prefer prefix prefixed prefixing presumably pretend previously primarily principle print prints prior private prod produce produces programmers programs promote properly protected proto prototype prototypes prototyping provide provides punctuation purpose push pushme putting qualified qualifier quiet quote qw rand randal rcsfile read reader readhandle reads real reasons rec reclaims recursively recycled redefine redundant refer reference references referring refs reimplementation release releases remember removes represents requests require requires reserved rest restored restoring restricted results retains retlist retrofit return returned returning returns revision root routine routines rule run runtime safer save saved saving saying scalar scalars scope scoped scopes scoping scribbling searched secret_sub secret_val secret_version section self selfloader semantics semicolon separates severe sh shell shift shines shrink sig signs silent similar similarly simply simulate size skipped sneak some_function some_pack::secret_version someary someday someone sometimes somewhat somewhere sort sounding sourced sp space specially specify specifying split splits splutter spring ss st_dev st_ino stack standard star starts statement statements static statically statics stdin stdout stick storage stored strict string structures style sub subref subroutine subroutines subs subsection substr subtle supplies supply surprising swallow symbol syntax table tad tail tailings takes taking templates temporarily temporary tempted test th that's there's therefore they'll thinks thisline throughout thu thwarting tie tied time title totally tr trace translation treat tried trouble truly try tue turning turns type typeglob typeglobs types typically um unambiguously unary unavailable unbackslashed unbreakable undef undefined understand understandable unexpectedly uninterruptible unix unless unlike unphooey unprototyped unqualifiable unqualified unreachable unresolved untied upcase upcase_in updatable update updated upper usage usefulness user user_agrees user_disagrees users using value values var variable variables vars versions versus via viewed visibility visible visually void wantarray wants warning wasn't ways we're wed whatever whereas whitespace wid wildcard wish won't working works worth wouldn't write writehandle writer writers written wrong xx yes you'd you'll you're you've perlsub	1pub/perlsub
 0x1f 0x7e 0x7f 0xa 0xb 0xc 0xd alphanumeric ascii bugs carriage centric character classification classify coded control converts ctype ctype.c ctype.h defined delete digit eof exclamation false fopen formfeed hexadecimal horizontal include ing integer isalnum isalpha isalpharune isascii iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit letter libc libc.h lookup lower macro macros newline non ordinary original port predicate printing punctuation range rest return returning returns similar source space src sys tab table tables tilde toascii tolower toupper u.h upper value values version vertical visible ctype	2/ctype
 0x1f accept accepting access adding addpt adjacent affected algebra aliased aliasing aligned alignment aligns allows alpha ambiguities analogous angle angles anti arc array arrow arrowhead atan atan2 axis background barb basic behaves behavior bezier bezspline bg bgp bits black block blue boolean border bugs building built bytes calculation captures cases centered chan channel channels chantodepth char character characters clip clipping clipr clips closed color combine complementary compositing computer conceptually conditions control convenience coordinates coords corresponds cos cosine cosp counterclockwise cover covered created cubic curve data debugging default define defined defines defining deg degrees depends depth described descriptor despite destination determined diagnostics diameter differ differently digital direction disc discussion display distance draw draw.h drawing drawn drawrepl drawreplxy draws drawsetdebug dst duff dynamically edge ellipse encode encoded end0 end1 endarrow enddisc ending endmask endpoint ends endsquare enum equal equivalent error errors except explicit extant extending extent false fatal fields fill fillarc fillbezier fillbezspline filled fillellipse fillpoly fills flag font fonts format formats frequently further gendraw geometric geometrical goes graphics greyscale height higher holding horizontal horizontally icossin icossin2 id identical identically ignores image images implementation implicitly include independent inside int intact integer integers interior intersect intersected intersecting intersection interval involved joining joins leaving len length level libc.h libdraw limit lines list location longer macro management mask masks max measured memory methods min modification modifications modified modifies mp names necessary needed negative non notifies np npt ntsc nul null objects odd opaque operation operations operator operators outline outlined outlining output outside parameter parameters particular periodic permits perpendicular perpendicularly phi picture pictures pixel pixel's pixels plane points poly polygon polygon's porter portion positioned positive pp primitives proc procedure proceeds produced produces promoted proper provided pt purposes q.v quadratic radius read rectangle rectangles rectangular region regular repclipr repl replaces replclipr replicate replicated replicates replicating replication representing requires resolves restricted resulting returns routine routines rule rune runes runestring runestringbg runestringn runestringnbg scaled screen sector self semiaxes serial series server shape shapes siggraph similar simply sin sine sinp sizes smaller smooth source sp specify specifying spline src standard stored stores string stringbg stringn stringnbg stringsize struct structure structure's styles subtracting sufficient sys takes terminates terms text thick thickness tile tiled tiling tip touches translate translating transparent truncated turns type typedef u.h ulong undefined using usual utf value values variant variants various vertical vertically void width wind winding window windows write draw	2/draw
 0x2f8 0x337,0x430 0x3e8 0x3f8 0x43f 0xd0000 100base 100basefx 100basetx 100mbit 1024x768x8 10base 10base2 10baset 1600x1200x8 16mb 3com 53c8xx 82543gc 91cxx 9load a.b.c.d ability able access accton actions ad adaptec adapter adapters add added adding address addresses adhoc advanced agp aha1542 aid allocation am79c970 amd amd79c970 apm apm0 appropriately armpit asterisk async attach attached attribute audio0 audiox aui auth authentication autodetected autoexec.bat automatic automatically autoprobing avanstar base based battery baud bed behavior bin bind bios bit blanking blaster block blocks boards boot bootargs bootdisk bootfile booting bootstrap bound bridging bt bug bugs built bus buslogic bytes cache capable card cards cases cat cfs cga channel check chip chips chipset clear clone clones com com1 com2 com2:96,n,8,1,p combo command.com commas common compatible completely concentrators config.sys configurability configurable configuration configurations configure configured configures connecting consist console consulted consults contained contains controller controllers converted correct correctly cpu cpurc crypt ctl dance debugging decided default defaults defined defines definition degrees delay dell deprecated describe described desired detected determined dev device device's devices dhcp differing digital dir direct directed directory disable disabled discards disconcerting disk display distributions dma dos dos;c dp83815 dpms draw driver drivers dummy dummyrr duplex e.g ea easy ec2t echo eia eia0 eia1 elite elnk3 en2216 enable enabled enables encryption ends entries entry environment equipment error ess1688 essid etc ether ether0 etherexpress etherez etherfast etherlink ethernet ethernetcard ethernets etherpair etherx examine exceptions exclude experiment experimental extending fa310 fa311 fa312 fa410tx factory fast fast16 fast4 fast8 fd feature file files fishcalledraawaru flag flags force100 format fs ft full fullduplex further fx fxfd gate generates generic gigabit gigabytes graphic hard hardware hd hoc holding i.e id idea identified identifier identifies identify identifying ieee iii images include included includes inclusion inclusive increasing initialization initially input instant integrated intel intelligent intellimouse intended interactively interesting interface interrupt intersil ioexclude ip irq irq3 irq4 isa item iteration kernel kernel's kernelpercent kernels key key2 keyboard kfs l2a1157 lan laptops latter length level levels lies limit lines linksys list listed live load locate logic longer looks lost lsi lucent machine machines main maintains managed management mapped marginally match maximum maxmem maxsd53c8xx media megabytes mem memories memory menu menuconsole menudefault menuitem messages mga4xx mii minimum mode models modem modemport monitor monotonically motherboard mount mounting mouse mouseport ms multimaster multiprocessor multisync135 mylex names naming ncpu ncr ne2000 near necessary needed needs negotiate negotiated net netgear network newer nodummyrr noetherprobe nomce nomp non none nopcirouting noscsireset notably notice nousbprobe novga null numeric nvr odd older omitted ones operating operation option optional options origins orinoco override packets parameter params parity partition partitioning path pc pccard0 pci pcimaxbno pcimaxdno pcm100 pcmcia pcmcia0 pcmciax pcmpc100 pcnet pcs percentage perle physical picks places plan plan9.ini plan9.nvr pn pnic pnic2 po pool port ports prefixed presented printed prism pro probed probing procedure process processed processes processor processors programming programs prompt prompted properly provide provided ps2 ps2intellimouse purposes puts range ranges rarely read reads realtek receives reception reconfiguration relevant remainder remaining remote representative require reserved reset resets resident response restricts reuse root rootdir rootspec routing rs rtl8139 run saving sb16 scan scanning screen script scripts scsi scsix sdc0 searches seconds sections sector select selected selecting selection selections selects semiconductor sensitive sent separator serial serial0 series server servers services setting settings setup shell sic sign similarly simpler sink sis sis900 size sizing slot slots smc smc91cxx software solve sound space spec specifier specifies specify specifying sta standard standby star startup station stats stop stops string subsequently suffice superseded support supported suspect suspend switch symbios syntax systems table tag temp terminals termrc test tested tfd third tightly time timeout tmp traditional transmit tried troublesome truemobile ttc turns tx txfd txkey type types typical typically uart uarts uhci ultra unencrypted unique unit unless unlike unspecified usb usbx user using value values variable variables variant various varying vestige vga vgasize via video vmware watch wavelan wavelanpci wd8003 wd8013 wireless works write writing xxx plan9.ini	8/plan9.ini
 0x3bc bind communicating control correspond corresponds data dev devices devlpt.c dlr drive driver file files fine interface interfaces latch lpt lpt?data lpt?dlr lpt?pcr lpt?psr parallel pc pc's pcr port ports printer printers programs provides psr reading register sends source specifiers src status sufficient sys write writing lpt	3/lpt
 0x3ff ability access adding additional address addressed algorithm alternatively arbitration assign assigned base bind bios bit bits boot bugs bus card card's cards cat chosen class colon configurable configuration configured configuring conflict conflicts contains control csn ctl data decimal describe determine dev device devices devpnp.c digit digits directory disabled discovered driver echo enabled enumerate enumerated enumerates enumeration existing expressed fields file files fixed fn formatted grep hex hexadecimal id identification identifying idstring index instance intended intention interface interfaces interrupt isa letters limited list logically lost manufacturer mapped mechanism memory needs note obtain particular pci perform periods plan9.ini play plug pnp pnp0 port programming provided provides range raw read reading reads regions register registers remainder representing reset resolve resources returns sending serial served serves settings size slash source space specifying src strings sub substring summary sys text textual textually third time traversing type typically unique unlock upper user using valid value values various vendor via video write written yields pnp	3/pnp
 0x7c00 0x7e00 3½dd 3½hd 5¼dd 5¼hd 8.5gb 9fat 9load 9pcdisk abcfnprw abfprw absence accepted access active add added address addressing adds allocated appending arbitrarily architecture arithmetic assigns assumed attempt attribute automatically based baw bfile bios bioses blank block blocks boot bootable bootblock booting bootstrap bring bugs bytes cache cfs chained chains check checks chosen cluster cmd collisions common configuration confused conjunction considerations consists constants contains contiguous contiguously convention conventionally create created creates creating csize ctl cylinder cylinders data date debugging default delete density described descriptions detects dev device device's df dfvx directory disabled disc discussion disk disk's diskette diskettes disks disksize distinguishes divided division doing dos dos.1 dos.2 dossrv double drive driver due e.g editor edits ending ends enter entire entries entry etc evaluates evaluating exceed executes exist exists exit explaining explicitly expression expressions extant extended extending extents fail fails fat fat12 fat16 fat32 fd0disk fdisk fifth file files finally fixed flag flags flashes floppy format formatted formatting former fs gets goes hard highest hold i.e ignoring image include inform initialize install installed installs interactive invoked jump jumps keeps kept kernel kernels kfs label larger largest lba lines linux linuxswap listed listing load loaded loads logical looks mark marks master maximum mbr mbrfile message mistakes mode modified modifying ms names neither newdot non nor nresrv ntfs numbered numeric nvram offset omitted op operates operating operators option options output overlap overlaps parameter particular partition partition's partitioned partitions pass pbs pbslba pc pcs physical physically places plan plan9 plan9.ini plan9.nvr plan9partition plus prefixed prep prepare prepared prepares previously primary print printed prints programs prompt pseudovariables quit raw read reads record refuse refuses regardless regions regular remaining reserved resolves restore root running runs scans sd sdc0 secondary sector sectors sectorsize sent share similar size slots source space specific specify src starts stored subpartitions suffix suitable supported swap synopses sys systems table takes test textual time tmp total translate type types typically typing unique units unless unnamed unpartitioned unused using valid value variable warning windows works write written prep	8/prep
 0x7c00 16mb 2gb 8.5gb 9fat 9load active acts address addresses addressing allocated alt appended appropriately attempt attempts auto automatically baud bios bioses bit block boot bootable booted bootfile booting bootp bootstrap bugs cd cdboot character checked choices chooses chs cn code com commercial common compatibility compiled compressed configuration considerations console constraints contains contiguously control convention copies copy cpurc ctrl cylinder data de default defaulting del described details detects determine determined determining device devices directed directly directory disk disks display dos dossrv double drive drivers due duplicated embedded encountering ensuring enter entered enters entire entries entry error ether ethern ethernet executable execution extended extensive fat fat16 fd fd0 fdisk file files filesystem finds fits fixed floppy follow format fs further gzip hard hardware header host image initialize input install installed interfaces kept kernel keyboard kfs knows larger lba ld ld.com leaving lib linear list load loaded loaders loading loads location machine machine's manager manual maps master mbr mbrs media medium memory menu mode modulo mounted ms ndb network networks non numerical omitted operate operating option options overridden parses particular partition partitioning partitions path pathname pbs pbslba pbss pc perform physical plan plan9 plan9.ini prep prepared prints prioritized probing procedures proceeding proceeds profusion programs prompt prone rate read recognized record refers removable representing required reset reside resides response root run running safer sd search searches searching seconds sector sectors select sequences server size source space specifiers specifies src starts stops stripped suitable summary supported supports switches sys systems tables technique termrc time transfers type typed typically unfortunate units unless upwards user using version virtual ways 9load	8/9load
 0x7fffffff 0xffffffff a.out access accessing addr address addresses adjusted allocated allocation applicable application architecture architectures associating asstype assumed attached attachproc base based beswab beswal beswav bio.h bit buf build byte bytes cache char class code comprises construct constructs contained contains corefd crackhdr creates current data default dependent described describing descriptor determines diagnostics differs disassembler docache dynamically eight endian error errstr executable executing existing extends extern fails fd fhdr file files findseg floating foffset former fp fpregs generic get1 get2 get4 get8 global header highest id images implies include independent index indicated indicates initializes instruction int interface interprets invokes kernel kflag latter leswab leswal leswav level libc.h libmach library list load loaded loadmap loads location logical lowest mach mach.h machbyname machbytype machdata machine map mapped mapping maps marks matches maximum mem memory modification multi names necessary negative newmap non object offset offsets opened opening overhead overlapping page parameter parameters parses performs pid pointed pointers points proc process processor programs proper provide put1 put2 put4 put8 quantities quantity range read readable readahead reduce references reflects register registers regs related remain representation resized resulting retrieve retrieves return returned returns routines running section seg segment segments selection selects sequences setmap similar size source space specific src stack static stored structure structures supported swapped symbol sys tables target text transferred transfers translate translated type u.h uchar ulong unable unaffected unused unusemap user ushort using val valid value values variable variables virtual vlong void writable write written mach	2/mach
 0x8e57c 0x8e5b8 1pub ability abuse accessed accessible actually add additional ae ahead allocate allocated allocates allows ambiguities ambiguity anonymous appealing aren't arg args arrange array arrow ary assumed attributes autoload automatically bad bam bang bareword barney base based behalf bell belong belonging belongs beware bin bit blah bless blessed blessing block book break breaks bugs build building built bump buy cache cached calling can't capture care carved cc character cheat check checks choosing circularities clarification class class's classes clean cleanup closely cluttered code collected collection collector combined comes commonly compared compile compiled compiler compiler's complains complete complicated concern confuse confusing consider constrained construct constructing construction constructor constructors construed contained container contains context contributed control convenience costly count cover create creating creation critter current cw dash data date ddebugging deal debugging default define defined defining definition definitions delegation demonstrates depend depth dereference design desired destroy destroyed destroying destruct destructed destruction destructor destructors details didn't die directly display disturbing documentation doesn't don't double ds dummy dynamically effects efficiency eh elsewhere embedded enabled english ensuring environment equivalent especially essential etc everything exactly except exclusively executable executing exist exit exited exits expect expected expects explicitly exportable extension extra familiar fans fast feature fieldname filehandle finally findbest findfirst flag follow foreach foregoing forehead forgotten fred freed fully functionality future garbage generally gentler gets global goes grave greater grief guess guides happens hard hash haven't header hear height here's higher holds honor horribly hy i.e idea ignore implements implicitly implies imported indirect infix ing inherit inheritance inherited initialize instance intended internal interpretation interpreter introduce invalidates invocation invoke invoked ip isa isn't it's item jun key keys kinder knows language lead leak leaving level levels likely limited lines list log logo lookahead lookee looking looks lookup lucky main manipulating manpage manually mark meaningful meantime memory merely messes method methodology methods misbehaving miscompiled missing model modified modules months move multithreadable mycritter::display mycritter::find na namely namespace ne necessarily necessary needed neither new_node node nodes non none nor notation note notice obj object object's objects objtable obviously occur oe opaque operated operator operators ordinary oriented output outside overridden package package's package__ pairs parent parentheses parse parsed particular pass passes patch performance performed perl perl's perl_destruct_level perlbot perlmodlib perlobj perlref perltoot phased pi piece places plain please pointer points postfix precedence preferable prepend presuming prevent print printf produced programmers programming provide provided provides pseudo purposes putting qualified qualify quirky quote qw rcsfile re reaching read readable reasonable reassuring recommend recursive ref reference referenced references referential refs regardless regular regularity remembering replacing reports requested require required requisite resemble responsible return returned returns revision row rule rules run saying says scalar scope search searched section seduced seem self selfref serious serves setting sh shift shifts shouldn't shuts similar similarly simply six slot solution solving sometimes sophisticated sort sp spawn speakers specify ss statement static stderr stored strange strategy string structure structures style sub subclass subroutine subroutines subs subsection subtle suffer suffers summary super super::display support surprising surround sweep syntax takes tells test th that's there's therefore they're thingy thinking thread time times tips title tk tmp tr track translation traps tree tricked tricks tries try trying tutorial types typical typically unbreakable undef understand universal unless unlike unlikely unravel unreachable user using usr value variable variables various versa version via vice virtual warn warning ways we'll weight weren't whatever widgets wish won't wont workaround works worth written wrong xs xx yeah you'd you'll you're you've yourself perlobj	1pub/perlobj
 0xc0000 0xc0068 0xc0076 0xc0090 0xc0200 0xnnnnn 1024x768i 135mhz 31.5khz 35.5khz 48.4khz 50khz 60hz 6200mx 640x480x 64kb 65mhz 87hz 9gxe64 9gxepro 9load accelerated acceleration accelerator accordingly achieve actually add adding addition address alias allowable anywhere ark2000pv ark200pvhwgc ati att20c490 att20c491 att20c492 att21c498 attr attribute attributes aux bandwidth baseline basic beyond bios bit blanking block book boot bt485 bt485hwgc bugs builds bus bytes card card's cards cases ch9294 character characters chip chips chipset chipsets chooses clgd542x clgd542xhwgc clgd546xhwgc clock clocking clocks code combination comments common commonly complex components comprises consists constraints contains continue controller controllers conventionally copies cpd create ct65540 ct65545 ct65545hwgc ctlr current cursor cyber938x cyber938xhwgc data database default defaultclock defined depths described describing desired details determine dev display dot doubler duplication dynamite edition ega ehb entire entries entry env equivalent et4000 existing expected explained extension extensions fairly ferraro file files fills formalizes fortunately frequency generator generic grade graphics gui guide handle handles hardware height hercules highest hiqvideo hiqvideohwgc historic horizontal hsync ht hwgc i.e ibm8514 icd2061a ics2494 ics2494a identification identifier identifies identify inc include included indicates initialization initialize initialized input integrated interact interconnected interesting interlace interlaced internal internally kernel laboratories laptop lib limit linear lines link loaded lucky mach mach32 mach64 mach64lp mach64xx mach64xxhwgc manual match matching maximum meaningful megabytes membw memory mga2164w mga2164whwgc mhz mmmmm mode modern modes monitor monitors multi multiplexing multisync multisync65 ndb nec necessary needed neomagic neomagichwgc nnnnn non note numbered occurring offset overwritten page pairs parameter parameters parsed particular particularly parts pci performance pixel pixels polarity previously printed pro programmed programming properties provide provided ramdac range rate reasonable recognized rectangle refresh registers remainder replacing representing required requires resolution rgb524hwgc rgb524mn richard s3clock s3hwgc save sc15025 scope searched selected serial shb sheets shifted shown similarly simply sometimes sony space speed starts steps stg1702 straightforward stream string subsystem subtype super support supports sync t2r4 t2r4hwgc table technology third timing total trio64 tseng tvp3020 tvp3020hwgc tvp3025 tvp3025clock tvp3026 tvp3026clock tvp3026hwgc type types unit unless unspecified v8.00n value values variety versa vertical vga vgactl vgadb vgasize video virge vision864 vision964 vision968 vl vre vrs vsync vt w30c516 w32p width window worked writing vgadb	6/vgadb
 0xc0045 1024x768x 1280x1024x 1376x1024x8 1600x1200x8 640x480x 640x480x1 640x480x8 800x600x 9load actions aux bail bcdilpvv bios boot bugs card cases caused cmd color configuration configure configures confusing confusion controller controllers current cursor database default depth depths desired devices disable disables display displays don't dram dump e.g effort encounters entirely entries entry env error especially exit expected file files fingertips follow graphics hardware height hex identifying include indicates interlaced ip laptops lib load loaded looking memory message mode modes monitor monitors mouse operation options output override palette pan pc performed physical plan9.ini playing points prevent print printing provided read redirect register registers resolution screen screens setting size sizes software source specifying src standard stealth string strings sys tmp trace trying type using usual valid value values various verbose verify vers vga vgadb via virtual whatever width wrong vga	8/vga
 0xdecaf 0xffffffff 199th 1_000_000 1pub 200th 2nd 3rd a::b abnormal aborted absolute accept access accessible accidental accidentally account acls active actual actually add additional address adds administrator advised advisory ae affect afoul ahem ain't aix alas aliases alien allocate allocated allocating allocation allocs allow allows alone alternately alternatives ambiguity ambiguous amount ancient angle anon anonymous answer anymore anytime anyway anywhere apparently applications apply applying arbitrary architecture aren't arena arenas arg args argv arises arrange array arrays ask assertion assign assigned assigning assignment assume assumed assumes assuming attempt attempted auto autogenerated autoload autoloaded autoloader autoloading automatically autosplit av avoid awk awry backreference backreferences backslash backslashes backup backwards bad badly badref balanced bar bare bareword bargaining base baseclass baseclass::autoload bash_env basically basis baz behalf behaves behavior bell benchmark benign berkeley bet bidirectional bin binary bind binmode bit bits bitty bizarre blank bless blessed blessing blew block blocks blow blown blue boolean botched bottom boundary bourne brace braces bracket bracketed bracketing brackets break breaks broken bsd buffer buffers bug buggy build builtin byte byteorder bytes c's callable callback calling can't capitalize captured carriage carried catches caught caused cdpath cease cgi chance chances character characters chdir check checking checks checksum checksumming child chmod chomp choose chop chopping circumscribed circumstances ck_grep ck_split claimed clash class classes classified cleanup clearsv clobber clobbered closed closer closing closure cloth cmd cmp code coerce collected combining comes comma commas comment commentary comments common comparison comparisons compilation compile compiled compiler compiles complete completely components compound compressed computed condition conditional config.sh configure confused confusing conjunction connect connection conservative consider considered consistency constant constants construct constructor constructs contained contains context contexts continue contributed control conversion convert converted converting converts copiable copies copy core coredump correct correctly corrupt corrupted corruption couldn't count counted counting counts create created creates creating creation crtl crypt csh curlies curly curpad current cursed customer cw cybernetic d_csh dangerous dash data date db db::db db::sub db_file dbm dbsub dead deal debugger debugging decide decided decimal declaration declare declared declaring decrement deemed deep deeply default define defined delete deleted delimit delimiter delimiters delurk denied denoted deny depend dependency depends deprecated deprecation dereference dereferencing derived desired desperation destination destined destroyed details detected determine dev developers device diagnostics didn't die died difference difficult digit dilly dimudmw direct directive directly directory disable disabled disallowed disambiguate disambiguated disaster discovered discovers discussion disk distance distressed divide division do_match do_split do_study do_subst do_trans document documentation documents doesn't doing dollar don't dos dosallocmem dot double drat ds due dummy dump dup duplicate dynamic e.g earlier easily easy ed edit editing editor educated effectively effects eg eligible eliminate eliminating elseif elsif embedded emergency emulate emulated emulation emulator en_us enabled encapsulation encouraged ended ends enforces engine entails enter entered enters entries entry enum env environment eof equal equivalent errno errno.pm error errors especially etc etsockopt euid eval eval'd evaluate evaluated evaluating eventually everything exactly examined exceed exceeded except exception excessive excessively exec executable executables execute executed executing execution exhaust exhausted exist existed existence existing exists exit exited exiting expect expected expecting explicit explicitly exported expr expression expressions extend extension external extra facsimile fail failed fails failure fallback falling false faq faq.html faqs fashioned fatal favor fcntl fd feature features fed feed feel fewer fid fields fifo figure file filehandle filehandles filename filenames filespec filesystem filled final finding finds fine finish finished fit fix fixed flags flavors flow follow foo foo::bar forced foreach forget forgiving forgot fork forking format formed formline forms fortunate fortunately forward frame free_tmps freed freeing frees frequently frexp front fsf fstat ftp full_csh func functioning funny further furthermore future garbage gdbm gdbm_file generally generate generated generates generic genome.wi.mit.edu gethostent getpgrp getpwnam gets getsockopt getsyi getting getuai gid glob global goes gone goto gourd governing grammar grandfathered granted greater grep grow gs guaranteed guard guess guesses guide.html hadn't halt handed handle handler handlers handles handling happen happened happens hard hash hashes hasn't haven't header heavily helps hex hexadecimal hierarchy highly holds hoohoo.ncsa.uiuc.edu hopefully hoping hostname http hv hy i'm i.bak id idea identifier identifiers identify idiots ifs ill illegal imagine implement implementation implicit implicitely implicitly implies import importation imported importing impose impossible inadvertently inc include included incomplete inconsistency incorrect incorrectly increasing incredibly increment indeed index indicate indicated indicates indicating indication indirect indirectly infinite infinitely info ing inheritance inherited inheriting initialization initialize initialized inlining inner innermost inplace input insecure insert inside insidious install installed instance instances insufficient integer intended interconverted interface.html interferes interim interior internal internally internet interpcasemod interpconcat interpolate interpolated interpolates interpret interpretation interpreter interprets intervening introduce introduced invalid invoke invoked ioctl ip ipc ipc::open2 irregular isa isn't issued issues it'd it'll it's item items iterate iterator itty judged jump jun junk keeps kernel key keys keyword kill kindly knows la label labels lang larger largest larry late lc_all leading leave_scope leaves leftward length letters level levels lexer lexical lexically lexicals libraries library lightly likely limit limitation limitations limits lines linkhood linking list listed listen lists literal literally literals live loads locale localize localized locate location log logarithm logic logical logo lone longer looking looks lookup loop looping loopish loops loses lot lstat luckless lvalue lx machine machines magic magical magically mailbox main mainline maintains malformed malloc managed mandatory manpage manually manufacture map mapstart marker masks match matched matches matching math::complex maxbuf maxima maximum maybe mean meaningless meant meantime mechanism memory mention mentioned message messages method methods middle minima minimal minimum miscount misinterpreted misleading mismatch misplaced misprint missing misspelled mistake mixed mod mode model modifiable modification modifier modifiers modify modifying module modules modulus moon morally mortal mortalized mostly ms msg msgctl msgrcv msgsnd msqid_ds multi multidimensional my_pclose mypack mypackage myvar n,m na namely names namespace naturally ne near nearby necessary needed needs negative neither nested nesting network newline news.answers newsvsv nix nobody non noncreatable none nonempty nonexistent nonstandard nontrappable nor notably notation note nothing's novice nowadays null numeric obj object objects obligated obsolete obviously occasionally occurred occurrence occurs octal odd oddly oe offset offsets ok omit omitted ones oops oopsav oopshv op opcode opendir opened opening operand operate operating operation operational operations operator operators opposed optimize optimizes option optional options ordering ordinarily ordinary os ought outer outermost output outside overfl
 0xe000 accepts access actions affect ambiguities ambiguous amount analyzer argc argv arising assigned associate besides break bugs char cmd code codes compile compiled compiler conflicts context converts couple create declared default define defined described diagnostic differences direct edition effects environment error errors essentially file files finally fits full generated generator grammar hall handling higher implement include incorporate inner input int interface interpreter johnson kernighan lex lexical lib libc libc.h loaded longer lr main manual mentioned messages missing names non option options output parser parsing pike precedence prefix prentice preprocessor print produce programmer's programming programs prototype recursive reductions references regulated relevant reports research return returned reverses rob routine routines rules sethi short sort source specification src statement statements stdio stdio.h stem structure symbol sys tables temporary tenth terminals text token tokens transitions translation translator undocumented unix user using utf value values version void volume workings write writes y.acts y.debug y.output y.tab.c y.tab.h y.tmp yacc yacc.c yaccpar yaccpars yydebug yyerror yylex yyparse yacc	1/yacc
 0xf1000000 0xf7000000 0xf9000000 0xf90012345 access addresses adjacent adjusted aggregate alloc allocate allocated allocation allocator allotted amount arena arenas assumed attempt attempts behavior bit block block's blocks bookkeeping brk byte bytes caller callers calling carrying char coarser combat common complete constant convey corruption crashes created curalloc curfree cursize dangling debugging defragment defragments dereferenced detected diagnose distinguish doing double e.g ease easier enables encompass entire entry enum error exceed exclusive external extra facility fills finished flags forgetting format fragmentation freed frees garbage grows happened i.e include innards int interface internal kernel's lastcompact leak leaks legal lesser libc libc.h lock locked locking logging logstack looking magnitude malloc malloc.c manage management markings maxsize mechanism memory merge mergeable message minarena minblock modifying move moved moves moving multiprocess newly nfree nil non notice notification notifies nsize nul obtains op or'ed orders output panic pointer pointers pool pool.c pool.h pool_antagonism pool_debugging pool_logging pool_noreuse pool_paranoia pool_tolerance pool_verbosity poolalloc poolblockcheck poolcheck poolcompact pooldump poolfree poolmsize poolrealloc pools port possibly previously print printed prints private programs protected provide provides ptr quantum receipt recognizing related releasing remains request requested requests resize retried retrieved return returned returns reuse rounded rounding routine routines runtime safely satisfied sbrk search setting setup size sizes slows smallest source space specifically specifies src strict strings struct structure style successful summary surrounding suspect sys tickles time total try tweaks typedef u.h ulong unallocated unchanged unlock unlocked unlocking unspecified unused user using valid validate value varies various vector via void volatile walk ways whenever wish written xalloc pool	2/pool
 0xff 1_000_000 1pub 1st 224466xxyyzz 246xyz 2nd 3rd 8th a_or_b aaa aabbcc abc abc123xyz abc246xyz abcd able absence accents accept access accidental acegibdfhj actions activities actual actually add adding additional additive address ae affect aft aggregates ahead alarm algorithm allows alone alpha alphabet alphanumeric alphas alternate alternatives amount anded angle anonymous anyway anywhere apart appended applications applies apply approximations aren't arg args argv arithmetic array arrays arrow ary ascii assertion assign assignable assigned assignment assignments assigns associativity assume assumes assuming auto automatic automatically avoid avoids aware awk az ba backslash backspace backticks bar bareword based baz becomes behave behaves behaving behavior behaviors bel bell beta beware bgreen bigger bin binary binding binds bistable bit bits bitstrings bitwise biz blank blessed block blurch bokeper bookkeeper boolean borrowed bracketing brackets bs bug built builtin burn burned c's can't canonicalize capabilities capable capitalized capture care careful carry cases casting cds ceil cgimosx ch char character characters chdir cheap checked chmod choose chop chosen circuit circuits cj class clean cleaner clear closing cm cmd cmp cnt code collation collected column combine comes comma command's commas comment comments common compare compared comparison compile compiled compiler complement complemented complete complex compressed computes concatenated concatenates concatenation concerns conditional confuse confused conjunction considerable considerations considered consisting conspire constant constitutes construct constructors constructs construed contains context contexts continue contrary contribute contributed control controls convey copy corners cost count countermand counting covered cr created creates cs csh cumbersome curly current customary cut cw dash dashes data date dates dc dealing debug decimal decrement default defined defines definitely delete deleted delimited delimiter delimiters depends deprecated dereference dereferencing descriptor desired details determined determines dev device devotees die differ difference differs difficult digit digits digraph dir direct directly directory discard discussion disjunction distinction distribution divides documentation documented documenting doesn't dog doing don't dos dots double doubles downward drivers ds due dummy duplicate duplicating dynamics e's e.g easier easiest easy echo ed editors eeg effects efficient eg egimosx embedded emit emulate emulates enclosed enclosing endpoint ends ensure entirely entry env environment eof eol eq equal equality equivalency equivalent error errors esc escape escapes escaping etc eval evaluate evaluated evaluates evaluating evaluation eventually exact exactly exceed except exceptions exchange exclude exclusive exec execute executed exit expand expansion expect expectations expecting expensive expensively explained explanation explicit explicitly exponentiation export expr expression expressions extended extra extracted failed failure false fashion faster feed ff fh fields fifteen file filehandle filehandles filename filenames files filetest filters final financial fine fixed fledged flexible flip floating floats floor flop flow folding folks follow foo forces fore foreach fork forms fp_equal frequently front full further furthermore future gamma gc ge generalized generated generic getopts getpwuid gets getting glance glob global globally globbed globbing glue glues gobble goes grave greater grep gripe grounds grouped gsx gt guaranteed gz gzip habit handle happens happy hard hardware hash haven't header here's hex hexadecimal hexdigit hide higher highest holding holds homeless honored host ht http hundred hy hyphen i.e idea identical identifier identifiers idiom ii illusion impede implement implementation implements implications implicitly imply in_body in_header include included includes incorporated increment indicates indirect inequality infinitely infix info inner input input_record_separator insensitive insert inserted inserts inside installed instance integer integers integral intend intending intermix internal internally interpolate interpolated interpolates interpolating interpolation interpolations interpretation interpreter invokes ip isn't it's item items iterates ja japh jun key kinds knuth language largest lasts latter le lead leading leaning learning leave leaves leftward legal length letters level levels lex lexicals lf libraries likes likewise limit limited lines list listed literal literally literals locale localeconv location log logdir logical login logo longer looking looks loop loops lot low lower lowercase lowest lt lts lvalue lvalues mac machine machines magic magical mail maintainers maintains man's manipulate manipulated manpage manual map match matched matches matching math::bigfloat math::bigint math::complex mathematical mathematician mauve mday mean meant memory mentioning messages metacharacters method minimal minus missing mistake mister mixed modern modification modified modifier modify modifying module modules modulus mostly multi multiline multiplicative multiplies mysterious na names native naughty ne necessarily necessary negated negation negative neither nest networking newline newlines newlist njunk nl noise non nonassoc nor notably notation note notes notice notion nt null num numeric numerically object objects obviously occasionally occur occurrence occurrences occurs octal odd oe ok okay older oldlist ones oo oops op opened opening operand operands operate operating operation operations operator operators opposite ops optimization option optional options ordering ordinarily ordinary ored output overload overloaded overrides package packages pair pairs paragraph parentheses parenthesis parenthesized parse parsed particular particularly pass passing patch path pattern patterns pays percent performs perl perl's perl4 perl5 perl_info perlfunc perllocale perlobj perlop perlre perlref perls perlsec perlvar ph physical pi pipe pipes pitfalls places plain platform platforms plus pod points poor port portable portion pos positive posix possibly potentially pow pp ppooqppqq practice precedence preceding precisely precision precompute predefined prefer prefix preserve preserving print printf printing prints process processed processing produce produces program.stderr program.stdout programmers programs promise propagates protect protecting protects protocols provide provided provides providing ps pseudo putting python qhost qq quote quoted quotes quoting quser qw qx qx'ps rand range rcsfile read readability readable readdir readline real reals reasonably recognized recompilations recompiled redirect redirections redo reduces reference regard regexp regexps regular related relational relationship relatively release remain remainder remember remembers removed repeated repeats repetition replace replaced replacement replacementlist replaces replicated represent representations represents reset resets restarts restrictions results return returned returning returns reverse reversed revision rexx rightward robust round rounding route routine row rule rules run runs safe safely safest saying scalar scanners scope screwy script search searched searches searchlist section sections security sed seem seldom selected selecting sentences separately separating separator sequences serious setlocale sh shell shell's shell_info shells shift shifted short shorter shortest shouldn't sign signed similar similarly situation size sizes skip sky slashes slice slightly smallest solicit sort sorts sp space spaces spacing specific specifically specifies speed split split's splits spool sprintf square squash squashed squashing ss standard stars starts stat static status stays stderr stdin stdout string strings stringwise stringy style sub subexpressions subject subjected subroutine subscript subsection substituted substitution substitutions substrings success successfully sum supplying supported supports supposed surrounding switch switches symbol symbolic syndrome synonym syntactic syntactically syntax systems tab table tabs takes taking 
 0xfffd arabic ascii atari big5 bit central character characters chinese cmd continues conversion convert converted converts correctly cp cyrillic czech date default deprecated described diagnostic dutch encoded encoding encodings error errors euc european file finnish forces format gb gb2312 generates gost greek guesses hebrew hku ibm ics input interprets iso japanese jis jp jx kanji koi koi8 latin list lists lv microsoft ms msdos ocs option original output particular pc plan plus portuguese prevents print processing recognizes reporting rune runes russian scandinavian shift slcv slovak source src st standard stream substituted summary supported supports sys tcs thai tis translate turkish ujis unicode unknown utf utf1 value variety various verbose version tcs	1/tcs
 0xffffffff accessed accesses acid activated active addition address addressed addresses advance advanced advancing alignment allocated allow allows alpha alternate append approximate architecture architectures argc ascii assigned associative assume assumed assumes asynchronously attach automatic backtrace bad base becomes beware binding bit bitwise breakpoint breakpointing breakpoints bss bugs byte bytes c'th calculate calculated caused causing character characters closed cmd code compared compiler complement condition conjunction consisting consists contained contains contexts continue continued continuing control controlled convention copy correspondence count counts cpu cputype create created ctl current data db debug debugged debugger debugging decimal decremented default define defining delay delete dependent diagnostics digit digits directory disassembling disassembly disjoint disjunction display division don't dot double due dumps dyadic e.g eight elided enclosed entered entire entirely entry environment equal error escape established evaluated examine examined examining except executable executed executing execution exist exit exp expression expressions extant external failed fetch fetched file files finding fire flag floating format fraction frame frames further halt heap hexadecimal i.e id identical image import impossible include incompatibilities increment incremented indicated initialized initially input instruction instructions integer integers interpretation ints kernel kremvax length letters limit lines list loaded location locations lower machine machines magic main main.argc manage management manufacturer's manufacturers map mapped mapping maps mask masked match matched matches mem memfile memory mipsco miscellaneous model modifier modifiers modify monadic motorola moves multi multiplication names nearest necessary negation newline nm non note notes null octal offset oh omitted operators optimization optimized option options output overlap page pair parameters parse parse:b path pc pending permitted pid plan plus precision prefixes print printable printed printing prints proc procedure process processes processor produces program's programs provide purpose quadruples radix range rc reached read reading received recently recorded refer region register registers relative released remainder remaining remote remotely repeat repeated repetitions represent reproduce requests reside resolves responses rest results returned returning returns rounded routine routine.name run rune runes running saved scheduled section segment segments select selecting sent series signed similar similarly simulate sixteen size skipping slots sometimes source sp space specifies specify src stack standard statement static status step stepped stop stopping stops stored stream string style subprocess subtraction sunsparc supports suppressed symbol symbolic symbols syntax sys tab table tabs terminal termination terminator test text textfile threaded times total translated translation type typed ublock unaffected unchanged undefined underscores unless unnecessary unsigned update upper using utf valid value values variable variables various via width write write:b writing xnn db	1/db
 1,wnohang 1pub able absolutely accept accepting accepts access accidentally accomplish acts actually add addison additional additionally address addressed addresses advantages ae af_inet af_unix affect alarm alien alive allocation allow alone alrm altogether amongst anonymous another's answer anyone anywhere apache appending approach archive aren't args argv arrive ascii assign assume assumed asynchronously author auto autoflush automatically avoid avoids awkward background backtick backticks backwards bad bailing bang bars based basic begat behalf behave behaved behaves behavior behaviour bell berkeley besides bet beyond bidirectional bin bind bit blank block blocking blocks blow bogus books broadcast broke broken browsers bsd buff buffer buffering buffers bugs building built bunch byte calling camel can't careful cares carp cases cat catch catch_zap catsock causing cavalier certainly cgi challenged chance chances chapter character chat chdir check checking checks child child's child_rdr child_wtr chld chomp choose christiansen circuits circumvent cld clean cleaning clear clearing clever client client,server clients clock clocks clone closed clunky cmd cmd1 cmd2 code coded coderef comm comm.pl command's common communicate communicating communication communications complete completely complex compliant complicated compromise concerned confess config configured conformant connect connected connecting connection connections connects consider constant constants construct constructor contains content continue continues contributed control convenience convenient conversion cookie copies copy core cornerstones correctly count covered cpan create created creates creating croak ctime current cw daemon daemonization daemonize danger dash data database datagram datagrams date daytime dce dead deal dealing declaration decrement default defensive defined definitely deleting delivered demonstration derived describes descriptors designed destination detailed details dev device devoted diagnostic didn't die differ differently directly directory discard dissociate dissociation distribution dns document documentation documents dodginess doesn't doing domain don't double driver ds due dummy dump dumps dup duplicate e.g earlier easier easy effectively efficient egid eh elaborate elsewhere elsif employ ended ends engineering english ensure entire entirely entrant env eol eq equivalent error essential etc euid eval events eventually everything exactly except exception exec execute executing exercise exist existing exists exit exited exiting expect expect.pm expected expecting expects explain explicitly exposing extend external facilities fail failed fails failure faq fashion fault featured feel fetch fetching fh fifo fifos file filehandle filehandles filename filenames fileno filesystem fill finally fine finer finger finished firewall fit flag flock flush flushed folks footnote forbid foreach forget fork forking forks fortune forward friendliness ftp full fully future games gateway generated generic gethostbyaddr gethostbyname getprotobyname gets getservbyname getting gid global gmt goes gotten grants grep guanaco.html guaranteed handing handle handler handlers handles handling hang happen happened happens hard harder hash haven't header hello here's higher hisiaddr hispaddr histime hitting holds honor hope host host.org hostinfo hostname hosts html http hup hurt hy i'm i.e iaddr iaddr,af_inet id idea ident identical ignore ignoring immeasurably implement inaddr_any included incoming increment index indexed indirect indispensable inet_aton inet_ntoa inevitable inherited input insist installed installing instance int integer intend intentionally interact interactive interesting interface interfaces interference internal internally internet interpretation interprocess interrupt interrupts intrepid involve involved io::handle io::pty io::socket io::socket::inet io::stty ioctl ip ipc ipc::chat ipc::open2 ipc::sysv ipc_creat ipc_key ipc_private ipc_rmid irrespective isn't it's item jump jun kernel key keyboard kid kid_pid kid_status kid_to_read kid_to_write kidpid kill knowing knows lamentably language languages larry launched leader learn leave length lenient lessens let's letting level levels lib libraries library likelihood limit limited lines list listed listen listing loathe localhost localport localtime lock locked log logging logmsg logo lone longer longjmp longjump looking looks loop lot low lower lowest lpr ls lwp mac machine machines mailer main malloc manner manpage manually master maximum mdt mean mechanism memory mentioned mercy message messages method mildly minus minutes misfortunate mk mkfifo mknod mmap model modems modern module modules more_functions motd multi multicast multihomed multiprocess multithreaded multithreading na names ne nearest nearly needed negative neither nervous net::hostent netstat network networking newer newline news nifty nis nisplus nntp nod,fifo non nonstandard nor note noted notes notice notreached noutta null numeric numerous object obvious occasional oct oe offers ok omitted ones oo open2 open3 open_proc opened opening opens operate operating operation operations opstring opstring1 opstring2 optimal options oriented original outlive output outside overhead overly pack packets padded paddr page pair pairs parameter parameters paranoiac paranoid parent parent's parent_rdr parent_wtr parentheses parlance particular particularly party pass passing patch path pcs peeraddr peerhost peerport pending perl perl's perlfunc perlipc perlmodlib perlsec perspective pf_inet pf_unix pf_unspec ph philosophy pi pick pid pid,0 ping pipe pipe1 pipe2 pipes plain platform platforms politely pop3 port portability portable porters ports posix posix.t possibly powerful pragmatic precious prefer preferring prepared prepending pretty prevent primitives principle print printf prints private problematic process process's processes processing prog_for_reading_and_writing programmer programmers programming programs progs promises prompt prompts protected proto protocol protocols provide provides providing proxy prudent pseudo ptty published purporting purposes queue quick quickly quietly quit quote qw raise random rcsfile re read reader readers reading real reallocate reaped reaper reasonable reasonably reasons received recent recommend record recv redirect ref references referred reflects regular reinstall reinstate related release reliability reliably remaining remarkably remember remote removed rendezvous reopen replace request requested requests require requires respect response responses restart restarting restored restricted retrieve return returned returns reuse revision rfc richard rin risks root rough rout routines rpc rtime ruin run running runs rw s_irwxg s_irwxo s_irwxu safe safely safest sample scalar schedule script scripts seconds secs_of_70_years section seldom select semantics semaphore semaphores semflag semget semnum semop send sending sends sent server server's server,pf_unix,sock_stream,0 server,somaxconn servers services session sessions setgid setsid setsockopt setting setuid setup severely sh share shared shell shell's shift shm shmctl shmget shmread shmwrite showing shows shucks sig sig_name sigalrm sigchld signal signals signame signature signo sigpipe sigs sigterm sigtrap silly similar similarly simpler simplest simply simulating simultaneously sit site situations size slave sleep sleep_count slightly slow smith smtp snazzy snmp so_reuseaddr sock sock_dgram sock_stream sockaddr_in sockaddr_un socket socketpair sockets software sol_socket solution solutions somaxconn some_data somebody someone something's sometimes somewhat soon source sp space spawn spawns speak specific specify spectacularly split spool spooler spread srw ss ssleay sss stack stand standard standards started statement status stderr stdin stdio stdout stevens stick stitch stop straightforward strange strategy stream streams strict string strings structures stuff sub subnet subprocesses subsection substr succeed success successor suggest suggestions suid superior superuser supply support supported supports surface swell symbol syntax sys::hostname sys_wai
 10,9,8,7,6,5,4,3,2,1,'boom 1pub abc able access accidentally acts actually add added addition additional ae ahead algorithm alias aliases aliasing allows ambiguity amode anywhere apart appendixb.html applications applied approach aren't argv arrange array ary ary1 ary2 assignment assumed attempt author autoload avoids awk backslashes bar barney based basic behave behaved behavior belief bell besides betty bin bit block blocks bounded bourne braces brackets break brevity browser bust bzzzt caller can't card careful cases catch causing certainly char character chomp christmas clauses cleaner code colon comes comfortable comma comment comments common compile compiler compound computed conditional conditionals confused consider consists construct context continuation continue continued contrary contributed control convenient count counters created csh curly current cut cw cybernetic dangling dash date declaration declarations declare declared declaring def default defined defines defining definition delimited deprecated described descriptor desperate details die difference dir directive directives discard discarded division documentation doing don't double dows ds dummy dynamic dynamically easier effects elaborate elaborated elem elsif embedded enclosing encounters encouraged end__ ending english entry env envariable eof eq equal equivalent error escapes especially etc eval evaluate evaluated evaluating eventually evilandrude.html exactly except excepting exception executed executes execution exit exiting exits exotic expect expected expecting expects explicit explicitly expr expression extend extent faint familiar faster file file__ filename filenames files final finds flag flags flow foo foreach forever format formats formatted former forms fortran forward fred freely generally gets glarch global goes goop goto hang hash head1 header heart here's hi highly holds homer horrors hp http http_user_agent hy i'm idea identifier identifies idiom imagine implicit implicitly implies imported include increment index indicate indicated initialization inner innermost input inside inspired interactive interesting intermix intermixing interpretation intervening ip isn't it's item iterates iteration iterator jargon jet jun keyword knows label labeled labels language leave lend levels lexical lexically lie line__ lines linux linux.html list load loaded localized location log logo longer looking looks loop loop's looping loops lvalue lying mac macintrash.html magical maintainability mandatory manpage marge matches matching mechanism mechanisms merely merry mes messages microslothwindows.html middle minor modifications modifier modifiers modify modifying mom msie myname na names namespace naturally ndie ne necessarily neither nice noisy nor note nt nuff null o_append o_creat o_rdonly o_rdwr o_wronly objects obvious occurrence oe official omitted on_a_tty operation operator operators optimized optimizing optional optionally ordinary outer page pair paragraph paragraphs parsing particular particularly pascal pat patch pattern perl perl's perlfunc perlmod perlpod perlsyn pi pick pickier plain pod podded pods popular possibly preprocessor preprocessors presuming pretend previously primary print private process processed processing programmer programs prompt propagated proper prudent push pyrotechnics qq quickly quote quotes rapidly rcsfile read readability realize reasons recommended record redo refer refers regains regard regular rely remaining remove replace replaced report require required requires reset resolved resorting restart restarts resumes return reversed revision routine rulings run running safer saying scope scoped script scripts scumos.html secret section sections sed semantically semantics semicolon sh shell shift short shouldn't sign similar skip sleep snazzle sometimes sorry sort source sp speaker spectacular splice split ss stack stands starts statement statements stdin stdout straightforward strange string strings structured structures stuff style sub subroutine subroutines subsection substitutes sunos support sux.html switch switches synonym syntactic syntax synthesizing takes target temporary termcap termination terms test tested text th that's therefore they're thingie third throw tied time title tr translation translators triggers type typically unary unbreakable undefined uninitialized unknown unless unlike user using usr usual ux valid value values var variable variables version via visible warn warning warnings ways webtv whereas wid wilma win wish won't works write writing written www.wins.uva.nl xx xxx xyz yes you'll you're perlsyn	1pub/perlsyn
 10:05pm abandoned abandoning able absolute accepted accepts accessed acdf achieved activities activity acts actual actually add added adding addition additional additions admin administration administrative affect affected ahead al algorithms alias allow allowing allows alnrqq alone alpha alter alternate ancestor anticipate anyway applied apply approach april arbitrary archive args arrives artifacts assign associates assorted attempt attempting attesting attic author authors automatically avoid avoided backup base based behavior benefit berliner binaries binary bindir bootstrap brackets branch branches brian brief bring bugs builds built bypass bypasses cancel care careful cd cederqvist central characters checked checkin checkin.prog checking checkout checks chosen ci clean client co code coder collection collections collisions colon combination coming command's command_args command_arguments command_options commit commitinfo,v committed committing common communication comp.sources.unix compare compared compiled completely comprehensive compress compression concurrent conditions conflict conflicting conflicts connection consider consisting constrain consult contained contains context continue continues contribute control controlled convenient copied copies copy copyright correct correspond count create created creates creating creation credited current cvs cvs.html cvs.lock cvs.ps cvs.rfl cvs.texinfo cvs.tfl cvs.wfl cvs_command cvs_ignore_remote_root cvs_options cvs_root_directory cvs_rsh cvs_server cvsbug cvseditor cvsrc cvsread cvsroot cvswrappers cvswrappers,v data database date date1 date2 date_spec dates de december declare default defaults defined definitions delete deleted deletions deliberately delta depth describe described describes descriptions design designer detail detailed details detected determine developers device dick diff differ differences differs diffs dir directly directories directory disabling discards display displayed displays distributed distribution distributions disturbing documentation doesn't doing don't dot dots dqq dt duplicate e.g easier east edit edited editinfo,v editing editor effectively electronic elicits eliminate enable enabled encrypt ends enroll enrolled ensure enter entire entries entries.backup entries.static environment environments equivalent erase erasing error essential et etc everything exact exactly examined except exception execute executed executes executing execution executions exist existing exists exit expanded experimental explanations explicit explicitly explore export expr1 extract extracted extracting extreme extremely facilities faster fcs1_2_patch features fed file file's files filtering finally finding finds fixed flag flags foo.c forget forgotten format formats fortnight freeze full fully further future generate generated global gmt gnu gone grep ground grune gzip hack happened hard haven't header helped helps hierarchical hierarchies hierarchy highlight historical hours http i.e idea identified identify ignore ignores ignoring immediate impact implicitly implied import imported include incorporate incorporating index.html indicate indicated info informational informed init initialisation initialize inside instance instructs intend intended intentionally interested interface interfering internet intervened invocation invoked isn't iso isolated issue issued it's january jeff jsymbolic_tag:date_specifier jtag jtag:yesterday kb keeps kept kerberos keyword keywords kflag kinds kl ko kv larry latest leading leave leaves leaving letters level limit lines link list listed listing lists lnnqq lnr locally locate located location lock log log_message logging loginfo,v logs looks lose losing lppqqr lqqr lr lrqq lt mail main manage management manpage manual master match mean meaningfully meanings meant mention merge merged merges merging message messages method minutes missing mixed mkdir modification modifications modified modifying module modules modules,v molli monday month move moved names nearest necessary needed needs network new_directory newer newly non note notify numeric numerous object obsolete occurred offsets older omit omitting operate operates operation operations opportunity option optional optionally options original output outputting outside overall override overrides overwrite particular particularly parties party patch patching path pathname pathnames paths patterns pending perform performed permanent permanently permit permitted perturbing physically pid pipe piping polk populate posted postscript potential precisely prefaced preliminary prepare prepared presence prevent previously principal printing prior private procedure process processed processing produce produced producing product product_module programs progress project provides prune pst publish purge purpose quiet ranges rcs rcsbin rcsdiff rcsdiff_options rcsinfo,v rcsmerge rdiff re read reading reads received recent reconcile record recorded recording records recurring recursion recursive recursively references referring refers reflects reformat regardless related relative release released releases releasetag remains remember remembers reminder remote removal remove removed rename repeatedly report reports repositories repository reproducing request requesting requests require required requires requiring reset resolution respect respective restrict resulting results resurrect retain retrieve retrieved rev rev1 rev2 revision revisions rexpr1 rfcs1_2 rfcs1_2_patch rfreeze rich ridden risk rlog rm root rsh rtag run running rv safeguard safely satisfy saved sccs scenario scheduling scope script search searched seconds section seeing select selected selection send sensitive sent sep serious server setting shell ship shipment short shorten shortening shortens shouldn't showing shown silently similar simpler simply site situation situations snapshot software someone sometimes somewhat sorted source sources sp specific specification specifications specifies specify specifying stand standard stands started starts startup status steps sticky stored str strictly string stuff style sub subdirectories subdirectory succeeded succeeds successfully sufficient summary supply support supported supporting supports suppress suppressed suppressing symbolic symbolic_tag synchronized synonym synonyms systems tag tagged tagging taginfo,v tags target tells templates temporary texinfo thereby therefore they're third time timezone tp trace tracks transactions transferred transferring triggers trunk try trying twice type types typical typically ucb un unchanged unfamiliar unfortunate unidiff unless unlike unmodified update update.prog updated updates updating usage user user's users using usr usual utc utilities utilize valid validating valuable value variable variables variant variety various vendor vendortag verifies version versions vi vn void volume6 wall wanted warning ways wealth whatever whatever_module whenever wholesale wide wish working works wrapper wrappers write writing written www.cyclic.com www.loria.fr xmacfrogwut yesterday you'd you're you've zone cvs	1pub/cvs
 12h34m 9fs abbreviations abell abell1701 add alcyone alllabel alpha altitude angles appended approximately arc arcseconds ascension ast asterism astro astronomical astrophysical atlas azimuth becomes betelgeuse bit black blank block box brief bright brighter brightest brightness catalog catalogs catalogue catalogues cd center centered centers chart circles class classes cluster clusters cmd code collect collects color comet compact complement constellation constellations constelnames converting coordinates copyright corporation correct cost cover covered cross crts cull current data database dec declination decsize default defect degree degrees depth descriptions designations designed details digitized dim discover disk disks display displayed displays distance distributed double draw drawn drop dx dy e.g earth's eclipse ellipses except executing execution expand extent externally eye files finally finder flat flatten flattening flattens flight format formats full galactic galaxies galaxy gamma gb getmap globular goddard greater greek grey gx hardware hd holds horizontal ic1234 identified identifies identifying images implements improving index inferior input insensitive installed institute's interface it's item items juke keeping keyed knot kt labels larger latitude lcd leading legibility lesser letter letters lib lines listed listings location locations longitude looks lookup lower lunar magnitude magnitudes manipulations map mapped mars maximum meager megaparsecs member messier messier's minutes moon motion multiplicity naked names nasa nb nearest nebula nebulosity nebulous necessary negative ngc ngc1234 ngc1300 ngc2000.0 nogrey nogrid nolabel non nonexistent nonstellar notation object objects oc omitted option options ori orientation orients orion output outside partial patch patches pd penumbra permission phase photographic pixel pixels pl planet's planetary planetarynebula planets plate plates pleiades plot plotted plotting popular population positions positive precisions prefix pretty print prints proper provided provides publishing q.v quotes ra radius range ranges rasize read refer references region remember representative represents richness rom roms run running sao sao12345 scale scat science screen section series shadow shown size sizes sky smithsonian solar source space specific spectral spelled square src standard star stars stippled stored sufficient suitable sun superior suppresses survey symbols sys telescope tenth thin time times touching translated triangle triple trouble try type types umi uncertain understood unknown unlabeled unverified upper uranus usual value values variability variable vertical visibility visual wider window zenithup zwicky scat	7/scat
 14th 1pub able abnormally absolutely access accessed accesses accessible accessing actual actually add adder addition additional addresses addsubtract adequate advantage ae allocated allow allows alpha alternate alternative anonymous anyway apart api append appended appending applicable application application's applications apr aren't argv arise array array_asynch_close array_asynch_read assist assisted associates assumed assumes assuming asynch_close asynch_read asynch_read_if asynchronous attempt attempts attention author automatically avoid aware ax behavior bell belongs beta bfsec.bt.co.uk bit bless block blue bottom boundary bracketed break buffer bug bunce button bypass call_adder call_addsubscalar call_addsubtract call_addsubtract2 call_fred call_inc call_leftstring call_method call_printid call_printlist call_printuid call_subtract callback callback1 callbacks calling callsavedsub1 callsavedsub2 callsubpv callsubsv can't care cases catch cautious cb1 char character characters check checking checks choice chosen circumstances class classic cleaning cleanup clear cluttering code coding combination common compile complain complete completed completeness completion complex computes concerned condition conjunction consider considerably considered consist consistent consists constructor consume consumes context continue contributed control convenient conventions converted copied copy corresponded corresponds count covered create created creates creating creation croak current cursor cvrv cw dash data date deal dealing declared declares deeply default define defined defines definition definitions delta dependent described describing designing desirable destroy destroyed destructor destructors details detected detecting determine determining diagram didn't die die__ dies difference direct directly disadvantages discussed discusses discussing display dispose disposed distinct distinction document documentation documents doesn't doing don't double driven drop dropped ds dsp dummy dump duration dying e.g ease easier effects eh embedding enclosing encounter ending ensures enter entirely entry environment equivalent error errors errsv essential eval event events eventually except exception execute executed executes executing exist existing exists exit exiting expect expected expecting expects explain explicitly extend external extreme facetious fail failure fairly false fatal feature fh figuring file final finally fine finished firstly flag flags flexibility flow fn fn1 fn2 fn3 fnmap foo foreach fprintf fred freed freetmps full functionality further future g_array g_discard g_eval g_keeperr g_noargs g_scalar g_void gamma gets gianniotis gimme gimme_v global goal goes greater green gurusamy gv handle handler handlers handling hanging happen happened hard harm hash haven't header hello here's higher holds hooks hope hv hv_delete hv_fetch hv_store hy hypothetical i'm i.e idea ideal identical identically identification identifies iff ignore illustrated illustrates implement implementation implements impossible inc include inconsistent increase increments index indicate indicates initializes inside instance int integer intending interested interface interfacing internal internals interpretation introduced invoke invoked invoking ip isn't item items jeff joe jun kapow keepsub kelem key knowing knows larry launch leak leave leftstring let's letting levels library likely limit limited lines list log logo longer lot loudly macro macros main main::47 manage manipulation manpage map mapping mapstruct marquess mask max_cb mean meant mechanics mechanism memory mental mentioned menu message messages methname method methods mine mixed modification modified modifying mortal mortals mostly mouse moves na namely namespace nasty ne necessary needs negative nested newhv newsviv newsvpv newsvsv nick none note notes notice noticed noting null null_handle null_index object obtain obvious occur occurred occurs oe oh okamoto older onto opened operates operation options or'ed original originally outermost outlines output overcome overwrite overwritten package pair pairing parameter parameters particular particularly pass passing patch paul pay pcb pcb1 perfectly perl perl_call perl_call_ perl_call_argv perl_call_method perl_call_pv perl_call_sv perl_eval_pv perlcall perlembed perlguts perlobj perlsub perlxs pi pkg::fred pl_errgv pl_na pl_stack_base plus pmarquess pointer pointers points pop popi popl popn popp popped pops possibility potentially practically practice predefine prefixed preform preserve pressed previously primary print printcontext printed printf printid printlist prints printuid problematic process processing processread promptly provide provided provides purpose pushed pushing pushmark putback quickly quote random rcsfile reach read reads real reallocated recoded recognize recompiling recorded red ref refer reference referenced references referred refers refresh regains regardless register register_fatal registered registers reliable remember remembersub remove removing repeated replace requested require required reset resetting rest restore results retrieving return returned returning returns reverse revert reverts revision rid routine rule sarathy save saved savesub1 savesub2 savetmps scalar scenario scope script secondly section sections seem selected self series setting settings sh shift showed shown shows signal similar similarly simpler simplicity simply simultaneously situation situations sizeof sketched slightly snippet solution someone sorts sp space spagain specific specifically specify specifying ss st stack stage stands statement statements static stderr steve stop store stored storing straightforward strategies string strings struct stuff sub subname subroutine subroutines subsection substr subtle subtract suitable sum summarize surprisingly surrounding sv sv_2mortal sva svb sviv svpv svrefcnt_dec svs svsetsv svtrue symbol symbols symptom table takes talk technique techniques tells temporaries temporary terminate test th thanks thereafter thereby therefore tidied tidy tie tim time title topic tr tracked translation trap trapped trickiest trivial trouble try twice type typedef types typical typically uh uid unbreakable uncertain undef undefined understand unexpected unlike unlimited unqualified updated upgrade user user's using usual value values variable variables version via virtual void vulnerable wait wall wantarray wanted warn__ warned warrants we've whatever whenever wherever whilst window windows wiped wired workable working works worth wouldn't wrappers write writing wrong xpush xpushs xs xsub xsubs xx yourself perlcall	1pub/perlcall
 1:1:bcd:def 1pub 4::abc::xyz 5.001l,m a','b','c a,b,c a,b,c,d,e a1,&sub1,&sub2 a2p aaa aab aac ab ab','abc','bcd','def ab:abc:bcd:def ababab abc abcd abcde abcdef aborts accept accustomed achieve actual actually add added additional additionally address ae affect aglobal akey alias allows always_ anewlocal angle anonymous anywhere apparently append arbitrary archaic arg argc argv arithmetic arr array arrays assign assigned assigning assignment attached attaches attempted auto automatically avoid awk baby backreferences backslash backslashes backtick backticks bar bareword barewords basically baz bcde becomes behave behaves behavior behaviors believe bell best.com biggest bill bind binds bit blah block blocks brace braces brackets break bug bugfix buggy bugs build build_match builtin builtins buz c's caller camel can't capitalized careful carriage catch caught cerebral character characters chdir chop class classed clobber closure closures code colon comma commas comments common comparisons compatible compile compiled compiler compiles complement component concatenation condition confused consistent constant constants construct constructs context contexts continue contributed control conversion converted copies core correctly couldn't count created creates creation crudely csh curlies curly current cw darn dash data databases date db dbm dbmopen deal debatable decide declarations declared default defined deleted delimiter demonstrated deprecated deprecation dereference details determine didn't die dies differ differently differs digit digits discarded discards discern discontinuance discontinued division do.pl documentation documented documents doesn't doit doit.pl don't double doubt ds dummy dumps dynamic e'print e.g earlier easy effects efficiency elsif encourage ending ends english entire environment eof eq equality equivalent errno erroneously error errors especially etc eval evaluated evaluates evaluation everything exceeding except execute executed executing execution exhibits exist existence existing exit expand expansion expect expected explicitly exponentiation exported expr expressed expression expressions extension external fail fails failures false fatal feature feeling fh fields file filehandle filename files final fine fixed fld fly fmt fnr foo foo.pl foobar fopen forced foreach forgetting fork format formats formatted front fs full funkiness future generally generated glob global globallevel globs gotit goto grep grpc guaranteed handle handled handler handlers happens happy hard hash hashes hashname hasta header hello hi hi:mom holds hostname hpux hy iff ignore illegal immediate implement implementation implementations impossible inadvertently include includes inclusion incompatible inconsistencies incorrect increment index indices infinite ing input inside inspection instance int integers intent interpolate interpolated interpolates interpolating interpolation interpret interpretation involving ip isn't it's item items iterate iterating join jun key keys keywords kill knows la ldbm leads leaves legacy legal length lets level levels lhs library likewise limit lines link linked list listed lists literal lndbm loaded localize localized log logical logo longer looking looks loop lost lower lowercase m?once m?x magic main main'foo main'seeya main'x main::1 main:global manpage map marker1 match matched matches matching math::bigint mathematical mere messages metacharacters middleton minus mistakenly mod modification modifications modify module mom mysterious na names ndbm ne near negation negative newline nf nope not_ notation note nr null numeric numerical occur oe officially ofmt ofs ok older one's ones onto op opened opening opens operands operated operation operations operator operators opt optimized ordered original ors os oses output overwrite package packages parentheses parenthesize parse parsed parser parses parsing particularly pat patch pattern patterns perl perl4 perl5 perl5.003 perl5.004 perldata perldelta perldiag perlform perlop perlrun perltrap perlvar pi pid please plus positions practice practicing precedence preferred presence print printed printf prints programmer programmers programs properly protected push pushed qq qualifier quote quoted quotes quotish rang range rc rcsfile re read reading readline real record recover recovered refer reference references refers regard regular related relationship rely relying remain remember remembering removed rename render rep repeatedly replace represents require required requires reset resulting retain return returned returns reverse revision reworked rhs rlength rs rstart rule rules run runnable running runs s'd says scalar scalars scope scoping script scripts search searched seasoned section sed seek seek.test sees seeya segv segvs semantic semantics semicolons sensitive separator separators setting sh sharp shell shells shift sig sigaction signal signals signed significant sigterm silently similar similarly size slash sleep slightly snippet solaris sole someone sometimes somewhere somewhere.com sort sorting sp space specific specification specify splice split spring sprintf sprintf.t ss standard start,0 starts statement statements stderr stdout stem store strict stricter string strings stripped stuff sub sub1 sub2 submit subroutine subroutines subscript subscripts subsection subsep substitution substitutions substr substrings subtraction success suicide supported switch symbols syntactically syntax sysv table taking target temporary term terminator test test.pl testdb tests text th that's theargument there's they'll they're thinks third tie tighter tightly time title tmp to:someone tokenizer tool tr translation trap trappiness traps treats tries trivial type types unary unbreakable unclassified unconsciously undef undefines undocumented unescaped unforeseen unless unlike unlink unparsable unwary usage useless user users using valid value values var var::abc::xyz variable variables variants version versions via viewer vis vista void vs w.r.t w.w.w ward warn warns wary watch whatever whenever whitespace widths wjm won't works write written www xor xx xxx xxxx you'll you're yourself yup perltrap	1pub/perltrap
 1kb 32vfs 4kb archival attached berkeley block ca cmd constructed cpio cpiofs data default derive disk edition era ffs fifth file files flag flags format formats fs fs.c highly id images inquiries interpret interprets introduces mapping media mount mountpoint numeric optional passim passwd password plan pre ramfs raw read reported research section seventh sixth size source specify src status stereotyped stored strings substantially sys systems tap tape tapefs tapes tapfs tar tarfs tenth tp tpfs traditional unix user using util.c v10fs v6fs vax tapefs	1/tapefs
 1kb 32vfs 4kb archival attached berkeley block ca cmd constructed cpio cpiofs data default derive disk edition era ffs fifth file files flag flags format formats fs fs.c highly id images inquiries interpret interprets introduces mapping media mount mountpoint numeric optional passim passwd password plan pre ramfs raw read reported research section seventh sixth size source specify src status stereotyped stored strings substantially sys systems tap tape tapefs tapes tapfs tar tarfs tenth tp tpfs traditional unix user using util.c v10fs v6fs vax tapefs	4/tapefs
 1ms 200ms 40ms 80ms arrows bars behavior behavor black blocking blocks character choosing cmd colored consequence cost costs current deadline deadlines decimal default defaults desirable dir directory display displays effort empted event events factor file files fixed flag flags green indicate log machine ms nblog non ns ones optionally pause periods pre prints process produce quit reaching real realtime received recognized red releases represents results resume rtstats run running runs shown shows source specification specify src sys task tasks thin time timedev times units version window yielding zoom rtstats	1/rtstats
 1multiple 1pub 2nd 2use 3.the 3use 4th 4use 5another a2p abbrev abbreviation abbreviations abort abs absolute abstract abstraction abuse accept access accesses accessing accessor accumulator acknowledgments acos active activestate actually add added addhistory adding additional additive addr,addrtype address adds addset ae affect africa afs aggregation alan alarm algorithm alias aliases align alignment allocation allow alphabetical alter alternate am ambiguous america amounts anatomy anchored andreas angle anguish anonymous ansi anydbm_file aol.com apache api append appending applepi1 application applications approx approximate april aptr arbitrarily arbitrary architecture archives archiving aren't arg args argv arithmetic array array,list array,offset array,offset,length array,offset,length,list arraydepth arrayref arrays arrow article arybase as400.rochester.ibm.com ascii asctime asia asin ask assemble assert assigned assigning assignment associative assumes assuming async atan atan2 atari atexit atof atoi atol attacks attribs attribute attributes attrs australasia auth_type authentication author authors auto auto_abbrev autobundle autocreating autoflush autogenerated autogeneration autoload autoloaded autoloader autoloading automate autosplit autotrace autouse auxiliary av av_clear av_extend av_fetch av_len av_make av_pop av_push av_shift av_store av_undef av_unshift availability avfill avflags avoid avoiding avs awk axis.se b::asmdata b::assembler b::av b::bblock b::binop b::bm b::bytecode b::c b::cc b::condop b::cop b::cv b::debug b::deparse b::disassembler b::gv b::gvop b::hv b::io b::iv b::lint b::listop b::logop b::loop b::magic b::nv b::o b::op b::pmop b::pv b::pvlv b::pvmg b::pvop b::rv b::showlex b::stackobj b::sv b::svop b::terse b::unop b::xref backend backends background backslash backslashed backslashes backticks backtrace backtracking backward bad bag'o balanced bar bareword barwonwater.vic.gov.au base base64 base_core base_io base_loop base_math base_mem base_orig base_thread based basename basetime basic basis baud bblock bbs behavior behaviour bell belong benchmark berkeley berlin.de bidirectional bigger binary bind binding binmode bishop bit bitmap bits bitwise blank blanks bless blessed blessing blib block blocking blocks bnf book books boolean boot bootstrap bot bottom bottom_gv bottom_name boundary break brief broken browse browser bs bsearch bsloadlibs btree buckets buf bug bugfix bugs build built builtin builtins bunce bundle bundled bundles bundling bundling_override button buy bval byte bytecode byteload_fh bytes c2ph c_args c_cc c_cflag c_iflag c_lflag c_o c_oflag cache callback callbacks caller calling calloc can't can_read can_write canonical canonpath capitalization capitalize capture card care carp carriage cartesian_to_cylindrical cartesian_to_spherical cascading cases cast_i32 cat catch catdir categories category catfile caveat caveats cc ccdlflags ccflags ccopts cd cds ceil certified cflags cgi cgi.pm cgi::apache cgi::carp cgi::cookie cgi::disable_uploads cgi::fast cgi::post_max cgi::push cgi::switch cgimosx chain chaining char character characters chdir check checkbox checkboxes checking checks checksum child child_error chmod chomp chop chown chr christiansen chroot chunks ci circle circular class class::struct class_name classes classname clean cleaning cleanup clear clearallcache clearcache clearerr clickable client clients clobber clock closedir closelog closure closures clustering cmd cmp cnation.com co code codehashref coerce coercing cog collation collection color columns comma commandline commas comment comments commercial common communication communications comp.lang.perl.misc compactdump compare comparison comparisons compartments compatibility compatible compilability compile compiled compiler compiler's compiling complain complete completely completion complex compliant compound comppadlist compression compute computed concatenation conceivable cond_broadcast cond_signal cond_wait condition conditional conf config configuration configure connect consecutive consider const_cccmd const_config const_loadlibs constant constants constrcutor constructing constructor constructors constructs contains context contexts continue contribute contributed contributors control conventions conversion conversions convert converting converts convex.com convince cookbook cookie cookies coordinate cop_seq copied copy copyright core correctly cos cosh count counts cp cpan cpan.pm cpan::config cpan::firsttime cpan::nox cpan::shell cpanox cpu cr craig creat create creating creation credit credits croak cross crypt csb csgrad1.cs.wvu.edu csh cstring ctags ctermid ctime curdir current curses curtis cuserid custom customization cv cvgen cvstash cw cwd cylindrical_to_cartesian cylindrical_to_spherical da daemon dahmen dangerous dash data data::dumper data::dumper::bless data::dumper::deepcopy data::dumper::freezer data::dumper::indent data::dumper::pad data::dumper::purity data::dumper::quotekeys data::dumper::terse data::dumper::toaster data::dumper::useqq data::dumper::varname data_ database databases datatypes date date_flag dates david db db_btree db_file db_hash db_recno dbcmd dbm dbmclose dbmopen dbms dc debug debugger debugging decimals declaration declarations declare decode decompress decrement deep deepcopy def_timeout default define define_optag defined defines definitions del delay delegation delete deleting delfosse delim delimited delimiters delset demand denial deny deny_only depend dependencies dependent deprecated deprecation depth dequeue dequeue_nb derivatives derived desc described descriptor design destination destroy destructors details detected detecting determination determine determining devel::selfstubber develops device dfas diagnostics dictionary didn't die dielevel difference differences difficult difftime digifix.com digit digits dir dir_target direct directive directives directories directory directory_tree dirhandle dirhandle,expr dirhandle,pos dirname disable disablecache disabling disappeared disassemble disclaimer discontinuance dispose dissociation dist dist_basics dist_ci dist_core dist_dir dist_test distances distcheck distclean distdir distinction distname distribute distribution distributions distributive div division djgpp dl dl_funcs dl_vars dlbase dlsyms dm dmark do_binmode document documentation documenting documents doesn't dogwood.tyler.wm.edu doing dollar domain domainname don't dorigmark dos dos,nt double doug dougm download dp dq dr drawing driven ds dsp dst dt due dummy dump dumpdbfiles dumper dumperx dumping dumppackages dumpreused dumpxs dup dup2 duplicate dxsargs dxsi32 dynaloader dynamic dynamic_bs dynamic_lib e.g easily easy ebcdic ed edit edition editor effective_group_id effective_user_id efficient efficiently eg egid egimosx egv elaborate eliminate_macros emacs embed embeddable embedded embedding employees empty_opset emptyset emulations emx enable enablecache enabling encodings encrypted encryption end_ endgrent endhostent ending endnetent endprotoent endpwent endservent engines english enhancements enqueue enter entire entries env environment eof epoch eqtime equality equivalent equivalents errno errno.pm error errors especially establish etc euid europe eval eval_error evaluating event examining except exception exceptions exclude_ext exclusive exe_files exec execl execle execlp executable_name execute execv execve execvp exescan exist existence existing exists exit exited exp expand expect expected experimental expiration expires explicit exponentiation export export's export_list export_ok exportable exported exporter exporting exports expr expr,length expr,limit expr,list expr,offset expr,offset,bits expr,offset,len expr,offset,len,replacement expression expressions extend extended extended_os_error extending extensible extension extensions external extliblist extra extract extraction extralibs extutils::command extutils::embed extutils::install extutils::installed extutils::liblist extutils::makemaker extutils::manifest extutils::mkbootstrap extutils::mksymlists extutils::mm_os2 extutils::mm_unix extutils::mm_vms extutils::mm_win32 extutils::packlist e
 1pub 1st abc:def:ghi abcdefghi absence accumulator actual actually added adding additional additionally advanced ae alarm alias allocate alternative analogues ansi api appended applies apply arg argv array arrays arrives assign assigned assigning assignment assume assumed assumes attempt attempted attribute autoflush awk backtick backtrace bad bang bareword based basetime behave behavior bell belongs binary bits blindly block blocks borrowed boundaries bracket break broken brother buffer buffered buffering built c's calling carp carp::confess cases casual caught causion caveats cdrom channel character characters checks checksumming child child_error chld chop chosen circumvent closed code collected colon comma compile compiled compiler completion condition conditions config configuration confusing consecutive consider considered consists constructs contains context continuation continue continues contrast contributed convenient copy core correctly correspond counting criterion crt current cw dash data date dbl_dig debug debugging decided def default defaults defined delimit delimiter delimiters delivery depend dependent deprecated described describes descriptions descriptor descriptors details detected determine determined die die_ die__ died differences differing differs digits directive directly directory disable disabled discouraged disincentive distance documentation don't double dperl_emergency_sbrk ds dummy dump duplicate ed edit editing editors effective effective_group_id effective_user_id effectively egid emergency empties emulate emulation enable enabled enclosed english enter entries entry env environment eof epoch equivalent errno error errors etc euid eval eval_error evaluate evaluated evaluating evaluation evmserr except exception exec executable_name executed executing execution exit exited exits explanation explicit explicitly expr expression extended_os_error extension external extra extreme fail failed fails failure false fashion fatal feature feed fh fields file filehandle filename files filetests fill finally fine finished flag flags float.h flush foo forced forces foreach format format_formfeed format_line_break_characters format_lines_left format_lines_per_page format_name format_page_number format_top_name formats formline fortran forward further future generally getegid getgid getgroups gethost getlasterror gid goto gotten grep groups h_errno handful handle handler handlers handling happen happening hash hashes header hearted hidden hiding higher hints holds hook hooks horizontal hot hy hyphens id identical ignore ignoring illustrate implicit implicitly imported inc included inconsistent increase index indicated indicating indicator indicators indirectly influence influences info ing initially inplace inplace_edit input input_line_number input_record_separator inside inspections install installed instance int intended interactive internal interpolate interpolated interpretation interpreter interrupted invoked ip it's item iterator join jun kernel key keys ksh lame last_paren_match length levels lib libdir library lines lines_on_page lines_printed list list_separator listed literal load loaded localizing location log logo looking loop lower machine machines macperl macro main::plumber malloc manpage map match matched matches matching maximum mcarp mean mechanism medium membership memory mentioned message messages method methods minus mnemonic mnemonics mode modern modifiers modifies modify module multi multidimensional multiline_matching mypath na names ne nested nevertheless newline newlines non note notion notions nr nroff null numeric object obscured obvious oe ofmt ofs ones oops operating operation's operations operator optimizations optimizing option optional ord ordered ordinarily ordinary ors os os_error osname output output_autoflush output_field_separator output_record_separator outputting outside overwriting package page pairs paragraph parameters parentheses parsed parser parsing particular particularly patch patchlevel pattern patterns perform performed perl perl's perl_version perldb perlform perlfunc perlipc perls perlsub perlvar pi pid pipe pipes piping places platforms plumber poetry points pool portable positive posix posix::sigaction postmatch pragma precedes preceding predefined preferably prematch presence preserve preserved pretty primarily print printable printed printing prints probable problematic process process_id processes processing produce proggie program_name programs properly prototypes provided provides ps punctuation purpose quit quote quoted quoting raise range rcsfile re read reading real real_group_id real_user_id reasonable recommended record refer reference reflect regardless regexp related relevent reliable remember repeat report reported reports represent representing require res resets respect rest restore results return returned returning returns rev revision routine rs rsh run running runtime sa_restart safe safely save scalar scary scoped script scripts search searched searching seconds section seek sees segfault selected semi semicolon separator setgid setgroups setregid setreuid setting setuid sh shells short shouldn't shown shutting sig sigaction sigalrm sigchld sign signal signal_h signals sigquit similar similarly simply simultaneously slice slightly sole somemod sometimes somewhat source sp space spaces specific specifies specify ss standard statement status stderr stdin stdout step strict string strings sub subject subpattern subprocess subroutine subscript subscript_separator subscripting subscripts subsection subsep substr substring subsystem successful summary supplanted support supported supporting supports suppose suppressed swap swapped switch switches symbolic syntactic syntax system's system_fd_max systems tabs tells terminal test tested tests th that's third thrown time times title tr translated translation trappable tray treat treating triggered try types typically ug uid unary unbreakable undef undefined underline understood unix unless unlink upper user using usr usual value values variable variables various verbose version versions via vms vmsish wait warn warn_ warn__ warning warnings whatever whitespace win32 wish works write wrong xx yeah yields you'll you're you've yourself perlvar	1pub/perlvar
 1pub 2nd able access accessed accesses accessing actually add additional address admittedly ae aesthetics aggregate al allow allows alternately anonymous anyway anywhere apache array arrays ary assign assigned assigning assignment attempt attempted attention author automatically auxiliary avoid bad becomes behavior bell berkeley beyond binds bit bless blessed blow bound bounded_array bounded_array.pm bounded_array::fetch bounds bsd::resource buf buffers bugs built caller calling can't caps careful carp carrying cat certainly character chdir check checks choose chosen christiansen class classes classname clean cleaning clear cleared clobber clobberable closed closedir code collected collection comment comments complete completeness complexity concept concerned confess config connect consider constants constructor constructors content contributed contrived convenience convention correct couldn't cpan create creating creation croak cshrc cumbersome current cw daemon daemon_dots dangerous dash data database date db db_file dbm dbminit dbmopen dealing deallocates debug debugging decided define defined defines delete deleted deletes deleting demonstrates dereference described destroy destroyed destructed destructor details didn't die differ dir directory discussion disk distinctly distinguishes dns.ufsia.ac.be documentation don't dot dotdir dotfiles dotfiles.pm double doubt doubtless doug dougm ds dummy e.g easiest easily easy efficient elt embedded emit empties emulate enchanted eperm equals equivalent error ersch especially et except exception executed exist existence existing exists expected expects experimental explicitly extend extra fail failed fails feel fetch fh fields file file's filehandle filehandles filename files filetest firstkey fixed flag flushed fmt foo foo,'shout foreach forgiving format fred garbage gdbm generic getc getppid getpriority getpwnam getpwuid gets global goes gotcha greater grep guard handle happen hard hash hashes hasn't header hello here's hidden hide hietaniemi higher his_speed hist hold holds huge hy id idx iki.fi implement implementation implementations implementing implicit implicitly included incomplete index indicate indices indirectly info inherit inner instances intend interesting internal internally interpretation io::file ip isn't it's item iterate iteration iterator jarkko jhi join jun key keys kill lacking language lastkey lay leave len length let's lets levels lib library limitations lines list lists live log login logo lot lvalue maceachern magic magically manpage manpath manually map mappings max_subscript maximum mechanism memory mentioning merely message method methods minimum minus missed mldbm modified module moribund multilevel my_speed myfile.txt na namely names ndbm_file ne nearest necessarily necessary needed needs new_nicety news nextkey nice nice::debug nice::destroy nice::tie::scalar nicety node noise non note noticed numeric nvi ob object object's objects obvious oe offset offsets ones oob opendir ordering ordinary original osf.org output outside overwrite package packages pairs partially particular patch paying performed perl perlmodlib perltie pi pid plus pop portable possibilities possibly practice preamble prefer prepend presented print printed printf prints prio_max prio_min prio_process prior priority privacy process process's profile programmer proper properly provide purposes push quote raise raising rcsfile read readdir readline real record redefining redirected ref reference references regular release remember remove renice reports represent representing represents require requires reset respect retrieve retrieved return returned returns revision robustness run sake sample scalar scalars scope script seem seldom self servicing setpriority setting setup sh shift shout shouting signature silence simpler simply site size skimo someone somewhat sort source sp splice spot spotted sprintf ss standard stderr stdout store stored storing strict string structure sub subsection subtle success successfully sven sysread syswrite takes target tells testba tested testing text th that's theory there's therefore they'll they're they've thinking thinks tie tie's tie::hash tiearray tied tiehandle tiehash ties tiescalar time times title tom tr tracing translation tries triggered triggers try trying tying type types typically uc unbreakable undef underlying unix unixy unless unlike unlink unpack unshift untie usage user user's using usr val valid value values variable variables verdoolaege via vs wanted warning warnings we'll we're we've whatever whenever whowasi wish won't works worth write written wrong xx you'd you'll you're yourself perltie	1pub/perltie
 1pub 4th able activestate activestate's add added adding addition additional ae aeiou afterwards al allocate allocating alone alpha amount apache api application applications arbitrary archlib argc args arguably argv array article as_string ask assume assumed assuming attempt attention author authors autoload automate av av_fetch av_len avoid aware backticks base bastardized bck bell ben bg bill bin binary bit blithely bll block blocks bob boolean boot_dynaloader boot_module boot_socket box breath bt build building builtin bunce c's c...no cache cafeteria calling can't cardinal care cases cautious cc ccflags ccopts cents changepurse char character check chngprs choose christiansen clasp clean cleaned cleaning cleanup clearly cms cnts cnvnnc code coercion collection collisions columns combine comes communicate compilation compile compiled compiler compiling complains compute computed computer conditions config configuration configured considered constructed constructing consult consumption contact contains context continue contributed contributions convenience convert copies copy copying copyright core corollary correct counterpart cpan cplusplus create created creates creating croak croak_on_error crrct ctrl current cv cw d__language_c__ d_no_proto dangerous dash data date dbool deadbeef deallocate dec dec_osf decide decoux deep default define defined delete delete_package demonstrate demonstrated derived described design destroy details determine determined devel::symdump developer developing dhas_bool die digit directories directory discussed disk distribute distributed distribution dllr dmultiplicity do_clean document documentation documented doesn't dollar don't double doug dougm dov dress ds dsp dstandard_c dth dummy dynaloader dynaloader::boot_dynaloader dynamic dynamically e.g easy ed eg eighth elapsed embed embed::persistent embed::persistent::eval_file embed::test_2epl embedded embedding embeds employ enable end__ endif ensure enter entire entry env environment epoch equivalent error error_check errsv errsv,pl_na essentials et eval eval'd eval_file evaluate evaluates evaluating everything everything_ evolution exactly examine except exec executable executables execute executes execution exit exitstatus explain expo exponent exponentiation expression extension extension's extensions extern extern.h extern_c external extra extract extracting extutils extutils::embed false faq faster feasible fetch fh fiddling figure file file__ filename filename's files fills final finally flag flags float fly fmbls foo fprintf freetmps friends fumbles furuseth g_discard g_eval g_noargs g_scalar gcc generate generates genmake gets gi gi...139 global glue granted grobgeld grow growth gt guaranteed guy gvs h2xs hacker hallvard handed handing handler happened happens header hello here's hi hide higher hint hm holds hooks hoping hpng hs http hy i'll i'm idea identical ifdef ifndef ignore ilya implements incantation include included incorporate initialization initialize input insert inserted inside installed instance instances int integer interactive interfacing internal internet interp interp.c interp.exe interp.o interpretation interpreter interpreter's interpreters invoked ip isn't issue it's item january jon journal july jun keeps kinda kit knowing knows language lck ldopts leave let's lets levels lib libraries library libs lines link linked linux list lives lk lm load loaded loading locate log logic logo longer looks lperl lrep luck maceachern machine magic main maintain maintaining makefile manipulate manpage match match.c match_list matches matching maybe maynard mconfig memory menu merging methods mextutils::embed mght microsoft midst minimized miniperlmain.c mnt mod_perl model modified modifies modify module module::bootstrap modules moral mortal mtime multiplicity multiplicity.c mumble my_argv my_perl my_perl_eval_sv mynrd na names namespace native nbl nd ne necessary needed netscape newav newly newsv newsviv newxs nmake nonportable note notice nsapi_perl nt null num_matches object occasionally occurrences oe official olimit one_args one_perl ones onto operation operations operator opt options oracle orwant osf.org output outrageous package parse particular pass passing patch path pattern pay pennies performing perl perl's perl.apache.org perl.h perl.lib perl5 perl_alloc perl_call_ perl_call_argv perl_call_pv perl_construct perl_destruct perl_eval_pv perl_eval_sv perl_for_win32_faq.html perl_free perl_get_av perl_get_sv perl_parse perl_run perlcall perlembed perlfunc perlguts perlinterpreter perlmain.c perlpower perlxs perlxsi.c perlxsi.o perlxstut permission persistent persistent.c persistent.pl pi pieces pl_na pl_perl_destruct_level placing plates played plugins pnns pointer pollution pop popi pops post potentially pow power.c power.pl practice preamble preserved pretty print printed printf prize process produces programs project proper properly provided provides prz pulled purposes push pushed pushmark putback qq qrtr quarter quote quotes qw rare rarely rchh rcsfile rd read ready real recent red refresh rehtona rekcah relative release remember remove replaced request requests require reserved reset reside resources restarts resulting results rethink retrieve return returning returns retval reverse revision richh rights rnew roadmap robert robust routines rule run running runtime sample savetmps say_hello says scalar scalars scenario science scope scoping script scripts seconds section select sentence server session setting sh shan't shell shielded shiny ships shld shny shouldn't shown showtime showtime.c showtime.pl shut significant simplified simply size skipping slap slightly sm smthng snippets socket socket::bootstrap somedynamicallyloadedmodule sometimes sorry sounds source sp spagain specialize speed sporadically spring sprintf squeaky squeezey sqzy ss stack stacks starters statement statements static statically stderr store str strange strategy strict string string,pl_na string.c strings stub studio sub subroutine subroutines subsection subsequently substitute substitution substitutions substrings subtitles successful sugars's supports suppose sv sv_2mortal sv_setnv sv_setpv sv_setpvf sviv svnv svpv svpvx svrefcnt_dec svtrue symbol syntax table tables takes temporarily temporary terms test.pl tests text text,pl_na textbooks th that'll that's they're third thn thr thrgh tht tim time times title tom tools tpj.com tr track translate translation translations treat tree tried trouble troubles try trying tsuj tw two_args two_perl types typically unbreakable unchanged undef undefined understood unique unix unless unpack untouched updated user using usr usual v:archlib val val,pl_na valid_package_name value values variable variables vars verbatim version versions via void volume vowels we'll we're we've web what's whenever whn wht wi widely win32 wish wll wn working worry wr wrap wrapped write writing written wrong wth www.perl.com xpushed xpushs xs_init xsinit xsub xsubpp xsubs xtr xx yelling yielding you'd you'll you're you've your_architecture_here za zakharevich perlembed	1pub/perlembed
 1pub 5.002b1h a,b a,b,c abs absolutely access accommodate accurately actual actually add added adding addition additional address administrator advance ae allow alternately andreas ar archive arg array arrays ask assigned assist assisted assumed assumes atof attempts author auto autoload autoloading automatically autosplit becomes behavior bell belongs beta bin bit blib block bootstrap bug build building built bunce c's callers calling capability carefully cases casting caused caveat cc cd ceil char char&a character check checking chmod choice clarity clashes clean cleanest closely closer code coded collection colon column comment commonly comparisons compiler complete completely completion complex complicated concepts confirm connect consists const constant constants consult contained contains continue contributed convert converted converts copied copy corp.hp.com correct correspondence corresponds cp cplusplus cr create created creates creating croak current cw dash data date dealing dean declaration declare default define define'd defined definition depends described details determine dhave_something dies difference dir directive directives directories directory disable disaster discussion document documentation documenting doesn't doing don't double doubles ds dummy dxsargs dynaloader dynamic dynamic_lib dynamically e.g earlier ease easier easy edit educate embedded end__ endif ensure epsilon equality equivalent error etc exact exactly except excessively excuse executable executed exist existing exists expects explained explains export export_ok exported exporter ext extending extension extension's extensions extern extern.h extra extutils extutils::makemaker extutils::testlib factor fatal features fed file files final finally finds fix flag floating floor follow foo format full fully function's gamma generate generated generates generating gone goodies h2xs happened happens hard header heavy hello holds hy hypothetical i.e idea identically ifdef ilya imitate importance improving inc include incorrect increment indent indented indents influence input insert inside install installed installing insures int interact interface interfaces interpretation intersperse invite invoked invoking involved ip is_even isa it's item items jeff jun key kit koenig latest ld ld_run_path lead let's level levels lib lib_ext libm libmylib libraries library libs lines link linked list listed lists live lm load loadable loaded loader location log logo looks lot lots macro main main::testval makefile makefile.pl makemaker.pm manifest manpage map math mean meat mechanism message method methods mkbootstrap modify module mv my::postamble my::top_targets myextlib mylib mylib.c mylib.h mytest mytest.bs mytest.c mytest.o mytest.pm mytest.sl mytest.tc mytest.xs mytest2 mytest2::foo mytest2::mylib mytest::hello mytest::is_even mytest::round n'th na names namespace ne near needs nice nine note notice o_files object occurs odd oe ok okamoto okay opposed opt optional optionally oriented outcome output overemphasized overwriting pa package package's packages page pains pair parameter parameters parse parts pass passes passing pasthru patch path perform perl perl's perl.h perl5 perl5.002b2 perl_dl_nonlazy perlguts perllib perlmod perlpod perlxs perlxstut permission pi piece pieces placing pm pod pod2man pointer points portion possibly postamble pre predefined preloaded print printf printing prior processed produce properly prototypes provide provided purpose purposes qualified quote qw ranlib rcsfile read readability reader ready real rebuild references reflects relative released remove removed replaced replacement require required rerun rest resulting return returned retval reviewed revision risc1.1 roehrich round rounded routine routines rule rules run running runs save saying says scalar script scripts search searches section sees select semi semicolon send setting sh shared shortened similar similarly simpler simply simulate situation skip slowly solution sometimes source sp space spaces specify specifying split ss st stack stands starts statement static static_lib statically stdlib.h steps stop stored string structure stub style sub subdirectory subroutine subroutines subsection sufficient suffix suggested support sv_setnv svnv sync systems t_double t_pv tab takes talk tells template templates temporarily test test.pl test_static tested testing tests testval th that's there's third thumb tim time title tolerated tr track translation tries trouble try trying tutorial type typemap types umask unambiguous unbreakable understand understanding unlike unpolluted unshift untouched upgrade usage use'd user using usr value values variable various vars verbose version version_from versions versus via void wanted wants warning we'll we've what's whatever wish won't wondering working works write writemakefile writing written xs xs_mytest_round xsreturn xsub xsub's xsub.h xsubpp xsubs xx xxxxx you'll zakharevich perlxstut	1pub/perlxstut
 1pub a,b able abstraction accepts access achieve acting active add added adding additional address adjusted ae affect affects alias aliases allow allows alternate anatomy ansi anywhere api appended application approach arg arg,pl_na arise array assign assignment assume attempt author automatic automatically avoid backslashes bar::getit beazley beazley's becomes behavior believe bell belongs bind blank blessed blessing block blocks blue bool_t boot bootstrap c_blue calling candidates care carrying cases cat char character checking choose class class::method cleanup code collection colons color color::blue color::destroy color::new color::set_blue combined comment commented comments common compile compiler complement complex complicated component concentrate conditional consider considered consist const constant constructs consult contained contains contributed control convenient core correct corrected correctly corresponds covered covers cray.com create created creates creating creation critical croak current custom cw dash date dave dealing dean declare declared default defaults define defined definition delete demonstrate demonstrated demonstrates deprecated dereference designated designates designed designing desired destroy destroys destructor destructors detail details determine didn't difference direct directive directives directory disable disambiguate discovered disguise distinct document documentation double ds dummy duplicate dynaloader dynamic earlier easier ellipsis embed embedded embedding emits enable enabled endif ends ensure enter entering entry equate equivalent error especially eval'd evaluated examining except executes exist expanded expect expected explained explicit explicitly explored export exporter ext extend extension extension's extensions extern.h extra facility fails failure fall features file files fly follow foo::gettime fragments front fully func_name function's future generate generated generates getnetconfigent gettime glue greater greedy handle handled handles handling hash header hello helpful hence here's heuristic heuristics hold holds hook host host,timep http hy identify imitate implicit implicitly inclined include included incoming incorrect indent indented index indicate indicates indirection init initialization initialize initialized initializing input inserted inserting int interface interfaces interpret interpretation introduction invoke invoked invoking ip isa items iv ix jul jun kept keyword keywords labeled language late lead leave length lest letting levels library likewise limited lines linked list listed listing lists literally localhost log logo looks macro macros magic main mainly malloc'd manipulate manipulated manner manpage manual map mapped mappings maps match matches matching maybe mechanism memory mercy message method methods minimum mnemonic modified modifies modify module modules na names ne necessary needed net::config net_config netconf netconfig netconfigptr netconfigptr::destroy netid newsviv no_init non nonintuitive noprototypes note notice noversioncheck ntt ntype o_object object objects occasionally oe offer offers older onc onto operator operators optional options orders outgoing output outside override overrides package packages parameter parameters particular parts pass patch perl perl.h perlguts perlsub perlxs perlxstut pi piece pipe placing pm pointer pointers poplar positions potentially ppcode practice precede preceding prefix prefixes preinit preprocessor preserves prevent print printed printf private procedures process processed programmer prone properly protected prototype prototypes provide provided provides ptr pull pulled pulls push pushed pushs qualified qualifiers quote quotes qw range rcsfile read real reality rearranged received recognized recommended redundant reenable refer reference referenced referred refers register remain remainder remove removed represents require required requires return returned returning returns retval reversed revision road roehrich rpc rpc.h rpc.pm rpc.xs rpc_ rpcb rpcb1.xsh rpcb_ rpcb_destroy rpcb_gettime rpctest.pl run safer scenarios scope scoping section sections segfaults segments select self send sent serve set_blue setmagic setup sh shown shows significantly similar simplest simply sin situation situations source sp spaces specific specify specifying ss st stack statement statements static status store stored straight strategy string struct structure structures subroutine subroutines subsection substitute succeeds sufficient supplement supplies supply supplying support supported suppose sv sv_2mortal sv_derived_from sv_isobject sv_newmortal sv_setnv sv_setref_pv sv_undef sviv svpv svrv svsetmagic svt_pvmg svtype swig switch switched syntax t_ptrobj t_ptrobj_special t_ptrref tab tag takes tcp tells terminate terminates test text th throughout time time_t timep timep,host times tirpc title tmp tr transfer translate translation tries trim truely tt tutorial type typedef typemap typemaps types typical udp unary unblessed unbreakable undef underscores understand unique unknown unless unlike untouched update updated usage user using usual val valid value values var variable variables variation variety verify versatility version version1 version2 versioncheck versions via virtual visible void wanted wants warn whitespace wishes www.cs.utah.edu x_gettime xs xsreturn xsreturn_empty xsreturn_undef xsub xsub's xsub.h xsubpp xsubs xx perlxs	1pub/perlxs
 1pub a2p able abstraction access actually add added additional advocate ae allow allows amounts anonymous anyone anyway apart application applications apply arbitrarily arbitrary archive array arrays associative atof author author's auto autoload autoloaded autoloading automatically awk awk's backreference based basic beautiful behavior bell benefits berkeley binary binding blocks book bug bugs built builtin byte bytes calling camel capabilities capture casting catch character characters choose class classes closely closures code combines comments common communication compatible compilability compilation compile compiled compiler compiling complete compliant component comprehensive configuration configvar consider consistent constraints constructors contains continue contributed contributes control conventions corresponds counted counts cpan create creating cryptic csh cut cw dash data dataflow date db dbm dbmopen deal debugger debugging declared deep default define defined defines definitely definitions degenerate degraded dependency depth described despite destructors developers diagnostic diagnostics difficulty dir directives directories directory distributed divining documentation documented doesn't doing don't double ds dummy dynamic ease easily easy eclectic efficient elegant embed embeddable embedded enhancements environment eof equivalent error errors exactly examined exceeds except execution exercise exhibit exist exits explanations express expression expressions extensibility extensible extension extensions extensive extracting extraction familiar faster features file filehandles files floating folks formats formerly forms forward frequently full gdbm generalized generate getting glue gone grammar gratitude grouping grow guide hashes header hidden historians holds holes http hubris hundreds hv hy hype identifiers impatience implementations import inc include indication informative inheritance innumerable insecure install installed intended intending interface internal internally interpretation interprocess intro io ip it's item jun language languages larry laziness levels lexical lib libraries library limit limits lines list lister lists loading locale locations log logo longer lovely machine's mail man1 man3 management manages mandatory manner manpage manpages manpath manual matching mechanism memory mention mercy messages methods minimal mistakes mnemonic mode modularity module module's modules motto myconfig mysterious na names ndbm ne near nearly necessary nested network none nongreedy note notes novice object objects octal oe okay oo oodles operations operators opinion optimized optional options ordinarily oriented output overview package packages particular party pascal patch path pathologically pattern performance perl perl's perl.com perl.org perl5 perlapio perlbook perlbot perlbug perlcall perldata perldebug perldelta perldiag perldoc perldsc perlembed perlfaq perlform perlfunc perlguts perlhist perlipc perllocale perllol perlmod perlmodinstall perlmodlib perlobj perlop perlpod perlport perlre perlref perlrun perlsec perlstyle perlsub perlsyn perltie perltoc perltoot perltrap perlvar perlxs perlxstut pi plain play please plug plus pna portability portable portion posix practical pragma pragmas precedence predefined preprocessor prevent prevents previously principal printing privacy produce produces production programfile programmer programming programs proper provide provided provides published quantifiers questions quickly quote rcsfile read readability readable reader reads records recursion reduce reference references regular regularized replaced replacement report reports requires reserved reusability reusable revision rewrite routines rubbish rules run s2p safer scalar scan scanning scope scoping script scripts sdbm section sections security sed seek semantics setuid sh share shared silly simplified simply simultaneous simultaneously site size slurp sophisticated source sp specify split sprintf ss standard stands stdio stem stems stories straight straightforward strange stream stressed string structures stupid stuu style subdirectory subroutine subroutines succeeded success suggested support supported switch switches syntax sysread syswrite table tables tasks techniques tend terms terse testimonials text th thanks that's there's third tied time tiny title token tr tracing translation translator translators traps tree tricks trouble try turns tutorial type types unbreakable unbundled unchanged undefined unix unlike unlimited unwary upwardly usability user using usr utilities utils v:man.dir value variable variables various version vestiges via view virtual virtues wait wall wall.org warnings ways whenever whitespace wish working write writes wrong www.perl.com xs xx yacc you'll you're you've perl	1pub/perl
 1pub aaa able access accessing accidentally accomplish accustomed actually adam adding additional address adjective admittedly advantage ae affects allow allows alternative ambiguous anonymous anywhere applied applies arbitrary aren't argv arise array arrayref arrays arrow assign assignment assignments associate association assumes attempting automatically autovivification backslash bar bareword basic bbb behave behaves bell besides bit bits bless blessed block blocks blue boink bonnie borderwidth brace braces brackets build c's callback callbacks can't careful cases ccc chain character checking checks chicanery civility class clears clobbering closure closures clyde code coderef coding collection color colors compatibility compilation compile compiled complete complex complicated composers concern confusing consider considered construct constructors contains context continue continues contrast contributed contributing convenient converted correct count countermand counts create created creates creating critical cumbersome curlies curly current cw cyclic dangerous dash data date deceptive declaration declarations declared deemed define defined defines degenerate demand dereference dereferenced dereferencing described desired despite destructed detailed determine didn't difference difficult direct directory dirhandle disadvantage disambiguate dispatch documentation documents doesn't doggie don't double ds dummy dying dynamic earlier ears earthlings easier easily easy economy effectively encapsulation enclosing enforce entirely entry enumerated env equivalent error etc eval evaluated eve event everything except executable execute executed exist existence expect explained explanation explanatory explicitly expression expressions extra feature fh file filehandle filehandles filename filesystem final font foo foofoo forcing frame freeing freely frequently front functioning funny future garbage generalized generate generated get_rec gets glob global globals globref globrefs globs goes gone green greetings grow handle handler handles happen happens hard hash hashem hashes hashref hasn't hassle haven't header here's hmmm hold holding holds howdy html hy idea identifier identifiers iff implicit impose includes incurs independently index indicate indicates indirectly inner inside instructive intend interesting intermixed interpolating interpretation interprets intuitive invisible io io::handle ioref ip isn't it'll it's item iteration january jun key keys languages larger late leading lets levels lexical lexically lexicals likewise lines link links lisp list literals loaded localized log logo longer lookups loop lost lovingly lowercase lvalue magically main mainwindow manipulation manpage mean meant mechanism memory mentioned menubar merely method methods mistake mnemonic module multidimensional mysterious mysub na names ne necessary nest nested newprint nice notation note notion object object's objects objref obvious occasional occasionally occur oe officially ok okay omit ones op opendir opening operator operators optional options orange ordinary oriented ospeed outer output outside overriding pack package paragraph parentheses particular particularly passes passing patch pathological perl perlbot perldata perldsc perlfunc perllol perlobj perlref perltoot phased pi piece places please pointing points pop possibly powerful precedence presence presumably pretends principle print prints private process produce programmers programming prone proper properly protect prototype provides purple push putting quote quoted quotes qw raised rare rcsfile readability real realizes reasons rec recursively red ref ref.t refer reference references referencing referential referred refrefref refs regression release relief remains remember replace represent require reserve reserved respect rest results retains return returned returning returns revision risk routine rule run runs saves says scalar scalarref scalars scope score section seemingly self semicolon serve setting sh shared shift short showem shrink signal silently silly similar similarly sincerity slightly slot smart socket socketpair sockets soft sometimes source sp spaceless specifically splutter spring square ss standard statement statements stay stdin stdout stick storing strict string structure structures stuck stuff sub subname subroutine subroutines subscripted subscripting subscripts subsection sugar suppopose supported switch symbol symbolic symbols synonym synonyms syntactic syntax table tail taking talked talking technique template templates temporary term::cap terminal terms test tgetent th that's that::foo there's therefore tie::refhash time times title tk totalitarians tr track translation trick trouble try trying type typeglob typeglobs typically uc um unbreakable undef undefined underlying understand unix unless usefully useless user using utmost value values variable variables various version versions viewing violate violet visible wanted warn warning warnings ways we'll we're we've widgets wise wish won't wonder workaround worked works worry worth write writing written wrong xx yellow yields you'd you'll you're perlref	1pub/perlref
 1pub ab abc abc123 abc445 achieve actual actually add addicts addition additional ae alarm algorithms allowing alphabetic alphanumeric alter alternation alternative alternatives anded anywhere appreciate aren't ascii assertion assertions assumption attempted avoid az backreference backreferences backs backslash backslashed backspace backtrack backtracking backward badly bar barefoot barn based basically behaved behaviour bel bell bit block blurfl boundary bracket bracketing brackets break buffer builtin can't capturing carriage caused certainly chain char character characters chosen claims class classes clearer clustering code comes comment comments common compatibility complete complicated confused confusion consequent consistent construct consume contains context contrary contributed control cost costly counting cover cr curly current customary cw dash date deal deeper default defined defines definition deletion delimit delimiter deprecated derived described describes designate details difference differently digit digit'th digits dirty disable disambiguate distantly documentation doesn't doing don't double ds due dummy e.g easier effective eg egrep embedded enable enclosing encode engine entire entry equivalent error esc escape escapes escaping etc eval everything exactly examined except expand expect expectations expected explanation explicit exponential expression expressions extend extends extension extensions extra facilitate fail fails familiar feature features fee feed feio ff fie fields finally finds fix flexible foe follow foo foobar food foot forever formatting freely friedl front fundamental generally generated global gobbled goes grandfathered greediness greedy grouping groups guaranteed habit handles happening header henry here's hex hexadecimal holds hope hoping hours ht hy idiom ignore ignoring imaginary imagine immense imstx include includes inclusive indeed influenced initially insensitive inside integral internal interpolates interpolation interpretation introducing involves ip ish isn't it's item jeffrey jun juxtaposition kludged languages leading legibility let's lets levels lex lf limited limiting lines list listed literal literally loads locale location log logo lookahead lookaheads lookbehind looking looks lot lowercase lvalue manpage map mark mastering match matched matcher matches matching mathing mean meanings mechanism member merely metacharacter metacharacters minimal minimize minimum minutes mistake modification modifier modifiers module ms multi n,m na namely ne necessarily needed needs negation negations negative neither newline newlines nl nn nnn non nor notation note notion numbered occasion occurrence occurs octal oe older ones opening operation operations operator operators optimizations ordinary output outside overhead override overrides page paid pair parentheses parenthesis parser particular particularly parts pat patch pats pattern pattern's patterns pay pdp penalized perl perl's perlbook perlfunc perllocale perlop perlre perlthink permitting pi picture plus popular pos positions positive potentially practice preceding prefixing pretend pretty price print printf prints processed produces programs provide provides psychology purpose qhost quantified quantifier quantifiers quote quoted quotemeta quser qw ran range rare rcsfile readable real realize realizes recalculates recognized redistributable refer reference regex regexp regular reimplementation relate relied remember represents rest retry return returns revision rewriting rhs righthand routines rule rules run runs saved saving saying scanners scope script search seconds section sed seem sees sensitive series setting sh shocking similarly simply simultaneously six slash slightly slow solve sometimes somewhere soon sp space specifies specify spencer's spit split spot square ss stack standard starts stop string strings subexpressions subpattern subpatterns subsection substitute substitutions substring substrings succeed succeeds success successful successfully suffice suffices supported swap switch symbols syntax tab table target tells tentative test text th that's there's thereafter therefore they're till time times title towards tr translation treat tricker tricky tried troff trouble truth try twenty unaffected unbreakable underlying understand unescaped unexpectedly unix unless unlike unquoted uppercase user using usual value values variable variables variants variety various version versions vertical vi vs wants warning ways we'll what's whatever whatsoever whenever whereas whichever whitespace width wish won't works write writing written wrong x1b xx yields you'd you'll you're you've yourself yup perlre	1pub/perlre
 1pub abbreviation able access accessing actual adaptable additional appended applications applies assignment augments author based basic befored behavior bin built bytecode cast category caught checked class cleanup clear colons combines comp.lang.python comp.lang.python.announce compilation compiled complete conditions connected constants contains control controlled controls converted core dates debugging default defaulting defined depend dependent described describes detail developer developing device digit directories directory disable discarded disclaimer displayed distributed distribution division doc docstrings documentation documents documnetation dos dynamically ecommended eeded embedding entails enter entire environment eof equivalent error except exception exec_prefix executable execute executed executes executing existant existing exit exits explained explicitly expressed extended extension extensions favor fields file filename files finally fixdiv.py float format front ftp ftp.python.org full fully generally generate global guido hack hints http i.e ignore import imported include indentation initialization initialized input insensitive inserted inside inspect installation installed int integer intended interactive interface internal internet interpreter interrupt introduction invalid ioerror issue issued keyboardinterrupt language leading lib libraries library license licensing list loaded located location locations loop mail main manipulated manipulations manual match matches matching message messages mixes mode modify module modules newlines newsgroups non note nterpreter object objects occurs omitted operator optimizations option options oriented output packages parnassus parsed parser path pathnames pep performed prefix primary print printed printing prints programming project prompt prompts provides pub pyc pydoc pyo python python's python.org pythondebug pythonhome pythoninspect pythonoptimize pythonpath pythonrc.py pythonstartup pythonunbuffered pythonverbose pythony2k qualification qualified quits raise raises read readable reads reference referred remaining remarkable repeatedly replaces repository request require resembles resources return returns rossum rules running script scripts search searched searching section semantics sensitive session shell shell's showing signal signals significant sigpipe silently simplest site skip sometimes source sourceforge.net space spaces specific specify specifying stack standard starship.python.net statement statements stderr stdin stdout string strings subclass syntax sys sys.argv sys.path sys.ps1 sys.ps2 sys.stderr systems tab tabs terminates terms test thereafter thousands time times tools totally trace triggered tty tutorial twice types typical unbuffered unhandled unique unix usage user using usr value values van variable variables version via viewed warn warnall warning warnings warranties website whitespace wizards worth written www.python.org www.vex.net python	1pub/python
 1pub abbreviations able abstraction accept access accessed accessible accessing accommodate achieve acquire actions actual actually add added adding addition additional address addresses adds adjust adjusted administrative ae algorithm alias aliases allocate allocated allocates allocation allow allowing allows alphabetic alphanumeric alternate alternately am amounts amt analogue analyses andreas anonymous answer anyway anywhere api append appended appending appends applicable applied apply applying approximately aptr ar arbitrary arg args argument's argv arrange array arrays ary ascii ask assign assigned assigning associate associates assumptions attach attempts author authors auto autoload autoloading automatically av av_clear av_extend av_fetch av_len av_make av_pop av_push av_shift av_store av_undef av_unshift avfill avoid avs aware backward bar bar::baz basic baz beasts beattie becomes becoming behavior behaviour believe bell belong biggest bills binmode bit bits bitwise bless blessed blesses blessing blessings block boardman bool boolean born bottom boundaries bowers boyer bracket bracketed buckets buffer bugs bunce bus byte bytes cache caching calculate calculates callback caller caller's calling can't care careful carefully carries cases cast casted casting caveats cf char character characters check checked checkers checks child choose chunk circuits ck_ class classname clear clears closing code coerce coerces collection column combines comments comparatively compare compares compatibility compatible compilation compile compiled compiler complete complex complicated complications composite compute computed concatenates concept conditionals configure conflict considered consists const constant constantly construct constructed construction constructions constructor consult contained contains content context contexts continues contrast contributed control convenience convention conventions conversion convert converted converting converts cookie copied copies copy core corollary corp.hp.com correct correspond correspondence corresponds corrupt corrupted corruptions count counterparts counts covers crafted cray.com create created creates creating creation croak croak_on_error current cv cvstash cw dash data datatypes date db::single db::sub db::trace dberror dberror_list dealing deallocated deals dean debugged debugger debugging declare declares decrease decreased decrement decremented decrementing decrements deduce default deferred defers defined delete deleted deletes delimited dependency dependent depends deprecated depth dereference dereferenced dereferences dereferencing derived describe described descriptions descriptive designate designated desired dest destination destroyed destruction destructive detailed details determinant determine determined determines determining developers die difference digit directive directives directly disables discarded discover distributed dmark do_binmode document documentation doesn't doing don't dorigmark double doubles driven drops ds dsp dsv due dummy dump dumps duplicate duplicates dx dxsargs dxsi32 earlier ed effects efficient elementary eligible elsewhere embedded enable enabled enclosed enclosing ends enter entries entry enum env equal equally equivalent errno error errors esoteric especially etc eval evaluate evaluated evaluates everything exact examine examining except exception executable executed execution exist existed existing exists exit exits expands expansion expect expected experimenting explicit explicitly extend extended extending extends extension extensions extern external extra extutils::makemaker f,p fail failed false familiar fashion fast fbm_compile fbm_compiled fbm_instr feature features feeds fetch fetched fifth file filehandle filename final finding finds firstly fixed flag flags folding foo fooled forbidden forces forcing foreach forget format formatted formatting formline forms fourth fp freed freeing frees freetmps front fully functionality fundamental future g_array g_discard g_eval g_noargs g_scalar g_void garbage generally generic gimme gimme_v glob global globs goto grant grants greater green grow guaranteed gurusamy gv gv_addmulti gv_addwarn gv_fetchmeth gv_fetchmethod gv_fetchmethod_autoload gv_stash gv_stashpv gv_stashsv gvcv gvsv hack handle handled handles handy hang happen happens hash hashes hasn't header hef_svkey hehash hekey heklen hepv hesvkey hesvkey_force hesvkey_set heval highest historical hold holding holds hook hptr hudson hv hv_clear hv_delete hv_delete_ent hv_exists hv_exists_ent hv_fetch hv_fetch_ent hv_iterinit hv_iterkey hv_iterkeysv hv_iternext hv_iternextsv hv_iterval hv_magic hv_store hv_store_ent hv_undef hvfill hvkeys hvname hvs hy i.e id identical identifier identifies identify ified ignore ilya imagine immediate implement implementation implementations implementing implements implications imposes include included increase increment incremented incrementing increments indentation index indicate indicated indicates indicating indirection indirectly info ing inheritance initialize initialized initializes initially inlining insensitive inserted inserts inside insignificant instance instances int integer integral interested interesting interface interfaces internal internally interpretation interpreter introduce invoke invokes invoking involves io iotype ip irrespective isa isalnum isalpha isdigit islower isspace issues isupper it's item items iterator iv ivs ix jeff judged jun keeps key keys keyword kinds klen koenig language lastly layer lazy leak leaks leave len length lengths letter level levels lexicals lexicon lifespan limited lines linked links list listing lists literal lived lives load loaded locale localization localize localized localizing location log logo longer looking looks looks_like_number lookup lot lots lower lowercase lval lvalue machine macro macros magic magic_ magic_get magic_len magic_set magical main main::b main::c maintained malcolm malloc malloc'd manipulate manipulated manipulates manpage map mark marker marks marquess match matches matching matthew maxsarg maybe maychange mccamant meaningful meant measure mechanism memcpy memmove memory memzero mere merely methname method method's methods mg mg_clear mg_copy mg_find mg_flags mg_free mg_get mg_len mg_magical mg_moremagic mg_obj mg_private mg_ptr mg_set mg_type mg_virtual mgvtbl mimic miscellaneous missing mode modifiable modified modify module module's moore mortal mortality mortalization mortalize move moves mt multiply my_get_fn my_set_fn mytie na names namlen ne necessary needed needing needs negative negligible neil neither nested nevertheless newav newc newconstsub newhv newlen newly newrv newrv_inc newrv_noinc newsv newsviv newsvnv newsvpv newsvpvf newsvpvn newsvrv newsvsv newxs newxsproto newz node node's nodes non none note notice nsv nul null nullav nullch nullcv nullhv nulls nullsv nuls num numeric nv obj object object's objects obtained occurrences oe offset ok okamoto older oldsv oldvar onto oo op op_free op_null opcode opcode.pl opcodes opening operate operating operation operations ops optimization optimizations optimize optimized optionally or'ed oriented original originally origmark output outside overhead overlapping overload overloading overridden overwritten package package::varname packages pair pairs paragraph parameter parent parse parsed particular parts pass passes passing pat patch patchlevel patlen paul peep peephole perform performed performs perl perl's perl.h perl_ perl_alloc perl_call_argv perl_call_method perl_call_pv perl_call_sv perl_construct perl_destruct perl_eval_pv perl_eval_sv perl_free perl_get_av perl_get_cv perl_get_hv perl_get_sv perl_hash perl_parse perl_require_pv perl_run perlapio perlcall perlembed perlguts perlio perlish perlref perlsec perlxs perlxstut perly.y permitted pfeifer pi piece pl_ pl_dbsingle pl_dbsub pl_dbtrace pl_defstash pl_dowarn pl_na pl_sv_no pl_sv_undef pl_sv_yes platforms please plus pm pni pointed pointer pointers pointing points pools pop popi popl popn popp pops populates pos posix posix::tzname possibly post postfix ppcode pre preallocated precomputed predefined preferable prefix preinit 
 1pub abc able ac access accessed accident accomplish actually add additional additionally ae affect ahead alas allows alphabetics alter alternate alternately anywhere approach apt aren't arg arg1 arg2 arise array attributes automatically av avoid aware backtick backticks bad bar based bash_env begun behalf bell beyond bin binary bit bits blah blindly block bottom bsd bug bugs builds builtin bypass byte calling can't cards care careful carefully cdpath cgi char character characters check checked checking checks child cleaning clear code compartments compile compiled compiler compiles complain compliance conceal concerned condition configure connects conservative considered considers contains contribute contributed controlled convenient convention conventional corp cpan crackers create csh current cw dash data data's date de dealing decrypt defeat define defined definitions definitively degrees delete dependency dependent derived described designed detailed detecting detects determine determined dev didn't die differing difficulty directly directories directory dirty disable disabled disassemble discussion distribution documentation doesn't doing don't dot double drop dropping ds dsetuid_scripts_are_secure_now dummy easy echo effective efficient eg egid else's emulate enable enables encryption english entire entry env environment environments eq equivalent error escapes especially etc euid eval evaluation everything evil exceedingly except exception exec executable execute execv expand expansion explicit explicitly exploit expression external extra fairly farm fatal fd feature fewer figure file filenames files filter filters finally fixing flag flexible foo fork fortunately friendly full fully functionality further gecos generated getpw gets gid glob gone guarantee header here's hid hidden hide hiding holds hole hy hyphen id ids ifs ignore impose impossible included indeed indirectly inefficient inherent inherently initgroups input insecure insecurities intended interpret interpretation interpreter introduce invoked invokes ip is_tainted isn't issue it's join judicious jun kernel kid kill knowing language latter launched launder laundering lawyer leading leave legal lesser lesson lets level levels licence licence's license limit lines links list lists locale log logically logo longer loudly main managed manpage match matched mean mechanism meddling message messages metacharacters mirror mistakenly mistakes mode modern modifies module moves myprog na namespace native ne nearby necessarily needed non none nor note notice notices november numerics obscurity obvious oe ok ones opened opening opens operations operator originals outlaw outside owner parameter parent pass passes patch path pathname pattern patterns pepper perl perllocale perlrun perlsec permission permissions pi pid pipe plagues plus pose posix possibly precautions presence presumes prevent print prior privilege privileges privs process processes profiting programmer programmers programs properly proprietary protecting provide provides purposes qualified quote qw race rcsfile read readable readdir reading readlink real real_path reasonably recent reduced reference referencing regard regular release releases relies rely remainder remove renders reopens required resets restrictive results return revision run running safe safely safer safety saying says scalar scheme script script's scripts secure securely security server setgid setid setuid sh shell shells shift shouldn't shout sign similar simply slightly snags socially software someone sometimes somewhere source sp specify ss stand standard statements stdin stem strategy strict string strings strongly stupid sub subject subjected subpatterns subprocesses subsection substitution substring subterfuge subtle suggested suidperl supply support supported surprised switch switches symbolic syntax systems sysvr4 taint taint.pm tainted taintedness tainting takes temp test testing tests th that's theory threatening time title tr translation trapped traps trick tricked tries trigger trouble trust trusting try trying turns uid umask umasks unbreakable underscores unfortunately unix unless unlike unlink unpublished untaint untainted untainting untrustworthy usable useless user using usr value values variable variables varying vendors verify verifying versions via viewing wanting ways web wild wildcard wildcards wish wording working wrapper wrapsuid writable write writer writing written wrote wu xx xyz you'll you're you've yourself perlsec	1pub/perlsec
 1pub abc additional ae aesthetics afraid all_caps_here allow ampersands analysis anyway aren't array as_string assume avoid backslashes backticks bell beware beyond blank block bottom bounce brace brackets brainpower breaks broken bytes can't capital cares caused character chdir check choose chunks claim clarity clashes class cleanly closing code codes column comma complex config configure consider consistent consistently constants construct context contortions contributed curlies curly current cw dash date default defaults defined delimiter designed determined diagnostics die dir documentation documents doesn't don't double doubt ds due dummy e.g easier else's elses english enhance equivalent error especially eval everyone except exception excessive exit explicitly expression failed fails feature features file files fit flag foo foreach formatting generalizing generally global gotit grep guide guidelines hairy header helpful here's hides holds hy identifiers idx incidence include indent indicate informally inside installed instance integer interpretation interrogate ip isn't issues it'd it's item items jun key keyword labels larry lay lazy leading lets letter levels limitations lines list log logo loop lowercase machine main maintain map matching mean mental message messages method middle mixed mkdir mnemonic modifier module modules multi multilevel na names native nature ne nice no_caps_here noise non num obj object oe oh ok omit omitted opendir opening operator operators opt_c opt_s opt_u ought outdent outside package parentheses parenthesis parenthesize particular patch patchlevel perl perl_version perlstyle person pi picking places poor portability portions pragma pragmas preferences primitive print programmer programmers programs prove provides punctuation quote rcsfile read readability readable reasons reduce redundant regarding regards regexp regular remember repeated representations reserves return reusability reverse revision rule run schmuck scope seem semicolon sh short shot sigtrap silly similarly slash slashes some_caps_here sometimes sort sp space sparse speakers ss st_atime st_ctime st_mtime st_size standard started statement statements static stderr strict string strong strongly style subroutines subscript substantive suffer sufficient supplying systems test th they're throw times title tmp tmpdir tr translation transliterations typed unbreakable uncuddled underscore underscores understand unless user using values var_names_like_this variable variables varnameslikethis vars verbose version vertically vi via view visible void waste ways welfare whitespace wide works writing wrong xx xyz you've perlstyle	1pub/perlstyle
 1pub able accessible accessing accident actually ada addition additional ae affect affects alias aliasing alter alternative another_hash appended argv argvout arrange array arrays assign assigning assignment assignments assume assumed assumes autoload autoloaded autoloading availability awk backwards bar bar::baz bell beware block blocks blown braces building builtin callable caller's can't capitalized character cheap cheaply check checking class classes classicist clean closure closures clues code colon colons comes compatibility compilation compile compiled compiler completely constant construct constructors contains context contributed convenient copy core cpan create created creating creation current cvs cw cwd cwd::getcwd dash date db debug debugger decided declaration declare declares default defined definition definitions degenerate delimiter depth dereference derive descriptions designed destructor destructors details determines devel::symdump dick die differ difference differentiate directives directly directory disambiguate document documentation doesn't don't double ds dummy dumpvar.pl dynamic dynamically e.g earlier easily easy ed efficient eg eh emacs enclosing entirely entry env equivalent eval evaluate exactly examine except exception exec executables execute executed executes execution exit exited exiting explanation explicit explicitly export export_ok export_tags exportation exported exporter exporting expression expressions extension fashioned feel file filehandles filename filenames files fn foo forced formats fully func1 func2 func3 func4 functionality functioning further getcwd gets glob global globals goes handler handles happens hard hash hashit hashsym header helps here's holds humans hy i.e identifier identifiers identify_typeglob implicitly implies import importation impossible inc included inconvenient indicate indirect influences initalize initially inner inner::var inside instance interesting interfere interpretation interpreter involving ip isa isn't issues it's jun kept late leading leaves letters levels lexical lexicals library lifo likewise lines linked list listing literally load loading log logo lookups macros main main::bar main::foo main::getcwd main::sail makemaker manpage match meant mechanics mechanism memory mentioned merely method methods middle modify module module's module.pm modules na name1 name2 names namespace namespaces ne nested nhash non notation note nowhere null ob object objects obtain oe ones oops operation operator operators opposed optimization optional optionally other's outer outer::inner outer::inner::var overwrite owner owner's owner::s package package's package::variable package__ packages parsed particular pass passing patch pattern performs perl perl's perldb.pl perldebug perlguts perlmod perlmodlib perlobj perlref perlsub perltoot perlxstut ph pi pl pm points polymorphing pool posix pragma pragmas pragmata pragmatic preferred prefixing print prints priv_func priv_var private program's programmers protect proto'd prototype prototyped provides providing pull punctuation purge purposes qualifications qualified qualify quote quotes qw rcs rcsfile readable recommended ref refer reference references referring refers regarding related remember require responsibility rest return returned reusable reverse revision richard routines run running sail saying scalars scope scoped scoping script secret_hash seeing semantics separator sh shift short shorthand sig signal slot some::module some::module::stuff some_hash somemodule somemodule.pm sometimes somewhat soon soundex.pm sp spell sprintf ss standard statement statements stderr stdin stdout stomping stored strict string strings stubs stuff style sub subject subroutine subroutines subsection substitution supported switch switches symbol symbols syntax system's systems table table's tables tag template temporarily text text::soundex th there's therefore they're time title totally tr translated translation transliteration transparent trap treat tricky tried try trying tutorial typeglob typeglobs typically unbreakable undefined underscore unit unless unqualified unwieldy user using value var1 variable variables various vars version via visible void ways what's wherever whichever wish won't works writers writing xx yes you'll you're you've yourself perlmod	1pub/perlmod
 1pub able acme additional ae alternatively ansi answer answers ape aren't author bang beaches behavior bell bin bugs built can't carl category character chown chroot compatibility complete concept config configuring considered contact contributed copious correctly create cw dash date dbmclose dbmopen defined described describing directly document documentation double ds dummy dynaloading dynamic emulation endnetent endprotoent endservent environment equivalent error excellent except exist expect extension extensions fcntl features filehandle filename:18 friendly future getnetbyaddr getnetbyname getnetent getprotoent getservent getsockopt grains haven't header holds huffman hy identified include intended interpretation interpreter invoke invoked invoking ip isn't items jun latter levels lines list loading located log logo luther lutherh makemaker manpage mentioned messages na ne nor notes october oe opcode os pages patch path peculiar perl perl5 perlplan9 pi pl plan posix previously priority produce provided provides questions quote rcsfile recvmsg related replacement rest revised revision sagan sand script scripts self sendmsg sethostent setnetent setprotoent setservent setsockopt sh shebang shell shouldn't sigabrt sigalrm sigchld sigcont sigfpe sighup sigill sigint sigkill signal signals sigpipe sigquit sigsegv sigstop sigterm sigtstp sigttin sigttou sigusr1 sigusr2 simply socket sp specific ss stacking statement static stratcom.com string subsection supported tells th title tr translation try umask unbreakable undefined unix user usr we'll what's wish won't worried written xx perlplan9	1pub/perlplan9
 1pub accept accepted accordingly achieve add address adds adjusted aharon alone amount angle arnold article assume assumed assumes assuming author autodefs automatically auxiliary avoid awk basic bin bit black blank boundaries bourne boxes bracket brackets break breaks bug bugs build catch chapter characters choice chooses chunk chunk's chunks cmd code column columns comment comments common compares comparison compromises concatenates contains control converse conversion converting converts copied copy correctly cox cpif cputype create cross def default defined defines definition definitions delay delays deprecated described describes detailed dictate digesting digit directory discover document documentation documentclass documents doing don't double doubled e.g eecs.harvard.edu effects emit emitted emptydefn enable enables encounters ends ensures environments eq error ersion eval except executed exist expand expanded expanding expands expected experts explanatory extra extracts fail features file files filter filters final finds finduses foo.c foo.h foo.html foo.nw foo.tex footers forces format formats formatter formatting fortran fresh fun generate gnu.org guide guide.ps hackers harvard header headers heuristic html htmltoc http hypertext i'll icn icon icon.filter identifier identifiers identifies identifying idioms ieee ignores ignoring implied implies include incorrect indentation indented index indexed indexfrom indexing indicates indication indications info input inserted inserts interleaved inverts knuth's l2h labs.com lang language languages larger latex latex2html lib limbo lines links list listed literal literate location longxref looking looks macro macros magic mangles manner mark markup material mean messages middle misc misspelled misspelling mistake mk mkfile ml mode modula names ne necessary neither newline newlines nj noidx nonwhite norman noroff noroots notangle nountangle noweave noweb noweb.sty nowebchunks nowebindex noweboptions nr nt nternet numarkup nuweb nw nwmac nwmac.tex occur ok omitted omitting opt option options ordinary orman output overfull overwriting package page pagestyles pair paired paragraph paragraphs parse parsed parser pascal path percent permissible pipeline placing plain plan9.bell pp preamble precede preceding preprocessor prereq preserves prevents print printed prints processed produce produces programming proper provide ps puts putting quoted quotes ramsey rc rcs re readable reading reads reasonable rebuild recognizing redefine refer reference references referencing refers related relating relevant remedy repeated reports require requires respect rest results rewriting rfoo.c rfoo.h rightmost robbins roots rs rsc rule run russ scripts section self sensible september sharpline shell shell's showautodefs sign silently simpler simplified skipped sml software solve sometimes somewhat sorted source space spaces specialized square src standard stands started starts stops strange strings style substrings succeeds suitable suitably sun support supports sys tabs tags tangling target terminates tex texmf text tohtml tool tools toroff totex trailer transforms transliterated treatment treats trickery troff trouble try turning typeset typical typically typographic understands uninteresting university unless unmarkup untouched unused usable usage useless user user's users using usre values vary vbox verbatim version vertical violate weaving web whitespace wide width works wrapper writes written www.eecs.harvard.edu xdoc yields you're noweb	1pub/noweb
 1pub accept accepting add added adding additional ae agrave alone am apparently arbitrary aren't ascii assumed author bar basic becomes bell beyond block book boundaries br breaking bugs bullets can't capital character characters check checking checkpods.pl claiming code column common compiler completely consistent constant contains contributed control cross cut cw dammit dash data_ date decide default defined details directive directly distinguished distribution ditto doc document documentation don don't double doubtless ds dummy easily embed embedded embedding embolden emphasis end_ end__ entire entity entry equivalent er escape escapes etc exactly except exist explanation figure figure1.png file filehandle filenames filled fmt font foo forget format formatter formatters formatting forming generation gotten gt have_ head1 head2 header heading headings headn hence holds html hy i'm i've i.e ident identifier idiot ignore img importantly include indentation indented index indicated inside intent interior interpretation ip it's italicize item items jun justified kinds languages larry lasts latex lay leave letter level levels library lines link list lists literal log logo looks lot lt manpage manual mark markup matching maybe mixing mode modern module modules mostly na names ne non note nroff numbered numeric odd oe online optional ordinary output outside page paired paragraph paragraphs parsing particular pass patch perl perlpod perlsyn pi pitfalls placeholder plain pleases pod pod2fm pod2html pod2latex pod2man pod2text pod::checker pods presumably print produce producing programs proof proofread provides quote quotes raw rcsfile read reads recognized reference reformat reproduced require revision roff rules run runs script scripts sec section sections sensibly sequences sh shift shouldn't similar similarly simplicity skeletal slurp someone source sp space spaces specifically specifies src ss stand starts stick string subsection sufficient surprisingly switches synonyms tab tabs telling tex text th that's title total tr translated translates translation translator translators treat troff trying type unbreakable user using utilize variable variables verbatim version vi visually wall wanted whatever width wish wording working worry wouldn't write writes xx you're perlpod	1pub/perlpod
 1pub access accessible actually adbm adding additional ae aggregation allow allows alternative ambiguities anonymous anyway appetites array ask assume attempt autoload bag'o bar bar::baz bar::fizzle baz behave behavior bell bitten biz bless blessing bot break broken bugs buz calling cathy certainly character class classes code collection comprehensive constructor construed consult context contributed copy correct create creates curious custom cw dash data date dbm define defined definitions delegate delegation demonstrate demonstrated demonstrates desired destroy die difficult directly discussion documentation doing don't double ds dummy earlier ease effectively encouraged enter equivalent everything exactly except expect explicitly extend extended fcntl features feeding fetch fizzle flattening foo foo::bar foo::baz foo::fizzle foo::private foo::private::baz foreign forwarding fully global globals goo google goop goop::baz grr grumble guess guide hackery happen happens happy hash header here's hinder hints hold holds hunting hy illustrates immediate implement impossible inclusion inconvenient indirect inherit inheritable inheritance inherited inheriting instance intended interface interpretation interpreter io ip isa isn't item jun key knowing knows language languages lead levels lines located log logo low main mechanics mentioned message messages method methodology methods modify motto move mumble mumbling mydbm na namespace ne needed needs noisy nor notice o_creat o_rdwr object objects oe one's oo oriented overridden override overriding package parameter parameters params paranoia paranoid pass password patch perform perl perl's perlbot pi places print private programmer programming promote prone propagated pseudo qualified quote qw rcsfile reader ref reference relationship relationships relevant remove replace require requires return reusable reuse revision rule rumple scalar scaling sdbm sdbm2 sdbm_file section self sh shift shows solve solved someday someone sometimes sort sp ss static store strength string style sub subclass subclassed subvert super super::goo super::google super::mumble superclass superclass's symbol's syntax technique textbooks th that'll there's they're thinking tie tie::hash tiehash tips title tr translation tricks trigger try tutorial type unbreakable undefined user using valid variable variables verify via whet xx xyzzy you're perlbot	1pub/perlbot
 1pub access accessing accumulator additional ae affect altered alternate anywhere apart applied approach arbitrary aren't args array aspects assigned autoflush automatically based basic's basis bell blank blanked block borrowed brace braces break bug builtin caret carp center centering channel character characters charts check checking child chops code cols column columns commas comment commify common concatenated confused considered consists contains context contiguous contributed controlled convenient croak current cutoff cw dash date debugger debugging decimal declare declared default defined desired desperate determined die directly discussion doable documentation don't dot double ds dummy eh embedded enables enclosed ending ends english entirety entries entry environment equivalent etc eval evaluate evaluated evaluates exactly exceed except exception execute executed execution exhausted exist expression expressions facilitate farm fields file filehandle fill filling filter final finally fixed float fly fmt foo footer footers forces forever format format_formfeed format_line_break_characters format_lines_left format_lines_per_page format_name format_page_number format_top_name formats formatted formatting formline formlist fortran fortunately front funny further generate german gid goes handle handled handling happens header headers helps here's historical hold holds hy ident idiom ignores improve indent index indicated inside intermediary intermix internals internet interpolation interpretation ip it's item jun justification keywords knowing layout lc_numeric legal legibility legible length level levels lexical lines list locale log login logo lone looking low lowercase mail mailer man's manpage margin marker massage mechanism message method misconfiguration misconfigured mode module multi my_other_format my_top_format myself na names namespace ne necessary newline nontruncated notes nroff numeric occur oe ofh omitted opening optional outf output output_autoflush outside packages padding page passing passwd patch perl perlform perlfunc perllocale pi picture pipe plug points poor pragma prematurely pretty prevent print printed printf printing priority process processed processing produce program's programmer providing puts putting quote rcsfile read real rearrange reasons record records referenced remaining repeated report reports return returned revision rudimentary rule run scalar scope section select sending sh shift short size smtp somewhat sophisticated sp space specially specifies specify spread sprintf ss stack stage starts statement stdin stdout stdout_top step stored str strategy string structure sub subject subroutine subroutines subsection substitute supply supplying suppress surprised swrite temp temporary text th that's tied tilde time title todo token tr track translated translation triggered truly truncated types ugly uid unbreakable unconditionally undefined undergo unless usage user using value values variable variables variety version vertical visible warnings weren't whitespace wide width wish wow write xx yes you'll you're yourself perlform	1pub/perlform
 1pub access accused add adding additional adjacent ae ah alroy append applicable applies aref argue array arrays arrow assign assigning assignment assume author automatically bambam barney bart bell betty bit bracket brackets build can't careful casual character christiansen clearer code columns compile complicated construct constructor context contributed convenience couldn't counts create curly cw dash data date dealing declaration declarations defined dereference dereferencing develop dimensional dino direct documentation doesn't don't double ds dummy easier easiest easy elroy elt entirely equivalent everything except existing exists explicitly fancier fancy file fixed flat fly fred freely func func2 funnier george getting gladly growing happy hard header here's hmm holds homer hy i'd imagine inner inscrutable insecurity interchange interpretation intervening ip isn't it'll it's jane judy jun leery let's levels likewise lines list listed lists loaded log logo lol looking loop looping lrr maggie manager manipulating map marge matrices maybe mdt multidimensional na ne needs newlol nice notice oe omit operation outer parentheses parenthesis patch pebbles perl perl.com perldata perldsc perllol perlref pi pointer potential pretty print printing prints proper push quote rapid rcsfile reader reading real reasonably reduce ref ref_to_lol reference references refs regular remember replaced return revision roll rough round row rows rule run running scalar schwartzian scratch security seeking selected setting sh shell shift simplest sitting slice slices somefunc sometimes sp splice_2d split square ss startx starty stating strict string structure structures style sub subscripting subscripts synonym syntax tchrist temporary th that's there's thereto thu time title tmp tom tr track transforms translation trivial trying type ugly unbreakable undef understand unlike update user using variable via wanted we'll whereas wilma wouldn't write wrong x_hi x_lo xx y_hi y_lo you'd you'll you're yourself perllol	1pub/perllol
 1pub additional ae al associates authors bell book books camel character connected contributed covering cw dash date defined definitive documentation double ds dummy edition equivalent et except fax header holds http hy interpretation ip jun larry levels lines listed locate log logo manpage mosey na ne nearly o'reilly oe officially online overseas patch perl perlbook perlfaq3 pi programming publishers quote rcsfile reference revision sh sp ss string th title tr translation unbreakable user various wall web www.ora.com xx you're perlbook	1pub/perlbook
 2.31.178.204.in 9powerboot a.root add adding addition addr addr.arpa address addresses addrs administrative alias aliases ampl.com anna.cs.research.bell answer astro.txt attached attr attribute attributes awk b.root base bell bignose.cs.research.bell boot bootf bsd bypasses c.root carded clone cmd cname communicates con concert configured control convert creates cron cs cs.bell csquery daily data database dbfile default defaults defer define delegated delegation dev dhcpd dial directed directs displays dj.cs.research.bell dns dnsdebug dnsquery dom domain efficient elsewhere entries entry established etc ether exchangers exit exits external figure file files finally finds flag forwarder frequent further generates gets hash helix helix.research.bell hill hint holds host hosts hosts.1127 hosts.equiv hosts.txt il indicated interface internet interval inverse ip ipconfig ipmask ipnet ipquery labs labs.com learned lib library lines list listed looking mail mail.research.bell mapping matched mb message mh minimum mips mkdb mkhash mkhosts modified mount mounted murray mx names nameservers ndb ndbipinfo necessary net net.alt net1 net2 netmtpt network networks nil nonetheless ns ns1.cs.bell ns2.cs.bell option options owning packets pair particular person plan9.bell port postmaster pref presotto printing prints profitable programs prompted prompts properly proto provide ptr queries query rattr real reasons received records refresh remote request requests research research.bell resolution resolve resolved resolver resolves responsible restricted results returned returns reverse rfcs root routines rs run rx scripts search searched searches sent served server servers servers.net serves severely situation soa source specific specifies specify src srv started starts status style subtree successfully superseded supplies sys sysname systems tack time track translate translated translations ttl type udp underfoot uucp value values via whatever whenever wild writing written www.cs.research.bell xxx ndb	8/ndb
 2.out aa accept access acid ansi ape assembly bugs characteristic checking cmd code comments compilation compiled compiler compilers compiles compiling complain concept constant contains conversion cpp db declared def default define defined definition definitions dependent described dir directories directory doesn't don't driver echo effective enable ending environment etc examining except executable executed exist fails file files handlers header howard ids ieee include included independent insert interface iso language leave lib libap.a libraries library limited link linking links loaded loader loaders loading loads locale machine manipulation messages minimal minimally mk names nm object objtype omit omitted operating optimize option options output pcc pcc.c phase phases plan portable posix posix_source pragma preprocessed preprocessing preprocessor print prof profiling programs prototypes related routines send setting signal sought source src standard structures support sys terminal trickey type undef undefine user using v.out vararg variable version void warning warnings pcc	1/pcc
 2.out accumulated active annotating automatically based brief buffer cmd collect collected compressed controlled correlated counter counts ctl data decreasing default dev device display dr dynamic echo elided enable entries entry environment etc execute executing file files fills formatted frequency full graph hold image indented instruction intended interprets interrupt kernel kpdata kprof kprof.c loaded loader milliseconds multiprocess ncall objtype operating option options output percentage pid presents printed prints proc process processes produced prof prof.c prof.out profile profiling profsize programs provided read recorded recursive recursively routine run running sampling seconds setting share similar size source spaces spent src stored symbol symbol:time sys table target text time times tprof typically using variable prof	1/prof
 20ms 33ms 8ms able absolute accepted account accounted achieve actually addition additionally adds admission admit admitted aged ahead allocation allow allowing allows apply arbitrary architecture arrives attributes automatically average becomes billion binary bind block blocked blocking blocks boot bound bugs bytes calculate capital char clock clone clonedev cmd collaborate commandname common complete condition conducted consume contains continue control controlled conventions converted cooperating corresponds cost cpu created creation current deadline deadlines debug debugging decimal declare declared declares declaring decompressing default dependent depends descriptor desired determine dev devrealtime.c devrealtime.h directly directory displayed displaying divide earlier earliest edf edf.c edfproc.c effort enum equivalent etype event events examined exceed except exhausted expel expelled explained expressed fail fails fasthz fd file files forfeiting fprint functionality guarantees happens hold hundred i.e id identified identifying iff immediate implies include indicate inherited initiates instance instruction int integer intended intervals invalid letters limitations list listing load loads log longer lower machine machine's maintained meet membership microseconds milliseconds minimum missed mixing mode modified monitoring ms multiprocessors names nanoseconds naturally nature nblog nearly needs non note ns nsec occur occurred opened opening operator operators ordered ordwr parameter parameters periods pid pipeline plan plus points port practice precision preempt preempted preempting presented prevented primary prints proc proc's process processes processframe processor processvideo procs produces programmable programmers progression provides queues quote quoting rarely ratio reached read reading readmitted real realtime received receiving release released releases remaining remove reported representation require resource resources resulting returned returns rtstats run runnable running runs sadmit says sblock schedevent schedulable scheduled scheduler schedules scheduling sdeadline secondary seconds self settable sevent sexpel sharable share shared shares sharing slice slightly source sp space spends spent spreempt src srelease sresume srun sslice started stream string struct structures subtracts succeeds syield syntax sys sysfatal takes task task's tasks temporarily test therefore thousand ticks tid time times total trivial truly ts type typedef unit ushort using utilization value verbose version video vlong void voluntarily voluntary whichever write writing yield yielding yieldonblock realtime	3/realtime
 20th beware bugs cal cal.c calendar century christian cmd colonies considered current england era historically january larger letter lower month months naive omitted prefix print printed prints produced refers sep source src sys try twelve cal	1/cal
 22nd cmd copies file files input interprets lines newline option output p.c page paginate pass quit rest shell source src standard stopping sys user wait waiting p	1/p
 26e522ade2bbb2a229 9psk1 accomplished account actions acts actual add addition additional address agent allows answer anyone apop append asaddr attack attempt attibutes attr attribute attributes auth auth_challenge auth_proxy authenticate authenticating authentication authinfo authsrv avayalabs.com boot boyd bytes callee caller challenge channel chap checks chosen clear client cmd collection comments communicate confiming confirm confirmation confirmed confirming conjunction connection consist consists contains control copies cpu cram create cryptographic ctl data database ddksun debug debugging default defining delete delimited delkey denied depend depends describe described determines dev dictionary directory distinguish dk does.it.matter doesn't dom domain don't e.g ek embodied ending entering error exactly exclamation exclusive execution exist exists exit extend external factotum failed fails fetch fgui fields file finally follow format formats forth further generated graphic graphical haveai hex hexadecimal hides hostowner i.e id identify identifying identity inbound include independent indicates input interface interleaved isn't kept kernel key key.pem keypair keys kp kq length level lib library list lists log looks lucent mail maintaining management managing mark marshaled match matches matching maximun mesages message messages metaprotocol microsoft missing mit.edu mnt mount mschap mtpt mutual mutually ndb necessary needed needkey needs negotiate negotiation nerdsrus network non null nvram ok onto opened opening option options ordered outbound output p9any p9cr p9sk1 p9sk2 pair pairs particular party pass password passwords pem performed phase plan pop3 possessing ppp pptp preceed presents presotto private proceed process processes programs prompt prompting prompts proof proprietary proto protocol protocols prove provided provides query querying random read reader reading readnvram reads remain remote replace replies reply represents request requests require required requires response responses restarted restricting retrieve retrieved retry return returned returns role routines rpc rpc's rsa rsc running runs secret secretpem secstore section sections secureid select selectors send server servers setting shared short shuttling similar singe size sometimes source space speak speaksfor specifies specify specifying src srv srvname ssh ssh_genkey sshrsa standard started starts stored strictly string strong structure subsequently succeeded successful suitable supplies supports syntax sys tag tagno tb template templates time toggle tokens toosmall total tracing tuple tuples turns typically unchanged unformatted unhides uniquely usage user users using val valid validating value values variant verb verbs via vnc waits whenever window write writes writing written x.com xxx yes factotum	4/factotum
 2sa advances ansi arrow background backup bar black bottom buffer bugs button care carriage character clear cmd color columns communicating con configure connecting control cooked cr crnl dec display echo emulate emulation emulator enter entries environments eot equivalent exit exits expected fills forces foreign forward fresh hold host i.e input instance interpretation key leave linefeed lines menu middle mode modes move necessary newline nl nlcr non options page pause plan poor print proceeding processing provide raw rc receiving recovered replaces reset resize return rich right_key rio rows running saner scheme screen screenful scroll send sending session setting shell snarf sort source src substitute sys systems terminal text typed typing unix using via visible vt wait window vt	1/vt
 3440ct 3480ct accupoint accupoint.c add approximation automated automatically aux baud behavior bin bugs button buttons click cmd communication compatible configuration configure configured configures cons control converting cpurc cursor default dependent determine dev device difficult dr due e.g effectual enable events exited extra fail fast flag generate generates ii initialization intellimouse interface keypad knows laptops lib limitations logitech mice microsoft mouse mouse.c mouseport option overcomes peculiar pipefile plan9.ini pointing port portégé process processes produce profile properties provides ps2 ps2intellimouse queries rate reasonable regular release released repeat reports restart rio running script scroll scrolling serial setting simulation simulations slow source src string sys termrc time toshiba type types user usr wait wheel mouse	8/mouse
 386proto 9fat 9load 9pcdisk active administration autoexec.bat autoexec.p9 backed backup bin boot boot.ini boot.p9 bootfloppy bootplan9 bootstrap bootwin9x bootwinnt byte config.p9 config.sys contained copies copying creates current dev directory disk distribution drive edits environment exist fat file files fileserver floppy floppydisk formats initialize installing kernel kfs lib loader machine main maintain menu minimal mkfs mounted msdos.p9 msdos.sys nt option partition partition's partitions pc personalize plan plan9.ini plan9.nvr prep prepare private programs proto prototype provide rc removes runs scripts sd sdxx server setup.9fat setup.disk setup.kfs source sys sysconfig systems time update updates user usr variable various ways windows zeroed update	8/update
 39cdeffkjrtv 39cdektv accept adjacent alpha animated animation appearance assemble attaching automatically avoids behavior bits black bugs capability card channel character clumsy cmd color comment compression control convert converted converts current debugging decompression default defined del diffusion disable display displayed displaying displays driven error exits extra fast fields file files floyd forever format formats frames friendly full gamma gif glory grey image images improve index input interface invokes jpeg jpg lml loop loopcount mapped menu merge milliseconds motion movie msec navigation negative offers option options originally output page panning particularly pause picture pictures piped pixel plan playing png ppm primarily process processing produce programs read rendered represent representation representing resulting rgb rgbv saves scale scrolling share source specifies src standard steinberg stop suppress sys time times togif topng toppm transindex translates transparency typically typing uncompressed undertaking user using value video view window write writing jpg	1/jpg
 3des accept add address adm allocated allows args attempted attempts authenticate authenticated authentication authlist authsrv aux basename blowfish bootes bruce capability carriage challenge channel character choice ciimpprrw cipher cipherlist ciphers client clients cmd colon con confirmations connect connection connections cons control controlling convince cooked copy daemon daemon's data decipher default defined deprecated des described descriptor details dev differentiates dir disable disconnecting discussion domain doubtful echo enable encrypted encrypting encryption error escape establishes except execute executed exit expected factotum favor file files forwarding full functionality gathered generate generates grounded host hostkey hostkey.public hostkey.secret hostname hosts identified input insecure interactive ip key keyring keys legitimate lib list listed login looks lu machine mandatory manner matches menu method methods mode moderate mounted mtpt namespace namespace.noworld necessary net netkey network non none notify noworld offers option options ordered outgoing output owned password passwords personal plan preferred presents presumably printing private prompt prompts protocol protocols provide pseudoterminal pseudoterminals raw rc4 read readable received rejected remote reports request requests response responses return returns rfc rsa run running runs satisfied schneier's scp screen secret secret.factotum secure securid sends server server's servers services session shell sides size somewhat source space spaces specify src ssh ssh_genkey sshnet sshserve stack standard started strip style support syntax sys systems takes tcp time tis tis_authentication toggle token tradition triple try unix unlike unrecognized usage user users using usr valid variation via whenever window writes writing ssh	1/ssh
 3des_ede_cbc accepted active alert alerting alertno alerts algorithm algorithms allocated anti application authentication automatically base based behavior bind boundaries buffer bytes canceled categories category changecipher channel channels clear client clone closed code comes communicated communications configured connection contains control controlled converted correspondence ctl current data datain dataout datum decoding describing descriptor descriptors device devtls devtls.c dial digest digesting directory divided enable enc encalg encalgs encin encode encoded encout encrypt encrypting encryption error errored established exactly exchange executed extra fail fatal fd fields file files filter filters follow format further future halted handin handout handshake handshaking hash hashalg hashalgs hashin hashing hashout headers hexadecimal hungup implement implementations implements include incoming initialization initially inserted integral interrupted isclient issued key keys layer length level lines list listen localclosed mapped maximal maximum md5 message messages mutual names net newencin newencout newhashin newhashout newly non notify numbered offending opened opening operation operations optional outgoing outside packed padding pass pending populate port potentially precede protocol protocols providing rc4_128 read reading reads ready receipt received reclaimed record records remoteclosed renegotiation reserves responsible return returned returns secret secretdata secrets secure security selected send sends sent server session sha1 significant similarly size sockets source space src ssl3 sslv3.0 sslv3.01 stats status string stripped subdirectories successful supported synchronize sys tag tagged tags tampering terminate text textual time times tls tls1 tlsv1.0 trailers transport traveling tries underlying unless user using valid value vectors vers version versions visible write writes writing tls	3/tls
 3½dd 3½hd 5¼dd 5¼hd accepted access bind control ctl data density describing dev devfloppy.c directory disk drive drives eject factor fd0ctl fd0disk fd1ctl fd1disk fd2ctl fd2disk fd3ctl fd3disk file floppy format formatted include interface level messages partitions prep read reset returns serves source src string sys type floppy	3/floppy
 48x48x access address addresses aliasmail altering append appended arg bin box caught chmod contained create created dead.letter delivery destination details directories e.g es everyone exclusion exclusive executable exists faces file files filter forward forwarded forwarding gremlin icons incoming invokes it's l.mbox l.reading lib lock log loops mail mailbox mailboxes marshal mbox message mlmgr mode mutual nedmail none option options pages path piped pipeto preparer qer rc readable reader readers recipients resolved rewrite run script seemail send shell smtp source sys unless upas upasfs user user's username using writable mail	1/mail
 48x48x account acme ad add added address addressable addresses affect aliasmail allow altering alternate announcements append appended applied args atomically attachment attachments attributes backwards bcc becomes biff biffing bin binary bodies box bytes cc characters closed cmd contains content contiguous control create created ctl current date dead.letter default defaults delete deleted deletes deleting deletion delivery described digest dir direct directories directory disappeared disposition doesn't don't ed edits entire envelope eot es escape essentially exclusion exit exiting expression faces file filename files filetype filter fool format forward forwarded forwarding fs full generates groups header headers here's hierarchical howard html icons id implies included indicate individually info initially inline input inreplyto intended interrupt item jmk l.mbox l.reading length level lib lines lists lock log looks madeup.net mail mailbox mailboxes mailfile mailfs mailtype mark marshal match matches mbox mboxname message messages mfile miles mime mimeheader minus mixed mlmgr mount movement multipart mutual names nauseam nedmail none noone northwest.htm northwest.html notice numbered omitted opens option optional options original output overridden parse particular path person persons pipeto plain plumb plumber plumbing port possibility presents presotto print printed printing produced profile prompting provide provided range raw rawbody rawheader rc read reader readers reading reads received reception recipient recipient's recurse references regular relative remove removed renumbered replies reply replyto representing reread resides reverse rewrite rf rfc822 rio rules run save saved saves search seemail send sender sendername senders sends session sha1 shell size smtp source space specifies src srv standard stands starts stop stops stored stripped structure structures style subject subpart subparts summary sys takes telnetting ten text time tmp treat type undecoded undeleted unixheader unless unrooted upas upasfs updated user username vwhois whenever window write written xxx yourself yyy.net nedmail	1/nedmail
 5am 9fs access accessed added alone anded appended aside attach attenuated authentication background based belonging bin bits blocks boot bugs cache cached checking combination compiler computer configuration connection continued copied created daily date dd december deciding deny directories directory disabled disk disks dump dumped dumps edition effective emelie emelieother etc ethernets except february file file's files fourth frozen fs fsconfig full halted hill holds il ip kfs lp ls magneto main maintains march minimal mips mirrored mm mmdds modified month mount murray newly noauth non none noworld null numbered occasionally optical output overcome packet permission permissions plan portion practice privileges process property protocol protocols provide quinlan read recently relabeled requires root runs sean serve server serves similar sniffing software source specifically speed src srv stand subdirectory sys systems third tickets time times traffic uniq unwritten user user's users using vc version versions via walking worm write yesterday yyyy fs	4/fs
 80105ac6 80105bc1 80140bb4 8048e16c acid bugs cmd consists correct debugged dump dumps edited examining fields hexadecimal interested interpret interrupt interrupts kernel kernels ktrace ktrace.c lines link location locations machine memory mips option pasted path pc points printed prompts provide rdbfs readable register resulting screen series shell source sp src stack sys topmost trace translates values window ktrace	1/ktrace
 8fe472d31b360a8303cd29f92bd734813cbd923c applications attr attribute attributes authentication authorities based binary calling certificate check checksum cn comments comparing comprises convention cs.bell file files hex include key keys labs.com lib lines list lists maintained okthumbprint pairs permissions pki plan playing policies protected pushtls remote role server servers sha1 side's stored sys systems thereby thumbprint thumbprints tls tlsclient trusted value web thumbprint	6/thumbprint
 8lux arg argc argv bugs char cs current discover fetch firstarg getcallerpc include int libc libc.h main necessary objtype parameter pc pointer portable print printpc return source src sys u.h ulong void getcallerpc	2/getcallerpc
 9660srv 9cj 9cjr access added additional allproto amounts applied backup base based bios block boot bootable booted bootes bootfile cd cdfs cdimage cds character characters clones cmd colons common conform conform.map conformant conforming create created creates current data debugging default described digits directories directory disk dossrv dump dump9660 ease entry error exception exclusive exit extensions fat fields file file's files flag floppy format formatted freely fs full grow image images immense imposed inverse iso january joliet key larger length letters lib listed loaded map maximum maxsize metadata microsoft mixed mk9660 mkfs mode mutually names naming nnnnnn non option options output owner path plan plan9proto platforms pointer pointers populated posix process proto protocol provides random read relative replace restrictions reverse rewritten ridge rock root scanned seconds sharing similar size source spaces specification specifies src standard status stored style sys sysconfig systems time title translated tree underscore unicode unix unspecified updates usual utf versions volume windows writes writing written mk9660	8/mk9660
 9660srv 9fat access accessible actually allocated allocates allows arrange attempt attempts attribute attributes bin bind bit bits block boot booting bugs caused cd cds channel characters choice clients cmd communications component concept confusing contains contiguous contiguously corresponds creates creation debugging default describing descriptor dev device directly directory disk disks dmappend dmexcl dos dosmnt dossrv drive drives eject ejection except exclusive execute explicit explicitly fail fat fd0disk fields file file's files fills flag flags floppy guarantee helps holding ignore input instance instructs interprets iso9660 joliet kernels kfs laid map merit microsoft mode motor mount mounting mtpt names non null operating option output overloading partition permission permissions pipe plan posts prep prevents provide provides raw rc read removing restricted rom script scripts semantics server setting shell shorthand sierra similar simultaneously source spec specification spit src srv standard stat stored succeeding succeeds sys systems th therefore third treatment tree trees try typically undefined unicode unless unmount user verbose via write wstat dossrv	4/dossrv
 9660srv 9fs access alone attach box bugs cdrom chess copies covering descriptions digitized disc discs dossrv dss eg file games juke jukefs locally mount plan plan9.1992 plan9.1995 release replaces running scat server simulation sky specifier stand stores subdirectory survey zz juke	7/juke
 9660srv access add appended audio aux avoid blank buffer bugs capable care carries cd cddb cdfs cds character cmd cnnn compliant contains control copy copying cp created ctl current data database default desired dev device directories directory disk diskid dossrv drive drives dtt dumped dvds easy echoed eject ensure entire file files fixate fixated fixation freedb.freedb.org grep ingest inserted internet kept kpbs level lines maximum messages mk9660 mkdir mmc mnt mounted mtpt nnn note ntracks onto operation option optional output permanent prefix prints provides query quickblank raw rc read reader readers reading real recommended regardless remove removed reset response rewritable rm round run saturated sd sd05 sdd0 sddev selects separately server serves simply songs source speed speeds src standard stored support supported sys table takes time tmp total track track0id tracks type underruns wa wd writable write writer writers writing yields cdfs	4/cdfs
 9apc 9apccpu 9ch 9fat 9load 9pccpu 9pccpudisk able accept address alpha arc behaves bell boot boot_file boot_reset bootalphapc bootdef_dev booted bootf bootfile booting bootp bootstrap bootstrapping bugs challenge collects conf configuration configure console consoles control cpu default described details device dhcp dhcpd disk diskless distinct dos download downloaded essentially ethernet ewa0 ewa0_inet_init ewa0_protocols expected fat16 file files firmware floppy format fs generic happens http incantations init installation ip kernel labs lib load loaded loading loads locates lower machine machines manual memory mentioned methods mips monitor multi multiprocessor ndb necessary none obtained omitted page parameter particular partition pc pcs plan plan9.ini powered prep prepared procedures proceed programs prompts protocol protocols reach read rebooting reboots regular replace request required reset rom root run running secondary server servers services setenv sgi source sources specific src srm stored string substituting sys system:file t's template terminal terminals tftp type typing understand unix user using value variable various via ways www.compaq.com booting	8/booting
 9auth 9fs 9nfs access addr address allow answer assuming auth_tooweak authentication authorizes aux bin blank bootes bugs cache caching chat class clears client clients cmd collectively completely configuration contains cpu cpurc creates credentials cvrd daemon database debug debugging deduced detail dynamically echoed echoing edu eduardo eduardo:bootes eduardo:fornax entry error etc executed expression fields file files flag format fornax gid hall hour id's il instance intended internal ip ivy level lib lines list log low lower machine machines map mapped maps messages mount ndb network nfs nfsserver nfsserver.chat nice none notation note options passwd password pc pcnfsd plan portmapper privileges procedure programs protocol provide query rc read regardless regexp regular reject remote repeated reply requests returning rfc1057 rfc1094 rpc run security server server's servers soft,intr source space specification src srv started startup subsequently sys systems tcp toy trusted typical typically uid unix user users using verbose version via zz nfsserver	8/nfsserver
 9bitsy backlight bin bitsy bitsy's bitsyload boot boots button calibrate calibrates calibration center characters clicking cmd compaq configure consistent copies cpurc creates crosses default del destination dev dimmest direction display displays doesn't drawing echo editor erases esc eval exit file flag flash format grep input inputs intensity ipaq kernel key keyboard keys load loader loops maximum memory mousectl mp opposite option optional pad parameters params partition pencal pressing prompter prompting ramdisk ramfs rc required rio run screen scribble section selects source specific src standard starts stylus suppresses sys tapping text tmp tmpparams touch touches typing unless updated user using utilities value values variables virtual write writes writing bitsyload	1/bitsyload
 9dos accesses actual addr address aid arrow attach authdom authentication authid automatic automatically behaves beyond binary bind binds boot bootes booting bootp brackets break built cache caches cfs challenged clients compiled complete completes connect connected connection connects console control cpu cputype crafts ctrl data default depend depends describe determine dev devices dhcpd dial directly discussion disk domain dos dumb encryption env environment ethernet except exec exists fields file files fkm flag fs holder id identify il ing init initializes insert interactions ip items kernel key labs.com lets level list listed lists loaded loading machines mechanics memory method methods modem mount mounts mutual namespace needed network newline none numeric nvram objtype onto option owner owning partition pass password pc pc's pcs performs picks plan plan9.ini prints process processes processor prompt prompted protocol read reboot reformat remote research.bell responses rom root run sd sdc0 seconds send serial serve server servers setting simulates simulating sole source specific specifier src started starts stops store stored structures sys tcp terminal type typed types typically unit unix user user's username using valid value variable variables varied vendor via view xx boot	8/boot
 9fans ability accepted accepts accumulated actions actually added additionally administrative aggressive algorithm allows amount analysis applied applies args ascii assembles automatic avd backslash based block blocking border bugs cancels canonical canonicalization canonicalized cases character characters cmd collecting combine comment commonly compile compiles complete confined consecutive contains continuation continue continues control conversion convert converts copies copy counting criteria cse.psu.edu data date debug debugging decreasing default define delayed delete deleted deleting deliver deliverable delivered delivery desirable destination detecting determined dev directives directories directory disabled discarded dispatches domain double dump dumped efficient elided enable enclosed engine entry enumerate equivalents error escape essex.com exactly except excluding executed expression expressions facilities fields file filename files filter filtering filters finally finds further gateway generally generic harmful header highest hold holdroot href html ideally img implementing inadvertently included incoming indicates indicator input insignificant inspection instances introduced introduces keyword lasex.com layers leading leaving legitimate letters lib likely limiting lines list lists loff log logged loops lower mail mailing manual manually match matched matcher matches matching material meshes message messages mime missing mode newline none notified occasionally occurs optimization option optional options ordering override overrides owner parameters pass patfile pattern patterns personal phrases pipeline pipeto portion potentially print prints priority process processed processing programs provide q.v qer qmail queue queue.dump queue.hold queued queues queuing quote randomly rc rcpt read recipient regexp regime regular repetitive replaced replaces report results review root runq salvaged save saved scanmail script searches section selects semi sender senders sending seq sequences sex.com sharing similar size smtpd source space spaces spam spec specific specification specify src standard stored strategy string strings structure stuck style subdirectories subdirectory subjected successfully supported supporting sussex.com swept syntax sys sysex.com systems tabs test testing testscan time times tool trigger type unaware undesirable unique unlike unlikely unwanted upas updating user user's using utility vacation version viruses wiser write written scanmail	8/scanmail
 9fat accessible ad alphas anamelen answer array asgetresp asgetticket asrdresp attribute auth authdial authdom authdomsum authentication authenticator authenticators authid authidsum authkey authsrv authsrv.h authsum buf bytes char character checksum communicating config configlen configsum connection cons contains conva2m convert converted converts convm2a convm2pr convm2t convm2tr convpr2m convt2m convtr2m cs decrypting default des deskeylen diagnostics dial dialed dials dom domain domlen dos drive encrypting entry error errstr fails fd fields file flag floppy former include int integer key len libauthsrv libc.h machines machkey machsum match mem message messages mips msg ndb net netroot network nil non nv nvcsum nvram nvrsafe nvwrite nvwriteonerr opens partition passtokey passwd password passwordreq plan9.nvr pr precedence prompt queried ram readnvram reads received receives reception recieve request requests respective return returned returns rooted routine routines sd00 sdc0 sends server servers sgi source sparc specifies src stopping storage stores string struct structure structures succeed successful successively sys tbuf ticket ticketreq tickets tr transmission transmittable trbuf u.h uchar value valued values void volatile write x86s zeroed authsrv	2/authsrv
 9fs 9powerboot add address adds anna anna.cs.bell astro attr attribute attributes auth authdom authentication authsrv aware bind bootes.research.bell bootf bootstrap chosen class closest comments common composed comprise con connect consider consists cpu cs database decide declares default describing dhcp dhcpd dial dialstring directly dns dnsdomain doing dom domain domains download entries entry ether ethernet exchanger exists file files flat floor fs gateway global hill host hosts i.e identified identifies il impose included indirectly installation internet ip ipconfig ipgw ipmask ipnet ipsubmask it's knowledge labs.com level lib lines looks lowest machines mail mappings mask meaningful metaname metanames mh mips missing multi murray mx names ndb ndbipinfo needed net network network's networks ntp ntp.cs.bell numbered oncore.cs.bell onto ordering p9auth.research.bell pair pairs particular perform plan plan9 port ports programs proto protocol publicly r70.research.bell redefine relative relevant reserved restricted rexec root routine routines running search searched searches server servers smtp smtp1.cs.bell smtp2.cs.bell soa sometimes space speak specific specify spindle spindle.research.bell starts structure subnet subnets subnetted support supported supports sys sysmon tcp third tighter time times tuple tuples udp uniquely unix unrooted users using value values windows wins works ndb	6/ndb
 9fs abccd abccmq access addr allow apply authenticate authentication automatically bin bind blanks boundaries calling characters cmd compatibilty complaints connect connecting connection connections contains control conventions cpu creates debuggging deepthought deepthought's dial dials directly directs dump edition enable establish examine existing exists explicitly file files filter flag flags fourth ftpfs hack hhgttg il initializes input insert internal kernels kgbsun kremvax kremvax's likeliest log machine maintain mentioned message messages mount mounted mountpoint mtpt names necessary needed net network non none note older omitted ones onto option options output performs plan port ports post posted process protocol provided quoted rc received recognizes remote run script serve server servers servicename services source src srv srv.c srvname srvold9p standard string suppresses sys systems tcp translation typically u9fs underlying user users value variant version windows srv	4/srv
 9fs absolute accepts acme acme's acme.dump acmeaddr acquire actions added address adds adjusted adm alphanumerics alternate analogous angle anywhere append appended appends applications applied apply applying appropriately arrange arranged assumed attention automatic automatically awd awd.c backspacing bar based behaves behavior believes bin binaries bind binds bit black blank bottom bound box brackets buffer bugs built builtin button buttons capital cd center character characters checking chord chords click clicked clicking clicks cmd colon column columnated columns combine common compilers complement completely complex components contained contains context continues control convention conventionally conventions copy corner cputype create created creates current cursor cut data date default defined definition del delcol delete deleting delivered described diagnostics dies directly directories directory dirtiness dirty discussed display distinct documentation double drags dump e.g easier echo edit edited editing efficient employ en enclosed ends entire environment error errors esc etc euro.8.font evaluated evaluates except exception execute executed executes executing exist existent existing exit expands expansion expected experimental explicitly expressions external extra feature file file.c file.c:27 filename files final fix fixed fixfont fn font full fully further future grows guide hiding highlighted hold holding holds id idea identical identified image implicitly import incl include includes indicate indicated indicates indicating informal inherited initiated input ins instructs intended interactive interactively interface interpreting intervals investigate invoke it's key keyboard keys kill killed label labeled language largely largest layout leaves leaving letter lexicographical lib list lists literal live load loaded loads locate longer lost ls lucidasans lucm main mainly maintained maintains manages masse match matches mc meaningless mips mk modified motion mouse moved moves moving multi names ncol near necessary needed needs newcol newly non none note null numeral objtype occurrence occurrences occurs op opening operations option original output outputs overridden particularly parts paste path pike pitch placement plain plumb plumbing pointed pointing possibly pre prefixed prepared pressed pressing print prints produce produced producing programmers programs proportional provides purely putall pwd q.v qualified rate rc read readme real receives recently recognized records recreation redo refers regexp regular related release released relevant repaired repeatedly replace replacing required rerun reside restore restricted resulting return rio rob rule rules run running runs sam sam.c sample scratch scroll scrolling search searched searches select selected selecting selection selects send sent served shell similar slash slightly slowly snarf sort source space spaced specific speeds src srv standard starts stops store stored string strings style subdirectories subdirectory succeed sufficient suffix suffixed suit superseded supplementary support sweep sweeping sys sysname tab tabstop tag tags takes template temporarily text textual textually treat turning type typed typically typing unaffected undirtied undo undoes unexpectedly unicode.9.font uniformly units unless upper usefully user users using usual valid value var varfont variable variables versa vertical vice visible warning whenever width widths win window window's windows write written zerox acme	1/acme
 9fs accept access add address altogether ansi assumes atomicity attach attaches autharg authenticate authentication authtype binary bind block box bug bugs cases chatty clients cmd coming compile compiler connected connection connects consulted controlled copy data debugging default descriptions determine device devices diagnostics digit directory discouraged dnz domain due edition editions effective enables entire entries etc ethernet exactly except execnet file files flag forbids fs greater hard hosts.equiv id identical implementation inetd inetd.conf input install intro invoked ip kremvax library lines listeners log logfile login machine machines mainly match maximum mechanisms message messages method mount msize multiplexes names network networks nfsserver none nowait onlyuser option options output password permits plaintext plan port procedure process processing produce protocol provide remote remove reported requests results rhosts root run running runs ruserok semantics serve serves services signals size software source space specifier specifies specify specifying src srv ssh standard started startup stream sys systems tcp thinking third threaded time tmp treat truncate try turns typically u9fs u9fs.key u9fs.log uid uids unix unpredictable unpredictably unsatisfactory user users using usr usual via wire write wstat u9fs	4/u9fs
 9fs actions actually addition allow appends applicability applying assumed based bell bind careful carried carry central check client client's clientdb clientexclude clientlog clientmount clientproto clientroot clients cnsv configuration configured conflict conflicting conflicts connected connection copied copies copy cpu database define deleted deletion described describes describing details detected developers dials dir directory disallow disk dist distribution doing edition entries event events except exclude fast file file's files flag flags fn fourth gid inner installation installations instant interface internet intervening invoking keeps kept kfs kfscmd knowledge labs laptop length level lib list locally log looks low machine maintained management manually mean mechanism merely metadata mode mount mounts mtime network notice nv one's operation path paths plan plan9 plan9.db plan9.log plan9.proto polished potentially primarily print prints programs proto provide pull push pushed rc reading relative replica replicas replicated report require rescan rescans resolved returns root run running runs scan scans script scripts server server's serverdb serverlog servermount serverpath serverproto serverroot serverupdate shell simply simultaneous sources space specific specifies stat status structure successfully summary synchronization synchronize tools typical typically uid update updates using variables verb wider workings written replica	1/replica
 9fs activity actual addition additions annulled annuls appending applies applychanges applylog assume assumed atomically attempt based bin bugs character cl cli.portproto.db client client's clientdb clientroot clients cnsuv collectively combined compactdb conflict conflicts connect connection consider copied copy copying cpu creation current database databases date db decimal default deleted deletion deletions described describes describing detect detects developers dir directory distribution enables entries equivalent error essentially event events excluded excludes facilitate favor fields fifth file file's files flag flags fs full further future gen gid ignoring incremental incrementing indicator input intended interface invoke kept kfs length lib listed listing log maintain management manual manually metadata mode mtime mv necessary network noting nuv omits omitted ones operates opposite option optional ordering outdated output overwrite overwrites page path plan polished portproto prints process propagate properties proto provide providing rc read readable reads records remote removed repl replica replicated report reported resolve resolved resulting root rooted run scan scans scripts server serverpath serverroot shell silently similarly sorted specify speed srv.portproto.db srv.portproto.log standard stat string structure subsequently summary supersede sync sys sysconfig takes textual time times tmp tools typically uid uids update updatedb updating using verb version writes writing replica	8/replica
 9fs.org array assembled assembler assembles author aux cmd code control controllers defines device driver enums file guide included instructions language loadable logic microcode na ngr nigel operation patches pci processors programming roles scripts scsi sd53c8xx.c sd53c8xx.n series source src sym53c8xx symbios sys version written na	8/na
 9p.h 9pfid 9pfile abort accept accessed active actually additional address afid allocate allocated allow alternate amount analogous appropriately arbitrary archfs arg argbegin argv0 arrange arranged arranging arrive asynchronously attach attempt auth authentication aux auxiliary avoid avoided bad behaves behavior block buffer bugs bytes caller calling care cdfs chance char chatty9p check checked child clean cleanup client client's clients clone clunked common conditions consider considered constraints consult consulted consulting consults contained contains convention conversation convert copies copy copying count create createfile creation data debugging decoding default demands depends described desired destroy destroyfid destroyreq detects differences dir direct directories directory dirgen dirread9p discussion dispatching dispose draw drops e.g easily elsewhere emalloc9p endsrv enforce ensure entire entry erealloc9p error errors estrdup9p etc exception executes exists exit exits expected explicit extant extern fail fails fcall.h fd fid fids file files fill filled filling fills final finished flag flags flush flushed fork freed fresh freshly full further future gen generated gracefully gratuitous greater handle handled handles highly i.e idea ifcall ifcall.oldreq implementation implementations implementing include incoming increment independent indirectly infd info initialize initialized initializes initializing int interface internal internally intricate intro kept lib9p libc.h library link loop machine maintained maintaining malloc mark measures memory message metadata minus mtpt multithreaded necessary newfid nil nntpfs non nopipe note nqid nsrc numeric nwname obtain occurs ofcall ofcall.qid ofcall.stat offset oldfid oldreq opened operations opportunity option optionally ought outfd outgoing outlined output outstanding palm parameter parameters parent path's permissible permissions pilot pipe pleases pointer pointers post postfd postmountsrv printed proc process processes procrfork programs prohibited promise prone provide provided prudent qid ramfs ramfs.c reached read readbuf reading reads readstr realloc reclaim record reference referenced references referring remove removed removefile reply representation req request requested requester requests required respond responded response responses return returned returning returns reuse rffdg rfmem rfnameg rfnoteg rfork root routine rule run runs satisfied satisfies satisfy satisfying sent serial server servers serves session setting sharing short signal similar similarly simply snap source space src srv srvfd srvname ssh sshnet standard stat stored strdup string struct structure structured structures success successful successfully suggested switch synchronization sys sysfatal terminate terminates th thread thread.h threaded threadpostmountsrv tidy time transactions transcript tree tree's trees typedef typically u.h ulong uncompleted unmounted unspecified updated updating user using variable via void wait walk walk1 webfs wire wname wrappers write writes writing written wstat 9p	2/9p
 9p.h 9pfid 9pfile active addition allocated allocfid allocfidpool allocreq allocreqpool analogous auth.h authentication aux based chan char cleanup client closefid closereq connection contains count counted create creates creating derives described destroy destroys destruction due equivalent exception extant fcall fcall.h fid fidpool fids file flags freefidpool freereqpool hold ifcall ignore include increment integer intended involving kernel lib9p libc.h lingering longer lookupfid lookupreq loop management mean member mode necessary needed note ofcall oldreq omode omode&omask opened operate ordwr oread owrite parameter particular perform permissible plan points pool primarily provide qid read reference references regarding removed removefid removereq removes represent req reqpool request return returned returning returns routines server source specific src struct structure structures successful sys tag thread.h tracking transaction tree typedef u.h uid ulong using values various void walk whatever 9pfid	2/9pfid
 9p.h 9pfid access accidentally added adjustments allocmap anticipation arbitrary caller calling caninsertkey concurrent count counted counts creates creation current data dec decremented deleted deletekey destroys entries entry external fcall.h fidpool freed freemap id implement inc include increment inserted inserting insertion insertkey inserts int integer integers intmap intmap.c key lib9p libc.h library lock lookupkey maintain map mapping maps moderated non nor pointer pointers protected qlock rationale reclaim reference removes reqpool responsibility return returning returns safe similarly source src storage stored structure structures sys thread.h time transfers typically u.h ulong val value via void intmap	2/intmap
 9p.h 9pfile additional aexec alloctree allow aread assumes attempts auth.h automatically aux awrite bits bitwise buf buffers bugs calculate calling care char checking checks cleanup client clients closedirfile closefile code complex concurrent consider consume copying correct correctly count counted counting create created createfile creates creating cumbersome described destroy destroys dir directories directory elem elementwise entry error evaluates exist explicitly fcall.h file file.c files finished foo freed freeing freetree gid groups handles hasperm hierarchy implementation include incref independent inherited int integral intended intermediate lib9p libc.h link lock machine memory mode necessary nf nil nls non note obtain opendirfile owned owner path permissible permission permissions pointer pointers provide rdir read readdir readdirfile reading ref reference references related relative removal removed removefile removes removing resulting return returning returns root server servers simplistic slash source src standard stat storage struct structure structure's structures success sys thread.h tree trees typedef u.h uid ulong update user using void walkfile walking written yield yielding 9pfile	2/9pfile
 9pc acid cmd console consolefs control copy db debugged debuggers debugging default dev device directly eia0 enter file files kernel kernels lines mode panics pid port presented presents proc process protocol provided rdb.c rdbfs rdbfs.c remote remotely serial serving source src substituted suspended sys td text textual typing using rdbfs	4/rdbfs
 9pc acquired address addresses administrative allocate application arranged array ascii attr attribute attributes attrs aware base binding bio.h bootf bound buf buffer cached calling chain char checks circular closes cname computes concatenates connection consider copies corresponds create csgetval csipinfo data database databases db db1 db2 defaults dept described describing diagnostics directly directory dns dns.big.com dnsquery dom domain domainname entries entry errstr exchanger exchangers expiration expire failure fieldin file files fill frees hash hlen identified implement include int internet ip ipattr ipmask ipnet ipsubmask it's length levels lib libc.h libndb lie lines link linked list logicly looking looks mail malloc match matched minimum mounted mx nattr ndb ndb.h ndbalen ndbcat ndbclose ndbfree ndbgetval ndbhash ndbipinfo ndblookval ndbopen ndbparse ndbreopen ndbs ndbsearch ndbsnext ndbtuple ndbtuple's ndbvlen net netroot network networks nickname nil ns null offset opened opens operate pair pairs parse parses particular pointed pointer pointers points pref preference primary programs protocol ptr queries query rattr reads real record refresh reopens represent representing retry return returned returns reverse root routines search searched searches seconds sequential serial server servers smtp smtp.big.com smtp1.big.com soa source specifies src starts storage string struct structure structures submits subnets subnetwork successful successive sys system's table tables takes throws tighter time ttl tuple tuples type typedef u.h ulong using val valid value void wraps x.big.com ndb	2/ndb
 9pcdisk accumulated accumulates array base bind byte clock controls count counter counts data depends dev device devkprof.c echo endian file formats hold holds integers kernel kpctl kpdata kprof message occurred operating port presentation prof profiling provides range rc recording reports rest restarts results running runs runtest script size source src startclr stop string sys terminates test text tick ticks total writing zeroing kprof	3/kprof
 9pcon 9pcon.c absent added address afid aname arrive attempts automatically aux binary bugs byte carry cmd cn connection conventional conversation count data default descriptors dial dir ease easy established exceptions expanded facilitate fid fields file flag getfields gid id inferred input integer interface interpret interprets intro length lines message messages mirrors mode msize mtime network newfid note nwname offset oldtag opaque opened parsed pass perm prints prompt provides recognizes responses run scripting section sends server source specifying src standard strings syntax sys tags tattach tauth tclunk tcreate text textual tflush tokenize topen translator tread tremove tstat tversion twalk twrite twstat typed uid uname version wait wname wnames wstat 9pcon	8/9pcon
 9sys 9syscall able affect ancestors becomes bss built child clean closed collect copied copy created current data default dereferencing descriptor descriptors diagnostics disallowed dissociated env environment errstr exclusive exit explicitly file files flags fork fork.c forking id ids include inherits initialized int integer intro invoker's invoking isolated kept leave libc libc.h logical manipulate maximum member member's mount mounts mutually necessary note notepg notes parent parent's particular pathnames permits proc process processes range receive regardless rendezvous required resources return returned rfcenvg rfcfdg rfcnameg rfenvg rffdg rfmem rfnameg rfnomnt rfnoteg rfnowait rfork rfproc rfrend segment segments selects share shared shares sharing sleep source space src stack starts subset sys table tags types u.h unable unaffected value values variables void wait waitmsg written fork	2/fork
 9sys 9syscall access accessed accessing allocated anyone append associate atime attachment attributes beware bit bit16sz bits blocking buffer bytes care char check communicated comparing connections constants content conversions copied count counterparts current data deal defined described descriptor dev device diagnostics dir directories directory dirfstat dirfwstat dirread dirstat dirwstat dmappend dmdir dmexcl dmexec dmread dmwrite doing don't e.g edir entries epoch equal error errstr except exclusive execute fcall fd fields file file's files format freeing frees fstat fwstat gid gmt groups guaranteed id identifies include includes independent indicate initialize initializes int integer integral intended intro jan kernel knows leader leading length libc libc.h list locked machine malloc maximum measured member mismatches mode modified modifier modify mtime muid names necessary nedir network nil non nulldir operate operation owner parent passing path permanent permission permissions pipes plus pointer prefixed process provided qid read resides responsibility responsible retrieve retrying return returned routine routines says search seconds selects server servers setting short similar similarly size source src stat status storage streams string strings struct structure structures subtype succeed success successful symmetry sys time type typedef u.h uchar uid uint ulong unique unsigned user users using value values vers vlong void whenever write wstat stat	2/stat
 9sys 9syscall array boundary buffer bytes char character describing diagnostics discarded err error errstr exchange fails fit fmt format generated include int intro libc libc.h libraries mechanism modify nerr nul outputs pass perror print process property provides reads records recover rerrstr return returned returns silently source src string style swaps sys takes truncated u.h uint utf value verb void werrstr werrstr.c write errstr	2/errstr
 9sys a.d accordingly alternate anyway applies ascii asctime assumes aug boot broken bugs byte char clock constant consults contains content convert converts corrects ctime data date daylight delta determine difference directly edt env environment epoch equipped est fields gmt gmtime greenwich handle hemisphere hour hours ignores include init int libc libc.h list localtime mday mean min minutes mon month newline non overwritten pairs pointer pointers provincial range remainder requested return returned returns routines savings sec seconds sic source southern src static string struct structures sunday sys text time times timezone tm tm2sec typedef tzoff u.h values variable wday wed width yday zone ctime	2/ctime
 9sys abort abort.c access broken causing current debugger enter fault generate include inspected libc libc.h process source src sys u.h void abort	2/abort
 9sys accept accepts accessing acfd actual addr address addresses adir aid allocated allows announce announcing appended asterisk attempt attribute auth authentication avoided base bekremvax binding break buf buffer bytes caller callkremvax can't cfdp char closely closing common communicate communications complements completely conndir connection connections contains control conventions conversion copied copies cs ctl data default defnet defservice descriptor destination determined dfd diagnostics dial dialauth dialing dir directory dns domain e.g echo echoing eof establishes existing exists exits fail fails fd fd2path file files forcing forever fork forking freed freenetconninfo getnetconninfo guaranteed hang hangup holding host include indicate int ip ipconfig kremvax lcfd ldir length libc libc.h listed listen loop lserv lsys merge messages meta mount multiplexed ndb net netaddr netconninfo netmkaddr network networks newdir nil non obsolete obtained opened ordwr pair parameter path performing perror pointed pointer points port pre process read reading received receiving refuses reject remote replaced return returns root routine routines rserv rsys send sent server setnetmtpt simply sizeof slash source spec specifying src stands static string struct structure succeeds successful succession suitable switch sys takes tcp token tolen try typedef u.h udp using value variable void write writing written dial	2/dial
 9sys accept algorithms allocate allocated alternatively application arranged association attach auth authenticated authentication base bugs byte bytes caller cert cert.pem certificate certificates certlen channel char checked client communication communications comprises computed confirms conn connect connection convenient conversation copied copy creation crl ctl data defined described descriptor device diagnostics dial digest digesting dir directory doing encalg encoding encrypted encrypting encryption ends exits factotum failure fd file filename files fmt freed freethumbprints freshly full guaranteed handshake hash hash,table hashalg hashes implementations include initthumbprints input int interoperate isclient kernel key key.pem keys layer lcfd ldir level lib libc libc.h libsec libsec.h listen loaded maintained mallocz manually mechanism message mnt mp.h nearly needs negotiate negotiated nil non note ok okthumbprint ongoing options output parameters particular path pcertlen perform pointer points port previously private protocol provide pushtls pushtls.c rc4_128 readcert record remote's required resume return returned returns revoked secret secretpem secrets security server services sessionid sessionidlen sessionids sha1 sha1dlen sizeof software source speak src ssl ssl3 standard stored struct suspect sys table thumbprint thumbprints tls tls.h tls1 tlsclient tlsconn tlsserver trace transport trusted typedef u.h uchar user void whenever written pushtls	2/pushtls
 9sys access access.c accessibility aexec aexist aread avoid awrite besides bits bugs char check checked client defines desired determine diagnostics directories errstr evaluates exec executable execute exist existence expected expensive fail file format include int intended leading libc libc.h merely misleading mode permission permissions permit permitted proper read returned searches server source src stat sys u.h unless writability write access	2/access
 9sys access allocated char creates diagnostics env environment errstr exists file getenv include int libc libc.h malloc memory pointer putenv reads returned returns source src string sys terminates u.h val value variables writes written getenv	2/getenv
 9sys access atomic atomically blocking blocks calling canlock canqlock canrlock canwlock carelessly contains context data deadlocks decref decrement decremented decrements discouraged distinct easily especially execution expensive fork generate granted grants implementation include incref increment incremented increments initialized int interface libc libc.h library libthread limitations lock lock.c locking locks manage memory moreover non obtain obtained operation port prevent primitive proc processes programs puts qlock qlock.c qlocks qunlock read reader readers ref ref.c regular released releases rendez rendezvous replaces resulting returns rfork rlock routines runlock rwlock rwlocks semantics shared sharing simultaneous slightly source spin src struct structure successful suspend switches synchronize synchronized sys task tasks third thread thread.h threaded threadrendezvous threads tries typedef types u.h unlock unlocked value versions void vous wlock write writer writers wunlock lock	2/lock
 9sys accessed added addr address allocation alternate break brk bss bytes data defined diagnostics dynamic error errstr exec execution growing highest idea include incr int intro libc libc.h location locations lowest malloc memory occurs ordinarily pointer program's programs return returned returns rounded rounding sbrk sbrk.c segattach segbrk segment source space src stack storage sys system's therefore u.h ulong via violation void brk	2/brk
 9sys actually address advanced allocated array buf bytes complete constant contrast data decodes define dependent diagnostics dir directory dirmax dirread dirread.c dirreadall entire entries entry equivalent error errstr exactly fd file filled format freed hold impunity include independent int integral intro layout length libc libc.h limit machine malloc maximum necessary negative nil occupy offset pointer read reads return returned returns size sizeof source src stat statmax steps structure structures subdirectory successful sys time u.h unpacks upper value variable dirread	2/dirread
 9sys additive algorithm approximately bits buf buffer bugs bytes calling cons data descriptor dev double due faster fastrand feedback file fill fills frand generate generator generators genrandom genrandom.c hundred include initialize initialized int integer intended larger libc libc.h libsec libsec.h lnrand lrand maintain mantissa mod mp mp.h mprand native nature nbytes nfastrand nrand ntruerand periodically port prng prng.c produce pseudo rand rand.c random read reproducible requires return returns scrambled security seed seeded significant software source srand src static stream sys testing time times truerand truerand.c truly twice u.h uchar ulong unguessable uniform unsigned using val value void whatever rand	2/rand
 9sys addr analogous analogy array buffer buffers bugs build bytes collected data diagnostics errstr facilities fd future gather implementations implicitly include int intro io iochunk len libc libc.h malloc nio offset operations placeholders preadv pwritev read reads readv readv.c received returns routines scatter seeks source src standard stored storing struct structures successive supplement sys total typedef u.h ulong vlong void write writev writev.c readv	2/readv
 9sys afid amount analogous aname ap aqid assumes bit bit16sz bit32sz bit64sz bit8sz brethren buf buffer buffers byte bytes char checks comments complete constant convd2m convenient conversion convert converts convm2d convm2s convs2m copied copy correct count data define defined described dir directory dirfmt dirmodefmt effective ename encoding entire entry enumerated equal error etc exactly except exception exchange extract fcall fcall.h fcallfmt fd fid fields file fill fmt fmtinstall format formatted formatting full gbit16 gbit32 gbit64 gbit8 greater handling header holds include includes incorrectly independent installed int interface internal intro iohdrsz iounit length letter libc libc.h locations machine macro macros maxwelem message messages minus mode msize nap nbuf necessary needed negotiated newfid nil nstat nwname nwqid occupied offset oldtag packing partial pbit16 pbit32 pbit64 pbit8 perm plan plus pointer pointers portion precedes produced properly protocol qid quantities rattach rauth rcreate read read9pmsg related reports representation representations required rerror reserve resulting retrieve return returned returning returns reverse ropen routine routines rread rstat rversion rwalk section selectively short size sized sized2m sizes sizes2m source src stat statcheck storage store stored storing string strings strs struct structure successful successive suitable sum sys ta tag takes tattach tauth tcreate test tflush therefore times topen translation tread turning tversion twalk twrite twstat type typedef types u.h u32int uchar uint ulong uname union ushort valid validity validly value values verifies version vlong void wname wqid wstat fcall	2/fcall
 9sys alg algorithms attach authenticated authentication cfd channel char communication communications connects control data descriptor device diagnostics dial directions encrypted encryption failure fd file include int keys libc libc.h message nil non opened opens pushssl return returned returns secin secout source space src ssl starts sys u.h version written pushssl	2/pushssl
 9sys allocated data exec include legal libc libc.h location management nil pointer privalloc privalloc.c private privfree process processes releases returns segments share shared slots source src storage sys u.h void privalloc	2/privalloc
 9sys amounts atomic breaking broken bytes data descriptor descriptors devices diagnostics discover dup error fd file files include int interface intro involving iounit libc libc.h maximum occurs operating operations particularly pieces protocol read reads records return returns routine size smaller source specific src sys transfer transmitted u.h unit unknown unspecified using value writes written iounit	2/iounit
 9sys answer bintime bugs cons descriptor dev diagnostics epoch errstr file former gmt include jan latter libc libc.h maintain nanoseconds nsec nsec.c opening reading return routines seconds source src static sys time time.c tp u.h value vlong void time	2/time
 9sys append arg argv0 bugs char colon cons console date described describing directory error errstr exist exits fields file final fmt format formatted holdover include int interface intro libc libc.h log logname logs machine message messages multi newline nil null opened perror perror.c port preferred print printed prints process produces program's programs running safely short slashes source space src standard string suppressed sys sysfatal sysfatal.c syslog syslog.c threaded time u.h value void writing perror	2/perror
 9sys buf buffer bugs bytes char consulted current diagnostics directory error errstr fd2path fills getwd getwd.c guaranteed include incorrect int libc libc.h null path places provided pwd reach representing returned returns size source space src string sys u.h underfoot getwd	2/getwd
 9sys calling char delivered diagnostics errstr include int intro libc libc.h note notepg notify pid pngroup pnproc postnote postnote.c proc process returned send sends source src successful sys target u.h write writing written postnote	2/postnote
 9sys child code cons converted cpu cputime dev double elapsed file fills include int libc libc.h milliseconds non null opening process processes read real returns running seconds source spent src sum sys time times u.h user void cputime	2/cputime
 9sys cons converts current dev diagnostics errstr executing getpid getppid guaranteed id ids include int intro libc libc.h machine parent pid ppid proc process processes reads returns running source src sys u.h unique unsuccessful void getpid	2/getpid
 9syscall a.out accepting address allow apply approximate architecture argc argv array attributes beyond bin binary calling carried cell char clock contains convention conventions copy current data defined dependent diagnostics directory e.g entry env environment errstr except exec exec'ed execl execl.c execute executed expended fail file files finally follow global handler honors image include int interface interpret intro keeps level libc libc.h lost lower ls machine main mc measured milliseconds mode naming newly notification notify nprivates null ocexec opened or'd original overlay parameters particular permissions pointed pointer pointers points port private privates process processes prof profiler programs rate raw rc register remain return script segments share shell source src stack stat storage successful sys time transfer typically u.h updated user valid void working zeroth exec	2/exec
 9syscall accept amount auth bind buffer bufsize char commonly connection constraints default defaults defined determines diagnostics directly errstr fauth fd final fversion highest include initialize int interpretation intro kernel length level libc libc.h lower manner mount negotiate negotiated negotiation nversion overwritten performed possibly presented protocol rare read receive represents requests return returned sensible server size source src stage string strings subject sufficient support sys text therefore total u.h value values version fversion	2/fversion
 9syscall access actually addition allows anded append applications asking atomic automatically bind bit char client closed closes constituent copy create created creates creating defined depends described descriptor descriptors details diagnostics directory dmappend dmdir dmexcl doesn't error errstr evaluated everyone exclusive exec execl execute exist existing exists extended fails fd file files final guaranteed identical implicit include int intro invalid length libc libc.h mechanism mode necessary ocexec oexcl oexec omode opening opens operation orclose ordwr oread ored otrunc owner owrite path perm permission permissions permit prepares process provided purpose read reading remain remove requested require returned returns reused rewrite says source src stat structure succeed succeeds sys termination time truncate truncated u.h ulong unchanged union unlike user userid valid values write writing open	2/open
 9syscall access addr address addresses adds allocation allow allows arg assembly attached attaching attr attributes belong beware bit bltz boundary bounds bss btas buffers bugs build byte bytes caching calling char choose class classes contains control cop3 creates data default dependent detached device devices diagnostics draws equal error errstr exec exec'ed executable fails failure file filled fixed fork fp frame free'd freed greater hardware helps implement implements include inherited initialized instruction instructions int integer interface interfaces kernel language leaves legal len libc libc.h limit lock locks low lowest machine machines map mapped maximum memory method mfc3 mips movb movw multiprocessors nearest negative nop nor operating outside overlap overlaps page particular peculiar permit physical plain points portion proc process process's provide provided read referenced release remain removes ret return returns rounded save sb segattach segbrk segdetach segflush segfree segment segment's segments sema semaphore series sg_cexec sg_ronly sgi shared size software source space span specific specifies specify src stack succeeds success suitable support sys systems tas tells test text trap trapped try type typically u.h ulong uncached unknown unmap untouched va valid values vary virtual void segattach	2/segattach
 9syscall access afd amount aname attach auth auth_proxy authentication authsrv bind char commonly connection conventionally current descriptor diagnostics directly entry error errstr establish fauth fauth_proxy fd file include int libc libc.h mount negotiate particularly protocol rare require resources return returns server source src subsequently successful sys ticket typically u.h user using value fauth	2/fauth
 9syscall access bind boundary buf bytes char character component described descriptor diagnostics directory error errstr executing fd fd2path file getwd include indeed int intro kernel libc libc.h longer nbuf ns null occurs opening original path proc rebound refer removed renamed resulting return returned returns rooted silently source space src stored stores sys therefore truncated typically u.h underlying unless update utf value fd2path	2/fd2path
 9syscall accessible add addition afd alias amount aname attached attempt attempts auth authenticated authentication automatically becomes bind binding bound bugs cache cached caching char chooses client closed condition connection consisting constituent controls create created currency current data default defined definition described descriptor details device diagnostics directories directory doesn't doing effects enabled errstr evaluated evaluating evaluation everything except exist existing fails failure fauth fcall fd file files final finally flag flags fork goes happens henceforth hide include int integer intro kernel libc libc.h machine mafter mbefore mcache mcreate messages mnt modification modify mount mounted mounting mrepl names network null object operations or'd original originally particular particularly path pipe positive possibly prepared process processes read reading refer refers replace requests required respond retrieved return root routines satisfy searched section selects served server serving source space src srv string subsequently success successful successfully sys time translated translation tree trees turns u.h unbound undone union unique unmount unmounted valid value verified visible writing bind	2/bind
 9syscall actions address alarm ansi arrival asynchronous atnotify atnotify.c awakens bad behavior breakpoint broken bugs bytes calling cancel cancels char characters child clears closed common communicate condition connection correctly counter current debugged debugger debugging default defined defines del dependent depends described designed discards discouraged divide dividing due e.g elsewhere emulation enabling environment errlen erroneous error except exception exceptional exceptions exec executed exiting exits expired external externally file finish floating fork format fp fppc fptrap further generated handle handler handlers hangup id identical improve include includes incomplete instruction instructs int interrupt interrupted intro jump key kill layout leaves libc libc.h limited longer machine modifying ncont ndflt needed neither non note noted notejmp notepg notes notification notified notify nrstr nsave nul null objtype odd offending operating operations origin original overridden parameter parent pc perform pipe pointer port portions posix posted posts prefixed presence printed proc process process's programs provided puts raises range read receipt receive received receiving recognized recorded recover regardless register registered registers registration replaces reported resolved restores restoring resume resumes return returns saved setjmp signals source specific src stack standard starts stopped string structure suffixed suicide suspended syntax sys terminal trampoline trap traps truncated types typically u.h unaligned undefined ureg ureg.h user using values void vulnerability window write writing notify	2/notify
 9syscall actual alarm amount ask clears clock cpu current delay delayed diagnostics errstr include int interrupted intro invoking libc libc.h milliseconds millisecs note notify previously process remaining requested reset return returning returns run sent sleep source src successive suspends suspension sys time u.h unsigned value waiting sleep	2/sleep
 9syscall actually advanced atomic buf bytes characters closely combining concurrent console conventionally count data descriptor diagnostics dup equivalent error errstr event execute fd file guaranteed include int interference intro libc libc.h match memory multiprocess nbytes non offset operations permit pipe port positive pread programs protocol pwrite read readn readn.c reads readv refers regarded requested return returned returns seek source src successive sys u.h value vlong void write writes written read	2/read
 9syscall addr address allocation allow altered brk bss bytes data diagnostics errstr idea identified include int length libc libc.h location lowest memory overlapping page prevent proc returns rounded saddr segattach segbrk segflush segment segments size source src stack sys system's text typically u.h unused valid void segbrk	2/segbrk
 9syscall address allows arrive arrives awakened common communication conjunction control diagnostics enables errstr exchange exchanged execution fork forks include inherited interrupted level libc libc.h meets memory parallel process processes programs rendezvous respective return returned rfork rfrend scheduling segattach share shared source space src succeeds suspends synchronization synchronize sys tag typically u.h ulong unless user value values wishing rendezvous	2/rendezvous
 9syscall address architecture boundary bytes cache caches contained correct correctly data depends diagnostics errstr flush flushed include instruction int invalidates len length libc libc.h machine memory nearest page pages proc referenced rounded segattach segbrk segflush segment segments source specific specifies src straddles sys u.h ulong understanding va void works writes segflush	2/segflush
 9syscall allocated appending array await blank blocking buffer byte bytes calling char child child's code colon contains data descendants diagnostics discarded discards elapsed errstr exit exited exiting exits fields file filled fills fit fork formatted freed getfields holding id include int length libc libc.h living longer loved malloc message milliseconds msg necessary nil nul parsed pid prefixed proc process programs properly real remainder representation rest resulting return returns routines source spent src string struct structure sys terminal textual time times tokenize truncated typedef u.h ulong underlying units user using value void wait waitmsg waitpid wait	2/wait
 9syscall allocated chooses closing descriptor descriptors diagnostics dup duplicate dynamically errstr file greater growth highest include int intro libc libc.h lowest newfd oldfd prevent referring requires returns source src sys table u.h unwarranted dup	2/dup
 9syscall boots char chdir diagnostics directory dirname errstr evaluating explained file include int intro invoking libc libc.h names plan process source src sys u.h working chdir	2/chdir
 9syscall boundaries buffer buffered bugs byte bytes channel closed comes communication contiguous cooperating create created creates data descriptors diagnostics dirfstat errstr established exited explicit fd file fork fstat full generate include indistinguishable int interprocess interrupted intro length libc libc.h note pass pipe preserved processes read reader reading reported return returned returns source src stat sys terminates transferred u.h unknown whichever write writer writes writing written pipe	2/pipe
 9syscall bytes current diagnostics directory errstr fd file include int intro libc libc.h location offset op pipe plus pointer returned seek seeking size source src sys type u.h value vlong seek	2/seek
 9syscall char diagnostics directory discards errstr file include int intro libc libc.h orclose permission remove removes source src sys u.h user write remove	2/remove
 a,a absolute accent accented accepts addr address addresses advances assumed bell bit browser bugs byte characters cmd coverage current default described dict dictionaries dictionary dictname distributed doesn't edition english entries entry equivalents etc exact execute executes expression expressions files folded folding font format headword headwords i.e implicit index integer interactive key labs latin leading letter letters lib list literal lower mapped match matched matching mode necessarily non oed oed2 oed2index offset option options outside oxford pairs pattern patterns pelm print printed prints pronunciation quit raw re regexp regular repeatedly resets results setting sorted source src standard syntax sys takes th time translating try unicode unicode.9.font upper variants version wide wrapping dict	7/dict
 a.c a.e a.ne a.s a.se accepts alone apply arc arcrad arcs arg1 arg2 arranged arrow arrowhead arrowht arrowwid assumed atan2 attribute attributes backslash balanced bare block bot box boxht boxwid built center centered centerline chop circle circle.nw circlerad cmd code commandline comments compass consists contained contains context continued coordinate copy corner cos current dashed dashwid default defaults define definition determined diam dimensions direction divided doctype dotted drawing edition eigh eight ellipse ellipseht ellipsewid enclosed ending entering entry etc eter evaluated except existent exit exiting exp expr expr,expr expressions extreme figures file files fill filled floating font format generally geometrical grammar grap graph graphics height ht implies inches independently input int internally introduced invis invoked irrelevant item items ius kernighan keyword language letter lineht lines linewid list ljust log lower macro manual max mentioned min missing motion motions move moveht moves movewid names ne newline newlines non nr nth null nw object objects occurrences ones op opt optional ordinal output pair pe permitted pf pic picture pictures placename points positioning preprocessor preprocessors primitive primitives print printing process produces programmer's proportion ps qualified rad rand refer refers regardless remain removes replaced replacement representing requests research reset restored retain revert rjust saved scale scaled se semicolons sh silently sin size source sp spline splines sprintf sqrt src stand statement statements strings sw synonym sys tenth tex text textht textwid th thru time tpic troff typesetter typesetting ultimately undef unit unix unless upper value values var variable variables vertically volume ways wid wide width x,y pic	1/pic
 a.c abs access actions acts added aggregate aggregates alarm alloc alltarget ambiguous ampersand ar arbitrary arc architecture archives arg1 arg2 assignment assignments assume attr attribute attributes augmented automatically b.c backquoted backslash bar bin blank blanks bob bquote break bugs build building builtins caused cc cd cflags character characters clause cmd cmp colon comments compilation compile computed conditions conjunction considered consists contains content continue control copy correct cp cpus current date deal debugging default define defined deleted depend dependency depends derive described determine determines dhz differently distinct distinguished don't draws egp elided environment erroneous erroneously error errors evaluating everything exactly except execute executed executing execution exist existing exit exits expand expanded expanding explain exported expression expressions extracts fashion file file's files flag flandrena folded foo formed gram.y grammars graph hume id identical identifies implicit includes increasing initially input inserting intermediate interpreting intro invoked ld ldflags learn legal length lex lex.c libc.a library lines list literal machine main maintain master match matched matches maximal member membername meta missing mk mk's mkargs mkfile mkfiles mkflags modification modified modify modifying names needed newer newline newmember newprereq non nonempty nonexistent nproc null o:r obj objtype occurrence occurrences older omitted option optional options output override overrides parallel parentheses parsed parsing pattern percent pid places plan possibly potential precedence preceding prereq prereq1 prereq2 prerequisite prerequisites pretend print printed printing prior process processed produce prog propagated quoted quotes rc read recent recipe recipes recognizable recommended refer reference references reflect regexp regular related rely remade replaced reports respect respects restrictions return returning rule rules run runs sam satisfies script seemingly separating sequentially settings sign simultaneously slash slot sometimes source space specially specify src stamp stamps standard static status stem stem.2 stem.c stem0 stem1 stem2.c stem9 string strings subexpressions substitute substituted substituting substitution successor supplying supported surrounding sys tail takes target target's target1 target2 targets terminate text time touch treatment triggered trust types unless unquoted update updated updates updating using value values var variable variables virtual visible what's x.tab.h x.tab.h:pcmp y.tab.c y.tab.h yacc mk	1/mk
 a.i accurate bin bugs chapter chapter.0 chapter.1 deduce doctype document eqn eval examines file files formatting grap guesses input inspired intuit invokes lp macro mm ms nroff option options output packages pic preprocessors prints rc recognizes related source standard style tbl text troff typeset doctype	1/doctype
 a.out a.out.h a_magic absolute acid added address adjustment algorithm alpha amd architectures arm array associates assumed att automatic automatically base binary bit brk bss bugs byte bytes char characters clustered compiled compiler compilers component components computed consists constant contains conversion core correspond counts current d_magic data db dec dedicating define defined dependent describe described directives discover downwards dsp e.g e_magic encoded encoding endian entries entry exec executable executed expressed extended extension facilitate file files finally flags format forming frame growing header highest hold i_magic image implement include included initialized instruction integer integers intel interpret interpreting j_magic k_magic l_magic laid le leaf length location locations m_magic mach machine magic main mc68020 mc680x0 memory mips moreover multiplied n_magic names newlines nm nul null object occupies occupying offset operations page parameter path pc pcsz plan pointer pop possibly powerpc pre preceding preprocessed printed produce q_magic quantum recorded recover reduced register remaining represent represents rounded run scan section sections segment segments setting sign similar six size sizes slash slashes source sp sparc specify spsz stack starts static stream strip struct structure subtracted symbol symbols syms table text type typedef types uchar uninitialized unique using v_magic value values variable virtual x_magic a.out	6/a.out
 a.out absolute access accessible adding additional addr address addresses application applied applies approach architecture architectures array assigns automatic base basepc basic beyond bio.h boundaries bounding bounds buf buffer bytes calculated cany cauto cdata char character class code compiler components constant contained contains conversion converts count counter cparam crackhdr ctext current data defined derived describe described describes describing descriptor desired device dummy e.g encname encoded entries entry equal equivalent error errstr executable executing exists fd fhdr file file2pc file:line fileelem fileline files filesym filled fills findlocal findsym fixed fn fnbound fp frame getauto getsym global globalsym handle header higher identify image impose inaccurate include increasing independent index instruction int interface internally invoke latter length level libc.h libmach library limits line2addr loads localsym located location longs lookup mach mach.h machine matching memory message names near nearest non nsyms null object occupy occurs offset opening operate operation optimized ordered original owning pair parameter parameters particular pass path pc pc2line pc2sp penalty pid places pointer pointers points popular pre prior private proc process processing produce proper provide range raw read recalculate receive receiving reference relative resolves results retrieval retrievals retrieved return returned returns riding search searched searches segment selected selects source space specification specifies specify speed src stack stacks startup statement stored str string struct structure structures success sym symbase symbol symbols syminit sys table tables target text textseg textsym th type typedef u.h uchar ulong uniquely unless unsigned using value values var variable variables vary via void symbol	2/symbol
 a.out access adding additional address application architecture archive bio bio.h biobuf bp buf buffer built char characters code constructs contains current data decoded decoding defining definitions describe described describing destroys diagnostics difference directory dummy encoded errstr exactly executable executing extra extracted extracts file files formal generic header identical images include independent indicate indicates indicating input int intermediate interpretation interpreting invocation invoked isar leaves libc.h libmach library loaded loader mach mach.h machine malformed member missing negative nextar non object objtraverse objtype offset operates organization pointer pointing positioned previously processing produced provide readar readobj reads references relative representation requires resolved resulting return returned returns rewound routines sarname scans size source specifying src stored string structure structures sym symbol symbols sys table type u.h value vector void yields object	2/object
 a.out acid address aghnsu alphabetically ar archive automatic blanks bss cmd components data db defined don't executable file global headers hexadecimal leaf letters lines list nm nm.c object offset options output parameter print printed prints segment sort sorted source src static symbol symbols sys table text undefined user value variable nm	1/nm
 a.out binary cmd directory executable file files input output permission remove removes requires rewriting segments source src standard strip strip.c stripped stripping symbol symbols sys table write written strip	1/strip
 a.out bsssize bytes cmd datasize default executable file files format print prints segments size size.c source src sys textsize total v.out size	1/size
 aa accept accepted acid adjusts alpha amd ansi append apx architecture argpos arithmetic arm array assembler assembly at&t automatic bin bit brackets buggy bugs cc certainly char character check checking cmd code comment compile compiler compilers compiling complete conflict conformance context controller convention conventionally cpp current db declared declaring dedicated def default define defined definition dependent digital dir directives directories directory discussion double dsp e.g eleven emulated enable enabled enclosed endian environment equal equality error etc examining except explicitly expression extensions extern fails fields file files finally flag format formatted formed forms full fvw generating global handle handles handling header identifies identify identifying ifdef ifndef include included includes independent indices initializers initializes input int intel invoke kc language lax legal letter lib libbio.a libraries library lines list loaded loader loaders machine machine's main.2 main.c mc68000 mc68020 messages mips mips2 mk mkfile modules motorola names needs nm non notation obj object objtype obviate optimization option options outer output parent pc pcc pentium permits pike plan pointer pointers pragma pragmas preconditioning prefix preprocessing preprocessor print processes produce prog programs promotes prototype qc quotes records referenced register registerization reject related represents requires resolution rob routines run says separately sign slash sought source sparc specify spim square src standard standardly statement string strip struct structure structures style sub.2 sub.c substructure substructures subunions sun support suppress sys tag tagname tells tenth third time type typedef typedefs typically undef union unnamed unspecified unused using value values varargck variable variables vc verb version vlong void warning xc 2c	1/2c
 aa add adding addition address addresses adds alias aliases aliasmail allows append attachment attachments automatically bin boris box builds cc cmd conformant contained content copy copyaddr dead.letter delivery determined direct directing directs display disposition edited envelope environment esc exist exists exit expands explicitly faces file files filter format formatting freely full header headers hit hold included inline input intentionally invokes it's key kremvax.com lines login mail mailaddr mailbox marshal message mime mlmgr mode myupassend names natasha necessary nedmail nrx option options overriden passes personal prepends puts qer read reader recipient recipients reply required return rewrite rfc rio running send sending sent smtp source specifies squirrel.com src standard subject sys transmission type unless upas upasfs upasname user username using value variable window xr marshal	1/marshal
 aaa.bbb.ccc.ddd abusive accept accepted accepting accessible account accumulate additional address addresses allocation allow appended applicable asks assumed authorized banished banned bits block blocked blocking capabilities capability card care character characters checks cidr class code commas comments configuration conform connections consist consisting contact contains continuation convention copies covered cursory daemon date default defaultdomain defines delegation deny depends described describes describing destination detecting detection dial differs directories discarded discussion dns domain domains easier enabled entire enumerate equivalent error escaped example.com exercise exists exposed external facilities file files finally flag format friendly further gateway generally generated hostdomain identical implements inadvertently include incoming input insensitive internal ip lacking larger legitimate length lengths lib limited lines list listener loops low lower mail mask matches matching mechanisms message messages missing modem names necessary negates network networks norelay notation notice numeric octet octets omitted option options ourdomains ournets override overriding parameters pattern port ports postmaster precede processed processing prohibited protected protocol provide qualification queue.dump random randomly range readable reads receive received rejected rejection rejects relay relayed relaying remaining require restated rfc safety saveblockedmsg saved saying scanmail security seldom select selects sender sender's senders sending series served server sessions setting significant similarly slash slave smtp smtpd smtpd.conf software source space spam specifications specifies specify specifying standard stuck style sub subdirectories sufficient supported synonym systems tcp test token tokens traffic treatment trusted unauthorized unreturnable user users uucp values verb verbs verifies verifysenderdom wild works xx smtpd	6/smtpd
 aan aan.c assume astro6 automatically aux break breaks broken client client's cmd connection data default dialstring due e.g echo encapsulated establishes exec exits exportfs file files handle import imported ip listen listens log lost machine maxto mnt net netdir network networking networks option persistent protocol re reconnection redialing retransmits roaming run seconds sed server sob source space src started sys tcp term traffic tunnels unacknowledged unique unreliable using voluntarily aan	1/aan
 aan abcc algorithms allows arbitrary assume auth authentication authority bind clear cmd complete connection connection's construction control cs default defaults descriptor directories directory enc encrypting encryption exactly exportfs file filter full global import import.c imported inside interfaces internet intranet ip kremvax list machine mount mountable mounted mountpoint ndb net net.alt network omitted onto option options outages perform plans posts process protect protocol protocols push pushes rc4_256 remote sha1 source space specifies src srv srvname ssl started supported sys tcp telnet temporary tls traffic tree ucbvax union user using wire import	4/import
 aan access acts ads algorithms allows announce appearance arbitrary attach auth authenticate authentication aux avoid bin boot broke broken bypasses client cmd combination compatibility compute connection connections copy correctly corresponds cpu create created dbgfile debug debugging default defaults device directly directory disallows e.g enable enc encrypting encryption equivalent establishes executed export exportdb exported exportfs exporting exportprog file files filter fragmentation ftp ftpfs full handle helps identifies import imported instructs invoked invokes kernel level list listener log machine manipulated maximum message mnt mode mount mountable mounted mounting msize network networks nfs.boot nfsserver obtain obtained offer operations option options passes path perm permitting person pieces pipes plan plumbing portions posts predates proc process protocol protocols publish rc4_256 reads relay remains remote results returned rio root rooted send serve server servers serves serving sha1 simulate size source space specifies src srv srvfs srvfs.c ssl started string supported sys systems term terminal tmp traffic tree tunneled typically unnecessary user users version windows wire writes exportfs	4/exportfs
 ab abstract acceptable ae ai append attached au author author's automatic automatically bell bi block blocked bold boldface bottom box boxed bp br break bt btl bx canned centered column conjunction constant copies cover ct cw da date de default defined definitions display displayed document documents ds e.g edition eg en enclosed engineer's ens eq eqn equation equations except explanation extension facility fe file files filling float floating font foot footer footnote format formats formatting fp fs full grap graphs hanging heading height hill ho holmdel ih illinois implies impunity inches indent indentation indented initials input insert institution internal invoked ip italic italicize jersey justified ke keeping kept kf ks laboratories larger lesk letter letterhead letters level lg lib list location lp ls lt lucent lucidasans macro macros manual manuscripts margin margins material measured memorandum mf mh moved ms murray na naperville nd neqn nh nical nl non note notes notice nroff omit optional options output package page pages paper papers paragraph pe pf pic picture pictures piscataway positions pp precede preprocessors print produced produces programmer's provides ps py qe qp qs quoted re record redefined reference registered relative released repeated report request requests research restore roman rp rs section sg sh sheet signature size sm smaller sp space straight subsection suppressed switch sys ta table tables tabs tag tbl te tech technical telephone tenth text th third title tl tm tmac tmac.s tr trademark troff ts typing typist ul underline unix unsafe using ux value various verbatim vertical volume wh whippany width yes ms	6/ms
 abandoned aes awkward basic bit bits block block_cipher blocks blowfish book buffer buffers byte bytes cbc chain chained chaining characters cipher code compatible contains convert converting created data decrypting decryption depend depends des des3cbcdecrypt des3cbcencrypt des3ecbdecrypt des3ecbencrypt des3state des56to64 des64to56 des_key_setup descbcdecrypt descbcencrypt desecbdecrypt desecbencrypt desstate digital directly dsa ecb eight electronic elgamal encoded encrypt encrypted encrypting encryption ensure equivalent except flag format formats forth hence include indicating initialization int ivec key key_setup keys larger libc.h libsec libsec.h mode modes mp mp.h parity plan pointer prime rand rarely rc4 rest routines rsa schedule sechash secure setupdes3state setupdesstate shared source src standard stream structure substitution successful symmetric sys takes track triple triple_block_cipher u.h uchar ulong using vector void we've works des	2/des
 abbreviated abbreviations accept accepts access addition additional assumed attribute attributes audio audiostat bass bind bit blaster buffered bufsize byte bytes calculate cd complement connected connection control controller controls converter converters data decrease default defaults degenerates depend dev devaudio.c device devices directory dma duplex endian existent expressed file format greater hz i.e implementations increase input integer internal khz latency length level lines loud mcd mic microphone midi minimum monaural non offset operations output particular playback played player port ports possibly provides quiet ranging rate reached read reads record recorded reporting represents reset return returned returns sample samples sampling serves shared shown size sound soundblaster source sources speaker speed src stat stereo string support synth synthesizer sys time timing tone treb treble two's usb using valid value values volume writes writing written audio	3/audio
 abbreviated absolute access accessed accessing address addressable adjustment adjustments advance affect affects algorithm allocated allocates alter altered ansi arbitrarily arbitrary architecture archive ascii attributes auth.h automatically base basic belongs bidirectional bind bio.h bit bits block bring broken bss buffered bugs bytes calling capable cases channel channels char character characters chdir chicanery child collected collection commonly communicating communication completes comprise concatenations confound confused connected consist contains continues control convenient convention conventions copies coroutine create created creates current data dates declarations declared declares define defined defines definitions deleted dependent depends describes describing descriptor descriptors design desired details dev device's diagnostics dir directly directories directory directs dirfstat dirfwstat dirlen dirstat dirwstat divided dot draw draw.h dup dynamically employ emptive enable entries entry error errors errstr etc evaluated evaluation events except exception exec execute executing execution existing exits faults fcall.h fd2path file files filled flags floating fork frame.h friends fstat fwstat getfcr getwd graphics handler header hierarchical hierarchy historical id identical identifies implementation include includes independent independently indexed indicating indices initialized input instruction integer integers integral interface intro introduction jmp_buf kernel latin layout ldraw leading length level lexical liability lib libbio libc libc.h libdraw.a libraries library libstdio limit limitation listed listing loader lock locks longjmp lowest mach.h machine macros main maintained maintains malloc math mechanism memory messages method mount mouse multi multiprocess multithreading namelen names namespace nan ndb.h necessary needs networked nm notably notification notify ns objtype occupy occur occurred occurs offset opened operating ordinary organization output outside ownership pages pair parent particular passing path paths permissible permission permits pick pipe plan plus points possibility practice pragma pre prefixing prerequisite prerequisites presents preserved print printable prints proc process process's processes programs proper properly properties protect provides purposes rarely reachable reached read reasons reassigned record records recovers regexp.h register regular related removals remove renamings repeat replace report reported representable representation representing request resident retrieved return rfmem rfork rfproc root route routines running schar scheduled scheduling searched section seek segattach segment segments selecting send sequential sequentially serve setjmp shared sharing shouldn't signed similar slash slashes sleep source space stack standard starts stat status stdarg.h stdio.h step stored string stripped strlen structure structures subroutines support switching synchronization synchronize table telling terminate terminates text therefore thread thread.h threads time translated translation translations tree type typedef types u.h uchar ulong unaware undefined understood unexpectedly union unique unsigned unused user ushort using va_arg valid value values variadic various via visible vlong wait whenever working works write writing written wstat yield 0intro	2/0intro
 abbreviated affected agreement algorithm applying ascertain backward basename behavior blanks bring bugs circumstances cmd cmp comm comparator compare compared consisting contains convert creating debate diagnostics diff difference differences differential differing directories directory ed editing editor efmnbwr equal equally error except exchanging exit file file1 file2 files finds flag flagged forms identical input inserts letters lines listing method n1,n2 n3,n4 naive names notion opposite option oriented output pairs pertain post prefixes process processing processor produced produces range rare reading recreate recursively removed resemble running script scripts similar similarly smallest source space spaces src status stream string strings subdirectories sufficient sys tabs tells text tmp trouble verbs diff	1/diff
 abbreviates add add3 add4 affine alpha amongst arith3 arithmetic assume assumption can't closept3 closest component compute convert converting coordinates cross cross3 cryptic dealing dist3 distance div3 divide division dot dot3 double draw.h duality eps eqpt3 equality euclidean exact extra fff2p3 geometry.h homogeneous identically ignoring include indicate int interpolation intersection joining len3 length lerp3 libgeometry linear matrix midpoint midpt3 mul3 multiply names nearseg3 neg3 negate operate operations ordinary origin p.w p.x p.y p.z parallel passing pdiv4 perpendicular perspective plane planes pldist3 pn2f3 point3 points ppp2f3 pq product projective q.w q.x q.y q.z reflect3 reflection remainder reminds representations results returns roundoff routines scalar segment smaller source space src struct sub3 sub4 subtract sys takes test testp type typedef unit unit3 units various vdiv3 vector vectors vrem3 we're whenever x,y,z arith3	2/arith3
 abbreviations acceleration accurate add astronomical atm au avogadro's belgiumfranc brgallon britainpound british bugs catenation centigrade charge circumference cm cmd combination complete compound constants conversion conversions convert converts counterparts currency database denoted diameter differ divide ds e.g electron entire equivalents etc exotica exponentiation expressed fahrenheit familiar fashion file files flag floating generous gravity grouping height inch interactively in² kelvin leavening lib lightyear list mass metric mole multiplicative multiply names nature operators pi pound pounds precedence prefixed prefixes pressure print quantities quantity rankine ratio recognized run scale scales someone source specifies speed src standard subtract sys time unit units units.y updated various works units	1/units
 abc abcc attach auth bind blank cd character construct describe dir directory environment escapes everything expanded file files host import init lines machine missing mount mounted mountpoint namespace newns non operation operations options performed quotes recognized remotepath scratch servename server space spaces spec specifies string subroutine tabs typically unmount utf variables working namespace	6/namespace
 abc accessible append arithmetically binary character check cmd combined comparisons compatibility condition cons construct current default deprecated descriptor dev directory dubious echo enclosed eq equal evaluates exclusive execute exists exit expr expression false fildes file flags ge greater grouping gt higher identical inefficient integer integers le length lt match meaningful ne negation non nonstandard notice null ok operator operators option parentheses permission plain posix precedence primaries primitives process purported quotes rc readable recognized return signs size source specific src statement status string strings switch sys test test.c unary understands value writable wrong test	1/test
 abcc arch archfile archfs archfs.c archive bind cmd control default file flag flags format mkfs mnt mount mounts mtpt presenting produced source src style sys archfs	4/archfs
 abccdd acme adiff adm behavior bin binary bind bugs compare copy correctly current date day's daysago dd default diff differ digits dump dumps existing file files format fs guarantee hard implementation it's lib libc libc.a library loaded march mips mk mmdd morning names option options port print prints prior rc recent represents rm run runs select selected selects singing source src string sys temporarily today's users v.out vc yesterday yesterday's yymmdd yyyymmdd yesterday	1/yesterday
 abcdef address adjustment aggregate alternate applied applies arg args array asterisk base behavior bio blank bugs bytes calling cast char character characters code consecutive contains control conversion conversions convert converted converting copied dd ddd decimal default defined depends described digit digits double ell ensure equal error except excess exhausted expanded explicit explicitly exponent fetching fewer file flag flags follow fopen format formatted fprintf fractional friends fscanf function's greater hexadecimal implementation implies include increases indicated indicates indication infinite int integer integral introduced introducing invalid justified leading letters libstdio list maximum meanings minimum missing modify negative non nonexistent notation null objects octal omitted optional output pad padded padding performed places plain plan pointer points portion positive precision prefixed print printed printf printing produces promoted promotions reached remain removed responsibility resulting results returns routines rune short sign signed significant simply snprintf source space spaces specification specifications specifier specifies specifying sprintf src standard stdio.h stdout storage stream string style supplies sys takes transmitted truncation type types undefined union unsigned user's using va_list value vfprintf void vprintf vsnprintf vsprintf wide wider width writes written wrong yields fprintf	2/fprintf
 abilities accessible announces application auth bin binary bytes cern client clients cmd connection connections considered contains content converts current data default defaults delimited described details determined directory domain echo encoding entries etc executed executes existing exists explicit file files finish format headers host html http httpd httpd.h httpd.rewrite httplogin image imagemap inbuf includes incoming ip lib libhttpd.a library list listen listens locked looking looks machine magic man2html manual manuals map matches message method methods mimetype namespace namespace.httpd ncsa netdir network newline newns octet opening page pages pair pairs parsing password path persistent portion possibly post prefix presented processes processing programs protocol query quotes read received record redirect redirection remaining remoteip replacement request requested rest returns rewritten routines save saved search sent server serves servicing source space specify src srvaddr stream string submissions succeed suffixes support supported supports sys table tcp time tokens trivial type uri user using usr valid version web webroot writes httpd	8/httpd
 ability abnormal absent access active acts addition additional address addresses agrees allows alphanumerics answer applied apply arbitrarily asks assumed attribute automatically backslash backslashes backward backwards becomes begun behaves behavior bin bit blank block border boundaries brace braces bracketed buffer buffers button catenated catenation cd character characters class clean click clicking cmd communication complete composed compound computed conditionals contains continuing controls copy create created creates current cursors cut cycle dark debugging deeply default defaults defining delete deleted deleting deletion delimited delimiter delimiters demarcated dev digit direction directory disjoint display distinguishable dot double download downloaded ed edit edited editing editor editor's elided elisions enabled enclosing entered entering entry equivalent error esc escape etc evaluated examined except exception exchange executable executed existing explicit expressed expression expressions extended extends external file file's filename files finds formally format forms forward forwards full further generated gets grep grouped grouping hangup highlighted hit host i.e identifies idioms independent indicate indicated indicates indicating ineffective input insert insertion insertions inserts instance invocation invoking key language leftmost level lib lies lines list listed listens literal literally load locally locates longest looking loops low machine malformed manipulating mark match matched matches meaningful mechanism member menu message miscellany missing modified modifies mouse move multi names necessarily necessary negative nested newline newlines nnnn non none null occur occurrence omitted opening operating operation operations operators option optional options ordinary original output paragraph parenthesis passive paste path pattern pike pipe plan plumb plumbing pointing port potentially precedence preceding prefixed print printable printed prompt prompted provides quit quote quoted quotes range raster rc re read recent recently rectangle redoes refers regexp region regular remote remotely replace replaces represent representing represents required resize resulting reverse reversed rio rmachine rob run running sam sam.err sam.save samsave samterm save saved saves screen search searching sed selected selecting selection selections selects semantically send sent separates sequentially setting shell simultaneous simultaneously skips slashes snarf sole source space src srv standard stands starts stderr stdout straddle string strings structural sub subexpression substitute substituted substring substrings succeed successive sweeping sys takes terminal terminates termination text th thereby time tmp type typed unaffected unassigned unchanged undo undoing unique unless unnecessarily unpack unread updated user using usual value visible whatever whereupon whichever window windows working write writing written zerox sam	1/sam
 ability access accesses actually advisable affect allocation allows appended authentication authsrv average backspace belongs binary bind bintime bit bits blank blanks boot bootfile buffer buffered bugs byte bytes care character characters clock clocks closed closing complete configuration configured cons consctl console contains context control controls copy counts cpus cputime current data debugger debugging decayed decimal delete delta descendants descriptor dev devcons.c device devices digit directory display domain draw drivers e.g ec echoed elapsed enable encoding endian ends epoch erase erases erasing etc except exited fails faster faults file files fits fixed format formats formatted freq frequency generate generated generators graphics greater holds host hostdomain hostowner hundred ids image include incrementing inefficient infinite input integers interface internal interpreting interrupts kernel kernel's kernelpath keyboard kill killing kills kprint kremvax largest leading leaves length letter level listing load loads loops low machine machine's manage memory message milli milliseconds miscellaneous mode mostly multiprocessor nanoseconds newline non null numeric offset opened operating ordinary osversion output owner owns padded page pages parameters parent's permissions pgrpid pid port ppid preserving print printed prints priority process processes processing processor processors produce produces producing protocol provides pseudo purges putting q.v queue random rate raw rawoff rawon read reading reads real reboot rebooted receive reentered remainder remains removes representation representing reread reset resets rest restart restarts return returns rio run runes sampled screen seconds seed seek sent serial served serves shutdown six soon source specially spent src stack started starts statements stream string strings sufficiently swap swapping switches sys sysname sysstat system's t's td terminals textual therefore throws tick ticks time tk tlb toggles total totaling tp tq tr translated trim ts tx typed typing units unlike user utf valued variable version via wait write writes writing written cons	3/cons
 ability access addition affect algorithm allow allows append asks atomic attempt behavior bind bit bits breaking bytes calling check checked client clunked create created creation described determines dir dir.perm directories directory discovered dmdir doesn't draw entry error exclusive execute existing exists fail failed fails fid file files finally further generate generates granted guaranteed id illegal implied iounit issues issuing kernel libc.h maximum mean message messages mode names newly oexcl oexec opened opens orclose ordwr oread otrunc owner owrite perm permission permissions points prepare process product programs qid race rcreate read regular rejected remove removed reply represent request requires return returned ropen send sent server setting size stat succeeds successful tag tcreate time topen transfer truncate truncated truncation try type union user value walk write written open	5/open
 ability access additional adds adobe aladdin allow alternate alternatives anywhere applications apply arg1 array automatically basic benefit bind bugs built bypass caching character cmd colon compressed current d.xyz dbatch ddeviceheight ddevicewidth ddevicexresolution ddeviceyresolution ddiskfonts debugging def default define defined definition definitions deletefile described designated desirable device devices dictionaries directly directories directory directs disables disk dname dnobind dnocache dnodisplay dnopause doc document doesn't doing dquiet driving dsafer dwritesystemdict e.g enabling environment environments equivalent etc exactly executes executing exit exits expense fd file filename files finishes font font2c fonts foo foo1.xyz foo2.xyz format forth fprintf fragment further ghostscript goes gs gs_ gs_device gs_init.ps gs_lib height highest image include initialization input interpreter invocation invoke language languages leaves lib library list listing loaded loading loads looking looks lowest lp manual messages mode names necessary non note null number1 number2 opened opens operator operators option options outlines output page parameters path pause pcharstr pdf pipe pipeline plan9 postscript precede precedence printers printf processed produces programming programs prompt protection ps ps2pdf quiet quit quit.ps ram read reads receive recognizes related remaining renamefile rendering represents requires resolutions run running scratch sdevice search selectdevice selected selects send sensitive sent separately series setting shell similar slash slower sname source soutputfile space specification specifying spoolers src standard startup string strings subdirectories suitable superseded support suppress suppresses switch switches syntactic sys systemdict systems thereafter time token treatment userdict usual utilities utility value values variable viewing whereas width windows writable writing xyz gs	1/gs
 ability access appending applications arena arenas arenasize balance blocksize bytes cds cmd copy data default disk external file fmtarenas fmtindex fmtisect format formats formatting gigabytes indicate kilobytes media megabytes names operations option partition provide read recordable recorded reduces replaced sections selected sequential size sizes source src sys tapes time typically units using various venti write zeroed fmtarenas	8/fmtarenas
 abirprvvw abort absence adobe's arrow backspace basename bit bitmap bottom boundaries bounding box browse bugs button channel claim cleanly clicking clumsy cmd code color comments common compressed computable conform conforming contains control conventions conversion convert converted correctly create created cursor debugging default described determining device diagnostics display displayed displays document documents draw ellipsis enables enter errors exactly exit exits extra facilitate fax faxes file file's filename files fly format formats graphic graphics grow gs guess height holding icons image images inch independent inferno input interface jpg keyboard leaves library listen listens load manual menu messages minus mistransmitted mouse multipage necessary needed newly nor ones option output page pagenum pages pan panning particular pdf permits pixels plan plumber plumbing postscript ppi pressing preview processing programs purpose raises raster read reading reads references removes resolution respect reverses rounding runs screen selected sent simply size skeptical slightly slower source space specific src standard started structuring supports sys tex tiger.ps time toggles troff trouble try turns type typesetter typing unchanged unfortunately unsatisfactory upside user usr variety various version via view viewed viewer viewing window working write writing page	1/page
 able access acme actual add addition address addresses allow announce announces appeared append author base bell black c2.com canonical capital cgi character client cmd coexist comes compare conflicting contains conversation current data date decimal default described descriptor diff.html differences dir directories directory discussion distribution dm domain due easy edit edit.html edited editing entry epoch error except existed expects explicitly facilitates fail fails fields file files final finally flag format formatting forms generated grey guide helper hidden hist historical history.html history.txt holds html http httpd inbuf includes index.html index.txt instances interface ip l.map labs length letter level lib lines links listing listings lock looks map mapping mark message metadata method mnt mode mount mounted mounting mounts mtpt names namespace.httpd netdir network none notice noting obtain occurred oldpage.html oldpage.txt option options original page page's page.html page.txt pages peacefully perm permission plan plan9 post posted prefixed presented presents process provides raw read reading reads rejected remoteip representing request requests response rest return returned returns revised run running sample saved search seconds served server services showing similar slashes someone source space spaces specifies specifying src srv stamp stamps standard started stored subdirectories submission submitted succeeds sys takes tcp templates text textual time title titles transcript type types typically underscores unique update updated uri urls user users usr usual version versions via viewed wants web webroot werror.html wiki wiki.plan9 wiki?wikiwikiweb wikifs wikipost wikipost.c writable write writes writing written wikifs	4/wikifs
 able accessed accesses active add address adl adm administration allow allowoff anyone append atime atimes attach authenticated authentication authsrv bad behavior bin block blocks booting cache casual cdfppqrtw cfs chaperone chat check checked checking clear clri cmd connections console convenience correct couple create creates data default delete described dial directories directory dirty disable disallow disk duplicate duplicated edit encouraged entire errors except exclusive executes exist exists facilitate feature file files filsys fix fs full halt il impossible initialize intended kfs kfscmd kfscmd.c ksync laptops level list listen listener listening looks machines main memory messages mkfs mode names needed needs network networks newuser noauth non none noneattach note nowritegroup nvram objtype octal opposite option options owner path performance permission plan possibly prep prevents print processes production quiet quoted rc re read readable reading readnvram rebuild reduce redundant references remove rename report reread rereads resolve restart retrieved sd serve server servers simplify simulated situation someone source src standard statistics stats stop strongly summary suppress sync sys tags terminal time toggle toggles touched tracing transmits turns updated updates user users write kfscmd	8/kfscmd
 able actions adds analysis analyzer asteroid blanks bugs cmd code compile compilers converts copies default dinosaur edition executed executes expression expressions file files generated generates generator handle input kill lesk lex lex.yy.c lexical lib lines lower manual meanings native ncform opposite options orbit output portions print programmer's programs putchar recognized regular removes replaces research run schmidt searched sed source src standard statistics summary sys template tenth text tvn9 unix unrecognized upper utf volume written yacc yytext lex	1/lex
 able actual adjustments alternate authaddr authentication authserv based behavior bin binaries boxes bugs challenge cmd connect connections cpu cpuaddr cpuserv default delicate depth devices diagnostics difference digital displays drawterm due edit error establish events explicitly file graphical guard illusion improved irix kept keyboard latency lib linux lost matches message mnt mounted mounts mouse netkey network nice nm non operating option options password plan ported print profile programs prompt protocol provide provided queues real recompiling remote resident response rio root rooted run screen seem served server servers serves shell solaris source space specifies specify src standard starts style sys systems term terminal terminals tree turns typically unix user users using usr values variables version versions via virtual windows drawterm	8/drawterm
 able add amount apply background bit black blue border bugs chandesc channel cmd color combined compressed compression constant convert converted converting coordinate coordinates crop crop.c cropped crops cut default depths described descriptor diffusion dithering draw dx dy edge edges error exact extra file fill floyd format frame generate geometry green grey iconv image image's imagefile input insets larger mapped maximal maxx maxy minx miny monochrome negative option options original outer output outside picture pink pixel pixels processing reads rectangle rectangular red remove resulting run scale similar source space specifies specify src standard steinberg step strip sys takes ten translated triplet turns tx ty unchanged value ways writes crop	1/crop
 able address addresses aliasmail appended assigned attacks authenticate authenticated authentication blocked broken can't carefully clear clients cmd configuration connect connection connections continually conveniently converted copies cram debugging denial destaddr destination determine determined dev df dfr directory dns domain dropped e.g effects encrypted entry envelope environment error evilipaddr faces file files filter finally flag forward fully gateway header host incoming inferred input intended ip isn't lessen lib list listen listener logged login mail mailers marshal md5 message messages mlmgr mx mydom names nedmail netdir network networks non notified option options output pass password peer permits permitted prevents previously protocol protocols qer qualified queue.dump rcpt receives receiving relay relaying remote requires rewrite run saved send sender sending sends site smtp smtpd smtpd.conf source specifies src standard startup stored sub supported sys sysname tlssrv transfer transport trusted turns unqaulified upas upasfs users using validation variable via smtp	8/smtp
 abnormally answer array automatically bugs char characters closed copied created creates defined executed existing exits fclose file files fopen generates include l_tmpnam libstdio mode names non opened overwritten particular pointer removed return returns source src stdio stdio.h string sys template temporary terminates tf000000000000 tmp tmpfile tmpnam tn000000000000 update valid value void tmpfile	2/tmpfile
 abort accumulated actually adding addition allocated allocation ansi append associates attached attempted attempts automatically binary bio buf buffer buffered buffering bufsiz bugs char character characters clearerr closes closing compatibility computed constant consume corrupt create creates current data deal declared default defined delay delivering described descriptive descriptor designate designates device diagnostics distinction earlier empties eof error errors errstr except exception exec exits extensions external failed fails faster fclose fd fdopen feof ferror fflush fgetc fgetpos file filename fileno files fill filling flushed flushes flushing fopen fprintf frees freopen fscanf fseek fsetpos ftell full fully further host identify ignores implement implementation include indicate indicator initialized input int integer interactive iofbf iolbf ionbf length libstdio maintained malloc measured memory method mode necessary newline non null object obtains occurs offers offset older opened opens operations output package pages plan pointed pointer pointers pointing pos prevent process read reading receipt related returned returns reuses rewind runes says sclose seek_cur seek_end seek_set seeking setbuf setvbuf simpler size smaller somewhere sopenr sopenw source src standard starts stderr stdin stdio stdio.h stdout stores stream streams string strings success support supports sys takes text tmpfile transactions trouble truncate type unbuffered uniformly unintelligible unless unwritten update using utf value valued values void whence write writing written fopen	2/fopen
 abort acid active address aligned allocated allocates allocating allocation allocator ansi arena array behaves beyond bizarre block blocks bounds brk bugs bytes calloc clr combine common convention corrupt corruption custom data detect diagnostics directly elsize encompass errors errstr examined except execution extra fields flags freed freeing frees further gaffes getcallerpc getmalloctag getrealloctag grows include incompatibly inconsistencies initialized int leak legal lesser libc libc.h library likely mainmem maintains malloc malloc.c malloctopoolblock mallocz memory moved msize nelem non null object obtain obtained op package passing pc pointed pointer pointers pool pool.h pool_noreuse poolcheck port possibly previously properly provide ptr realloc reallocate reallocated return returned returns routines scan setmalloctag setrealloctag setting size sized sizes sometimes source space specification src storage storing suitably sys tag tags takes traces trump type u.h ulong unchanged undefined unused user valid value void wrapper writes written zeroed malloc	2/malloc
 abort allocated answer arriving canceled client completed conditions considered correctly created depends discard doing echoing exceptional fid file flush flushed flushes flushing handled honor identified instance interrupts invalid longer message messages needed oldtag pending process purge read receive received recognizes request rerror respond responded response reusing rflush semantics sending sends sent server signify size specification tag tcreate tflush transaction twalk user wait flush	5/flush
 abort ansi arrays assembly behave bounded bugs byte bytes bytewise check comes compares comparison copied copies copy count dependent destination efficiently equal except greater guaranteed handed handle identically implementations include int integer language lexicographically libc libc.h looking machine memccpy memchr memcmp memcpy memmove memory memset negative objtype occur occurrence operate operations overflow overlap overlapping plan pointer port portable receiving require returns routines source src stopping strcat sys u.h unsigned value void whichever works memory	2/memory
 abort arg arg1 arg2 argbegin argc argend argf arginit argopt args argv argv0 assume badflag bffile1 break cases char character characters code conventionally copy current default doesn't eargf exec executed exits extern file1 file2 include int integer letters libc.h list macro macros main names nil option options output pointer points print process processing prog remaining requires rest returning returns rune running runs scope source string surround switch sys takes typical u.h usage value void arg	2/arg
 abort assert assert.c check cond define false include int invariants libc libc.h macro message port preprocessor prints source src sys u.h via void assert	2/assert
 aborted aborts access accessed acts additional advisory afid agent allow allows aname append aqid arbitrary arrange arrives attach attached attempts attributes auth authentication based besides bidirectional bind bit bits brackets byte bytes cases character characters choose chosen client clients clunk combined communication complete components confusingly connection consists constant constants consulted contains convention convert convey copied count counts create created current data defined delay deleted deletes demand dependent described describes describing descriptions descriptors device directly directories directory dmappend dmauth dmdir dmexcl dot driver eight ename encoded endian entry enumeration error established establishing etc events everyone examined except exception exchange exchanging excluded exclusive execute executing existing explicit explicitly external failed failure fcall fcall.h fid fids fields file file's files final fit flush forming generate gets grant greater group's groups handle hence hexadecimal hierarchical hierarchy historical hold id identification identifications identified identifies identify identifying illegal implicit include includes incremented independence indicates indicating initializes inside integer integers interim intro introduction iounit items kept kernel keyboard larger latter leader legal length lengths library literal longer low machine maintains managing manipulated matching maximum media member message messages mnt mode modification modified modify mount msize names navigate navigates necessary needed negotiable negotiated newfid notag notation nul nwname nwqid offset oldtag ones opened operating operation original outside outstanding override owner parameter parameters parent particular path perm permanent permission permissions permit plain plan pointing possibility prepared presented printable privileges proc process processes programs properties protocol prototypical proven provides providing qid qids qtappend qtauth qtdir qtexcl qtfile rattach rauth rclunk rcreate read reading reads reasons receives receiving recreated reduce refer refers regarded remaining remove replied replies reply represents reproduced request requested requests rerror respond responds response responses restricted restriction resulting retrieves returns reused rflush root ropen routines rread rremove rstat rversion rwalk rwrite rwstat says send served server server's servers session share sharing shorthand significant situation size sizes skipped skipping slash slashes someone sometimes somewhat space specify specifying stat stored stores string strings structure structures subdirectories subsequently supply support syntactic synthesize synthesizes systems tag tags tattach tauth tclunk tcreate text textual tflush therefore thirteen time times topen transaction translated transmits transmitted transmitting transported tread tree trees tremove truncated truncating tstat tversion twalk twrite twstat type typically uname unicode unique unless unlikely unsigned user users ushort using utf valid value variable version wait waiting walk walks wname wqid write writes writing wstat 0intro	5/0intro
 aborted absolute activity add added affect affected alias aliases allow allows append appended appending approved article avoid backslash berliner blank brian cases central character check checked checking checkout code coding collections comment comments commit commitinfo commitinfo,v committed committing common compiled complete concurrent conditions conform considered contains continued control controlled copies copy copying copyright create created creates creation current cvs cvsignore cvsignore,v cvsroot cvswrappers cvswrappers,v cygnus deep default define defined defines defining definition definitions del derived described developers dir directories directory distribute distributed edit editinfo editinfo,v editing electronic enable enables english entire entries entry exactly except execute executed executing exist exists exit exits explicitly exported expression feature february fields file filename filenames files filing filled filling filter finally finds flags flexible foreach.m4 forloop.m4 format formats forms foundation full gnu granted hierarchical i.e identical ignore immediate include included intended intermediate invocation involved involving jeff language level levels lines list listed listing load loaded loads log logging loginfo loginfo,v looks m4test mail maintained manage manages manual master match matches message messages mname modifications modified module modules modules,v mov names newsgroup non notice older operate operation options original pair pairs particular path pathname paths patterns permission person piped points polk portion post practice pre preserved private procedures proceed process processed prog programmer programs proper provide provided providing rcsinfo rcsinfo,v ready record recorded records reduces refer reformat regular relative remainder remaining removed repositories repository represents rest resulting revision revisions rtag run runs sample satisfied script scripts select selected send sending session sh sharing simplest site's software somewhere source sp specification specifies specify specifying standards starts startup status strings structure sub subdirectory supplies support supporting symbolic tag tagged taginfo taginfo,v tagname template templates terms text time translations traverses treat typical unsupported update user using valid validating verbatim verify versions ways whatever whenever whitespace wish working wrapper wrappers write writes wth cvs	6pub/cvs
 aborted access acid actions address alef allocated allocates alt alts analogues arbitrary arg argc args argv array atnotify aware behave block blocked blocking blocks buffer buffered calling cases chancreate chanend chanfree chaninit channel channels channoblk channop chanprint chanrcv chanrecv chansnd char chosen communicating communication contains continue control cooperatively coroutines cpid create created creates current data debugging declare default define delayed delivered depends describes descriptions descriptors desired die directed discarded distinguish e.g eight elsize entire entry entryno environment error errors eventually example.c exec exec'ed execl executed executes executing execution exit exits explicitly external failure fashion fields file files finishes fixed flags fmt fn fork formats freed freeing frees full further global holding id identical identified identifying ids include index inherits initialized initializes inside int integer internally interrupted interrupts intro invoke invoked item kills kilobytes languages lib libc.h library libthread list listed lock longer main mainstacksize malloc manage management manner marks memory mentioned messages modified names namespace nbrecv nbrecvp nbrecvul nbsend nbsendp nbsendul nel newly newsqueak nonpreemptively note notify null occupy occur occurs op operating operation operations parallel pass perror pid plan pointed pointer pointers potential preempt primarily print proc proccreate procdata proceed process processes processor procexec procexecl procrfork procs programming programs provides qlocks queue random read receipt receive received receiver receives recv recvp recvul related relinquish relinquishes rendezvous replace response return returned returning returns reused rfcenvg rfcfdg rfenvg rffdg rfmem rfnameg rfnoteg rfnowait rfork rforkflag rfproc rfrend robin round run running safe safely scheduled send sender sending sendp sends sendul sent shared similar similarly size source sp space src stack stacks stacksize started status storage stores string struct structure structures success support synchronize synchronizing sys sysfatal tag terminate terminates therefore thread thread's thread.h threadcreate threaddata threaded threadexits threadexitsall threadgetgrp threadgetname threadgrp threadid threadint threadintgrp threadkill threadkillgrp threadmain threadnotify threadpid threads threadsetgrp threadsetname threadwaitchan typedef u.h uint ulong unblocks unbuffered unique unsigned using valid value variable variables varying versa via vice void wait waitmsg ways yield thread	2/thread
 aborted active automatically bytes characters client client's clunked communication connection contains count data defined defines digits earlier entry enveloping equal excludes expect extending fauth fids freed further fversion generate generated honor identifies identifying includes initializes issue length level limit maximum message messages mount msize negotiate negotiates nnnn notag outstanding points protocol protocols receive received reply request requests required rerror respond responds response rversion sent server server's session sides size string strings stripping substring successful suffix suggests tag thenceforth transport tversion understand uninitialized unknown ushort value version version	5/version
 aborts access accessed affect allow allows alt apop args authenticated bandwidth behalf bit bits buffer bugs challenge characters chooses clients closes cmd co color colors computing connected connecting connections consumes contact control copyrect corner corre correctly cover csv ctl ctrl default depth desired desktop disconnect display displays drawterm e.g eight encodings events executed exist existing fixed format frame full geometry global handles happens height hextile host http hunts interface invoked key keyboard keystrokes kill killing larger list location map mapped matching memory message migrate modifiers mouse native nearest negotiates network note option options ordered output owner particularly password pixel pixels pressed printed private process protocol provides r3g3b2 r4g4b4 r5g6b5 raw rc receipt rectangle remote requests require resizes response restarting results retyped rio rre running screen send sent sequences server servers settle share shift shifted shutdown similar simultaneous size smaller source space specifies specify src started starts stderr support sys systems terminal therefore translates typing unique upper user using verbose viewer viewers virtual vnc vncs vncv waits whichever width widthxheight window www.uk.research.att.com vnc	1/vnc
 abound accuracy aes algorithm algorithms alpha bit blowfish checks computation confirm count des divides divisibility divisible dsa dsaprimes elgamal factor generate generates generation generator genprime gensafegprime gensafeprime genstrongprime include int integers key length libc.h libsec libsec.h miller mod mp.h mpint multiplicative nist non nrep patient primality prime primes probability probably_prime properties rabin random recommended repetition returned returns routines rsa seed sha1dlen skeptics slow smallprimetest source src sys test u.h uchar using void prime	2/prime
 abs abs.c absolute diagnostics fabs floor include int integer labs libc libc.h negative port return returns source src sys u.h unrepresentable value values abs	2/abs
 abs absolute ceil ceiling double fabs floor fmod frexp greater include integer iy largest libc libc.h port remainder returns sign smallest source src sys u.h value floor	2/floor
 abs acos allows appeared arithmetic asin assignments atan backslash basic bc braces bugs built cmd consists constants contains control cos cosh dc decreasing definitions deg degrees ends environment eof equivalent error evaluated exp explicitly exponentiation expression expressions file files floating flow formed func gamma gcd grouping hall hello hoc imperfect include input int interactive interprets introduced kernighan language level list listed log log10 names newline operators option output phi pi pike precedence predefined prentice print printed prints proc procedure procedures produce programming radian read reads recovery results return returns sin sinh source space sqrt src standard statement statements string syntax sys tan tanh temp typically unix unless usual value variable variables hoc	1/hoc
 abscissa abscissas actually applies automatic automatically axes axis blanks bounds break bugs character cmd connected connecting curves default determined devices disconnect disconnected display distinguishable draw dropped encoded equal exceeds filters fraction frame full grap graph graphics grid height horizontal input integers label labels legend limit limits lines log logarithmic lower mode move newlines nonnumeric option optional options ordinate ordinates output overlay page pairs plot plotting points printed quantities quotes ranges recognized reversed rotates run save scale scales scaling screen segments similarly source space spacing src standard straight string style styles successive superposed supply surrounded sys takes third ticks title transpose unless upper value values vertical width windowed graph	1/graph
 abscissae add addition additive adjust aid arrow automatic automatically base bentley blank blanks bot bottom bottommost bullet capitalized category character characters circle cmd comment computation conditionals contains continue coord coordinate coords copied copy cos current dash dashed data debugging default define defined defines definitions discarded disconnect dot dotted draw drawing e.g edition error etc evaluate everything exist exists exp explicitly expr expression file files formatting frame generated grap grap.defines graph graphs grid grids happy ht inches include included independently input instructions int invis irrelevant iterator iterators justified kernighan label labels language leading leave lib linedesc list ljust log loops macro macros mandatory manual maps margin marks max min mode modify mostly multiplicative newlines non omitted op operators optional optionally optname output override overrides pass perpendicular pic plot plotted plotting plus preprocessor previously print printf processing programmer's provided provides ps qualified rand random range ranges remainder removed requested research rest returns rjust scaled scaling sh shell shift sides silly sin size solid source sqrt src standard star steps stop str string strings style styles suppress surrounded sw symbols sys tenth text thing1.se thing2 thru tick ticks transformations treating troff typesetter typesetting unix value var verbatim volume whatever wid width works x,y1 x,y2 grap	1/grap
 absence accesses adding addition aitoff albers aligned allow angle arc arccos arising arranges aux axis azequalarea azequidistant azimuth azimuthal bank based bearing betrays bicentric bilateral bin bonne border borders boundaries boundary bounds breaks bugs bureau canada canal canals cap census center centered centers central charts chauvinism circle circles circular classified clipped closing cmd coarse coincides colatitude comment compass computing concatenated concentric cone cones conformal conformally conic connected consider contains convention convex coordinate coordinates corners counted counterclockwise counties courses covering cross crystallography curved customary cylequalarea cylinder cylindrical dashed data date default define defined degree degrees described descriptions designated detailed developed diagnostics diagonal diagonally directory display displayed disputed dist distance distances dlat dlon dot dotted doubly draw drawing drawn driver dropped earth earth's eastern edge edges ellipse elliptic encompassing environment equal equally equator equatorial equilateral except excessively exist extend extent factor fall falls fan faster feature features file files filled filter filters finally fisheye fit forced gall gazing geodetic gilbert glacier globe globular gnomonic grid gridded guyou harrison height hemisphere hemispheres hex hexagon higher homalographic homing horizontal iceshelf ii ilake image imagine include indefinite independent index indexes infinity input inside intermittent inversely invisible iriver irrigation islands label labels lagrange lakes lambert lat lat,angle lat0 lat1 latitude latitudes laue lesser lib likely limb limited limiting limits lines list lists log lon lon0 lon1 longitude longitudes looking lower lune map mapd mapdemo mapdir mapped mapping maps mecca medium menu mercator meridian meridians middle mile miles minor miscellaneous missing mollweide move names newline newyorker nominal nonstandard north northern numbered numerical oblique observer omit ones onto opening operations opposite option optional options orient orientation orientations orthogonal orthographic orthographically output outputs outside overlay overrides page pairs parallel parallels pathnames pedestal performed periodic perspective plane plot plotted plotting points polar pole poles polyconic polygon positioned positioning positive prefixed prepares presenting prime produced project projected projection projections properly provinces quality ra radial radii radius range ranked ranks ray rectangle rectangular reef refined refractive res resemble resolution response retroazimuthal reverse river rivers road rot rotate rotated runs saltpan scale scaled scaling scene seacoasts segments setting sheet shore shore1 shorelines short shows simpleconic sinusoidal size solid source southern sp_albers sp_mercator spaced spacing spacings speed sphere spheroid square src standard star stereographic stereographically straight stretched string strings style suitable superpose support supports suppress suppressed survey switch symbol symmetric symmetry sys tan tangent tetra tetrahedron textured th tilt tilted time times track tracks transparent trapezoidal triangle triangles tries twist unbroken underlying unfolded unknown unprefixed vandergrinten variables varies various verso vertical vertically vertices view viewed viewing views visibility western width window windows wise yankee yorker ±lon0 map	7/map
 absence add adds adequate angle ansi blank brackets cmd comments compilers cpp debugging def default dependencies dependent described dir directives directories directory environment except extra files generate ifile include independent input insert interprets language linenumber lines list listed machine macro mk numbering objtype ofile option options original output path plan preprocessor print processed read reads search searched source specifying sprinkled src standard substitution suitable superfluous sys text twice understand variable cpp	1/cpp
 absence affect applicable assumed bjc bjc240l bugs canon canonbjc240l check comma commas connected convert copies cw.11 cycle daemon default degrees desired deskjet dest destination destinations dev device devices doc.ps double dsafari dstdout duplex entry environment eqn equations fcw.8 feed file files font generalized generic ghostscript glick gs guide header horizontal hp hpdeskjet i.e image inches include input invoked jobs kill landscape lib lines list logical lp lpdest lpt1data machine magnification manual measured mode ms names noproc offset option options output page pages paper physical port postscript pr print printer printers printing proc processing processor queue range ranges regular remaining restarts reverse running safari select sided simplex slot spooler standard status stdout stops supported suppress syntax sys tex text tray tries troff typeset user using variable vertical wedged window windows lp	1/lp
 absent addresses alternatively applicable arbitrary audio audioctl audioin backward bass block buffer bus bytes chance channel characters checks classes cmd columns compatibility compatible configuration configures continuously control controller ctrlno current data dev device device's devices discrete driver drivers dynamic endian events favorite fields file files finds fixed flag foreground format frequency handling implement implements indication insertion integral kernel keyword level listed locate maintain manages maxima maximum mice minimal minimum mounted mountpoint mouse mousein names numeric occupy omitted operations ordered overrides pair percentages plan primarily processes produces profile programs provide provides range read reading removal replace report reported resolution returned run runs samples sampling scans script search secondarily sends serial settable setting settings size sized soundblaster source specific speed src starts status support supported syntax sys test time treb universal usb usb0 usbaudio usbd usbmouse usbstart user using usual value values variable volume write written yields usb	4/usb
 absent bytes cmd contains copied data date debugging dv error fetch file ftp ftpfs hget hget.c http incomplete ip length lines missing modified mount mounted net netmntpt ofile option output page performed post posted progress retrieve retrieves source specify src stack standard sync sys total transferred turns type types url web writes written hget	1/hget
 absolute abuts accurate acme actions add addr analyze append application applications applied arg assignment attr attribute attributes basic behavior bit blank block browser built bytes cases character characters check click client commentary component components consist constructed contains convention conventional count cp current data declares default defined defines definitions delete deleted delimited describe described describes destination detail determined dir directory discarded dispatch dispose dollar domain dst e.g edit editor embedded emits emitted enable encoded ending ends entire equal error etc evaluated eventually exactly examined exception executing existing expand expression expressions extract extracts fails fields file fileaddr files fires follow format formatted formed ftp generally generating gif gopher horse.gif horse.gift https identical identified identify image implicitly include indicate intended interpreting interprets isdir isfile jpe?g jpeg largest leading leftmost lib library lines list location longest macro mailto maintains match matched matches matching message messages misinterpreted missing mnt modest mount mouse ndata newline newlines news nntp none object objects occur optional page pair pairs parenthesized path pattern patterns pdf permanent picture piece plumb plumb.h plumber plumbing plumbmsg pointed port portion ports possibly pre predicates processes produced properties protocol ps quote quoted quoting rc received receives refer refers reformats regarded regexp regular reports representation representative requires response rest resulting retrieve rewrite rewritings rule rules run sam sees select selection send sender sending sent shell sign signs skipped space specific specification specifies specify src statement statements string strings structure style subexpression subset substitutes substitutions succeed successful supported supposition syntactically sys tagged telnet terminates text textual transmission triggered type typically unchanged unless unlike update urls user using usr usual value variable variables verb verbs wais wdir web webbrowser window wins working write za plumb	6/plumb
 absolute accept acceptable accepted accepts accumulate acquire acquired actions activate activation active adapting add added adding addition addressed adds affect affected affects aggregator aid aim align alignment alignments allocate allocated allow allows alphabetical alt altogether anywhere appearance appearances append applications appropriately arbitrary argc args argv ascii assembles assembling assign assigned associate association attach automatic automatically avoid background backspace bad bar behave behaves behavior bindings bit bitsy black boldlatin1.6.font border bordercolor borders borderwidth bot bottom bounding box boxbox boxboxes boxes boxname brief bring buffer bugs button buttonname buttons calculate calling candidate caps carriage catch caveat center centered centerleft centerright ch chan chancreate channel channels chanprint char character characters choices clamp clamped clear clears click clicking clicktotype client closecontrol closecontrolset clumsy cname collection collections collects colocated colon color colors column columns combines common complete composed computes configuration configurations configured connect connecting consists constituent contains continue control control's control.h controlcalled controlled controls controlset controlset's controlwire convenient coordinates copies correct correctly correspond count couples coupling covered create createbox createboxbox createbutton createcolumn created createentry createkeyboard createlabel createmenu createradiobutton createrow creates createscribble createslider createstack createtab createtext createtextbutton creation cross cs ctl ctldeletequits ctlerror ctlmalloc ctlprint ctlrealloc ctlrunestrdup ctlstrdup current cursor data deactivate dealing debugging decimal decreases default defaults defined defines del delete deletes delivered delivers delivery described describes descriptions design destination destroyed detail details determined determines devices dir direction directly disable disabled display displayed displaying displays document documented don't downwards dragging draw draw.h drawing drawn dx dy easiest easy echoed edit editable edited enable enabled encodes encounters encouraged enlarged enter entry entryname equivalent error established establishes etc event events eventually exactly examining existing exists exits experimenting explicitly extra fail failed fatal features fields file final finally finds fine fingers fit fixed flag fmt focus font font's fonts format formats formatted formatting frame freectlfont freectlimage freed frees further generated generates geometry getfields getwindow global globally goal goes graphical graphics greater grouping groups guarantee handled handles height heights hello helper hexadecimal hidden hide hiding hierachy hierarchies hierarchy highlight hits honored hor horizontal identified ignore ignores illuminates image images implement implementation implements include increases independently index indexed indicate indicates indicating indicator indicatorcolor indicia initcontrols initdraw initialization initialize initkeyboard initmouse input inset insetrect install int integer integral interactive interchanged interline interpretations interprets invisible justified kc key keyboard keyboard.h keyboardname keys keystroke keystrokes label labels largest lay layed layout lays level lib libc.h libcontrol library linecolor lines linked lock log lost low lowercenter lowerleft lowerright lucidasans lucm maintained malloc manages managing manipulated manipulates manner mask masks match matches matters max maximum maxx maxy maxΔx maxΔy mc meaningful mechanism member memory mentioned menu menu's menuname menus message messages method min minimum minx miny minΔx minΔy missing modified moreover mouse mouse.h moved msec multi multiline multiplexing name1 name2 namectlfont namectlimage names naming nbot necessary needed needs neither nelem newcontrolset newline newlines nil nn non none note ntop nul numbered numeric numerical object obvious occurred ommitted ones onto opaque operation operations opposite optional organized orient orientation origin other's output overlayed packagings packed page paint paleyellow palmtop paradigm parses particularly pass passwd.9.font passwords pastes permits piece pixels placement plain plan plans pointer pop portion positioned precede presented presents press pressed pressedtextcolor primitive print printed prints processed processes processing programs properly proportional proposal provided provides q.v quotation quote quoted quotefmtinstall quotes quoting r1.max.y r1.min.y r2.max.y r2.min.y radio radiobottuns radiobutton radiobuttonname range rc re react reader reading rearrangement reasonable reassign reassigned receive receives receiving recipient recognized reconnect rect rectangle recvp red redraw refbackup refer referenced refers refnone refresh refreshed refreshes region regular released remove removed removes render repetition replace reported reports representation representing request requested rerouting resize resizecontrolset resized respects respond responsive rest resume return returns reveal revealed revealing rewiring richer roles row rows rules runes screen scrib scribble scroll secret section sections select selectcolor selected selection selections selectmode selects selecttextcolor send sender sending sends sensible sent separation separator serve setting setup share shared sharing shift shown shows significant simply simulated situations size sizeof sizes slide slider slider's slidername sliders snarf source space spaces spacing specific specifies specify squared src stack stacks standard static strcmp strict string strings strokes struct structure structures subject supremum sync synchronization syntax synthesizing sys sysfatal tab tabbed tabs takes tears terminator text textbutton textbuttonname textbuttons textcolor textname textual th tha thread thread.h threadexitsall threadmain threads tightly time toggle toggled toggles tokenize topline touch tp transmitted transparent trigger triggered triggers trivial turns type type1 type2 typed typedef types typically typing u.h uint unadorned unicode unicode.6.font unimplemented unique unless unmodified unpredictable unquoted unselected unusual uppercenter upperleft upperright user using usual utf valid value valued values variable variant various ver verb vertical vertically via vis visibility visible visual void volume whenever width widths window windows wise works write writing yellow yield control	2/control
 absolute accept acceptcookies actual address agent allocated allows arrives associate assumed attr attribute attributes based baseurl bell bugs chatty9p clear clone closed cmd comment comprises conform confusingly connection connections consistent contains content contenttype controls cookie cookiedebug cookiefile cookies ctl current data debug debugging decimal default defaults described descriptor determine directories directory discussed discussion domain dot edited editing effort epoch equal equivalent error ether executed expire expires explicitdomain explicitpath fetch file files finally flag flags format fragment fsdebug ftp ftptype global header hget hierarchies host hosts http https included index.html inferred infinite initialized initiates instance instances interface internal ip it's italics keeping labs.com level lib library loop maintain message mime mnt module mounts mtpt names netscape netscapestyle network numbered opening ordinary output page pairs parameters parsed parses parsing particular password path pattern persistent pieces plan post postbody posted presented presenting presents prints private profiles protocol query read reading reallocated redirect redirecting redirectlimit redirects relationship relative remote request requests respond resulting retrieved retrieving rfc2109 root's scheme schemedata seconds secure sendcookies sends sent server servers share source specification src srv standard stored string strings style suffix suggestive synonymous syntaxes sys text time traces type unimplemented url urldebug urls user useragent value values variable variables version via web webcookies webfs whim wide writing written www.bell www.lucent.com www.not www.research.bell yields webfs	4/webfs
 absolute actions actual added addition additional adds albaseline albottom alcenter alchar align alignment alignments alink aljustify alleft allocate allocated allocates allocation almiddle alnone alright alternative altop altrep analogous anchor anchorid anchors animated application array ascent assigned attribute attributes automatically auxiliary availw background backgrounditem bar bars base baseline belonging bind bit bits blank bold border break buf buffer bugs builds bytes caller caph caption caption_lay caption_place cases cell cellid cellpadding cells cellspacing center char character characters check checking chset class clear cleared client col collection color cols colspan column columns combination complex components composed comprise considered consists consortium contained contains content control conventional conversion converted converts coordinates coords corner correct correspond correspondingly created ctlid current data datalen dbgbuild dbglex debugging default deffnt defined defines definition describe described describes describing desired destanchor destination destinations dests detail details dimen dimenkind dimension dimensional dimenspec directly displacement display displayed dnone doc docinfo docinfo.anchors docinfo.dests docinfo.forms docinfo.images docinfo.kidinfo docinfo.maps docinfo.tables doctitle document document's documents don't dpercent dpixels draw drelative emalloc embedded encapsulates encoded encodes ensures entire enum enumerated equiv erealloc error event events everything except expanded expects extracted fails fbutton fcheckbox ffchecked ffile ffmultiple fg fhidden fieldid fields fill fimage finally finds finished fit flags float floats flows fmt fnt fntb fnti fntr fntt font forced foregound form's format formatted formfield formid forms fpassword fradio frame framebd frameborder frameid frames frameset framesets freed freedocinfo freeitems freset frhscroll frhscrollauto frnoresize frnoscroll fromstr frvscroll frvscrollauto fselect fsubmit ftblank ftext ftextarea ftparent ftself fttop ftype genattr generic gets global grid halign handles handling hang hangs hasn't hasscripts headed header headers height hget highlighting holds horizontal hpost href hspace hspec html html.h http hyperlink hyperlinks hypertext id ids ifbrk ifbrksp ifcjust ifcleft ifcright ifhang ifhangmask ifindentmask ifindentshift ifloat ifloattag ifnobrk iformfield iformfieldtag ifrjust ifsmap ifwrap ignore iimage iimagetag image images imheight implement implements imsrc imwidth include includes indent index indicate indicates indicating indices infloats info initially input inside installed int integer intended intermediate internal internally interpret interpretted irule iruletag isframeset iso_8859_1 ispacer ispacertag ispgeneral isphspace ispnull ispvline itable itabletag italic item items itext itexttag justified kept kidinfo kidinfos kindspec laid lay layout leaves length lexer libc.h libhtml library lines link linked list lists loaded low malformed malloc map map's mapped mapping maps margin marginh marginheight marginw marginwidth markers maxlength maxw measures media mediatype memory meta method minw msg mtype names ncell ncol ncols ncoords needed negative nested newly nextfloat nextframeset nextimage nextinrow nfields nil non noresize noshade note nowrap nrow nrows null numfnt numsize occur offset ok option optional options or'd original pad padding page parameters parsed parsehtml parser parses parsing particular parts pdi pending percentage permanent permitted pertaining piece pixels placing pointer pointers points portion pos predefines print printed printitems process provide provided provides purposes realloc referenced reflects refresh relative remaining represent representation represents requested required reserved resize respond retrieved return returned returns rgb role roman routines row rows rowspan rule rune screen script scripted scripting scripts scripttype scroll scrollbar section sections selected send seonblur seonchange seonclick seondblclick seonfocus seonkeypress seonkeyup seonload seonmousedown seonmousemove seonmouseout seonmouseover seonmouseup seonreset seonselect seonsubmit seonunload serial server sevent shaded shape shcircle shpoly shrect similarly size smaller solid source space spacer span spanned spans spec specific specification specifications specifiers spkind src standard sticks stops store stored strike string strings struct structure structures stuff style styles submitted subsidiary substructure subtract successor suggested sys tab table table.cells table.grid tablecell tablecol tableid tablerow tablerow.cells tables tabletok tabstop tag tagged tags takes target targetid targetname targid td tenths terminate text texthtml textjavascript textplain tfisth tfnowrap tfparsing th times tiny title token tostr total toth totw track traverses type typedef types typewriter typical typically u.h uchar ul ulmid ulnone ulunder underline underlying unicode unique unnamed unsupported unvisited url us_ascii user using utf_8 valid validitems valign value values variable variant variety various verb vertical verylarge via visited vlink voff voffbias void vspace w3c warn warning web weight whenever whereas wide width wrap wrapped wspec html	2/html
 absolute actually add addison adjust affect al alternatives angle angles anywhere apart ar arc assignments asterisk aux auxiliary auxname axis b:c base bbl becomes behaves behavior bib bibinputs bibliography bibliographystyle bibtex bin bit bitmap bitmapfonts bitmaps bizarre bk black braces bst bugs building center chapter character chatter circular cite clipping clockwise cmd colon colons commas common compress configuration conjunction constrained consulting contains controlsequence convert converts coordinate count count0 count1 count9 created creates creating cross current da dashed dashes default defined degrees delatex deroff described describes descriptions dev device diameter directly directories directory distill distilling dlen doc document documentation documents doing don't dot dots dotted downward draw drawing drawn dt dvi dvifile dvips dviselect ed edition editor elliptical emitted enable endpoints entire environment equal error especially et everything execute executed exist expand explicitly extend extended extension extract fair file files fill finally first:last flush fly font fonts format formats formatting forming fp friends gather generate goes graphics grey guide headers hierarchy hoffset hscale hsize illustration inches include included includes independent index indicated infile input installations installed interspersed invoked jobname key keys knuth lamport landscape lar latex leading leave length level lib list listed listing lists loaded locally log looks lp ls macro macros manner manual matrix measured medium mem mentioned messages metafont metapost metric mf mfinputs midpoints milli miscellaneous mktexlsr mode modified mp mpinputs names necessary needed negative notation numeric object objtype offsets omitted openin option optional options organized origin outfile output outputs overridden pa packages page pages pairs paper paper.tex path paths pdf pen periods pic pieces pk pkfonts pn points polygonal pool portable positive possibly postscript preloaded preparation print printed printers processes processing produces programmer's programs proof properly ps psfile psfonts psvf quadratic quick quickly radii range ranges rc reads referencing replaced research reset resulting reverse reversing rooted rotate run runs runtime scale search searched searches searching section segments select selector selectors selects sending separately seventh sh shading sign simulates sit sites size sized sizes slen slitex sought source sp space specials specify specifying spelled spline src standard started straight string strings style supporting switch sys table takes template ten tenth testfont.tex tex texbook texedit texformats texinputs texmf texmf.cnf texpool texput text texvfonts tfm tfmfonts thebibliography third time tpic transformation translate tree trickey troff truncated twice typesetting typically underscore understands units unix user using usr value values variables varied various verbose version versions vffonts viewgraphs virtual voffset volume vscale vsize walk walking web2c wesley wh wherever width wildcard write writes writing written x,y xr yr tex	1pub/tex
 absolutely access add append assign bits chmod chmod.c cmd combination constructed default directory exclusive execute existing file file's leader letter letters ls mode modes octal omitted op owner permission permissions read reset search source src stands stat symbolic sys ugo user's write chmod	1/chmod
 abutting accesses accident actually adding addpt allocate allocation allocimage alphabet application applications appropriately approximately archaic arranged arranges arrays arrow ascenders ascent ascii assume automated automatically backing bad baseline beyond bit bits black border bottom boundaries buffer buffered bufimage bugs buildfont builds bytes cachechars can't chan channel chantodepth chantostr char character characters client client's clients closedisplay clr color common connect connection connects cons contains contiguous convention convert coordinate coordinates copied core create created creates current curs cursor cursor.h cursorset cursorswitch data default defaultfont defaultsubfont defined defining definition desc descenders described describing descriptor desiring detail detailed details dev devdir device diagnostics directories directory disconnects display displayed displays distance doing draw draw.h drawerror drawing driver dx dy edges endian environment errfun error errstr establish etc euro european event excluded executing exist extern extra failed fails failure fatal fd fields file files flush flushes flushimage fmt font fonts format formats frame freefont frees fresh full further gengetwindow geninitdraw getdefont getenv getwindow global graphics height hence hidden hierarchy highest historical holding identify image images immaterial imports include includes increasing independent indexed indication initdisplay initdraw initialize input inside installs int interactive interline internal international interrelated ip label languages latin1 letters lib libc.h libdraw library library's location lockdisplay locked locking looking lower lowest map marks mask max max.x max.y maximum mechanisms memory message messages method min min.x min.y minimal mount mouse mousedir moves mrepl msg multi namedimage names naming needed negotiates nil nine non none notify null offset op opaque openfont opening operating operations ordwr organized oriental overall overloading overwrites overwritten package parses particular path pending pfmt phonetic pixel pixels pointed pointer pointers points portion presented print printing private process programs protected protocol provided provides punctuation range raster reading reads reconnect rectangle rectangles rectangular ref refnone refresh reminders representation representing represents requesting reside resize resizing resources restore resulting return returning returns rfmt rfnameg rfork rio root routine routines row rows runes running screen screen2 send sent similar size sized soft sophisticated source sp space spacing specifies src srvwsys store string strings strtochan struct structure structures subfont subfonts subwindows success switch sys sysfatal sytem text time tmp transparent typedef u.h uchar ulong unfortunate unicode unlockdisplay upper using utf values variable variables various vis visible void win windir window window's windows winname wish writes writing written wsys graphics	2/graphics
 accelerated acceleration application arrow binary bind bit bitmask bits blank blocks bugs button buttonmap buttons byte bytes characters clears clients clr configures consist controlling controls coordinates cope current cursor cursors decimal default delta described details dev device devices devmouse.c displayed don't endian equivalent event events except exclusive external extra fewer fields file files format generated generates graphics hardware host hwaccel ibm idempotent illusion image implement inclusive intellimouse intended interface interpret kernel key laptops letter level linear managed map message messages mice microsoft middle milliseconds mouse mouse's mousectl mousein move msec multiplexed notably note notification offset omitted opened ops owner pointing port pressed private processed provides ps2 ps2intellimouse read reading res reset resize resolution rest restores returns rio screen semantics serial setting shift software source space specifying src stamp status strings swap swaps sys thinkpad time turns units unlike usb user using usual via wheel wide window write writes writing written xyz mouse	3/mouse
 accelerated add adding adm auth authentication bin bind bit bootstrap brings build built changeuser chosen con cons consctl console cpu cputype create dev directories drawterm echo environment establish established euro.9.font exec exists file fn font fs label latin1.8.font lib looks mail mailbox mnt mousectl namespace necessary news newuser option passwd password pelm plan plumber plumbing profile prompt properties prudent rc reasonable reboot reflect res rio rules run running runs script sensible server sites step switch sys sysname term terminal test tmp type upas user user's users using usr wsys newuser	8/newuser
 acceleration accommodate actualsize align aligned alignment allocates allows aperture appropriately arch ark200pv ark200pvhwgc attach bind bit bits black blank blanking blanks blanktime boundary bt485hwgc bugs byte cards chan chip chips clgd542x clgd542xhwgc clgd546x clgd546xhwgc closectl color combined compliant configuration configure configures consists control controller controllers ct65545 ct65545hwgc ctlr current cursor cyber938x cyber938xhwgc data default depth described dev device devvga.c disable disabled disables display displayed displays dpms drawing drawinit drawn driver echo enable enables encoded engine et4000 filling follow format full gc graphics hardware height higher hiqvideo hiqvideohwgc hsync hwaccel hwblank hwgc image implement inactivity includes indicate initialize inside larger level linear list mach64xx mach64xxhwgc map memory message mga2164w mga2164whwgc minutes mode monitors mouse moving neomagic neomagichwgc note openctl opens optional overlay packed palette palettedepth pan panning particular pc performed physical pixel pixels port portion precision properties provided reading recognize rectangle registers require resources returns rgb524hwgc s3hwgc screen screen's sent setting settings setup signals size software source src strings support supported sys t2r4 t2r4hwgc terminates timeout tvp3020hwgc tvp3026hwgc type unblanked valid value values vesa vga vgactl vgaovl vgaovlctl virtual vision864 vision964 vsync wide width writing written yuyv vga	3/vga
 acceleration actual added adding addpt advantage align aligned alignment allocages allocated allocator allocd allocmemimage allocmemimaged allocmemsubfont allocsubfont allows alpha analogues arc ascent attaching bad base basis bdata bit bitmap bits bounding box buf buffer bugs byte byteaddr bytes calculates calculations calling chan channel channels char chunks clients clipped clipping clipr clips cloadmemimage cmap color compact compressed congruent conservative consumed contains coordinate coords corners cover cp creadmemimage creating cs current data debugging defines depends depth dereference described descriptions descriptor destination determine dev differ directly display dr draw draw.h drawclip drawdebug drawing driver dst ellipse emdraw end0 end1 enum error exactly except explicit extra falpha fbytes fcmap fd fgrey file fillpoly fills flags fmt font fontchar format formats freememimage freememsubfont frees freesubfont frepl fresh fsimple gendraw getdefont getmemdefont global graphics grey hardware height hierarchy holds horizontally hwdraw identical image images imref include info initializes instance int integer integral involved iprint kernel layer length libc.h libmemdraw library loadmemimage machine malloc'd manipulate manipulated mask memarc memblack memdata memdraw memdraw.h memdrawparam memellipse memfillcolor memfillpoly memimage memimagedraw memimageinit memimageline memimagemove memimages memimagestring memlayer memlinebbox memlineendsize memopaque memory mempoly memsetchan memsubfont memsubfontwidth memtransparent memwhite method methods move moves mp nbuf nchan nil non note np obvious offset ones op openfont openmemsubfont operate operation origin output overridden param parameter parameters particular perform phi pictures pixel pixels pointed pointer pointers points poly pool precomputed print prints programs purpose radius readmemimage reads reasons rectangle rectangles rectangular ref referring region repl replace replicated representation request request's resident retrieves return returned returning returns routines rpcs satisfy scan screen serial similar similarly solid source sp sr src static storage store string stringsize strsubfontwidth strtochan struct structure structures stubs style styles subfont subsumes success sys systems tables takes thick translated type typedef u.h uchar ulong uncompressed unloadmemimage unusual updates upper user using utf values variable various void width wind wordaddr works writememimage writes yield memdraw	2/memdraw
 accented adm affected alphabetical arithmetic ascii assume attached bugs bytes capitalized character characters check choice cmd cmumbdf colon comments compare compared comparison comparisons conditions confused consisting dates decimal default defines diagnostics differ digits dir directory discovered disorder e.g earlier ending entire equal etc except exits exponents external feb fields file files flag flags fold folded format further generated global globally grep hopelessly ignore independently input inputs inrwt instance internally invalid jan key keys leading letters lexicographic lines list longer low lower mbdfginr meanings merge minus missing month months non notation null numeric onto option optional optionally options ordered ordering ordinal origin original output outside override participate phone pid plus pos1 pos2 posix precedes predictable print provincial range representative restricts reverse rules runes sed separating sign significant skip sort sort.c sorted sorts source space spaces spellings src stable standard status string strings style sub suppress sys tab tabs tells temporary tmp trouble um umm uncapitalized understood uniq unique unless upper user users value various writes sort	1/sort
 accept accepted accepting added addition address addressed addresses addressing affected allow alone ampersand appearing append appended applies assume assumed automatic backslash backslashes backspace backward blank bounding browse buffer character characters cmd collected comma compatibility confirming consequence considered constructed copy correspond counting counts created cumulative current customarily decimal default defaults del delete deleted delimit described desired determined diagnostics differs digit digits direction discards discussed displayed dot double e.g earlier ed ed's ed.c ed.hup edit edited editing editor enclosed enclosing ends entire equivalent error errors everyone exact except execute executed exist existing expression expressions fail fd file filename files folded format forms forward generally global hangs hexadecimal inaccessible included indented indicated indicator initially input insert insufficient intermediate interrupt join legal letter level lines list literal lower maintain mark matched matches matching mean merely metacharacters minus missing mode modified moreover move moved multi necessary nested newline newlines non none notation nul occurrence occurrences omitted operates optional options ordinary output overflow overflows overwriting page pagesize parameters parentheses parenthesized perform permitted piping placement pln plus portion possibly precedes preceding prefixing presence print printed printing prints queries quit rc read readable reading recognized refers regard regexp regular remainder remembered replace replaced replacement reposition require requires resides resp respect restore resulting returns reverses rule sam saved search searching sed semicolon send sent shell shown sic sign signal simulates slashes source space specifies specify src standard stepping stop stopping string structure sub subexpression subexpressions substitute substituted substitution subtracted subtraction successful successor supports suppress synonym sys tab temporary terminal text th third time tmp transfer typed typically typing unambiguous unchanged unconditional unconditionally understand understood undo venerable versions wraps writable write writing written ed	1/ed
 accept accepted actively actually add added additional addmulti addr address addresses administers ah alg algorithm algorithms alive allocate allocated allow alters anded announce announced answer ape appends applies apply arbitrary arglist arp arrives ascii aspects assigned associate association assume automatically backlog bad based binary bind bit block broadcast bsd buffer bugs built byte bytes cache carry carrying catch character checked checksum chosen class clear client clone closing combination coming communication communications compared comparison compress configuration configured configuring congestion connect connected connection connections considered contains control controlled controls conversation copying count created cs ctl dat data datagram datagrams debug debugging decimal decrypted default defined delimiters delivered delivers dependent des_56_cbc describe describes descriptor destination details detected determined developed device dial difference digits directories directory disable disallow disappear disassociate discarded discarding dns doesn't dot dropped dst duplicate easy echo efficient emulation enable encapsulating encapsulation encoded encrypt encrypted encrypts ends entries entry eof eproto equals err error errors esp establish established establishes ether ethernet exceededs exec existing exists experimental explicitly expr failed fails failures favor features ff fields file files fills filter filters firewalls fit flags flush format formats formatted forwarded forwarding fragmentations fragments fs further future generally generating gre hangup hash header headers headers4 heavily hexadecimal higher hmac_md5_96 hmac_sha1_96 holding hop icmp identifier identifying ifc il ilmsg implement implementation implementing implements incoming independent indicate inferno ing initiate input integer intended interface interface's interfaces internet ip ip's ipaddress ipconfig ipifc ipmsg ipmux iproute iprouting ipsec ipselftab ipv4 ipv6 isn't items keepalive keepalives kernel key laddr lans leave length level libraries link list listen listens live locally log login longer longest looks loopback looped lost low lower lport lru mac mac's machine machines malformed mask match matches matching maximum mean media mediate medium merged message messages milliseconds missing mode monitoring mount mounted mtu multicast multiplex ndb needed net netdev network networks newly nexthop noheader non null numbered offsets ok older onto opened opening optional originated ospf outgoing output overridden overrides packet packets pair pairs parameter passively path payload pcc pending physical physically ping pkt plan points policy port portion ports ppp pptp preferred prefix prefixed prefixes prepare primarily procedure process programs proto protocol protocols provide provided provides proxy quenches queue queued queues raddr range rc4_128 read reading readipifc reads reassemble reassemblies reassembly reboot rebooted receive received receiving redirects rejected relation relations relatively relevant reliable reliably remmulti remote remove replace replacement replies report representing represents request requested requester requests reserves reset resolution responds restrict restricted resulting resume resumes retransmit retransmitted retransmitting return returned returns rfc route routed routes routing rport rudp rules run secret security segments semantics semicolon send sending sent server services shorter sic similar six size sockets source space spec specific specifies spi src stack stacks standard starts statistics stats status stream streams string strings struct structure subdirectories subdirectory subset successful support supported supports sys systems table tag tagged talking target tcp tcpmsg text time timed timeouts times timestamp timestamps tos total tp traditional transfer transfers transmission transmit transmitted treat tree ttl tunnel type typedef uchar udb udp udphdr udphdr4 udpmsg unacknowledged unanswered unbind unicast unit unix unknown unlike unordered unreachables unreliable unsuccessful unsued update updated updates usage user using value values version via wait whenever write writes writing written younger ip	3/ip
 accept accepts access affected appearance application attach automatically bar bind blanks block blocks bottom buffer button catenation cd character characters chdir choose clients closing cmd cons consctl constructed contains continue control controlled controlling controls convenient coordinates corner create created creation current cursor data dealing decimal default defined del deliver depth describing dev device digits directories directory disable display draw dx dx100 dy echo edge editing enable entire entries environment establish etc event except executed extra features file files fill finally font format formatted full fully generated generates geometry getwindow graphics hangup hangups height hi hidden hide hold holdoff holdon horizontal id idea identified identifies image initially inner input instance integers interpretation interrupt introduced invisible invocation item keyboard label lead leaves located location lower lp main maintains managing maxx maxy mediate mentioned menu menus message messages minus minx miny mnt mode modes mount mounted mouse move moved movements moves multiplexed multiplexes necessary neither newly nor noscroll notcurrent note notes obscuring opening operations option optional options outside parameters parent partially particular pid pipe placement places plain plumb possibly posts pressed print printed process processes programs properties provide q.v raster raw rawoff rawon rc re read reading receive receiving recipient recursively released reporting representing resize resized restore returns revert rio riosrv run running sam screen scroll scrolling section selected send server serves services shell sign similarly size sized snarf source space spaces specific specifier src srv standard string strings style subdirectory supplies supply syntax sys tag terminal text tmp totally turns unaware unchangeable uncompressed underlying unhide unique update upper user using usual variable variety version versions virtual visible wctl wdir whom width window window's windows winid working writable write writing written wsys rio	4/rio
 accept access actual address associate assumed attr attributes bell bugs clear client clients cmd comment comprises conform confusingly connecting connections contains cookie cookiefile cookiefs cookies data decides decimal default descriptor directory domain dot edited epoch exists expire expires explicitdomain explicitpath file files flag full header headers hget hostname http https included indication inferred intended ip it's labs.com lib lines manage manager manages mnt mounts mtpt netscape netscapestyle opening outlined pairs particular path pattern persistent post presented presenting profiles reading reads relationship remote representation request requests response rfc2109 save seconds section secure sent server servers serves sites source specification src srv standard style suffix sys textual time url urls user value values version web webcookies webcookies.c webfs write writing written www.bell www.research.bell yield webcookies	4/webcookies
 accept add allocate allocates allows arg array background backing backup basic belongs buf build built bytes clear client col color component compressed connects coordinate coordinates coords corner couple create created data defined definition deleted deletes delta display displayed dnofill doing draw draw.h drawing drawn dst due efficient entry establish expects extend fields fill flag fn format frees front frontmost fully geometry goes graphical graphics holds ia identical image images implement include initialized int interface internal interpretation iscompressed kernel layer layers leaving libc.h libmemlayer library loadmemimage location log logical losing main maintain management mask memdraw memdraw.h memimage memimagedraw memimageline memimages memlalloc memlayer memlayer.h memlayer.save memlayers memldelete memlexpose memlfree memlhide memline memlnorefresh memload memlorigin memlsetrefresh memltofront memltofrontn memltorear memltorearn memory memscreen memunload method methods min modified mp nil non obscured op operation origin outside overlapping paint painting parts performed permitting phys physical picture pointer points portion portions predefined presented provide provided pulled pulls push r.min rear rearmost receives recorded rectangle recursively reducing refresh refreshed refreshfn refreshptr regardless repainting represent resident restore restores restoring routine routines save savvy screen screenr setting signatures similarly size smaller source sp specifies src stack store stringsize struct structure structures subdivide sys systems temporary type typedef u.h uchar ulong ultimately unaffected uncovered underlying unlinking unloadmemimage upper using valid versa versions vice visible void window window's windows memlayer	2/memlayer
 accept added admissible applied args array ascii assigned assignment assignments atof automatically base behave behavior brace bracket brackets bugs calling char character characters circumflex complete completion composed comprise comprising condition conflicting consumed contains control conversion converted count ctype current decimal defined defines described detailed determinable differing differs directive directives directly double due earlier ell ends eof error evaluated event except excess executed executes execution exhausted expected fails failure failures fewer fgetc file finally float floating fopen format formatted fprintf fscanf function's hexadecimal implementation inappropriate include includes increment indicated indicating input insufficient int integer interpretation introduced invalid isspace item items leading length libstdio list literal longest matched matches matching maximum newline non nonempty nor nul object objects occurs octal offending optional optionally ordinary permitted plan pointed pointer pointers prevented produced provided range read reading reads receive received receiving remain remains return returned returns routines scan scanf scanlist scanset sequences short sic signed similarly size skipped source space specification specifier specifiers specifies src sscanf stdin stdio.h steps stream string strtod strtol strtoul subject subsequence success suppressed suppressing suppression sys terminates type unavailability undefined unless unread unsigned using utf valid value vfscanf via void width written fscanf	2/fscanf
 accept addpt analogous array bit bytes cachechars char character characters component compute diagnostics directory display draw draw.h drawn dynamically encoded error extent files font fonts generate geometrical graphical graphics image include int lib libc.h libdraw loaded lower nul produce representing returns routines rune runes runestringnwidth runestringsize runestringwidth server size source src straightforward string stringnwidth strings stringsize stringwidth subfont sys u.h upper utf vector width stringsize	2/stringsize
 accept address addresses apply archive attach attached authentication blank block blocks box cache cached calling clears comma complicated concatenation config config.c configuration configures configuring connect constants contains cp creates data databases defaulting defined demountable described device device1 device1device2 device2 device3 devices directory disk doing drive drives dump effectively enable enters erased establish exits explicit external file files filsys formed fourth fresh fs fsconfig gateway's gets id identifies inclusive initialization initialize initializes initializing interface interleave interleaved interleaving ip ipaddr ipauth ipgw ipmask ipsntp juke jukebox ken kgbsun kremvax label leaving length letter list magnetic main mask messages missing mkfs mode necessary network non null overwrites owner parenthesize partition partitioned perform periods plan platters port previously proper pseudo quarter quarters ram read ream reboot record recorded recover recreate relevant replaced represent represents request required resetting rest root run running scsi server server's size smallest sntp source space specifier specifies specify src stat stored string subnet syntax sys target targets text textual therefore third thompson times typically unit unless valid values various volatile whatever wise worm write written wstat fsconfig	8/fsconfig
 accept address arriving assigned bind boundaries broadcast bytes card cards clone closed connect connection connections constant contains control copies copy ctl data decimal demultiplexed destination devether.c device directory distinct enables ether ethernet extra ff:ff:ff:ff:ff:ff file files header identifying ifstats incoming independent index inserted integer interface interfaces machine net network opening options packet packets permitting plan9.ini promiscuous read reading reads receive receives remains returns send sent source specific src statistics stats status string subdirectories supply sys terminate type types unique value wavelan write writing written ether	3/ether
 accept ansi atof atoi atol atoll base behave bugs calling char character characters charstod constant continuation contrary convert converted decimal described diagnostics digit digits double ends errstr escapes floating fscanf gets hexadecimal include indicators input int integer integral interpret interpretable interprets leading legal letters libc libc.h manner necessary nptr octal optional optionally pointed port recognize recognizes representation returned routines rptr scan sign signed similarly source spaces specification src stream string strtod strtol strtoll strtoul strtoull style successive suffixed sys tabs terminates text therefore type u.h ulong understood unrecognized updated value vlong void atof	2/atof
 accepted access accessed actual adjacent align aligned aligns allocate alpha ambiguities angles application arc arrow ascent associate association attach background backing bgid bglong bgshort binary bind bit bits blank blending blue bottom bp bplong bpshort brackets buf buffer bugs byte bytes cache cacheid caches calculations calpha catenation cblue cells center centered cgreen cgrey chan channel channels character characters cignore client clipped clipping clipr closed cmap color colormap combine common complementary compressed conceptually confined congruent connection connects consists constants contains control coordinate coordinates corner correctly correspond corresponds count cred ctl current data debugging debugon decimal defined definitions degree deleted dependent described describing descriptor details detected dev devdraw.c device diagnostics dictated dimensions directory disable disc discussion display displays distance distinction dp draw draw.h drawing drawn draws dst dstid dstr ellipse enable end0 end1 endings ends entries entry equivalent erroneous error errors errstr exist facilities failure fetched fields file files fill filled fillid filling fills flush font fontid fonts format formatted freed fully further graphics green highest horizontal id identified identifier identifiers ignore ignoring image image's imageid images immutable implementation include independent index indices initially inside insufficient integer integers interface interior internal intersecting introduce involving joining joins length letter level libmemdraw lines list load log logical low lowest macros maintain maintaining map mask maskid maskp max max.x max.y message messages method min min.x min.y mishandled moved multibyte necessary needs negative nibble non note object occur odd opening operator outlining output outside overrides owned parameter parameters particular phi pixel pixels points polygon polygon's port portions private process processes protocol provides providing publicscreen purposes q.v r.min read reading recovered rectangle rectangles red refbackup reference refmesg refnone refresh refreshed remaining repainted repl replace replicate report reporting requests resolves resources response retrieve return returns rounded rule scr screen screenid screens sector segments self semiaxes send sent separately series server serves settings signed simultaneously smooth soft source sp space spacing specifically specifies specify specifying square src srcid srcp stack storage store string strings subfonts sys text thick thickness translated transmitted treat type u.h uchar ulong uncompressed uncovered undefined upper ushort using values version vertical via void whatever wide width wind winding window windows write writing written yields draw	3/draw
 accepted accessed accesses address addresses affect allocated allow amount args assembled attached attempt attempts auth await base based bind bit block boundary bss bytes can't carefully cd character characters clear cleared closefiles completes cons contains contiguous control count counter cputime created crosses ctl current dat.h data debugger debugging decimal delivered delivery dependent descriptor descriptors device devproc.c directly directories directory display doing don't draw ending enter equal errlen error etc except exec executed execution exists exited exiting exits explicitly extant fd fields file files flags floating fork format fpregs frequency getfields gleaned hang hexadecimal higher hold identifies identifying image implementing impossible inaccessible inherit inherited instruction integer interrupt iounit justified kernel kill kregs letter level lines list lists live living lowered mach machine main meant mem mem.h memory message messages mode multilevel multiprocess names namespace newns nohang noswap note noteid notepg notify ns nul numbered offset oldest ones opened owned parent's particular pending permitted pids piece plan port posted prevent pri priorities priority private proc process process's processes processor prof profile profiling program's property provided ps pseudonym putting qid quoted rc read rearranged receive records recover reference registers regs renamed representation representations representing require reserved resettable resume resumed retrieve return returning rfnoteg run running rw sampling saved scheduler scheduling segment segments sensitive serves similar similarly six source space sparingly src stack startstop status stop stopped string strings structure subsequently suitable suspend swap swapped symbol sys table target text textual time tokenize tprof transferred twelve type unit units unless user valid virtual wait waitstop wire working write writes writing written proc	3/proc
 accepted accessed addressing ansi applied applies ata attempts audio automatically backwards basic bench betrays blank blanking block blocks brief bugs byte bytes capacity cd cdload cdpause cdplay cdresume cdstatus cdstop cdunload changer check checks class classes cmd code complete completion comprise computer concerning condition constants control coverage current data default descriptions destination details determine dev device devices directory disk disks documents drive driver effort einit eject ejection endl engineering entire erase error estatus exception executed exercising file filemark filemarks files fixed format forwards further global groups host howmany identifies incomplete ingest initialize input inquiry integer intended interactive interface internal internally interpretation invert investigate issued issues jukebox lba length lengths level limited limits load logical low luns maintains manipulate manipulates manual mechanism media medium message method missing mmc mmove mode modeselect modeselect6 modesense modesense6 move multimedia nbytes needed negative note notion odd offset ok opened optical option options origins page pages parameters particular partition pause performs pi plain play playback pma positioned positions powered printed prints probe processing product provides publications purpose quoted raw rblimits rc rdiscinfo read reads ready recoded reference regardless remaining report reports reqsense request requests respond response results resume retrieves returned rewind rezero rotating rough rtoc rtrackinfo rudimentary rw scsi scuzz sd sdc0 sddev sdxx seek seeking select ses session shuffling size slot smc source space spacing specific specification specifies specify spelled spelling spin src standard starts status stop style subset successful supported supports suppresses synonyms sys table tables tape tapes target targets test time toc track transferred transfers transport type types typically unit units unless unload values variable version whence write writes writing wtrack www.t10.org x3t9.2 scuzz	8/scuzz
 accepted ahead apr april attempt calendar calendar.c cmd comparisons cron current date dates default digits events file files flag formats forms friday insensitive lib lines listed mailed match monday non output performs personal print printed processing reads recognized repeatable saturday source space src standard sys thereof today's tomorrow's upcoming user usr writes calendar	1/calendar
 accepted algorithm auth authenticate authentication batteries binary box bugs button bytes calculator california carried challenge clumsy compared compares computed confirm confused connections consists copy corresponds current decimal delicate des described digit digital digits display displays easily ed eight encrypt encrypted encryption ent enter entered entering ep fill follow foreign generated greater hexadecimal instructions internally kept key letters looks lose machine match memory mistake mountain netcrypt numerical octal pathways performs pin plain plan pocket press pressing print printed prints procedure prompt prompts protected ranging recommended remote removed reprogram requires reset respond response return retyping routine securenet server stored string succession terminal text time times twice type unauthorized unix user using view wear wrong securenet	8/securenet
 accepting adm auth behavior boot booting class cmd console correspond cpu cpurc cputype ctm decide env environment establishes incoming init init.c initialize initializes interactive invoked machine machine's namespace newns objtype option options password profile rc regardless requires run runs server shell source space src starts sys terminal termrc timezone user user's value variable variables init	8/init
 accepts access accessed accessing acme actions actually addr address addressed addresses affect analogous appended applied automatic bar behave bit bitwise blank bound built button buttons byte cancel character characters chorded chosen clean cleartag cmd colon compatibility complete compound conjunction cons consctl console context control controlling count created creates ctl current cut data dealing decimal decimally default del delete deleted described describing determined dev diagnostic dir directories directory dirty discovered display distinct dot dump dumpdir echo elided environment equivalent errors etc evaluated event exactly examine except expansion expected explicitly expression extra fields file files final fixed fixfont flag follow font format formatted fourth fully guarantee holding holds id identical ids immediate included index indicated indicating indirectly individually input inserted interactive interface interpret keyboard label labeled limit lines literal loading location mark marking mentioned message messages mnt modification modified mount mounted mouse necessary needed newline newlines nomark non noscroll null numbered occur offset offsets omitted opened operations opposite optional origin originated output partial particular paste permit pixels plain plus post q.v qualified random read reader reading recently recognized recover recreate redirected regular related relevant remove replaces reported reporting restricts returned returning returns rio run runes running scroll scrolling searches sees selected selection sent sequentially serves services source specific src standard starts string style subdirectory supply sys tag terminal text textual third type underlying understood undo undone unique unlike unwritable user user's usual value varfont variety versions vertical virtual visible wherein width win window window's windows writable write writes writing written wsys zeroxed acme	4/acme
 accepts access accessed baud bind bits block break byte clear communication configures control ctl cts data dev device devices devuart.c directory disable dtr eia eia0 eia0ctl eia0status eia1 eia1ctl eia1status enable fifo file files format input lasting legal level milliseconds modem non obey odd parity port ports rate read reads representation rts send serial serve signal source src status stop sys textual uart values uart	3/uart
 accepts account accounts address addresses allow attempt bind bits block blocked blocking blocks category check cidr classification closes cmd configuration contains control corresponds creates ctl debug debugging default delay deny described determine dial direct directories directory dirfstat entries entry expression expressions fail falls file files formats fstat gre i.e imap4d instance ip ipserv level lib list mail mapping match matched matches matching mountpoint mounts multimegabyte names network nodebug opening ournet output parse particular persistent pop3 process range ranges ratfs ratification ratify read regular reload remaining represent representation represents reread rereads scanmail semantics sends serves similar smtpd smtpd.conf someone's source spam src starts stat string strings succeed succeeds sufficient sys trusted try turns typically whenever write ratfs	4/ratfs
 accepts acrobat's adobe bin bitmap cases competitive convert dcompatibilitylevel default direct distiller dlanguagelevel embedded file generation ghostscript gs hints input invoking level neither nor option options output page pdf pdf2ps postscript produces ps2pdf rc read similarly smaller source standard topostscript translation unaltered version write written ps2pdf	1/ps2pdf
 accepts alarm algorithm allows alone alphanumeric alter ampersands apid appends applied arg artificial assigned assignment assignments associative asynchronously automatically backquote backslash becomes bin binaries binary bind binds bitwise blank blanks brace braces brackets bugs build built builtin caret carets cases cc cd cdpath character characters check circumstances class clear closed closing cmd cmp command's compare complemented complete completed completion component components composed compound comprising concatenated concatenates concatenation condition connected connects construction construction's constructions constructs contains continued control copy cpu creates ctrl current debugging decorated default defines definition definitions delete deleted depends described descriptor descriptors dev device diagnostic dir directories directory directs discouraged disguised distributive document documents doesn't doing don't duff dup duration echo effective effects enclosed ens entirely entry env environment eof equal equivalent eval everybody examined except exec executable execute executed executes executing execution exists exit exits explicitly favor fd fd0 fd1 file files finish flag flags floating fn follow fork full gets grouping handle hangup hi highest i.e id ifs implied indirection initialization initialized inline input insert inserted instance interactively intermediate internal internally interrupt interrupts interspersed intervening inverted invocation it's junk junk.c keyword keywords language letters level levels lexically lib linear lines list lists lowest machine's manner marker marks match matched matches matching meanings mentioned message names needed neither nested newline nneesffm non none nor note notes notify null occurs omitted op opened operand operands operations operator option origin output outputs outstanding pair pairs pairwise parentheses parenthesis parenthesized path pathname pattern patterns permission pid pipe pipelines plan precedence preceding prefixed prefixing previously print printed priorities process process's processes profile prompt prompted puts qualifying questionable quits quotation quote quoted quotes rc rc's read reading reads receives receiving recognizes recursive redirected redirection redirections redirects referring remain remainder removes repeatedly replaced replaces requested required requires rescinded restored returns rfcenvg rfcfdg rfcnameg rfenvg rffdg rfnameg rfnomnt rfnoteg rfork run runs saved saving script scripts search searched semicolons sends sent separators serve shell shift sigalrm sigexit sigfpe sighup sigint sign signal simplest slash source space spaces splitting square src srdiilxepvv stand standard standing stands started starts stat status stem stem.c stop stored stream string strings structure subject subjected subscript subscripts subsequently subshell substituted substitution substitutions successful suggest suitable surrounded switch syntax sys tab tabs terminal test text th therefore tighter time tmp tom trap type typed typing unary underscore unless unquoted user using usual utility valid value values variable variable's variables wait waited what's whatever whatis whenever writing yields rc	1/rc
 accepts anchors attempt base brackets bugs cmd copies default dimensional displaying document entries fields file files filling flag flags fmt fmt.c formatted formatters geometry html htmlfmt idempotent image indent indenting input inserted leaves length lines option options output performs plain preserved print render similar source space spaces square src standard suppresses synonym sys table tables tags text treats unchanged url urls fmt	1/fmt
 access accessed accidental accross acts addition address aid allocated appending application applications approach archival archive arena arenas auxiliary backup block block's blockcachesize blocks buffering buildindex built bytes cache cachesize caching check checkarenas checkindex client clients cmd coalesced config configuration connections consists consumption contained contains copies copying cost creating data debugging default defaults destruction device disk disks distribution divided dorward duplicate dw enable enforces enumeration error exception extract facilitate file files fingerprint fingerprints fix fmtarenas fmtindex fmtisect format fs functionality future generally gigabytes hash http httpaddress icachesize identifier implementation improve improved include included incoming increase index indicate initialized integrity intended internal killing kilobytes limited listens location locations log maintaining malicious mapping media megabytes memory mounted necessary network non note operations option optionally options output partitions performance plan policy preventing produce protection protocol provides quinlan raid random raw rdarena read rebuild recommended reducing regenerated release removable replacement require returning robustness root rudimentary run sean sections self server serves sha1 simplifying size sized sizes source specifies spread spreading src standard statistics stats status storage stored success summary sys tcp ties typically undocumented units url using utilities vac vacfs various venti venti's venti.conf ventiaddress via worm write writes written xindex xml venti	8/venti
 access accessed account added addition aid arbitrary ata attach attached bind buggy bugs bytes capabilities capability cat cd closed cmd640 config configuration contained contains controller controllers convention counts created ctl cu cylinder data default defined deleted delpart dependent detected dev device device's devices devsd.c diagnostic direct direction directory disable disabled disc discs dma dmactl dos driver e.g echo enable enabled enforced etc execute exist fdisk file files fit follow geometry hc identify individually inquiry instance integer interface kenwood legacy level limit low luns maintenance manipulate manufacturer maximum media model multi naming non opened operating options partition partitions pci pi plan port prefixed prep process processing programs purposes raw read reading remainder remaining removable rest retrieve returned returns rom rwm scan scsi scuzz sd sd00 sdc0 sdd0 seconds sector sectors serves shows size source specifier split src ssdd0 standby starts status steps storage subdirectory supported supports swap sys systems text textual timer transfer type typically ucr unit units using via write writing sd	3/sd
 access accessed address char current eleven file generated getpid id include letter letters libc libc.h mktemp mktemp.c port process replaced replaces returns source src sys template tried u.h unique mktemp	2/mktemp
 access accessed attach bind broken bugs bytes channel communication communications connect connection converted data device devmnt.c directly distinct driver drivers error errors file files identify illegal involving issues kernel maximum message messages mnt mount mounting multiplexed multiplexes oriented port portion procedure process processes protocol provided read remote reply return returned returns separately served server servers session short size source space src string sys transferred translated translates transmitted user users validate various write mnt	3/mnt
 access accessible account adm adnptn adp allow allows anonymous assume authenticate authenticated authentication authenticator authsrv bin box bsd challenge character clear client cmd codes completing connection connections contained contains control cram created cs daemons debugging default defaults defines direction disallowed domain don't echoing enabled encrypt encrypted encrypting enforce env error examined execs executes exist expect file files ftpd ftpd.c ftpfs handheld handshake imap's imap.subscribed imap4d imap4rev1 imp imply inbox incoming initially input internet ip ipserv lib list listen locally log login logs machines mail mailbox mailboxes md5 namepace namespace namespace.ftp namespace.noworld namespace.world ndb netkey network non none noworld nu option options originate output passwd password permit plan policy print printed programs protocol provided provides queried rc remote require requires response returning rexexec rexexec.c rlogind rlogind.c rooted runs scripts securenet server server's servers shadow site source src ssl standard started store subscribed subtree support sys sysname telnet telnetd telnetd.c transfer trusted types user user's username users using usr via write ipserv	8/ipserv
 access accessible accumulate acquire activates acts adding affect afterwards allow allows alphanumeric arg arranged arrow asynchronous asynchronously attached automatically background bar behave behaves behavior beyond bin bind bit bitsyload blanks block blocks blue border borders bound brings bs buffer bugs button calling cases cd character characters choice circumstances claimed clear click clicking cmd collect color common communicating compiler's complete computation computing cons consctl console construct contains contiguous continuous continuously control controlling controls coordinates copies corner cpu create created creates cross current cursor cursor's cut dark default define del delete deleted deletes deleting delimited delimiter deliver delivered described determines dev diagnostic diagonally dir directly directories directory discussed display displays distinct document double dragging draw dx dy echoed edge edit edited editing editor entry environment eot eots erases error esc established establishes etb events eventually exactly except feature file files final finishes font forestall forward fragment frame front gathered generated geometry gets graphics gray gunsight hairline hangup happen hence hidden hide hold holding holds honor identifying imported imports indicate indicated indicates indication initializes initially input inside instance interactive interpretation interpreting interprets interrupt intervening item jumps kbdcmd key keyboard keys label layers lib limitation lines location mail maintained maintaining maintains manages manipulating matched maxx maxy measures mentioned menu menus messages minx miny missing mnt mode mount mouse mousing move moved moves multi nak names newline newlines newly non nonalphanumeric note notify null occasionally occur opening operating operation operations opposite option optional ordinary output overlapping pair partially particular paste pasting pending pid pipe pixels placement places plumb plumber plumbing pointing points portion possibly press pressed pressing prints process processes programs proof properties provide provided prudent punctuation puts putting raster raw rc reaches read reading reads real rearranged rectangle redirected refrains released releasing removes replace replaces request resize responsibility restore return reversing rio riowctl ruler run running runs sam screen script scroll scrolling scrolls section selected selection selects send sends sent served server serves services shell shows simplify size sizes snarf sometimes source space src srv standard starts startup stored string successfully supplying suppresses sweep sweeping sys systems takes terminal terminal's text therefore time toggles total treating turns type typed typical typically typing underlying unioned units unlike unread upper user using usual value variable variety vertical vertically view visible wctl whereupon window window's windows wloc working written wsys rio	1/rio
 access accessible address aliasmail allow ap apop assume authenticate authenticated authenticating authentication box certificate challenge clear cmd connection connections contained contains cram create created cs debugfile debugging default defaults details disallowed domain enabled encrypted enforce env examined faces file files filter imap's imap.subscribed imap4d imap4rev1 imp inbox initially ip keyfs list login mail mailbox mailboxes marshal md5 mlmgr ndb nedmail non none option options output password passwords peeraddr policy pop3 protocol provided provides qer queried ratfs ratify read response rewrite rooted running secret securenet send server server's servername servers sessions shadow site smtp smtpdomain source src ssl subscribed sys sysname tls tlscertfile trusted upas upasfs user user's username using via write pop3	8/pop3
 access accessible authenticate bind channel client clients cmd communication create data debugging default descriptors dir enabling file files flag groups implementation implements initially interface keeping level machine mainly memory mounting mountpoint mounts network performance pipe post precious private proc process provide ramfs ramfs.c remote rooted server simplistic source src srv starts sys tells temporary tmp tree user write ramfs	4/ramfs
 access account acme ad address addresses affect aliasmail altering announcements apop apops apoptls atomically attachment attributes authentication bcc becomes biff biffing bnp box bytes cc challenge choose cleartext closed cmd connect connects contains content conversation ctl date dead.letter default delegated delete deleted deleting delivery described digest direct directories directory disappeared disposition don't encrypted envelope es essentially exclusion exit faces factotum file filename files filetype filter final fs full generates gleaned groups header headers host id imap imaps imaptls info initially initiating inline inreplyto intended interprets item key l.mbox l.reading length level lines lists lock mail mailbox mailboxes mailfs mailtype marshal mbox mboxname mean message messages mime mimeheader minus mlmgr mntpoint mount mutual names nauseam nedmail nice none numbered omitted opens options output overridden parse password path plaintext plumb plumber plumbing pop pops poptls port presents printed profile proto protocol protocols provide qer raw rawbody rawheader reader readers reads received recipient recurse references removed renumbered replies reply replyto representing reread response rewrite rfc822 rio seemail send sender senders sends server sha1 source space specifies src srv srvname standard standards stands starts starttls stls structure style subject summary supported sys takes telnetting that's there's time tls type undecoded unixheader unless upas upasfs updated user username using whenever window written upasfs	4/upasfs
 access account add administration alice ascii attach attribute attributes automates aux avoid barney baud bignose bin bind bit bob bootes bootesctl boris broadcast broadcasts bugs carol channel client clients clog clog.c closes cmd complete computer con connect connected console consoledb consolefs consolefs.c consoles controlled cronly ctl database default defined detected dev device directory dirty ease edited eia205 enter entries equivalent excessive file files format fornax fornaxctl gid gid's groups holds identify import inadvertently installation interfering lets level lib lines locally log logging ls machine machines member message mnt mntpt mount mounts names ndb newlines notification opened opens output pair pairs permissions pipe posts prefixed presents procedure rate rc read readers reads remote represents restart returns running script sent serial server simultaneously source specifies speed src srv support sys ted therefore time typed typing uid uid's user users using value values vlad whenever writes consolefs	4/consolefs
 access accounts addition address adm administrative allows apop appends asks auth auth.srv authenticated authentication authsrv biographical box challenge changeuser chosen cmd connect connection conversation converts convkeys convkeys2 cram database databases decrypt default department described dev disable displays domain e.g easy email enable encryption encrypts entered everything exec's executes file files forces foreign format fs guard.srv guess handles holding host http httppasswords id il imap incoming input install installed installs key keyfile keyfs keys keys.who lib list login machine maintain manipulates match microsoft namespace neither netkey netkeys.who network non np option output owner password passwords performed plan pop3 port printnetkey prints prompt prompts protocol protocols ram rc re realms rekeying release requesting requests response responses rfc1939 rfc2195 run script scripts secret securenet served server server's servers shell similar source sponsor src standard started status stored stores sys ticket twice unix user user's users using volatile vpn wants whenever wrkey auth	8/auth
 access accurate allows auth behaves bind boot clock clocks cons dev device devices devrtc.c file key machine's maintained necessarily neither non nvram permission provides ram reads real rtc server source src supports sys time volatile rtc	3/rtc
 access acid acme active adhere adm administration alias alpha appearance applications architecture arm assemble auth authentication aux auxiliary behave bin binaries bindings bins bit bitmap boot bootstrap bootstrapping box channel cmd code collecting collections communication communications compile compiled composed configures connection connections cons console conventional conventions copy cpu cputype created cron cs ctime current data database databases debugging default defined dependent describing descriptors dev device devices directories directory display dist distribution's dns doc documentation documents domain draw dup easily eastern electronic env environment est.edt establish establishes etc executable executables exhaustive factotum fd file files floppy font formed fs generally guide hershey hierarchy holders holding holds il imported include independent init initialization installation intel interface intro ip isomorphic kernel keys kremvax level lib libraries list load log machine macros mail main mammals manual mips mk mkfile mnt modified modules mount mounted mounts multiplexed namespace ndb net netkeys network networking newns none object objtype operating overriding page parser parts pieces plan points prefixes private proc process processes profile programs proper protocol provides pseudonyms raster rc rcmain registry related remote reside rio root run securenet selected server servers serves services serving shell simulations sky software source sources space sparc specific src srv standard starts startup structure subdirectories supported sys systems tables tcp term terminal's terminals time timezone tmp tools traversal traversing trees troff udp union unioned unwritable user's users variables various vector version window wsys yacc yaccpar zone namespace	4/namespace
 access acname add addition address addresses allows ask authenticating authentication baud believe bytes chap chat chatfile client cmd communicate communicates communications compression concentrator configuration connection connections contains control conversation cpscdfu debugging default dev device dial differences dir directory disallow discovery don't drop e.g encapsulate encrypted eof error ether0 etherdir ethernet except expected file forth fraction framing gre hdlc header id initiates input inside insist interface internet invokes ip it's lack lines maximum missing mode modem modemcmd mounted ms mtu ndb necessary net netmntpt ok option optional options output packet packets pass porotcol ppp pppnetmntpt pppnetmtpt pppoe pppoe.c pptp pptpd pptpd.c primary protocol rate receive received remote response route run secret send sent serial server shuttle size source specifies specify src srvname stack standard stream string supplies supply support supports sys takes tcp tcpdir terminate testing transfer transmitted tries tunnel tunneled type unit user username using via wants window write ppp	8/ppp
 access acquire afid aname aqid attach auth authenticate authentication authsrv bind boots client complete connection contains defined defining definition described desired device devices directory doing entry error establish established evaluates execute fauth fcall.h fid file fresh generated generates granting idea identifies intro introduction kernel knows machine message messages mount nofid pipe points presented previously protocol protocol's qid qtauth rattach rauth read remote requested require required rerror returned returns root select server server's serves size specifies tag tattach tauth transaction tree type u32int uname uninitialized user using usual validate validated version wish write written attach	5/attach
 access actions actual addition affecting altered anyone append atime attach attempt attempted attempts attributes avoid bit bits break bugs byte bytes claims clients committed conditions consider consistency contains content convd2m conventional convert convm2d count create current data datum decide defined deny described dev devices dir directories directory dmappend dmdir dmexcl don't draws easy echoed encoding endian entries entry epoch error establishing etc exactly except exclusive existing explicit extended fails fcall fid fields file file's files flags formatted fsconfig fstat further fwstat generated gid gmt groups guarantee happen holding identification identified illegal implement independent inquire inquires integers integral interpret intro jan kernel laid leader length limited lock machine maximum mean measured member message messages minutes mode modification modified modifying mtime muid names non none note offset otrunc owner parent parse particular path permission permissions plain points properties providing qid.path qid.type qid.vers read reasonable reasons recent recently records reflects reject relaxed remove reply representing request requires returned root routines rstat rwstat seconds sent server server's servers significant similarly size stable stat status storage strings structure succeeds successful tag text time timeout total touch transaction trigger truncation tstat twice twstat type uid unique unsigned unused user users value values variable vector version walk whenever write writes wstat yields stat	5/stat
 access actions address addresses allow answer answering architecture associate attribute attributes auth authentication backup boot booted bootf booting bootp clients cmd comes common configuration contains coordinate correctly database debugging default dhcp dhcpd directory directs dns dom domain don't dr dynamic entry etherdev ethernet everything exception exist exists extra fails file files fs gateway global hex homedir honored identifier inclusive internet ip ipgw ipinfo ipmask kernel lease lib list listed log looks machine mail maintains mask mdsnp minimum mode mounted mute names ndb net netbios netmtpt network non none ntp obtain octet options originating output pairs particular performs permission piece plan pop3 pptp precedence print programs protocol protocols proxy rarpd read readable record reply request requester requesting requests resolution responds restricts return reverse rooted run runs seconds secs served server servers sleep smtp source sparc specifically specify src stack standard static subnet subnetwork suns support supports sys systems targeted tftpd time transfer transfers translating user using value web wide wins www xxxxxxxx xxxxxxxx.sunyy yy dhcpd	8/dhcpd
 access actions appended approach assumed bugs bytes chan channel char character characters closekeyboard closes combination complete connection cons consfd control ctl ctlfd ctlkeyboard delivers descriptors dev device draw driven environment event file frees graphics include initkeyboard int interface kc keyboard keyboard.h keyboardct keyboardctl keyboardctl.c keys kills lesser libc.h libdraw library message mode mouse msg multi naming nil opens passing pid proc processes programs raw read regular report returns rune runes sent shift slave source src string struct structure sys thread thread.h threaded threads time typedef typically u.h void wish writes keyboard	2/keyboard
 access active acts bus bytes cmd configuration configures configuring daemon debug device devices file flags hubs inactive infrastructure manages message monitors plugged polls ports print provides pulled received recognizes sent serial source src status switched sys unconfiguring universal usb usbd verbose usbd	4/usbd
 access activities actual approach array atomouse backing behaves bit bits blocking buffered button buttons cancels cfd chan channel char closemouse closes connected control create creates creating cursor cursor.h cursorswitch data default defined described descriptors dev device dimensions directly discarded display displayed draw draw.h drawgetrect drawn driven emenuhit environment erase event exceptions file flushimage format frees gen getrect getwindow graphics image include initdraw initmouse int interface item keyboard kills lasthit libc.h libdraw library lmr maintain manner mc mechanism menu menuhit message messages mfd millisecond motion mouse mouse.h mousectl mousectl.c mousectl.resizec moves moveto msec multi namesake naming nil null parallel parameter passing permitting pid press pressed proc processes programs progress provides pt rc read readmouse receipt reconnect recorded records rectangle red released removed reported representing requests resizec resized restoring returned returns rio routine running sam says scr screen sent setcursor showing slave source specifies spelled src stamp store struct structure succeeds successive sweep swept sys tells thread thread.h threaded threads time type typedef typically u.h ulong updates user using value variable visible void window wish writing xy mouse	2/mouse
 access activity allows anonymous append apply approximately attempt automatically avoid bind bugs cache cached caches cases clue cmd connecting connection conventionally correspond default desired determined dials directories directory doesn't don't dqn entry equivalent export.lcs.mit.edu ext extension fail fall feel file files finally forces format ftp ftpfs gateway guest handle hangup heuristics implement import include interaction interpret interpretation ip issue length links list listings ls machine machines mean meant messages metadata minutes mode mount mountpoint mounts mvs names necessary net netware nlst nop notices occur offer operating option options os password plan9 port prompt protocol provide ps quiescent rare rarely read remote remoteroot removing request required resorts response retrieve retrieved return root seconds seeing send server servers sometimes source specify specifying src startup steer succeed sun switches symbolic synthetic sys syst systems tar tcp terminate tops transfer try tso types unix unmount user user's using valid visible vm vms walking windows_nt wordy writing you'll yourmachine yourname ftpfs	4/ftpfs
 access add addr address addresses adds allows answer auth authentication aux background baud bdr bin bind bindings binds bound broadcasts byte class cmd comcast company's configuration configure configured configures configuring confusing connected connection correct cputype creates cs debug debugging default determine determines device dhcp directly directs dns doesn't don't entry equivalent ether ether0 ether1 ethernet except exits external file files firewall forever fork forked gateway gateways gathers gbe generic hostname il inside interface internal internet interpret ip ipconfig ipconfig.c jumbo keeps kernel lease lib list listen listens lucent mask maximum mounted mtu ndb nddrg net net.alt netmtpt network networks note ntp obtain obtained onto option options outside packet packets parameters performed plan plan9_ ppp prevents primary process protected protocol rate rc remote remove renew replies request requested requests resolver respond rip rip.c route routing run runs seconds serial server servers service.alt size source specific src stack stream sx sys table tables tcp trying type unbind unless unspecified updates value vendor verb verbs via voluminous write written ipconfig	8/ipconfig
 access add afile alter append ar ar.c architecture archive assumptions avoids behavior bugs character characters checking cmd combined concatenated constituent constituents cr create current date dates delete deleted directory discards drqtpmx duplicates elsewhere etc except exist explicitly extract extracted file files front gid groups id's inserts instance invalid key lib.a library list listed listing loaders ls main maintainer maintains meanings mentioned missing mode modification modified modifiers move moved names neither numeric object option optional optionally places plan posname precede predates preserve print purpose quadratic quick rebuilt replace required showing similar size somewhat source src suppresses sys table temporaries temporary times tmp twice uid update user valid verbose vuaibclo vxxxx warning whenever ar	1/ar
 access add alphabetically append behavior bin bits bytes character characters cmd code contains current default devices directory disables dlmnpqrstufq dlmnqrstufq don't e.g entry exclusive executable execute fields file files final flag format granted indicate indicated instance intro kbytes latest lc letter list listed listing lists ls ls.c mc mean mode modification modified names none option options output owner path permission permissions pipes plain print printed qid quoted rc read readable reader recently refers repeats requested reverse search size sort sorted source src stat subdevice sys time type user version writable write writer ls	1/ls
 access adding allocate blocks bugs byte channel check checked checking choices cmd connection consistency create data deciding default descriptor dev disk edition efficient erasing faster file files fit fourth fs hierarchical holding inconsistent intro kfs kfs.local kfscmd larger level list maintains megabytes memory messages mkfs mount nbuf nlocal offers options packet perm permission permissions placing plan post prep protocol q.v rb4096 rc read ream reamed rebuilding sd sdc0 serve server serves smaller sniffing source space src srv sys terminal third user versions whichever write kfs	4/kfs
 access addition addns adm afd ai allocated amount amount_getkey aname apop applies arg args attribute auth auth.h auth_allocrpc auth_challenge auth_chuid auth_freeai auth_freechal auth_freerpc auth_getinfo auth_getkey auth_getuserpasswd auth_proxy auth_respond auth_response auth_rpc auth_userpasswd auth_userpassword authenticate authenticated authenticating authentication authentications authgetkey authinfo authrpc authsrv bind build builds byte caller calling cap capability chal challenge chalstate chalstate.nresp chap char client communicating concert connection contains conversation converts copies cram create cuid current default definition described desired device diagnostics dom encryption environment erases error errstr executes expect factotum fails fauth_proxy fd fields file flag fmt format freed frees ftpd generated generic getkey global hashing holds id ids implementation include int interface interprets invoke invoking kept key keys length lib libauth libc.h library list login maxchlen maxnamelen message mnt mount mounted namespace nchal necessary newns nil nnamespace noworld nresp ns nsecret nsfile null nuser obtained opens p9cr pair params passes passwd password perform performs permitted phase pointer posess primary print process prompting proper proto protocol protocols provide provided provides proxies queries reading reads recreates remote required requires resp response rest retrieves return returned returns role routine routines rpc sandboxed scratch secret sent server shared similary source space specify specifying sprint src storage string struct structure successful suid supply sys takes telnetd template typedef u.h uchar uint unlike user userbuf userinchal userpasswd users using variable variables verb verifies vnc void whenever wiping writing xxx yields auth	2/auth
 access addr address adjacent alternate application architecture architectures assume automatic beieee80ftos beieeedftos beieeesftos beyond bio.h bit bits buf buffer bytes calculate calculated cany cases caused cdata char character characters cisc ciscframe cisctrace code combining common compiler conforming consistent contained contains context convert converted converts count counter counterparts crackhdr ctext current data debugger defined defining described describing desired diagnostics directly double endian entry equal error errstr executable executing execution exists extended extern fills float floating floats fn formatted former fp fpformat frame frames generic global header hexadecimal hold i.e ieeedftos ieeesftos image implement implementations include independent indicates indirectly instantiated int interpret invoked invoking iteration jump legitimate leieee80ftos leieeedftos leieeesftos length levels libc.h libmach link localaddr location low mach mach.h machdata machine main map meaningful mechanism memory model models multi names nearest negative non offset owning parameters passes pc pointed pointer pointers precision primarily printed process processing programs prototype provide receive recent recursive reference register registers reglist requiring resolving responsible resulting ret retrieval retrieve return returned returns rget rgetter risc riscframe risctrace rp search selecting setting significant somewhere source sp space specifying src stack stacks starts string structure structures successfully suitable supports symbol symbolic symoff sys table target threaded trace tracer type u.h ulong uniform unwind unwinding unwinds unwound valid value values var variable variables virtual void debugger	2/debugger
 access addr arg arranges buf bytes calling cdfp char closeioproc common complete counting descriptors dial dir error execute executing fails fd fd0 fd1 file forks frees implement include instances int interrupts io iocall ioclose iodial iointerrupt ioopen ioproc ioread ioreadn iowrite libc.h library libthread list mallocz messages omode op parameter pointer primitive proc proccreate process processes procs programs provide read relay relaythread return returning returns routines run running similarly sizeof slave source sp src static struct sys sysfatal terminates thread thread.h threadcreate threaded threads time tot total typedef u.h unsafe va_arg va_list value variable void waits ioproc	2/ioproc
 access address arg buf buffer bytes cmd connected constant data detail diagnostics entries entry error errstr exit extra file formats fstat hello hexadecimal input integer interprets invokes kbyte literal lqm ls manual message modify null options osx output pointer print printed prints read return returns section similar source src standard stat status strictly string style succeeds sys syscall test times unknown valid value write syscall	1/syscall
 access address assumed authenticated based blocks cache cachesize channel checking clients cmd communication configured create created data debugging default descriptors dips disables environment error eventually exist file fingerprint groups hierarchy host interprets limited location member memory metaname mount mounted mounting mtpt ndb network options permission pipe plan post print read removed restrictions root server source src standard stored sys vac vacfile vacfs variable venti via vacfs	4/vacfs
 access adds allocated allows applies arg argpos args basic behave bits buf buffer buffered buffering buffers bugs bytes c.i c.r cases char character characters chars checking clear closure code compared complex construction conversion current custom data declared decoded defined described describes descriptor design details diagnostics directive dofmt dorfmt double emit emitting enum errfmt error errors errstr essence except execution existing exits fails farg fatal fd fetch file finally finishes fixed flag flags flush fmt fmtcomma fmtfdflush fmtfdinit fmtflag fmtinstall fmtleft fmtlong fmtprec fmtprint fmtrune fmtrunestrcpy fmtsharp fmtshort fmtsign fmtspace fmtstrcpy fmtstrflush fmtstrinit fmtunsigned fmtvlong fmtvprint fmtwidth fmtzero fn format formats formatted formatters fp fprint freed generate generates handler honor identify include influences initialize initializes insofar install installation int interface internal internally interpretation items labeled libc libc.h library list ll main maintains message messages nbuf negation negative nfmt nil non num output outputting outside overflows overwritten parameters passes pointer pragma prec precision prepare primitive print printing prints process processed produce produced properly provide quits receive recorded recording records regardless relatives reset resize return returns routine routines run rune runefmtstrflush runefmtstrinit runes saved section size sizeof smaller sophisticated source src standard stop string struct structure style subsidiary succeeds successful suite support sys truncate type typedef types typical u.h uchar ulong underlying unicode unimportant unused user users using utf va_arg va_end va_list va_start value values varargck variable verb verbs version vfprint void width workings write xfmt fmtinstall	2/fmtinstall
 access algorithm archive block blocks blocksize byte bytes cmd compact compressed compression copies default directory divided embeds file files flate header identifying label larger longer mkpaqfs mkpaqfs.c option paqfs range read source src structure sys tree using mkpaqfs	8/mkpaqfs
 access algorithm archive block blocks blocksize byte cmd compact compressed compression copies default directory disk divided efficient file files larger longer mksacfs mksacfs.c sacfs source src structure sys tree using mksacfs	8/mksacfs
 access allow allowing base32 bind bugs bytes cmd directory encoding exists file files filtered getting hash lnfs lnfs.c longer longnames maintains mapping md5 mount mountpoint mounts names option options performed post posting presents process provide read real record server servers shame source src srv srvname starts support sys underlying user users view working lnfs	4/lnfs
 access allow array associates bit black blue color colors convert data datum depth described display displays draw draw.h error errstr etc graphics green greyscale hardware hold images include int intensities length libc.h libdraw map mapped maximum offset operator pixel pixels positions provided readcolmap reads red retrieves return rgb setting source space src struct success sys treating typedef typically u.h ulong unsigned value writecolmap readcolmap	2/readcolmap
 access apop at&t auth authentication avoid bell bitsy bootstrap box challenges characters clear cmd cons dev domain encrypt establish external files forestall greater guess hard host hostower iam id identity imap input invoker's journal ken key laboratories length log login machine machines mistakes morris netkey netkey.c network optional owner passwd passwd.c password passwords plan pop3 possibility pp procedure processes prompts robert run running secret secrets securenet security services seven source specifies src started substitute sufficiently supertor sys technical terminal text thompson tor transmitting twice typed unix user username vol vpn passwd	1/passwd
 access bell data databases describes distributed intro introduction involve laboratories manual outside plan proprietary section 0intro	7/0intro
 access boot bytes cache cached caches caching cfs cfsctl checks client clone clwalk cmd concerning connect connecting connection connections consistency converted data debugging default descriptors destination dev dial discards disk efficiency except file files gathering improve interposed intro kernel latencies level lines manually messages missing modem mounts mtpt netaddr network onto options partition queried rds read reformat remote root satisfied sdc0 server sides slow source src started statistics storing sys time unchanged user users walk cfs	4/cfs
 accessed accommodating additional allocated allows attach attached audio belongs bind bit blocks boot branching buffered buffers bufsize bugs built bulk bus byte bytes calculate cards channel channels class classes codes communicating communication configuration configure configured configures configuring connected connecting consumption continues control controlled controller counting create created ctl data debugging determine dev device device's devices dictated digit directory distortion dma driver enabled endpoint endpoints ep ep0data epoch etc exactly exchange explored extract fields file files forms forward fully handling hex host hub hubs hz i.e input interface interfaces internal isochronous keyboard keyboards khz leaf leave level limited lines map maximum maxpkt mean medium merely message messages mice milliseconds minimum mode mouse nanoseconds nbuf network nnn nodes non notion notions obtained offset offsets openhci operations output outstanding packet packets particular passive pc pcs plan9.ini play plugged points poll polled polls popular port preconfigured predetermined print printers process produced produces programs proto provided provides queries querying rate reached read reading reads real received record remaining remove route samples samplesize sampling scan scanners seek sending serial setup shaped significant six size slot slots slow somewhat specialization specialized specific speed standard standardized stat status stream streams subclass subclasses subsubclasses successful support supported syntax th time topology transmitted tree type units universal usb usbd user using variance vary verbose viewed wire writes writing written www.usb.org yields usb	3/usb
 accessed accuracy alternate announces aux boot clock cmd debugging default determined determines dial dir directory doesn't error file files frequency frnddlil gmt guess impotent indicate kept listen log logging missing nanoseconds netroot network ntp options os pcs print real reference requests rooted rtc run server source sources specifies src srv standard stands startum stratum synchronize synchronized synchronizes sys sysname time timeserver timesync timesync.c tmp tracking ts turns type udp windows timesync	8/timesync
 accessed address allows alpha arch architecture assigned bind bit byte class clock code contains control cputype data dec descriptor determined dev devarch.c device enabled fields file hardware hexadecimal inportb interrupt interrupts ioalloc iob iobfd iol iow irq irqalloc level machines offset ordwr pc port ports presents processor range ranges rate read reads recover requests return seek sizeof source space specific src sys sysfatal textual trap type uchar user using wide writes arch	3/arch
 accessed allocated assumes blocks bytes cmd contained count counts current data default descend directories directory disk du du.c error errors file files finally format hierarchy ignores includes kbytes missing modified multiplication option optionally options print printed prints qid quantized recursively size source specify src stops storage suffixed summary sys time tu units usage values du	1/du
 accessed allow bind boot built code dev device devroot.c directly directory env exception exec executable file holders illegal initializing kernel kernels kfs level mostly names net net.alt port proc provides read root services source space src srv syntax sys tree root	3/root
 accesses allow amount appending arenas becomes blockcachesize bugs build buildindex bytes caching checkindex cmd copy created default described disk entries errors failure file fixed fmtindex formatted generated gigabytes index indicate kilobytes media megabytes memory merge option options partition perform performed populates previously property raw reading rebuild rebuilt requiring running section size sort source space src store sys temporary tmp typically units using venti venti.conf venti.config zeroed buildindex	8/buildindex
 accesses amount appending arenas attempt blockcachesize blocks buildindex bytes caching check checkindex cmd conditions copy default described detects disk duplicate entries error errors examines exist file fix generated gigabytes index indexed indicate integrity kilobytes megabytes memory merge option optionally partition perform raw reading requested running size sort source space src store sys temporary tmp units various venti venti.conf venti.config checkindex	8/checkindex
 accesses assure bank belongs bit bureau byte bytewise census char cia comes connected consecutive contains coordinates corner counted data degree degrees differences digitized earth's endian fields file files formats geological highres ii index indicate integers kept latdiff latitude lexicographically londiff longitude low map measured necessarily negative north ordered padding patch patches patchlatitude patchlongitude points portability positive printable radian range related segment segments short shorts signed sources southeast stands stored struct structs structures succeeding surface survey u.s union units values map	6/map
 accessible add addition adm allows appearance archaic ascii awk bdays birthdays bugs character cmd collating comm comma common comprises consists contains count database default designated designators discarded equivalent fields file file1 file2 files forms identical increasing input join join.c joined ken:feb layout leading leaving lines names omitting operator options output pair paired pairs posix print produce randomly recognized relational relations replace rest separation separator separators significant sort sorted source space spaces src standard string syntax sys tab tabs temp th tr unknown unpairable usage userids users join	1/join
 accessible add addition alias aspects attach becomes bind bind.c binding boot bootstrap bound cache cached client cmd communications compile condition connection consisting contains control convenient create created creation currency current data default definition device directories directory discussion doesn't dump effects evaluation everything existing exit fails file files flag fork happens henceforth hide intro july kernel lib libc.a library loaded machine message mips mk modification modify mount mount.c mounted none object opened operation option options original originally permission permit port possibly process processes read refer refers registry rendezvous replace requests retrieved root satisfy selects served servename server services silently source space spec src srv successful sys time translated trees undo undone union unmount unmount.c unmounted verified write yields bind	1/bind
 accessible address architectures bugs build bus bytes char code continue data dealing define defined env environment error errors establishes except execution fault frame goto handler include int interim interrupts invoker jmp_buf jmp_bufs jmpbufdpc jmpbufpc jmpbufsp label leaves level libc libc.h longjmp low macros non note notejmp notejmp.c notify nstack objtype page pc recover restores returned returns routines saved saves setjmp setjmp.s setlabel sizeof source src stack stacks subroutine switch sys time trap u.h ulong uregs val value values void setjmp	2/setjmp
 accessing additional affect affects allows alternatively assumes at&t attempts automatically auxiliary base basename bases batchmode becomes beginfig behavior bell binary bitmap bitmaps bitmask block book box btex column compatible construct contained control converts correct corresponds create cstr current debug debugging default defaults definitions describes detail details directly directories directory display distribution doc document documentstyle donald download downloaded drawing dump dumping dvips editor embedded encoded ensure environment epsf.tex epsfbox eqn errorstopmode etex examples.mp except exit experts explicitly expression extension extensions fast feature features figs figs.mp figure figures file filename files flag flags font fonts format forming generate generated graphs handling hobby implicitly included ini inimpost input interaction interprets invoked invoking jobname jobname.nnn knowledge knuth knuth's kpathsea kpsewhich labs language latex lib list loading macro macros makempx manual mechanism mem memname message messages metafont metafont's metapost mf mfinputs mfplain.mem mfplain.mp minipage mode modes mp mpedit mpictures mpinputs mpintro.tex mpost.pool mpout mpsupport mpxcommand names negative nnn nonstopmode online options original output overridden package packages path paths permits picture pictures pipeline plain plain.mem plain.mp postscript predigested pretend print process processing produce produces progname prologues ps psfile psfonts.map query read reads sample script scrollmode search searching section self shell similar simulates size source specifying standard stick support sys table tables template tex texmf texmfoutput text third trfonts.map troff troffmpx typesetting understands unless usage user's using utility values variable variables various vbox verbatimtex version via works mp	1pub/mp
 accessing additional allocated arbitrary array arrow attach bits block blocking buf buffer buffered button buttons buttons&1 buttons&2 buttons&4 bytes calling channel char character characters checks chosen complete conflict connected connection cons continually converts corner corners count current cursor cursor.h data default described descriptor descriptors displayed displays draw draw.h drawn draws eatomouse ecankbd ecanmouse ecanread edrawgetrect egetrect einit ekbd ekeyboard emaxmsg emenuhit emouse emoveto enabled enum erase eread ereadmouse eresized error esetcursor establish estart estartfn etimer event event.h event.v events extern extra fails fd file filled fills final flag flush fn gen getrect getwindow global graphics hold holding id image include initdraw input int interface item items kbdc key keyboard keys lasthit length libc.h libdraw list looks maintain marking mask maximum mechanism menu menuhit message middle milliseconds mode mouse moves msec nil non none null numbered parameter plumb pointed pressed process processes programs progress prompts provide queue queued raw rc re read reads received rectangle red register released repeating resized resizing restores return returned returning returns rio routines rune running says scan screen selected selection showing similar soon source sources specifying src stamp started starts string strings struct structure submitted successive sweep swept sys takes textual thread threaded time timer triggered type typed u.h uchar ulong units unless unthreaded update updated user variable void waiting waits whenever window window's xy event	2/event
 accident adaptation address adequate advantage advantages aids allocimage alpha applications artifacts avoids bit bits black blue buffers byte bytes caused cells channels check chosen cited cmap color colors common compatibility components computes concentrating consistency conspicuous constant contiguous continuous converted converts coordinates corrected covering created cube demonstrate den depths described design designed dice dicing differences display displays distribute divide draw duff e.g easy endian entries external extra factor fewer film fixed format formats former frame full fully gamma graphics green grey hue hues idea ignores images imperceptible increase index indexed initialization int intensities intensity interface latter leftmost libraries linear loops low maintain map mapping maps maximum multiplexing navigator nested netscape non ntsc's num odd opacity opaque ordering pack packed packing paper parts peculiar photographic physics pick picking picture pixel pixels plan plus portability porter premultiplied primary properly property purposes range reasonable reasons red red,green,blue reduce releases replicating represent representation represents require requires resolution response rest results rgb24 rgbv sample samples sampling scaled secondary selection sensitive setalpha setmaprgbv shade shades significant size space stored subcube subcubes subdivision subregions suggests suitable systems television tend th therefore tone tones transparent triple trivial uchar uniformly unintuitive usable value values various vga visual void whence color	6/color
 accidentally actions activity actual actually algorithm allocate anftv anonymizing appends appreciate appropriately arbitrary arise atomically auto automatically aux auxiliary behavior bin bit blank block bother bug bulk can't carried cat causing cd chmod co code collecting collection compress compression configured conflict conflicts connection connections connects considerably considered consult consulted contains convince copied copy corresponds create created creating creation cvs cvs.pdos.lcs.mit.edu data database date dates dbfile decide default deflate delete deleted deletion demonstrates described detect determines directories disk displays diverged dst e.g earliest echo emelie emelie.tradb enabled enables entire equal equivalent error errors establish event exactly exclude executable executables exercise exists explanations favor featured file files finished fixed fixes flag flush fsck ft full further greatly gzip hashed hashes hello helps histories hold hosts idea identical ifile implementation include included includes incomptible inconsistencies indicates indicating initialize initializes instructs interested internal interruptions involved kept killing level lib limited lines list log logging logs machine machines mail manage manual match matches merges metadata minisync minisync.log minisync.log.gz mkdir mkwriteable mode modes modification nagle's names needs neither newly none notice occasionally occurred operation operations optimistically option options outdbfile output oversimplified owner pairwise paragraphs path paths pattern pdos.lcs.mit.edu performed performing performs plan please prefix prefixed primarily print proceeds programmer programs promise propagated propagating propagation pserver:anoncvs pty purposes random rc rcs read redo redo2 reliably remote repair repl1 repl2 replica replicaname replicas replicated replication report reported reporting research resolution resolve resolved rmp root rooted rpcs rsc rule run running scan scans script scripts section sending server setgid setmode setmode,setgid setmtime setting setuid sh sha1 shared sharp shell size slows source src ssh standard starts stdmerge stdsplit stored string style suffix suffixed surprise synchronization synchronizations synchronized synchronizer systems t1.tradb t2.tradb temporarily testdblog time times tmp touch tra traces tracks tradb trafixdb tralog tramkdb trascan trasrv trees turns typically undirectional unidirectional unix unlike update updated updates user using usr utility uuencode verb verbose via wally writeable writes xxx.tradb tra	1/tra
 accidents agree allocates anymore assumed ata base bear bios bioses bits char constraints control ctl ctlfd cylinders declares dependent descriptor descriptors device directory discover disk disk.c disk.h disks employs fat fd fields file filename files finds fit floppy formatting forming gather generic geometries geometry hard heads heuristics ibm include initialized int interface kept length libc.h libdisk looks measured messages modern namelen noctl offset offsets opendisk opened opens operating parses partition partition's partitioning partitions pc plain prefix prevent provide rdonly reading reads reality report resemblance resulting returned routines saved sd secs secsize sector sectors setting size source src stats store stored stores struct structure suffix supposed sys systems tables tfile tfloppy track tsd type typedef u.h vlong wfd works writing disk	2/disk
 accompany bytes clients convention defined describing ename errmax error failing failure libc.h message messages replaces reply request rerror return size string successful tag terror transaction truncate error	5/error
 accomplished allows angle animating ap arbitrary arc attention axis button buttons caller center circle conference controller curves diameter dimensions dragging draw.h endpoints event events examine expected geometry.h imagine include interaction interactive ken libgeometry midpoint mouse mousep multiplying nearest null orientation outside particular plane pointer points proceedings projected projecting qball qball's qball.c quaternion read reading rectangle redraw reflect restrict return rotation rotations routine screen shoemake siggraph smaller source space specifies sphere sphere's src sys triggered twice unconstrained unit update updated void qball	2/qball
 account accounts adm administrative announces auth authserver cmd create date default existing expiration files lib machine mapping ndb net net.alt option password prompts radius requests runs secstore secstored secuser servername serves source src status store sys tcp uid userid username users verifier writing secstore	8/secstore
 account address addresses ascii attempts automatic baud behave bits break bsd bugs bytes carriage cat cdnrrvst character characters closed cmd combined communicate communication computer con con's connection connections connectivity connects control cooked copy cu dcrn debug debugging deepthought dial disables e.g echo ensues environment eof eqn error escape executes execution exit file file1 file2 files forces forestall hang incoming input inseparably intended ip kilobyte kilobytes kremvax legitimate length listed logged login logs lp machine message misinterpretation mode ms net network networks newlines option options output packet paper parallel parity pipe pipeline plan print printable printing processing programs progress prompt prompts protocol provided quit rate receive received receiving remote remuser responses return returns rudimentary run runs rx screen send session shares shell shells sic signal similar size source specially src stage standard strips supported suppresses sys target telnet ten terminals toggle towards transfer translates transmitting troff trying typed using utf verbose versa vice wait written xmodem xmr xms con	1/con
 account addresses adds adm affect allow attempts auth authentication authsrv bad binary byte bytes changeuser cmd connect consecutive considered contains cpu creates creating current database databases date decrypt decrypts dedicated default delimited derived des described deskeylen directories directory disabled disables duplicate enable enabled enables encrypted encryption endian entries entry epoch error except expiration expire expired expiring failed fifty file files holds host hours identifies increments initialized installed integer interface interpretation key keyfile keyfs keyfs.c keys keys.who level lines list log machine mail manipulating match mnt mntpt namelen names namespace netkeys netkeys.who network newline non np null nvram ok option password plan prior programs prompts providing ram reached reaches read reading reads record reflected removes removing renaming represents resets restrict returns rooted rtc runs seconds securenet send sent separately server serves source src starts status stored string strings sys time tree user user's users using utf version volatile warn warning warning's warning.c warnings write writing written keyfs	4/keyfs
 account aes algorithm alleged backwards blowfish buffer byte bytes cover cycle data decrypt des dlen dsa elgamal encrypt encryption entered forward generator include input int keeps length libc.h libsec libsec.h lost mp mp.h nbytes output prime pseudo rand random rc4 rc4back rc4skip rc4state retransmitted rivest's rsa run sechash seed setuprc4state skip slen source src structure sys track transmissions u.h uchar using void xor'd rc4	2/rc4
 accrued affects architecture architectures behavior bits characteristics clear clears contains control controlled default define defined divide double efficiently enable equivalent exception exceptions execution extended fairly fcr fixed floating fpainex fpainval fpaovfl fpaunfl fpazdiv fpinex fpinval fpovfl fppdbl fppext fppmask fppsgl fprmask fprninf fprnr fprpinf fprz fpunfl fpzdiv fsr getfcr getfcr.s getfsr gradual guaranteed halt hardware holds identify ieee include inexact infinity installing interface internal invalid libc libc.h machine machines macros mask mc68020 modes modify nearest negative objtype operation overflow pair plan portable positive precision provide pseudo register registers retrieve round rounded rounding routine routines selective setfcr setfsr source src status support sys towards traps u.h ulong undefined underflow unit units value values void getfcr	2/getfcr
 accumulate added address addresses append applied applies apply awk backslashes bearing bears beyond blank blanks branch buffering bugs chapter chapter1 chapter2 character characters cmd consists consume context convention copies copy counts created cumulatively current cycle cyclically decimal default delete deletes denoted distinct don't drop ed edited editing editor embedded equal es etc exactly except exchange execute executed execution expression file files flag flags formatted fuller global grep hide hold inclusive input insert instance instances interactive label lengths lex lines looking manual manuscript matches matching mcmahon ms negation newline newlines non nroff occurrences omitted operation option options output overlapping pattern pipe print process processing programmer's protect quit range read reading recent regexp regular repeated replace replacement research rfile sam script sed sed.c segment select selected selects sfile source space spaces src standard stream string string1 string2 stripping style substitute substitutions suffixed suppresses sys tabs terminate test text thereafter transform unix unless volume wfile write sed	1/sed
 accumulate appended blocks buffer bugs bytes cmd continue copied copies copying counted counts custom data default deliver designated ell file flag follow fr further grows ignorant input lbc length limited lines measured nbytes nlines option options output posix print printing promulgated relative reverse rf sed signed source src standard syntax sys tail tail.c tails ten treasured utf watch tail	1/tail
 accumulate arcs background bounding buffer cmd col color created current default double drawing erase factor file files fill filter foreground grade grades graphics higher input instructions interprets interspersed middle names newline newly options pause pen persists plot plot's plotting processing quality rectangle results rio screen source specify src standard sys typed various window write x0,y0,x1,y1 plot	1/plot
 accumulated adjustments amount assumed attach baseline bottom boundingbox box bp break bugs can't center clockwise closed comment comments complex current default defaults define degrees delimiting described destined diagnostics dimensions disappear distance diversion document documents downward entire ep everything explicitly file fill filled fills flags frame freely goes height horizontal horizontally implicitly improper inch included inclusion incorrectly indent insert isn't justify label lacks length level low macro macros margin measuring missing move mpictures null occupied offset optionally options original outline packages page pi picture pictures positive postprocessor postscript prevents reached read replaced retrieve retrieved rotate scale select silently size source space started suffixed sweeps text there's trap troff vertical width xoffset yoffset mpictures	6/mpictures
 accumulates active actual address adse algorithm allowing amount appended args assumed avoid c.xxxxxx character chunks cmd combination connect consist contains continue control copied copies create created creates cron cumulative d.xxxxxx data debugging default depends describing dev differ directory drained e.xxxxxx entire entry error etc exactly executing executions exists exits external failed failure fax file files fits flag flags folded forces hour hours identify incrementally input instance kremvax lib limit limits load mail mailed management meaningful memory message minutes mktemp modified names nfiles notification nprocs null older option output page parallel parallelism pass piling preceding prevents process processed processes processing progress qer queue queued queues regardless remotemail removed reply reprocessed reprocessing request requester requests retries retry return returns root runq secondary send slow source spaces specifies spooled src standard starts status subdir successful sweeping sweeps swept sys systems tag telco time times total trying upas user xxxxxx younger qer	8/qer
 accurate allows amount amounts args average bugs clock cmd consists data dbfile debugging default error exits fastest figures file final flag fooled fresh gather headers interposes involved iostats iostats.out level log measure message messages mounts opens outside overhead plan poor printed programs protocol purview rate read reads regular report reports resolution rpc section sections sent server slowest source src standard statistics summary sys terms time total traffic transactions transferred type user write writes written iostats	4/iostats
 accurate approaching arc artificial ascension astro astronomical azimuth bopp bugs calculated celestial centers clock cmd comet conjunctions data date declination default degrees described difference distance dlpsatokm due earth earth's eclipses ecliptic elevation empirical english environment ephemeris estartab etc events file files format formula fractions gmt hale hours include includes input interesting interval involving kitchen latitude lib list longitude magnitude meters minutes missing modified moon needed north obj1 obj2 objects observation occultations option options orbital output outside positions presents print printed prompt read refer refers report reports reverts rotation satellites scat search searching seconds semidiameter sidereal sky slowing source speech src standard star steady stellar successive suitable sun synthesizers sys time times timezone timing universal upcoming usable variable astro	7/astro
 acid add allow alternate author awk bugs cmd compressing conventional create current db debug debugger debugging default directories disk entries errant file gone gs hung id images machine memory month mount mountpoint mounts mtpt nf option output owned page page.snap pid postscript print proc process processes psu recommended recreates requests rest restore return returns rewritable running save saved serve server snap snapfs snapshot snapshots source space specify src srv standard static storing string suppose sys terminal text time user via viewing writes snap	4/snap
 acid baseline bin broken cmd created critical current db dead default display event examined exited fault files flag id idle kernel kill lingering moribund newlines ns pa page pageout paging performing print printed prints priorities proc process processes ps ps.c psu queue queueing rc ready reclaimed reported resource resources run running scheding servicing size source spaces src started status stop stopped stopwait sys syscall time translated unnatural user waiting wake wakeme ps	1/ps
 acme active advanced amount apm apm.c apm0 aux battery bin bind bios block brings bugs charge charging cmd contains control critical ctl default descriptions dev device directory disable display doing eia enable estimate event fields file files full guaranteed integral interface kernel lists low lpt management messages mnt mode modes mountpoint network nontrivial occurred parts pcmcia percent plan9.ini posted presents puts read reads remaining requires return seconds source src srv standby status storage string supported suspend sys textual time try unknown various verb verbs apm	8/apm
 acme additions arrows automatically behavior box button clear clicking current deleted deletions directory display displays faces file files flag fs icon icons ih image incoming interface invokes listens log mail mailbox marshal mbox message messages middle mode monitors nedmail notified particular person persons plumb plumbed plumber port portrait rc reacts read reader reads received removed representation rule running screen script scroll scrolls seemail sender sending showmail startup sys tells typical typically upas user user's using venerable visible vwhois window faces	1/faces
 acos arc asin atan atan2 bugs caller checked cos cosine double garbage greater include intro libc libc.h magnitude meaningful port radian range return returns sin sine source src sys tan tangent trigonometric u.h value sin	2/sin
 acquire actual actually affect allocate allocates allocimage allocscreen allocwindow analogous appearance apply arbitrary array background backing band border bottom bottomnwindows bottomwindow bugs builds cachechars calling chan channel check choice client clients color completely confusing connected coordinate coordinates coordination corner corresponds covered create created creates creation data deallocated define defining deletion delivered descriptor designed disappear discover discussed display draw draw.h drawing enum expected facilities fill finished flag freed freeimage freescreen fully gather geometry global graphics historic holding id image images include indented initdraw initialization initialize initially int integer internal leave libc.h libdraw library listed log logical management messages method methods move necessary needs newly nw obscuring operations origin originwindow owner paint parent particular permit pixel pointer profitably programs protect protected protects provides pt publicly publicscreen published pull pulls push pushes r.min recorded rectangle ref refbackup reference refmesg refnone refresh regular releases repainted require resides rio routine routines safety scr screen section separately share shown shuffling source specifying src stack stacking store struct structure sweeping sys takes temporary topnwindows topwindow translated turns typedef typically u.h ulong unaffected unless unlike unused upper usage val value view visible void window windows wp window	2/window
 acquire atof bind buf bulletin channel channels char create data descriptor descriptors device devsrv.c directory drop entry error executing fd file fprint hello holding holds install int level myserv namedpipe owrite pipe port post process processes provides read receive received reference registered registry releases removing server service1 service2 services sizeof source src srv string strtoul suitable sys text write written srv	3/srv
 actions actual attach client clunk clunked current entry error failed fid file forget generated indirectly informs longer message needed opened orclose points rclunk removed request returns reused server size tag tclunk unless valid walk clunk	5/clunk
 actions address addresses alias append applied arg1 arg2 arriving bell blank box bundling com common composed concatenating consists continues convert dead.letter deliver delivered delivering depends deposit depth destination destinations dispose disposition ed entire error es event executing execution expanded expanding expands expression fields file follow formed id indicated indicates insensitive invoked ken labs labs.com lib lines list locally login loop machine mail mailbox match matched matches message net network output parenthesized pattern performed performs pipe plan9.bell postmaster presotto print provided qmail queuing rc recur recursion recursively reduce regexp regular remote replace replaced replacement returned rewrite rewriting rmail rob rule rules run runs script sender sent standing starts string strings style subpattern substring text th times translate transmitted type user valid rewrite	6/rewrite
 active activity adjacent affect affected average axes axis battery buffer bugs button card choose cmd collected columns computed configured context control corner count decimal default details detected device disable display displayed displays disregard due enable error errors ether ether0 etherin,out etherin,out,err ethernet exceptions executing factor factors fault faults files flushes fraction fractions goes graph graphs hardware highest horizontal indicate interrupts intr labeled larger linear load logarithmic lookaside lower machine machine's machines markers matters maxima maximum mechanism mem memory menu midrange misses mouse multiplied multiprocessor names net operating option options origin packets page pages parameter percentage plot plotted presents process processes processors range ready received receiver remaining remote represents rightmost rolling run running scale scaling sent serves showing shown signal source space specific src statistics stats stats.c strength strong swap switches sys syscall sysstat time times tlb tlbmiss tlbpurge total translation transmitter twice unless updated upper valid value values various vertical visible wireless stats	8/stats
 active added aligned allocate allocated allocation bin bin.h binalloc binfree bingrow block bp bytes calling chunks clr deallocation diagnostics extend freed grouped grow include int item items libbin libc.h locations malloc memory nil non null object op original osize pieces pointed pointer pointers provide remaining return returned returns routines size source src storage struct suitably sys type typedef u.h ulong undefined using valid value void bin	2/bin
 active adds appending applications applied behavior bugs clears client cmd consist convention copy cpu created creating default defined deleted deliver delivered delivery destination determined difficult directory discarded discards dispatches dispatching dynamically earlier edit edited editor elsewhere error examined examines exist file files fixed format include interprocess involve item level lib menu message messages messaging mnt mount mounted mounting neither newly none opened opening otrunc output plumb plumber plumbing plumbsrv port ports pre programmed programs published read reading reads receive receives returned rewrites rule rules run runs sam search send sender sent server services source space specification src srv statements sys term text traditional unique user usr write plumber	4/plumber
 activities address addresses algorithm annotates ar architecture architectures archives assembly automatically bare base bdata binary boot bss bytes character cmd code compilation compiler correspondence creates data db debugging decimal default defaults depend dependent divide dsp3210 edata emulation enabled entry etc etext executable explicitly ext file files format generate header hexadecimal image included includes insert inserted instructions internal items kl language letter lib libc.a libc.h libraries library linkage listed load loaded loader loaders loading main mainp maximum mention mentioned mips multiply necessary needed needs nm object objtype octal option options output picked pike plan practice print prof profiling ql ram rarely read regular remaining repeatedly represents resolve reversed rob rounded routines scan scanning search searching segment sgi size source specifies src starts startup strip suppress symbol symbols sys tables text time topological type types typically undefined unix values vl xl 2l	1/2l
 actual actually agreed alg algorithms algoritms allocated anti assumed authenticating authentication base64 binary bind boundaries buffers bugs byte bytes channel clear clone configured connection connections contains control controlled correspond cryptoalgs ctl data decrypting des_40_cbc des_40_ecb des_56_cbc des_56_ecb descriptor device devssl.c dial digest digesting direction directions directory enables enabling encalgs encoded encrypting encryption equal established exchange existing fd file files filter greater handshake hash hashalgs hashing implementing included incoming interface kernel key layer lengths level list listen loaded longer md5 messages mode mutual net newly numbered opening optional options outgoing port presented preserves protocol provides providing rc4_128 rc4_256 rc4_40 read reading reads record remote replaced representing reserves responsible returned returns run secret secretin secretout secrets secure sha shared shown similarly smaller socket source space specify src ssl sslv2 stream string strings subdirectories supported sys tampering text time transmission truncated turns using write writes writing written ssl	3/ssl
 actual addr address advantage allowing application args bin bugs cat cert.pem cert.thumb certificate certificates client cmd connection convention create creating crypt dials dyourdomain encrypted encryption establish excludedkeys exec exec'd factotum file files flag generate hash helper hold http imap imap.pem imap4d imaps input interact ip key key.pem keyout keys krem kremvax kremvax:5 launching legacy lib limap4d listed listen listen1 listener log logfile logging mail mainly mosc moscvax network newkey nodes offset openssl optionally output plain plan port private provide putting rc relays remote remotesys req reverse rsa:1024 running script server service.auth sha1 source src ssl standard starts stunnel sys target tcp tcp993 thumbprint tls tlsclient tlsclient.c tlsclienttunnel tlssrv tlssrv.c tlssrvtunnel tool toolkit tools trustedkeys tunnels typical typically unix unix's usr vnc vncs vncv tlssrv	8/tlssrv
 actual address affects allocated attach attached automatically bind bit boundary bytes check class continue control create created ctl data defined device devsegment.c directory dmdir echo equivalent error exist exit file files format hi ing length level lived longer megabyte memory message mkdir mnt mode mom opening ordwr page performed permissions port process processes properties provides reading remove representing reset reside retrieves returns rounded seg1 seg2 segattach segdetach segment segment's segments setting sharable sharing source src string sys ulong using va virtual writing yields segment	3/segment
 actual adds adjusted al ar ar.h ar_hdr arch architecture archive archives arfmag armag automatically bits blank boundary bugs char combine compatibility constituent contains data date decimal define defined dependent described et except exclusive externally extra fields file files fmag format gid header include independently index inserted insertion layout length libraries library loaders locate low magic mainly manner member mod mode modification necessary nevertheless newline nm object octal padded padding permission plan presence produced provide provision read reflects sar_hdr sarmag searched size stat string struct structure symbols symdef text time uid unit unix unused verify written ar	6/ar
 actual adjective admit affix agglutinated amspell aux backyard bin biology british brspell bugs cede check checker chemistry classes cmd common constructs coverage covered crew crewmember default derivations deroff don't english errors excise expects favor file files follow formatting heuristics ignores imperfect input judgement judgment languages lib lightly list list's literally looks medicine member mention misspellings modeled modelled names noun options output particular perforce places policy preferred preprocessors print proper rc rejected rules sanctioned script shunned sizable sizeable source spell spelling spellings sprog src standard stem sys takes troff understands uneven unruly usage variants yard spell	1/spell
 actual allocated alternate ansi appends arg array ascii binary bio blanks buf buffered bug bugs byte bytes char character characters commas complete consecutive contains control conversion conversions converted converts copied copies count custom decimal dependent deprecated described descriptor diagnostics difference digit digits directly distinctly doesn't double ensure error errstr etc except excess exhausted existence exits exponent fatal fd fetching file finally fit flag flags floating fmt fmtinstall format formats formatted formatting fprint fprintf fraction friends generate goal hexadecimal hh holds include indicated installed int integer integers interprets justification justified len length libc libc.h list main malloc maximal maximum mean message minimum missing msg negative neither non nor nul numeric objects obtained octal omitted output pad padded parameter places plain plus pointer pointers points positive precision precludes print prints produces producing promoted quits reasons relatives remain removed replaced representative required responsibility resulting results return returned returns routines rune runefprint runeprint runes runeseprint runesmprint runesnprint runesprint runevseprint runevsmprint runevsnprint safety section seprint short shows sign significant similar simply size sizeof sizes smallest smprint snprint sometimes source space spaces specification specifications sprint src standard storage stream string strings synonym sys takes text transmitted type types u.h undefined unsigned upper usage user's using utf ux va_end va_list va_start value values variable variadic verb verbs vfprint vlong void vseprint vsmprint vsnprint width works write writes written wrong print	2/print
 actually adjusted admit alternating alternation amount applied bi blanks bold br break bugs chapter closing column columns commentary constant declarations default denoted diagnostics direct displayed distance doesn't dot double dt e.g ee ens eq eqn equalize equations ex except explanation extra file files fit font fonts fool format handling hanging hp ib include indent indented indents input inserting interparagraph ip ir italic italicize join keywords lengths letters lib literal literals lower lp lr macros main manual margin marks move n.t.l naked names nested nofill non nroff output p.i page pages paragraph paragraphs parameters pd pp predefined preferred prevailing printed processing punctuation quote quotes rarely re reaching reg relative remembered request requests reset restore return ri rl roman rs secondary setting sh short six size sm sp ss string strings struct style subhead successive summary support suppress symbol sys tables tabs tag tbl text tf th there's tmac tmac.an tp trademark treatment troff ts type typeset units value values wide widows width xx yes man	6/man
 actually advances append appended appends appropriately array bio block bugs char character characters check clears converted data deprecated described discarding discards eof error except fails fgetc fgets file fopen fputc fputs fread fseek fsetpos fwrite getc getchar gets guaranteed handle include indicated indicator input int intervening items itemsize libstdio macro mode newline nitems nonnegative null occurred occurs onto opened operation output overflow pointer positioning ptr push pushed pushes pushing putc putchar puts read reading reads receiving requests returned returning returns reverse rewind runes similar size source src stdin stdio stdio.h stdout stream streams string successful successive support sys takes type ungetc unsigned utf value void write writes writing written fgetc	2/fgetc
 actually affects amount append asks atomically bytes correspond count data directly directories directory entries entry equal error exactly fid file generate generated greater guaranteed identified illegal implementations include indicates integral iounit limit maximum member message messages non offset opened plus points pread produced pwrite read reading recorded records regardless reply reports request requested returned returns rread rwrite seek seeking size stat tag transfer transferred tread twrite value write writing written read	5/read
 actually answers approximate arbitrarily arbitrary arctangent arithmetic array assignment assignments auto automatic automatically bc bc.y bclib bessel brackets break bugs calculation cmd comments compile compute cosine dc decimal declaration define definitions digits display enclosed executed exponential expression file files follow global hoc ibase include influences input interactive invokes language length letter level lexical lib library log main manner math mathematical names newlines null obase operands operations operator operators option optional output precision preprocessor print printed processor programs provides pushed quit quotes radix read reads remainder resembles results retained return scale semicolons sent sign significant simultaneously sine source sqrt square src standard stands statement statements suppresses syntax sys takes text unless value values variable variables via bc	1/bc
 actually arbitrary bind bit bugs child clears configuration cons contains content continue contrast creates current devenv.c device directory ec env environment error everything exactly extent file files filling fork global groups host initially intention kernel level mistake names noticed offset owner parent plan9.ini port process processes rc reboot rfcenvg rfenvg rfork serves source split splits src sys that's value var1 var2 variable variable's variables writable write xxx yields env	3/env
 adapted addition advertising allocates allow application appropriately array based bitsyload button capslock card character characters charater classifiers code compaq computer contains control copies copy copyright copyrighted corporation cs_digits cs_letters cs_punctuation ctrlshift curcharset current define definitions depressed digits distribute distribution documentation draw draw.h drawing drawn easy encoded encodes express fee fields file files flags graf graffiti graffiti.c granted graphical groups hereby identified implements implied include influenced initialized int intended keith key keyboard letter letters lib libc.h library libscribble microsystems mode modifies modify mouse non notice packard palmtop parameters pen pen_points permission pertaining points poly portions ppasize primary printable prior private prompter provided ps pt publicity puncshift punctuation purpose quick quickref.gif recognition recognize recognized recognizes reference representations reproduced returned returns rune scribble scribble.c scribble.h scribblealloc searched sell serves similarly software source specific src standalone storing stroke strokes struct structure suitability sun supporting switch sys tmpshift u.h upper using version void warranty written scribble	2/scribble
 add added addition additions address addressfile aliasmail appended ar box bulk cmd comments consequence created creates deletions describes dev directing directories directory entries envelope error events exclamation faces fields file files filter hash header inserted key lines list list's listname lists log mail mailbox mailed mailing marshal membership message messages ml mlmgr mlowner nedmail notification null ones option options owmer's owner pipeto precedence programs qer receive removal removals remove removed replies reply represents requests rewrite send sent smtp source specifying src subscribe sys unmoderated unsubscribe upas upasfs updates user using mlmgr	1/mlmgr
 add addison aho allows apply arbitrary argc argv arithmetic array assignable assignment associative atan2 average awk blank blanks boolean botch braces break buffered bugs built capture cases character characters closes cmd column combination combinations combine comma commonly compensate concatenate concatenated concatenation conditional consist constant constants constituents continue control conversion conversions converting converts convfmt copy cos count counted created current default defined defines definition delete denote denoted directed echo entire environ environment equivalents error escapes except excess executed executes exit exp explicit exponentiation expr expression expressions fflush fields file filename files finally flushes fmt fnr foo format formats formatting fprintf fs getline global gsub i,j,k identical implementation inadequate index indicated initialized input int integer isbn isolated kernighan language length lines list literal literally log longer lower management match matched matches matchop mathematical maximum meanings memory mf missing names necessarily newline newlines nextfile nf non nr null numeric numerical occur occurrence occurrences occurs ofmt ofs opened operators opposite option options ordinal ors output pairs parameters parenthesized pattern patterns performed permitted pipe pipes portion print printf prints processing prog programming providing quoted rand random re read recognized record recursively reference refers regexp regular relational relop remaining replaced replacements rest resulting return returns rlength rs rstart rules scalar scalars scanning scans scope sed seed semicolons separates separation separator settable simulate sin six size skip source space split splits sprintf sqrt srand src standard stands statement statements status stop storage str string strings sub subscripts subsep substitutes substr substring successful sum syntax sys tabs time tolower toupper translated truncates upper using usual utf value values var variable variables weinberger wesley worse awk	1/awk
 add additional address arena arenas assumption basic block blocks buildindex cmd collection composed compressed computes contains copies copy current data depends determined determines enable entire exact existing feature file files fingerprint fixed fmtarenas fmtindex fmtisect format formatted header implementation index initializes linear location map mapping mappings option overflow previously range rarely rebuilding restore run section sections sha1 size source space src stored structure sufficiently sys takes total usable using values venti venti.conf venti.config fmtindex	8/fmtindex
 add addpt arithmetic canonicalized canonrect clips combinerect compares completely components construct contained cover data difference divpt draw.h dx dy eqpt eqrect equal extent geometrical graphics height include insetrect int libc.h libdraw macros max max.x max.y min min.x min.y mulpt overwrites pixels pointed points pt ptinrect rect rectaddpt rectangle rectangles rectclip rectinrect rectsubpt rectxrect return returns rp rpt share smallest source src sub subpt sufficient sum sys types u.h unchanged unequal value void width addpt	2/addpt
 add address addresses addressfile addrfile addrssfile adds aid aliasmail allow allows append appends attachments bh bin bound box build bulk check checks cmd combined contained contains content conventions copy created creating current date dead.letter delete deliver delivered delivers described determines dev directory directs doesh't error exactly executable exist expression expressions extensions faces fifth file filename filenames files filter filtering filterkit filterng flags forms fromfile gets header include includes incoming input insensitive key kit lib lines list locking logging mail mailbox marshal match matched matches matching mbox message messages mime mimetype mlmgr myupassend myupassend.sample nedmail non none null obeys onto outgoing output pairs pattern patternfile patterns pipeto pipeto.sample precedence prints profile provided provides qer rc rcvr read readable recipient recipient's regexp regular related remaining returns rewrite rule sample script searches send sender's shell smtp source src standard status string successfully suspect sys takes token tokenfile tokens types unique upas upasfs user user's username using verbs vf warning wraps writable filter	1/filter
 add advised aes aescbc apop append auth authenticates automatically backup bits block bugs cbc cd chaining cipher cleartext cmd copy crash credentials cryptext ctl dates decrypts default delete deleted deliberately detect digits directory disk dom echo ehg encryption encrypts env ephemeral factotum feedback fetch file files final getfile hardware hashes hex intended internally invisible irrevocable key keypairs lengths list loads location memory mistyping mnt mode option optionally output particular password passwords persistent private produces prompts proto providing putfile ramfs read remote removed removes resident retrieves rijndael rmfile running save saves secret secrets secstore send server sha1 source specifying src standard startup store stores sys tcp tmp token updated user using verbose window workspace writes x.com secstore	1/secstore
 add algorithms allows analyzed analyzing approximate arbitrary bit buffer caused cbhmt cc channel check collapses combination combined communication compiled compiler compiling computer concurrent conditions consistency contains correctness cplgrsmv creation current cycles dbitstate default defined delayed described design detail directive dnoreduce dynamic effects error events executable executed execution exhaustive exist exit extra fast file files finds full g.j generate global gotos guarded guided hall holzmann iat include input inspected instance integer interactive invariants invoking language level liveness logical loops lost machine memory message minimal mode model non nondeterministic obtained operations option options ordinarily output pan pan.c parameter partial perform performs pglmrsv pglrsv prentice print process processes produce progress promela property protocol protocol's protocols random receive receiving reduction reference references reported require requirements rules run running safety seed selection send sent simulation simulations source space specific specifically specification spin standard statement step system's systems tabular target time tool trail type unless user using validation value variables verbose verification verifier verifiers version views violated violation warnings writes written spin	1/spin
 add angle arithmetic axis carries commutative complex component components componentwise composes convert cos cross designed divide dot double draw.h extension geometry.h imaginary include interpolate inverse length lerp libgeometry mat matrix mtoq multiplication multiplicative multiply negate non object operate ordinary orientation orientations points products proportional q.i q.j q.k q.r qadd qball qdiv qinv qlen qmid qmul qneg qsqrt qsub qtom quaternion quaternion.c quaternions qunit real relative return root rotation rotations routines rs rule rw sin slerp source space spherical sqrt square src standard struct subtract sys transforms typedef unit vector void vs x',y',z x,y,z quaternion	2/quaternion
 add attr attribute attributes blanks cmd concatenation current data default destination directory dst file files formats input lib message mnt mount options plumb plumber plumbfile plumbing rules send sends showdata source src standard strings sys text type user usr wdir working write plumb	1/plumb
 added adding allocated allows alternate ambiguity automatically avoid becomes blanks char character characters check compiler contains control copy created default don''t don't doquote doubled embedded evaluated fmt fmtquote.c format formatting freshly hello identical include includes indicated installed installs instance int libc libc.h malloc manipulate mechanism necessary needs nil non original output pointer port pragma print printed produce programs properties provided quote quote.c quoted quotefmtinstall quoterunestrdup quoterunestrfmt quotes quotestrdup quotestrfmt rc regardless removing return returned returns routines rune runestrcat source specify src standard statements strcat strdup string strings style surrounding sys type u.h unquoterunestrdup unquotestrdup using value variants versions void worry quote	2/quote
 added addition advance advances advancing allocate allocated allocation amount array ascii avoid avoided base basic begining beyond bio bio.h biobuf bounding bytes char character characters code constant converts copied copies copy copying count create define defined directly discarded doesn't double encountering eof equivalent error escape exposes extensible filling finger fixed freed freeing frowned grow grown grows implementation include int interaction keeps leading libc.h libstring lightly lock longer lower macros maintains manipulate mechanism memory multithreaded multithreading necessary needs newline nul null parsing performs pointer pointers points programs ptr quoted quotes read reading reads reference released requested resets returned returns routines s_alloc s_append s_array s_clone s_copy s_error s_free s_getline s_grow s_incref s_len s_memappend s_nappend s_new s_newalloc s_parse s_putc s_read s_read_line s_reset s_restart s_terminate s_to_c s_tolower s_unique source space spaces specifying src stop string string's string.h strings struct structure sys tab tabs terminates token track tread type typedef u.h unique user using void won't write writes string	2/string
 added address addresses announces anyone attempts average buckets button bytes clicking cmd considered contains count datapoint debugging default delay dest destination determine display displays dn don't dropped echo endport error expires exponentially gping gping.c graphical graphs header headers histogram hogports hogports.c icmp included increasing internet interval ip larger length live lost machine menu message messages milliseconds mounted ms mtpt names nbuck net.alt network options packet packets percentage ping ping.c ports presents print printed probe processes proto range received recorded replied replies request requests response returns round router routers run seconds sending sends sent size smaller source src standard startport sttl sys tcp time times total traceroute traceroute.c trip try ttl using value visible vncserver warning weighted ping	8/ping
 added address addresses answers assumed att14400 aux baud baudrate bin bugs built caller ccitt class cmd commas communications compatible compress compression computers con connection connections control cover data decimal default derived destination dev devs dial dialer dialers dialing dir directory e.g edited eia1 encoded facsimile fax faxqueue faxreceive faxreceive's faxrecipients faxsend file files follow h.ps hayes highest id images incoming input inputs insert interface interfaces ip kept lib list log machine mail match message modem modems modifiable mt1432 mt2834 multitech's names needs negotiable net network notification options outgoing output page page1 pages passing pauses pc phone portable postscript process programs provided provides pulse queues rate rc receiverc receiving recipient recipients representing require safaris scheme script sends sent server sheet shell source specific specify spool spools src standard started starts string subset success supported sys telco telcodata telcofax telephone telno text transfers transmits transmitted type types user using verbose vocal write telco	4/telco
 added address appending approximately archival archive archives backup based block blocks blocksize broken build building bytes cmd coalesced collection comparing configured consumption copy copying create creates data default described detected detecting directory duplicate environment equal error examining exclude exist existing expand expanded explicitly file files fingerprint format generated hexadecimal host include increase incremental indicate input inserted kilobytes match merge merged meta metaname mqsv ndb network note occurs oldvacfile operations optimization option options output performance plan print produce properties range reading reduce reduction relative repeated representation require resulting results root server sha1 shares simply size source specifies src standard statistics storage stored storing sys times transparently tree trees unchanged units unpacked unusual user vac vac:64daefaecc4df4b5cb48a368b361ef56012a4f46 vacfile vacfs variable various venti verbose via write written vac	1/vac
 added addressable afterwards allocate allowing alongside appended application appropriately array assumes background backspaces bar beforehand beyond bord borders box button buttons bytes cachechars caller calling chaos character characters chars check clear closest col color colored colors cols components consistent contiguous control copy corner data deallocated defined defines deletes deletion delimited designed determine determines directly display displayed displays document draw draw.h drawn draws editable ensue entire entirely enum erase establish except fewer file fills fixed flag folded font frame frame.h frames frbox frcharofpt frclear frdelete frdrawsel frdrawsel0 freed frees frgetmouse frinit frinittick frinsert frptofchar frselect frselectpaint frsetrects frtick ft full generated geometrical geometry graphics handled helper highlighted hold holds htext image image's images include index indicated indicating initialize inserted inserts int interface internal intervals inverse involve larger lastlinefull level libc.h libframe library limit lines location longer lower maintain maintained maintenance manage managing max maxlines maxtab modified mouse mouse.h mousectl moved nalloc nbox nchars ncol necessary needs newlines nlines non nul null obscured occupy onscreen p'th paint pass permitting pixels plain pointer points portion positions prepares printed programs provided pt pt0 q.v range raster recreate rectangle redrawing redrawn region regular removed removes repaints replaced representing required resize resized return returns rio routine routines rune runes sam saved screen scroll section select selected selection separately session shape size solid source src stops string struct structure structures sufficient supports sys tab tabs taking terminal text thread.h tick tickback ticked times total tracks type typedef typical typically typing u.h ulong unchanged unless unnecessary upper user ushort value vertical visible void width window wish frame	2/frame
 added advantage alphabetics ascii blanks block blocks bs buffer bytes cases catenate cbs character characters cmd conv conversion conversions convert copied copies copy copying core count cp dd dd.c default device diagnostics ebcdic ebcdic,ucase efficient error expected file files fixed forward full handled ibm ibs indicate input iseek latter lcase length lower magnetic map mapping multiplication noerror obs opens option options oseek output packing pad pair partial particularly physical preserve processing product raw read record records reports seek sending short similar size sizes skip slightly source specify src standard stop structure style superseding swab swap sync sys tape trimmed trunc truncates truncation ucase unblock unspecified upper value variable dd	1/dd
 adding adds aux bin bracketed bugs ccitt character characters cmd conversion converts correct corresponds cputype data deal default descriptions determine dev device devutf directory dlcfilmnorxy dlcimnorxy dlm dpost drive dvipost executes exists faces fax file files font g3post generated generic gif gifpost handle header hpost image input interface job's jobs jpeg jpgpost lcinor lib list lp mappings noproc option options output owner p9bitpost page pair paper passes patches pdf pdfpost plan post postscript ppost preprocessors printer process processor processors programs provides rc responds reversal screen script smart source space src suite sys systems table tex text tr2post tray troff troff'ed type types unix untouched utf width window window's wsys lp	8/lp
 adding advanced apm apm.c apm0 apmjump.s bind bios dev device driver enable enabled enables equals executes friendly intended interface interfaces level low management pc pcs plan9.ini presence presents read reading registers returned sign source src structure sys uniprocessor ureg user value writing written apm	3/apm
 adding alter analogously appends array ascii assembly beyond bugs byte bytes char check cistrcmp cistrncmp cistrstr compares comparing comparison comparisons considered considers consist consists copied copies copy correctly definition dependent differences distictions distinct entirely equal es1 exactly examines exists greater guarantees ignore ignores implementations include int integer keeps language length lexicographically libc libc.h machine malloc memory moves necessary none note null objtype obtained occur occurrence operates operations original outcome overflow overlapping pointed pointer port portable remains returned returns routines rune runestrcat segment separator signified source space spans src stopping strcat strchr strcmp strcpy strcspn strdup strecpy string strings strlen strncat strncmp strncpy strpbrk strrchr strspn strstr strtok substring sys text token tokens track truncating u.h unsigned utf varies writes written strcat	2/strcat
 addition address addresses agents alias aliases aliasmail appends based box cmd compatibility dead.letter decision deliver delivery determines directly disposes error exactly execute expect faces file files filter fork full handling implies input lib lists log login mail mailaddr mailbox mailers marshal message mlmgr namefiles names nedmail option options personal pipe preparers prints protocol provide purely qer queue queues reads recipient recipient's refers remote reply report returns rewrite routing rules run send sender smtp smtpd source src standard suppresses sys text timestamp undeliverable unmailable upas upasfs user username via ways send	8/send
 addition address alphabetic alphasubpage anchor appearance appearing applies arcana associates author backslash br braces briggs characters chunk chunks code commas concise consecutively control controls creates cross cs.virginia.edu curly default defaults defined defines definition definitions describes documentation don't e.g environment equivalent exist expanding extend externalindex fi filter finally font footnotes former fragments gazillion generated generates hanson hideunuseddefs href html http hyperidents hyperlink hyperlinked hyperquotedidents hyperref hypertext identifier identifiers ifhtml implies include index indicator internet knuth l2h label latex latter lib lines link linking listed literally loaded longchunks longxref macro margin margintag markings meanings misc necessary nextchunklabel nohyperidents nohyperquotedidents noidentxref noindex nomargintag normalsize norman nosubpage nosubscriptidents nosubscriptquotedidents noweave noweb noweb.sty nowebchunks noweboptions nr numeric numsubpage nwanchorname nwanchorto omit options output package page pagestyle paragraphs preston provided quoted ramsey reference required selecting sequences sh shift short shortxref similar size sl2h smallcode source style sub subpageref subscripted subscriptidents subscripting subscriptquotedidents symbols sys tag tags tex texmf text tinker translate translates university unused url usepackage using version virginia web webcode webnumbering won't www.cs.virginia.edu noweb	6pub/noweb
 addition alpha altered anywhere arbitrary automatically ax bar bars bold braces bracket brackets bugs bx ccol ceiling center centering character characters cherry circumflex circumflexes clause cmd column comes commonly communicate complicated construction cos cpile customarily default define defined defines delim delimiters descriptions desired dest devutf diacritical digits display document dot dotdot double dyad edition embolden en enclosed entered eq eqn equation equations escapes etc existing fails fat file files filters floor font fonts fractions full gamma generally gfont globally greek grouping gsize guide hat height identical inf input int introduce italic justified justifies kernighan keywords lcol legal letters lh lib lim limits lined lines lineup log lower lpile macro manual mark marks mathematical mathematics matrices matrix necessary neither newlines nor numbering occur operators option optional ossanna output packages parens permits pile piles postscript prefix prepares preprocessor prime produced produces programmer's quote quotes rcol reads recognized redefined reduced replaced replacement represents research results roman roots rpile run shorthands sin size sizes source space spaces spacing speaking spelled sqrt square src standard strings sub subscripts successive sum sup superscripts sys tabs tbl tenth text thereafter tilde tildes token tokens troff tutf typeset typesetter typesetting unix untouched upper usage user's vec vertical vertically volume whenever xy yields eqn	1/eqn
 addition alphabetic alternative awk buffer care character characters cmd confuse converse copied count counted default defined dev diagnostics discovered distinctions don't easy ed ell enclose entire error exit expression expressions file files folds grep headers ignore implementation include input interpretation letters lines literal lower lowest mark match matched matching metacharacters names newline non null occurs option options original output parsing pattern patterns precedence print printed produce quotes regexp regular rest return reverse safest sam search searches sed selected shell soon source specify src standard status substitute sys tagged tagging tags treat using write grep	1/grep
 additional alone assumes authenticate blocks byte cache cachesize channel checksum clients cmd communication compared compressed concatenated consist create created data debugging default descriptors device disv embedded enables entire file files flash integrity interprets location maximum member memory mesgsize message mkpaqfs mount mounted mounting mtpt option output paq paqfile paqfs paqfs.c parsed persistent pipe plan post read rom sha1 size source src stand stderr storage stored sufficient sys typically various verify paqfs	4/paqfs
 additional appended arena arenas assigned collection comments component components configuration consists constitute contains copied described disk disks enumerates file fmtarenas fmtindex fmtisect formatted formatting index indicated internally isect isect0 isect1 lines location main names particular partition reside sample section sections server started tmp typically using various venti venti.conf venti.conf	6/venti.conf
 addr address affirmative alternate announced announces args authentication authsrv aux bin bind bit box bucket bytes chargen check cmd concatenating connection consume convention cpu daemon default delivery device dial directory dns echo env environment executable executed executes execution file files flag forgoing ftp ident il il17005 il17007 il17008 il17009 il17013 il17031 il19 il565 il566 il7 il9 imap4rev1 inbound incoming inferno's intended invoking lib lightweight listen listen.c listen1 listen1.c listener listening listens log logging looks lp mail mirror modeled names namespace negotiation neither net network none nor option output personal piece plan pop3 port protocol ramfs rc received remote report reports requests rlogin root run running scripts secure securenet serve server serves service.auth services source sources space src srvdir standard started subtree suppresses sys sysname systems tcp tcp110 tcp113 tcp143 tcp17005 tcp17007 tcp17009 tcp17013 tcp19 tcp21 tcp23 tcp25 tcp513 tcp515 tcp53 tcp564 tcp565 tcp566 tcp567 tcp7 tcp9 tcp993 telnet terminal ticket tlssrvtunnel tree trustsrvdir tv typically unix user using verbose listen	8/listen
 addr allocate allocated allocating allow altered applies arbitrarily arglist atof bbuffered beof bfildes bflush bgetc bgetd bgetrune binit binits bio bio.h biobuf biobufhdr bits blanks blinelen boffset bopen bp bprint bputc bputrune brdline brdstr bread bseek bsize bterm buf buffer buffered bugs bungetc bungetrune bungetsize bvprint bwrite byte bytes cases char character characters charstod closed cost creates data declaration delim delimited delimiter descriptor descriptors diagnostics double error errstr except excluding exit exits fast fd file floating flushes format formatted freed full implement include independent initializes input int integer integers interchangeably interface issues length libbio libc.h longer low malloc maximum memory mode nbytes negative non nul nulldelim occur occurred offset opened opens oread output outputs overwritten owrite parameter pointer print processed read reading reads ready recent related reread return returned returns routine routines rune seek sidesteps size skipping source src standard stored stream string strings struct success successful sys tabs takes terminal type typedef types u.h uchar unlike user utf va_list value variadic vlong void write writing written yield bio	2/bio
 address addresses appeared arrange articles automatically cmd core create currency current daemon dead.letter file files gets header invoked item items lib list mail mailed mails modify names news news.c newstime options particular post print printing prints read reading receive recent recorded regardless registering report select source src subscribers sys time news	1/news
 address addresses ascii asterisk blank buffer bugs byte bytes characters cmd concatenates db decimal default don't dump dumps endian escape file files flush format formats groups hex hexadecimal identical input octal offset option options output padded pairs prefixed print printed printing properly repeating representations reverse sequences size sizes source src standard style styles swab sys telling unbuffered units various xd xd.c xd	1/xd
 address addresses cmd connection connections databases default device errors files interface ip ipconfig listing looks masl mounted mtu names net netmtpt netstat netstat.c network option packets port print prints remote reports source src summarize symbolic sys translate user netstat	1/netstat
 address appending attribute attributes bin bl011 bl011273 book chosen cmd codes comma contains criteria customarily database declared department differences digits directory domain e.g email emlin employee's ends entries entry everyone exactly explicitly fails files flags fuller g.r.emlin grace grace.emlin grep id ignore implies inferred initials internet iwhois key letters lib location looks lucent match matches middle miscellaneous mix multiline names nic's option optionally org organization personnel phone post ppq ppq.c prefix prefixed private proper rc research returns roosevelt search searches server server's source src string surname sys tel telephone title userids users using value tel	1/tel
 address bugs cmd connected data default directory display file files flag il inaccurate includes names namespace net network ns ns.c output pid principle printed prints proc process produced ps rc reading recreate reformatting renamed replacing represent representation rewrites rewriting script source space src suppresses sys ns	1/ns
 addresses alias aliases aliasmail appending arg backslash cmd comment consulted continued domain expand expands expansion faces file files filter fromfiles invoked items lib listed mail marshal mlmgr namefiles names nedmail option printed qer rest rewrite rule searched send smtp source space src sys upas upasfs wide aliasmail	8/aliasmail
 adds adjacent algorithm appending archive becoming bigger block bugs bunzip2 burrows bytes bz2 bzip2 category central cisttvd cmd compress compressed compression compromise contained convert converted converting created creating cttvd cvd data debugging decompressed default deflate descriptive directory directory's encodes ends error expand extension extract extracted extracting extracts fails fall faulty file files gunzip gz gzip huffman hybrid implies interface lempel level list looks lower matching minimal mode modification modified names none options original output path places prints process produce programs recent recognizes recursively removed removes resulting results reverses scheme seeking similar size smaller sorting source speed src standard streaming stripping subdirectories suffix synonym sys taking tar tar.bz2 tar.gz tbz tbz2 tgz time tuned uncompressed unzip vd wheeler write zip zipfile ziv gzip	1/gzip
 adds adm allows alone applications ascii ask assumed attach attaches attacks attribute auth auth.h authac authas authchal authenticate authenticated authenticating authentication authenticator autherr authok authorize authpass authsrv authtc authtp authtreq authts base becomes belonging bind bit bootes boots box byte calling challenge chc checks chs client client's client→server common con confirm connection connections cons constants contains converted convince correct count cpu created daemon daemon→as data database databases decrypts defined definitions des describe describes descriptions details dev dhcpd displays dns domain encrypted encryptor encrypts entry error except exchanged execution exists expected exportfs fauth file files finally foiling ftp ftpfs generated goal guaranteed guarantees hash hexadecimal holds host host's hostid id idc identifies identify identifying identities identity ids incremented indicates internet intervention kc kernel key keys kn ks lib list lived login machine machine's machines maintain manual matches meaningful message messages mixed mount mounts ndb network non nonce null nullx operator originated outlined owner page pairs particular passes passing passtokey password personal plan players plus process processes prompted protocol protocols provides ram random rattach reads reboot reduce relayed relays remembered remote replay replies reply request require response responsible returned returns rsession running rx saved saving screen secret semantics sends sent server server's servers server→userproc services session sessions share situations speak stand stolen stored string sys tattach telnet terminal terminal's ticket tickets time tsession types uid uidc uids unique user user's userproc userproc→as userproc→server users using valid validates validity validly value values volatile whenever writes written xxx authsrv	6/authsrv
 adjacent adm backwards bootesdump check ches cmd current date dates debugging diff dump dumpfilesystem edt enables exists file files filesystem finally fs gmt history.c logged looking main modifier names nb option output pair print printed printout prints produces recent run runs selects sizes source src stored sys time times tmp tree user users usr ut vdu verbose versions yesterday yyyymmdd history	1/history
 adjacent args array break breaks bytes char characters contains defining delimiter delimiters delims exactly except fields getfields gettokens handling include int libc libc.h manner maxargs multiflag non null overwritten places pointers port processed quote quoted quotes rc related returns software source src str strcat string strtok sys tokenize tokenize.c tokens u.h using utf getfields	2/getfields
 adjacent blanks bugs characters cmd comparing comparison compatible copies copy count defined duplicated fields file implies input lines neighbors non num output prefix print removed repeated repetition report selection skipped sort source space spaces src standard string succeeding sys tab tabs udc uniq uniq.c unique uniq	1/uniq
 adjoint affine aligned allocated angle apex arbitrary arith3 aspect ax axes axial axis bottom calling can't centered central clipping coefficients cofactors contains coordinate coordinates copy corner creates creating cube cz data define described describing determinant difference directions discards displacement divides double draw.h dual dx dy equal equation euclidean eye factors fit fov frustum geometric geometry.h homogeneous ident identity implicit include increasing indicating infinity inside int inv inverse invertmat ixform libgeometry lower madj manipulate mapped maps matmul matmulr matrices matrix matrix's matrix.c max min minv modify move moved newly nominally non null origin outside pair parent persp perspective pixels plane planes point3 point3s pointed pointer pointing points popmat positive priori projective pushmat qrot quaternion radians ratio recomputing rectangle remaining represent representation represents rest returning returns root rot rotated rotates rotation routines save scale scales screen singular slop source space spaces src stack stored stores struct structure structures sys theta times tinv transform transformation transformations transformed transforms translates tree typedef unchanged unit vectors view viewed viewport viewport's void window window's xaxis xform xformplane xformpoint xformpointd yaxis zaxis matrix	2/matrix
 adjust align aligned allbox alphabetic becomes bedminster bernards bernardsville block box center centered centering character cherry cmd column columns consisting contains continue continues copied current data decimal default delim delimiters describe describes doctype double doublebox draw draws edition enclose ens eqn equalize except expand extend fb fi file files font format formatted formatting gap genuine horizontal household households indented inferred input integer integers item items justify key keys lay length lesk letters lines linesize lower manual mean minimize modifiers nroff numeric obligatory optional options output parens pipeline pipes population pp preprocessor programmer's range reads recognize recognized relative remainder repeat replaced represent requests research row rows rule rules segments semicolon separately signed size source sp3 spacing span spanned specification src standard sys tab table tables tabs tb tbl te tenth text town troff ts twp type typed unix upper vertical vertically volume wide widest width widths xy tbl	1/tbl
 adjust applied ascent attach bit bits bitwise bottom bugs but1 but2 button buttons cachechars cancel canceled char character character's click clicking cmd column complain coordinate copy covered create cross cursor default defined depth described desired digit display displayed displays edit edited edits encloses entire entry etc existing exit file files fit folded font fonts forms global graphics gunsight height hex hexadecimal holding image image's images includes indicated invert inverted iwidth leave lines mag magnification magnified magnify menu methods mode modified modify mouse move multi necessary negation obtain offset ones operation optionally original parameters performed physical pixel pixels portion portions presenting presents pressed pressing prompt prompts pushed quit read reads rectangle report representing reread resulting rio rune screen select selection shows smaller source src stored subfont subfont's sweep sweeping switch switching sys tables text textual tilde transfer tweak tweak's tweak.c type typed types typically typing unmagnified unreasonably unwritten val value values variety various vertical view views wide width window write written tweak	1/tweak
 adjusted allow approximation assumed capability character characters cmd comma consisting count dasi default deroff dest devices diablo dir directory doctype driving edition encoded encoding eqn equally exhausted file files final font formats formatting full generated grap halt handle horizontal hp hyterm image include input invoke kernighan lib lines linotron list loading lp macro manual mergenthaler minus mode model ms names nominal nroff option options ossanna output page pages paper pic plan postscript prepare preprocessing print printable printer printers printing prior process produce produces programmer's proof range ranges rd read reduce register regular request research resolution results send settings simultaneous source spaced spacing speed src standard suitable sys tab tables tabs tbl teletype temporary tenth term terminal tex text textual thinkjet tmac tmp tpost troff trtmp tutf tutorial typesetter typesetting typewriter unicode unix user's using utf volume width widths xx troff	1/troff
 adjusted alphabetic appended applying approximate arc ashed automatically backslash basic becomes blanks blue bo box brackets ca cdash center centered cf cfill character characters ci circle circular cl clockwise closely co color commas comments connected controlling coordinates corner counterclockwise csp current cyan data ddash de default define defined delimited designated device devices di disc display displayable dotd dott double draw drawing drawn draws dsp dx dy ed elliptical enclosed ending endpoint endpoints environment escaped exact exactly except executed extra faces fall fi file filename files fill filling filters fit floating format fr fraction frame fsp graph graphics green guided holes include inherits inner instruction instructions interface inverts invoke joining kblack leading letters levels li limit lines lower lsp magenta magnified marks mean midpoint move needed negative newline newlines nonsquare numeric output outside par parabola parabolic parameters passes pe pen plot plots plotting poi points pol polygon polygons positive preserve punctuation px1 px2 py1 py2 quadrant quote ra radius range re read red reduced remain repeated requires rest restore rm rmove run rv rvec sa save sb scale scaling screen separator settings short size solid sp spaces specifies specify spill spline square stream string strings style styles supported tabs tangent troff unity upper using utf valid vec vector vertex vertices x,y xc xg xm xn yc yellow yg ym yn plot	6/plot
 adjustments adm analog aug cdt clock clock.c cmd conversion convert copied ctime current date date.c default depends directory draws env environment epoch file files format gmt greenwich init january mean option optional options print real report seconds source src sys tables time timezone tue variable window date	1/date
 adler adler32 algorithm allocates amount bit block blockcrc blocks buf buffer butes byte bytes calling char checksum complementation compress compressed compresses compressing compression compromise computation conditions converting converts count crc cryptic data debug debugging decompress defined deflate deflateblock deflateinit deflatezlib deflatezlibblock dsize dst error fail fewer files flate flate.h flatecorrupted flateerr flateinputfail flateinternal flatenomem flateok flateoutputfail getr gzip header higher include inclusive indicates indicating inflate inflateblock inflateinit inflatezlib inflatezlibblock initializes initially input int interface level levels libc.h libflate malloc memory message mkcrctab negative non ones operate output outputs poly polynomial post pre printable process produce produced rapid read requested retrieved return returned returning returns reverses routines rr seeing signaled similar smaller source src ssize standard succeed successful sys tab table time trailer u.h uchar ulong uncompressed update updates using valid value values void wr write writing written zip zlib flate	2/flate
 adm adm.users aprvxu arch archive archived assuming block bytes cmd contains copied copies copy copying correspond created date dates default destination directories directory disk dist entire establish exist extracted fields file files format fs gid headers il initializing intermediate kfs kfscmd list load missing mkext mkext.c mkfs mkfs.c modification mount mounted moved names newfs onto option options output owners pass path permissions permitted prep print prints producing proto read reenable removed restores root rooted sd serve setting sizes source specifies src srv standard subdirectories suitable suppresses sys temporary times tree uid unpack unpacked unpacking unpacks update updated users valued write writes writing mkfs	8/mkfs
 adm attach characters comma console convention decimal defines duplicate excluding file format groups integer internally intro leader lines list maintain member names negative num owned permanent printable private protected server servers stat strings user users via write users	6/users
 adm bin current everyone exiting looks machine non person prints process rc source users using whois who	1/who
 administration describes intro introduction invoked manual necessary programs routinely section user utility various 0intro	8/0intro
 administrative automatic based bin boot boots boottime bring compilation configuration cpu cpurc cputype daemons edited enable env environment execs executable execute executed exists file files init initialization installations invokes kernel lib listen machine mk mouse namespace network none nproc parallel pc processes rc reflect root script scripts source specific srv suitable suppressed swapping sys sysconfig sysname systems terminal termrc time user value values variable vga cpurc	8/cpurc
 administrative behaves cat cmd copies copy cp cp.c diagnostics dir directories directory equivalent except existing exists file file1 file2 files gux id mode modified move moves mv mv.c names onto option original owner plain preserved refuse refuses rename renamed rm server source src stat sys time user cp	1/cp
 advance bugs cmd decimal default effective equalize exponential floating format incr increments infinite integer integers leading lines near necessary nor notation option options padding painful print printed printing prints seq seq.c sequences source src style surveys sys value values widths seq	1/seq
 advanced aes aesbsize aescbcdecrypt aescbcencrypt aesstate block blowfish bytes chaining ciper cipher cryptographically des dsa elgamal encryption implement include initialization int ivec key keybytes libc.h libsec libsec.h mp mp.h preferred prime rand random rc4 replaced reused rijndael rsa sechash setupaesstate source src standard strongly sys u.h uchar unlikely unpredictable vector void aes	2/aes
 aes aid algorithm allocated asn1 asn1torsapriv binary bit blowfish caller calling cert certificate certificate's certificates chains char check checks cn computing conventionally convert converting converts copy crt data dec64 decoded decodepem decodes decryption decrypts default des distinguished dk dns dsa ek elen elgamal encrypting encryption enhanced error exp exponent fingerprint format formatted generated host include int key keys kp kq latter len length libc.h libsec libsec.h mail miller mod modulus mp mp.h mpint ncert newly nil nlen nname npriv nrep owner pem pk precomputed primality prime priv privacy private provided pub publishes rabin rand rc4 repetitions residues returns rounds routine routines rsa rsaalloc rsadecrypt rsaencrypt rsafree rsagen rsapriv rsaprivalloc rsaprivfree rsaprivtopub rsapub rsapuballoc rsapubfree run sechash section sent sha1 signature signed source src step stored string struct structure subject successful sys table takes test trusted type u.h uchar undefined user userid using values verification void x509torsapub x509verify rsa	2/rsa
 aes algorithm allocated alpha approved blowfish copied copy created decryption des digital divides dsa dsagen dsaprimes dsapriv dsaprivalloc dsaprivfree dsaprivtopub dsapub dsapuballoc dsapubfree dsasig dsasigalloc dsasigfree dsasign dsaverify generated generator include int key keys libc.h libsec libsec.h manage message mod modulus mp mp.h mpint newly nil nist opub owner prime private provided pub publishes rand rc4 returns routines rsa sechash secret sig signature signatures signs source src storage struct sys u.h using valid verifying void yielding dsa	2/dsa
 aes algorithm allocated alpha bit blowfish copy data decryption decrypts default des dsa egdecrypt egencrypt eggen egpriv egprivalloc egprivfree egprivtopub egpub egpuballoc egpubfree egsig egsigalloc egsigfree egsign egverify elgamal encrypting encryption generated generator include int key keys latter length libc.h libsec libsec.h manage message miller mod modulus mp mp.h mpint newly nlen nrep owner primality prime private provided pub publishes rabin rand rc4 repetitions returns rounds routines rsa run sechash secret sent sig signature signs source src storage struct sys takes test u.h using valid void yielding elgamal	2/elgamal
 aes algorithms anyone blowfish bounded buf buffer buffers chain char check constants copy cryptographically data define des differ differently difficult digest digests digeststate dlen drowssap elgamal fd hash hashed hashes hmac_md5 hmac_sha1 include integrity key keyed klen len length lengths libc.h libsec libsec.h malloc marshal md4 md4dlen md5 md5dlen md5pickle md5state md5unpickle mp.h newly nil non object output parameter password pickled pointer possessing predict produced rc4 read rehashing require resulting return returns routine routines rsa sechash secret secure security sha1 sha1dlen sha1pickle sha1unpickle size slightly source src support sys therefore transmission u.h uchar ulong unmarshal usage using ym sechash	2/sechash
 aes bfcbcdecrypt bfcbcencrypt bfecbdecrypt bfecbencrypt bfstate bits block blowfish bruce buffer bytes cbc cipher data decryption des dsa ecb eight elgamal encryption include initialization int ivec key keybytes keys len length libc.h libsec libsec.h modes mp mp.h nil padding prime rand rc4 rsa schneier's sechash setupbfstate size source src structure supported supports symmetric sys takes u.h uchar unsupported variable vector void zeroes blowfish	2/blowfish
 affect assumed binary blanks character cmd collating compare comparison comparisons comprises consults decimal default df dfnixt dfnt diagnostics dictionary digits directory entire equal exact exactly exit file files fold grep input interactive key letters lib lines list look.c lower match matches minus missing numeric opened optional options participate print prints recognized search sign sort sorted source src standard status string strings sys tab tabs takes terminates upper look	1/look
 affect attach bind bugs cat cmd cons continuous data date delivered dev device devices direction doesn't echo edt eof established exit exits file files filter filters flag hello insert intended interpose interposes level managed mode model mouse oct opened opens option ordwr pair peculiar pipefile pipefile.c pipes plain process programs rc read repaired rewritten run simulate simulated source space specify src subsequently sys terminal thu tr twice unaffected unusable user using written pipefile	1/pipefile
 affected applied applies associate assumes bind carries chdir client constant create current descend despite difference directory discussion dot elementwise entry equal equivalent evaluate exec existing failed fcall fid file files final full generated greater hierarchy identified illegal implementation implicit implied imposes index intro legal limit locally maximum maxwelem message messages mount names newfid nwname nwqid obvious opened packed parent path permission points preceding proposed protocol qid qids reached remove represent represents request requested rerror rest restriction restrictions results return returned root rwalk search server servers session simplify sixteen size stat succeed successful successfully successive tag therefore transmitted traversing twalk unaffected unless unmount user using valid value visited walk walked walking walks wishes wname wstat walk	5/walk
 affixes basename basename.c cmd component contains deletes directory ending file final newline option output prefix printed prints slash source src standard string strip suffix sys basename	1/basename
 afv arena arenas attempt attempts check checkarenas cmd conditions contained data detects entire error errors examined examines file fix increase integrity omitted option optionally output scan section source src sys various venti verbosity checkarenas	8/checkarenas
 alef apparent arabic archive armenian ascii assembler attempt audio bengali binary blocks box bugs character chinese classification classify classifying cmd code compressed content cpio cyrillic data decides decimal describing determine devanagari device devices directory dvi encrypted english etc executable extended fails fax file file.c files filled flag font format georgian gif greek gujarati gurmukhi hebrew holding image include input japanese kannada korean language lao latin looks mail malayalam mime mistakes object oriya output outputs pac performed performs plan postscript purpose rc script series sh source specification src standard subfont subtype symbol sys table tamil telugu tests tex text thai tibetan troff type types unicode utf various file	1/file
 algorithm algorithms algs allows analogue architecture args auth authentication authenticator authsrv automatically aware bin bindings binds bound bugs built challenge clear cmd coalesce comes comprise connecting connection connections cons cpu cpu.c cputype current data default dependent details dev directory domain encrypt encryption environment error except executed exits exportfs fast file files filter flag fragments full goes hash hashing host incoming input inserts interaction invoked invoking keyboard lib listen locations log machine mechanism mechanisms method mnt mounted mounts netkey objtype older option output packet packets passwd paths plan possibilities profile protection quoted rc rc4_256 receive reflect reflected remainder remote required resources response rio root run running script server server's servers sha1 shell source space specifies specify src ssl standard starts stream sys talk tcp term terminal type user using usr variable variables versions via wants window working cpu	1/cpu
 algorithm algorithms bad bit blocks byte calculates checksum cmd cmp communicated computes count data default described determine digest digit file files fips hash hex hexadecimal inc input institute length machines md5 md5sum md5sum.c message options print prints pub quick rfc1321 rsa secure security sha1 sha1sum sha1sum.c source spots src standard standards sum sum.c summed summing sys technology transmission typically v's validate wc sum	1/sum
 algorithm array ascii auth.h authentication binary block broken buffer bugs byte bytes copied data decimal decrypt decrypted decryption defined des deskeylen diagnostics digit digits encrypt encrypted encryption encrypts fail fails fewer fill formatted full hexadecimal implementation include int invalid inverse key len libc libc.h longer method netcrypt numeric perform performs points port preceding prefixed remain remaining repeated return routines securenet source src string sys u.h unencrypted unsuitable usual value void encrypt	2/encrypt
 algorithms aspect bit bugs cmd compressed correct crop decimated default described dimension exist faster file format iconv image implementation input interpolated kaiser options original output percent percentage picture pictures pixel pixels plan preserve produces r8g8b8 ratio reduce resample resample.c resampled resamples scaled sign size source specifies src standard suffixed sys unadorned uncompress using value window resample	1/resample
 aligning apply balance blanks cat character characters cmd column columns date default double ensure feeds file files headed header input length lines listing lp margin missing multi numeric odd offset option options output pad page pages positions pr pr.c print printed printers printing prints produce produces replace reset sequences sided simultaneously source space spaces src standard stops sys tab tabs text trailer using width pr	1/pr
 allocated allocimage allocsubfont allows alone analogous application applications approximately arrangement array ascenders ascent ascii bit bitmap briefly cache cachechars cached caching calling cfname char character characters class comes components comprises constructs contains convention default depth descenders described describes descriptions descriptor device diagnostics display dolock draw draw.h drawn dst elided encoded environments error etc exists extension external failure fd fields file files finally fname font fontchar fonts format frees freesbufont freesubfont graphics greek header height hold holding identify image images include info initialized installsubfont int intended interface internal kept kernels latin1 letters lib libc.h libdraw library loaded locate lookupsubfont lower malloc manipulation maps maximum memory min mkfont names naming nil operating oriented partially pixels pointer primitives principally processes provide q.v range read reads readsubfont readsubfonti registered removes resolved returned returns routine run rune runes scheme searches shared size source specifies src stand stores str string stringsubfont strsubfontwidth structure subffree subfont subfontname subfonts substituted suitable synchronize sys takes threaded time tree typically u.h underlying uninstallsubfont version void width writeimage writes writesubfont zeroed subfont	2/subfont
 allocated appends appropriately arrive assumes attr attribute buf byte bytes caller char character characters complete components contains converting converts copy count data deletes descriptor diagnostics dst enables encodes eplumb equal error errstr event exists fails fd file format formats frees header include int interface inverse key length libc.h libplumb list literal location malloc manipulate message messages mode morep ndata newline nil np null occur omode op opens original owrite permit pieces plumb plumb.h plumbaddattr plumbattr plumbattra plumbdelattr plumber plumbfree plumblookup plumbmsg plumbopen plumbpack plumbpackattr plumbrecv plumbsend plumbsendtext plumbunpack plumbunpackattr plumbunpackpartial points port processing programs quote quoted read recall receipt received receiving registers remaining reports resulting return returned returning returns routine routines searches sections send setting signs simplified slash source space src string strlen struct structures sufficient sys terminate text therefore total translating transmitting type typedef u.h unpack unpacked unpacking using value version void wdir writes plumb	2/plumb
 allocated array beyond bugs bytes char character characters chars compiled compiles context correspond corresponds counting delimited dest detected diagnostics digit dlen entry ep error exactly except exits exp expression expressions extended failure fields file filled fills fit generated grep illegal include instance int involving libc.h libregexp literally malloc match matched matches matching metacharacter msg msize newlines nul null nuls parenthesis parenthesized patterns perform performed pick places pointer pointers points preceding processing prog regcomp regcomplit regcompnl regerror regexec regexp regexp.h regsub regular released rep replaced reprog resub return returns routines rregexec rregsub rsp rune runes source sp space specify src standard starts string strings struct structure subexpression subexpressions substitution substring substrings sys terminate th trimmed typedef u.h union unused user using variants void whenever writes regexp	2/regexp
 allocates atomic attach becomes bind boundaries buffer byte bytes channel channels comes communication connected contiguous control cross ctl ctl1 data data1 delivered descriptors device devpipe.c dir file files full guaranteed interprocess mode ordwr performs piece pipe pipe's port preserved provided read readers reading receiving recipient return returns size source src stream streams sys terminates typically whichever write writers writes written pipe	3/pipe
 allocimage alpha backward base bit bits blank block blocks blue bottom byte byte's bytes care chan channel channels character characters code color comfortably comma compressed compression comprising confused consists contains contiguous coordinate coordinates copied copy correspond current cursor cursors data deal decimal deduce deep define defines definition deprecated depth described describing descriptions descriptors design details directly discussion divisor don't draw draw.h eight encode encoded encoding error external faces file files fine fit font fonts format formats graphics greater green greyscale header hexadecimal identical image image's images include inclusion independent indicates input integral jacm jpg justified laid larger ldepth lempel length lengths letter limit literal loadimage logarithm longs low lz77 machine mapped memdraw memory message mod numbered occurring offset offsets ordering overlap padded pair particular pixel pixel's pixels pp prescient previously processed programs r.max.x r.max.y r.min.x r.min.y r8g8b8 read readimage readmemimage reads rectangle red reflect replaces represents requires rest row rows scan scheme seemail separately shorts size sizes sliding software source starts stored storer stream string strings strtochan subfonts substitution substring substrings suitable sum szymanski takes text textual textually tweak twelve uncompressed unloadimage unused user using usual value values variable venerable version via wide width window works writeimage writememimage written ziv's image	6/image
 allocimage alpha bit bits blue closest cmap2rgb cmap2rgba col color colors convert decomposes defined draw draw.h format full graphics green image include index int integer intensity libc.h libdraw library low map maps memdraw plan red representation representing returns rgb2cmap rgbv routines scaled shifted source src standard sys takes trio triples u.h value values color	2/color
 allocimage bit blue button clicking cmap cmd color colormap colors colors.c components contains contrast current default define defined defining directory display display's displays entry exit file files finally floating gamma getmap green grey grid hardware hexadecimal index lib listed loads map mapped menu monochrome mouse names option presents ramp red repository reverse rgamma rgbv scale screen showing shows similarly source src standard stored string synonyms sys value vga video colors	1/colors
 allow approximately bind bytedelay bytes clear connected connection contains control controlled cross ctl data delay device devloopback.c directories directory disallow divided drop dropped droprate due exit file files flow format hold indrop input interface latency limit link links list loopback machine monitor nanoseconds net network options output overflows packet packets parameters permitting port queue queues randomly readable reading receive receiver receiving recorded reported representing reset returns send sent simulated simulation size source src statistics stats status subdirectories supply supported sys tagged takes time transferred typically writes writing written loopback	3/loopback
 allow asks client clunk consider correct directory entry fail fails fid file generated messages parent permission permissions points remove removing request rremove server size tag tremove write remove	5/remove
 allow authenticate behalf bind bytes cap capabilities capability caphash capuse characters computes concatenation cons consisting create dev devcap.c device diagnostics dir doesn't enables error errors errstr executing factotum freeing generated generates hash hashes hmac_sha1 host hostowner id identity indeed intent invalid ipserv kernel key length list maintains match matching minute nil null obtained old_at_new owner pass port process process's processes proved randomly read reading running searches sechash secure server setting source src string strlen sys telnetd trusted user using write writing cap	3/cap
 allow bin broke broken caught ctl current debugger default delivered dies error examination execute executing file handed heavy ignoring kill lets linger message necessary note notes notify offending output owned pipe print printed prints proc process process's processes ps rc reclaim resources rio send sending slay source stop suggests surer user kill	1/kill
 allows appended ar archive archiver ask behavior bugs bundle cd characters cmd concepts contained contains copy create current default details directories directory dumped entire entries extract extracted extracting file files foreign format fromdir hierarchies i.e id ignore implies input key keys latest leading letter letters limited links list mode modes modified modifiers modifies moving names non numeric occurrence occurrences optional output path plan plus print recursively relative restored restores saves slash source specification src standard string subdirectories symbolic sys tapefs tar tar.c time todir transport tree trees user verbose wins xt tar	1/tar
 allows arbitrary bit bottommost bounds button character clear cmd convert current debug desired dir displayed doubles entirety everything file files flag font fonts goes gs hold input intermediate interpreter item kernighan keyboard language lib location lp mag magnification manual map menu missing mouse move moving names nearer negative newline nview offset options ossanna output page pages pan pans pauses piece pieces pixels positioning press print printed proof quit reads redisplayed released resulting rightmost screen selecting shown shrinks signed simulates size slightly source split src standard sys text toggle troff typed user's val wait window proof	1/proof
 alone assumes authenticate based block channel clients cmd communication compressed create created default descriptors device disk file flag flash infd interprets member mksacfs mounted mountpoint mounts neither nor outfd persistent plan post rom sacfs sacfs.c source src stand storage stored sys typically sacfs	4/sacfs
 alphabet's ambiguity appearance ascii ascii.c avoid base character characters cmd codes contains control conversion convert converted converting converts current decimal default descriptions encoding extensions file files flag font forces goes greek hex hexadecimal hexmax hexmin included insert interpret iso latin lib lower mathematical miscellaneous mnemonics nct newlines nt numeric octal opposite option options output oxdb print printed prints range representations running settable similar sorted source specially specifies src standard string suitable symbols sys table tcs text translates treats unhelpful unicode unicode.c unless unlike utf valid value values versa vice ascii	1/ascii
 alphabetic analogously ascii cases character characters classes conversion ctype defined defines examine explanatory include int isalpharune islowerrune isspacerune istitlerune isupperrune libc libc.h lower modify names operate particular port properties return routines rune runetype.c self source specifies src standard subset sys test title tolowerrune totitlerune toupperrune types u.h unchanged unicode upper isalpharune	2/isalpharune
 alphabetics ascii bit cds character characters cmd code codes combination complement copies create cs delete deletion digits duplicating file1 file2 hexadecimal input length letters lexicographically list lower mapped maximal mixed newline noninitial occur octal options ordered output padded possibly quoted range repeated replace runes running sed selected short source squeeze src standard stands string string1 string2 substitution successor sys tr tr.c translate upper value za tr	1/tr
 alphanumeric ampersands apostrophes attachments backslash bugs chaos characters cmd complete consider constructions constructs definition definitions delatex delatex.c deletions delimiters deroff deroff.c digits documents embedded emitted eqn etc execution file files filters formatting ignore included input inside interpreters latex letter letters list lists macro macros mentioned ml mm ms non nroff nx option options ordinary original output pic popular preprocessors properly punctuation reads remaining remove removes requests skipped source spell src standard string sys tbl terminates tex text titles troff underscores wi written deroff	1/deroff
 alternative applications ascending awk bounds bracketed character characters charclass class commonly concatenated delimiter ed expression expressions extends grep inclusive instances literal match matched matches member metacharacter metacharacters negated newline non nonempty notation operators preceding preventing range regexp regular remainder rep rune sam sed specification specifies stands string strings substring syntax unescaped regexp	6/regexp
 amount asc ascq atapi attempt attempts bit bring bytes changetime char closes closescsi cmd codes commonly connection consulted consulting current data debugging denoted descriptor detected devdir device device's dir disk.h drive error errstr execute fail fails failure fair fields file files frees harder include inconsistent inquire inquiry inserted int interface issued issues lib libc.h libdisk list maintained media messages nchange ncmd ndata obtain openscsi operation operations output overwritten produce provide raw rawfd reads ready record request responds return returned returning returns routine routines scsi scsi.c scsicmd scsicodes scsierror scsiready scsiverbose scuzz sd send sends simply snone source src sread status store stored stores string struct structure success successful swrite sys textual time times transmitted tries try typedef u.h uchar ulong unit via void works written scsi	2/scsi
 analogous arrived beyond byte bytes char chartorune chr coded complete considered contains conversion convert copied copies count decoded defined differs encoding es1 exactly format full fullrune guarantee include includes incompletely input int legal length libc libc.h maximum none nul null obtain occur occurrence original pointed pointer port programs represent required return returned returns routine routines rune rune.c runelen runenlen runes runetochar sequences source src str stream string substituted substring sys tcs time u.h utf utfecpy utflen utfmax utfnlen utfrrune utfrune utfrune.c utfutf writes rune	2/rune
 analogues bugs es1 implementations include int libc libc.h memory moves operations outcome overlapping port rune runestrcat runestrchr runestrcmp runestrcpy runestrdup runestrecpy runestrlen runestrncat runestrncmp runestrncpy runestrrchr runestrstr source src strcat string sys u.h varies runestrcat	2/runestrcat
 aname attach auth automatically bind binds bound channel character characters client console conventional dev device device's devices driver equivalents error file files flush identified identifies implements includes init intro introduction ip kernel lib list locations looks ls messages mrepl names namespace newns nop pages parameter particular performs plan pound procedure processes protect protocol provided quotes rc remote representing root section sections server session sign space stack string subroutine tree typed using valid 0intro	3/0intro
 anchors annotated annotations bugs cases complex confused constructions convert converts cp create default depends described documents don't easily eqn etc experimental file files handle helped helper html httpd improve indented independent input interpolated introduced invoked lines macro macros magic main man2html manhtml manref mesh models modulo ms ms2html output package pages pair paragraphs pic placing pointing preprocessors produced properties reads recognized reliable rest reverse served shows specially standard straight subsume time title tolerable troff troff2html understands x'html troff2html	1/troff2html
 aphorism automatically chosen cmd fast file files fortune fortune.c fortunes fortunes.index games lib lines lookup maintained prints random sample saying selected source src sys table fortune	1/fortune
 append architecture architectures assemble assembler assembler's assemblers character cmd common correspondence default dependent directives directory etc file files handle include input ka letter machine manual obj object objtype option options output path pike plan preprocessor programs qa rob searched source specifies src strip sys va xa 2a	1/2a
 append awk cmd contained default divisions exclude excluding expression file files grep identified ignore input lines lower matched matches names occur option options output parentheses pieces portion reads regexp regular sed source split split.c src standard stem subexpression suffix sys writes xaa xab xzz split	1/split
 append cmd copies files fitting ignore input interrupts options output pipe rewriting source src standard sys tee tee.c transcribes tee	1/tee
 appending block blocksize bytes cmd combined default disk file fmtarenas fmtindex fmtisect format formats formatted formatting gigabytes index indicate kilobytes megabytes operations option options partition read reduces section sections size source src sys time typically unique units using venti write zeroed fmtisect	8/fmtisect
 applicable behavior blank char considered continues copied copy current default desired destination dir directories directory disk.h enm enumeration environment error except exist expanded explicitly extra fetch fields fifth file files formats fourth generic gid guaranteed include indentation int interprets length level lib libc.h libdisk lines listed listing message mk9660 mkfs mode msg mtime names nil opened optional override owner owning parse path permissions pointing points portproto prefix prints process processed processing proto proto.c protoenum prototype protowarn rdproto read reads recursively relative returns root setting significant source space specifies specifying src standard subdirectories sys sysconfig tabs third tree typedef typically u.h uid valid variables void warn warning wishes proto	2/proto
 applications base bind bound cd cmd constructing current directory discover dot enter fd2path final getwd guaranteed intended intro longer mechanism names newline path pbd pbd.c prints prompts pwd pwd.c rc reported return shell source space src stat sys underlying valid working pwd	1/pwd
 appropriately assumes bin bugs cat certainly cmd connect default dial dialing directory exec execnet executed execution exists hosts instance instances interface ip na net netdir network newly none ny page presents protocol remote running sh shown source src srv ssh strings sys tested tmp u9fs u9fs.log user execnet	4/execnet
 appropriately diagnostics double eptr exp exponent fractional frexp frexp.c include indirectly infinity int integer intro iptr ir ldexp libc libc.h mantissa modf overflow port positive quantity returns signed source split src stores sys u.h underflow value frexp	2/frexp
 ar archives beware bin boris bourne bugs bundle cd ch collect complete create directories distributing distribution documenting executed file files gift horse horses kremvax machine mail main makefile mk mkfile non original output postmark preparation rc receiving recreate refined related required sans save script self send shell source standard tar text unsatisfactory writes bundle	1/bundle
 arbitrary block bugs button center checkerboard cmd counting decrease default dictated digit display dragging easier freezes grid imposed increase indicate interactive interface key keyboard keys lens lens.c limit lower magnification magnified magnifier magnify mouse moves movie multiplexing pixel pixels presents pressed pressing refresh releasing rio rules screen showing snapshot source space src standing static sys toggles typing unit update upper using view window lens	1/lens
 architectures division equivalent final fit generate hold include integer integers intermediate libc.h muldiv multiplication overflowing precision returns routines scale silently trap truncate u.h ulong umuldiv unsigned using values vlong worry muldiv	2/muldiv
 arena arenas bugs cmd collection described error external extract extracted extracts file generates media option output rdarena restore source src standard sys typically venti venti.conf venti.config verbose writes rdarena	8/rdarena
 arg blanks cmd echo echo.c newline option output print source src standard suppresses sys writes echo	1/echo
 arg cmd complete elapsed error executed prof program's real reports seconds source src standard sys time time.c user time	1/time
 array arrays base buffer byte bytes char create dec16 dec32 dec64 decoded decoding display enc16 enc32 enc64 encode encoded encodefmt encoding fails fmt fmtinstall hex hexadecimal i.e include input int length libc libc.h lim mime null output port print representations return size sizeof source src string strings sys u.h u32.c u64.c uchar verbs encode	2/encode
 array base bytes compar compared comparison considered data equal greater include int integer libc libc.h nel nondecreasing pointer pointers port qsort qsort.c quicker return routine sort sorts source src sys third u.h void width qsort	2/qsort
 article articles authenticate authenticates bugs check cmd comp comp.os.plan9 compliant connection contains ctl default deleted detected determined dials directories directory directory's dots e.g echo effort entire eventually exist factotum file files follow full groups hang hangups header keepalives key largest lines list location megabyte mnt modification mount mountpoint necessary network news newsgroup newsgroups nntp nntpfs nntpfs.c nose.mit.edu note numbered numbering obtained opened option os pass password plan9 port post posted presented presents private proto protocol qid recorded redials rfc1036 root rsc secret send server servers session slashes source specifier src srv stat stored sys tcp terminate text tied time transferred transport unmount user version write written nntpfs	4/nntpfs
 ascent baseline bit blank bottom byte bytes cachechars calculate character characters chosen consistently consists contains convention covered decimal default described directories directory display distance draw entries external fields file files font fontchar fonts format glyphs graphics header height hexadecimal image include inclusive info inter irrelevant justified lib libg.h low mapped minimum names non note nul numeric octal openfont optional padded pixels plain range read readsubfont relative represent rigid slash space spacing specification specifications strings subfont subfonts suitable text using value width writesubfont written zeroth font	6/font
 ascii binary blank characters cmd consecutive continuation decimal default dots encoded extract ffff file finds hexadecimal inclusive input longer nm offset printable printing prints reports resumed runes source src standard starts string strings strings.c sys text tilde typically utf value strings	1/strings
 ascii blank broken bugs bytes characters cmd code codes count counts delimited file files includes input invalid letters lines looks lwc lwrbc maximal newline newlines occur optional options reported runes scattered selected source space spaces src standard string suboptimal syntactically sys tab tabs unicode utf wc wc.c wc	1/wc
 assembler base dependent double exp exponential hypot implementations include int intro libc libc.h log log10 logarithm machine natural objtype port portable pow pow10 returns root routines sinh source sqrt square src sys u.h written exp	2/exp
 association attr attribute bind bugs card card's chip compatible computer ctl databook dev devi82365.c device devices driver drivers ethernet included intel interface mem memory ne4100 pc pcm pcm0attr pcm0ctl pcm0mem pcm1attr pcm1ctl pcm1mem pcmcia personal plan9.ini provides ram reading reads returns routines slots source src status supports sys writes writing i82365	3/i82365
 atexit atexit.c atexitdont brief calling cancels char cleanup conventional conventionally errlen exit exiting exits explanation failed fn fork id include includes indicate int invoke length libc libc.h limit maximum memory msg null package parent pointer port prefixed process programs reached recorded records register registered registration return returns reverse routine share simplify source src string sys terminate termination twice typical u.h underlying void wait exits	2/exits
 attack denial disguise doing echo ext identity ip listen packets port received run someone testing udp udpecho udpecho	8/udpecho
 attempts bugs chmod cmd created current date default directories exist file files ls modification option source src stat sys time touch touch.c unless touch	1/touch
 attribute aux card cmd default file files identify memory output pcm0attr pcmcia pcmcia.c readable slot source src standard structure sys translates writes pcmcia	8/pcmcia
 auth authenticates authentication blank cat clock cmd commas con create cron cron.c current daemon dates entries equivalent executes execution fields files helix host hour hyphens inclusive instructions integer lib lines lists machine mail mailnews mails minute minutes month news option patterns plan profile range ranges rc reach reliable remote run running runs rx send server skips source spaces specify src string sunday syntax sys time times upas user user's valid weekday cron	8/cron
 automatic belong bin bugs cases chapter date default detail doesn't eqn except files index indices intended key lib locates lookman lower manual mechanism names nroff option options output page pages print printed prints proof rc recognize run sacrificed searched secindex section sections send serve source standard sys tbl terminals text title titles troff typeset using man	1/man
 aux berlin.de:8081 bin binary cmd defaults developer doc doc2txt document documents embedding extract extracting fat file file.doc format inside laola linking microsoft microsoft's mnt mswordstrings mswordstrings.c mtpt object ole olefs olefs.c page parses pmh presents printable rc scaled schwartz script shell snake.cs.tu source src stored stream strings structures sys text version worddocument doc2txt	1/doc2txt
 aux broken cmd connection cpu cputype default diskless file init loss minute reboot reboot.c reboots remote restart server servers source src stat stats sys times whenever reboot	8/reboot
 becomes binary blank byte bytes character characters check contains core cpu creation data debugging decimal denotes described describes descriptions disjoint dumps fd file flag format formatted fpregs guaranteed header hold humans id identification image images incomplete indicating intended justified kernel kilobyte kregs machine mem memory missing noteid ns offset omitted padded page prefix previously proc process programs quickly reading record records regs rest save section sections segment shorter size smaller snap snapshot snapshots space split status string strings text throughout time type understood unix useless user snap	6/snap
 beware blocks buffered bugs cat cat.c catenate cmd concatenates continue copies cp data default destroy diagnostics doesn't eof exactly executes exits expect file file1 file2 file3 files flag helpful input interactive lines matching nline nlines output places preparing prints programs rc read read.c reading reads scripts source src standard status sys third time write writes writing cat	1/cat
 bin code current db defined definition directory ed editor examines executable extract file files flag identifies locate looks main plumb print rc routine sam script send sent source src strcmp subdirectories symbol table using src	1/src
 bin consistent current debugged execute kill owned pipe print prints proc processes ps rc rio send source started stop stopped user stop	1/stop
 bind conventional describes file files interesting interface intro introduction maintained manner manual mounted permanent plan process processes provider provides section server servers services space storage synthesizes tree 0intro	4/0intro
 blank bugs editor emacs intentionally macros mit options page sam source vi yes emacs	1/emacs
 blanks cmd colon columns default ending file fit input lc ls mc mc.c multicolumn option positions pr print printed rio run separately source splits src sys window mc	1/mc
 blocks boot bugs channel closed cmd configured created deadlock device devices directly directory environment error establish establishes file files full kfs lead level process raw remote replaced resulting returned served source src swap swap.c swapping sys time unique user valid variable swap	8/swap
 bootstrap chgrp chgrp.c chmod cmd current file file's holding ineffectual leader ls member option ou owner ownership permits server source specify src stat synonyms sys unless chgrp	1/chgrp
 buf buffer bytes dev fill fills generation generator genrandom include int libc.h libsec libsec.h mp mp.h mprand native nbytes prng produce pseudo rand random read reproducible requires security seeded software source srand src stream sys testing truly u.h uchar unguessable void genrandom	2/genrandom
 bugs bw chunk cmd compare diff differ differences displays environment execute file1 file2 files flags future hall idiff idiff.c interactive interactively invokes kernighan manual merges output page pike poorly prentice programming prompt prompts questions response responses select simply source src style sys tmp unix user valid wherever written idiff	1/idiff
 bugs cmd contains convert converted converts defined document doesn't entry eqn equations files gif handle html html2ms html2ms.c images input macro macros ms ms2html ms2html.c output pipe postscript preprocessors prints source src standard strings sys tables tbl text title tl troff troff's understand unknown value ms2html	1/ms2html
 byte bytes cmd cmp cmp.c compare compared comparison decimal designated diagnostic diagnostics diff differ difference differing disagreeing eof except exit file file1 file2 files hexadecimal inaccessible longer lsl missing octal offset1 offset2 offsets options output print reports results source src starts status sys cmp	1/cmp
 byte character cmd counts decimal default dxocr entry file files flags formats freq freq.c frequencies hex histogram histograms input non octal option options print printable printed prints reads runes sequences source specify src standard subset sys table unicode utf value wc freq	1/freq
 bytes char clean cleanname cleanname.c components directory eliminates file filename hypothetical include interprets lexical lexically libc libc.h names null overwritten path port possibly processing return returns shortest slashes source src string sys takes therefore u.h cleanname	2/cleanname
 caches char cons contains current data dev file getuser getuser.c include intro libc libc.h machine null owns pointer port process provides reading reads returns source src static string sys sysname u.h unlike user void getuser	2/getuser
 can't cmd delete directories directory don't entire file files fr neither nor options permission read recursively removal remove removed removes report requires rm rm.c source src sys write rm	1/rm
 cd cmd creates diagnostic diagnostics directories directory dirname error exit mkdir mkdir.c null parent permission prints rc requires returns rm source src status successfully sys write mkdir	1/mkdir
 clean cleanname cleanname.c cmd components directory eliminates equivalent file hypothetical interprets lexical lexically names option path possibly prefixed prints processing pwd shortest slashes source src string sys unrooted cleanname	1/cleanname
 cmd cmp column comm comm.c common diff file file1 file2 files flag input lexicographical lines output print printing produces reads reject select sort sorted source src standard suppresses sys uniq comm	1/comm
 cmd execute execution hence interval repeat seconds sleep sleep.c source src suspend suspends sys time sleep	1/sleep
 cmd exits factor factor.c factors finish generate input integer maximum missing positive prime primes primes.c prints proper proportional ranging reads repeated running source sqrt src standard stream sys time times factor	1/factor
 compute cosh designated double hyperbolic include intro libc libc.h port real sinh source src sys tanh u.h sinh	2/sinh
 defines division domain double equal floating greater ieee include inf infinity int isinf isnan libc libc.h library nan nan.c negative overflow port positive produced range return returns sign sometimes source src standard sys u.h values void nan	2/nan
 describes file formats intro introduction macro manual miscellany packages section troff 0intro	6/0intro
 distance double euclidean hypot hypot.c include libc libc.h overflows port precautions returns source sqrt src sys taking u.h unwarranted hypot	2/hypot