diff --git a/include/link.h b/include/link.h
index 73f148c14c..8c73eab51e 100644
--- a/include/link.h
+++ b/include/link.h
@@ -392,7 +392,7 @@ struct	Link
 	LSym*	sym_divu;
 	LSym*	sym_mod;
 	LSym*	sym_modu;
-	LSym*	symmorestack[20];
+	LSym*	symmorestack[2];
 	LSym*	tlsg;
 	LSym*	plan9privates;
 	Prog*	curp;
diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c
index 6e87029e7c..36efb5711c 100644
--- a/src/cmd/dist/buildruntime.c
+++ b/src/cmd/dist/buildruntime.c
@@ -246,6 +246,8 @@ mkzasm(char *dir, char *file)
 				aggr = "alg";
 			else if(streq(fields.p[1], "Panic"))
 				aggr = "panic";
+			else if(streq(fields.p[1], "Stack"))
+				aggr = "stack";
 		}
 		if(hasprefix(lines.p[i], "}"))
 			aggr = nil;
diff --git a/src/liblink/obj5.c b/src/liblink/obj5.c
index d9f980aca8..a571d8f166 100644
--- a/src/liblink/obj5.c
+++ b/src/liblink/obj5.c
@@ -458,7 +458,7 @@ addstacksplit(Link *ctxt, LSym *cursym)
 				p->as = AMOVW;
 				p->from.type = D_OREG;
 				p->from.reg = REGG;
-				p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
+				p->from.offset = 4*ctxt->arch->ptrsize; // G.panic
 				p->to.type = D_REG;
 				p->to.reg = 1;
 			
@@ -762,15 +762,14 @@ softfloat(Link *ctxt, LSym *cursym)
 static Prog*
 stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt)
 {
-	int32 arg;
-
 	// MOVW			g_stackguard(g), R1
 	p = appendp(ctxt, p);
 	p->as = AMOVW;
 	p->from.type = D_OREG;
 	p->from.reg = REGG;
+	p->from.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 	if(ctxt->cursym->cfunc)
-		p->from.offset = 3*ctxt->arch->ptrsize;
+		p->from.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 	p->to.type = D_REG;
 	p->to.reg = 1;
 	
@@ -849,29 +848,6 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt)
 		p->scond = C_SCOND_NE;
 	}
 	
-	// MOVW.LS		$framesize, R1
-	p = appendp(ctxt, p);
-	p->as = AMOVW;
-	p->scond = C_SCOND_LS;
-	p->from.type = D_CONST;
-	p->from.offset = framesize;
-	p->to.type = D_REG;
-	p->to.reg = 1;
-
-	// MOVW.LS		$args, R2
-	p = appendp(ctxt, p);
-	p->as = AMOVW;
-	p->scond = C_SCOND_LS;
-	p->from.type = D_CONST;
-	arg = ctxt->cursym->text->to.offset2;
-	if(arg == 1) // special marker for known 0
-		arg = 0;
-	if(arg&3)
-		ctxt->diag("misaligned argument size in stack split");
-	p->from.offset = arg;
-	p->to.type = D_REG;
-	p->to.reg = 2;
-
 	// MOVW.LS	R14, R3
 	p = appendp(ctxt, p);
 	p->as = AMOVW;
diff --git a/src/liblink/obj6.c b/src/liblink/obj6.c
index 572219b5b7..2acfd2f70d 100644
--- a/src/liblink/obj6.c
+++ b/src/liblink/obj6.c
@@ -342,32 +342,6 @@ nacladdr(Link *ctxt, Prog *p, Addr *a)
 	}
 }
 
-static char*
-morename[] =
-{
-	"runtime.morestack00",
-	"runtime.morestack00_noctxt",
-	"runtime.morestack10",
-	"runtime.morestack10_noctxt",
-	"runtime.morestack01",
-	"runtime.morestack01_noctxt",
-	"runtime.morestack11",
-	"runtime.morestack11_noctxt",
-
-	"runtime.morestack8",
-	"runtime.morestack8_noctxt",
-	"runtime.morestack16",
-	"runtime.morestack16_noctxt",
-	"runtime.morestack24",
-	"runtime.morestack24_noctxt",
-	"runtime.morestack32",
-	"runtime.morestack32_noctxt",
-	"runtime.morestack40",
-	"runtime.morestack40_noctxt",
-	"runtime.morestack48",
-	"runtime.morestack48_noctxt",
-};
-
 static Prog*	load_g_cx(Link*, Prog*);
 static Prog*	stacksplit(Link*, Prog*, int32, int32, int, Prog**);
 static void	indir_cx(Link*, Addr*);
@@ -388,19 +362,16 @@ parsetextconst(vlong arg, vlong *textstksiz, vlong *textarg)
 static void
 addstacksplit(Link *ctxt, LSym *cursym)
 {
-	Prog *p, *q, *q1, *p1, *p2;
+	Prog *p, *q, *p1, *p2;
 	int32 autoffset, deltasp;
 	int a, pcsize;
-	uint32 i;
 	vlong textstksiz, textarg;
 
 	if(ctxt->tlsg == nil)
 		ctxt->tlsg = linklookup(ctxt, "runtime.tlsg", 0);
 	if(ctxt->symmorestack[0] == nil) {
-		if(nelem(morename) > nelem(ctxt->symmorestack))
-			sysfatal("Link.symmorestack needs at least %d elements", nelem(morename));
-		for(i=0; i<nelem(morename); i++)
-			ctxt->symmorestack[i] = linklookup(ctxt, morename[i], 0);
+		ctxt->symmorestack[0] = linklookup(ctxt, "runtime.morestack", 0);
+		ctxt->symmorestack[1] = linklookup(ctxt, "runtime.morestack_noctxt", 0);
 	}
 
 	if(ctxt->headtype == Hplan9 && ctxt->plan9privates == nil)
@@ -481,7 +452,7 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p = appendp(ctxt, p);
 		p->as = AMOVQ;
 		p->from.type = D_INDIR+D_CX;
-		p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
+		p->from.offset = 4*ctxt->arch->ptrsize; // G.panic
 		p->to.type = D_BX;
 		if(ctxt->headtype == Hnacl) {
 			p->as = AMOVL;
@@ -545,42 +516,6 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p2->pcond = p;
 	}
 
-	if(ctxt->debugstack > 1 && autoffset) {
-		// 6l -K -K means double-check for stack overflow
-		// even after calling morestack and even if the
-		// function is marked as nosplit.
-		p = appendp(ctxt, p);
-		p->as = AMOVQ;
-		indir_cx(ctxt, &p->from);
-		p->from.offset = 0;
-		p->to.type = D_BX;
-
-		p = appendp(ctxt, p);
-		p->as = ASUBQ;
-		p->from.type = D_CONST;
-		p->from.offset = StackSmall+32;
-		p->to.type = D_BX;
-
-		p = appendp(ctxt, p);
-		p->as = ACMPQ;
-		p->from.type = D_SP;
-		p->to.type = D_BX;
-
-		p = appendp(ctxt, p);
-		p->as = AJHI;
-		p->to.type = D_BRANCH;
-		q1 = p;
-
-		p = appendp(ctxt, p);
-		p->as = AINT;
-		p->from.type = D_CONST;
-		p->from.offset = 3;
-
-		p = appendp(ctxt, p);
-		p->as = ANOP;
-		q1->pcond = p;
-	}
-	
 	if(ctxt->debugzerostack && autoffset && !(cursym->text->from.scale&NOSPLIT)) {
 		// 6l -Z means zero the stack frame on entry.
 		// This slows down function calls but can help avoid
@@ -731,9 +666,9 @@ static Prog*
 stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog **jmpok)
 {
 	Prog *q, *q1;
-	uint32 moreconst1, moreconst2, i;
 	int cmp, lea, mov, sub;
 
+	USED(textarg);
 	cmp = ACMPQ;
 	lea = ALEAQ;
 	mov = AMOVQ;
@@ -746,35 +681,6 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog
 		sub = ASUBL;
 	}
 
-	if(ctxt->debugstack) {
-		// 6l -K means check not only for stack
-		// overflow but stack underflow.
-		// On underflow, INT 3 (breakpoint).
-		// Underflow itself is rare but this also
-		// catches out-of-sync stack guard info
-
-		p = appendp(ctxt, p);
-		p->as = cmp;
-		indir_cx(ctxt, &p->from);
-		p->from.offset = 8;
-		p->to.type = D_SP;
-
-		p = appendp(ctxt, p);
-		p->as = AJHI;
-		p->to.type = D_BRANCH;
-		p->to.offset = 4;
-		q1 = p;
-
-		p = appendp(ctxt, p);
-		p->as = AINT;
-		p->from.type = D_CONST;
-		p->from.offset = 3;
-
-		p = appendp(ctxt, p);
-		p->as = ANOP;
-		q1->pcond = p;
-	}
-
 	q1 = nil;
 	if(framesize <= StackSmall) {
 		// small stack: SP <= stackguard
@@ -783,8 +689,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog
 		p->as = cmp;
 		p->from.type = D_SP;
 		indir_cx(ctxt, &p->to);
+		p->to.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->to.offset = 3*ctxt->arch->ptrsize;
+			p->to.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 	} else if(framesize <= StackBig) {
 		// large stack: SP-framesize <= stackguard-StackSmall
 		//	LEAQ -xxx(SP), AX
@@ -799,8 +706,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog
 		p->as = cmp;
 		p->from.type = D_AX;
 		indir_cx(ctxt, &p->to);
+		p->to.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->to.offset = 3*ctxt->arch->ptrsize;
+			p->to.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 	} else {
 		// Such a large stack we need to protect against wraparound.
 		// If SP is close to zero:
@@ -820,9 +728,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog
 		p = appendp(ctxt, p);
 		p->as = mov;
 		indir_cx(ctxt, &p->from);
-		p->from.offset = 0;
+		p->from.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->from.offset = 3*ctxt->arch->ptrsize;
+			p->from.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 		p->to.type = D_SI;
 
 		p = appendp(ctxt, p);
@@ -860,75 +768,13 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int32 textarg, int noctxt, Prog
 	p->to.type = D_BRANCH;
 	q = p;
 
-	// If we ask for more stack, we'll get a minimum of StackMin bytes.
-	// We need a stack frame large enough to hold the top-of-stack data,
-	// the function arguments+results, our caller's PC, our frame,
-	// a word for the return PC of the next call, and then the StackLimit bytes
-	// that must be available on entry to any function called from a function
-	// that did a stack check.  If StackMin is enough, don't ask for a specific
-	// amount: then we can use the custom functions and save a few
-	// instructions.
-	moreconst1 = 0;
-	if(StackTop + textarg + ctxt->arch->ptrsize + framesize + ctxt->arch->ptrsize + StackLimit >= StackMin)
-		moreconst1 = framesize;
-	moreconst2 = textarg;
-	if(moreconst2 == 1) // special marker
-		moreconst2 = 0;
-	if((moreconst2&7) != 0)
-		ctxt->diag("misaligned argument size in stack split");
-	// 4 varieties varieties (const1==0 cross const2==0)
-	// and 6 subvarieties of (const1==0 and const2!=0)
 	p = appendp(ctxt, p);
-	if(ctxt->cursym->cfunc) {
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
+	p->as = ACALL;
+	p->to.type = D_BRANCH;
+	if(ctxt->cursym->cfunc)
 		p->to.sym = linklookup(ctxt, "runtime.morestackc", 0);
-	} else
-	if(moreconst1 == 0 && moreconst2 == 0) {
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
-		p->to.sym = ctxt->symmorestack[0*2+noctxt];
-	} else
-	if(moreconst1 != 0 && moreconst2 == 0) {
-		p->as = AMOVL;
-		p->from.type = D_CONST;
-		p->from.offset = moreconst1;
-		p->to.type = D_AX;
-
-		p = appendp(ctxt, p);
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
-		p->to.sym = ctxt->symmorestack[1*2+noctxt];
-	} else
-	if(moreconst1 == 0 && moreconst2 <= 48 && moreconst2%8 == 0) {
-		i = moreconst2/8 + 3;
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
-		p->to.sym = ctxt->symmorestack[i*2+noctxt];
-	} else
-	if(moreconst1 == 0 && moreconst2 != 0) {
-		p->as = AMOVL;
-		p->from.type = D_CONST;
-		p->from.offset = moreconst2;
-		p->to.type = D_AX;
-
-		p = appendp(ctxt, p);
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
-		p->to.sym = ctxt->symmorestack[2*2+noctxt];
-	} else {
-		// Pass framesize and argsize.
-		p->as = AMOVQ;
-		p->from.type = D_CONST;
-		p->from.offset = (uint64)moreconst2 << 32;
-		p->from.offset |= moreconst1;
-		p->to.type = D_AX;
-
-		p = appendp(ctxt, p);
-		p->as = ACALL;
-		p->to.type = D_BRANCH;
-		p->to.sym = ctxt->symmorestack[3*2+noctxt];
-	}
+	else
+		p->to.sym = ctxt->symmorestack[noctxt];
 	
 	p = appendp(ctxt, p);
 	p->as = AJMP;
diff --git a/src/liblink/obj8.c b/src/liblink/obj8.c
index d8a93fb576..f54153ae9b 100644
--- a/src/liblink/obj8.c
+++ b/src/liblink/obj8.c
@@ -335,7 +335,7 @@ addstacksplit(Link *ctxt, LSym *cursym)
 		p = appendp(ctxt, p);
 		p->as = AMOVL;
 		p->from.type = D_INDIR+D_CX;
-		p->from.offset = 2*ctxt->arch->ptrsize; // G.panic
+		p->from.offset = 4*ctxt->arch->ptrsize; // G.panic
 		p->to.type = D_BX;
 
 		p = appendp(ctxt, p);
@@ -501,7 +501,6 @@ static Prog*
 stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt, Prog **jmpok)
 {
 	Prog *q, *q1;
-	int arg;
 
 	if(ctxt->debugstack) {
 		// 8l -K means check not only for stack
@@ -539,8 +538,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt, Prog **jmpok)
 		p->as = ACMPL;
 		p->from.type = D_SP;
 		p->to.type = D_INDIR+D_CX;
+		p->to.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->to.offset = 3*ctxt->arch->ptrsize;
+			p->to.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 	} else if(framesize <= StackBig) {
 		// large stack: SP-framesize <= stackguard-StackSmall
 		//	LEAL -(framesize-StackSmall)(SP), AX
@@ -555,8 +555,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt, Prog **jmpok)
 		p->as = ACMPL;
 		p->from.type = D_AX;
 		p->to.type = D_INDIR+D_CX;
+		p->to.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->to.offset = 3*ctxt->arch->ptrsize;
+			p->to.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 	} else {
 		// Such a large stack we need to protect against wraparound
 		// if SP is close to zero.
@@ -576,8 +577,9 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt, Prog **jmpok)
 		p->as = AMOVL;
 		p->from.type = D_INDIR+D_CX;
 		p->from.offset = 0;
+		p->from.offset = 2*ctxt->arch->ptrsize;	// G.stackguard0
 		if(ctxt->cursym->cfunc)
-			p->from.offset = 3*ctxt->arch->ptrsize;
+			p->from.offset = 3*ctxt->arch->ptrsize;	// G.stackguard1
 		p->to.type = D_SI;
 
 		p = appendp(ctxt, p);
@@ -617,33 +619,6 @@ stacksplit(Link *ctxt, Prog *p, int32 framesize, int noctxt, Prog **jmpok)
 	p->to.offset = 4;
 	q = p;
 
-	p = appendp(ctxt, p);	// save frame size in DI
-	p->as = AMOVL;
-	p->to.type = D_DI;
-	p->from.type = D_CONST;
-
-	// If we ask for more stack, we'll get a minimum of StackMin bytes.
-	// We need a stack frame large enough to hold the top-of-stack data,
-	// the function arguments+results, our caller's PC, our frame,
-	// a word for the return PC of the next call, and then the StackLimit bytes
-	// that must be available on entry to any function called from a function
-	// that did a stack check.  If StackMin is enough, don't ask for a specific
-	// amount: then we can use the custom functions and save a few
-	// instructions.
-	if(StackTop + ctxt->cursym->text->to.offset2 + ctxt->arch->ptrsize + framesize + ctxt->arch->ptrsize + StackLimit >= StackMin)
-		p->from.offset = (framesize+7) & ~7LL;
-
-	arg = ctxt->cursym->text->to.offset2;
-	if(arg == 1) // special marker for known 0
-		arg = 0;
-	if(arg&3)
-		ctxt->diag("misaligned argument size in stack split");
-	p = appendp(ctxt, p);	// save arg size in AX
-	p->as = AMOVL;
-	p->to.type = D_AX;
-	p->from.type = D_CONST;
-	p->from.offset = arg;
-
 	p = appendp(ctxt, p);
 	p->as = ACALL;
 	p->to.type = D_BRANCH;
diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 7eba8977c6..fc01b995b1 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -19,9 +19,10 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// _cgo_init may update stackguard.
 	MOVL	$runtime·g0(SB), BP
 	LEAL	(-64*1024+104)(SP), BX
-	MOVL	BX, g_stackguard(BP)
 	MOVL	BX, g_stackguard0(BP)
-	MOVL	SP, g_stackbase(BP)
+	MOVL	BX, g_stackguard1(BP)
+	MOVL	BX, (g_stack+stack_lo)(BP)
+	MOVL	SP, (g_stack+stack_hi)(BP)
 	
 	// find out information about the processor we're on
 	MOVL	$0, AX
@@ -44,10 +45,14 @@ nocpuinfo:
 	MOVL	BX, 4(SP)
 	MOVL	BP, 0(SP)
 	CALL	AX
+
 	// update stackguard after _cgo_init
 	MOVL	$runtime·g0(SB), CX
-	MOVL	g_stackguard0(CX), AX
-	MOVL	AX, g_stackguard(CX)
+	MOVL	(g_stack+stack_lo)(CX), AX
+	ADDL	$const_StackGuard, AX
+	MOVL	AX, g_stackguard0(CX)
+	MOVL	AX, g_stackguard1(CX)
+
 	// skip runtime·ldt0setup(SB) and tls test after _cgo_init for non-windows
 	CMPL runtime·iswindows(SB), $0
 	JEQ ok
@@ -289,19 +294,12 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	JNE	2(PC)
 	INT	$3
 
-	// frame size in DI
-	// arg size in AX
-	// Save in m.
-	MOVL	DI, m_moreframesize(BX)
-	MOVL	AX, m_moreargsize(BX)
-
 	// Called from f.
 	// Set m->morebuf to f's caller.
 	MOVL	4(SP), DI	// f's caller's PC
 	MOVL	DI, (m_morebuf+gobuf_pc)(BX)
 	LEAL	8(SP), CX	// f's caller's SP
 	MOVL	CX, (m_morebuf+gobuf_sp)(BX)
-	MOVL	CX, m_moreargp(BX)
 	get_tls(CX)
 	MOVL	g(CX), SI
 	MOVL	SI, (m_morebuf+gobuf_g)(BX)
@@ -437,25 +435,6 @@ CALLFN(runtime·call268435456, 268435456)
 CALLFN(runtime·call536870912, 536870912)
 CALLFN(runtime·call1073741824, 1073741824)
 
-// Return point when leaving stack.
-//
-// Lessstack can appear in stack traces for the same reason
-// as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB), NOSPLIT, $0-0
-	// Save return value in m->cret
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	MOVL	AX, m_cret(BX)
-
-	// Call oldstack on m->g0's stack.
-	MOVL	m_g0(BX), BP
-	MOVL	BP, g(CX)
-	MOVL	(g_sched+gobuf_sp)(BP), SP
-	CALL	runtime·oldstack(SB)
-	MOVL	$0, 0x1004	// crash if oldstack returns
-	RET
-
 // bool cas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
@@ -836,10 +815,10 @@ TEXT setg_gcc<>(SB), NOSPLIT, $0
 TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
 	get_tls(CX)
 	MOVL	g(CX), AX
-	CMPL	g_stackbase(AX), SP
+	CMPL	(g_stack+stack_hi)(AX), SP
 	JHI	2(PC)
 	INT	$3
-	CMPL	SP, g_stackguard(AX)
+	CMPL	SP, (g_stack+stack_lo)(AX)
 	JHI	2(PC)
 	INT	$3
 	RET
@@ -904,15 +883,6 @@ TEXT runtime·emptyfunc(SB),0,$0-0
 TEXT runtime·abort(SB),NOSPLIT,$0-0
 	INT $0x3
 
-TEXT runtime·stackguard(SB),NOSPLIT,$0-8
-	MOVL	SP, DX
-	MOVL	DX, sp+0(FP)
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_stackguard(BX), DX
-	MOVL	DX, limit+4(FP)
-	RET
-
 GLOBL runtime·tls0(SB), $32
 
 // hash function using AES hardware instructions
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index a47fb09522..a32e03e4ee 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -19,9 +19,10 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	// _cgo_init may update stackguard.
 	MOVQ	$runtime·g0(SB), DI
 	LEAQ	(-64*1024+104)(SP), BX
-	MOVQ	BX, g_stackguard(DI)
 	MOVQ	BX, g_stackguard0(DI)
-	MOVQ	SP, g_stackbase(DI)
+	MOVQ	BX, g_stackguard1(DI)
+	MOVQ	BX, (g_stack+stack_lo)(DI)
+	MOVQ	SP, (g_stack+stack_hi)(DI)
 
 	// find out information about the processor we're on
 	MOVQ	$0, AX
@@ -42,13 +43,16 @@ nocpuinfo:
 	MOVQ	DI, CX	// Win64 uses CX for first parameter
 	MOVQ	$setg_gcc<>(SB), SI
 	CALL	AX
+
 	// update stackguard after _cgo_init
 	MOVQ	$runtime·g0(SB), CX
-	MOVQ	g_stackguard0(CX), AX
-	MOVQ	AX, g_stackguard(CX)
+	MOVQ	(g_stack+stack_lo)(CX), AX
+	ADDQ	$const_StackGuard, AX
+	MOVQ	AX, g_stackguard0(CX)
+	MOVQ	AX, g_stackguard1(CX)
+
 	CMPL	runtime·iswindows(SB), $0
 	JEQ ok
-
 needtls:
 	// skip TLS setup on Plan 9
 	CMPL	runtime·isplan9(SB), $1
@@ -261,7 +265,6 @@ onm:
  */
 
 // Called during function prolog when more stack is needed.
-// Caller has already done get_tls(CX); MOVQ m(CX), BX.
 //
 // The traceback routines see morestack on a g0 as being
 // the top of a stack (for example, morestack calling newstack
@@ -269,6 +272,8 @@ onm:
 // record an argument size. For that purpose, it has no arguments.
 TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	// Cannot grow scheduler stack (m->g0).
+	MOVQ	g(CX), BX
+	MOVQ	g_m(BX), BX
 	MOVQ	m_g0(BX), SI
 	CMPQ	g(CX), SI
 	JNE	2(PC)
@@ -286,7 +291,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVQ	AX, (m_morebuf+gobuf_pc)(BX)
 	LEAQ	16(SP), AX	// f's caller's SP
 	MOVQ	AX, (m_morebuf+gobuf_sp)(BX)
-	MOVQ	AX, m_moreargp(BX)
 	get_tls(CX)
 	MOVQ	g(CX), SI
 	MOVQ	SI, (m_morebuf+gobuf_g)(BX)
@@ -307,6 +311,11 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVQ	$0, 0x1003	// crash if newstack returns
 	RET
 
+// morestack but not preserving ctxt.
+TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
+	MOVL	$0, DX
+	JMP	runtime·morestack(SB)
+
 // reflectcall: call a function with the given argument list
 // func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
@@ -415,142 +424,6 @@ CALLFN(runtime·call268435456, 268435456)
 CALLFN(runtime·call536870912, 536870912)
 CALLFN(runtime·call1073741824, 1073741824)
 
-// Return point when leaving stack.
-//
-// Lessstack can appear in stack traces for the same reason
-// as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB), NOSPLIT, $0-0
-	// Save return value in m->cret
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	MOVQ	AX, m_cret(BX)
-
-	// Call oldstack on m->g0's stack.
-	MOVQ	m_g0(BX), BP
-	MOVQ	BP, g(CX)
-	MOVQ	(g_sched+gobuf_sp)(BP), SP
-	CALL	runtime·oldstack(SB)
-	MOVQ	$0, 0x1004	// crash if oldstack returns
-	RET
-
-// morestack trampolines
-TEXT runtime·morestack00(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	MOVQ	$0, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVQ	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack01(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	SHLQ	$32, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVQ	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack10(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	MOVLQZX	AX, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVQ	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack11(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVQ	$runtime·morestack(SB), AX
-	JMP	AX
-
-// subcases of morestack01
-// with const of 8,16,...48
-TEXT runtime·morestack8(SB),NOSPLIT,$0
-	MOVQ	$1, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack16(SB),NOSPLIT,$0
-	MOVQ	$2, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack24(SB),NOSPLIT,$0
-	MOVQ	$3, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack32(SB),NOSPLIT,$0
-	MOVQ	$4, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack40(SB),NOSPLIT,$0
-	MOVQ	$5, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack48(SB),NOSPLIT,$0
-	MOVQ	$6, R8
-	MOVQ	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT morestack<>(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_m(BX), BX
-	SHLQ	$35, R8
-	MOVQ	R8, m_moreframesize(BX)
-	MOVQ	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack00_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack00(SB)
-
-TEXT runtime·morestack01_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack01(SB)
-
-TEXT runtime·morestack10_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack10(SB)
-
-TEXT runtime·morestack11_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack11(SB)
-
-TEXT runtime·morestack8_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack8(SB)
-
-TEXT runtime·morestack16_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack16(SB)
-
-TEXT runtime·morestack24_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack24(SB)
-
-TEXT runtime·morestack32_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack32(SB)
-
-TEXT runtime·morestack40_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack40(SB)
-
-TEXT runtime·morestack48_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack48(SB)
-
 // bool cas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
@@ -922,14 +795,14 @@ TEXT setg_gcc<>(SB),NOSPLIT,$0
 	MOVQ	DI, g(AX)
 	RET
 
-// check that SP is in range [g->stackbase, g->stackguard)
+// check that SP is in range [g->stack.lo, g->stack.hi)
 TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
 	get_tls(CX)
 	MOVQ	g(CX), AX
-	CMPQ	g_stackbase(AX), SP
+	CMPQ	(g_stack+stack_hi)(AX), SP
 	JHI	2(PC)
 	INT	$3
-	CMPQ	SP, g_stackguard(AX)
+	CMPQ	SP, (g_stack+stack_lo)(AX)
 	JHI	2(PC)
 	INT	$3
 	RET
@@ -978,15 +851,6 @@ TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
 	MOVQ    AX, ret+0(FP)
 	RET
 
-TEXT runtime·stackguard(SB),NOSPLIT,$0-16
-	MOVQ	SP, DX
-	MOVQ	DX, sp+0(FP)
-	get_tls(CX)
-	MOVQ	g(CX), BX
-	MOVQ	g_stackguard(BX), DX
-	MOVQ	DX, limit+8(FP)
-	RET
-
 GLOBL runtime·tls0(SB), $64
 
 // hash function using AES hardware instructions
diff --git a/src/runtime/asm_amd64p32.s b/src/runtime/asm_amd64p32.s
index 95d04cae4f..046eb1cd6f 100644
--- a/src/runtime/asm_amd64p32.s
+++ b/src/runtime/asm_amd64p32.s
@@ -20,10 +20,11 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	
 	// create istack out of the given (operating system) stack.
 	MOVL	$runtime·g0(SB), DI
-	LEAL	(-64*1024+104)(SP), DI
-	MOVL	BX, g_stackguard(DI)
+	LEAL	(-64*1024+104)(SP), BX
 	MOVL	BX, g_stackguard0(DI)
-	MOVL	SP, g_stackbase(DI)
+	MOVL	BX, g_stackguard1(DI)
+	MOVL	BX, (g_stack+stack_lo)(DI)
+	MOVL	SP, (g_stack+stack_hi)(DI)
 
 	// find out information about the processor we're on
 	MOVQ	$0, AX
@@ -234,13 +235,16 @@ onm:
  */
 
 // Called during function prolog when more stack is needed.
-// Caller has already done get_tls(CX); MOVQ m(CX), BX.
 //
 // The traceback routines see morestack on a g0 as being
 // the top of a stack (for example, morestack calling newstack
 // calling the scheduler calling newm calling gc), so we must
 // record an argument size. For that purpose, it has no arguments.
 TEXT runtime·morestack(SB),NOSPLIT,$0-0
+	get_tls(CX)
+	MOVL	g(CX), BX
+	MOVL	g_m(BX), BX
+
 	// Cannot grow scheduler stack (m->g0).
 	MOVL	m_g0(BX), SI
 	CMPL	g(CX), SI
@@ -259,7 +263,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVL	AX, (m_morebuf+gobuf_pc)(BX)
 	LEAL	16(SP), AX	// f's caller's SP
 	MOVL	AX, (m_morebuf+gobuf_sp)(BX)
-	MOVL	AX, m_moreargp(BX)
 	get_tls(CX)
 	MOVL	g(CX), SI
 	MOVL	SI, (m_morebuf+gobuf_g)(BX)
@@ -280,6 +283,11 @@ TEXT runtime·morestack(SB),NOSPLIT,$0-0
 	MOVL	$0, 0x1003	// crash if newstack returns
 	RET
 
+// morestack trampolines
+TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0
+	MOVL	$0, DX
+	JMP	runtime·morestack(SB)
+
 // reflectcall: call a function with the given argument list
 // func call(f *FuncVal, arg *byte, argsize, retoffset uint32).
 // we don't have variable-sized frames, so we use a small number
@@ -389,142 +397,6 @@ CALLFN(runtime·call268435456, 268435456)
 CALLFN(runtime·call536870912, 536870912)
 CALLFN(runtime·call1073741824, 1073741824)
 
-// Return point when leaving stack.
-//
-// Lessstack can appear in stack traces for the same reason
-// as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB), NOSPLIT, $0-0
-	// Save return value in m->cret
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	MOVQ	AX, m_cret(BX)	// MOVQ, to save all 64 bits
-
-	// Call oldstack on m->g0's stack.
-	MOVL	m_g0(BX), BX
-	MOVL	BX, g(CX)
-	MOVL	(g_sched+gobuf_sp)(BX), SP
-	CALL	runtime·oldstack(SB)
-	MOVL	$0, 0x1004	// crash if oldstack returns
-	RET
-
-// morestack trampolines
-TEXT runtime·morestack00(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	MOVQ	$0, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVL	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack01(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	SHLQ	$32, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVL	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack10(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	MOVLQZX	AX, AX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVL	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack11(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	MOVQ	AX, m_moreframesize(BX)
-	MOVL	$runtime·morestack(SB), AX
-	JMP	AX
-
-// subcases of morestack01
-// with const of 8,16,...48
-TEXT runtime·morestack8(SB),NOSPLIT,$0
-	MOVQ	$1, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack16(SB),NOSPLIT,$0
-	MOVQ	$2, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack24(SB),NOSPLIT,$0
-	MOVQ	$3, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack32(SB),NOSPLIT,$0
-	MOVQ	$4, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack40(SB),NOSPLIT,$0
-	MOVQ	$5, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack48(SB),NOSPLIT,$0
-	MOVQ	$6, R8
-	MOVL	$morestack<>(SB), AX
-	JMP	AX
-
-TEXT morestack<>(SB),NOSPLIT,$0
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_m(BX), BX
-	SHLQ	$35, R8
-	MOVQ	R8, m_moreframesize(BX)
-	MOVL	$runtime·morestack(SB), AX
-	JMP	AX
-
-TEXT runtime·morestack00_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack00(SB)
-
-TEXT runtime·morestack01_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack01(SB)
-
-TEXT runtime·morestack10_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack10(SB)
-
-TEXT runtime·morestack11_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack11(SB)
-
-TEXT runtime·morestack8_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack8(SB)
-
-TEXT runtime·morestack16_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack16(SB)
-
-TEXT runtime·morestack24_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack24(SB)
-
-TEXT runtime·morestack32_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack32(SB)
-
-TEXT runtime·morestack40_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack40(SB)
-
-TEXT runtime·morestack48_noctxt(SB),NOSPLIT,$0
-	MOVL	$0, DX
-	JMP	runtime·morestack48(SB)
-
 // bool cas(int32 *val, int32 old, int32 new)
 // Atomically:
 //	if(*val == old){
@@ -722,10 +594,10 @@ TEXT runtime·setg(SB), NOSPLIT, $0-4
 TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
 	get_tls(CX)
 	MOVL	g(CX), AX
-	CMPL	g_stackbase(AX), SP
+	CMPL	(g_stack+stack_hi)(AX), SP
 	JHI	2(PC)
 	MOVL	0, AX
-	CMPL	SP, g_stackguard(AX)
+	CMPL	SP, (g_stack+stack_lo)(AX)
 	JHI	2(PC)
 	MOVL	0, AX
 	RET
@@ -789,15 +661,6 @@ TEXT runtime·gocputicks(SB),NOSPLIT,$0-8
 	MOVQ    AX, ret+0(FP)
 	RET
 
-TEXT runtime·stackguard(SB),NOSPLIT,$0-8
-	MOVL	SP, DX
-	MOVL	DX, sp+0(FP)
-	get_tls(CX)
-	MOVL	g(CX), BX
-	MOVL	g_stackguard(BX), DX
-	MOVL	DX, limit+4(FP)
-	RET
-
 GLOBL runtime·tls0(SB), $64
 
 // hash function using AES hardware instructions
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index af536f079c..ac78bd9dc5 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -31,9 +31,11 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$-4
 
 	// create istack out of the OS stack
 	MOVW	$(-8192+104)(R13), R0
-	MOVW	R0, g_stackguard(g)	// (w 104b guard)
 	MOVW	R0, g_stackguard0(g)
-	MOVW	R13, g_stackbase(g)
+	MOVW	R0, g_stackguard1(g)
+	MOVW	R0, (g_stack+stack_lo)(g)
+	MOVW	R13, (g_stack+stack_hi)(g)
+
 	BL	runtime·emptyfunc(SB)	// fault if stack check is wrong
 
 #ifndef GOOS_nacl
@@ -51,8 +53,10 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$-4
 
 nocgo:
 	// update stackguard after _cgo_init
-	MOVW	g_stackguard0(g), R0
-	MOVW	R0, g_stackguard(g)
+	MOVW	(g_stack+stack_lo)(g), R0
+	ADD	$const_StackGuard, R0
+	MOVW	R0, g_stackguard0(g)
+	MOVW	R0, g_stackguard1(g)
 
 	BL	runtime·checkgoarm(SB)
 	BL	runtime·check(SB)
@@ -287,9 +291,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$-4-0
 	CMP	g, R4
 	BL.EQ	runtime·abort(SB)
 
-	MOVW	R1, m_moreframesize(R8)
-	MOVW	R2, m_moreargsize(R8)
-
 	// Called from f.
 	// Set g->sched to context in f.
 	MOVW	R7, (g_sched+gobuf_ctxt)(g)
@@ -302,7 +303,6 @@ TEXT runtime·morestack(SB),NOSPLIT,$-4-0
 	MOVW	R3, (m_morebuf+gobuf_pc)(R8)	// f's caller's PC
 	MOVW	SP, (m_morebuf+gobuf_sp)(R8)	// f's caller's SP
 	MOVW	$4(SP), R3			// f's argument pointer
-	MOVW	R3, m_moreargp(R8)	
 	MOVW	g, (m_morebuf+gobuf_g)(R8)
 
 	// Call newstack on m->g0's stack.
@@ -436,22 +436,6 @@ CALLFN(runtime·call268435456, 268435456)
 CALLFN(runtime·call536870912, 536870912)
 CALLFN(runtime·call1073741824, 1073741824)
 
-// Return point when leaving stack.
-// using frame size $-4 means do not save LR on stack.
-//
-// Lessstack can appear in stack traces for the same reason
-// as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB),NOSPLIT,$-4-0
-	// Save return value in m->cret
-	MOVW	g_m(g), R8
-	MOVW	R0, m_cret(R8)
-
-	// Call oldstack on m->g0's stack.
-	MOVW	m_g0(R8), R0
-	BL	setg<>(SB)
-	MOVW	(g_sched+gobuf_sp)(g), SP
-	BL	runtime·oldstack(SB)
-
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. grab stored LR for caller
@@ -721,13 +705,6 @@ TEXT runtime·atomicloaduintptr(SB),NOSPLIT,$0-8
 TEXT runtime·atomicloaduint(SB),NOSPLIT,$0-8
 	B	runtime·atomicload(SB)
 
-TEXT runtime·stackguard(SB),NOSPLIT,$0-8
-	MOVW	R13, R1
-	MOVW	g_stackguard(g), R2
-	MOVW	R1, sp+0(FP)
-	MOVW	R2, limit+4(FP)
-	RET
-
 // AES hashing not implemented for ARM
 TEXT runtime·aeshash(SB),NOSPLIT,$-4-0
 	MOVW	$0, R0
diff --git a/src/runtime/cgo/gcc_darwin_386.c b/src/runtime/cgo/gcc_darwin_386.c
index d1ef31ed4e..6668ba4a21 100644
--- a/src/runtime/cgo/gcc_darwin_386.c
+++ b/src/runtime/cgo/gcc_darwin_386.c
@@ -100,7 +100,7 @@ x_cgo_init(G *g)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 
 	inittls();
@@ -121,7 +121,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -140,14 +141,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	pthread_setspecific(k1, (void*)ts.g);
 
 	crosscall_386(ts.fn);
diff --git a/src/runtime/cgo/gcc_darwin_amd64.c b/src/runtime/cgo/gcc_darwin_amd64.c
index 358a2816a3..dc679acab9 100644
--- a/src/runtime/cgo/gcc_darwin_amd64.c
+++ b/src/runtime/cgo/gcc_darwin_amd64.c
@@ -71,7 +71,7 @@ x_cgo_init(G *g)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 
 	inittls();
@@ -92,7 +92,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -111,14 +112,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	pthread_setspecific(k1, (void*)ts.g);
 
 	crosscall_amd64(ts.fn);
diff --git a/src/runtime/cgo/gcc_dragonfly_386.c b/src/runtime/cgo/gcc_dragonfly_386.c
index 6af61ac495..074418f77d 100644
--- a/src/runtime/cgo/gcc_dragonfly_386.c
+++ b/src/runtime/cgo/gcc_dragonfly_386.c
@@ -21,7 +21,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -59,14 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c
index a29d522946..f79f652e46 100644
--- a/src/runtime/cgo/gcc_dragonfly_amd64.c
+++ b/src/runtime/cgo/gcc_dragonfly_amd64.c
@@ -21,7 +21,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
 
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -59,14 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_freebsd_386.c b/src/runtime/cgo/gcc_freebsd_386.c
index 6af61ac495..074418f77d 100644
--- a/src/runtime/cgo/gcc_freebsd_386.c
+++ b/src/runtime/cgo/gcc_freebsd_386.c
@@ -21,7 +21,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -59,14 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_freebsd_amd64.c b/src/runtime/cgo/gcc_freebsd_amd64.c
index a29d522946..f79f652e46 100644
--- a/src/runtime/cgo/gcc_freebsd_amd64.c
+++ b/src/runtime/cgo/gcc_freebsd_amd64.c
@@ -21,7 +21,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
 
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -59,14 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_freebsd_arm.c b/src/runtime/cgo/gcc_freebsd_arm.c
index 16530f0200..2a86a91174 100644
--- a/src/runtime/cgo/gcc_freebsd_arm.c
+++ b/src/runtime/cgo/gcc_freebsd_arm.c
@@ -32,7 +32,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -56,7 +56,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	size = 0;
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -76,14 +77,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096 * 2;
-
 	crosscall_arm1(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_linux_386.c b/src/runtime/cgo/gcc_linux_386.c
index 82b156cbb0..9801c87bdb 100644
--- a/src/runtime/cgo/gcc_linux_386.c
+++ b/src/runtime/cgo/gcc_linux_386.c
@@ -19,7 +19,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -43,7 +43,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	size = 0;
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -61,14 +62,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_linux_amd64.c b/src/runtime/cgo/gcc_linux_amd64.c
index fdbf51c254..275d5ddaca 100644
--- a/src/runtime/cgo/gcc_linux_amd64.c
+++ b/src/runtime/cgo/gcc_linux_amd64.c
@@ -19,7 +19,7 @@ x_cgo_init(G* g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -38,7 +38,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -56,14 +57,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_linux_arm.c b/src/runtime/cgo/gcc_linux_arm.c
index ef16d2341a..7d4b4d6d4f 100644
--- a/src/runtime/cgo/gcc_linux_arm.c
+++ b/src/runtime/cgo/gcc_linux_arm.c
@@ -31,7 +31,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	size = 0;
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -50,14 +51,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096 * 2;
-
 	crosscall_arm1(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
@@ -71,7 +64,7 @@ x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 
 	if (x_cgo_inittls) {
diff --git a/src/runtime/cgo/gcc_netbsd_386.c b/src/runtime/cgo/gcc_netbsd_386.c
index a2b7ef3fc5..2505e6dc7c 100644
--- a/src/runtime/cgo/gcc_netbsd_386.c
+++ b/src/runtime/cgo/gcc_netbsd_386.c
@@ -20,7 +20,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -39,7 +39,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -58,14 +59,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_netbsd_amd64.c b/src/runtime/cgo/gcc_netbsd_amd64.c
index ccd08b73ce..8f646502d7 100644
--- a/src/runtime/cgo/gcc_netbsd_amd64.c
+++ b/src/runtime/cgo/gcc_netbsd_amd64.c
@@ -20,7 +20,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
 
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -59,14 +60,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_netbsd_arm.c b/src/runtime/cgo/gcc_netbsd_arm.c
index 5c0603dc6e..7a98c0de24 100644
--- a/src/runtime/cgo/gcc_netbsd_arm.c
+++ b/src/runtime/cgo/gcc_netbsd_arm.c
@@ -21,7 +21,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 }
 
@@ -40,7 +40,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -60,14 +61,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096 * 2;
-
 	crosscall_arm1(ts.fn, setg_gcc, (void*)ts.g);
 	return nil;
 }
diff --git a/src/runtime/cgo/gcc_openbsd_386.c b/src/runtime/cgo/gcc_openbsd_386.c
index 48b4bc7393..582e943f34 100644
--- a/src/runtime/cgo/gcc_openbsd_386.c
+++ b/src/runtime/cgo/gcc_openbsd_386.c
@@ -92,7 +92,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 
 	// Locate symbol for the system pthread_create function.
@@ -126,7 +126,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = sys_pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -147,14 +148,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_openbsd_amd64.c b/src/runtime/cgo/gcc_openbsd_amd64.c
index 5f0d3bb453..35b359bbaf 100644
--- a/src/runtime/cgo/gcc_openbsd_amd64.c
+++ b/src/runtime/cgo/gcc_openbsd_amd64.c
@@ -92,7 +92,7 @@ x_cgo_init(G *g, void (*setg)(void*))
 	setg_gcc = setg;
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
-	g->stackguard = (uintptr)&attr - size + 4096;
+	g->stacklo = (uintptr)&attr - size + 4096;
 	pthread_attr_destroy(&attr);
 
 	// Locate symbol for the system pthread_create function.
@@ -127,7 +127,8 @@ _cgo_sys_thread_start(ThreadStart *ts)
 	pthread_attr_init(&attr);
 	pthread_attr_getstacksize(&attr, &size);
 
-	ts->g->stackguard = size;
+	// Leave stacklo=0 and set stackhi=size; mstack will do the rest.
+	ts->g->stackhi = size;
 	err = sys_pthread_create(&p, &attr, threadentry, ts);
 
 	pthread_sigmask(SIG_SETMASK, &oset, nil);
@@ -148,14 +149,6 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-
-	/*
-	 * _cgo_sys_thread_start set stackguard to stack size;
-	 * change to actual guard pointer.
-	 */
-	ts.g->stackguard = (uintptr)&ts - ts.g->stackguard + 4096;
-
 	/*
 	 * Set specific keys.
 	 */
diff --git a/src/runtime/cgo/gcc_windows_386.c b/src/runtime/cgo/gcc_windows_386.c
index 0935b74f22..acd038ccd6 100644
--- a/src/runtime/cgo/gcc_windows_386.c
+++ b/src/runtime/cgo/gcc_windows_386.c
@@ -20,7 +20,7 @@ void
 x_cgo_init(G *g)
 {
 	int tmp;
-	g->stackguard = (uintptr)&tmp - STACKSIZE + 8*1024;
+	g->stacklo = (uintptr)&tmp - STACKSIZE + 8*1024;
 }
 
 
@@ -44,8 +44,8 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-	ts.g->stackguard = (uintptr)&ts - STACKSIZE + 8*1024;
+	ts.g->stackhi = (uintptr)&ts;
+	ts.g->stacklo = (uintptr)&ts - STACKSIZE + 8*1024;
 
 	/*
 	 * Set specific keys in thread local storage.
diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c
index 4a2540a352..ce7e06b3df 100644
--- a/src/runtime/cgo/gcc_windows_amd64.c
+++ b/src/runtime/cgo/gcc_windows_amd64.c
@@ -20,7 +20,7 @@ void
 x_cgo_init(G *g)
 {
 	int tmp;
-	g->stackguard = (uintptr)&tmp - STACKSIZE + 8*1024;
+	g->stacklo = (uintptr)&tmp - STACKSIZE + 8*1024;
 }
 
 
@@ -44,8 +44,8 @@ threadentry(void *v)
 	ts = *(ThreadStart*)v;
 	free(v);
 
-	ts.g->stackbase = (uintptr)&ts;
-	ts.g->stackguard = (uintptr)&ts - STACKSIZE + 8*1024;
+	ts.g->stackhi = (uintptr)&ts;
+	ts.g->stacklo = (uintptr)&ts - STACKSIZE + 8*1024;
 
 	/*
 	 * Set specific keys in thread local storage.
diff --git a/src/runtime/cgo/libcgo.h b/src/runtime/cgo/libcgo.h
index 799af05ead..9d918fd7ab 100644
--- a/src/runtime/cgo/libcgo.h
+++ b/src/runtime/cgo/libcgo.h
@@ -21,8 +21,8 @@ typedef uintptr_t uintptr;
 typedef struct G G;
 struct G
 {
-	uintptr stackguard;
-	uintptr stackbase;
+	uintptr stacklo;
+	uintptr stackhi;
 };
 
 /*
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 07ef26f25a..1f1b5fc794 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -24,7 +24,6 @@ func stackguard() (sp, limit uintptr)
 var Entersyscall = entersyscall
 var Exitsyscall = exitsyscall
 var LockedOSThread = lockedOSThread
-var Stackguard = stackguard
 
 type LFNode struct {
 	Next    *LFNode
diff --git a/src/runtime/heapdump.c b/src/runtime/heapdump.c
index 435e0b2dae..db2c552b72 100644
--- a/src/runtime/heapdump.c
+++ b/src/runtime/heapdump.c
@@ -382,7 +382,7 @@ dumpgoroutine(G *gp)
 	Panic *p;
 	bool (*fn)(Stkframe*, void*);
 
-	if(gp->syscallstack != (uintptr)nil) {
+	if(gp->syscallsp != (uintptr)nil) {
 		sp = gp->syscallsp;
 		pc = gp->syscallpc;
 		lr = 0;
@@ -412,8 +412,6 @@ dumpgoroutine(G *gp)
 	child.arglen = 0;
 	child.sp = nil;
 	child.depth = 0;
-	if(!ScanStackByFrames)
-		runtime·throw("need frame info to dump stacks");
 	fn = dumpframe;
 	runtime·gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, &fn, &child, false);
 
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index ca7cb6d36a..890ddea6d5 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -136,7 +136,7 @@ func mallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 						}
 						mp.mallocing = 0
 						if mp.curg != nil {
-							mp.curg.stackguard0 = mp.curg.stackguard
+							mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
 						}
 						// Note: one releasem for the acquirem just above.
 						// The other for the acquirem at start of malloc.
@@ -313,7 +313,7 @@ marked:
 		}
 		mp.mallocing = 0
 		if mp.curg != nil {
-			mp.curg.stackguard0 = mp.curg.stackguard
+			mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
 		}
 		// Note: one releasem for the acquirem just above.
 		// The other for the acquirem at start of malloc.
diff --git a/src/runtime/mgc0.c b/src/runtime/mgc0.c
index cdda6e7e6f..da0455d923 100644
--- a/src/runtime/mgc0.c
+++ b/src/runtime/mgc0.c
@@ -689,9 +689,6 @@ static void
 scanstack(G *gp)
 {
 	M *mp;
-	int32 n;
-	Stktop *stk;
-	uintptr sp, guard;
 	bool (*fn)(Stkframe*, void*);
 
 	if(runtime·readgstatus(gp)&Gscan == 0) {
@@ -719,44 +716,8 @@ scanstack(G *gp)
 	if((mp = gp->m) != nil && mp->helpgc)
 		runtime·throw("can't scan gchelper stack");
 
-	if(gp->syscallstack != (uintptr)nil) {
-		// Scanning another goroutine that is about to enter or might
-		// have just exited a system call. It may be executing code such
-		// as schedlock and may have needed to start a new stack segment.
-		// Use the stack segment and stack pointer at the time of
-		// the system call instead, since that won't change underfoot.
-		sp = gp->syscallsp;
-		stk = (Stktop*)gp->syscallstack;
-		guard = gp->syscallguard;
-	} else {
-		// Scanning another goroutine's stack.
-		// The goroutine is usually asleep (the world is stopped).
-		sp = gp->sched.sp;
-		stk = (Stktop*)gp->stackbase;
-		guard = gp->stackguard;
-	}
-	if(ScanStackByFrames) {
-		USED(sp);
-		USED(stk);
-		USED(guard);
-		fn = scanframe;
-		runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, &fn, nil, false);
-	} else {
-		n = 0;
-		while(stk) {
-			if(sp < guard-StackGuard || (uintptr)stk < sp) {
-				runtime·printf("scanstack inconsistent: g%D#%d sp=%p not in [%p,%p]\n", gp->goid, n, sp, guard-StackGuard, stk);
-				runtime·throw("scanstack");
-			}
-			if(Debug > 2)
-				runtime·printf("conservative stack %p+%p\n", (byte*)sp, (uintptr)stk-sp);
-			scanblock((byte*)sp, (uintptr)stk - sp, ScanConservatively);
-			sp = stk->gobuf.sp;
-			guard = stk->stackguard;
-			stk = (Stktop*)stk->stackbase;
-			n++;
-		}
-	}
+	fn = scanframe;
+	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, 0x7fffffff, &fn, nil, false);
 }
 
 // The gp has been moved to a gc safepoint. If there is gcphase specific
diff --git a/src/runtime/mgc0.h b/src/runtime/mgc0.h
index d04b5cab8f..0daf7511b6 100644
--- a/src/runtime/mgc0.h
+++ b/src/runtime/mgc0.h
@@ -5,8 +5,6 @@
 // Garbage collector (GC)
 
 enum {
-	ScanStackByFrames = 1,
-
 	// Four bits per word (see #defines below).
 	gcBits = 4,
 	wordsPerBitmapByte = 8/gcBits,
diff --git a/src/runtime/os_darwin.c b/src/runtime/os_darwin.c
index 2de0cd949e..bbd29282b0 100644
--- a/src/runtime/os_darwin.c
+++ b/src/runtime/os_darwin.c
@@ -144,7 +144,7 @@ void
 runtime·minit(void)
 {
 	// Initialize signal handling.
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 
 	runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
 }
diff --git a/src/runtime/os_dragonfly.c b/src/runtime/os_dragonfly.c
index 208252d9f3..e372205ec8 100644
--- a/src/runtime/os_dragonfly.c
+++ b/src/runtime/os_dragonfly.c
@@ -204,7 +204,7 @@ void
 runtime·minit(void)
 {
 	// Initialize signal handling
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·sigprocmask(&sigset_none, nil);
 }
 
diff --git a/src/runtime/os_freebsd.c b/src/runtime/os_freebsd.c
index 476def557f..cde6936de5 100644
--- a/src/runtime/os_freebsd.c
+++ b/src/runtime/os_freebsd.c
@@ -212,7 +212,7 @@ void
 runtime·minit(void)
 {
 	// Initialize signal handling
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·sigprocmask(&sigset_none, nil);
 }
 
diff --git a/src/runtime/os_linux.c b/src/runtime/os_linux.c
index 3a8c1a7579..0d8ffc995f 100644
--- a/src/runtime/os_linux.c
+++ b/src/runtime/os_linux.c
@@ -226,7 +226,7 @@ void
 runtime·minit(void)
 {
 	// Initialize signal handling.
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·rtsigprocmask(SIG_SETMASK, &sigset_none, nil, sizeof(Sigset));
 }
 
diff --git a/src/runtime/os_nacl.c b/src/runtime/os_nacl.c
index aecd61740c..14b5583033 100644
--- a/src/runtime/os_nacl.c
+++ b/src/runtime/os_nacl.c
@@ -31,7 +31,7 @@ runtime·minit(void)
 	int32 ret;
 
 	// Initialize signal handling
-	ret = runtime·nacl_exception_stack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	ret = runtime·nacl_exception_stack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	if(ret < 0)
 		runtime·printf("runtime: nacl_exception_stack: error %d\n", -ret);
 
diff --git a/src/runtime/os_netbsd.c b/src/runtime/os_netbsd.c
index db64b01c8d..58e5bedf2f 100644
--- a/src/runtime/os_netbsd.c
+++ b/src/runtime/os_netbsd.c
@@ -282,7 +282,7 @@ runtime·minit(void)
 	g->m->procid = runtime·lwp_self();
 
 	// Initialize signal handling
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
 }
 
diff --git a/src/runtime/os_openbsd.c b/src/runtime/os_openbsd.c
index 045c3a9462..91bd9449a1 100644
--- a/src/runtime/os_openbsd.c
+++ b/src/runtime/os_openbsd.c
@@ -237,7 +237,7 @@ void
 runtime·minit(void)
 {
 	// Initialize signal handling
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·sigprocmask(SIG_SETMASK, sigset_none);
 }
 
diff --git a/src/runtime/os_solaris.c b/src/runtime/os_solaris.c
index 97afdf40c1..4b382b731b 100644
--- a/src/runtime/os_solaris.c
+++ b/src/runtime/os_solaris.c
@@ -183,7 +183,7 @@ runtime·minit(void)
 {
 	runtime·asmcgocall(runtime·miniterrno, (void *)libc·___errno);
 	// Initialize signal handling
-	runtime·signalstack((byte*)g->m->gsignal->stackguard - StackGuard, 32*1024);
+	runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
 	runtime·sigprocmask(SIG_SETMASK, &sigset_none, nil);
 }
 
diff --git a/src/runtime/panic.c b/src/runtime/panic.c
index 4b21975b16..e015e41cca 100644
--- a/src/runtime/panic.c
+++ b/src/runtime/panic.c
@@ -51,8 +51,11 @@ runtime·recovery_m(G *gp)
 	argp = (void*)gp->sigcode0;
 	pc = (uintptr)gp->sigcode1;
 
-	// Unwind to the stack frame with d's arguments in it.
-	runtime·unwindstack(gp, argp);
+	// d's arguments need to be in the stack.
+	if(argp != nil && ((uintptr)argp < gp->stack.lo || gp->stack.hi < (uintptr)argp)) {
+		runtime·printf("recover: %p not in [%p, %p]\n", argp, gp->stack.lo, gp->stack.hi);
+		runtime·throw("bad recovery");
+	}
 
 	// Make the deferproc for this d return again,
 	// this time returning 1.  The calling function will
@@ -73,34 +76,6 @@ runtime·recovery_m(G *gp)
 	runtime·gogo(&gp->sched);
 }
 
-// Free stack frames until we hit the last one
-// or until we find the one that contains the sp.
-void
-runtime·unwindstack(G *gp, byte *sp)
-{
-	Stktop *top;
-	byte *stk;
-
-	// Must be called from a different goroutine, usually m->g0.
-	if(g == gp)
-		runtime·throw("unwindstack on self");
-
-	while((top = (Stktop*)gp->stackbase) != 0 && top->stackbase != 0) {
-		stk = (byte*)gp->stackguard - StackGuard;
-		if(stk <= sp && sp < (byte*)gp->stackbase)
-			break;
-		gp->stackbase = top->stackbase;
-		gp->stackguard = top->stackguard;
-		gp->stackguard0 = gp->stackguard;
-		runtime·stackfree(gp, stk, top);
-	}
-
-	if(sp != nil && (sp < (byte*)gp->stackguard - StackGuard || (byte*)gp->stackbase < sp)) {
-		runtime·printf("recover: %p not in [%p, %p]\n", sp, gp->stackguard - StackGuard, gp->stackbase);
-		runtime·throw("bad unwindstack");
-	}
-}
-
 void
 runtime·startpanic_m(void)
 {
diff --git a/src/runtime/proc.c b/src/runtime/proc.c
index 6132fee579..a7f9db410f 100644
--- a/src/runtime/proc.c
+++ b/src/runtime/proc.c
@@ -168,7 +168,6 @@ runtime·schedinit(void)
 		g->racectx = runtime·raceinit();
 
 	runtime·sched.maxmcount = 10000;
-	runtime·precisestack = true; // haveexperiment("precisestack");
 
 	runtime·symtabinit();
 	runtime·stackinit();
@@ -196,11 +195,6 @@ runtime·schedinit(void)
 	}
 	procresize(procs);
 
-	runtime·copystack = runtime·precisestack;
-	p = runtime·getenv("GOCOPYSTACK");
-	if(p != nil && !runtime·strcmp(p, (byte*)"0"))
-		runtime·copystack = false;
-
 	if(runtime·buildVersion.str == nil) {
 		// Condition should never trigger.  This code just serves
 		// to ensure runtime·buildVersion is kept in the resulting binary.
@@ -249,7 +243,7 @@ mcommoninit(M *mp)
 	checkmcount();
 	runtime·mpreinit(mp);
 	if(mp->gsignal)
-		mp->gsignal->stackguard1 = mp->gsignal->stackguard;
+		mp->gsignal->stackguard1 = mp->gsignal->stack.lo + StackGuard;
 
 	// Add to runtime·allm so garbage collector doesn't free g->m
 	// when it is just in a register or thread-local storage.
@@ -827,9 +821,34 @@ runtime·starttheworld(void)
 		g->stackguard0 = StackPreempt;
 }
 
+static void mstart(void);
+
 // Called to start an M.
+#pragma textflag NOSPLIT
 void
 runtime·mstart(void)
+{
+	uintptr x, size;
+	
+	if(g->stack.lo == 0) {
+		// Initialize stack bounds from system stack.
+		// Cgo may have left stack size in stack.hi.
+		size = g->stack.hi;
+		if(size == 0)
+			size = 8192;
+		g->stack.hi = (uintptr)&x;
+		g->stack.lo = g->stack.hi - size + 1024;
+	}
+	
+	// Initialize stack guards so that we can start calling
+	// both Go and C functions with stack growth prologues.
+	g->stackguard0 = g->stack.lo + StackGuard;
+	g->stackguard1 = g->stackguard0;
+	mstart();
+}
+
+static void
+mstart(void)
 {
 	if(g != g->m->g0)
 		runtime·throw("bad runtime·mstart");
@@ -839,7 +858,6 @@ runtime·mstart(void)
 	// so other calls can reuse this stack space.
 	runtime·gosave(&g->m->g0->sched);
 	g->m->g0->sched.pc = (uintptr)-1;  // make sure it is never used
-	g->m->g0->stackguard = g->m->g0->stackguard0;  // cgo sets only stackguard0, copy it to stackguard
 	runtime·asminit();
 	runtime·minit();
 
@@ -905,7 +923,6 @@ runtime·allocm(P *p)
 	else
 		mp->g0 = runtime·malg(8192);
 	mp->g0->m = mp;
-	mp->g0->stackguard1 = mp->g0->stackguard;
 
 	if(p == g->m->p)
 		releasep();
@@ -1003,9 +1020,9 @@ runtime·needm(byte x)
 	// scheduling stack is, but we assume there's at least 32 kB,
 	// which is more than enough for us.
 	runtime·setg(mp->g0);
-	g->stackbase = (uintptr)(&x + 1024);
-	g->stackguard = (uintptr)(&x - 32*1024);
-	g->stackguard0 = g->stackguard;
+	g->stack.hi = (uintptr)(&x + 1024);
+	g->stack.lo = (uintptr)(&x - 32*1024);
+	g->stackguard0 = g->stack.lo + StackGuard;
 
 	// Initialize this thread to use the m.
 	runtime·asminit();
@@ -1029,13 +1046,11 @@ runtime·newextram(void)
 	mp = runtime·allocm(nil);
 	gp = runtime·malg(4096);
 	gp->sched.pc = (uintptr)runtime·goexit;
-	gp->sched.sp = gp->stackbase;
+	gp->sched.sp = gp->stack.hi;
 	gp->sched.lr = 0;
 	gp->sched.g = gp;
 	gp->syscallpc = gp->sched.pc;
 	gp->syscallsp = gp->sched.sp;
-	gp->syscallstack = gp->stackbase;
-	gp->syscallguard = gp->stackguard;
 	// malg returns status as Gidle, change to Gsyscall before adding to allg
 	// where GC will see it.
 	runtime·casgstatus(gp, Gidle, Gsyscall);
@@ -1161,7 +1176,7 @@ newm(void(*fn)(void), P *p)
 		runtime·asmcgocall(_cgo_thread_start, &ts);
 		return;
 	}
-	runtime·newosproc(mp, (byte*)mp->g0->stackbase);
+	runtime·newosproc(mp, (byte*)mp->g0->stack.hi);
 }
 
 // Stops execution of the current m until new work is available.
@@ -1368,7 +1383,7 @@ execute(G *gp)
 	runtime·casgstatus(gp, Grunnable, Grunning);
 	gp->waitsince = 0;
 	gp->preempt = false;
-	gp->stackguard0 = gp->stackguard;
+	gp->stackguard0 = gp->stack.lo + StackGuard;
 	g->m->p->schedtick++;
 	g->m->curg = gp;
 	gp->m = g->m;
@@ -1693,7 +1708,7 @@ runtime·gosched_m(G *gp)
 }
 
 // Finishes execution of the current goroutine.
-// Need to mark it as nosplit, because it runs with sp > stackbase (as runtime·lessstack).
+// Need to mark it as nosplit, because it runs with sp > stackbase.
 // Since it does not return it does not matter.  But if it is preempted
 // at the split stack check, GC will complain about inconsistent sp.
 #pragma textflag NOSPLIT
@@ -1733,7 +1748,6 @@ goexit0(G *gp)
 		runtime·throw("internal lockOSThread error");
 	}	
 	g->m->locked = 0;
-	runtime·unwindstack(gp, nil);
 	gfput(g->m->p, gp);
 	schedule();
 }
@@ -1791,10 +1805,8 @@ void
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	g->syscallsp = g->sched.sp;
 	g->syscallpc = g->sched.pc;
-	g->syscallstack = g->stackbase;
-	g->syscallguard = g->stackguard;
 	runtime·casgstatus(g, Grunning, Gsyscall);
-	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
+	if(g->syscallsp < g->stack.lo || g->stack.hi < g->syscallsp) {
 		fn = entersyscall_bad;
 		runtime·onM(&fn);
 	}
@@ -1828,7 +1840,7 @@ entersyscall_bad(void)
 	
 	gp = g->m->curg;
 	runtime·printf("entersyscall inconsistent %p [%p,%p]\n",
-		gp->syscallsp, gp->syscallguard-StackGuard, gp->syscallstack);
+		gp->syscallsp, gp->stack.lo, gp->stack.hi);
 	runtime·throw("entersyscall");
 }
 
@@ -1871,10 +1883,8 @@ void
 	save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
 	g->syscallsp = g->sched.sp;
 	g->syscallpc = g->sched.pc;
-	g->syscallstack = g->stackbase;
-	g->syscallguard = g->stackguard;
 	runtime·casgstatus(g, Grunning, Gsyscall);
-	if(g->syscallsp < g->syscallguard-StackGuard || g->syscallstack < g->syscallsp) {
+	if(g->syscallsp < g->stack.lo || g->stack.hi < g->syscallsp) {
 		fn = entersyscall_bad;
 		runtime·onM(&fn);
 	}
@@ -1914,8 +1924,7 @@ runtime·exitsyscall(void)
 		runtime·casgstatus(g, Gsyscall, Grunning);
 
 		// Garbage collector isn't running (since we are),
-		// so okay to clear gcstack and gcsp.
-		g->syscallstack = (uintptr)nil;
+		// so okay to clear syscallsp.
 		g->syscallsp = (uintptr)nil;
 		g->m->locks--;
 		if(g->preempt) {
@@ -1923,7 +1932,7 @@ runtime·exitsyscall(void)
 			g->stackguard0 = StackPreempt;
 		} else {
 			// otherwise restore the real stackguard, we've spoiled it in entersyscall/entersyscallblock
-			g->stackguard0 = g->stackguard;
+			g->stackguard0 = g->stack.lo + StackGuard;
 		}
 		g->throwsplit = 0;
 		return;
@@ -1936,12 +1945,11 @@ runtime·exitsyscall(void)
 	runtime·mcall(&fn);
 
 	// Scheduler returned, so we're allowed to run now.
-	// Delete the gcstack information that we left for
+	// Delete the syscallsp information that we left for
 	// the garbage collector during the system call.
 	// Must wait until now because until gosched returns
 	// we don't know for sure that the garbage collector
 	// is not running.
-	g->syscallstack = (uintptr)nil;
 	g->syscallsp = (uintptr)nil;
 	g->m->p->syscalltick++;
 	g->throwsplit = 0;
@@ -2047,9 +2055,7 @@ beforefork(void)
 	// Code between fork and exec must not allocate memory nor even try to grow stack.
 	// Here we spoil g->stackguard to reliably detect any attempts to grow stack.
 	// runtime_AfterFork will undo this in parent process, but not in child.
-	gp->m->forkstackguard = gp->stackguard;
-	gp->stackguard0 = StackPreempt-1;
-	gp->stackguard = StackPreempt-1;
+	gp->stackguard0 = StackFork;
 }
 
 // Called from syscall package before fork.
@@ -2071,9 +2077,7 @@ afterfork(void)
 	
 	gp = g->m->curg;
 	// See the comment in runtime_BeforeFork.
-	gp->stackguard0 = gp->m->forkstackguard;
-	gp->stackguard = gp->m->forkstackguard;
-	gp->m->forkstackguard = 0;
+	gp->stackguard0 = gp->stack.lo + StackGuard;
 
 	hz = runtime·sched.profilehz;
 	if(hz != 0)
@@ -2102,10 +2106,11 @@ mstackalloc(G *gp)
 	G *newg;
 	uintptr size;
 
-	newg = (G*)gp->param;
-	size = newg->stacksize;
-	newg->stacksize = 0;
-	gp->param = runtime·stackalloc(newg, size);
+	newg = g->m->ptrarg[0];
+	size = g->m->scalararg[0];
+
+	newg->stack = runtime·stackalloc(size);
+
 	runtime·gogo(&gp->sched);
 }
 
@@ -2114,34 +2119,24 @@ G*
 runtime·malg(int32 stacksize)
 {
 	G *newg;
-	byte *stk;
 	void (*fn)(G*);
 
-	if(StackTop < sizeof(Stktop)) {
-		runtime·printf("runtime: SizeofStktop=%d, should be >=%d\n", (int32)StackTop, (int32)sizeof(Stktop));
-		runtime·throw("runtime: bad stack.h");
-	}
-
 	newg = allocg();
 	if(stacksize >= 0) {
 		stacksize = runtime·round2(StackSystem + stacksize);
 		if(g == g->m->g0) {
 			// running on scheduler stack already.
-			stk = runtime·stackalloc(newg, stacksize);
+			newg->stack = runtime·stackalloc(stacksize);
 		} else {
 			// have to call stackalloc on scheduler stack.
-			newg->stacksize = stacksize;
-			g->param = newg;
+			g->m->scalararg[0] = stacksize;
+			g->m->ptrarg[0] = newg;
 			fn = mstackalloc;
 			runtime·mcall(&fn);
-			stk = g->param;
-			g->param = nil;
+			g->m->ptrarg[0] = nil;
 		}
-		newg->stack0 = (uintptr)stk;
-		newg->stackguard = (uintptr)stk + StackGuard;
-		newg->stackguard0 = newg->stackguard;
+		newg->stackguard0 = newg->stack.lo + StackGuard;
 		newg->stackguard1 = ~(uintptr)0;
-		newg->stackbase = (uintptr)stk + stacksize - sizeof(Stktop);
 	}
 	return newg;
 }
@@ -2222,19 +2217,18 @@ runtime·newproc1(FuncVal *fn, byte *argp, int32 narg, int32 nret, void *callerp
 		runtime·throw("runtime.newproc: function arguments too large for new goroutine");
 
 	p = g->m->p;
-	if((newg = gfget(p)) != nil) {
-		if(newg->stackguard - StackGuard != newg->stack0)
-			runtime·throw("invalid stack in newg");
-	} else {
+	if((newg = gfget(p)) == nil) {
 		newg = runtime·malg(StackMin);
 		runtime·casgstatus(newg, Gidle, Gdead);
 		allgadd(newg); // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
 	}
+	if(newg->stack.hi == 0)
+		runtime·throw("newproc1: newg missing stack");
 
 	if(runtime·readgstatus(newg) != Gdead) 
 		runtime·throw("newproc1: new g is not Gdead");
 
-	sp = (byte*)newg->stackbase;
+	sp = (byte*)newg->stack.hi;
 	sp -= siz;
 	runtime·memmove(sp, argp, narg);
 	if(thechar == '5') {
@@ -2307,27 +2301,18 @@ static void
 gfput(P *p, G *gp)
 {
 	uintptr stksize;
-	Stktop *top;
 
 	if(runtime·readgstatus(gp) != Gdead) 
 		runtime·throw("gfput: bad status (not Gdead)");
 
-	if(gp->stackguard - StackGuard != gp->stack0)
-		runtime·throw("invalid stack in gfput");
-	stksize = gp->stackbase + sizeof(Stktop) - gp->stack0;
-	if(stksize != gp->stacksize) {
-		runtime·printf("runtime: bad stacksize, goroutine %D, remain=%d, last=%d\n",
-			gp->goid, (int32)gp->stacksize, (int32)stksize);
-		runtime·throw("gfput: bad stacksize");
-	}
-	top = (Stktop*)gp->stackbase;
+	stksize = gp->stack.hi - gp->stack.lo;
+	
 	if(stksize != FixedStack) {
 		// non-standard stack size - free it.
-		runtime·stackfree(gp, (void*)gp->stack0, top);
-		gp->stack0 = 0;
-		gp->stackguard = 0;
+		runtime·stackfree(gp->stack);
+		gp->stack.lo = 0;
+		gp->stack.hi = 0;
 		gp->stackguard0 = 0;
-		gp->stackbase = 0;
 	}
 	gp->schedlink = p->gfree;
 	p->gfree = gp;
@@ -2352,7 +2337,6 @@ static G*
 gfget(P *p)
 {
 	G *gp;
-	byte *stk;
 	void (*fn)(G*);
 
 retry:
@@ -2374,25 +2358,21 @@ gfget(P *p)
 		p->gfree = gp->schedlink;
 		p->gfreecnt--;
 
-		if(gp->stack0 == 0) {
+		if(gp->stack.lo == 0) {
 			// Stack was deallocated in gfput.  Allocate a new one.
 			if(g == g->m->g0) {
-				stk = runtime·stackalloc(gp, FixedStack);
+				gp->stack = runtime·stackalloc(FixedStack);
 			} else {
-				gp->stacksize = FixedStack;
-				g->param = gp;
+				g->m->scalararg[0] = FixedStack;
+				g->m->ptrarg[0] = gp;
 				fn = mstackalloc;
 				runtime·mcall(&fn);
-				stk = g->param;
-				g->param = nil;
+				g->m->ptrarg[0] = nil;
 			}
-			gp->stack0 = (uintptr)stk;
-			gp->stackbase = (uintptr)stk + FixedStack - sizeof(Stktop);
-			gp->stackguard = (uintptr)stk + StackGuard;
-			gp->stackguard0 = gp->stackguard;
+			gp->stackguard0 = gp->stack.lo + StackGuard;
 		} else {
 			if(raceenabled)
-				runtime·racemalloc((void*)gp->stack0, gp->stackbase + sizeof(Stktop) - gp->stack0);
+				runtime·racemalloc((void*)gp->stack.lo, gp->stack.hi - gp->stack.lo);
 		}
 	}
 	return gp;
@@ -2654,7 +2634,7 @@ runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp)
 	// in runtime.gogo.
 	traceback = true;
 	if(gp == nil || gp != mp->curg ||
-	   (uintptr)sp < gp->stackguard - StackGuard || gp->stackbase < (uintptr)sp ||
+	   (uintptr)sp < gp->stack.lo || gp->stack.hi < (uintptr)sp ||
 	   ((uint8*)runtime·gogo <= pc && pc < (uint8*)runtime·gogo + RuntimeGogoBytes))
 		traceback = false;
 
diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h
index 9584c5dfcc..4622a2c3d7 100644
--- a/src/runtime/runtime.h
+++ b/src/runtime/runtime.h
@@ -62,7 +62,6 @@ typedef	struct	M		M;
 typedef	struct	P		P;
 typedef	struct	Note		Note;
 typedef	struct	Slice		Slice;
-typedef	struct	Stktop		Stktop;
 typedef	struct	String		String;
 typedef	struct	FuncVal		FuncVal;
 typedef	struct	SigTab		SigTab;
@@ -74,12 +73,12 @@ typedef	struct	InterfaceType	InterfaceType;
 typedef	struct	Eface		Eface;
 typedef	struct	Type		Type;
 typedef	struct	PtrType		PtrType;
-typedef	struct	ChanType		ChanType;
+typedef	struct	ChanType	ChanType;
 typedef	struct	MapType		MapType;
 typedef	struct	Defer		Defer;
 typedef	struct	Panic		Panic;
 typedef	struct	Hmap		Hmap;
-typedef	struct	Hiter			Hiter;
+typedef	struct	Hiter		Hiter;
 typedef	struct	Hchan		Hchan;
 typedef	struct	Complex64	Complex64;
 typedef	struct	Complex128	Complex128;
@@ -92,7 +91,8 @@ typedef	struct	ParForThread	ParForThread;
 typedef	struct	CgoMal		CgoMal;
 typedef	struct	PollDesc	PollDesc;
 typedef	struct	DebugVars	DebugVars;
-typedef struct	ForceGCState	ForceGCState;
+typedef	struct	ForceGCState	ForceGCState;
+typedef	struct	Stack		Stack;
 
 /*
  * Per-CPU declaration.
@@ -265,23 +265,33 @@ struct	WinCallbackContext
 	bool	cleanstack;
 };
 
+// Stack describes a Go execution stack.
+// The bounds of the stack are exactly [lo, hi),
+// with no implicit data structures on either side.
+struct	Stack
+{
+	uintptr	lo;
+	uintptr	hi;
+};
+
 struct	G
 {
-	// stackguard0 can be set to StackPreempt as opposed to stackguard
-	uintptr	stackguard0;	// cannot move - also known to liblink, libmach, runtime/cgo
-	uintptr	stackbase;	// cannot move - also known to libmach, runtime/cgo
-	Panic*	panic;	// cannot move - also known to liblink
-	// stackguard1 is checked by C code; it is set to ~0 in ordinary (non-g0, non-gsignal) goroutines
-	uintptr	stackguard1;	// cannot move - also known to liblink
-	Defer*	defer;
+	// Stack parameters.
+	// stack describes the actual stack memory: [stack.lo, stack.hi).
+	// stackguard0 is the stack pointer compared in the Go stack growth prologue.
+	// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
+	// stackguard1 is the stack pointer compared in the C stack growth prologue.
+	// It is stack.lo+StackGuard on g0 and gsignal stacks.
+	// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
+	Stack	stack;	// offset known to runtime/cgo
+	uintptr	stackguard0;	// offset known to liblink
+	uintptr	stackguard1;	// offset known to liblink
+
+	Panic*	panic;	// innermost panic - offset known to liblink
+	Defer*	defer;	// innermost defer
 	Gobuf	sched;
-	uintptr	syscallstack;	// if status==Gsyscall, syscallstack = stackbase to use during gc
 	uintptr	syscallsp;	// if status==Gsyscall, syscallsp = sched.sp to use during gc
 	uintptr	syscallpc;	// if status==Gsyscall, syscallpc = sched.pc to use during gc
-	uintptr	syscallguard;	// if status==Gsyscall, syscallguard = stackguard to use during gc
-	uintptr	stackguard;	// same as stackguard0, but not set to StackPreempt
-	uintptr	stack0;
-	uintptr	stacksize;
 	void*	param;		// passed parameter on wakeup
 	uint32	atomicstatus;
 	int64	goid;
@@ -291,34 +301,29 @@ struct	G
 	bool	issystem;	// do not output in stack dump, ignore in deadlock detector
 	bool	preempt;	// preemption signal, duplicates stackguard0 = StackPreempt
 	bool	paniconfault;	// panic (instead of crash) on unexpected fault address
-	bool    preemptscan;    // preempted g does scan for GC
-	bool    gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
+	bool	preemptscan;    // preempted g does scan for GC
+	bool	gcworkdone;     // debug: cleared at begining of gc work phase cycle, set by gcphasework, tested at end of cycle
 	bool	throwsplit; // must not split stack
 	int8	raceignore;	// ignore race detection events
 	M*	m;		// for debuggers, but offset not hard-coded
 	M*	lockedm;
 	int32	sig;
-	int32	writenbuf;
 	Slice	writebuf;
 	uintptr	sigcode0;
 	uintptr	sigcode1;
 	uintptr	sigpc;
 	uintptr	gopc;		// pc of go statement that created this goroutine
 	uintptr	racectx;
-	SudoG   *waiting;	// sudog structures this G is waiting on (that have a valid elem ptr)
+	SudoG*	waiting;	// sudog structures this G is waiting on (that have a valid elem ptr)
 	uintptr	end[];
 };
 
 struct	M
 {
 	G*	g0;		// goroutine with scheduling stack
-	void*	moreargp;	// argument pointer for more stack
 	Gobuf	morebuf;	// gobuf arg to morestack
 
 	// Fields not known to debuggers.
-	uint32	moreframesize;	// size arguments to morestack
-	uint32	moreargsize;	// known by amd64 asm to follow moreframesize
-	uintreg	cret;		// return value from C
 	uint64	procid;		// for debuggers, but offset not hard-coded
 	G*	gsignal;	// signal-handling G
 	uintptr	tls[4];		// thread-local storage (for x86 extern register)
@@ -362,7 +367,6 @@ struct	M
 	uint8	traceback;
 	bool	(*waitunlockf)(G*, void*);
 	void*	waitlock;
-	uintptr	forkstackguard;
 	uintptr scalararg[4];	// scalar argument/return for mcall
 	void*   ptrarg[4];	// pointer argument/return for mcall
 #ifdef GOOS_windows
@@ -442,16 +446,6 @@ enum
 	LockInternal = 2,
 };
 
-struct	Stktop
-{
-	// The offsets of these fields are known to (hard-coded in) libmach.
-	uintptr	stackguard;
-	uintptr	stackbase;
-	Gobuf	gobuf;
-	uint32	argsize;
-
-	uint8*	argp;	// pointer to arguments in old frame
-};
 struct	SigTab
 {
 	int32	flags;
@@ -596,8 +590,6 @@ struct ForceGCState
 };
 
 extern uint32 runtime·gcphase;
-extern bool runtime·precisestack;
-extern bool runtime·copystack;
 
 /*
  * defined macros
@@ -758,7 +750,6 @@ void	runtime·gogo(Gobuf*);
 void	runtime·gostartcall(Gobuf*, void(*)(void), void*);
 void	runtime·gostartcallfn(Gobuf*, FuncVal*);
 void	runtime·gosave(Gobuf*);
-void	runtime·lessstack(void);
 void	runtime·goargs(void);
 void	runtime·goenvs(void);
 void	runtime·goenvs_unix(void);
@@ -809,8 +800,8 @@ int32	runtime·funcspdelta(Func*, uintptr);
 int8*	runtime·funcname(Func*);
 int32	runtime·pcdatavalue(Func*, int32, uintptr);
 void	runtime·stackinit(void);
-void*	runtime·stackalloc(G*, uint32);
-void	runtime·stackfree(G*, void*, Stktop*);
+Stack	runtime·stackalloc(uint32);
+void	runtime·stackfree(Stack);
 void	runtime·shrinkstack(G*);
 MCache*	runtime·allocmcache(void);
 void	runtime·freemcache(MCache*);
@@ -873,7 +864,6 @@ int64	runtime·unixnanotime(void); // real time, can skip
 void	runtime·dopanic(int32);
 void	runtime·startpanic(void);
 void	runtime·freezetheworld(void);
-void	runtime·unwindstack(G*, byte*);
 void	runtime·sigprof(uint8 *pc, uint8 *sp, uint8 *lr, G *gp, M *mp);
 void	runtime·resetcpuprofiler(int32);
 void	runtime·setcpuprofilerate(int32);
diff --git a/src/runtime/stack.c b/src/runtime/stack.c
index 8461c01f37..2e0c91de08 100644
--- a/src/runtime/stack.c
+++ b/src/runtime/stack.c
@@ -25,8 +25,6 @@ enum
 	StackFaultOnFree = 0,	// old stacks are mapped noaccess to detect use after free
 
 	StackCache = 1,
-	
-	StackCopyAlways = 1,	// expect to be able to copy stacks 100% of the time
 };
 
 // Global pool of spans that have free stacks.
@@ -185,13 +183,12 @@ runtime·stackcache_clear(MCache *c)
 	runtime·unlock(&stackpoolmu);
 }
 
-void*
-runtime·stackalloc(G *gp, uint32 n)
+Stack
+runtime·stackalloc(uint32 n)
 {
 	uint8 order;
 	uint32 n2;
 	void *v;
-	Stktop *top;
 	MLink *x;
 	MSpan *s;
 	MCache *c;
@@ -206,12 +203,11 @@ runtime·stackalloc(G *gp, uint32 n)
 	if(StackDebug >= 1)
 		runtime·printf("stackalloc %d\n", n);
 
-	gp->stacksize += n;
 	if(runtime·debug.efence || StackFromSystem) {
 		v = runtime·sysAlloc(ROUND(n, PageSize), &mstats.stacks_sys);
 		if(v == nil)
 			runtime·throw("out of memory (stackalloc)");
-		return v;
+		return (Stack){(uintptr)v, (uintptr)v+n};
 	}
 
 	// Small stacks are allocated with a fixed-size free-list allocator.
@@ -249,32 +245,32 @@ runtime·stackalloc(G *gp, uint32 n)
 			runtime·throw("out of memory");
 		v = (byte*)(s->start<<PageShift);
 	}
-	top = (Stktop*)((byte*)v+n-sizeof(Stktop));
-	runtime·memclr((byte*)top, sizeof(*top));
+	
 	if(raceenabled)
 		runtime·racemalloc(v, n);
 	if(StackDebug >= 1)
 		runtime·printf("  allocated %p\n", v);
-	return v;
+	return (Stack){(uintptr)v, (uintptr)v+n};
 }
 
 void
-runtime·stackfree(G *gp, void *v, Stktop *top)
+runtime·stackfree(Stack stk)
 {
 	uint8 order;
 	uintptr n, n2;
 	MSpan *s;
 	MLink *x;
 	MCache *c;
+	void *v;
 	
-	n = (uintptr)(top+1) - (uintptr)v;
+	n = stk.hi - stk.lo;
+	v = (void*)stk.lo;
 	if(n & (n-1))
 		runtime·throw("stack not a power of 2");
 	if(StackDebug >= 1) {
 		runtime·printf("stackfree %p %d\n", v, (int32)n);
 		runtime·memclr(v, n); // for testing, clobber stack data
 	}
-	gp->stacksize -= n;
 	if(runtime·debug.efence || StackFromSystem) {
 		if(runtime·debug.efence || StackFaultOnFree)
 			runtime·SysFault(v, n);
@@ -312,70 +308,6 @@ runtime·stackfree(G *gp, void *v, Stktop *top)
 	}
 }
 
-// Called from runtime·lessstack when returning from a function which
-// allocated a new stack segment.  The function's return value is in
-// m->cret.
-void
-runtime·oldstack(void)
-{
-	Stktop *top;
-	uint32 argsize;
-	byte *sp, *old;
-	uintptr *src, *dst, *dstend;
-	G *gp;
-	int64 goid;
-	int32 oldstatus;
-
-	if(StackCopyAlways)
-		runtime·throw("unexpected call to oldstack");
-
-	gp = g->m->curg;
-	top = (Stktop*)gp->stackbase;
-	if(top == nil)
-		runtime·throw("nil stackbase");
-	old = (byte*)gp->stackguard - StackGuard;
-	sp = (byte*)top;
-	argsize = top->argsize;
-
-	if(StackDebug >= 1) {
-		runtime·printf("runtime: oldstack gobuf={pc:%p sp:%p lr:%p} cret=%p argsize=%p\n",
-			top->gobuf.pc, top->gobuf.sp, top->gobuf.lr, (uintptr)g->m->cret, (uintptr)argsize);
-	}
-
-	gp->sched = top->gobuf;
-	gp->sched.ret = g->m->cret;
-	g->m->cret = 0; // drop reference
-	// gp->status is usually Grunning, but it could be Gsyscall if a stack overflow
-	// happens during a function call inside entersyscall.
-
-	oldstatus = runtime·readgstatus(gp);
-	oldstatus &= ~Gscan;
-	if(oldstatus != Grunning && oldstatus != Gsyscall) {
-		runtime·printf("runtime: oldstack status=%d\n", oldstatus);
-		runtime·throw("oldstack");
-	}
-	runtime·casgstatus(gp, oldstatus, Gcopystack);
-	gp->waitreason = runtime·gostringnocopy((byte*)"stack unsplit");	
-
-	if(argsize > 0) {
-		sp -= argsize;
-		dst = (uintptr*)top->argp;
-		dstend = dst + argsize/sizeof(*dst);
-		src = (uintptr*)sp;
-		while(dst < dstend)
-			*dst++ = *src++;
-	}
-	goid = top->gobuf.g->goid;	// fault if g is bad, before gogo
-	USED(goid);
-
-	gp->stackbase = top->stackbase;
-	gp->stackguard = top->stackguard;
-	gp->stackguard0 = gp->stackguard;
-	runtime·stackfree(gp, old, top);
-	runtime·casgstatus(gp, Gcopystack, oldstatus); // oldstatus is Grunning or Gsyscall
-	runtime·gogo(&gp->sched);
-}
-
 uintptr runtime·maxstacksize = 1<<20; // enough until runtime.main sets it for real
 
 static uint8*
@@ -403,8 +335,7 @@ mapnames[] = {
 
 typedef struct CopyableInfo CopyableInfo;
 struct CopyableInfo {
-	byte *stk;	// bottom address of segment
-	byte *base;	// top address of segment (including Stktop)
+	Stack stk;
 	int32 frames;	// count of copyable frames (-1 = not copyable)
 };
 
@@ -421,9 +352,9 @@ checkframecopy(Stkframe *frame, void *arg)
 	cinfo = arg;
 	f = frame->fn;
 	if(StackDebug >= 2)
-		runtime·printf("    checking %s frame=[%p,%p] stk=[%p,%p]\n", runtime·funcname(f), frame->sp, frame->fp, cinfo->stk, cinfo->base);
+		runtime·printf("    checking %s frame=[%p,%p] stk=[%p,%p]\n", runtime·funcname(f), frame->sp, frame->fp, cinfo->stk.lo, cinfo->stk.hi);
 	// if we're not in the segment any more, return immediately.
-	if((byte*)frame->varp < cinfo->stk || (byte*)frame->varp >= cinfo->base) {
+	if(frame->varp < cinfo->stk.lo || frame->varp >= cinfo->stk.hi) {
 		if(StackDebug >= 2)
 			runtime·printf("    <next segment>\n");
 		return false; // stop traceback
@@ -439,14 +370,12 @@ checkframecopy(Stkframe *frame, void *arg)
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: no locals info for %s\n", runtime·funcname(f));
+			runtime·printf("runtime: copystack: no locals info for %s\n", runtime·funcname(f));
 			return false;
 		}
 		if(stackmap->n <= 0) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: locals size info only for %s\n", runtime·funcname(f));
+			runtime·printf("runtime: copystack: locals size info only for %s\n", runtime·funcname(f));
 			return false;
 		}
 	}
@@ -454,8 +383,7 @@ checkframecopy(Stkframe *frame, void *arg)
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
 		if(stackmap == nil) {
 			cinfo->frames = -1;
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: no arg info for %s\n", runtime·funcname(f));
+			runtime·printf("runtime: copystack: no arg info for %s\n", runtime·funcname(f));
 			return false;
 		}
 	}
@@ -476,10 +404,9 @@ copyabletopsegment(G *gp)
 	StackMap *stackmap;
 	bool (*cb)(Stkframe*, void*);
 
-	if(gp->stackbase == 0)
-		runtime·throw("stackbase == 0");
-	cinfo.stk = (byte*)gp->stackguard - StackGuard;
-	cinfo.base = (byte*)gp->stackbase + sizeof(Stktop);
+	if(gp->stack.lo == 0)
+		runtime·throw("missing stack in copyabletopsegment");
+	cinfo.stk = gp->stack;
 	cinfo.frames = 0;
 
 	// Check that each frame is copyable.  As a side effect,
@@ -494,21 +421,20 @@ copyabletopsegment(G *gp)
 
 	// Check to make sure all Defers are copyable
 	for(d = gp->defer; d != nil; d = d->link) {
-		if(cinfo.stk <= (byte*)d && (byte*)d < cinfo.base) {
+		if(cinfo.stk.lo <= (uintptr)d && (uintptr)d < cinfo.stk.hi) {
 			// Defer is on the stack.  Its copyableness has
 			// been established during stack walking.
 			// For now, this only happens with the Defer in runtime.main.
 			continue;
 		}
-		if((byte*)d->argp < cinfo.stk || cinfo.base <= (byte*)d->argp)
+		if(d->argp < cinfo.stk.lo || cinfo.stk.hi <= d->argp)
 			break; // a defer for the next segment
 		fn = d->fn;
 		if(fn == nil) // See issue 8047
 			continue;
 		f = runtime·findfunc((uintptr)fn->fn);
 		if(f == nil) {
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: no func for deferred pc %p\n", fn->fn);
+			runtime·printf("runtime: copystack: no func for deferred pc %p\n", fn->fn);
 			return -1;
 		}
 
@@ -519,18 +445,16 @@ copyabletopsegment(G *gp)
 		// C (particularly, cgo) lies to us.  See issue 7695.
 		stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
 		if(stackmap == nil || stackmap->n <= 0) {
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: no arg info for deferred %s\n", runtime·funcname(f));
+			runtime·printf("runtime: copystack: no arg info for deferred %s\n", runtime·funcname(f));
 			return -1;
 		}
 		stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
 		if(stackmap == nil || stackmap->n <= 0) {
-			if(StackDebug >= 1 || StackCopyAlways)
-				runtime·printf("runtime: copystack: no local info for deferred %s\n", runtime·funcname(f));
+			runtime·printf("runtime: copystack: no local info for deferred %s\n", runtime·funcname(f));
 			return -1;
 		}
 
-		if(cinfo.stk <= (byte*)fn && (byte*)fn < cinfo.base) {
+		if(cinfo.stk.lo <= (uintptr)fn && (uintptr)fn < cinfo.stk.hi) {
 			// FuncVal is on the stack.  Again, its copyableness
 			// was established during stack walking.
 			continue;
@@ -548,8 +472,7 @@ copyabletopsegment(G *gp)
 
 typedef struct AdjustInfo AdjustInfo;
 struct AdjustInfo {
-	byte *oldstk;	// bottom address of segment
-	byte *oldbase;	// top address of segment (after Stktop)
+	Stack old;
 	uintptr delta;  // ptr distance from old to new stack (newbase - oldbase)
 };
 
@@ -564,8 +487,8 @@ adjustpointers(byte **scanp, BitVector *bv, AdjustInfo *adjinfo, Func *f)
 	Type *t;
 	Itab *tab;
 	
-	minp = adjinfo->oldstk;
-	maxp = adjinfo->oldbase;
+	minp = (byte*)adjinfo->old.lo;
+	maxp = (byte*)adjinfo->old.hi;
 	delta = adjinfo->delta;
 	num = bv->n / BitsPerPointer;
 	for(i = 0; i < num; i++) {
@@ -693,7 +616,7 @@ adjustframe(Stkframe *frame, void *arg)
 static void
 adjustctxt(G *gp, AdjustInfo *adjinfo)
 {
-	if(adjinfo->oldstk <= (byte*)gp->sched.ctxt && (byte*)gp->sched.ctxt < adjinfo->oldbase)
+	if(adjinfo->old.lo <= (uintptr)gp->sched.ctxt && (uintptr)gp->sched.ctxt < adjinfo->old.hi)
 		gp->sched.ctxt = (byte*)gp->sched.ctxt + adjinfo->delta;
 }
 
@@ -707,7 +630,7 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 	BitVector bv;
 
 	for(dp = &gp->defer, d = *dp; d != nil; dp = &d->link, d = *dp) {
-		if(adjinfo->oldstk <= (byte*)d && (byte*)d < adjinfo->oldbase) {
+		if(adjinfo->old.lo <= (uintptr)d && (uintptr)d < adjinfo->old.hi) {
 			// The Defer record is on the stack.  Its fields will
 			// get adjusted appropriately.
 			// This only happens for runtime.main and runtime.gopanic now,
@@ -719,8 +642,12 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 			*dp = (Defer*)((byte*)d + adjinfo->delta);
 			continue;
 		}
-		if((byte*)d->argp < adjinfo->oldstk || adjinfo->oldbase <= (byte*)d->argp)
-			break; // a defer for the next segment
+		if(d->argp == NoArgs)
+			continue;
+		if(d->argp < adjinfo->old.lo || adjinfo->old.hi <= d->argp) {
+			runtime·printf("runtime: adjustdefers argp=%p stk=%p %p\n", d->argp, adjinfo->old.lo, adjinfo->old.hi);
+			runtime·throw("adjustdefers: unexpected argp");
+		}
 		fn = d->fn;
 		if(fn == nil) {
 			// Defer of nil function.  It will panic when run, and there
@@ -734,7 +661,7 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
 		if(StackDebug >= 4)
 			runtime·printf("  checking defer %s\n", runtime·funcname(f));
 		// Defer's FuncVal might be on the stack
-		if(adjinfo->oldstk <= (byte*)fn && (byte*)fn < adjinfo->oldbase) {
+		if(adjinfo->old.lo <= (uintptr)fn && (uintptr)fn < adjinfo->old.hi) {
 			if(StackDebug >= 3)
 				runtime·printf("    adjust defer fn %s\n", runtime·funcname(f));
 			d->fn = (FuncVal*)((byte*)fn + adjinfo->delta);
@@ -758,7 +685,7 @@ adjustpanics(G *gp, AdjustInfo *adjinfo)
 	// Panic structs are all on the stack
 	// and are adjusted by stack copying.
 	// The only pointer we need to update is gp->panic, the head of the list.
-	if(adjinfo->oldstk <= (byte*)gp->panic && (byte*)gp->panic < adjinfo->oldbase)
+	if(adjinfo->old.lo <= (uintptr)gp->panic && (uintptr)gp->panic < adjinfo->old.hi)
 		gp->panic = (Panic*)((byte*)gp->panic + adjinfo->delta);
 }
 
@@ -772,10 +699,10 @@ adjustsudogs(G *gp, AdjustInfo *adjinfo)
 	// might be in the stack.
 	for(s = gp->waiting; s != nil; s = s->waitlink) {
 		e = s->elem;
-		if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
+		if(adjinfo->old.lo <= (uintptr)e && (uintptr)e < adjinfo->old.hi)
 			s->elem = e + adjinfo->delta;
 		e = (byte*)s->selectdone;
-		if(adjinfo->oldstk <= e && e < adjinfo->oldbase)
+		if(adjinfo->old.lo <= (uintptr)e && (uintptr)e < adjinfo->old.hi)
 			s->selectdone = (uint32*)(e + adjinfo->delta);
 	}
 }
@@ -785,36 +712,28 @@ adjustsudogs(G *gp, AdjustInfo *adjinfo)
 static void
 copystack(G *gp, uintptr nframes, uintptr newsize)
 {
-	byte *oldstk, *oldbase, *newstk, *newbase;
-	uintptr oldsize, used;
+	Stack old, new;
+	uintptr used;
 	AdjustInfo adjinfo;
-	Stktop *oldtop, *newtop;
 	uint32 oldstatus;
 	bool (*cb)(Stkframe*, void*);
 
-	if(gp->syscallstack != 0)
-		runtime·throw("can't handle stack copy in syscall yet");
-	oldstk = (byte*)gp->stackguard - StackGuard;
-	if(gp->stackbase == 0)
+	if(gp->syscallsp != 0)
+		runtime·throw("stack growth not allowed in system call");
+	old = gp->stack;
+	if(old.lo == 0)
 		runtime·throw("nil stackbase");
-	oldbase = (byte*)gp->stackbase + sizeof(Stktop);
-	oldsize = oldbase - oldstk;
-	used = oldbase - (byte*)gp->sched.sp;
-	oldtop = (Stktop*)gp->stackbase;
+	used = old.hi - gp->sched.sp;
 
 	// allocate new stack
-	newstk = runtime·stackalloc(gp, newsize);
-	newbase = newstk + newsize;
-	newtop = (Stktop*)(newbase - sizeof(Stktop));
+	new = runtime·stackalloc(newsize);
 
 	if(StackDebug >= 1)
-		runtime·printf("copystack gp=%p [%p %p]/%d -> [%p %p]/%d\n", gp, oldstk, oldbase, (int32)oldsize, newstk, newbase, (int32)newsize);
-	USED(oldsize);
+		runtime·printf("copystack gp=%p [%p %p %p]/%d -> [%p %p %p]/%d\n", gp, old.lo, old.hi-used, old.hi, (int32)(old.hi-old.lo), new.lo, new.hi-used, new.hi, (int32)newsize);
 	
 	// adjust pointers in the to-be-copied frames
-	adjinfo.oldstk = oldstk;
-	adjinfo.oldbase = oldbase;
-	adjinfo.delta = newbase - oldbase;
+	adjinfo.old = old;
+	adjinfo.delta = new.hi - old.hi;
 	cb = adjustframe;
 	runtime·gentraceback(~(uintptr)0, ~(uintptr)0, 0, gp, 0, nil, nframes, &cb, &adjinfo, false);
 	
@@ -824,26 +743,25 @@ copystack(G *gp, uintptr nframes, uintptr newsize)
 	adjustpanics(gp, &adjinfo);
 	adjustsudogs(gp, &adjinfo);
 	
-	// copy the stack (including Stktop) to the new location
-	runtime·memmove(newbase - used, oldbase - used, used);
+	// copy the stack to the new location
+	runtime·memmove((byte*)new.hi - used, (byte*)old.hi - used, used);
+
 	oldstatus = runtime·readgstatus(gp);
 	oldstatus &= ~Gscan;
-	if (oldstatus == Gwaiting || oldstatus == Grunnable)
+	if(oldstatus == Gwaiting || oldstatus == Grunnable)
 		runtime·casgstatus(gp, oldstatus, Gcopystack); // oldstatus is Gwaiting or Grunnable
 	else
 		runtime·throw("copystack: bad status, not Gwaiting or Grunnable");
+
 	// Swap out old stack for new one
-	gp->stackbase = (uintptr)newtop;
-	gp->stackguard = (uintptr)newstk + StackGuard;
-	gp->stackguard0 = (uintptr)newstk + StackGuard; // NOTE: might clobber a preempt request
-	if(gp->stack0 == (uintptr)oldstk)
-		gp->stack0 = (uintptr)newstk;
-	gp->sched.sp = (uintptr)(newbase - used);
+	gp->stack = new;
+	gp->stackguard0 = new.lo + StackGuard; // NOTE: might clobber a preempt request
+	gp->sched.sp = new.hi - used;
 
 	runtime·casgstatus(gp, Gcopystack, oldstatus); // oldstatus is Gwaiting or Grunnable
 
 	// free old stack
-	runtime·stackfree(gp, oldstk, oldtop);
+	runtime·stackfree(old);
 }
 
 // round x up to a power of 2.
@@ -858,27 +776,22 @@ runtime·round2(int32 x)
 	return 1 << s;
 }
 
-// Called from runtime·morestack when a new stack segment is needed.
-// Allocate a new stack big enough for m->moreframesize bytes,
-// copy m->moreargsize bytes to the new frame,
-// and then act as though runtime·lessstack called the function at m->morepc.
+// Called from runtime·morestack when more stack is needed.
+// Allocate larger stack and relocate to new stack.
+// Stack growth is multiplicative, for constant amortized cost.
 //
-// g->atomicstatus will be Grunning, Gsyscall or Gscanrunning, Gscansyscall upon entry. 
+// g->atomicstatus will be Grunning or Gscanrunning upon entry. 
 // If the GC is trying to stop this g then it will set preemptscan to true.
 void
 runtime·newstack(void)
 {
-	int32 framesize, argsize, oldstatus, oldsize, newsize, nframes;
-	Stktop *top;
-	byte *stk, *oldstk, *oldbase;
+	int32 oldsize, newsize, nframes;
 	uintptr sp;
-	uintptr *src, *dst, *dstend;
 	G *gp;
-	Gobuf label, morebuf;
-	void *moreargp;
+	Gobuf morebuf;
 
-	if(g->m->forkstackguard)
-		runtime·throw("split stack after fork");
+	if(g->m->morebuf.g->stackguard0 == (uintptr)StackFork)
+		runtime·throw("stack growth after fork");
 	if(g->m->morebuf.g != g->m->curg) {
 		runtime·printf("runtime: newstack called from g=%p\n"
 			"\tm=%p m->curg=%p m->g0=%p m->gsignal=%p\n",
@@ -890,64 +803,50 @@ runtime·newstack(void)
 	if(g->throwsplit)
 		runtime·throw("runtime: stack split at bad time");
 
-	// The goroutine must be executing in order to call newstack, so the possible states are
-	// Grunning and Gsyscall (and, due to GC, also Gscanrunning and Gscansyscall).	
+	// The goroutine must be executing in order to call newstack,
+	// so it must be Grunning or Gscanrunning.
 
-	// gp->status is usually Grunning, but it could be Gsyscall if a stack overflow
-	// happens during a function call inside entersyscall.
 	gp = g->m->curg;
-	oldstatus = runtime·readgstatus(gp) & ~Gscan;
-	framesize = g->m->moreframesize;
-	argsize = g->m->moreargsize;
-	moreargp = g->m->moreargp;
-	g->m->moreargp = nil;
 	morebuf = g->m->morebuf;
 	g->m->morebuf.pc = (uintptr)nil;
 	g->m->morebuf.lr = (uintptr)nil;
 	g->m->morebuf.sp = (uintptr)nil;
 
-	runtime·casgstatus(gp, oldstatus, Gwaiting); // oldstatus is not in a Gscan status
+	runtime·casgstatus(gp, Grunning, Gwaiting);
 	gp->waitreason = runtime·gostringnocopy((byte*)"stack growth");
 
 	runtime·rewindmorestack(&gp->sched);
 
-	if(gp->stackbase == 0)
-		runtime·throw("nil stackbase");
+	if(gp->stack.lo == 0)
+		runtime·throw("missing stack in newstack");
 	sp = gp->sched.sp;
 	if(thechar == '6' || thechar == '8') {
 		// The call to morestack cost a word.
 		sp -= sizeof(uintreg);
 	}
-	if(StackDebug >= 1 || sp < gp->stackguard - StackGuard) {
-		runtime·printf("runtime: newstack framesize=%p argsize=%p sp=%p stack=[%p, %p]\n"
+	if(StackDebug >= 1 || sp < gp->stack.lo) {
+		runtime·printf("runtime: newstack sp=%p stack=[%p, %p]\n"
 			"\tmorebuf={pc:%p sp:%p lr:%p}\n"
 			"\tsched={pc:%p sp:%p lr:%p ctxt:%p}\n",
-			(uintptr)framesize, (uintptr)argsize, sp, gp->stackguard - StackGuard, gp->stackbase,
+			sp, gp->stack.lo, gp->stack.hi,
 			g->m->morebuf.pc, g->m->morebuf.sp, g->m->morebuf.lr,
 			gp->sched.pc, gp->sched.sp, gp->sched.lr, gp->sched.ctxt);
 	}
-	if(sp < gp->stackguard - StackGuard) {
-		runtime·printf("runtime: gp=%p, gp->status=%d, oldstatus=%d\n ", (void*)gp, runtime·readgstatus(gp), oldstatus);
-		runtime·printf("runtime: split stack overflow: %p < %p\n", sp, gp->stackguard - StackGuard);
+	if(sp < gp->stack.lo) {
+		runtime·printf("runtime: gp=%p, gp->status=%d\n ", (void*)gp, runtime·readgstatus(gp));
+		runtime·printf("runtime: split stack overflow: %p < %p\n", sp, gp->stack.lo);
 		runtime·throw("runtime: split stack overflow");
 	}
 
-	if(argsize % sizeof(uintptr) != 0) {
-		runtime·printf("runtime: stack growth with misaligned argsize %d\n", argsize);
-		runtime·throw("runtime: stack growth argsize");
-	}
-
 	if(gp->stackguard0 == (uintptr)StackPreempt) {
 		if(gp == g->m->g0)
 			runtime·throw("runtime: preempt g0");
-		if(oldstatus == Grunning && g->m->p == nil && g->m->locks == 0)
+		if(g->m->p == nil && g->m->locks == 0)
 			runtime·throw("runtime: g is running but p is not");
-		if(oldstatus == Gsyscall && g->m->locks == 0)
-			runtime·throw("runtime: stack growth during syscall");
-		if(oldstatus == Grunning && gp->preemptscan) {
+		if(gp->preemptscan) {
 			runtime·gcphasework(gp);
 			runtime·casgstatus(gp, Gwaiting, Grunning);
-			gp->stackguard0 = gp->stackguard;
+			gp->stackguard0 = gp->stack.lo + StackGuard;
 			gp->preempt = false; 
 			gp->preemptscan = false;        // Tells the GC premption was successful.
 			runtime·gogo(&gp->sched);	// never return 
@@ -955,105 +854,37 @@ runtime·newstack(void)
 
 		// Be conservative about where we preempt.
 		// We are interested in preempting user Go code, not runtime code.
-		if(oldstatus != Grunning || g->m->locks || g->m->mallocing || g->m->gcing || g->m->p->status != Prunning) {
+		if(g->m->locks || g->m->mallocing || g->m->gcing || g->m->p->status != Prunning) {
 			// Let the goroutine keep running for now.
 			// gp->preempt is set, so it will be preempted next time.
-			gp->stackguard0 = gp->stackguard;
-			runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
+			gp->stackguard0 = gp->stack.lo + StackGuard;
+			runtime·casgstatus(gp, Gwaiting, Grunning);
 			runtime·gogo(&gp->sched);	// never return
 		}
 		// Act like goroutine called runtime.Gosched.
-		runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
+		runtime·casgstatus(gp, Gwaiting, Grunning);
 		runtime·gosched_m(gp);	// never return
 	}
 
-	// If every frame on the top segment is copyable, allocate a bigger segment
-	// and move the segment instead of allocating a new segment.
-	if(runtime·copystack) {
-		if(!runtime·precisestack)
-			runtime·throw("can't copy stacks without precise stacks");
-		nframes = copyabletopsegment(gp);
-		if(nframes != -1) {
-			oldstk = (byte*)gp->stackguard - StackGuard;
-			oldbase = (byte*)gp->stackbase + sizeof(Stktop);
-			oldsize = oldbase - oldstk;
-			newsize = oldsize * 2;
-			// Note that the concurrent GC might be scanning the stack as we try to replace it.
-			// copystack takes care of the appropriate coordination with the stack scanner.
-			copystack(gp, nframes, newsize);
-			if(StackDebug >= 1)
-				runtime·printf("stack grow done\n");
-			if(gp->stacksize > runtime·maxstacksize) {
-				runtime·printf("runtime: goroutine stack exceeds %D-byte limit\n", (uint64)runtime·maxstacksize);
-				runtime·throw("stack overflow");
-			}
-			runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Gsyscall or Grunning
-			runtime·gogo(&gp->sched);
-		}
-		// TODO: if stack is uncopyable because we're in C code, patch return value at
-		// end of C code to trigger a copy as soon as C code exits.  That way, we'll
-		// have stack available if we get this deep again.
-	}
+	// Allocate a bigger segment and move the stack.
+	nframes = copyabletopsegment(gp);
+	if(nframes == -1)
+		runtime·throw("unable to grow stack");
 	
-	if(StackCopyAlways)
-		runtime·throw("split stack not allowed");
-
-	// allocate new segment.
-	framesize += argsize;
-	framesize += StackExtra;	// room for more functions, Stktop.
-	if(framesize < StackMin)
-		framesize = StackMin;
-	framesize += StackSystem;
-	framesize = runtime·round2(framesize);
-	stk = runtime·stackalloc(gp, framesize);
-	if(gp->stacksize > runtime·maxstacksize) {
+	oldsize = gp->stack.hi - gp->stack.lo;
+	newsize = oldsize * 2;
+	if(newsize > runtime·maxstacksize) {
 		runtime·printf("runtime: goroutine stack exceeds %D-byte limit\n", (uint64)runtime·maxstacksize);
 		runtime·throw("stack overflow");
 	}
-	top = (Stktop*)(stk+framesize-sizeof(*top));
 
-	if(StackDebug >= 1) {
-		runtime·printf("\t-> new stack gp=%p [%p, %p]\n", gp, stk, top);
-	}
-
-	top->stackbase = gp->stackbase;
-	top->stackguard = gp->stackguard;
-	top->gobuf = morebuf;
-	top->argp = moreargp;
-	top->argsize = argsize;
-
-	gp->stackbase = (uintptr)top;
-	gp->stackguard = (uintptr)stk + StackGuard;
-	gp->stackguard0 = gp->stackguard;
-
-	sp = (uintptr)top;
-	if(argsize > 0) {
-		sp -= argsize;
-		dst = (uintptr*)sp;
-		dstend = dst + argsize/sizeof(*dst);
-		src = (uintptr*)top->argp;
-		while(dst < dstend)
-			*dst++ = *src++;
-	}
-	
-	if(thechar == '5') {
-		// caller would have saved its LR below args.
-		sp -= sizeof(void*);
-		*(void**)sp = nil;
-	}
-
-	// Continue as if lessstack had just called m->morepc
-	// (the PC that decided to grow the stack).
-	runtime·memclr((byte*)&label, sizeof label);
-	label.sp = sp;
-	label.pc = (uintptr)runtime·lessstack;
-	label.g = g->m->curg;
-	runtime·gostartcall(&label, (void(*)(void))gp->sched.pc, gp->sched.ctxt);
-	gp->sched.ctxt = nil;
-	runtime·casgstatus(gp, Gwaiting, oldstatus); // oldstatus is Grunning or Gsyscall
-	runtime·gogo(&label);
-
-	*(int32*)345 = 123;	// never return
+	// Note that the concurrent GC might be scanning the stack as we try to replace it.
+	// copystack takes care of the appropriate coordination with the stack scanner.
+	copystack(gp, nframes, newsize);
+	if(StackDebug >= 1)
+		runtime·printf("stack grow done\n");
+	runtime·casgstatus(gp, Gwaiting, Grunning);
+	runtime·gogo(&gp->sched);
 }
 
 #pragma textflag NOSPLIT
@@ -1083,28 +914,24 @@ void
 runtime·shrinkstack(G *gp)
 {
 	int32 nframes;
-	byte *oldstk, *oldbase;
 	uintptr used, oldsize, newsize;
 
-	if(!runtime·copystack)
-		return;
 	if(runtime·readgstatus(gp) == Gdead)
 		return;
-	if(gp->stackbase == 0)
-		runtime·throw("stackbase == 0");
+	if(gp->stack.lo == 0)
+		runtime·throw("missing stack in shrinkstack");
 	//return; // TODO: why does this happen?
-	oldstk = (byte*)gp->stackguard - StackGuard;
-	oldbase = (byte*)gp->stackbase + sizeof(Stktop);
-	oldsize = oldbase - oldstk;
+	oldsize = gp->stack.hi - gp->stack.lo;
 	newsize = oldsize / 2;
 	if(newsize < FixedStack)
 		return; // don't shrink below the minimum-sized stack
-	used = oldbase - (byte*)gp->sched.sp;
+	used = gp->stack.hi - gp->sched.sp;
 	if(used >= oldsize / 4)
 		return; // still using at least 1/4 of the segment.
 
-	if(gp->syscallstack != (uintptr)nil) // TODO: can we handle this case?
+	if(gp->syscallsp != 0) // TODO: can we handle this case?
 		return;
+
 #ifdef GOOS_windows
 	if(gp->m != nil && gp->m->libcallsp != 0)
 		return;
diff --git a/src/runtime/stack.h b/src/runtime/stack.h
index 7f8c43ee54..b30e322166 100644
--- a/src/runtime/stack.h
+++ b/src/runtime/stack.h
@@ -99,11 +99,6 @@ enum {
 	// The maximum number of bytes that a chain of NOSPLIT
 	// functions can use.
 	StackLimit = StackGuard - StackSystem - StackSmall,
-	
-	// The assumed size of the top-of-stack data block.
-	// The actual size can be smaller than this but cannot be larger.
-	// Checked in proc.c's runtime.malg.
-	StackTop = 88,
 };
 
 // Goroutine preemption request.
@@ -117,3 +112,4 @@ enum
 	StackPreempt = -1314,
 };
 */
+#define StackFork ((uint64)-1234)
diff --git a/src/runtime/stack_gen_test.go b/src/runtime/stack_gen_test.go
deleted file mode 100644
index 28101062cc..0000000000
--- a/src/runtime/stack_gen_test.go
+++ /dev/null
@@ -1,1473 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime_test
-
-import (
-	. "runtime"
-)
-
-var splitTests = []func() (uintptr, uintptr){
-	// Edit .+1,/^}/-1|seq 4 4 5000 | sed 's/.*/	stack&,/' | fmt
-	stack4, stack8, stack12, stack16, stack20, stack24, stack28,
-	stack32, stack36, stack40, stack44, stack48, stack52, stack56,
-	stack60, stack64, stack68, stack72, stack76, stack80, stack84,
-	stack88, stack92, stack96, stack100, stack104, stack108, stack112,
-	stack116, stack120, stack124, stack128, stack132, stack136,
-	stack140, stack144, stack148, stack152, stack156, stack160,
-	stack164, stack168, stack172, stack176, stack180, stack184,
-	stack188, stack192, stack196, stack200, stack204, stack208,
-	stack212, stack216, stack220, stack224, stack228, stack232,
-	stack236, stack240, stack244, stack248, stack252, stack256,
-	stack260, stack264, stack268, stack272, stack276, stack280,
-	stack284, stack288, stack292, stack296, stack300, stack304,
-	stack308, stack312, stack316, stack320, stack324, stack328,
-	stack332, stack336, stack340, stack344, stack348, stack352,
-	stack356, stack360, stack364, stack368, stack372, stack376,
-	stack380, stack384, stack388, stack392, stack396, stack400,
-	stack404, stack408, stack412, stack416, stack420, stack424,
-	stack428, stack432, stack436, stack440, stack444, stack448,
-	stack452, stack456, stack460, stack464, stack468, stack472,
-	stack476, stack480, stack484, stack488, stack492, stack496,
-	stack500, stack504, stack508, stack512, stack516, stack520,
-	stack524, stack528, stack532, stack536, stack540, stack544,
-	stack548, stack552, stack556, stack560, stack564, stack568,
-	stack572, stack576, stack580, stack584, stack588, stack592,
-	stack596, stack600, stack604, stack608, stack612, stack616,
-	stack620, stack624, stack628, stack632, stack636, stack640,
-	stack644, stack648, stack652, stack656, stack660, stack664,
-	stack668, stack672, stack676, stack680, stack684, stack688,
-	stack692, stack696, stack700, stack704, stack708, stack712,
-	stack716, stack720, stack724, stack728, stack732, stack736,
-	stack740, stack744, stack748, stack752, stack756, stack760,
-	stack764, stack768, stack772, stack776, stack780, stack784,
-	stack788, stack792, stack796, stack800, stack804, stack808,
-	stack812, stack816, stack820, stack824, stack828, stack832,
-	stack836, stack840, stack844, stack848, stack852, stack856,
-	stack860, stack864, stack868, stack872, stack876, stack880,
-	stack884, stack888, stack892, stack896, stack900, stack904,
-	stack908, stack912, stack916, stack920, stack924, stack928,
-	stack932, stack936, stack940, stack944, stack948, stack952,
-	stack956, stack960, stack964, stack968, stack972, stack976,
-	stack980, stack984, stack988, stack992, stack996, stack1000,
-	stack1004, stack1008, stack1012, stack1016, stack1020, stack1024,
-	stack1028, stack1032, stack1036, stack1040, stack1044, stack1048,
-	stack1052, stack1056, stack1060, stack1064, stack1068, stack1072,
-	stack1076, stack1080, stack1084, stack1088, stack1092, stack1096,
-	stack1100, stack1104, stack1108, stack1112, stack1116, stack1120,
-	stack1124, stack1128, stack1132, stack1136, stack1140, stack1144,
-	stack1148, stack1152, stack1156, stack1160, stack1164, stack1168,
-	stack1172, stack1176, stack1180, stack1184, stack1188, stack1192,
-	stack1196, stack1200, stack1204, stack1208, stack1212, stack1216,
-	stack1220, stack1224, stack1228, stack1232, stack1236, stack1240,
-	stack1244, stack1248, stack1252, stack1256, stack1260, stack1264,
-	stack1268, stack1272, stack1276, stack1280, stack1284, stack1288,
-	stack1292, stack1296, stack1300, stack1304, stack1308, stack1312,
-	stack1316, stack1320, stack1324, stack1328, stack1332, stack1336,
-	stack1340, stack1344, stack1348, stack1352, stack1356, stack1360,
-	stack1364, stack1368, stack1372, stack1376, stack1380, stack1384,
-	stack1388, stack1392, stack1396, stack1400, stack1404, stack1408,
-	stack1412, stack1416, stack1420, stack1424, stack1428, stack1432,
-	stack1436, stack1440, stack1444, stack1448, stack1452, stack1456,
-	stack1460, stack1464, stack1468, stack1472, stack1476, stack1480,
-	stack1484, stack1488, stack1492, stack1496, stack1500, stack1504,
-	stack1508, stack1512, stack1516, stack1520, stack1524, stack1528,
-	stack1532, stack1536, stack1540, stack1544, stack1548, stack1552,
-	stack1556, stack1560, stack1564, stack1568, stack1572, stack1576,
-	stack1580, stack1584, stack1588, stack1592, stack1596, stack1600,
-	stack1604, stack1608, stack1612, stack1616, stack1620, stack1624,
-	stack1628, stack1632, stack1636, stack1640, stack1644, stack1648,
-	stack1652, stack1656, stack1660, stack1664, stack1668, stack1672,
-	stack1676, stack1680, stack1684, stack1688, stack1692, stack1696,
-	stack1700, stack1704, stack1708, stack1712, stack1716, stack1720,
-	stack1724, stack1728, stack1732, stack1736, stack1740, stack1744,
-	stack1748, stack1752, stack1756, stack1760, stack1764, stack1768,
-	stack1772, stack1776, stack1780, stack1784, stack1788, stack1792,
-	stack1796, stack1800, stack1804, stack1808, stack1812, stack1816,
-	stack1820, stack1824, stack1828, stack1832, stack1836, stack1840,
-	stack1844, stack1848, stack1852, stack1856, stack1860, stack1864,
-	stack1868, stack1872, stack1876, stack1880, stack1884, stack1888,
-	stack1892, stack1896, stack1900, stack1904, stack1908, stack1912,
-	stack1916, stack1920, stack1924, stack1928, stack1932, stack1936,
-	stack1940, stack1944, stack1948, stack1952, stack1956, stack1960,
-	stack1964, stack1968, stack1972, stack1976, stack1980, stack1984,
-	stack1988, stack1992, stack1996, stack2000, stack2004, stack2008,
-	stack2012, stack2016, stack2020, stack2024, stack2028, stack2032,
-	stack2036, stack2040, stack2044, stack2048, stack2052, stack2056,
-	stack2060, stack2064, stack2068, stack2072, stack2076, stack2080,
-	stack2084, stack2088, stack2092, stack2096, stack2100, stack2104,
-	stack2108, stack2112, stack2116, stack2120, stack2124, stack2128,
-	stack2132, stack2136, stack2140, stack2144, stack2148, stack2152,
-	stack2156, stack2160, stack2164, stack2168, stack2172, stack2176,
-	stack2180, stack2184, stack2188, stack2192, stack2196, stack2200,
-	stack2204, stack2208, stack2212, stack2216, stack2220, stack2224,
-	stack2228, stack2232, stack2236, stack2240, stack2244, stack2248,
-	stack2252, stack2256, stack2260, stack2264, stack2268, stack2272,
-	stack2276, stack2280, stack2284, stack2288, stack2292, stack2296,
-	stack2300, stack2304, stack2308, stack2312, stack2316, stack2320,
-	stack2324, stack2328, stack2332, stack2336, stack2340, stack2344,
-	stack2348, stack2352, stack2356, stack2360, stack2364, stack2368,
-	stack2372, stack2376, stack2380, stack2384, stack2388, stack2392,
-	stack2396, stack2400, stack2404, stack2408, stack2412, stack2416,
-	stack2420, stack2424, stack2428, stack2432, stack2436, stack2440,
-	stack2444, stack2448, stack2452, stack2456, stack2460, stack2464,
-	stack2468, stack2472, stack2476, stack2480, stack2484, stack2488,
-	stack2492, stack2496, stack2500, stack2504, stack2508, stack2512,
-	stack2516, stack2520, stack2524, stack2528, stack2532, stack2536,
-	stack2540, stack2544, stack2548, stack2552, stack2556, stack2560,
-	stack2564, stack2568, stack2572, stack2576, stack2580, stack2584,
-	stack2588, stack2592, stack2596, stack2600, stack2604, stack2608,
-	stack2612, stack2616, stack2620, stack2624, stack2628, stack2632,
-	stack2636, stack2640, stack2644, stack2648, stack2652, stack2656,
-	stack2660, stack2664, stack2668, stack2672, stack2676, stack2680,
-	stack2684, stack2688, stack2692, stack2696, stack2700, stack2704,
-	stack2708, stack2712, stack2716, stack2720, stack2724, stack2728,
-	stack2732, stack2736, stack2740, stack2744, stack2748, stack2752,
-	stack2756, stack2760, stack2764, stack2768, stack2772, stack2776,
-	stack2780, stack2784, stack2788, stack2792, stack2796, stack2800,
-	stack2804, stack2808, stack2812, stack2816, stack2820, stack2824,
-	stack2828, stack2832, stack2836, stack2840, stack2844, stack2848,
-	stack2852, stack2856, stack2860, stack2864, stack2868, stack2872,
-	stack2876, stack2880, stack2884, stack2888, stack2892, stack2896,
-	stack2900, stack2904, stack2908, stack2912, stack2916, stack2920,
-	stack2924, stack2928, stack2932, stack2936, stack2940, stack2944,
-	stack2948, stack2952, stack2956, stack2960, stack2964, stack2968,
-	stack2972, stack2976, stack2980, stack2984, stack2988, stack2992,
-	stack2996, stack3000, stack3004, stack3008, stack3012, stack3016,
-	stack3020, stack3024, stack3028, stack3032, stack3036, stack3040,
-	stack3044, stack3048, stack3052, stack3056, stack3060, stack3064,
-	stack3068, stack3072, stack3076, stack3080, stack3084, stack3088,
-	stack3092, stack3096, stack3100, stack3104, stack3108, stack3112,
-	stack3116, stack3120, stack3124, stack3128, stack3132, stack3136,
-	stack3140, stack3144, stack3148, stack3152, stack3156, stack3160,
-	stack3164, stack3168, stack3172, stack3176, stack3180, stack3184,
-	stack3188, stack3192, stack3196, stack3200, stack3204, stack3208,
-	stack3212, stack3216, stack3220, stack3224, stack3228, stack3232,
-	stack3236, stack3240, stack3244, stack3248, stack3252, stack3256,
-	stack3260, stack3264, stack3268, stack3272, stack3276, stack3280,
-	stack3284, stack3288, stack3292, stack3296, stack3300, stack3304,
-	stack3308, stack3312, stack3316, stack3320, stack3324, stack3328,
-	stack3332, stack3336, stack3340, stack3344, stack3348, stack3352,
-	stack3356, stack3360, stack3364, stack3368, stack3372, stack3376,
-	stack3380, stack3384, stack3388, stack3392, stack3396, stack3400,
-	stack3404, stack3408, stack3412, stack3416, stack3420, stack3424,
-	stack3428, stack3432, stack3436, stack3440, stack3444, stack3448,
-	stack3452, stack3456, stack3460, stack3464, stack3468, stack3472,
-	stack3476, stack3480, stack3484, stack3488, stack3492, stack3496,
-	stack3500, stack3504, stack3508, stack3512, stack3516, stack3520,
-	stack3524, stack3528, stack3532, stack3536, stack3540, stack3544,
-	stack3548, stack3552, stack3556, stack3560, stack3564, stack3568,
-	stack3572, stack3576, stack3580, stack3584, stack3588, stack3592,
-	stack3596, stack3600, stack3604, stack3608, stack3612, stack3616,
-	stack3620, stack3624, stack3628, stack3632, stack3636, stack3640,
-	stack3644, stack3648, stack3652, stack3656, stack3660, stack3664,
-	stack3668, stack3672, stack3676, stack3680, stack3684, stack3688,
-	stack3692, stack3696, stack3700, stack3704, stack3708, stack3712,
-	stack3716, stack3720, stack3724, stack3728, stack3732, stack3736,
-	stack3740, stack3744, stack3748, stack3752, stack3756, stack3760,
-	stack3764, stack3768, stack3772, stack3776, stack3780, stack3784,
-	stack3788, stack3792, stack3796, stack3800, stack3804, stack3808,
-	stack3812, stack3816, stack3820, stack3824, stack3828, stack3832,
-	stack3836, stack3840, stack3844, stack3848, stack3852, stack3856,
-	stack3860, stack3864, stack3868, stack3872, stack3876, stack3880,
-	stack3884, stack3888, stack3892, stack3896, stack3900, stack3904,
-	stack3908, stack3912, stack3916, stack3920, stack3924, stack3928,
-	stack3932, stack3936, stack3940, stack3944, stack3948, stack3952,
-	stack3956, stack3960, stack3964, stack3968, stack3972, stack3976,
-	stack3980, stack3984, stack3988, stack3992, stack3996, stack4000,
-	stack4004, stack4008, stack4012, stack4016, stack4020, stack4024,
-	stack4028, stack4032, stack4036, stack4040, stack4044, stack4048,
-	stack4052, stack4056, stack4060, stack4064, stack4068, stack4072,
-	stack4076, stack4080, stack4084, stack4088, stack4092, stack4096,
-	stack4100, stack4104, stack4108, stack4112, stack4116, stack4120,
-	stack4124, stack4128, stack4132, stack4136, stack4140, stack4144,
-	stack4148, stack4152, stack4156, stack4160, stack4164, stack4168,
-	stack4172, stack4176, stack4180, stack4184, stack4188, stack4192,
-	stack4196, stack4200, stack4204, stack4208, stack4212, stack4216,
-	stack4220, stack4224, stack4228, stack4232, stack4236, stack4240,
-	stack4244, stack4248, stack4252, stack4256, stack4260, stack4264,
-	stack4268, stack4272, stack4276, stack4280, stack4284, stack4288,
-	stack4292, stack4296, stack4300, stack4304, stack4308, stack4312,
-	stack4316, stack4320, stack4324, stack4328, stack4332, stack4336,
-	stack4340, stack4344, stack4348, stack4352, stack4356, stack4360,
-	stack4364, stack4368, stack4372, stack4376, stack4380, stack4384,
-	stack4388, stack4392, stack4396, stack4400, stack4404, stack4408,
-	stack4412, stack4416, stack4420, stack4424, stack4428, stack4432,
-	stack4436, stack4440, stack4444, stack4448, stack4452, stack4456,
-	stack4460, stack4464, stack4468, stack4472, stack4476, stack4480,
-	stack4484, stack4488, stack4492, stack4496, stack4500, stack4504,
-	stack4508, stack4512, stack4516, stack4520, stack4524, stack4528,
-	stack4532, stack4536, stack4540, stack4544, stack4548, stack4552,
-	stack4556, stack4560, stack4564, stack4568, stack4572, stack4576,
-	stack4580, stack4584, stack4588, stack4592, stack4596, stack4600,
-	stack4604, stack4608, stack4612, stack4616, stack4620, stack4624,
-	stack4628, stack4632, stack4636, stack4640, stack4644, stack4648,
-	stack4652, stack4656, stack4660, stack4664, stack4668, stack4672,
-	stack4676, stack4680, stack4684, stack4688, stack4692, stack4696,
-	stack4700, stack4704, stack4708, stack4712, stack4716, stack4720,
-	stack4724, stack4728, stack4732, stack4736, stack4740, stack4744,
-	stack4748, stack4752, stack4756, stack4760, stack4764, stack4768,
-	stack4772, stack4776, stack4780, stack4784, stack4788, stack4792,
-	stack4796, stack4800, stack4804, stack4808, stack4812, stack4816,
-	stack4820, stack4824, stack4828, stack4832, stack4836, stack4840,
-	stack4844, stack4848, stack4852, stack4856, stack4860, stack4864,
-	stack4868, stack4872, stack4876, stack4880, stack4884, stack4888,
-	stack4892, stack4896, stack4900, stack4904, stack4908, stack4912,
-	stack4916, stack4920, stack4924, stack4928, stack4932, stack4936,
-	stack4940, stack4944, stack4948, stack4952, stack4956, stack4960,
-	stack4964, stack4968, stack4972, stack4976, stack4980, stack4984,
-	stack4988, stack4992, stack4996, stack5000,
-}
-
-// Edit .+1,$ | seq 4 4 5000 | sed 's/.*/func stack&()(uintptr, uintptr) { var buf [&]byte; use(buf[:]); return Stackguard() }/'
-func stack4() (uintptr, uintptr)    { var buf [4]byte; use(buf[:]); return Stackguard() }
-func stack8() (uintptr, uintptr)    { var buf [8]byte; use(buf[:]); return Stackguard() }
-func stack12() (uintptr, uintptr)   { var buf [12]byte; use(buf[:]); return Stackguard() }
-func stack16() (uintptr, uintptr)   { var buf [16]byte; use(buf[:]); return Stackguard() }
-func stack20() (uintptr, uintptr)   { var buf [20]byte; use(buf[:]); return Stackguard() }
-func stack24() (uintptr, uintptr)   { var buf [24]byte; use(buf[:]); return Stackguard() }
-func stack28() (uintptr, uintptr)   { var buf [28]byte; use(buf[:]); return Stackguard() }
-func stack32() (uintptr, uintptr)   { var buf [32]byte; use(buf[:]); return Stackguard() }
-func stack36() (uintptr, uintptr)   { var buf [36]byte; use(buf[:]); return Stackguard() }
-func stack40() (uintptr, uintptr)   { var buf [40]byte; use(buf[:]); return Stackguard() }
-func stack44() (uintptr, uintptr)   { var buf [44]byte; use(buf[:]); return Stackguard() }
-func stack48() (uintptr, uintptr)   { var buf [48]byte; use(buf[:]); return Stackguard() }
-func stack52() (uintptr, uintptr)   { var buf [52]byte; use(buf[:]); return Stackguard() }
-func stack56() (uintptr, uintptr)   { var buf [56]byte; use(buf[:]); return Stackguard() }
-func stack60() (uintptr, uintptr)   { var buf [60]byte; use(buf[:]); return Stackguard() }
-func stack64() (uintptr, uintptr)   { var buf [64]byte; use(buf[:]); return Stackguard() }
-func stack68() (uintptr, uintptr)   { var buf [68]byte; use(buf[:]); return Stackguard() }
-func stack72() (uintptr, uintptr)   { var buf [72]byte; use(buf[:]); return Stackguard() }
-func stack76() (uintptr, uintptr)   { var buf [76]byte; use(buf[:]); return Stackguard() }
-func stack80() (uintptr, uintptr)   { var buf [80]byte; use(buf[:]); return Stackguard() }
-func stack84() (uintptr, uintptr)   { var buf [84]byte; use(buf[:]); return Stackguard() }
-func stack88() (uintptr, uintptr)   { var buf [88]byte; use(buf[:]); return Stackguard() }
-func stack92() (uintptr, uintptr)   { var buf [92]byte; use(buf[:]); return Stackguard() }
-func stack96() (uintptr, uintptr)   { var buf [96]byte; use(buf[:]); return Stackguard() }
-func stack100() (uintptr, uintptr)  { var buf [100]byte; use(buf[:]); return Stackguard() }
-func stack104() (uintptr, uintptr)  { var buf [104]byte; use(buf[:]); return Stackguard() }
-func stack108() (uintptr, uintptr)  { var buf [108]byte; use(buf[:]); return Stackguard() }
-func stack112() (uintptr, uintptr)  { var buf [112]byte; use(buf[:]); return Stackguard() }
-func stack116() (uintptr, uintptr)  { var buf [116]byte; use(buf[:]); return Stackguard() }
-func stack120() (uintptr, uintptr)  { var buf [120]byte; use(buf[:]); return Stackguard() }
-func stack124() (uintptr, uintptr)  { var buf [124]byte; use(buf[:]); return Stackguard() }
-func stack128() (uintptr, uintptr)  { var buf [128]byte; use(buf[:]); return Stackguard() }
-func stack132() (uintptr, uintptr)  { var buf [132]byte; use(buf[:]); return Stackguard() }
-func stack136() (uintptr, uintptr)  { var buf [136]byte; use(buf[:]); return Stackguard() }
-func stack140() (uintptr, uintptr)  { var buf [140]byte; use(buf[:]); return Stackguard() }
-func stack144() (uintptr, uintptr)  { var buf [144]byte; use(buf[:]); return Stackguard() }
-func stack148() (uintptr, uintptr)  { var buf [148]byte; use(buf[:]); return Stackguard() }
-func stack152() (uintptr, uintptr)  { var buf [152]byte; use(buf[:]); return Stackguard() }
-func stack156() (uintptr, uintptr)  { var buf [156]byte; use(buf[:]); return Stackguard() }
-func stack160() (uintptr, uintptr)  { var buf [160]byte; use(buf[:]); return Stackguard() }
-func stack164() (uintptr, uintptr)  { var buf [164]byte; use(buf[:]); return Stackguard() }
-func stack168() (uintptr, uintptr)  { var buf [168]byte; use(buf[:]); return Stackguard() }
-func stack172() (uintptr, uintptr)  { var buf [172]byte; use(buf[:]); return Stackguard() }
-func stack176() (uintptr, uintptr)  { var buf [176]byte; use(buf[:]); return Stackguard() }
-func stack180() (uintptr, uintptr)  { var buf [180]byte; use(buf[:]); return Stackguard() }
-func stack184() (uintptr, uintptr)  { var buf [184]byte; use(buf[:]); return Stackguard() }
-func stack188() (uintptr, uintptr)  { var buf [188]byte; use(buf[:]); return Stackguard() }
-func stack192() (uintptr, uintptr)  { var buf [192]byte; use(buf[:]); return Stackguard() }
-func stack196() (uintptr, uintptr)  { var buf [196]byte; use(buf[:]); return Stackguard() }
-func stack200() (uintptr, uintptr)  { var buf [200]byte; use(buf[:]); return Stackguard() }
-func stack204() (uintptr, uintptr)  { var buf [204]byte; use(buf[:]); return Stackguard() }
-func stack208() (uintptr, uintptr)  { var buf [208]byte; use(buf[:]); return Stackguard() }
-func stack212() (uintptr, uintptr)  { var buf [212]byte; use(buf[:]); return Stackguard() }
-func stack216() (uintptr, uintptr)  { var buf [216]byte; use(buf[:]); return Stackguard() }
-func stack220() (uintptr, uintptr)  { var buf [220]byte; use(buf[:]); return Stackguard() }
-func stack224() (uintptr, uintptr)  { var buf [224]byte; use(buf[:]); return Stackguard() }
-func stack228() (uintptr, uintptr)  { var buf [228]byte; use(buf[:]); return Stackguard() }
-func stack232() (uintptr, uintptr)  { var buf [232]byte; use(buf[:]); return Stackguard() }
-func stack236() (uintptr, uintptr)  { var buf [236]byte; use(buf[:]); return Stackguard() }
-func stack240() (uintptr, uintptr)  { var buf [240]byte; use(buf[:]); return Stackguard() }
-func stack244() (uintptr, uintptr)  { var buf [244]byte; use(buf[:]); return Stackguard() }
-func stack248() (uintptr, uintptr)  { var buf [248]byte; use(buf[:]); return Stackguard() }
-func stack252() (uintptr, uintptr)  { var buf [252]byte; use(buf[:]); return Stackguard() }
-func stack256() (uintptr, uintptr)  { var buf [256]byte; use(buf[:]); return Stackguard() }
-func stack260() (uintptr, uintptr)  { var buf [260]byte; use(buf[:]); return Stackguard() }
-func stack264() (uintptr, uintptr)  { var buf [264]byte; use(buf[:]); return Stackguard() }
-func stack268() (uintptr, uintptr)  { var buf [268]byte; use(buf[:]); return Stackguard() }
-func stack272() (uintptr, uintptr)  { var buf [272]byte; use(buf[:]); return Stackguard() }
-func stack276() (uintptr, uintptr)  { var buf [276]byte; use(buf[:]); return Stackguard() }
-func stack280() (uintptr, uintptr)  { var buf [280]byte; use(buf[:]); return Stackguard() }
-func stack284() (uintptr, uintptr)  { var buf [284]byte; use(buf[:]); return Stackguard() }
-func stack288() (uintptr, uintptr)  { var buf [288]byte; use(buf[:]); return Stackguard() }
-func stack292() (uintptr, uintptr)  { var buf [292]byte; use(buf[:]); return Stackguard() }
-func stack296() (uintptr, uintptr)  { var buf [296]byte; use(buf[:]); return Stackguard() }
-func stack300() (uintptr, uintptr)  { var buf [300]byte; use(buf[:]); return Stackguard() }
-func stack304() (uintptr, uintptr)  { var buf [304]byte; use(buf[:]); return Stackguard() }
-func stack308() (uintptr, uintptr)  { var buf [308]byte; use(buf[:]); return Stackguard() }
-func stack312() (uintptr, uintptr)  { var buf [312]byte; use(buf[:]); return Stackguard() }
-func stack316() (uintptr, uintptr)  { var buf [316]byte; use(buf[:]); return Stackguard() }
-func stack320() (uintptr, uintptr)  { var buf [320]byte; use(buf[:]); return Stackguard() }
-func stack324() (uintptr, uintptr)  { var buf [324]byte; use(buf[:]); return Stackguard() }
-func stack328() (uintptr, uintptr)  { var buf [328]byte; use(buf[:]); return Stackguard() }
-func stack332() (uintptr, uintptr)  { var buf [332]byte; use(buf[:]); return Stackguard() }
-func stack336() (uintptr, uintptr)  { var buf [336]byte; use(buf[:]); return Stackguard() }
-func stack340() (uintptr, uintptr)  { var buf [340]byte; use(buf[:]); return Stackguard() }
-func stack344() (uintptr, uintptr)  { var buf [344]byte; use(buf[:]); return Stackguard() }
-func stack348() (uintptr, uintptr)  { var buf [348]byte; use(buf[:]); return Stackguard() }
-func stack352() (uintptr, uintptr)  { var buf [352]byte; use(buf[:]); return Stackguard() }
-func stack356() (uintptr, uintptr)  { var buf [356]byte; use(buf[:]); return Stackguard() }
-func stack360() (uintptr, uintptr)  { var buf [360]byte; use(buf[:]); return Stackguard() }
-func stack364() (uintptr, uintptr)  { var buf [364]byte; use(buf[:]); return Stackguard() }
-func stack368() (uintptr, uintptr)  { var buf [368]byte; use(buf[:]); return Stackguard() }
-func stack372() (uintptr, uintptr)  { var buf [372]byte; use(buf[:]); return Stackguard() }
-func stack376() (uintptr, uintptr)  { var buf [376]byte; use(buf[:]); return Stackguard() }
-func stack380() (uintptr, uintptr)  { var buf [380]byte; use(buf[:]); return Stackguard() }
-func stack384() (uintptr, uintptr)  { var buf [384]byte; use(buf[:]); return Stackguard() }
-func stack388() (uintptr, uintptr)  { var buf [388]byte; use(buf[:]); return Stackguard() }
-func stack392() (uintptr, uintptr)  { var buf [392]byte; use(buf[:]); return Stackguard() }
-func stack396() (uintptr, uintptr)  { var buf [396]byte; use(buf[:]); return Stackguard() }
-func stack400() (uintptr, uintptr)  { var buf [400]byte; use(buf[:]); return Stackguard() }
-func stack404() (uintptr, uintptr)  { var buf [404]byte; use(buf[:]); return Stackguard() }
-func stack408() (uintptr, uintptr)  { var buf [408]byte; use(buf[:]); return Stackguard() }
-func stack412() (uintptr, uintptr)  { var buf [412]byte; use(buf[:]); return Stackguard() }
-func stack416() (uintptr, uintptr)  { var buf [416]byte; use(buf[:]); return Stackguard() }
-func stack420() (uintptr, uintptr)  { var buf [420]byte; use(buf[:]); return Stackguard() }
-func stack424() (uintptr, uintptr)  { var buf [424]byte; use(buf[:]); return Stackguard() }
-func stack428() (uintptr, uintptr)  { var buf [428]byte; use(buf[:]); return Stackguard() }
-func stack432() (uintptr, uintptr)  { var buf [432]byte; use(buf[:]); return Stackguard() }
-func stack436() (uintptr, uintptr)  { var buf [436]byte; use(buf[:]); return Stackguard() }
-func stack440() (uintptr, uintptr)  { var buf [440]byte; use(buf[:]); return Stackguard() }
-func stack444() (uintptr, uintptr)  { var buf [444]byte; use(buf[:]); return Stackguard() }
-func stack448() (uintptr, uintptr)  { var buf [448]byte; use(buf[:]); return Stackguard() }
-func stack452() (uintptr, uintptr)  { var buf [452]byte; use(buf[:]); return Stackguard() }
-func stack456() (uintptr, uintptr)  { var buf [456]byte; use(buf[:]); return Stackguard() }
-func stack460() (uintptr, uintptr)  { var buf [460]byte; use(buf[:]); return Stackguard() }
-func stack464() (uintptr, uintptr)  { var buf [464]byte; use(buf[:]); return Stackguard() }
-func stack468() (uintptr, uintptr)  { var buf [468]byte; use(buf[:]); return Stackguard() }
-func stack472() (uintptr, uintptr)  { var buf [472]byte; use(buf[:]); return Stackguard() }
-func stack476() (uintptr, uintptr)  { var buf [476]byte; use(buf[:]); return Stackguard() }
-func stack480() (uintptr, uintptr)  { var buf [480]byte; use(buf[:]); return Stackguard() }
-func stack484() (uintptr, uintptr)  { var buf [484]byte; use(buf[:]); return Stackguard() }
-func stack488() (uintptr, uintptr)  { var buf [488]byte; use(buf[:]); return Stackguard() }
-func stack492() (uintptr, uintptr)  { var buf [492]byte; use(buf[:]); return Stackguard() }
-func stack496() (uintptr, uintptr)  { var buf [496]byte; use(buf[:]); return Stackguard() }
-func stack500() (uintptr, uintptr)  { var buf [500]byte; use(buf[:]); return Stackguard() }
-func stack504() (uintptr, uintptr)  { var buf [504]byte; use(buf[:]); return Stackguard() }
-func stack508() (uintptr, uintptr)  { var buf [508]byte; use(buf[:]); return Stackguard() }
-func stack512() (uintptr, uintptr)  { var buf [512]byte; use(buf[:]); return Stackguard() }
-func stack516() (uintptr, uintptr)  { var buf [516]byte; use(buf[:]); return Stackguard() }
-func stack520() (uintptr, uintptr)  { var buf [520]byte; use(buf[:]); return Stackguard() }
-func stack524() (uintptr, uintptr)  { var buf [524]byte; use(buf[:]); return Stackguard() }
-func stack528() (uintptr, uintptr)  { var buf [528]byte; use(buf[:]); return Stackguard() }
-func stack532() (uintptr, uintptr)  { var buf [532]byte; use(buf[:]); return Stackguard() }
-func stack536() (uintptr, uintptr)  { var buf [536]byte; use(buf[:]); return Stackguard() }
-func stack540() (uintptr, uintptr)  { var buf [540]byte; use(buf[:]); return Stackguard() }
-func stack544() (uintptr, uintptr)  { var buf [544]byte; use(buf[:]); return Stackguard() }
-func stack548() (uintptr, uintptr)  { var buf [548]byte; use(buf[:]); return Stackguard() }
-func stack552() (uintptr, uintptr)  { var buf [552]byte; use(buf[:]); return Stackguard() }
-func stack556() (uintptr, uintptr)  { var buf [556]byte; use(buf[:]); return Stackguard() }
-func stack560() (uintptr, uintptr)  { var buf [560]byte; use(buf[:]); return Stackguard() }
-func stack564() (uintptr, uintptr)  { var buf [564]byte; use(buf[:]); return Stackguard() }
-func stack568() (uintptr, uintptr)  { var buf [568]byte; use(buf[:]); return Stackguard() }
-func stack572() (uintptr, uintptr)  { var buf [572]byte; use(buf[:]); return Stackguard() }
-func stack576() (uintptr, uintptr)  { var buf [576]byte; use(buf[:]); return Stackguard() }
-func stack580() (uintptr, uintptr)  { var buf [580]byte; use(buf[:]); return Stackguard() }
-func stack584() (uintptr, uintptr)  { var buf [584]byte; use(buf[:]); return Stackguard() }
-func stack588() (uintptr, uintptr)  { var buf [588]byte; use(buf[:]); return Stackguard() }
-func stack592() (uintptr, uintptr)  { var buf [592]byte; use(buf[:]); return Stackguard() }
-func stack596() (uintptr, uintptr)  { var buf [596]byte; use(buf[:]); return Stackguard() }
-func stack600() (uintptr, uintptr)  { var buf [600]byte; use(buf[:]); return Stackguard() }
-func stack604() (uintptr, uintptr)  { var buf [604]byte; use(buf[:]); return Stackguard() }
-func stack608() (uintptr, uintptr)  { var buf [608]byte; use(buf[:]); return Stackguard() }
-func stack612() (uintptr, uintptr)  { var buf [612]byte; use(buf[:]); return Stackguard() }
-func stack616() (uintptr, uintptr)  { var buf [616]byte; use(buf[:]); return Stackguard() }
-func stack620() (uintptr, uintptr)  { var buf [620]byte; use(buf[:]); return Stackguard() }
-func stack624() (uintptr, uintptr)  { var buf [624]byte; use(buf[:]); return Stackguard() }
-func stack628() (uintptr, uintptr)  { var buf [628]byte; use(buf[:]); return Stackguard() }
-func stack632() (uintptr, uintptr)  { var buf [632]byte; use(buf[:]); return Stackguard() }
-func stack636() (uintptr, uintptr)  { var buf [636]byte; use(buf[:]); return Stackguard() }
-func stack640() (uintptr, uintptr)  { var buf [640]byte; use(buf[:]); return Stackguard() }
-func stack644() (uintptr, uintptr)  { var buf [644]byte; use(buf[:]); return Stackguard() }
-func stack648() (uintptr, uintptr)  { var buf [648]byte; use(buf[:]); return Stackguard() }
-func stack652() (uintptr, uintptr)  { var buf [652]byte; use(buf[:]); return Stackguard() }
-func stack656() (uintptr, uintptr)  { var buf [656]byte; use(buf[:]); return Stackguard() }
-func stack660() (uintptr, uintptr)  { var buf [660]byte; use(buf[:]); return Stackguard() }
-func stack664() (uintptr, uintptr)  { var buf [664]byte; use(buf[:]); return Stackguard() }
-func stack668() (uintptr, uintptr)  { var buf [668]byte; use(buf[:]); return Stackguard() }
-func stack672() (uintptr, uintptr)  { var buf [672]byte; use(buf[:]); return Stackguard() }
-func stack676() (uintptr, uintptr)  { var buf [676]byte; use(buf[:]); return Stackguard() }
-func stack680() (uintptr, uintptr)  { var buf [680]byte; use(buf[:]); return Stackguard() }
-func stack684() (uintptr, uintptr)  { var buf [684]byte; use(buf[:]); return Stackguard() }
-func stack688() (uintptr, uintptr)  { var buf [688]byte; use(buf[:]); return Stackguard() }
-func stack692() (uintptr, uintptr)  { var buf [692]byte; use(buf[:]); return Stackguard() }
-func stack696() (uintptr, uintptr)  { var buf [696]byte; use(buf[:]); return Stackguard() }
-func stack700() (uintptr, uintptr)  { var buf [700]byte; use(buf[:]); return Stackguard() }
-func stack704() (uintptr, uintptr)  { var buf [704]byte; use(buf[:]); return Stackguard() }
-func stack708() (uintptr, uintptr)  { var buf [708]byte; use(buf[:]); return Stackguard() }
-func stack712() (uintptr, uintptr)  { var buf [712]byte; use(buf[:]); return Stackguard() }
-func stack716() (uintptr, uintptr)  { var buf [716]byte; use(buf[:]); return Stackguard() }
-func stack720() (uintptr, uintptr)  { var buf [720]byte; use(buf[:]); return Stackguard() }
-func stack724() (uintptr, uintptr)  { var buf [724]byte; use(buf[:]); return Stackguard() }
-func stack728() (uintptr, uintptr)  { var buf [728]byte; use(buf[:]); return Stackguard() }
-func stack732() (uintptr, uintptr)  { var buf [732]byte; use(buf[:]); return Stackguard() }
-func stack736() (uintptr, uintptr)  { var buf [736]byte; use(buf[:]); return Stackguard() }
-func stack740() (uintptr, uintptr)  { var buf [740]byte; use(buf[:]); return Stackguard() }
-func stack744() (uintptr, uintptr)  { var buf [744]byte; use(buf[:]); return Stackguard() }
-func stack748() (uintptr, uintptr)  { var buf [748]byte; use(buf[:]); return Stackguard() }
-func stack752() (uintptr, uintptr)  { var buf [752]byte; use(buf[:]); return Stackguard() }
-func stack756() (uintptr, uintptr)  { var buf [756]byte; use(buf[:]); return Stackguard() }
-func stack760() (uintptr, uintptr)  { var buf [760]byte; use(buf[:]); return Stackguard() }
-func stack764() (uintptr, uintptr)  { var buf [764]byte; use(buf[:]); return Stackguard() }
-func stack768() (uintptr, uintptr)  { var buf [768]byte; use(buf[:]); return Stackguard() }
-func stack772() (uintptr, uintptr)  { var buf [772]byte; use(buf[:]); return Stackguard() }
-func stack776() (uintptr, uintptr)  { var buf [776]byte; use(buf[:]); return Stackguard() }
-func stack780() (uintptr, uintptr)  { var buf [780]byte; use(buf[:]); return Stackguard() }
-func stack784() (uintptr, uintptr)  { var buf [784]byte; use(buf[:]); return Stackguard() }
-func stack788() (uintptr, uintptr)  { var buf [788]byte; use(buf[:]); return Stackguard() }
-func stack792() (uintptr, uintptr)  { var buf [792]byte; use(buf[:]); return Stackguard() }
-func stack796() (uintptr, uintptr)  { var buf [796]byte; use(buf[:]); return Stackguard() }
-func stack800() (uintptr, uintptr)  { var buf [800]byte; use(buf[:]); return Stackguard() }
-func stack804() (uintptr, uintptr)  { var buf [804]byte; use(buf[:]); return Stackguard() }
-func stack808() (uintptr, uintptr)  { var buf [808]byte; use(buf[:]); return Stackguard() }
-func stack812() (uintptr, uintptr)  { var buf [812]byte; use(buf[:]); return Stackguard() }
-func stack816() (uintptr, uintptr)  { var buf [816]byte; use(buf[:]); return Stackguard() }
-func stack820() (uintptr, uintptr)  { var buf [820]byte; use(buf[:]); return Stackguard() }
-func stack824() (uintptr, uintptr)  { var buf [824]byte; use(buf[:]); return Stackguard() }
-func stack828() (uintptr, uintptr)  { var buf [828]byte; use(buf[:]); return Stackguard() }
-func stack832() (uintptr, uintptr)  { var buf [832]byte; use(buf[:]); return Stackguard() }
-func stack836() (uintptr, uintptr)  { var buf [836]byte; use(buf[:]); return Stackguard() }
-func stack840() (uintptr, uintptr)  { var buf [840]byte; use(buf[:]); return Stackguard() }
-func stack844() (uintptr, uintptr)  { var buf [844]byte; use(buf[:]); return Stackguard() }
-func stack848() (uintptr, uintptr)  { var buf [848]byte; use(buf[:]); return Stackguard() }
-func stack852() (uintptr, uintptr)  { var buf [852]byte; use(buf[:]); return Stackguard() }
-func stack856() (uintptr, uintptr)  { var buf [856]byte; use(buf[:]); return Stackguard() }
-func stack860() (uintptr, uintptr)  { var buf [860]byte; use(buf[:]); return Stackguard() }
-func stack864() (uintptr, uintptr)  { var buf [864]byte; use(buf[:]); return Stackguard() }
-func stack868() (uintptr, uintptr)  { var buf [868]byte; use(buf[:]); return Stackguard() }
-func stack872() (uintptr, uintptr)  { var buf [872]byte; use(buf[:]); return Stackguard() }
-func stack876() (uintptr, uintptr)  { var buf [876]byte; use(buf[:]); return Stackguard() }
-func stack880() (uintptr, uintptr)  { var buf [880]byte; use(buf[:]); return Stackguard() }
-func stack884() (uintptr, uintptr)  { var buf [884]byte; use(buf[:]); return Stackguard() }
-func stack888() (uintptr, uintptr)  { var buf [888]byte; use(buf[:]); return Stackguard() }
-func stack892() (uintptr, uintptr)  { var buf [892]byte; use(buf[:]); return Stackguard() }
-func stack896() (uintptr, uintptr)  { var buf [896]byte; use(buf[:]); return Stackguard() }
-func stack900() (uintptr, uintptr)  { var buf [900]byte; use(buf[:]); return Stackguard() }
-func stack904() (uintptr, uintptr)  { var buf [904]byte; use(buf[:]); return Stackguard() }
-func stack908() (uintptr, uintptr)  { var buf [908]byte; use(buf[:]); return Stackguard() }
-func stack912() (uintptr, uintptr)  { var buf [912]byte; use(buf[:]); return Stackguard() }
-func stack916() (uintptr, uintptr)  { var buf [916]byte; use(buf[:]); return Stackguard() }
-func stack920() (uintptr, uintptr)  { var buf [920]byte; use(buf[:]); return Stackguard() }
-func stack924() (uintptr, uintptr)  { var buf [924]byte; use(buf[:]); return Stackguard() }
-func stack928() (uintptr, uintptr)  { var buf [928]byte; use(buf[:]); return Stackguard() }
-func stack932() (uintptr, uintptr)  { var buf [932]byte; use(buf[:]); return Stackguard() }
-func stack936() (uintptr, uintptr)  { var buf [936]byte; use(buf[:]); return Stackguard() }
-func stack940() (uintptr, uintptr)  { var buf [940]byte; use(buf[:]); return Stackguard() }
-func stack944() (uintptr, uintptr)  { var buf [944]byte; use(buf[:]); return Stackguard() }
-func stack948() (uintptr, uintptr)  { var buf [948]byte; use(buf[:]); return Stackguard() }
-func stack952() (uintptr, uintptr)  { var buf [952]byte; use(buf[:]); return Stackguard() }
-func stack956() (uintptr, uintptr)  { var buf [956]byte; use(buf[:]); return Stackguard() }
-func stack960() (uintptr, uintptr)  { var buf [960]byte; use(buf[:]); return Stackguard() }
-func stack964() (uintptr, uintptr)  { var buf [964]byte; use(buf[:]); return Stackguard() }
-func stack968() (uintptr, uintptr)  { var buf [968]byte; use(buf[:]); return Stackguard() }
-func stack972() (uintptr, uintptr)  { var buf [972]byte; use(buf[:]); return Stackguard() }
-func stack976() (uintptr, uintptr)  { var buf [976]byte; use(buf[:]); return Stackguard() }
-func stack980() (uintptr, uintptr)  { var buf [980]byte; use(buf[:]); return Stackguard() }
-func stack984() (uintptr, uintptr)  { var buf [984]byte; use(buf[:]); return Stackguard() }
-func stack988() (uintptr, uintptr)  { var buf [988]byte; use(buf[:]); return Stackguard() }
-func stack992() (uintptr, uintptr)  { var buf [992]byte; use(buf[:]); return Stackguard() }
-func stack996() (uintptr, uintptr)  { var buf [996]byte; use(buf[:]); return Stackguard() }
-func stack1000() (uintptr, uintptr) { var buf [1000]byte; use(buf[:]); return Stackguard() }
-func stack1004() (uintptr, uintptr) { var buf [1004]byte; use(buf[:]); return Stackguard() }
-func stack1008() (uintptr, uintptr) { var buf [1008]byte; use(buf[:]); return Stackguard() }
-func stack1012() (uintptr, uintptr) { var buf [1012]byte; use(buf[:]); return Stackguard() }
-func stack1016() (uintptr, uintptr) { var buf [1016]byte; use(buf[:]); return Stackguard() }
-func stack1020() (uintptr, uintptr) { var buf [1020]byte; use(buf[:]); return Stackguard() }
-func stack1024() (uintptr, uintptr) { var buf [1024]byte; use(buf[:]); return Stackguard() }
-func stack1028() (uintptr, uintptr) { var buf [1028]byte; use(buf[:]); return Stackguard() }
-func stack1032() (uintptr, uintptr) { var buf [1032]byte; use(buf[:]); return Stackguard() }
-func stack1036() (uintptr, uintptr) { var buf [1036]byte; use(buf[:]); return Stackguard() }
-func stack1040() (uintptr, uintptr) { var buf [1040]byte; use(buf[:]); return Stackguard() }
-func stack1044() (uintptr, uintptr) { var buf [1044]byte; use(buf[:]); return Stackguard() }
-func stack1048() (uintptr, uintptr) { var buf [1048]byte; use(buf[:]); return Stackguard() }
-func stack1052() (uintptr, uintptr) { var buf [1052]byte; use(buf[:]); return Stackguard() }
-func stack1056() (uintptr, uintptr) { var buf [1056]byte; use(buf[:]); return Stackguard() }
-func stack1060() (uintptr, uintptr) { var buf [1060]byte; use(buf[:]); return Stackguard() }
-func stack1064() (uintptr, uintptr) { var buf [1064]byte; use(buf[:]); return Stackguard() }
-func stack1068() (uintptr, uintptr) { var buf [1068]byte; use(buf[:]); return Stackguard() }
-func stack1072() (uintptr, uintptr) { var buf [1072]byte; use(buf[:]); return Stackguard() }
-func stack1076() (uintptr, uintptr) { var buf [1076]byte; use(buf[:]); return Stackguard() }
-func stack1080() (uintptr, uintptr) { var buf [1080]byte; use(buf[:]); return Stackguard() }
-func stack1084() (uintptr, uintptr) { var buf [1084]byte; use(buf[:]); return Stackguard() }
-func stack1088() (uintptr, uintptr) { var buf [1088]byte; use(buf[:]); return Stackguard() }
-func stack1092() (uintptr, uintptr) { var buf [1092]byte; use(buf[:]); return Stackguard() }
-func stack1096() (uintptr, uintptr) { var buf [1096]byte; use(buf[:]); return Stackguard() }
-func stack1100() (uintptr, uintptr) { var buf [1100]byte; use(buf[:]); return Stackguard() }
-func stack1104() (uintptr, uintptr) { var buf [1104]byte; use(buf[:]); return Stackguard() }
-func stack1108() (uintptr, uintptr) { var buf [1108]byte; use(buf[:]); return Stackguard() }
-func stack1112() (uintptr, uintptr) { var buf [1112]byte; use(buf[:]); return Stackguard() }
-func stack1116() (uintptr, uintptr) { var buf [1116]byte; use(buf[:]); return Stackguard() }
-func stack1120() (uintptr, uintptr) { var buf [1120]byte; use(buf[:]); return Stackguard() }
-func stack1124() (uintptr, uintptr) { var buf [1124]byte; use(buf[:]); return Stackguard() }
-func stack1128() (uintptr, uintptr) { var buf [1128]byte; use(buf[:]); return Stackguard() }
-func stack1132() (uintptr, uintptr) { var buf [1132]byte; use(buf[:]); return Stackguard() }
-func stack1136() (uintptr, uintptr) { var buf [1136]byte; use(buf[:]); return Stackguard() }
-func stack1140() (uintptr, uintptr) { var buf [1140]byte; use(buf[:]); return Stackguard() }
-func stack1144() (uintptr, uintptr) { var buf [1144]byte; use(buf[:]); return Stackguard() }
-func stack1148() (uintptr, uintptr) { var buf [1148]byte; use(buf[:]); return Stackguard() }
-func stack1152() (uintptr, uintptr) { var buf [1152]byte; use(buf[:]); return Stackguard() }
-func stack1156() (uintptr, uintptr) { var buf [1156]byte; use(buf[:]); return Stackguard() }
-func stack1160() (uintptr, uintptr) { var buf [1160]byte; use(buf[:]); return Stackguard() }
-func stack1164() (uintptr, uintptr) { var buf [1164]byte; use(buf[:]); return Stackguard() }
-func stack1168() (uintptr, uintptr) { var buf [1168]byte; use(buf[:]); return Stackguard() }
-func stack1172() (uintptr, uintptr) { var buf [1172]byte; use(buf[:]); return Stackguard() }
-func stack1176() (uintptr, uintptr) { var buf [1176]byte; use(buf[:]); return Stackguard() }
-func stack1180() (uintptr, uintptr) { var buf [1180]byte; use(buf[:]); return Stackguard() }
-func stack1184() (uintptr, uintptr) { var buf [1184]byte; use(buf[:]); return Stackguard() }
-func stack1188() (uintptr, uintptr) { var buf [1188]byte; use(buf[:]); return Stackguard() }
-func stack1192() (uintptr, uintptr) { var buf [1192]byte; use(buf[:]); return Stackguard() }
-func stack1196() (uintptr, uintptr) { var buf [1196]byte; use(buf[:]); return Stackguard() }
-func stack1200() (uintptr, uintptr) { var buf [1200]byte; use(buf[:]); return Stackguard() }
-func stack1204() (uintptr, uintptr) { var buf [1204]byte; use(buf[:]); return Stackguard() }
-func stack1208() (uintptr, uintptr) { var buf [1208]byte; use(buf[:]); return Stackguard() }
-func stack1212() (uintptr, uintptr) { var buf [1212]byte; use(buf[:]); return Stackguard() }
-func stack1216() (uintptr, uintptr) { var buf [1216]byte; use(buf[:]); return Stackguard() }
-func stack1220() (uintptr, uintptr) { var buf [1220]byte; use(buf[:]); return Stackguard() }
-func stack1224() (uintptr, uintptr) { var buf [1224]byte; use(buf[:]); return Stackguard() }
-func stack1228() (uintptr, uintptr) { var buf [1228]byte; use(buf[:]); return Stackguard() }
-func stack1232() (uintptr, uintptr) { var buf [1232]byte; use(buf[:]); return Stackguard() }
-func stack1236() (uintptr, uintptr) { var buf [1236]byte; use(buf[:]); return Stackguard() }
-func stack1240() (uintptr, uintptr) { var buf [1240]byte; use(buf[:]); return Stackguard() }
-func stack1244() (uintptr, uintptr) { var buf [1244]byte; use(buf[:]); return Stackguard() }
-func stack1248() (uintptr, uintptr) { var buf [1248]byte; use(buf[:]); return Stackguard() }
-func stack1252() (uintptr, uintptr) { var buf [1252]byte; use(buf[:]); return Stackguard() }
-func stack1256() (uintptr, uintptr) { var buf [1256]byte; use(buf[:]); return Stackguard() }
-func stack1260() (uintptr, uintptr) { var buf [1260]byte; use(buf[:]); return Stackguard() }
-func stack1264() (uintptr, uintptr) { var buf [1264]byte; use(buf[:]); return Stackguard() }
-func stack1268() (uintptr, uintptr) { var buf [1268]byte; use(buf[:]); return Stackguard() }
-func stack1272() (uintptr, uintptr) { var buf [1272]byte; use(buf[:]); return Stackguard() }
-func stack1276() (uintptr, uintptr) { var buf [1276]byte; use(buf[:]); return Stackguard() }
-func stack1280() (uintptr, uintptr) { var buf [1280]byte; use(buf[:]); return Stackguard() }
-func stack1284() (uintptr, uintptr) { var buf [1284]byte; use(buf[:]); return Stackguard() }
-func stack1288() (uintptr, uintptr) { var buf [1288]byte; use(buf[:]); return Stackguard() }
-func stack1292() (uintptr, uintptr) { var buf [1292]byte; use(buf[:]); return Stackguard() }
-func stack1296() (uintptr, uintptr) { var buf [1296]byte; use(buf[:]); return Stackguard() }
-func stack1300() (uintptr, uintptr) { var buf [1300]byte; use(buf[:]); return Stackguard() }
-func stack1304() (uintptr, uintptr) { var buf [1304]byte; use(buf[:]); return Stackguard() }
-func stack1308() (uintptr, uintptr) { var buf [1308]byte; use(buf[:]); return Stackguard() }
-func stack1312() (uintptr, uintptr) { var buf [1312]byte; use(buf[:]); return Stackguard() }
-func stack1316() (uintptr, uintptr) { var buf [1316]byte; use(buf[:]); return Stackguard() }
-func stack1320() (uintptr, uintptr) { var buf [1320]byte; use(buf[:]); return Stackguard() }
-func stack1324() (uintptr, uintptr) { var buf [1324]byte; use(buf[:]); return Stackguard() }
-func stack1328() (uintptr, uintptr) { var buf [1328]byte; use(buf[:]); return Stackguard() }
-func stack1332() (uintptr, uintptr) { var buf [1332]byte; use(buf[:]); return Stackguard() }
-func stack1336() (uintptr, uintptr) { var buf [1336]byte; use(buf[:]); return Stackguard() }
-func stack1340() (uintptr, uintptr) { var buf [1340]byte; use(buf[:]); return Stackguard() }
-func stack1344() (uintptr, uintptr) { var buf [1344]byte; use(buf[:]); return Stackguard() }
-func stack1348() (uintptr, uintptr) { var buf [1348]byte; use(buf[:]); return Stackguard() }
-func stack1352() (uintptr, uintptr) { var buf [1352]byte; use(buf[:]); return Stackguard() }
-func stack1356() (uintptr, uintptr) { var buf [1356]byte; use(buf[:]); return Stackguard() }
-func stack1360() (uintptr, uintptr) { var buf [1360]byte; use(buf[:]); return Stackguard() }
-func stack1364() (uintptr, uintptr) { var buf [1364]byte; use(buf[:]); return Stackguard() }
-func stack1368() (uintptr, uintptr) { var buf [1368]byte; use(buf[:]); return Stackguard() }
-func stack1372() (uintptr, uintptr) { var buf [1372]byte; use(buf[:]); return Stackguard() }
-func stack1376() (uintptr, uintptr) { var buf [1376]byte; use(buf[:]); return Stackguard() }
-func stack1380() (uintptr, uintptr) { var buf [1380]byte; use(buf[:]); return Stackguard() }
-func stack1384() (uintptr, uintptr) { var buf [1384]byte; use(buf[:]); return Stackguard() }
-func stack1388() (uintptr, uintptr) { var buf [1388]byte; use(buf[:]); return Stackguard() }
-func stack1392() (uintptr, uintptr) { var buf [1392]byte; use(buf[:]); return Stackguard() }
-func stack1396() (uintptr, uintptr) { var buf [1396]byte; use(buf[:]); return Stackguard() }
-func stack1400() (uintptr, uintptr) { var buf [1400]byte; use(buf[:]); return Stackguard() }
-func stack1404() (uintptr, uintptr) { var buf [1404]byte; use(buf[:]); return Stackguard() }
-func stack1408() (uintptr, uintptr) { var buf [1408]byte; use(buf[:]); return Stackguard() }
-func stack1412() (uintptr, uintptr) { var buf [1412]byte; use(buf[:]); return Stackguard() }
-func stack1416() (uintptr, uintptr) { var buf [1416]byte; use(buf[:]); return Stackguard() }
-func stack1420() (uintptr, uintptr) { var buf [1420]byte; use(buf[:]); return Stackguard() }
-func stack1424() (uintptr, uintptr) { var buf [1424]byte; use(buf[:]); return Stackguard() }
-func stack1428() (uintptr, uintptr) { var buf [1428]byte; use(buf[:]); return Stackguard() }
-func stack1432() (uintptr, uintptr) { var buf [1432]byte; use(buf[:]); return Stackguard() }
-func stack1436() (uintptr, uintptr) { var buf [1436]byte; use(buf[:]); return Stackguard() }
-func stack1440() (uintptr, uintptr) { var buf [1440]byte; use(buf[:]); return Stackguard() }
-func stack1444() (uintptr, uintptr) { var buf [1444]byte; use(buf[:]); return Stackguard() }
-func stack1448() (uintptr, uintptr) { var buf [1448]byte; use(buf[:]); return Stackguard() }
-func stack1452() (uintptr, uintptr) { var buf [1452]byte; use(buf[:]); return Stackguard() }
-func stack1456() (uintptr, uintptr) { var buf [1456]byte; use(buf[:]); return Stackguard() }
-func stack1460() (uintptr, uintptr) { var buf [1460]byte; use(buf[:]); return Stackguard() }
-func stack1464() (uintptr, uintptr) { var buf [1464]byte; use(buf[:]); return Stackguard() }
-func stack1468() (uintptr, uintptr) { var buf [1468]byte; use(buf[:]); return Stackguard() }
-func stack1472() (uintptr, uintptr) { var buf [1472]byte; use(buf[:]); return Stackguard() }
-func stack1476() (uintptr, uintptr) { var buf [1476]byte; use(buf[:]); return Stackguard() }
-func stack1480() (uintptr, uintptr) { var buf [1480]byte; use(buf[:]); return Stackguard() }
-func stack1484() (uintptr, uintptr) { var buf [1484]byte; use(buf[:]); return Stackguard() }
-func stack1488() (uintptr, uintptr) { var buf [1488]byte; use(buf[:]); return Stackguard() }
-func stack1492() (uintptr, uintptr) { var buf [1492]byte; use(buf[:]); return Stackguard() }
-func stack1496() (uintptr, uintptr) { var buf [1496]byte; use(buf[:]); return Stackguard() }
-func stack1500() (uintptr, uintptr) { var buf [1500]byte; use(buf[:]); return Stackguard() }
-func stack1504() (uintptr, uintptr) { var buf [1504]byte; use(buf[:]); return Stackguard() }
-func stack1508() (uintptr, uintptr) { var buf [1508]byte; use(buf[:]); return Stackguard() }
-func stack1512() (uintptr, uintptr) { var buf [1512]byte; use(buf[:]); return Stackguard() }
-func stack1516() (uintptr, uintptr) { var buf [1516]byte; use(buf[:]); return Stackguard() }
-func stack1520() (uintptr, uintptr) { var buf [1520]byte; use(buf[:]); return Stackguard() }
-func stack1524() (uintptr, uintptr) { var buf [1524]byte; use(buf[:]); return Stackguard() }
-func stack1528() (uintptr, uintptr) { var buf [1528]byte; use(buf[:]); return Stackguard() }
-func stack1532() (uintptr, uintptr) { var buf [1532]byte; use(buf[:]); return Stackguard() }
-func stack1536() (uintptr, uintptr) { var buf [1536]byte; use(buf[:]); return Stackguard() }
-func stack1540() (uintptr, uintptr) { var buf [1540]byte; use(buf[:]); return Stackguard() }
-func stack1544() (uintptr, uintptr) { var buf [1544]byte; use(buf[:]); return Stackguard() }
-func stack1548() (uintptr, uintptr) { var buf [1548]byte; use(buf[:]); return Stackguard() }
-func stack1552() (uintptr, uintptr) { var buf [1552]byte; use(buf[:]); return Stackguard() }
-func stack1556() (uintptr, uintptr) { var buf [1556]byte; use(buf[:]); return Stackguard() }
-func stack1560() (uintptr, uintptr) { var buf [1560]byte; use(buf[:]); return Stackguard() }
-func stack1564() (uintptr, uintptr) { var buf [1564]byte; use(buf[:]); return Stackguard() }
-func stack1568() (uintptr, uintptr) { var buf [1568]byte; use(buf[:]); return Stackguard() }
-func stack1572() (uintptr, uintptr) { var buf [1572]byte; use(buf[:]); return Stackguard() }
-func stack1576() (uintptr, uintptr) { var buf [1576]byte; use(buf[:]); return Stackguard() }
-func stack1580() (uintptr, uintptr) { var buf [1580]byte; use(buf[:]); return Stackguard() }
-func stack1584() (uintptr, uintptr) { var buf [1584]byte; use(buf[:]); return Stackguard() }
-func stack1588() (uintptr, uintptr) { var buf [1588]byte; use(buf[:]); return Stackguard() }
-func stack1592() (uintptr, uintptr) { var buf [1592]byte; use(buf[:]); return Stackguard() }
-func stack1596() (uintptr, uintptr) { var buf [1596]byte; use(buf[:]); return Stackguard() }
-func stack1600() (uintptr, uintptr) { var buf [1600]byte; use(buf[:]); return Stackguard() }
-func stack1604() (uintptr, uintptr) { var buf [1604]byte; use(buf[:]); return Stackguard() }
-func stack1608() (uintptr, uintptr) { var buf [1608]byte; use(buf[:]); return Stackguard() }
-func stack1612() (uintptr, uintptr) { var buf [1612]byte; use(buf[:]); return Stackguard() }
-func stack1616() (uintptr, uintptr) { var buf [1616]byte; use(buf[:]); return Stackguard() }
-func stack1620() (uintptr, uintptr) { var buf [1620]byte; use(buf[:]); return Stackguard() }
-func stack1624() (uintptr, uintptr) { var buf [1624]byte; use(buf[:]); return Stackguard() }
-func stack1628() (uintptr, uintptr) { var buf [1628]byte; use(buf[:]); return Stackguard() }
-func stack1632() (uintptr, uintptr) { var buf [1632]byte; use(buf[:]); return Stackguard() }
-func stack1636() (uintptr, uintptr) { var buf [1636]byte; use(buf[:]); return Stackguard() }
-func stack1640() (uintptr, uintptr) { var buf [1640]byte; use(buf[:]); return Stackguard() }
-func stack1644() (uintptr, uintptr) { var buf [1644]byte; use(buf[:]); return Stackguard() }
-func stack1648() (uintptr, uintptr) { var buf [1648]byte; use(buf[:]); return Stackguard() }
-func stack1652() (uintptr, uintptr) { var buf [1652]byte; use(buf[:]); return Stackguard() }
-func stack1656() (uintptr, uintptr) { var buf [1656]byte; use(buf[:]); return Stackguard() }
-func stack1660() (uintptr, uintptr) { var buf [1660]byte; use(buf[:]); return Stackguard() }
-func stack1664() (uintptr, uintptr) { var buf [1664]byte; use(buf[:]); return Stackguard() }
-func stack1668() (uintptr, uintptr) { var buf [1668]byte; use(buf[:]); return Stackguard() }
-func stack1672() (uintptr, uintptr) { var buf [1672]byte; use(buf[:]); return Stackguard() }
-func stack1676() (uintptr, uintptr) { var buf [1676]byte; use(buf[:]); return Stackguard() }
-func stack1680() (uintptr, uintptr) { var buf [1680]byte; use(buf[:]); return Stackguard() }
-func stack1684() (uintptr, uintptr) { var buf [1684]byte; use(buf[:]); return Stackguard() }
-func stack1688() (uintptr, uintptr) { var buf [1688]byte; use(buf[:]); return Stackguard() }
-func stack1692() (uintptr, uintptr) { var buf [1692]byte; use(buf[:]); return Stackguard() }
-func stack1696() (uintptr, uintptr) { var buf [1696]byte; use(buf[:]); return Stackguard() }
-func stack1700() (uintptr, uintptr) { var buf [1700]byte; use(buf[:]); return Stackguard() }
-func stack1704() (uintptr, uintptr) { var buf [1704]byte; use(buf[:]); return Stackguard() }
-func stack1708() (uintptr, uintptr) { var buf [1708]byte; use(buf[:]); return Stackguard() }
-func stack1712() (uintptr, uintptr) { var buf [1712]byte; use(buf[:]); return Stackguard() }
-func stack1716() (uintptr, uintptr) { var buf [1716]byte; use(buf[:]); return Stackguard() }
-func stack1720() (uintptr, uintptr) { var buf [1720]byte; use(buf[:]); return Stackguard() }
-func stack1724() (uintptr, uintptr) { var buf [1724]byte; use(buf[:]); return Stackguard() }
-func stack1728() (uintptr, uintptr) { var buf [1728]byte; use(buf[:]); return Stackguard() }
-func stack1732() (uintptr, uintptr) { var buf [1732]byte; use(buf[:]); return Stackguard() }
-func stack1736() (uintptr, uintptr) { var buf [1736]byte; use(buf[:]); return Stackguard() }
-func stack1740() (uintptr, uintptr) { var buf [1740]byte; use(buf[:]); return Stackguard() }
-func stack1744() (uintptr, uintptr) { var buf [1744]byte; use(buf[:]); return Stackguard() }
-func stack1748() (uintptr, uintptr) { var buf [1748]byte; use(buf[:]); return Stackguard() }
-func stack1752() (uintptr, uintptr) { var buf [1752]byte; use(buf[:]); return Stackguard() }
-func stack1756() (uintptr, uintptr) { var buf [1756]byte; use(buf[:]); return Stackguard() }
-func stack1760() (uintptr, uintptr) { var buf [1760]byte; use(buf[:]); return Stackguard() }
-func stack1764() (uintptr, uintptr) { var buf [1764]byte; use(buf[:]); return Stackguard() }
-func stack1768() (uintptr, uintptr) { var buf [1768]byte; use(buf[:]); return Stackguard() }
-func stack1772() (uintptr, uintptr) { var buf [1772]byte; use(buf[:]); return Stackguard() }
-func stack1776() (uintptr, uintptr) { var buf [1776]byte; use(buf[:]); return Stackguard() }
-func stack1780() (uintptr, uintptr) { var buf [1780]byte; use(buf[:]); return Stackguard() }
-func stack1784() (uintptr, uintptr) { var buf [1784]byte; use(buf[:]); return Stackguard() }
-func stack1788() (uintptr, uintptr) { var buf [1788]byte; use(buf[:]); return Stackguard() }
-func stack1792() (uintptr, uintptr) { var buf [1792]byte; use(buf[:]); return Stackguard() }
-func stack1796() (uintptr, uintptr) { var buf [1796]byte; use(buf[:]); return Stackguard() }
-func stack1800() (uintptr, uintptr) { var buf [1800]byte; use(buf[:]); return Stackguard() }
-func stack1804() (uintptr, uintptr) { var buf [1804]byte; use(buf[:]); return Stackguard() }
-func stack1808() (uintptr, uintptr) { var buf [1808]byte; use(buf[:]); return Stackguard() }
-func stack1812() (uintptr, uintptr) { var buf [1812]byte; use(buf[:]); return Stackguard() }
-func stack1816() (uintptr, uintptr) { var buf [1816]byte; use(buf[:]); return Stackguard() }
-func stack1820() (uintptr, uintptr) { var buf [1820]byte; use(buf[:]); return Stackguard() }
-func stack1824() (uintptr, uintptr) { var buf [1824]byte; use(buf[:]); return Stackguard() }
-func stack1828() (uintptr, uintptr) { var buf [1828]byte; use(buf[:]); return Stackguard() }
-func stack1832() (uintptr, uintptr) { var buf [1832]byte; use(buf[:]); return Stackguard() }
-func stack1836() (uintptr, uintptr) { var buf [1836]byte; use(buf[:]); return Stackguard() }
-func stack1840() (uintptr, uintptr) { var buf [1840]byte; use(buf[:]); return Stackguard() }
-func stack1844() (uintptr, uintptr) { var buf [1844]byte; use(buf[:]); return Stackguard() }
-func stack1848() (uintptr, uintptr) { var buf [1848]byte; use(buf[:]); return Stackguard() }
-func stack1852() (uintptr, uintptr) { var buf [1852]byte; use(buf[:]); return Stackguard() }
-func stack1856() (uintptr, uintptr) { var buf [1856]byte; use(buf[:]); return Stackguard() }
-func stack1860() (uintptr, uintptr) { var buf [1860]byte; use(buf[:]); return Stackguard() }
-func stack1864() (uintptr, uintptr) { var buf [1864]byte; use(buf[:]); return Stackguard() }
-func stack1868() (uintptr, uintptr) { var buf [1868]byte; use(buf[:]); return Stackguard() }
-func stack1872() (uintptr, uintptr) { var buf [1872]byte; use(buf[:]); return Stackguard() }
-func stack1876() (uintptr, uintptr) { var buf [1876]byte; use(buf[:]); return Stackguard() }
-func stack1880() (uintptr, uintptr) { var buf [1880]byte; use(buf[:]); return Stackguard() }
-func stack1884() (uintptr, uintptr) { var buf [1884]byte; use(buf[:]); return Stackguard() }
-func stack1888() (uintptr, uintptr) { var buf [1888]byte; use(buf[:]); return Stackguard() }
-func stack1892() (uintptr, uintptr) { var buf [1892]byte; use(buf[:]); return Stackguard() }
-func stack1896() (uintptr, uintptr) { var buf [1896]byte; use(buf[:]); return Stackguard() }
-func stack1900() (uintptr, uintptr) { var buf [1900]byte; use(buf[:]); return Stackguard() }
-func stack1904() (uintptr, uintptr) { var buf [1904]byte; use(buf[:]); return Stackguard() }
-func stack1908() (uintptr, uintptr) { var buf [1908]byte; use(buf[:]); return Stackguard() }
-func stack1912() (uintptr, uintptr) { var buf [1912]byte; use(buf[:]); return Stackguard() }
-func stack1916() (uintptr, uintptr) { var buf [1916]byte; use(buf[:]); return Stackguard() }
-func stack1920() (uintptr, uintptr) { var buf [1920]byte; use(buf[:]); return Stackguard() }
-func stack1924() (uintptr, uintptr) { var buf [1924]byte; use(buf[:]); return Stackguard() }
-func stack1928() (uintptr, uintptr) { var buf [1928]byte; use(buf[:]); return Stackguard() }
-func stack1932() (uintptr, uintptr) { var buf [1932]byte; use(buf[:]); return Stackguard() }
-func stack1936() (uintptr, uintptr) { var buf [1936]byte; use(buf[:]); return Stackguard() }
-func stack1940() (uintptr, uintptr) { var buf [1940]byte; use(buf[:]); return Stackguard() }
-func stack1944() (uintptr, uintptr) { var buf [1944]byte; use(buf[:]); return Stackguard() }
-func stack1948() (uintptr, uintptr) { var buf [1948]byte; use(buf[:]); return Stackguard() }
-func stack1952() (uintptr, uintptr) { var buf [1952]byte; use(buf[:]); return Stackguard() }
-func stack1956() (uintptr, uintptr) { var buf [1956]byte; use(buf[:]); return Stackguard() }
-func stack1960() (uintptr, uintptr) { var buf [1960]byte; use(buf[:]); return Stackguard() }
-func stack1964() (uintptr, uintptr) { var buf [1964]byte; use(buf[:]); return Stackguard() }
-func stack1968() (uintptr, uintptr) { var buf [1968]byte; use(buf[:]); return Stackguard() }
-func stack1972() (uintptr, uintptr) { var buf [1972]byte; use(buf[:]); return Stackguard() }
-func stack1976() (uintptr, uintptr) { var buf [1976]byte; use(buf[:]); return Stackguard() }
-func stack1980() (uintptr, uintptr) { var buf [1980]byte; use(buf[:]); return Stackguard() }
-func stack1984() (uintptr, uintptr) { var buf [1984]byte; use(buf[:]); return Stackguard() }
-func stack1988() (uintptr, uintptr) { var buf [1988]byte; use(buf[:]); return Stackguard() }
-func stack1992() (uintptr, uintptr) { var buf [1992]byte; use(buf[:]); return Stackguard() }
-func stack1996() (uintptr, uintptr) { var buf [1996]byte; use(buf[:]); return Stackguard() }
-func stack2000() (uintptr, uintptr) { var buf [2000]byte; use(buf[:]); return Stackguard() }
-func stack2004() (uintptr, uintptr) { var buf [2004]byte; use(buf[:]); return Stackguard() }
-func stack2008() (uintptr, uintptr) { var buf [2008]byte; use(buf[:]); return Stackguard() }
-func stack2012() (uintptr, uintptr) { var buf [2012]byte; use(buf[:]); return Stackguard() }
-func stack2016() (uintptr, uintptr) { var buf [2016]byte; use(buf[:]); return Stackguard() }
-func stack2020() (uintptr, uintptr) { var buf [2020]byte; use(buf[:]); return Stackguard() }
-func stack2024() (uintptr, uintptr) { var buf [2024]byte; use(buf[:]); return Stackguard() }
-func stack2028() (uintptr, uintptr) { var buf [2028]byte; use(buf[:]); return Stackguard() }
-func stack2032() (uintptr, uintptr) { var buf [2032]byte; use(buf[:]); return Stackguard() }
-func stack2036() (uintptr, uintptr) { var buf [2036]byte; use(buf[:]); return Stackguard() }
-func stack2040() (uintptr, uintptr) { var buf [2040]byte; use(buf[:]); return Stackguard() }
-func stack2044() (uintptr, uintptr) { var buf [2044]byte; use(buf[:]); return Stackguard() }
-func stack2048() (uintptr, uintptr) { var buf [2048]byte; use(buf[:]); return Stackguard() }
-func stack2052() (uintptr, uintptr) { var buf [2052]byte; use(buf[:]); return Stackguard() }
-func stack2056() (uintptr, uintptr) { var buf [2056]byte; use(buf[:]); return Stackguard() }
-func stack2060() (uintptr, uintptr) { var buf [2060]byte; use(buf[:]); return Stackguard() }
-func stack2064() (uintptr, uintptr) { var buf [2064]byte; use(buf[:]); return Stackguard() }
-func stack2068() (uintptr, uintptr) { var buf [2068]byte; use(buf[:]); return Stackguard() }
-func stack2072() (uintptr, uintptr) { var buf [2072]byte; use(buf[:]); return Stackguard() }
-func stack2076() (uintptr, uintptr) { var buf [2076]byte; use(buf[:]); return Stackguard() }
-func stack2080() (uintptr, uintptr) { var buf [2080]byte; use(buf[:]); return Stackguard() }
-func stack2084() (uintptr, uintptr) { var buf [2084]byte; use(buf[:]); return Stackguard() }
-func stack2088() (uintptr, uintptr) { var buf [2088]byte; use(buf[:]); return Stackguard() }
-func stack2092() (uintptr, uintptr) { var buf [2092]byte; use(buf[:]); return Stackguard() }
-func stack2096() (uintptr, uintptr) { var buf [2096]byte; use(buf[:]); return Stackguard() }
-func stack2100() (uintptr, uintptr) { var buf [2100]byte; use(buf[:]); return Stackguard() }
-func stack2104() (uintptr, uintptr) { var buf [2104]byte; use(buf[:]); return Stackguard() }
-func stack2108() (uintptr, uintptr) { var buf [2108]byte; use(buf[:]); return Stackguard() }
-func stack2112() (uintptr, uintptr) { var buf [2112]byte; use(buf[:]); return Stackguard() }
-func stack2116() (uintptr, uintptr) { var buf [2116]byte; use(buf[:]); return Stackguard() }
-func stack2120() (uintptr, uintptr) { var buf [2120]byte; use(buf[:]); return Stackguard() }
-func stack2124() (uintptr, uintptr) { var buf [2124]byte; use(buf[:]); return Stackguard() }
-func stack2128() (uintptr, uintptr) { var buf [2128]byte; use(buf[:]); return Stackguard() }
-func stack2132() (uintptr, uintptr) { var buf [2132]byte; use(buf[:]); return Stackguard() }
-func stack2136() (uintptr, uintptr) { var buf [2136]byte; use(buf[:]); return Stackguard() }
-func stack2140() (uintptr, uintptr) { var buf [2140]byte; use(buf[:]); return Stackguard() }
-func stack2144() (uintptr, uintptr) { var buf [2144]byte; use(buf[:]); return Stackguard() }
-func stack2148() (uintptr, uintptr) { var buf [2148]byte; use(buf[:]); return Stackguard() }
-func stack2152() (uintptr, uintptr) { var buf [2152]byte; use(buf[:]); return Stackguard() }
-func stack2156() (uintptr, uintptr) { var buf [2156]byte; use(buf[:]); return Stackguard() }
-func stack2160() (uintptr, uintptr) { var buf [2160]byte; use(buf[:]); return Stackguard() }
-func stack2164() (uintptr, uintptr) { var buf [2164]byte; use(buf[:]); return Stackguard() }
-func stack2168() (uintptr, uintptr) { var buf [2168]byte; use(buf[:]); return Stackguard() }
-func stack2172() (uintptr, uintptr) { var buf [2172]byte; use(buf[:]); return Stackguard() }
-func stack2176() (uintptr, uintptr) { var buf [2176]byte; use(buf[:]); return Stackguard() }
-func stack2180() (uintptr, uintptr) { var buf [2180]byte; use(buf[:]); return Stackguard() }
-func stack2184() (uintptr, uintptr) { var buf [2184]byte; use(buf[:]); return Stackguard() }
-func stack2188() (uintptr, uintptr) { var buf [2188]byte; use(buf[:]); return Stackguard() }
-func stack2192() (uintptr, uintptr) { var buf [2192]byte; use(buf[:]); return Stackguard() }
-func stack2196() (uintptr, uintptr) { var buf [2196]byte; use(buf[:]); return Stackguard() }
-func stack2200() (uintptr, uintptr) { var buf [2200]byte; use(buf[:]); return Stackguard() }
-func stack2204() (uintptr, uintptr) { var buf [2204]byte; use(buf[:]); return Stackguard() }
-func stack2208() (uintptr, uintptr) { var buf [2208]byte; use(buf[:]); return Stackguard() }
-func stack2212() (uintptr, uintptr) { var buf [2212]byte; use(buf[:]); return Stackguard() }
-func stack2216() (uintptr, uintptr) { var buf [2216]byte; use(buf[:]); return Stackguard() }
-func stack2220() (uintptr, uintptr) { var buf [2220]byte; use(buf[:]); return Stackguard() }
-func stack2224() (uintptr, uintptr) { var buf [2224]byte; use(buf[:]); return Stackguard() }
-func stack2228() (uintptr, uintptr) { var buf [2228]byte; use(buf[:]); return Stackguard() }
-func stack2232() (uintptr, uintptr) { var buf [2232]byte; use(buf[:]); return Stackguard() }
-func stack2236() (uintptr, uintptr) { var buf [2236]byte; use(buf[:]); return Stackguard() }
-func stack2240() (uintptr, uintptr) { var buf [2240]byte; use(buf[:]); return Stackguard() }
-func stack2244() (uintptr, uintptr) { var buf [2244]byte; use(buf[:]); return Stackguard() }
-func stack2248() (uintptr, uintptr) { var buf [2248]byte; use(buf[:]); return Stackguard() }
-func stack2252() (uintptr, uintptr) { var buf [2252]byte; use(buf[:]); return Stackguard() }
-func stack2256() (uintptr, uintptr) { var buf [2256]byte; use(buf[:]); return Stackguard() }
-func stack2260() (uintptr, uintptr) { var buf [2260]byte; use(buf[:]); return Stackguard() }
-func stack2264() (uintptr, uintptr) { var buf [2264]byte; use(buf[:]); return Stackguard() }
-func stack2268() (uintptr, uintptr) { var buf [2268]byte; use(buf[:]); return Stackguard() }
-func stack2272() (uintptr, uintptr) { var buf [2272]byte; use(buf[:]); return Stackguard() }
-func stack2276() (uintptr, uintptr) { var buf [2276]byte; use(buf[:]); return Stackguard() }
-func stack2280() (uintptr, uintptr) { var buf [2280]byte; use(buf[:]); return Stackguard() }
-func stack2284() (uintptr, uintptr) { var buf [2284]byte; use(buf[:]); return Stackguard() }
-func stack2288() (uintptr, uintptr) { var buf [2288]byte; use(buf[:]); return Stackguard() }
-func stack2292() (uintptr, uintptr) { var buf [2292]byte; use(buf[:]); return Stackguard() }
-func stack2296() (uintptr, uintptr) { var buf [2296]byte; use(buf[:]); return Stackguard() }
-func stack2300() (uintptr, uintptr) { var buf [2300]byte; use(buf[:]); return Stackguard() }
-func stack2304() (uintptr, uintptr) { var buf [2304]byte; use(buf[:]); return Stackguard() }
-func stack2308() (uintptr, uintptr) { var buf [2308]byte; use(buf[:]); return Stackguard() }
-func stack2312() (uintptr, uintptr) { var buf [2312]byte; use(buf[:]); return Stackguard() }
-func stack2316() (uintptr, uintptr) { var buf [2316]byte; use(buf[:]); return Stackguard() }
-func stack2320() (uintptr, uintptr) { var buf [2320]byte; use(buf[:]); return Stackguard() }
-func stack2324() (uintptr, uintptr) { var buf [2324]byte; use(buf[:]); return Stackguard() }
-func stack2328() (uintptr, uintptr) { var buf [2328]byte; use(buf[:]); return Stackguard() }
-func stack2332() (uintptr, uintptr) { var buf [2332]byte; use(buf[:]); return Stackguard() }
-func stack2336() (uintptr, uintptr) { var buf [2336]byte; use(buf[:]); return Stackguard() }
-func stack2340() (uintptr, uintptr) { var buf [2340]byte; use(buf[:]); return Stackguard() }
-func stack2344() (uintptr, uintptr) { var buf [2344]byte; use(buf[:]); return Stackguard() }
-func stack2348() (uintptr, uintptr) { var buf [2348]byte; use(buf[:]); return Stackguard() }
-func stack2352() (uintptr, uintptr) { var buf [2352]byte; use(buf[:]); return Stackguard() }
-func stack2356() (uintptr, uintptr) { var buf [2356]byte; use(buf[:]); return Stackguard() }
-func stack2360() (uintptr, uintptr) { var buf [2360]byte; use(buf[:]); return Stackguard() }
-func stack2364() (uintptr, uintptr) { var buf [2364]byte; use(buf[:]); return Stackguard() }
-func stack2368() (uintptr, uintptr) { var buf [2368]byte; use(buf[:]); return Stackguard() }
-func stack2372() (uintptr, uintptr) { var buf [2372]byte; use(buf[:]); return Stackguard() }
-func stack2376() (uintptr, uintptr) { var buf [2376]byte; use(buf[:]); return Stackguard() }
-func stack2380() (uintptr, uintptr) { var buf [2380]byte; use(buf[:]); return Stackguard() }
-func stack2384() (uintptr, uintptr) { var buf [2384]byte; use(buf[:]); return Stackguard() }
-func stack2388() (uintptr, uintptr) { var buf [2388]byte; use(buf[:]); return Stackguard() }
-func stack2392() (uintptr, uintptr) { var buf [2392]byte; use(buf[:]); return Stackguard() }
-func stack2396() (uintptr, uintptr) { var buf [2396]byte; use(buf[:]); return Stackguard() }
-func stack2400() (uintptr, uintptr) { var buf [2400]byte; use(buf[:]); return Stackguard() }
-func stack2404() (uintptr, uintptr) { var buf [2404]byte; use(buf[:]); return Stackguard() }
-func stack2408() (uintptr, uintptr) { var buf [2408]byte; use(buf[:]); return Stackguard() }
-func stack2412() (uintptr, uintptr) { var buf [2412]byte; use(buf[:]); return Stackguard() }
-func stack2416() (uintptr, uintptr) { var buf [2416]byte; use(buf[:]); return Stackguard() }
-func stack2420() (uintptr, uintptr) { var buf [2420]byte; use(buf[:]); return Stackguard() }
-func stack2424() (uintptr, uintptr) { var buf [2424]byte; use(buf[:]); return Stackguard() }
-func stack2428() (uintptr, uintptr) { var buf [2428]byte; use(buf[:]); return Stackguard() }
-func stack2432() (uintptr, uintptr) { var buf [2432]byte; use(buf[:]); return Stackguard() }
-func stack2436() (uintptr, uintptr) { var buf [2436]byte; use(buf[:]); return Stackguard() }
-func stack2440() (uintptr, uintptr) { var buf [2440]byte; use(buf[:]); return Stackguard() }
-func stack2444() (uintptr, uintptr) { var buf [2444]byte; use(buf[:]); return Stackguard() }
-func stack2448() (uintptr, uintptr) { var buf [2448]byte; use(buf[:]); return Stackguard() }
-func stack2452() (uintptr, uintptr) { var buf [2452]byte; use(buf[:]); return Stackguard() }
-func stack2456() (uintptr, uintptr) { var buf [2456]byte; use(buf[:]); return Stackguard() }
-func stack2460() (uintptr, uintptr) { var buf [2460]byte; use(buf[:]); return Stackguard() }
-func stack2464() (uintptr, uintptr) { var buf [2464]byte; use(buf[:]); return Stackguard() }
-func stack2468() (uintptr, uintptr) { var buf [2468]byte; use(buf[:]); return Stackguard() }
-func stack2472() (uintptr, uintptr) { var buf [2472]byte; use(buf[:]); return Stackguard() }
-func stack2476() (uintptr, uintptr) { var buf [2476]byte; use(buf[:]); return Stackguard() }
-func stack2480() (uintptr, uintptr) { var buf [2480]byte; use(buf[:]); return Stackguard() }
-func stack2484() (uintptr, uintptr) { var buf [2484]byte; use(buf[:]); return Stackguard() }
-func stack2488() (uintptr, uintptr) { var buf [2488]byte; use(buf[:]); return Stackguard() }
-func stack2492() (uintptr, uintptr) { var buf [2492]byte; use(buf[:]); return Stackguard() }
-func stack2496() (uintptr, uintptr) { var buf [2496]byte; use(buf[:]); return Stackguard() }
-func stack2500() (uintptr, uintptr) { var buf [2500]byte; use(buf[:]); return Stackguard() }
-func stack2504() (uintptr, uintptr) { var buf [2504]byte; use(buf[:]); return Stackguard() }
-func stack2508() (uintptr, uintptr) { var buf [2508]byte; use(buf[:]); return Stackguard() }
-func stack2512() (uintptr, uintptr) { var buf [2512]byte; use(buf[:]); return Stackguard() }
-func stack2516() (uintptr, uintptr) { var buf [2516]byte; use(buf[:]); return Stackguard() }
-func stack2520() (uintptr, uintptr) { var buf [2520]byte; use(buf[:]); return Stackguard() }
-func stack2524() (uintptr, uintptr) { var buf [2524]byte; use(buf[:]); return Stackguard() }
-func stack2528() (uintptr, uintptr) { var buf [2528]byte; use(buf[:]); return Stackguard() }
-func stack2532() (uintptr, uintptr) { var buf [2532]byte; use(buf[:]); return Stackguard() }
-func stack2536() (uintptr, uintptr) { var buf [2536]byte; use(buf[:]); return Stackguard() }
-func stack2540() (uintptr, uintptr) { var buf [2540]byte; use(buf[:]); return Stackguard() }
-func stack2544() (uintptr, uintptr) { var buf [2544]byte; use(buf[:]); return Stackguard() }
-func stack2548() (uintptr, uintptr) { var buf [2548]byte; use(buf[:]); return Stackguard() }
-func stack2552() (uintptr, uintptr) { var buf [2552]byte; use(buf[:]); return Stackguard() }
-func stack2556() (uintptr, uintptr) { var buf [2556]byte; use(buf[:]); return Stackguard() }
-func stack2560() (uintptr, uintptr) { var buf [2560]byte; use(buf[:]); return Stackguard() }
-func stack2564() (uintptr, uintptr) { var buf [2564]byte; use(buf[:]); return Stackguard() }
-func stack2568() (uintptr, uintptr) { var buf [2568]byte; use(buf[:]); return Stackguard() }
-func stack2572() (uintptr, uintptr) { var buf [2572]byte; use(buf[:]); return Stackguard() }
-func stack2576() (uintptr, uintptr) { var buf [2576]byte; use(buf[:]); return Stackguard() }
-func stack2580() (uintptr, uintptr) { var buf [2580]byte; use(buf[:]); return Stackguard() }
-func stack2584() (uintptr, uintptr) { var buf [2584]byte; use(buf[:]); return Stackguard() }
-func stack2588() (uintptr, uintptr) { var buf [2588]byte; use(buf[:]); return Stackguard() }
-func stack2592() (uintptr, uintptr) { var buf [2592]byte; use(buf[:]); return Stackguard() }
-func stack2596() (uintptr, uintptr) { var buf [2596]byte; use(buf[:]); return Stackguard() }
-func stack2600() (uintptr, uintptr) { var buf [2600]byte; use(buf[:]); return Stackguard() }
-func stack2604() (uintptr, uintptr) { var buf [2604]byte; use(buf[:]); return Stackguard() }
-func stack2608() (uintptr, uintptr) { var buf [2608]byte; use(buf[:]); return Stackguard() }
-func stack2612() (uintptr, uintptr) { var buf [2612]byte; use(buf[:]); return Stackguard() }
-func stack2616() (uintptr, uintptr) { var buf [2616]byte; use(buf[:]); return Stackguard() }
-func stack2620() (uintptr, uintptr) { var buf [2620]byte; use(buf[:]); return Stackguard() }
-func stack2624() (uintptr, uintptr) { var buf [2624]byte; use(buf[:]); return Stackguard() }
-func stack2628() (uintptr, uintptr) { var buf [2628]byte; use(buf[:]); return Stackguard() }
-func stack2632() (uintptr, uintptr) { var buf [2632]byte; use(buf[:]); return Stackguard() }
-func stack2636() (uintptr, uintptr) { var buf [2636]byte; use(buf[:]); return Stackguard() }
-func stack2640() (uintptr, uintptr) { var buf [2640]byte; use(buf[:]); return Stackguard() }
-func stack2644() (uintptr, uintptr) { var buf [2644]byte; use(buf[:]); return Stackguard() }
-func stack2648() (uintptr, uintptr) { var buf [2648]byte; use(buf[:]); return Stackguard() }
-func stack2652() (uintptr, uintptr) { var buf [2652]byte; use(buf[:]); return Stackguard() }
-func stack2656() (uintptr, uintptr) { var buf [2656]byte; use(buf[:]); return Stackguard() }
-func stack2660() (uintptr, uintptr) { var buf [2660]byte; use(buf[:]); return Stackguard() }
-func stack2664() (uintptr, uintptr) { var buf [2664]byte; use(buf[:]); return Stackguard() }
-func stack2668() (uintptr, uintptr) { var buf [2668]byte; use(buf[:]); return Stackguard() }
-func stack2672() (uintptr, uintptr) { var buf [2672]byte; use(buf[:]); return Stackguard() }
-func stack2676() (uintptr, uintptr) { var buf [2676]byte; use(buf[:]); return Stackguard() }
-func stack2680() (uintptr, uintptr) { var buf [2680]byte; use(buf[:]); return Stackguard() }
-func stack2684() (uintptr, uintptr) { var buf [2684]byte; use(buf[:]); return Stackguard() }
-func stack2688() (uintptr, uintptr) { var buf [2688]byte; use(buf[:]); return Stackguard() }
-func stack2692() (uintptr, uintptr) { var buf [2692]byte; use(buf[:]); return Stackguard() }
-func stack2696() (uintptr, uintptr) { var buf [2696]byte; use(buf[:]); return Stackguard() }
-func stack2700() (uintptr, uintptr) { var buf [2700]byte; use(buf[:]); return Stackguard() }
-func stack2704() (uintptr, uintptr) { var buf [2704]byte; use(buf[:]); return Stackguard() }
-func stack2708() (uintptr, uintptr) { var buf [2708]byte; use(buf[:]); return Stackguard() }
-func stack2712() (uintptr, uintptr) { var buf [2712]byte; use(buf[:]); return Stackguard() }
-func stack2716() (uintptr, uintptr) { var buf [2716]byte; use(buf[:]); return Stackguard() }
-func stack2720() (uintptr, uintptr) { var buf [2720]byte; use(buf[:]); return Stackguard() }
-func stack2724() (uintptr, uintptr) { var buf [2724]byte; use(buf[:]); return Stackguard() }
-func stack2728() (uintptr, uintptr) { var buf [2728]byte; use(buf[:]); return Stackguard() }
-func stack2732() (uintptr, uintptr) { var buf [2732]byte; use(buf[:]); return Stackguard() }
-func stack2736() (uintptr, uintptr) { var buf [2736]byte; use(buf[:]); return Stackguard() }
-func stack2740() (uintptr, uintptr) { var buf [2740]byte; use(buf[:]); return Stackguard() }
-func stack2744() (uintptr, uintptr) { var buf [2744]byte; use(buf[:]); return Stackguard() }
-func stack2748() (uintptr, uintptr) { var buf [2748]byte; use(buf[:]); return Stackguard() }
-func stack2752() (uintptr, uintptr) { var buf [2752]byte; use(buf[:]); return Stackguard() }
-func stack2756() (uintptr, uintptr) { var buf [2756]byte; use(buf[:]); return Stackguard() }
-func stack2760() (uintptr, uintptr) { var buf [2760]byte; use(buf[:]); return Stackguard() }
-func stack2764() (uintptr, uintptr) { var buf [2764]byte; use(buf[:]); return Stackguard() }
-func stack2768() (uintptr, uintptr) { var buf [2768]byte; use(buf[:]); return Stackguard() }
-func stack2772() (uintptr, uintptr) { var buf [2772]byte; use(buf[:]); return Stackguard() }
-func stack2776() (uintptr, uintptr) { var buf [2776]byte; use(buf[:]); return Stackguard() }
-func stack2780() (uintptr, uintptr) { var buf [2780]byte; use(buf[:]); return Stackguard() }
-func stack2784() (uintptr, uintptr) { var buf [2784]byte; use(buf[:]); return Stackguard() }
-func stack2788() (uintptr, uintptr) { var buf [2788]byte; use(buf[:]); return Stackguard() }
-func stack2792() (uintptr, uintptr) { var buf [2792]byte; use(buf[:]); return Stackguard() }
-func stack2796() (uintptr, uintptr) { var buf [2796]byte; use(buf[:]); return Stackguard() }
-func stack2800() (uintptr, uintptr) { var buf [2800]byte; use(buf[:]); return Stackguard() }
-func stack2804() (uintptr, uintptr) { var buf [2804]byte; use(buf[:]); return Stackguard() }
-func stack2808() (uintptr, uintptr) { var buf [2808]byte; use(buf[:]); return Stackguard() }
-func stack2812() (uintptr, uintptr) { var buf [2812]byte; use(buf[:]); return Stackguard() }
-func stack2816() (uintptr, uintptr) { var buf [2816]byte; use(buf[:]); return Stackguard() }
-func stack2820() (uintptr, uintptr) { var buf [2820]byte; use(buf[:]); return Stackguard() }
-func stack2824() (uintptr, uintptr) { var buf [2824]byte; use(buf[:]); return Stackguard() }
-func stack2828() (uintptr, uintptr) { var buf [2828]byte; use(buf[:]); return Stackguard() }
-func stack2832() (uintptr, uintptr) { var buf [2832]byte; use(buf[:]); return Stackguard() }
-func stack2836() (uintptr, uintptr) { var buf [2836]byte; use(buf[:]); return Stackguard() }
-func stack2840() (uintptr, uintptr) { var buf [2840]byte; use(buf[:]); return Stackguard() }
-func stack2844() (uintptr, uintptr) { var buf [2844]byte; use(buf[:]); return Stackguard() }
-func stack2848() (uintptr, uintptr) { var buf [2848]byte; use(buf[:]); return Stackguard() }
-func stack2852() (uintptr, uintptr) { var buf [2852]byte; use(buf[:]); return Stackguard() }
-func stack2856() (uintptr, uintptr) { var buf [2856]byte; use(buf[:]); return Stackguard() }
-func stack2860() (uintptr, uintptr) { var buf [2860]byte; use(buf[:]); return Stackguard() }
-func stack2864() (uintptr, uintptr) { var buf [2864]byte; use(buf[:]); return Stackguard() }
-func stack2868() (uintptr, uintptr) { var buf [2868]byte; use(buf[:]); return Stackguard() }
-func stack2872() (uintptr, uintptr) { var buf [2872]byte; use(buf[:]); return Stackguard() }
-func stack2876() (uintptr, uintptr) { var buf [2876]byte; use(buf[:]); return Stackguard() }
-func stack2880() (uintptr, uintptr) { var buf [2880]byte; use(buf[:]); return Stackguard() }
-func stack2884() (uintptr, uintptr) { var buf [2884]byte; use(buf[:]); return Stackguard() }
-func stack2888() (uintptr, uintptr) { var buf [2888]byte; use(buf[:]); return Stackguard() }
-func stack2892() (uintptr, uintptr) { var buf [2892]byte; use(buf[:]); return Stackguard() }
-func stack2896() (uintptr, uintptr) { var buf [2896]byte; use(buf[:]); return Stackguard() }
-func stack2900() (uintptr, uintptr) { var buf [2900]byte; use(buf[:]); return Stackguard() }
-func stack2904() (uintptr, uintptr) { var buf [2904]byte; use(buf[:]); return Stackguard() }
-func stack2908() (uintptr, uintptr) { var buf [2908]byte; use(buf[:]); return Stackguard() }
-func stack2912() (uintptr, uintptr) { var buf [2912]byte; use(buf[:]); return Stackguard() }
-func stack2916() (uintptr, uintptr) { var buf [2916]byte; use(buf[:]); return Stackguard() }
-func stack2920() (uintptr, uintptr) { var buf [2920]byte; use(buf[:]); return Stackguard() }
-func stack2924() (uintptr, uintptr) { var buf [2924]byte; use(buf[:]); return Stackguard() }
-func stack2928() (uintptr, uintptr) { var buf [2928]byte; use(buf[:]); return Stackguard() }
-func stack2932() (uintptr, uintptr) { var buf [2932]byte; use(buf[:]); return Stackguard() }
-func stack2936() (uintptr, uintptr) { var buf [2936]byte; use(buf[:]); return Stackguard() }
-func stack2940() (uintptr, uintptr) { var buf [2940]byte; use(buf[:]); return Stackguard() }
-func stack2944() (uintptr, uintptr) { var buf [2944]byte; use(buf[:]); return Stackguard() }
-func stack2948() (uintptr, uintptr) { var buf [2948]byte; use(buf[:]); return Stackguard() }
-func stack2952() (uintptr, uintptr) { var buf [2952]byte; use(buf[:]); return Stackguard() }
-func stack2956() (uintptr, uintptr) { var buf [2956]byte; use(buf[:]); return Stackguard() }
-func stack2960() (uintptr, uintptr) { var buf [2960]byte; use(buf[:]); return Stackguard() }
-func stack2964() (uintptr, uintptr) { var buf [2964]byte; use(buf[:]); return Stackguard() }
-func stack2968() (uintptr, uintptr) { var buf [2968]byte; use(buf[:]); return Stackguard() }
-func stack2972() (uintptr, uintptr) { var buf [2972]byte; use(buf[:]); return Stackguard() }
-func stack2976() (uintptr, uintptr) { var buf [2976]byte; use(buf[:]); return Stackguard() }
-func stack2980() (uintptr, uintptr) { var buf [2980]byte; use(buf[:]); return Stackguard() }
-func stack2984() (uintptr, uintptr) { var buf [2984]byte; use(buf[:]); return Stackguard() }
-func stack2988() (uintptr, uintptr) { var buf [2988]byte; use(buf[:]); return Stackguard() }
-func stack2992() (uintptr, uintptr) { var buf [2992]byte; use(buf[:]); return Stackguard() }
-func stack2996() (uintptr, uintptr) { var buf [2996]byte; use(buf[:]); return Stackguard() }
-func stack3000() (uintptr, uintptr) { var buf [3000]byte; use(buf[:]); return Stackguard() }
-func stack3004() (uintptr, uintptr) { var buf [3004]byte; use(buf[:]); return Stackguard() }
-func stack3008() (uintptr, uintptr) { var buf [3008]byte; use(buf[:]); return Stackguard() }
-func stack3012() (uintptr, uintptr) { var buf [3012]byte; use(buf[:]); return Stackguard() }
-func stack3016() (uintptr, uintptr) { var buf [3016]byte; use(buf[:]); return Stackguard() }
-func stack3020() (uintptr, uintptr) { var buf [3020]byte; use(buf[:]); return Stackguard() }
-func stack3024() (uintptr, uintptr) { var buf [3024]byte; use(buf[:]); return Stackguard() }
-func stack3028() (uintptr, uintptr) { var buf [3028]byte; use(buf[:]); return Stackguard() }
-func stack3032() (uintptr, uintptr) { var buf [3032]byte; use(buf[:]); return Stackguard() }
-func stack3036() (uintptr, uintptr) { var buf [3036]byte; use(buf[:]); return Stackguard() }
-func stack3040() (uintptr, uintptr) { var buf [3040]byte; use(buf[:]); return Stackguard() }
-func stack3044() (uintptr, uintptr) { var buf [3044]byte; use(buf[:]); return Stackguard() }
-func stack3048() (uintptr, uintptr) { var buf [3048]byte; use(buf[:]); return Stackguard() }
-func stack3052() (uintptr, uintptr) { var buf [3052]byte; use(buf[:]); return Stackguard() }
-func stack3056() (uintptr, uintptr) { var buf [3056]byte; use(buf[:]); return Stackguard() }
-func stack3060() (uintptr, uintptr) { var buf [3060]byte; use(buf[:]); return Stackguard() }
-func stack3064() (uintptr, uintptr) { var buf [3064]byte; use(buf[:]); return Stackguard() }
-func stack3068() (uintptr, uintptr) { var buf [3068]byte; use(buf[:]); return Stackguard() }
-func stack3072() (uintptr, uintptr) { var buf [3072]byte; use(buf[:]); return Stackguard() }
-func stack3076() (uintptr, uintptr) { var buf [3076]byte; use(buf[:]); return Stackguard() }
-func stack3080() (uintptr, uintptr) { var buf [3080]byte; use(buf[:]); return Stackguard() }
-func stack3084() (uintptr, uintptr) { var buf [3084]byte; use(buf[:]); return Stackguard() }
-func stack3088() (uintptr, uintptr) { var buf [3088]byte; use(buf[:]); return Stackguard() }
-func stack3092() (uintptr, uintptr) { var buf [3092]byte; use(buf[:]); return Stackguard() }
-func stack3096() (uintptr, uintptr) { var buf [3096]byte; use(buf[:]); return Stackguard() }
-func stack3100() (uintptr, uintptr) { var buf [3100]byte; use(buf[:]); return Stackguard() }
-func stack3104() (uintptr, uintptr) { var buf [3104]byte; use(buf[:]); return Stackguard() }
-func stack3108() (uintptr, uintptr) { var buf [3108]byte; use(buf[:]); return Stackguard() }
-func stack3112() (uintptr, uintptr) { var buf [3112]byte; use(buf[:]); return Stackguard() }
-func stack3116() (uintptr, uintptr) { var buf [3116]byte; use(buf[:]); return Stackguard() }
-func stack3120() (uintptr, uintptr) { var buf [3120]byte; use(buf[:]); return Stackguard() }
-func stack3124() (uintptr, uintptr) { var buf [3124]byte; use(buf[:]); return Stackguard() }
-func stack3128() (uintptr, uintptr) { var buf [3128]byte; use(buf[:]); return Stackguard() }
-func stack3132() (uintptr, uintptr) { var buf [3132]byte; use(buf[:]); return Stackguard() }
-func stack3136() (uintptr, uintptr) { var buf [3136]byte; use(buf[:]); return Stackguard() }
-func stack3140() (uintptr, uintptr) { var buf [3140]byte; use(buf[:]); return Stackguard() }
-func stack3144() (uintptr, uintptr) { var buf [3144]byte; use(buf[:]); return Stackguard() }
-func stack3148() (uintptr, uintptr) { var buf [3148]byte; use(buf[:]); return Stackguard() }
-func stack3152() (uintptr, uintptr) { var buf [3152]byte; use(buf[:]); return Stackguard() }
-func stack3156() (uintptr, uintptr) { var buf [3156]byte; use(buf[:]); return Stackguard() }
-func stack3160() (uintptr, uintptr) { var buf [3160]byte; use(buf[:]); return Stackguard() }
-func stack3164() (uintptr, uintptr) { var buf [3164]byte; use(buf[:]); return Stackguard() }
-func stack3168() (uintptr, uintptr) { var buf [3168]byte; use(buf[:]); return Stackguard() }
-func stack3172() (uintptr, uintptr) { var buf [3172]byte; use(buf[:]); return Stackguard() }
-func stack3176() (uintptr, uintptr) { var buf [3176]byte; use(buf[:]); return Stackguard() }
-func stack3180() (uintptr, uintptr) { var buf [3180]byte; use(buf[:]); return Stackguard() }
-func stack3184() (uintptr, uintptr) { var buf [3184]byte; use(buf[:]); return Stackguard() }
-func stack3188() (uintptr, uintptr) { var buf [3188]byte; use(buf[:]); return Stackguard() }
-func stack3192() (uintptr, uintptr) { var buf [3192]byte; use(buf[:]); return Stackguard() }
-func stack3196() (uintptr, uintptr) { var buf [3196]byte; use(buf[:]); return Stackguard() }
-func stack3200() (uintptr, uintptr) { var buf [3200]byte; use(buf[:]); return Stackguard() }
-func stack3204() (uintptr, uintptr) { var buf [3204]byte; use(buf[:]); return Stackguard() }
-func stack3208() (uintptr, uintptr) { var buf [3208]byte; use(buf[:]); return Stackguard() }
-func stack3212() (uintptr, uintptr) { var buf [3212]byte; use(buf[:]); return Stackguard() }
-func stack3216() (uintptr, uintptr) { var buf [3216]byte; use(buf[:]); return Stackguard() }
-func stack3220() (uintptr, uintptr) { var buf [3220]byte; use(buf[:]); return Stackguard() }
-func stack3224() (uintptr, uintptr) { var buf [3224]byte; use(buf[:]); return Stackguard() }
-func stack3228() (uintptr, uintptr) { var buf [3228]byte; use(buf[:]); return Stackguard() }
-func stack3232() (uintptr, uintptr) { var buf [3232]byte; use(buf[:]); return Stackguard() }
-func stack3236() (uintptr, uintptr) { var buf [3236]byte; use(buf[:]); return Stackguard() }
-func stack3240() (uintptr, uintptr) { var buf [3240]byte; use(buf[:]); return Stackguard() }
-func stack3244() (uintptr, uintptr) { var buf [3244]byte; use(buf[:]); return Stackguard() }
-func stack3248() (uintptr, uintptr) { var buf [3248]byte; use(buf[:]); return Stackguard() }
-func stack3252() (uintptr, uintptr) { var buf [3252]byte; use(buf[:]); return Stackguard() }
-func stack3256() (uintptr, uintptr) { var buf [3256]byte; use(buf[:]); return Stackguard() }
-func stack3260() (uintptr, uintptr) { var buf [3260]byte; use(buf[:]); return Stackguard() }
-func stack3264() (uintptr, uintptr) { var buf [3264]byte; use(buf[:]); return Stackguard() }
-func stack3268() (uintptr, uintptr) { var buf [3268]byte; use(buf[:]); return Stackguard() }
-func stack3272() (uintptr, uintptr) { var buf [3272]byte; use(buf[:]); return Stackguard() }
-func stack3276() (uintptr, uintptr) { var buf [3276]byte; use(buf[:]); return Stackguard() }
-func stack3280() (uintptr, uintptr) { var buf [3280]byte; use(buf[:]); return Stackguard() }
-func stack3284() (uintptr, uintptr) { var buf [3284]byte; use(buf[:]); return Stackguard() }
-func stack3288() (uintptr, uintptr) { var buf [3288]byte; use(buf[:]); return Stackguard() }
-func stack3292() (uintptr, uintptr) { var buf [3292]byte; use(buf[:]); return Stackguard() }
-func stack3296() (uintptr, uintptr) { var buf [3296]byte; use(buf[:]); return Stackguard() }
-func stack3300() (uintptr, uintptr) { var buf [3300]byte; use(buf[:]); return Stackguard() }
-func stack3304() (uintptr, uintptr) { var buf [3304]byte; use(buf[:]); return Stackguard() }
-func stack3308() (uintptr, uintptr) { var buf [3308]byte; use(buf[:]); return Stackguard() }
-func stack3312() (uintptr, uintptr) { var buf [3312]byte; use(buf[:]); return Stackguard() }
-func stack3316() (uintptr, uintptr) { var buf [3316]byte; use(buf[:]); return Stackguard() }
-func stack3320() (uintptr, uintptr) { var buf [3320]byte; use(buf[:]); return Stackguard() }
-func stack3324() (uintptr, uintptr) { var buf [3324]byte; use(buf[:]); return Stackguard() }
-func stack3328() (uintptr, uintptr) { var buf [3328]byte; use(buf[:]); return Stackguard() }
-func stack3332() (uintptr, uintptr) { var buf [3332]byte; use(buf[:]); return Stackguard() }
-func stack3336() (uintptr, uintptr) { var buf [3336]byte; use(buf[:]); return Stackguard() }
-func stack3340() (uintptr, uintptr) { var buf [3340]byte; use(buf[:]); return Stackguard() }
-func stack3344() (uintptr, uintptr) { var buf [3344]byte; use(buf[:]); return Stackguard() }
-func stack3348() (uintptr, uintptr) { var buf [3348]byte; use(buf[:]); return Stackguard() }
-func stack3352() (uintptr, uintptr) { var buf [3352]byte; use(buf[:]); return Stackguard() }
-func stack3356() (uintptr, uintptr) { var buf [3356]byte; use(buf[:]); return Stackguard() }
-func stack3360() (uintptr, uintptr) { var buf [3360]byte; use(buf[:]); return Stackguard() }
-func stack3364() (uintptr, uintptr) { var buf [3364]byte; use(buf[:]); return Stackguard() }
-func stack3368() (uintptr, uintptr) { var buf [3368]byte; use(buf[:]); return Stackguard() }
-func stack3372() (uintptr, uintptr) { var buf [3372]byte; use(buf[:]); return Stackguard() }
-func stack3376() (uintptr, uintptr) { var buf [3376]byte; use(buf[:]); return Stackguard() }
-func stack3380() (uintptr, uintptr) { var buf [3380]byte; use(buf[:]); return Stackguard() }
-func stack3384() (uintptr, uintptr) { var buf [3384]byte; use(buf[:]); return Stackguard() }
-func stack3388() (uintptr, uintptr) { var buf [3388]byte; use(buf[:]); return Stackguard() }
-func stack3392() (uintptr, uintptr) { var buf [3392]byte; use(buf[:]); return Stackguard() }
-func stack3396() (uintptr, uintptr) { var buf [3396]byte; use(buf[:]); return Stackguard() }
-func stack3400() (uintptr, uintptr) { var buf [3400]byte; use(buf[:]); return Stackguard() }
-func stack3404() (uintptr, uintptr) { var buf [3404]byte; use(buf[:]); return Stackguard() }
-func stack3408() (uintptr, uintptr) { var buf [3408]byte; use(buf[:]); return Stackguard() }
-func stack3412() (uintptr, uintptr) { var buf [3412]byte; use(buf[:]); return Stackguard() }
-func stack3416() (uintptr, uintptr) { var buf [3416]byte; use(buf[:]); return Stackguard() }
-func stack3420() (uintptr, uintptr) { var buf [3420]byte; use(buf[:]); return Stackguard() }
-func stack3424() (uintptr, uintptr) { var buf [3424]byte; use(buf[:]); return Stackguard() }
-func stack3428() (uintptr, uintptr) { var buf [3428]byte; use(buf[:]); return Stackguard() }
-func stack3432() (uintptr, uintptr) { var buf [3432]byte; use(buf[:]); return Stackguard() }
-func stack3436() (uintptr, uintptr) { var buf [3436]byte; use(buf[:]); return Stackguard() }
-func stack3440() (uintptr, uintptr) { var buf [3440]byte; use(buf[:]); return Stackguard() }
-func stack3444() (uintptr, uintptr) { var buf [3444]byte; use(buf[:]); return Stackguard() }
-func stack3448() (uintptr, uintptr) { var buf [3448]byte; use(buf[:]); return Stackguard() }
-func stack3452() (uintptr, uintptr) { var buf [3452]byte; use(buf[:]); return Stackguard() }
-func stack3456() (uintptr, uintptr) { var buf [3456]byte; use(buf[:]); return Stackguard() }
-func stack3460() (uintptr, uintptr) { var buf [3460]byte; use(buf[:]); return Stackguard() }
-func stack3464() (uintptr, uintptr) { var buf [3464]byte; use(buf[:]); return Stackguard() }
-func stack3468() (uintptr, uintptr) { var buf [3468]byte; use(buf[:]); return Stackguard() }
-func stack3472() (uintptr, uintptr) { var buf [3472]byte; use(buf[:]); return Stackguard() }
-func stack3476() (uintptr, uintptr) { var buf [3476]byte; use(buf[:]); return Stackguard() }
-func stack3480() (uintptr, uintptr) { var buf [3480]byte; use(buf[:]); return Stackguard() }
-func stack3484() (uintptr, uintptr) { var buf [3484]byte; use(buf[:]); return Stackguard() }
-func stack3488() (uintptr, uintptr) { var buf [3488]byte; use(buf[:]); return Stackguard() }
-func stack3492() (uintptr, uintptr) { var buf [3492]byte; use(buf[:]); return Stackguard() }
-func stack3496() (uintptr, uintptr) { var buf [3496]byte; use(buf[:]); return Stackguard() }
-func stack3500() (uintptr, uintptr) { var buf [3500]byte; use(buf[:]); return Stackguard() }
-func stack3504() (uintptr, uintptr) { var buf [3504]byte; use(buf[:]); return Stackguard() }
-func stack3508() (uintptr, uintptr) { var buf [3508]byte; use(buf[:]); return Stackguard() }
-func stack3512() (uintptr, uintptr) { var buf [3512]byte; use(buf[:]); return Stackguard() }
-func stack3516() (uintptr, uintptr) { var buf [3516]byte; use(buf[:]); return Stackguard() }
-func stack3520() (uintptr, uintptr) { var buf [3520]byte; use(buf[:]); return Stackguard() }
-func stack3524() (uintptr, uintptr) { var buf [3524]byte; use(buf[:]); return Stackguard() }
-func stack3528() (uintptr, uintptr) { var buf [3528]byte; use(buf[:]); return Stackguard() }
-func stack3532() (uintptr, uintptr) { var buf [3532]byte; use(buf[:]); return Stackguard() }
-func stack3536() (uintptr, uintptr) { var buf [3536]byte; use(buf[:]); return Stackguard() }
-func stack3540() (uintptr, uintptr) { var buf [3540]byte; use(buf[:]); return Stackguard() }
-func stack3544() (uintptr, uintptr) { var buf [3544]byte; use(buf[:]); return Stackguard() }
-func stack3548() (uintptr, uintptr) { var buf [3548]byte; use(buf[:]); return Stackguard() }
-func stack3552() (uintptr, uintptr) { var buf [3552]byte; use(buf[:]); return Stackguard() }
-func stack3556() (uintptr, uintptr) { var buf [3556]byte; use(buf[:]); return Stackguard() }
-func stack3560() (uintptr, uintptr) { var buf [3560]byte; use(buf[:]); return Stackguard() }
-func stack3564() (uintptr, uintptr) { var buf [3564]byte; use(buf[:]); return Stackguard() }
-func stack3568() (uintptr, uintptr) { var buf [3568]byte; use(buf[:]); return Stackguard() }
-func stack3572() (uintptr, uintptr) { var buf [3572]byte; use(buf[:]); return Stackguard() }
-func stack3576() (uintptr, uintptr) { var buf [3576]byte; use(buf[:]); return Stackguard() }
-func stack3580() (uintptr, uintptr) { var buf [3580]byte; use(buf[:]); return Stackguard() }
-func stack3584() (uintptr, uintptr) { var buf [3584]byte; use(buf[:]); return Stackguard() }
-func stack3588() (uintptr, uintptr) { var buf [3588]byte; use(buf[:]); return Stackguard() }
-func stack3592() (uintptr, uintptr) { var buf [3592]byte; use(buf[:]); return Stackguard() }
-func stack3596() (uintptr, uintptr) { var buf [3596]byte; use(buf[:]); return Stackguard() }
-func stack3600() (uintptr, uintptr) { var buf [3600]byte; use(buf[:]); return Stackguard() }
-func stack3604() (uintptr, uintptr) { var buf [3604]byte; use(buf[:]); return Stackguard() }
-func stack3608() (uintptr, uintptr) { var buf [3608]byte; use(buf[:]); return Stackguard() }
-func stack3612() (uintptr, uintptr) { var buf [3612]byte; use(buf[:]); return Stackguard() }
-func stack3616() (uintptr, uintptr) { var buf [3616]byte; use(buf[:]); return Stackguard() }
-func stack3620() (uintptr, uintptr) { var buf [3620]byte; use(buf[:]); return Stackguard() }
-func stack3624() (uintptr, uintptr) { var buf [3624]byte; use(buf[:]); return Stackguard() }
-func stack3628() (uintptr, uintptr) { var buf [3628]byte; use(buf[:]); return Stackguard() }
-func stack3632() (uintptr, uintptr) { var buf [3632]byte; use(buf[:]); return Stackguard() }
-func stack3636() (uintptr, uintptr) { var buf [3636]byte; use(buf[:]); return Stackguard() }
-func stack3640() (uintptr, uintptr) { var buf [3640]byte; use(buf[:]); return Stackguard() }
-func stack3644() (uintptr, uintptr) { var buf [3644]byte; use(buf[:]); return Stackguard() }
-func stack3648() (uintptr, uintptr) { var buf [3648]byte; use(buf[:]); return Stackguard() }
-func stack3652() (uintptr, uintptr) { var buf [3652]byte; use(buf[:]); return Stackguard() }
-func stack3656() (uintptr, uintptr) { var buf [3656]byte; use(buf[:]); return Stackguard() }
-func stack3660() (uintptr, uintptr) { var buf [3660]byte; use(buf[:]); return Stackguard() }
-func stack3664() (uintptr, uintptr) { var buf [3664]byte; use(buf[:]); return Stackguard() }
-func stack3668() (uintptr, uintptr) { var buf [3668]byte; use(buf[:]); return Stackguard() }
-func stack3672() (uintptr, uintptr) { var buf [3672]byte; use(buf[:]); return Stackguard() }
-func stack3676() (uintptr, uintptr) { var buf [3676]byte; use(buf[:]); return Stackguard() }
-func stack3680() (uintptr, uintptr) { var buf [3680]byte; use(buf[:]); return Stackguard() }
-func stack3684() (uintptr, uintptr) { var buf [3684]byte; use(buf[:]); return Stackguard() }
-func stack3688() (uintptr, uintptr) { var buf [3688]byte; use(buf[:]); return Stackguard() }
-func stack3692() (uintptr, uintptr) { var buf [3692]byte; use(buf[:]); return Stackguard() }
-func stack3696() (uintptr, uintptr) { var buf [3696]byte; use(buf[:]); return Stackguard() }
-func stack3700() (uintptr, uintptr) { var buf [3700]byte; use(buf[:]); return Stackguard() }
-func stack3704() (uintptr, uintptr) { var buf [3704]byte; use(buf[:]); return Stackguard() }
-func stack3708() (uintptr, uintptr) { var buf [3708]byte; use(buf[:]); return Stackguard() }
-func stack3712() (uintptr, uintptr) { var buf [3712]byte; use(buf[:]); return Stackguard() }
-func stack3716() (uintptr, uintptr) { var buf [3716]byte; use(buf[:]); return Stackguard() }
-func stack3720() (uintptr, uintptr) { var buf [3720]byte; use(buf[:]); return Stackguard() }
-func stack3724() (uintptr, uintptr) { var buf [3724]byte; use(buf[:]); return Stackguard() }
-func stack3728() (uintptr, uintptr) { var buf [3728]byte; use(buf[:]); return Stackguard() }
-func stack3732() (uintptr, uintptr) { var buf [3732]byte; use(buf[:]); return Stackguard() }
-func stack3736() (uintptr, uintptr) { var buf [3736]byte; use(buf[:]); return Stackguard() }
-func stack3740() (uintptr, uintptr) { var buf [3740]byte; use(buf[:]); return Stackguard() }
-func stack3744() (uintptr, uintptr) { var buf [3744]byte; use(buf[:]); return Stackguard() }
-func stack3748() (uintptr, uintptr) { var buf [3748]byte; use(buf[:]); return Stackguard() }
-func stack3752() (uintptr, uintptr) { var buf [3752]byte; use(buf[:]); return Stackguard() }
-func stack3756() (uintptr, uintptr) { var buf [3756]byte; use(buf[:]); return Stackguard() }
-func stack3760() (uintptr, uintptr) { var buf [3760]byte; use(buf[:]); return Stackguard() }
-func stack3764() (uintptr, uintptr) { var buf [3764]byte; use(buf[:]); return Stackguard() }
-func stack3768() (uintptr, uintptr) { var buf [3768]byte; use(buf[:]); return Stackguard() }
-func stack3772() (uintptr, uintptr) { var buf [3772]byte; use(buf[:]); return Stackguard() }
-func stack3776() (uintptr, uintptr) { var buf [3776]byte; use(buf[:]); return Stackguard() }
-func stack3780() (uintptr, uintptr) { var buf [3780]byte; use(buf[:]); return Stackguard() }
-func stack3784() (uintptr, uintptr) { var buf [3784]byte; use(buf[:]); return Stackguard() }
-func stack3788() (uintptr, uintptr) { var buf [3788]byte; use(buf[:]); return Stackguard() }
-func stack3792() (uintptr, uintptr) { var buf [3792]byte; use(buf[:]); return Stackguard() }
-func stack3796() (uintptr, uintptr) { var buf [3796]byte; use(buf[:]); return Stackguard() }
-func stack3800() (uintptr, uintptr) { var buf [3800]byte; use(buf[:]); return Stackguard() }
-func stack3804() (uintptr, uintptr) { var buf [3804]byte; use(buf[:]); return Stackguard() }
-func stack3808() (uintptr, uintptr) { var buf [3808]byte; use(buf[:]); return Stackguard() }
-func stack3812() (uintptr, uintptr) { var buf [3812]byte; use(buf[:]); return Stackguard() }
-func stack3816() (uintptr, uintptr) { var buf [3816]byte; use(buf[:]); return Stackguard() }
-func stack3820() (uintptr, uintptr) { var buf [3820]byte; use(buf[:]); return Stackguard() }
-func stack3824() (uintptr, uintptr) { var buf [3824]byte; use(buf[:]); return Stackguard() }
-func stack3828() (uintptr, uintptr) { var buf [3828]byte; use(buf[:]); return Stackguard() }
-func stack3832() (uintptr, uintptr) { var buf [3832]byte; use(buf[:]); return Stackguard() }
-func stack3836() (uintptr, uintptr) { var buf [3836]byte; use(buf[:]); return Stackguard() }
-func stack3840() (uintptr, uintptr) { var buf [3840]byte; use(buf[:]); return Stackguard() }
-func stack3844() (uintptr, uintptr) { var buf [3844]byte; use(buf[:]); return Stackguard() }
-func stack3848() (uintptr, uintptr) { var buf [3848]byte; use(buf[:]); return Stackguard() }
-func stack3852() (uintptr, uintptr) { var buf [3852]byte; use(buf[:]); return Stackguard() }
-func stack3856() (uintptr, uintptr) { var buf [3856]byte; use(buf[:]); return Stackguard() }
-func stack3860() (uintptr, uintptr) { var buf [3860]byte; use(buf[:]); return Stackguard() }
-func stack3864() (uintptr, uintptr) { var buf [3864]byte; use(buf[:]); return Stackguard() }
-func stack3868() (uintptr, uintptr) { var buf [3868]byte; use(buf[:]); return Stackguard() }
-func stack3872() (uintptr, uintptr) { var buf [3872]byte; use(buf[:]); return Stackguard() }
-func stack3876() (uintptr, uintptr) { var buf [3876]byte; use(buf[:]); return Stackguard() }
-func stack3880() (uintptr, uintptr) { var buf [3880]byte; use(buf[:]); return Stackguard() }
-func stack3884() (uintptr, uintptr) { var buf [3884]byte; use(buf[:]); return Stackguard() }
-func stack3888() (uintptr, uintptr) { var buf [3888]byte; use(buf[:]); return Stackguard() }
-func stack3892() (uintptr, uintptr) { var buf [3892]byte; use(buf[:]); return Stackguard() }
-func stack3896() (uintptr, uintptr) { var buf [3896]byte; use(buf[:]); return Stackguard() }
-func stack3900() (uintptr, uintptr) { var buf [3900]byte; use(buf[:]); return Stackguard() }
-func stack3904() (uintptr, uintptr) { var buf [3904]byte; use(buf[:]); return Stackguard() }
-func stack3908() (uintptr, uintptr) { var buf [3908]byte; use(buf[:]); return Stackguard() }
-func stack3912() (uintptr, uintptr) { var buf [3912]byte; use(buf[:]); return Stackguard() }
-func stack3916() (uintptr, uintptr) { var buf [3916]byte; use(buf[:]); return Stackguard() }
-func stack3920() (uintptr, uintptr) { var buf [3920]byte; use(buf[:]); return Stackguard() }
-func stack3924() (uintptr, uintptr) { var buf [3924]byte; use(buf[:]); return Stackguard() }
-func stack3928() (uintptr, uintptr) { var buf [3928]byte; use(buf[:]); return Stackguard() }
-func stack3932() (uintptr, uintptr) { var buf [3932]byte; use(buf[:]); return Stackguard() }
-func stack3936() (uintptr, uintptr) { var buf [3936]byte; use(buf[:]); return Stackguard() }
-func stack3940() (uintptr, uintptr) { var buf [3940]byte; use(buf[:]); return Stackguard() }
-func stack3944() (uintptr, uintptr) { var buf [3944]byte; use(buf[:]); return Stackguard() }
-func stack3948() (uintptr, uintptr) { var buf [3948]byte; use(buf[:]); return Stackguard() }
-func stack3952() (uintptr, uintptr) { var buf [3952]byte; use(buf[:]); return Stackguard() }
-func stack3956() (uintptr, uintptr) { var buf [3956]byte; use(buf[:]); return Stackguard() }
-func stack3960() (uintptr, uintptr) { var buf [3960]byte; use(buf[:]); return Stackguard() }
-func stack3964() (uintptr, uintptr) { var buf [3964]byte; use(buf[:]); return Stackguard() }
-func stack3968() (uintptr, uintptr) { var buf [3968]byte; use(buf[:]); return Stackguard() }
-func stack3972() (uintptr, uintptr) { var buf [3972]byte; use(buf[:]); return Stackguard() }
-func stack3976() (uintptr, uintptr) { var buf [3976]byte; use(buf[:]); return Stackguard() }
-func stack3980() (uintptr, uintptr) { var buf [3980]byte; use(buf[:]); return Stackguard() }
-func stack3984() (uintptr, uintptr) { var buf [3984]byte; use(buf[:]); return Stackguard() }
-func stack3988() (uintptr, uintptr) { var buf [3988]byte; use(buf[:]); return Stackguard() }
-func stack3992() (uintptr, uintptr) { var buf [3992]byte; use(buf[:]); return Stackguard() }
-func stack3996() (uintptr, uintptr) { var buf [3996]byte; use(buf[:]); return Stackguard() }
-func stack4000() (uintptr, uintptr) { var buf [4000]byte; use(buf[:]); return Stackguard() }
-func stack4004() (uintptr, uintptr) { var buf [4004]byte; use(buf[:]); return Stackguard() }
-func stack4008() (uintptr, uintptr) { var buf [4008]byte; use(buf[:]); return Stackguard() }
-func stack4012() (uintptr, uintptr) { var buf [4012]byte; use(buf[:]); return Stackguard() }
-func stack4016() (uintptr, uintptr) { var buf [4016]byte; use(buf[:]); return Stackguard() }
-func stack4020() (uintptr, uintptr) { var buf [4020]byte; use(buf[:]); return Stackguard() }
-func stack4024() (uintptr, uintptr) { var buf [4024]byte; use(buf[:]); return Stackguard() }
-func stack4028() (uintptr, uintptr) { var buf [4028]byte; use(buf[:]); return Stackguard() }
-func stack4032() (uintptr, uintptr) { var buf [4032]byte; use(buf[:]); return Stackguard() }
-func stack4036() (uintptr, uintptr) { var buf [4036]byte; use(buf[:]); return Stackguard() }
-func stack4040() (uintptr, uintptr) { var buf [4040]byte; use(buf[:]); return Stackguard() }
-func stack4044() (uintptr, uintptr) { var buf [4044]byte; use(buf[:]); return Stackguard() }
-func stack4048() (uintptr, uintptr) { var buf [4048]byte; use(buf[:]); return Stackguard() }
-func stack4052() (uintptr, uintptr) { var buf [4052]byte; use(buf[:]); return Stackguard() }
-func stack4056() (uintptr, uintptr) { var buf [4056]byte; use(buf[:]); return Stackguard() }
-func stack4060() (uintptr, uintptr) { var buf [4060]byte; use(buf[:]); return Stackguard() }
-func stack4064() (uintptr, uintptr) { var buf [4064]byte; use(buf[:]); return Stackguard() }
-func stack4068() (uintptr, uintptr) { var buf [4068]byte; use(buf[:]); return Stackguard() }
-func stack4072() (uintptr, uintptr) { var buf [4072]byte; use(buf[:]); return Stackguard() }
-func stack4076() (uintptr, uintptr) { var buf [4076]byte; use(buf[:]); return Stackguard() }
-func stack4080() (uintptr, uintptr) { var buf [4080]byte; use(buf[:]); return Stackguard() }
-func stack4084() (uintptr, uintptr) { var buf [4084]byte; use(buf[:]); return Stackguard() }
-func stack4088() (uintptr, uintptr) { var buf [4088]byte; use(buf[:]); return Stackguard() }
-func stack4092() (uintptr, uintptr) { var buf [4092]byte; use(buf[:]); return Stackguard() }
-func stack4096() (uintptr, uintptr) { var buf [4096]byte; use(buf[:]); return Stackguard() }
-func stack4100() (uintptr, uintptr) { var buf [4100]byte; use(buf[:]); return Stackguard() }
-func stack4104() (uintptr, uintptr) { var buf [4104]byte; use(buf[:]); return Stackguard() }
-func stack4108() (uintptr, uintptr) { var buf [4108]byte; use(buf[:]); return Stackguard() }
-func stack4112() (uintptr, uintptr) { var buf [4112]byte; use(buf[:]); return Stackguard() }
-func stack4116() (uintptr, uintptr) { var buf [4116]byte; use(buf[:]); return Stackguard() }
-func stack4120() (uintptr, uintptr) { var buf [4120]byte; use(buf[:]); return Stackguard() }
-func stack4124() (uintptr, uintptr) { var buf [4124]byte; use(buf[:]); return Stackguard() }
-func stack4128() (uintptr, uintptr) { var buf [4128]byte; use(buf[:]); return Stackguard() }
-func stack4132() (uintptr, uintptr) { var buf [4132]byte; use(buf[:]); return Stackguard() }
-func stack4136() (uintptr, uintptr) { var buf [4136]byte; use(buf[:]); return Stackguard() }
-func stack4140() (uintptr, uintptr) { var buf [4140]byte; use(buf[:]); return Stackguard() }
-func stack4144() (uintptr, uintptr) { var buf [4144]byte; use(buf[:]); return Stackguard() }
-func stack4148() (uintptr, uintptr) { var buf [4148]byte; use(buf[:]); return Stackguard() }
-func stack4152() (uintptr, uintptr) { var buf [4152]byte; use(buf[:]); return Stackguard() }
-func stack4156() (uintptr, uintptr) { var buf [4156]byte; use(buf[:]); return Stackguard() }
-func stack4160() (uintptr, uintptr) { var buf [4160]byte; use(buf[:]); return Stackguard() }
-func stack4164() (uintptr, uintptr) { var buf [4164]byte; use(buf[:]); return Stackguard() }
-func stack4168() (uintptr, uintptr) { var buf [4168]byte; use(buf[:]); return Stackguard() }
-func stack4172() (uintptr, uintptr) { var buf [4172]byte; use(buf[:]); return Stackguard() }
-func stack4176() (uintptr, uintptr) { var buf [4176]byte; use(buf[:]); return Stackguard() }
-func stack4180() (uintptr, uintptr) { var buf [4180]byte; use(buf[:]); return Stackguard() }
-func stack4184() (uintptr, uintptr) { var buf [4184]byte; use(buf[:]); return Stackguard() }
-func stack4188() (uintptr, uintptr) { var buf [4188]byte; use(buf[:]); return Stackguard() }
-func stack4192() (uintptr, uintptr) { var buf [4192]byte; use(buf[:]); return Stackguard() }
-func stack4196() (uintptr, uintptr) { var buf [4196]byte; use(buf[:]); return Stackguard() }
-func stack4200() (uintptr, uintptr) { var buf [4200]byte; use(buf[:]); return Stackguard() }
-func stack4204() (uintptr, uintptr) { var buf [4204]byte; use(buf[:]); return Stackguard() }
-func stack4208() (uintptr, uintptr) { var buf [4208]byte; use(buf[:]); return Stackguard() }
-func stack4212() (uintptr, uintptr) { var buf [4212]byte; use(buf[:]); return Stackguard() }
-func stack4216() (uintptr, uintptr) { var buf [4216]byte; use(buf[:]); return Stackguard() }
-func stack4220() (uintptr, uintptr) { var buf [4220]byte; use(buf[:]); return Stackguard() }
-func stack4224() (uintptr, uintptr) { var buf [4224]byte; use(buf[:]); return Stackguard() }
-func stack4228() (uintptr, uintptr) { var buf [4228]byte; use(buf[:]); return Stackguard() }
-func stack4232() (uintptr, uintptr) { var buf [4232]byte; use(buf[:]); return Stackguard() }
-func stack4236() (uintptr, uintptr) { var buf [4236]byte; use(buf[:]); return Stackguard() }
-func stack4240() (uintptr, uintptr) { var buf [4240]byte; use(buf[:]); return Stackguard() }
-func stack4244() (uintptr, uintptr) { var buf [4244]byte; use(buf[:]); return Stackguard() }
-func stack4248() (uintptr, uintptr) { var buf [4248]byte; use(buf[:]); return Stackguard() }
-func stack4252() (uintptr, uintptr) { var buf [4252]byte; use(buf[:]); return Stackguard() }
-func stack4256() (uintptr, uintptr) { var buf [4256]byte; use(buf[:]); return Stackguard() }
-func stack4260() (uintptr, uintptr) { var buf [4260]byte; use(buf[:]); return Stackguard() }
-func stack4264() (uintptr, uintptr) { var buf [4264]byte; use(buf[:]); return Stackguard() }
-func stack4268() (uintptr, uintptr) { var buf [4268]byte; use(buf[:]); return Stackguard() }
-func stack4272() (uintptr, uintptr) { var buf [4272]byte; use(buf[:]); return Stackguard() }
-func stack4276() (uintptr, uintptr) { var buf [4276]byte; use(buf[:]); return Stackguard() }
-func stack4280() (uintptr, uintptr) { var buf [4280]byte; use(buf[:]); return Stackguard() }
-func stack4284() (uintptr, uintptr) { var buf [4284]byte; use(buf[:]); return Stackguard() }
-func stack4288() (uintptr, uintptr) { var buf [4288]byte; use(buf[:]); return Stackguard() }
-func stack4292() (uintptr, uintptr) { var buf [4292]byte; use(buf[:]); return Stackguard() }
-func stack4296() (uintptr, uintptr) { var buf [4296]byte; use(buf[:]); return Stackguard() }
-func stack4300() (uintptr, uintptr) { var buf [4300]byte; use(buf[:]); return Stackguard() }
-func stack4304() (uintptr, uintptr) { var buf [4304]byte; use(buf[:]); return Stackguard() }
-func stack4308() (uintptr, uintptr) { var buf [4308]byte; use(buf[:]); return Stackguard() }
-func stack4312() (uintptr, uintptr) { var buf [4312]byte; use(buf[:]); return Stackguard() }
-func stack4316() (uintptr, uintptr) { var buf [4316]byte; use(buf[:]); return Stackguard() }
-func stack4320() (uintptr, uintptr) { var buf [4320]byte; use(buf[:]); return Stackguard() }
-func stack4324() (uintptr, uintptr) { var buf [4324]byte; use(buf[:]); return Stackguard() }
-func stack4328() (uintptr, uintptr) { var buf [4328]byte; use(buf[:]); return Stackguard() }
-func stack4332() (uintptr, uintptr) { var buf [4332]byte; use(buf[:]); return Stackguard() }
-func stack4336() (uintptr, uintptr) { var buf [4336]byte; use(buf[:]); return Stackguard() }
-func stack4340() (uintptr, uintptr) { var buf [4340]byte; use(buf[:]); return Stackguard() }
-func stack4344() (uintptr, uintptr) { var buf [4344]byte; use(buf[:]); return Stackguard() }
-func stack4348() (uintptr, uintptr) { var buf [4348]byte; use(buf[:]); return Stackguard() }
-func stack4352() (uintptr, uintptr) { var buf [4352]byte; use(buf[:]); return Stackguard() }
-func stack4356() (uintptr, uintptr) { var buf [4356]byte; use(buf[:]); return Stackguard() }
-func stack4360() (uintptr, uintptr) { var buf [4360]byte; use(buf[:]); return Stackguard() }
-func stack4364() (uintptr, uintptr) { var buf [4364]byte; use(buf[:]); return Stackguard() }
-func stack4368() (uintptr, uintptr) { var buf [4368]byte; use(buf[:]); return Stackguard() }
-func stack4372() (uintptr, uintptr) { var buf [4372]byte; use(buf[:]); return Stackguard() }
-func stack4376() (uintptr, uintptr) { var buf [4376]byte; use(buf[:]); return Stackguard() }
-func stack4380() (uintptr, uintptr) { var buf [4380]byte; use(buf[:]); return Stackguard() }
-func stack4384() (uintptr, uintptr) { var buf [4384]byte; use(buf[:]); return Stackguard() }
-func stack4388() (uintptr, uintptr) { var buf [4388]byte; use(buf[:]); return Stackguard() }
-func stack4392() (uintptr, uintptr) { var buf [4392]byte; use(buf[:]); return Stackguard() }
-func stack4396() (uintptr, uintptr) { var buf [4396]byte; use(buf[:]); return Stackguard() }
-func stack4400() (uintptr, uintptr) { var buf [4400]byte; use(buf[:]); return Stackguard() }
-func stack4404() (uintptr, uintptr) { var buf [4404]byte; use(buf[:]); return Stackguard() }
-func stack4408() (uintptr, uintptr) { var buf [4408]byte; use(buf[:]); return Stackguard() }
-func stack4412() (uintptr, uintptr) { var buf [4412]byte; use(buf[:]); return Stackguard() }
-func stack4416() (uintptr, uintptr) { var buf [4416]byte; use(buf[:]); return Stackguard() }
-func stack4420() (uintptr, uintptr) { var buf [4420]byte; use(buf[:]); return Stackguard() }
-func stack4424() (uintptr, uintptr) { var buf [4424]byte; use(buf[:]); return Stackguard() }
-func stack4428() (uintptr, uintptr) { var buf [4428]byte; use(buf[:]); return Stackguard() }
-func stack4432() (uintptr, uintptr) { var buf [4432]byte; use(buf[:]); return Stackguard() }
-func stack4436() (uintptr, uintptr) { var buf [4436]byte; use(buf[:]); return Stackguard() }
-func stack4440() (uintptr, uintptr) { var buf [4440]byte; use(buf[:]); return Stackguard() }
-func stack4444() (uintptr, uintptr) { var buf [4444]byte; use(buf[:]); return Stackguard() }
-func stack4448() (uintptr, uintptr) { var buf [4448]byte; use(buf[:]); return Stackguard() }
-func stack4452() (uintptr, uintptr) { var buf [4452]byte; use(buf[:]); return Stackguard() }
-func stack4456() (uintptr, uintptr) { var buf [4456]byte; use(buf[:]); return Stackguard() }
-func stack4460() (uintptr, uintptr) { var buf [4460]byte; use(buf[:]); return Stackguard() }
-func stack4464() (uintptr, uintptr) { var buf [4464]byte; use(buf[:]); return Stackguard() }
-func stack4468() (uintptr, uintptr) { var buf [4468]byte; use(buf[:]); return Stackguard() }
-func stack4472() (uintptr, uintptr) { var buf [4472]byte; use(buf[:]); return Stackguard() }
-func stack4476() (uintptr, uintptr) { var buf [4476]byte; use(buf[:]); return Stackguard() }
-func stack4480() (uintptr, uintptr) { var buf [4480]byte; use(buf[:]); return Stackguard() }
-func stack4484() (uintptr, uintptr) { var buf [4484]byte; use(buf[:]); return Stackguard() }
-func stack4488() (uintptr, uintptr) { var buf [4488]byte; use(buf[:]); return Stackguard() }
-func stack4492() (uintptr, uintptr) { var buf [4492]byte; use(buf[:]); return Stackguard() }
-func stack4496() (uintptr, uintptr) { var buf [4496]byte; use(buf[:]); return Stackguard() }
-func stack4500() (uintptr, uintptr) { var buf [4500]byte; use(buf[:]); return Stackguard() }
-func stack4504() (uintptr, uintptr) { var buf [4504]byte; use(buf[:]); return Stackguard() }
-func stack4508() (uintptr, uintptr) { var buf [4508]byte; use(buf[:]); return Stackguard() }
-func stack4512() (uintptr, uintptr) { var buf [4512]byte; use(buf[:]); return Stackguard() }
-func stack4516() (uintptr, uintptr) { var buf [4516]byte; use(buf[:]); return Stackguard() }
-func stack4520() (uintptr, uintptr) { var buf [4520]byte; use(buf[:]); return Stackguard() }
-func stack4524() (uintptr, uintptr) { var buf [4524]byte; use(buf[:]); return Stackguard() }
-func stack4528() (uintptr, uintptr) { var buf [4528]byte; use(buf[:]); return Stackguard() }
-func stack4532() (uintptr, uintptr) { var buf [4532]byte; use(buf[:]); return Stackguard() }
-func stack4536() (uintptr, uintptr) { var buf [4536]byte; use(buf[:]); return Stackguard() }
-func stack4540() (uintptr, uintptr) { var buf [4540]byte; use(buf[:]); return Stackguard() }
-func stack4544() (uintptr, uintptr) { var buf [4544]byte; use(buf[:]); return Stackguard() }
-func stack4548() (uintptr, uintptr) { var buf [4548]byte; use(buf[:]); return Stackguard() }
-func stack4552() (uintptr, uintptr) { var buf [4552]byte; use(buf[:]); return Stackguard() }
-func stack4556() (uintptr, uintptr) { var buf [4556]byte; use(buf[:]); return Stackguard() }
-func stack4560() (uintptr, uintptr) { var buf [4560]byte; use(buf[:]); return Stackguard() }
-func stack4564() (uintptr, uintptr) { var buf [4564]byte; use(buf[:]); return Stackguard() }
-func stack4568() (uintptr, uintptr) { var buf [4568]byte; use(buf[:]); return Stackguard() }
-func stack4572() (uintptr, uintptr) { var buf [4572]byte; use(buf[:]); return Stackguard() }
-func stack4576() (uintptr, uintptr) { var buf [4576]byte; use(buf[:]); return Stackguard() }
-func stack4580() (uintptr, uintptr) { var buf [4580]byte; use(buf[:]); return Stackguard() }
-func stack4584() (uintptr, uintptr) { var buf [4584]byte; use(buf[:]); return Stackguard() }
-func stack4588() (uintptr, uintptr) { var buf [4588]byte; use(buf[:]); return Stackguard() }
-func stack4592() (uintptr, uintptr) { var buf [4592]byte; use(buf[:]); return Stackguard() }
-func stack4596() (uintptr, uintptr) { var buf [4596]byte; use(buf[:]); return Stackguard() }
-func stack4600() (uintptr, uintptr) { var buf [4600]byte; use(buf[:]); return Stackguard() }
-func stack4604() (uintptr, uintptr) { var buf [4604]byte; use(buf[:]); return Stackguard() }
-func stack4608() (uintptr, uintptr) { var buf [4608]byte; use(buf[:]); return Stackguard() }
-func stack4612() (uintptr, uintptr) { var buf [4612]byte; use(buf[:]); return Stackguard() }
-func stack4616() (uintptr, uintptr) { var buf [4616]byte; use(buf[:]); return Stackguard() }
-func stack4620() (uintptr, uintptr) { var buf [4620]byte; use(buf[:]); return Stackguard() }
-func stack4624() (uintptr, uintptr) { var buf [4624]byte; use(buf[:]); return Stackguard() }
-func stack4628() (uintptr, uintptr) { var buf [4628]byte; use(buf[:]); return Stackguard() }
-func stack4632() (uintptr, uintptr) { var buf [4632]byte; use(buf[:]); return Stackguard() }
-func stack4636() (uintptr, uintptr) { var buf [4636]byte; use(buf[:]); return Stackguard() }
-func stack4640() (uintptr, uintptr) { var buf [4640]byte; use(buf[:]); return Stackguard() }
-func stack4644() (uintptr, uintptr) { var buf [4644]byte; use(buf[:]); return Stackguard() }
-func stack4648() (uintptr, uintptr) { var buf [4648]byte; use(buf[:]); return Stackguard() }
-func stack4652() (uintptr, uintptr) { var buf [4652]byte; use(buf[:]); return Stackguard() }
-func stack4656() (uintptr, uintptr) { var buf [4656]byte; use(buf[:]); return Stackguard() }
-func stack4660() (uintptr, uintptr) { var buf [4660]byte; use(buf[:]); return Stackguard() }
-func stack4664() (uintptr, uintptr) { var buf [4664]byte; use(buf[:]); return Stackguard() }
-func stack4668() (uintptr, uintptr) { var buf [4668]byte; use(buf[:]); return Stackguard() }
-func stack4672() (uintptr, uintptr) { var buf [4672]byte; use(buf[:]); return Stackguard() }
-func stack4676() (uintptr, uintptr) { var buf [4676]byte; use(buf[:]); return Stackguard() }
-func stack4680() (uintptr, uintptr) { var buf [4680]byte; use(buf[:]); return Stackguard() }
-func stack4684() (uintptr, uintptr) { var buf [4684]byte; use(buf[:]); return Stackguard() }
-func stack4688() (uintptr, uintptr) { var buf [4688]byte; use(buf[:]); return Stackguard() }
-func stack4692() (uintptr, uintptr) { var buf [4692]byte; use(buf[:]); return Stackguard() }
-func stack4696() (uintptr, uintptr) { var buf [4696]byte; use(buf[:]); return Stackguard() }
-func stack4700() (uintptr, uintptr) { var buf [4700]byte; use(buf[:]); return Stackguard() }
-func stack4704() (uintptr, uintptr) { var buf [4704]byte; use(buf[:]); return Stackguard() }
-func stack4708() (uintptr, uintptr) { var buf [4708]byte; use(buf[:]); return Stackguard() }
-func stack4712() (uintptr, uintptr) { var buf [4712]byte; use(buf[:]); return Stackguard() }
-func stack4716() (uintptr, uintptr) { var buf [4716]byte; use(buf[:]); return Stackguard() }
-func stack4720() (uintptr, uintptr) { var buf [4720]byte; use(buf[:]); return Stackguard() }
-func stack4724() (uintptr, uintptr) { var buf [4724]byte; use(buf[:]); return Stackguard() }
-func stack4728() (uintptr, uintptr) { var buf [4728]byte; use(buf[:]); return Stackguard() }
-func stack4732() (uintptr, uintptr) { var buf [4732]byte; use(buf[:]); return Stackguard() }
-func stack4736() (uintptr, uintptr) { var buf [4736]byte; use(buf[:]); return Stackguard() }
-func stack4740() (uintptr, uintptr) { var buf [4740]byte; use(buf[:]); return Stackguard() }
-func stack4744() (uintptr, uintptr) { var buf [4744]byte; use(buf[:]); return Stackguard() }
-func stack4748() (uintptr, uintptr) { var buf [4748]byte; use(buf[:]); return Stackguard() }
-func stack4752() (uintptr, uintptr) { var buf [4752]byte; use(buf[:]); return Stackguard() }
-func stack4756() (uintptr, uintptr) { var buf [4756]byte; use(buf[:]); return Stackguard() }
-func stack4760() (uintptr, uintptr) { var buf [4760]byte; use(buf[:]); return Stackguard() }
-func stack4764() (uintptr, uintptr) { var buf [4764]byte; use(buf[:]); return Stackguard() }
-func stack4768() (uintptr, uintptr) { var buf [4768]byte; use(buf[:]); return Stackguard() }
-func stack4772() (uintptr, uintptr) { var buf [4772]byte; use(buf[:]); return Stackguard() }
-func stack4776() (uintptr, uintptr) { var buf [4776]byte; use(buf[:]); return Stackguard() }
-func stack4780() (uintptr, uintptr) { var buf [4780]byte; use(buf[:]); return Stackguard() }
-func stack4784() (uintptr, uintptr) { var buf [4784]byte; use(buf[:]); return Stackguard() }
-func stack4788() (uintptr, uintptr) { var buf [4788]byte; use(buf[:]); return Stackguard() }
-func stack4792() (uintptr, uintptr) { var buf [4792]byte; use(buf[:]); return Stackguard() }
-func stack4796() (uintptr, uintptr) { var buf [4796]byte; use(buf[:]); return Stackguard() }
-func stack4800() (uintptr, uintptr) { var buf [4800]byte; use(buf[:]); return Stackguard() }
-func stack4804() (uintptr, uintptr) { var buf [4804]byte; use(buf[:]); return Stackguard() }
-func stack4808() (uintptr, uintptr) { var buf [4808]byte; use(buf[:]); return Stackguard() }
-func stack4812() (uintptr, uintptr) { var buf [4812]byte; use(buf[:]); return Stackguard() }
-func stack4816() (uintptr, uintptr) { var buf [4816]byte; use(buf[:]); return Stackguard() }
-func stack4820() (uintptr, uintptr) { var buf [4820]byte; use(buf[:]); return Stackguard() }
-func stack4824() (uintptr, uintptr) { var buf [4824]byte; use(buf[:]); return Stackguard() }
-func stack4828() (uintptr, uintptr) { var buf [4828]byte; use(buf[:]); return Stackguard() }
-func stack4832() (uintptr, uintptr) { var buf [4832]byte; use(buf[:]); return Stackguard() }
-func stack4836() (uintptr, uintptr) { var buf [4836]byte; use(buf[:]); return Stackguard() }
-func stack4840() (uintptr, uintptr) { var buf [4840]byte; use(buf[:]); return Stackguard() }
-func stack4844() (uintptr, uintptr) { var buf [4844]byte; use(buf[:]); return Stackguard() }
-func stack4848() (uintptr, uintptr) { var buf [4848]byte; use(buf[:]); return Stackguard() }
-func stack4852() (uintptr, uintptr) { var buf [4852]byte; use(buf[:]); return Stackguard() }
-func stack4856() (uintptr, uintptr) { var buf [4856]byte; use(buf[:]); return Stackguard() }
-func stack4860() (uintptr, uintptr) { var buf [4860]byte; use(buf[:]); return Stackguard() }
-func stack4864() (uintptr, uintptr) { var buf [4864]byte; use(buf[:]); return Stackguard() }
-func stack4868() (uintptr, uintptr) { var buf [4868]byte; use(buf[:]); return Stackguard() }
-func stack4872() (uintptr, uintptr) { var buf [4872]byte; use(buf[:]); return Stackguard() }
-func stack4876() (uintptr, uintptr) { var buf [4876]byte; use(buf[:]); return Stackguard() }
-func stack4880() (uintptr, uintptr) { var buf [4880]byte; use(buf[:]); return Stackguard() }
-func stack4884() (uintptr, uintptr) { var buf [4884]byte; use(buf[:]); return Stackguard() }
-func stack4888() (uintptr, uintptr) { var buf [4888]byte; use(buf[:]); return Stackguard() }
-func stack4892() (uintptr, uintptr) { var buf [4892]byte; use(buf[:]); return Stackguard() }
-func stack4896() (uintptr, uintptr) { var buf [4896]byte; use(buf[:]); return Stackguard() }
-func stack4900() (uintptr, uintptr) { var buf [4900]byte; use(buf[:]); return Stackguard() }
-func stack4904() (uintptr, uintptr) { var buf [4904]byte; use(buf[:]); return Stackguard() }
-func stack4908() (uintptr, uintptr) { var buf [4908]byte; use(buf[:]); return Stackguard() }
-func stack4912() (uintptr, uintptr) { var buf [4912]byte; use(buf[:]); return Stackguard() }
-func stack4916() (uintptr, uintptr) { var buf [4916]byte; use(buf[:]); return Stackguard() }
-func stack4920() (uintptr, uintptr) { var buf [4920]byte; use(buf[:]); return Stackguard() }
-func stack4924() (uintptr, uintptr) { var buf [4924]byte; use(buf[:]); return Stackguard() }
-func stack4928() (uintptr, uintptr) { var buf [4928]byte; use(buf[:]); return Stackguard() }
-func stack4932() (uintptr, uintptr) { var buf [4932]byte; use(buf[:]); return Stackguard() }
-func stack4936() (uintptr, uintptr) { var buf [4936]byte; use(buf[:]); return Stackguard() }
-func stack4940() (uintptr, uintptr) { var buf [4940]byte; use(buf[:]); return Stackguard() }
-func stack4944() (uintptr, uintptr) { var buf [4944]byte; use(buf[:]); return Stackguard() }
-func stack4948() (uintptr, uintptr) { var buf [4948]byte; use(buf[:]); return Stackguard() }
-func stack4952() (uintptr, uintptr) { var buf [4952]byte; use(buf[:]); return Stackguard() }
-func stack4956() (uintptr, uintptr) { var buf [4956]byte; use(buf[:]); return Stackguard() }
-func stack4960() (uintptr, uintptr) { var buf [4960]byte; use(buf[:]); return Stackguard() }
-func stack4964() (uintptr, uintptr) { var buf [4964]byte; use(buf[:]); return Stackguard() }
-func stack4968() (uintptr, uintptr) { var buf [4968]byte; use(buf[:]); return Stackguard() }
-func stack4972() (uintptr, uintptr) { var buf [4972]byte; use(buf[:]); return Stackguard() }
-func stack4976() (uintptr, uintptr) { var buf [4976]byte; use(buf[:]); return Stackguard() }
-func stack4980() (uintptr, uintptr) { var buf [4980]byte; use(buf[:]); return Stackguard() }
-func stack4984() (uintptr, uintptr) { var buf [4984]byte; use(buf[:]); return Stackguard() }
-func stack4988() (uintptr, uintptr) { var buf [4988]byte; use(buf[:]); return Stackguard() }
-func stack4992() (uintptr, uintptr) { var buf [4992]byte; use(buf[:]); return Stackguard() }
-func stack4996() (uintptr, uintptr) { var buf [4996]byte; use(buf[:]); return Stackguard() }
-func stack5000() (uintptr, uintptr) { var buf [5000]byte; use(buf[:]); return Stackguard() }
diff --git a/src/runtime/stack_test.go b/src/runtime/stack_test.go
index 7b9412af42..cd525a3fc5 100644
--- a/src/runtime/stack_test.go
+++ b/src/runtime/stack_test.go
@@ -10,62 +10,8 @@ import (
 	"sync"
 	"testing"
 	"time"
-	"unsafe"
 )
 
-// See stack.h.
-const (
-	StackGuard = 256
-	StackSmall = 64
-	StackLimit = StackGuard - StackSmall
-)
-
-// Test stack split logic by calling functions of every frame size
-// from near 0 up to and beyond the default segment size (4k).
-// Each of those functions reports its SP + stack limit, and then
-// the test (the caller) checks that those make sense.  By not
-// doing the actual checking and reporting from the suspect functions,
-// we minimize the possibility of crashes during the test itself.
-//
-// Exhaustive test for http://golang.org/issue/3310.
-// The linker used to get a few sizes near the segment size wrong:
-//
-// --- FAIL: TestStackSplit (0.01 seconds)
-// 	stack_test.go:22: after runtime_test.stack3812: sp=0x7f7818d5d078 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3816: sp=0x7f7818d5d078 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3820: sp=0x7f7818d5d070 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3824: sp=0x7f7818d5d070 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3828: sp=0x7f7818d5d068 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3832: sp=0x7f7818d5d068 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3836: sp=0x7f7818d5d060 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3840: sp=0x7f7818d5d060 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3844: sp=0x7f7818d5d058 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3848: sp=0x7f7818d5d058 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3852: sp=0x7f7818d5d050 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3856: sp=0x7f7818d5d050 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3860: sp=0x7f7818d5d048 < limit=0x7f7818d5d080
-// 	stack_test.go:22: after runtime_test.stack3864: sp=0x7f7818d5d048 < limit=0x7f7818d5d080
-// FAIL
-func TestStackSplit(t *testing.T) {
-	for _, f := range splitTests {
-		sp, guard := f()
-		bottom := guard - StackGuard
-		if sp < bottom+StackLimit {
-			fun := FuncForPC(**(**uintptr)(unsafe.Pointer(&f)))
-			t.Errorf("after %s: sp=%#x < limit=%#x (guard=%#x, bottom=%#x)",
-				fun.Name(), sp, bottom+StackLimit, guard, bottom)
-		}
-	}
-}
-
-var Used byte
-
-func use(buf []byte) {
-	for _, c := range buf {
-		Used += c
-	}
-}
-
 // TestStackMem measures per-thread stack segment cache behavior.
 // The test consumed up to 500MB in the past.
 func TestStackMem(t *testing.T) {
diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index f8ea1092e9..f3af34a584 100644
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -219,7 +219,6 @@ const _NoArgs = ^uintptr(0)
 
 func newstack()
 func newproc()
-func lessstack()
 func morestack()
 func mstart()
 func rt0_go()
diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index c1a019296f..ca3b862102 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -34,7 +34,6 @@ var (
 	deferprocPC = funcPC(deferproc)
 	goexitPC    = funcPC(goexit)
 	jmpdeferPC  = funcPC(jmpdefer)
-	lessstackPC = funcPC(lessstack)
 	mcallPC     = funcPC(mcall)
 	morestackPC = funcPC(morestack)
 	mstartPC    = funcPC(mstart)
@@ -57,7 +56,7 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 	g := getg()
 	gotraceback := gotraceback(nil)
 	if pc0 == ^uintptr(0) && sp0 == ^uintptr(0) { // Signal to fetch saved values from gp.
-		if gp.syscallstack != 0 {
+		if gp.syscallsp != 0 {
 			pc0 = gp.syscallpc
 			sp0 = gp.syscallsp
 			if usesLR {
@@ -115,7 +114,6 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 	frame.fn = f
 
 	n := 0
-	stk := (*stktop)(unsafe.Pointer(gp.stackbase))
 	for n < max {
 		// Typically:
 		//	pc is the PC of the running function.
@@ -123,39 +121,8 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 		//	fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown.
 		//	stk is the stack containing sp.
 		//	The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp.
-		if frame.pc == lessstackPC {
-			// Hit top of stack segment.  Unwind to next segment.
-			frame.pc = stk.gobuf.pc
-			frame.sp = stk.gobuf.sp
-			frame.lr = 0
-			frame.fp = 0
-			if printing && showframe(nil, gp) {
-				print("----- stack segment boundary -----\n")
-			}
-			stk = (*stktop)(unsafe.Pointer(stk.stackbase))
-			f = findfunc(frame.pc)
-			if f == nil {
-				print("runtime: unknown pc ", hex(frame.pc), " after stack split\n")
-				if callback != nil {
-					gothrow("unknown pc")
-				}
-			}
-			frame.fn = f
-			continue
-		}
 		f = frame.fn
 
-		// Hook for handling Windows exception handlers. See traceback_windows.go.
-		if systraceback != nil {
-			changed, aborted := systraceback(f, (*stkframe)(noescape(unsafe.Pointer(&frame))), gp, printing, callback, v)
-			if aborted {
-				return n
-			}
-			if changed {
-				continue
-			}
-		}
-
 		// Found an actual function.
 		// Derive frame pointer and link register.
 		if frame.fp == 0 {
@@ -224,8 +191,6 @@ func gentraceback(pc0 uintptr, sp0 uintptr, lr0 uintptr, gp *g, skip int, pcbuf
 				frame.arglen = uintptr(f.args)
 			} else if flr == nil {
 				frame.arglen = 0
-			} else if frame.lr == lessstackPC {
-				frame.arglen = uintptr(stk.argsize)
 			} else {
 				i := funcarglen(flr, frame.lr)
 				if i >= 0 {
@@ -617,7 +582,6 @@ func topofstack(f *_func) bool {
 		pc == mstartPC ||
 		pc == mcallPC ||
 		pc == morestackPC ||
-		pc == lessstackPC ||
 		pc == rt0_goPC ||
 		externalthreadhandlerp != 0 && pc == externalthreadhandlerp
 }
diff --git a/src/runtime/traceback_windows.go b/src/runtime/traceback_windows.go
deleted file mode 100644
index 89dc1336e3..0000000000
--- a/src/runtime/traceback_windows.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-
-import "unsafe"
-
-// sigtrampPC is the PC at the beginning of the jmpdefer assembly function.
-// The traceback needs to recognize it on link register architectures.
-var sigtrampPC uintptr
-
-func sigtramp()
-
-func init() {
-	sigtrampPC = funcPC(sigtramp)
-	systraceback = traceback_windows
-}
-
-func traceback_windows(f *_func, frame *stkframe, gp *g, printing bool, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer) (changed, aborted bool) {
-	// The main traceback thinks it has found a function. Check this.
-
-	// Windows exception handlers run on the actual g stack (there is room
-	// dedicated to this below the usual "bottom of stack"), not on a separate
-	// stack. As a result, we have to be able to unwind past the exception
-	// handler when called to unwind during stack growth inside the handler.
-	// Recognize the frame at the call to sighandler in sigtramp and unwind
-	// using the context argument passed to the call. This is awful.
-	if f != nil && f.entry == sigtrampPC && frame.pc > f.entry {
-		var r *context
-		// Invoke callback so that stack copier sees an uncopyable frame.
-		if callback != nil {
-			frame.continpc = frame.pc
-			frame.argp = 0
-			frame.arglen = 0
-			if !callback(frame, v) {
-				aborted = true
-				return
-			}
-		}
-		r = (*context)(unsafe.Pointer(frame.sp + ptrSize))
-		frame.pc = contextPC(r)
-		frame.sp = contextSP(r)
-		frame.lr = 0
-		frame.fp = 0
-		frame.fn = nil
-		if printing && showframe(nil, gp) {
-			print("----- exception handler -----\n")
-		}
-		f = findfunc(frame.pc)
-		if f == nil {
-			print("runtime: unknown pc ", hex(frame.pc), " after exception handler\n")
-			if callback != nil {
-				gothrow("unknown pc")
-			}
-		}
-		frame.fn = f
-		changed = true
-		return
-	}
-
-	return
-}