sizeof_1_ = 8;
aggr _1_
{
	'U' 0 lo;
	'U' 4 hi;
};

defn
_1_(addr) {
	complex _1_ addr;
	print("	lo	", addr.lo, "\n");
	print("	hi	", addr.hi, "\n");
};

sizeofFPdbleword = 8;
aggr FPdbleword
{
	'F' 0 x;
	{
	'U' 0 lo;
	'U' 4 hi;
	};
};

defn
FPdbleword(addr) {
	complex FPdbleword addr;
	print("	x	", addr.x, "\n");
	print("_1_ {\n");
		_1_(addr+0);
	print("}\n");
};

UTFmax = 3;
Runesync = 128;
Runeself = 128;
Runeerror = 65533;
sizeofFmt = 48;
aggr Fmt
{
	'b' 0 runes;
	'X' 4 start;
	'X' 8 to;
	'X' 12 stop;
	'X' 16 flush;
	'X' 20 farg;
	'D' 24 nfmt;
	'X' 28 args;
	'D' 32 r;
	'D' 36 width;
	'D' 40 prec;
	'U' 44 flags;
};

defn
Fmt(addr) {
	complex Fmt addr;
	print("	runes	", addr.runes, "\n");
	print("	start	", addr.start\X, "\n");
	print("	to	", addr.to\X, "\n");
	print("	stop	", addr.stop\X, "\n");
	print("	flush	", addr.flush\X, "\n");
	print("	farg	", addr.farg\X, "\n");
	print("	nfmt	", addr.nfmt, "\n");
	print("	args	", addr.args\X, "\n");
	print("	r	", addr.r, "\n");
	print("	width	", addr.width, "\n");
	print("	prec	", addr.prec, "\n");
	print("	flags	", addr.flags, "\n");
};

FmtWidth = 1;
FmtLeft = 2;
FmtPrec = 4;
FmtSharp = 8;
FmtSpace = 16;
FmtSign = 32;
FmtZero = 64;
FmtUnsigned = 128;
FmtShort = 256;
FmtLong = 512;
FmtVLong = 1024;
FmtComma = 2048;
FmtByte = 4096;
FmtFlag = 8192;
sizeofTm = 40;
aggr Tm
{
	'D' 0 sec;
	'D' 4 min;
	'D' 8 hour;
	'D' 12 mday;
	'D' 16 mon;
	'D' 20 year;
	'D' 24 wday;
	'D' 28 yday;
	'a' 32 zone;
	'D' 36 tzoff;
};

defn
Tm(addr) {
	complex Tm addr;
	print("	sec	", addr.sec, "\n");
	print("	min	", addr.min, "\n");
	print("	hour	", addr.hour, "\n");
	print("	mday	", addr.mday, "\n");
	print("	mon	", addr.mon, "\n");
	print("	year	", addr.year, "\n");
	print("	wday	", addr.wday, "\n");
	print("	yday	", addr.yday, "\n");
	print("	zone	", addr.zone, "\n");
	print("	tzoff	", addr.tzoff, "\n");
};

PNPROC = 1;
PNGROUP = 2;
Profoff = 0;
Profuser = 1;
Profkernel = 2;
Proftime = 3;
Profsample = 4;
sizeofLock = 4;
aggr Lock
{
	'D' 0 val;
};

defn
Lock(addr) {
	complex Lock addr;
	print("	val	", addr.val, "\n");
};

sizeofQLp = 12;
aggr QLp
{
	'D' 0 inuse;
	'A' QLp 4 next;
	'C' 8 state;
};

defn
QLp(addr) {
	complex QLp addr;
	print("	inuse	", addr.inuse, "\n");
	print("	next	", addr.next\X, "\n");
	print("	state	", addr.state, "\n");
};

sizeofQLock = 16;
aggr QLock
{
	Lock 0 lock;
	'D' 4 locked;
	'A' QLp 8 $head;
	'A' QLp 12 $tail;
};

defn
QLock(addr) {
	complex QLock addr;
	print("Lock lock {\n");
	Lock(addr.lock);
	print("}\n");
	print("	locked	", addr.locked, "\n");
	print("	$head	", addr.$head\X, "\n");
	print("	$tail	", addr.$tail\X, "\n");
};

sizeofRWLock = 20;
aggr RWLock
{
	Lock 0 lock;
	'D' 4 readers;
	'D' 8 writer;
	'A' QLp 12 $head;
	'A' QLp 16 $tail;
};

defn
RWLock(addr) {
	complex RWLock addr;
	print("Lock lock {\n");
	Lock(addr.lock);
	print("}\n");
	print("	readers	", addr.readers, "\n");
	print("	writer	", addr.writer, "\n");
	print("	$head	", addr.$head\X, "\n");
	print("	$tail	", addr.$tail\X, "\n");
};

sizeofRendez = 12;
aggr Rendez
{
	'A' QLock 0 l;
	'A' QLp 4 $head;
	'A' QLp 8 $tail;
};

defn
Rendez(addr) {
	complex Rendez addr;
	print("	l	", addr.l\X, "\n");
	print("	$head	", addr.$head\X, "\n");
	print("	$tail	", addr.$tail\X, "\n");
};

sizeofNetConnInfo = 36;
aggr NetConnInfo
{
	'X' 0 dir;
	'X' 4 root;
	'X' 8 spec;
	'X' 12 lsys;
	'X' 16 lserv;
	'X' 20 rsys;
	'X' 24 rserv;
	'X' 28 laddr;
	'X' 32 raddr;
};

defn
NetConnInfo(addr) {
	complex NetConnInfo addr;
	print("	dir	", addr.dir\X, "\n");
	print("	root	", addr.root\X, "\n");
	print("	spec	", addr.spec\X, "\n");
	print("	lsys	", addr.lsys\X, "\n");
	print("	lserv	", addr.lserv\X, "\n");
	print("	rsys	", addr.rsys\X, "\n");
	print("	rserv	", addr.rserv\X, "\n");
	print("	laddr	", addr.laddr\X, "\n");
	print("	raddr	", addr.raddr\X, "\n");
};

RFNAMEG = 1;
RFENVG = 2;
RFFDG = 4;
RFNOTEG = 8;
RFPROC = 16;
RFMEM = 32;
RFNOWAIT = 64;
RFCNAMEG = 1024;
RFCENVG = 2048;
RFCFDG = 4096;
RFREND = 8192;
RFNOMNT = 16384;
sizeofQid = 16;
aggr Qid
{
	'W' 0 path;
	'U' 8 vers;
	'b' 12 type;
};

defn
Qid(addr) {
	complex Qid addr;
	print("	path	", addr.path, "\n");
	print("	vers	", addr.vers, "\n");
	print("	type	", addr.type, "\n");
};

sizeofDir = 60;
aggr Dir
{
	'u' 0 type;
	'U' 4 dev;
	Qid 8 qid;
	'U' 24 mode;
	'U' 28 atime;
	'U' 32 mtime;
	'V' 36 length;
	'X' 44 name;
	'X' 48 uid;
	'X' 52 gid;
	'X' 56 muid;
};

defn
Dir(addr) {
	complex Dir addr;
	print("	type	", addr.type, "\n");
	print("	dev	", addr.dev, "\n");
	print("Qid qid {\n");
	Qid(addr.qid);
	print("}\n");
	print("	mode	", addr.mode, "\n");
	print("	atime	", addr.atime, "\n");
	print("	mtime	", addr.mtime, "\n");
	print("	length	", addr.length, "\n");
	print("	name	", addr.name\X, "\n");
	print("	uid	", addr.uid\X, "\n");
	print("	gid	", addr.gid\X, "\n");
	print("	muid	", addr.muid\X, "\n");
};

sizeofWaitmsg = 20;
aggr Waitmsg
{
	'D' 0 pid;
	'a' 4 time;
	'X' 16 msg;
};

defn
Waitmsg(addr) {
	complex Waitmsg addr;
	print("	pid	", addr.pid, "\n");
	print("	time	", addr.time, "\n");
	print("	msg	", addr.msg\X, "\n");
};

sizeofIOchunk = 8;
aggr IOchunk
{
	'X' 0 addr;
	'U' 4 len;
};

defn
IOchunk(addr) {
	complex IOchunk addr;
	print("	addr	", addr.addr\X, "\n");
	print("	len	", addr.len, "\n");
};

IPaddrlen = 16;
IPv4addrlen = 4;
IPv4off = 12;
IPllen = 4;
sizeofIplifc = 60;
aggr Iplifc
{
	'A' Iplifc 0 next;
	'a' 4 ip;
	'a' 20 mask;
	'a' 36 net;
	'U' 52 preflt;
	'U' 56 validlt;
};

defn
Iplifc(addr) {
	complex Iplifc addr;
	print("	next	", addr.next\X, "\n");
	print("	ip	", addr.ip, "\n");
	print("	mask	", addr.mask, "\n");
	print("	net	", addr.net, "\n");
	print("	preflt	", addr.preflt, "\n");
	print("	validlt	", addr.validlt, "\n");
};

sizeofIpv6rp = 36;
aggr Ipv6rp
{
	'D' 0 mflag;
	'D' 4 oflag;
	'D' 8 maxraint;
	'D' 12 minraint;
	'D' 16 linkmtu;
	'D' 20 reachtime;
	'D' 24 rxmitra;
	'D' 28 ttl;
	'D' 32 routerlt;
};

defn
Ipv6rp(addr) {
	complex Ipv6rp addr;
	print("	mflag	", addr.mflag, "\n");
	print("	oflag	", addr.oflag, "\n");
	print("	maxraint	", addr.maxraint, "\n");
	print("	minraint	", addr.minraint, "\n");
	print("	linkmtu	", addr.linkmtu, "\n");
	print("	reachtime	", addr.reachtime, "\n");
	print("	rxmitra	", addr.rxmitra, "\n");
	print("	ttl	", addr.ttl, "\n");
	print("	routerlt	", addr.routerlt, "\n");
};

sizeofIpifc = 136;
aggr Ipifc
{
	'A' Ipifc 0 next;
	'A' Iplifc 4 lifc;
	'D' 8 index;
	'a' 12 dev;
	'b' 76 sendra6;
	'b' 77 recvra6;
	'D' 80 mtu;
	'U' 84 pktin;
	'U' 88 pktout;
	'U' 92 errin;
	'U' 96 errout;
	Ipv6rp 100 rp;
};

defn
Ipifc(addr) {
	complex Ipifc addr;
	print("	next	", addr.next\X, "\n");
	print("	lifc	", addr.lifc\X, "\n");
	print("	index	", addr.index, "\n");
	print("	dev	", addr.dev, "\n");
	print("	sendra6	", addr.sendra6, "\n");
	print("	recvra6	", addr.recvra6, "\n");
	print("	mtu	", addr.mtu, "\n");
	print("	pktin	", addr.pktin, "\n");
	print("	pktout	", addr.pktout, "\n");
	print("	errin	", addr.errin, "\n");
	print("	errout	", addr.errout, "\n");
	print("Ipv6rp rp {\n");
	Ipv6rp(addr.rp);
	print("}\n");
};

OUdphdrsize = 36;
sizeofOUdphdr = 36;
aggr OUdphdr
{
	'a' 0 raddr;
	'a' 16 laddr;
	'a' 32 rport;
	'a' 34 lport;
};

defn
OUdphdr(addr) {
	complex OUdphdr addr;
	print("	raddr	", addr.raddr, "\n");
	print("	laddr	", addr.laddr, "\n");
	print("	rport	", addr.rport, "\n");
	print("	lport	", addr.lport, "\n");
};

Udphdrsize = 52;
sizeofUdphdr = 52;
aggr Udphdr
{
	'a' 0 raddr;
	'a' 16 laddr;
	'a' 32 ifcaddr;
	'a' 48 rport;
	'a' 50 lport;
};

defn
Udphdr(addr) {
	complex Udphdr addr;
	print("	raddr	", addr.raddr, "\n");
	print("	laddr	", addr.laddr, "\n");
	print("	ifcaddr	", addr.ifcaddr, "\n");
	print("	rport	", addr.rport, "\n");
	print("	lport	", addr.lport, "\n");
};

sizeofPool = 88;
aggr Pool
{
	'X' 0 name;
	'U' 4 maxsize;
	'U' 8 cursize;
	'U' 12 curfree;
	'U' 16 curalloc;
	'U' 20 minarena;
	'U' 24 quantum;
	'U' 28 minblock;
	'X' 32 freeroot;
	'X' 36 arenalist;
	'X' 40 alloc;
	'X' 44 merge;
	'X' 48 move;
	'D' 52 flags;
	'D' 56 nfree;
	'D' 60 lastcompact;
	'X' 64 lock;
	'X' 68 unlock;
	'X' 72 print;
	'X' 76 panic;
	'X' 80 logstack;
	'X' 84 private;
};

defn
Pool(addr) {
	complex Pool addr;
	print("	name	", addr.name\X, "\n");
	print("	maxsize	", addr.maxsize, "\n");
	print("	cursize	", addr.cursize, "\n");
	print("	curfree	", addr.curfree, "\n");
	print("	curalloc	", addr.curalloc, "\n");
	print("	minarena	", addr.minarena, "\n");
	print("	quantum	", addr.quantum, "\n");
	print("	minblock	", addr.minblock, "\n");
	print("	freeroot	", addr.freeroot\X, "\n");
	print("	arenalist	", addr.arenalist\X, "\n");
	print("	alloc	", addr.alloc\X, "\n");
	print("	merge	", addr.merge\X, "\n");
	print("	move	", addr.move\X, "\n");
	print("	flags	", addr.flags, "\n");
	print("	nfree	", addr.nfree, "\n");
	print("	lastcompact	", addr.lastcompact, "\n");
	print("	lock	", addr.lock\X, "\n");
	print("	unlock	", addr.unlock\X, "\n");
	print("	print	", addr.print\X, "\n");
	print("	panic	", addr.panic\X, "\n");
	print("	logstack	", addr.logstack\X, "\n");
	print("	private	", addr.private\X, "\n");
};

complex Pool mainmem;
complex Pool imagmem;
POOL_ANTAGONISM = 1;
POOL_PARANOIA = 2;
POOL_VERBOSITY = 4;
POOL_DEBUGGING = 8;
POOL_LOGGING = 16;
POOL_TOLERANCE = 32;
POOL_NOREUSE = 64;
Ta = 1;
Tns = 2;
Tmd = 3;
Tmf = 4;
Tcname = 5;
Tsoa = 6;
Tmb = 7;
Tmg = 8;
Tmr = 9;
Tnull = 10;
Twks = 11;
Tptr = 12;
Thinfo = 13;
Tminfo = 14;
Tmx = 15;
Ttxt = 16;
Trp = 17;
Tafsdb = 18;
Tx25 = 19;
Tisdn = 20;
Trt = 21;
Tnsap = 22;
Tnsapptr = 23;
Tsig = 24;
Tkey = 25;
Tpx = 26;
Tgpos = 27;
Taaaa = 28;
Tloc = 29;
Tnxt = 30;
Teid = 31;
Tnimloc = 32;
Tsrv = 33;
Tatma = 34;
Tnaptr = 35;
Tkx = 36;
Tcert = 37;
Ta6 = 38;
Tdname = 39;
Tsink = 40;
Topt = 41;
Tapl = 42;
Tds = 43;
Tsshfp = 44;
Tipseckey = 45;
Trrsig = 46;
Tnsec = 47;
Tdnskey = 48;
Tspf = 99;
Tuinfo = 100;
Tuid = 101;
Tgid = 102;
Tunspec = 103;
Ttkey = 249;
Ttsig = 250;
Tixfr = 251;
Taxfr = 252;
Tmailb = 253;
Tmaila = 254;
Tall = 255;
Csym = 0;
Cin = 1;
Ccs = 2;
Cch = 3;
Chs = 4;
Call = 255;
Oquery = 0;
Oinverse = 2048;
Ostatus = 4096;
Onotify = 8192;
Oupdate = 10240;
Omask = 30720;
Rok = 0;
Rformat = 1;
Rserver = 2;
Rname = 3;
Runimplimented = 4;
Rrefused = 5;
Ryxdomain = 6;
Ryxrrset = 7;
Rnxrrset = 8;
Rnotauth = 9;
Rnotzone = 10;
Rbadvers = 16;
Rbadkey = 17;
Rbadtime = 18;
Rbadmode = 19;
Rbadname = 20;
Rbadalg = 21;
Rmask = 31;
Rtimeout = 32;
Fresp = 32768;
Fauth = 1024;
Ftrunc = 512;
Frecurse = 256;
Fcanrec = 128;
Domlen = 256;
Labellen = 256;
Strlen = 256;
Iplen = 32;
Min = 60;
Hour = 3600;
Day = 86400;
Week = 604800;
Year = 31449600;
DEFTTL = 86400;
Reserved = 300;
Maxudp = 512;
Maxudpin = 2048;
HTLEN = 4096;
RRmagic = 3735927486;
DNmagic = 2702221584;
Maxactive = 32;
sizeofRequest = 20;
aggr Request
{
	'D' 0 isslave;
	'U' 4 aborttime;
	'a' 8 mret;
	'D' 16 id;
};

defn
Request(addr) {
	complex Request addr;
	print("	isslave	", addr.isslave, "\n");
	print("	aborttime	", addr.aborttime, "\n");
	print("	mret	", addr.mret, "\n");
	print("	id	", addr.id, "\n");
};

sizeofDN = 32;
aggr DN
{
	'A' DN 0 next;
	'U' 4 magic;
	'X' 8 name;
	'X' 12 rr;
	'U' 16 referenced;
	'U' 20 lookuptime;
	'u' 24 class;
	'C' 26 refs;
	'C' 27 nonexistent;
	'U' 28 ordinal;
};

defn
DN(addr) {
	complex DN addr;
	print("	next	", addr.next\X, "\n");
	print("	magic	", addr.magic, "\n");
	print("	name	", addr.name\X, "\n");
	print("	rr	", addr.rr\X, "\n");
	print("	referenced	", addr.referenced, "\n");
	print("	lookuptime	", addr.lookuptime, "\n");
	print("	class	", addr.class, "\n");
	print("	refs	", addr.refs, "\n");
	print("	nonexistent	", addr.nonexistent, "\n");
	print("	ordinal	", addr.ordinal, "\n");
};

sizeofKey = 20;
aggr Key
{
	'D' 0 flags;
	'D' 4 proto;
	'D' 8 alg;
	'D' 12 dlen;
	'X' 16 data;
};

defn
Key(addr) {
	complex Key addr;
	print("	flags	", addr.flags, "\n");
	print("	proto	", addr.proto, "\n");
	print("	alg	", addr.alg, "\n");
	print("	dlen	", addr.dlen, "\n");
	print("	data	", addr.data\X, "\n");
};

sizeofCert = 20;
aggr Cert
{
	'D' 0 type;
	'D' 4 tag;
	'D' 8 alg;
	'D' 12 dlen;
	'X' 16 data;
};

defn
Cert(addr) {
	complex Cert addr;
	print("	type	", addr.type, "\n");
	print("	tag	", addr.tag, "\n");
	print("	alg	", addr.alg, "\n");
	print("	dlen	", addr.dlen, "\n");
	print("	data	", addr.data\X, "\n");
};

sizeofSig = 40;
aggr Sig
{
	'D' 0 type;
	'D' 4 alg;
	'D' 8 labels;
	'U' 12 ttl;
	'U' 16 exp;
	'U' 20 incep;
	'D' 24 tag;
	'A' DN 28 signer;
	'D' 32 dlen;
	'X' 36 data;
};

defn
Sig(addr) {
	complex Sig addr;
	print("	type	", addr.type, "\n");
	print("	alg	", addr.alg, "\n");
	print("	labels	", addr.labels, "\n");
	print("	ttl	", addr.ttl, "\n");
	print("	exp	", addr.exp, "\n");
	print("	incep	", addr.incep, "\n");
	print("	tag	", addr.tag, "\n");
	print("	signer	", addr.signer\X, "\n");
	print("	dlen	", addr.dlen, "\n");
	print("	data	", addr.data\X, "\n");
};

sizeofNull = 8;
aggr Null
{
	'D' 0 dlen;
	'X' 4 data;
};

defn
Null(addr) {
	complex Null addr;
	print("	dlen	", addr.dlen, "\n");
	print("	data	", addr.data\X, "\n");
};

sizeofTxt = 8;
aggr Txt
{
	'A' Txt 0 next;
	'X' 4 p;
};

defn
Txt(addr) {
	complex Txt addr;
	print("	next	", addr.next\X, "\n");
	print("	p	", addr.p\X, "\n");
};

sizeof_2_ = 4;
aggr _2_
{
	'A' DN 0 negsoaowner;
	'A' DN 0 host;
	'A' DN 0 cpu;
	'A' DN 0 mb;
	'A' DN 0 ip;
	'A' DN 0 rp;
	'D' 0 cruftlen;
	'U' 0 arg0;
};

defn
_2_(addr) {
	complex _2_ addr;
	print("	negsoaowner	", addr.negsoaowner\X, "\n");
	print("	host	", addr.host\X, "\n");
	print("	cpu	", addr.cpu\X, "\n");
	print("	mb	", addr.mb\X, "\n");
	print("	ip	", addr.ip\X, "\n");
	print("	rp	", addr.rp\X, "\n");
	print("	cruftlen	", addr.cruftlen, "\n");
	print("	arg0	", addr.arg0, "\n");
};

sizeof_3_ = 4;
aggr _3_
{
	'D' 0 negrcode;
	'A' DN 0 rmb;
	'A' DN 0 ptr;
	'A' DN 0 os;
	'U' 0 pref;
	'U' 0 $local;
	'U' 0 arg1;
};

defn
_3_(addr) {
	complex _3_ addr;
	print("	negrcode	", addr.negrcode, "\n");
	print("	rmb	", addr.rmb\X, "\n");
	print("	ptr	", addr.ptr\X, "\n");
	print("	os	", addr.os\X, "\n");
	print("	pref	", addr.pref, "\n");
	print("	$local	", addr.$local, "\n");
	print("	arg1	", addr.arg1, "\n");
};

sizeof_4_ = 4;
aggr _4_
{
	'X' 0 soa;
	'A' Key 0 key;
	'A' Cert 0 cert;
	'A' Sig 0 sig;
	'A' Null 0 null;
	'A' Txt 0 txt;
};

defn
_4_(addr) {
	complex _4_ addr;
	print("	soa	", addr.soa\X, "\n");
	print("	key	", addr.key\X, "\n");
	print("	cert	", addr.cert\X, "\n");
	print("	sig	", addr.sig\X, "\n");
	print("	null	", addr.null\X, "\n");
	print("	txt	", addr.txt\X, "\n");
};

sizeofRR = 52;
aggr RR
{
	'A' RR 0 next;
	'U' 4 magic;
	'A' DN 8 owner;
	'b' 12 negative;
	'U' 16 pc;
	'U' 20 ttl;
	'U' 24 expire;
	'u' 28 type;
	'u' 30 query;
	'b' 32 auth;
	'b' 33 db;
	'b' 34 cached;
	'U' 36 marker;
	{
	'A' DN 40 negsoaowner;
	'A' DN 40 host;
	'A' DN 40 cpu;
	'A' DN 40 mb;
	'A' DN 40 ip;
	'A' DN 40 rp;
	'D' 40 cruftlen;
	'U' 40 arg0;
	};
	{
	'D' 44 negrcode;
	'A' DN 44 rmb;
	'A' DN 44 ptr;
	'A' DN 44 os;
	'U' 44 pref;
	'U' 44 $local;
	'U' 44 arg1;
	};
	{
	'X' 48 soa;
	'A' Key 48 key;
	'A' Cert 48 cert;
	'A' Sig 48 sig;
	'A' Null 48 null;
	'A' Txt 48 txt;
	};
};

defn
RR(addr) {
	complex RR addr;
	print("	next	", addr.next\X, "\n");
	print("	magic	", addr.magic, "\n");
	print("	owner	", addr.owner\X, "\n");
	print("	negative	", addr.negative, "\n");
	print("	pc	", addr.pc, "\n");
	print("	ttl	", addr.ttl, "\n");
	print("	expire	", addr.expire, "\n");
	print("	type	", addr.type, "\n");
	print("	query	", addr.query, "\n");
	print("	auth	", addr.auth, "\n");
	print("	db	", addr.db, "\n");
	print("	cached	", addr.cached, "\n");
	print("	marker	", addr.marker, "\n");
	print("_2_ {\n");
		_2_(addr+40);
	print("}\n");
	print("_3_ {\n");
		_3_(addr+44);
	print("}\n");
	print("_4_ {\n");
		_4_(addr+48);
	print("}\n");
};

sizeofServer = 8;
aggr Server
{
	'A' Server 0 next;
	'X' 4 name;
};

defn
Server(addr) {
	complex Server addr;
	print("	next	", addr.next\X, "\n");
	print("	name	", addr.name\X, "\n");
};

sizeofSOA = 24;
aggr SOA
{
	'U' 0 serial;
	'U' 4 refresh;
	'U' 8 retry;
	'U' 12 expire;
	'U' 16 minttl;
	'A' Server 20 slaves;
};

defn
SOA(addr) {
	complex SOA addr;
	print("	serial	", addr.serial, "\n");
	print("	refresh	", addr.refresh, "\n");
	print("	retry	", addr.retry, "\n");
	print("	expire	", addr.expire, "\n");
	print("	minttl	", addr.minttl, "\n");
	print("	slaves	", addr.slaves\X, "\n");
};

sizeofDNSmsg = 40;
aggr DNSmsg
{
	'u' 0 id;
	'D' 4 flags;
	'D' 8 qdcount;
	'A' RR 12 qd;
	'D' 16 ancount;
	'A' RR 20 an;
	'D' 24 nscount;
	'A' RR 28 ns;
	'D' 32 arcount;
	'A' RR 36 ar;
};

defn
DNSmsg(addr) {
	complex DNSmsg addr;
	print("	id	", addr.id, "\n");
	print("	flags	", addr.flags, "\n");
	print("	qdcount	", addr.qdcount, "\n");
	print("	qd	", addr.qd\X, "\n");
	print("	ancount	", addr.ancount, "\n");
	print("	an	", addr.an\X, "\n");
	print("	nscount	", addr.nscount, "\n");
	print("	ns	", addr.ns\X, "\n");
	print("	arcount	", addr.arcount, "\n");
	print("	ar	", addr.ar\X, "\n");
};

sizeofArea = 20;
aggr Area
{
	'A' Area 0 next;
	'D' 4 len;
	'A' RR 8 soarr;
	'D' 12 neednotify;
	'D' 16 needrefresh;
};

defn
Area(addr) {
	complex Area addr;
	print("	next	", addr.next\X, "\n");
	print("	len	", addr.len, "\n");
	print("	soarr	", addr.soarr\X, "\n");
	print("	neednotify	", addr.neednotify, "\n");
	print("	needrefresh	", addr.needrefresh, "\n");
};

Recurse = 0;
Dontrecurse = 1;
NOneg = 2;
OKneg = 3;
complex Area owned;
complex Area delegated;
sizeof_5_ = 24;
aggr _5_
{
	{
	'D' 0 val;
	};
	'U' 4 names;
	'U' 8 oldest;
	'D' 12 active;
	'D' 16 mutex;
	'D' 20 id;
};

defn
_5_(addr) {
	complex _5_ addr;
	print("Lock {\n");
		Lock(addr+0);
	print("}\n");
	print("	names	", addr.names, "\n");
	print("	oldest	", addr.oldest, "\n");
	print("	active	", addr.active, "\n");
	print("	mutex	", addr.mutex, "\n");
	print("	id	", addr.id, "\n");
};

complex _5_ dnvars;
complex Lock dnlock;
complex DN dnlookup:l;
complex DN dnlookup:dp;
complex DN dndump:dp;
complex RR dndump:rp;
complex DN dnpurge:dp;
complex RR dnpurge:rp;
complex RR dnpurge:srp;
complex DN dnage:dp;
complex RR dnage:l;
complex RR dnage:rp;
complex RR dnage:next;
complex DN dnageall:dp;
complex DN dnageall:l;
complex RR dnageall:rp;
complex DN dnagedb:dp;
complex RR dnagedb:rp;
complex DN dnauthdb:dp;
complex Area dnauthdb:area;
complex RR dnauthdb:rp;
complex Request getactivity:req;
complex RR rrattach1:new;
complex RR rrattach1:l;
complex RR rrattach1:rp;
complex DN rrattach1:dp;
complex RR rrattach:rp;
complex RR rrattach:next;
complex RR rralloc:rp;
complex RR rrfree:rp;
complex DN rrfree:dp;
complex RR rrfree:nrp;
complex Txt rrfree:t;
complex RR rrfreelist:rp;
complex RR rrfreelist:next;
complex RR rrcopy:rp;
complex RR rrcopy:last;
complex RR rrcopy:nrp;
complex SOA rrcopy:soa;
complex Key rrcopy:key;
complex Cert rrcopy:cert;
complex Sig rrcopy:sig;
complex Null rrcopy:null;
complex Txt rrcopy:t;
complex Txt rrcopy:nt;
complex Txt rrcopy:l;
complex DN rrlookup:dp;
complex RR rrlookup:rp;
complex RR rrlookup:first;
complex RR rrlookup:last;
complex RR rrcat:start;
complex RR rrcat:rp;
complex RR rrcat:last;
complex RR rrremneg:l;
complex RR rrremneg:nl;
complex RR rrremneg:rp;
complex RR rrremneg:first;
complex RR rrremtype:l;
complex RR rrremtype:nl;
complex RR rrremtype:rp;
complex RR rrremtype:first;
complex Fmt rrfmt:f;
complex RR rrfmt:rp;
complex Fmt rrfmt:fstr;
complex Server rrfmt:s;
complex Txt rrfmt:t;
complex Fmt rravfmt:f;
complex RR rravfmt:rp;
complex Fmt rravfmt:fstr;
complex Server rravfmt:s;
complex Txt rravfmt:t;
complex Request slave:req;
complex DN dncheck:dp;
complex RR dncheck:rp;
complex Pool mainmem;
complex RR rrequiv:r1;
complex RR rrequiv:r2;
complex RR unique:rp;
complex RR unique:l;
complex RR unique:nrp;
complex RR randomize:rp;
complex RR randomize:first;
complex RR randomize:last;
complex RR randomize:x;
complex RR randomize:base;
complex Fmt sencodefmt:f;
complex DN mkptr:dp;
complex DN mkptr:ipdp;
complex RR mkptr:rp;
complex DN dnptr:dp;
complex RR dnptr:rp;
complex RR dnptr:nrp;
complex RR dnptr:first;
complex RR dnptr:l;
complex Server freeserverlist:s;
complex Server freeserverlist:next;
complex Server addserver:l;
complex Server addserver:s;
complex Server copyserverlist:s;
complex Server copyserverlist:ns;