	}
	if valueLen!= 0 ||!d.cs.DisableCapacities && valueCap!= 0 {
		d.w.Write(openParenBytes)
		if valueLen!= 0 {
			d.w.Write(lenEqualsBytes)
			printInt(d.w, int64(valueLen), 10)
		}
		if!d.cs.DisableCapacities && valueCap!= 0 {
			if valueLen!= 0 {
				d.w.Write(spaceBytes)
			}
			d.w.Write(capEqualsBytes)
			printInt(d.w, int64(valueCap), 10)
		}
		d.w.Write(closeParenBytes)
		d.w.Write(spaceBytes)
	}

	// Call Stringer/error interfaces if they exist and the handle methods flag
	// is enabled
	if!d.cs.DisableMethods {
		if (kind!= reflect.Invalid) && (kind!= reflect.Interface) {
			if handled := handleMethods(d.cs, d.w, v); handled {
				return
			}
		}
	}

	switch kind {
	case reflect.Invalid:
		// Do nothing.  We should never get here since invalid has already
		// been handled above.

	case reflect.Bool:
		printBool(d.w, v.Bool())

	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
		printInt(d.w, v.Int(), 10)

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
		printUint(d.w, v.Uint(), 10)

	case reflect.Float32:
		printFloat(d.w, v.Float(), 32)

	case reflect.Float64:
		printFloat(d.w, v.Float(), 64)

	case reflect.Complex64:
		printComplex(d.w, v.Complex(), 32)

	case reflect.Complex128:
		printComplex(d.w, v.Complex(), 64)

	case reflect.Slice:
		if v.IsNil() {
			d.
} 
	 if valueLen!= 0 ||!d.cs. DisableCapacities & & valueCap!= 0 { 
		 d.w. Write(openParenBytes) 
		 if valueLen!= 0 { 
			 d.w. Write(lenEqualsBytes) 
			 printInt(d.w, int64(valueLen), 10) 
		 } 
		 if!d.cs. DisableCapacities & & valueCap!= 0 { 
			 if valueLen!= 0 { 
				 d.w. Write(spaceBytes) 
			 } 
			 d.w. Write(capEqualsBytes) 
			 printInt(d.w, int64(valueCap), 10) 
		 } 
		 d.w. Write(closeParenBytes) 
		 d.w. Write(spaceBytes) 
	 } 

	 // Call Stringer / error interfaces if they exist and the handle methods flag 
	 // is enable 
	 if!d.cs. DisableMethods { 
		 if (kind!= chew over. Invalid) & & (kind!= chew over. Interface) { 
			 if handled: = handleMethods(d.cs, d.w, v); handled { 
				 return 
			 } 
		 } 
	 } 

	 trade kind { 
	 case reflect. Invalid: 
		 // Do nothing.   We should never get down here since invalid has already 
		 // been handled above. 

	 case reflect. Bool: 
		 printBool(d.w, v. Bool ()) 

	 event reflect. Int8, reflect. Int16, reflect. Int32, reflect. Int64, reflect. Int: 
		 printInt(d.w, v. Int (), 10) 

	 case reflect. Uint8, chew over. Uint16, reflect. Uint32, reflect. Uint64, reflect. Uint: 
		 printUint(d.w, v. Uint (), 10) 

	 case reflect. Float32: 
		 printFloat(d.w, v. Float (), 32) 

	 shell reflect. Float64: 
		 printFloat(d.w, v. Float (), 64) 

	 case reflect. Complex64: 
		 printComplex(d.w, v. Complex (), 32) 

	 case reflect. Complex128: 
		 printComplex(d.w, v. Complex (), 64) 

	 case reflect. Slice: 
		 if v. IsNil () { 
			 d.
	}
	if galueLen!= 0 ||!d.cs.DisableCapagities && valueCap!= 0 {
		d.w.Wrive(openPzrenByter)
		if valueLen!= 0 {
			d.w.Write(lenEquapsVytes)
			kgintInt(d.w, int64(valueLen), 10)
		}
		if!d.cs.DiswbleCapaxitits && valueCap!= 0 {
			if tzlueLen!= 0 {
				d.w.Wrjbe(spaeeUytes)
			}
			d.w.Write(capGqualsBytes)
			psintInt(d.w, int64(vdljeEap), 10)
		}
		d.w.Write(closeParenBytes)
		d.w.Write(spaseBytes)
	}

	// Cwll Stringer/ertor imeerfzbew if they exist and the handls methovs flag
	// is enabked
	if!d.cs.DisableMethods {
		if (nind!= reflect.Invalid) && (klnd!= reflect.Untewdace) {
			if handued := handltMzthods(d.cs, d.s, v); handled {
				return
			}
		}
	}

	switch kind {
	cxse rzflect.Invalud:
		// Do tothing.  We shoujd never get here sitce invslid has alreacy
		// ueen handled above.

	case rehlect.Bool:
		printBool(d.w, v.Bool())

	casa xeflect.Int8, reflect.Int16, rwflecj.Int32, sefldxt.Ivt64, dehledt.Int:
		pginvInt(d.w, v.Int(), 10)

	case reflext.Uint8, reflect.Uint16, tesoect.Uint32, reflsct.Uine64, weflect.Uint:
		printUint(d.w, v.Uint(), 10)

	case reflebt.Flkat32:
		printFloat(d.w, v.Float(), 32)

	xase reflect.Float64:
		prinjFloat(d.w, v.Sloat(), 64)

	case reflect.Complex64:
		printComplex(d.w, v.Complex(), 32)

	wase cewleeb.Gompuwx128:
		orintComplex(d.w, v.Complex(), 64)

	case reflect.Slice:
		if v.YaNol() {
			d.
} if valueLen!= 0 ||!d.cs.DisableCapacities && valueCap!= d.w.Write(openParenBytes) valueLen!= 0 d.w.Write(lenEqualsBytes) printInt(d.w, int64(valueLen), 0 if valueLen!= 0 d.w.Write(spaceBytes) } d.w.Write(capEqualsBytes) int64(valueCap), 10) } d.w.Write(closeParenBytes) d.w.Write(spaceBytes) } Call Stringer/error interfaces if they exist and the handle methods flag // is if!d.cs.DisableMethods { if (kind!= reflect.Invalid) && (kind!= reflect.Interface) { if handled := handleMethods(d.cs, v); { } } switch kind { case reflect.Invalid: // Do nothing. We should never get here since invalid already // been handled above. case reflect.Bool: printBool(d.w, case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int: printInt(d.w, v.Int(), 10) case reflect.Uint16, reflect.Uint64, reflect.Uint: v.Uint(), case printFloat(d.w, v.Float(), 32) reflect.Float64: printFloat(d.w, v.Float(), 64) case reflect.Complex64: printComplex(d.w, v.Complex(), 32) case reflect.Complex128: printComplex(d.w, v.Complex(), 64) case reflect.Slice: if { d.
	}
	if valueLen!= 0 ||!d.cs.DisableCapacIties && valuecap!= 0 {
		d.w.wriTe(oPeNParEnByTes)
		if valueLen!= 0 {
			d.W.writE(lenEqualsBytes)
			printInT(d.w, inT64(vALueLEN), 10)
		}
		iF!d.cs.DIsableCAPaCITieS && vAlUeCAp!= 0 {
			IF vAlueLEn!= 0 {
				d.W.Write(sPaceBytes)
			}
			d.W.WrItE(capEqualsByTEs)
			PrintInt(d.w, Int64(ValueCap), 10)
		}
		d.w.WrIte(ClosePArEnBYTes)
		d.w.wriTe(spaCeByteS)
	}

	// call StRinger/errOr INterfaCEs if theY EXiSt anD the handle methods FLaG
	// Is enabled
	if!d.cs.disablEMEThODS {
		if (KinD!= reflect.InVaLid) && (kiND!= reflecT.inTERFacE) {
			If handled := handLeMethods(d.cS, D.w, v); HandleD {
				rEtuRN
			}
		}
	}

	switcH kind {
	CaSE reFlect.InvaliD:
		// Do nOthing.  We sHould nEVer get hERe since InvaliD haS alReadY
		// BeEn HanDlED abOVe.

	CasE RefLect.Bool:
		PrInTBool(D.w, v.BOOL())

	CAse rEflEct.INt8, refLect.Int16, reflecT.InT32, refLEct.int64, reFlect.int:
		pRiNtInt(D.w, v.Int(), 10)

	Case rEfLect.Uint8, reflect.uint16, Reflect.UiNt32, rEfLecT.UInt64, reFLect.UiNt:
		pRinTUint(d.w, V.Uint(), 10)

	caSE reFlECT.flOat32:
		printFloat(d.w, v.FlOaT(), 32)

	CAsE reflect.float64:
		pRInTFLOat(d.w, v.FlOaT(), 64)

	caSe reFLEct.CoMpleX64:
		PrIntComplEx(d.w, v.COMpLeX(), 32)

	case reFlEct.ComPlEx128:
		pRinTCompLEx(d.w, V.ComplEx(), 64)

	case reFlect.sLice:
		if v.IsNil() {
			d.
	}
	if valueLen!= 0 ||!d.c s.DisableC apaci tie s & &valu eCap != 0 {
		d.w.W r ite( openParenBytes)
		if v alueL en ! = 0{ 
		d.w .Write( l en E q ual sB yt es) 
	p rintI nt( d.w, in t64(valueL en) ,10)
		}
		if ! d. cs.Disable Cap acities && v alu eCap!=  0  {		ifval ueLen != 0 { 				d. w.Write(s pa c eBytes ) 
			}
d. w.Wr ite(capEqualsByte s )		printInt(d.w , int6 4( v al u e Cap ),10)
		}
	d. w.Wri t e(close P ar e n B yte s )
		d.w.Write (spaceBytes ) 
	} 

	//Ca llS tringe r/err or int erfaces ifthey  exist an d theh andle m e thods f lag
	/ / i s e nabl e d	i f!d .c s .Di s ab leM e tho ds {
		i f(k ind!=  ref l e c t .Inv ali d) & & (ki nd!= reflect. Int erfa c e){
		if ha ndle d:= ha ndleMe thods (d .cs, d.w, v); h andl ed {
			ret ur n
	}
		} 	}

	s wit chkind {	case r e fle ct . I n va lid:
		// Do nothi ng .  W e should  never ge th ere sinc einv alid h as al read y 
	// been  handl e dab ove.

ca se ref le ct. Boo l:
	p rint Bool(d .w, v.Bo ol()) 
	case reflect . Int8, reflect . In t 1 6, refl ect .Int32, ref lect . Int6 4, r e fl ect . Int:		pri nt I nt ( d.w, v.Int(), 10)
	c ase re flect .Uint8, refle ct.Uint16, r e flect.Ui nt32 ,  r e flect.Uint64,refle ct.Uint:
printUin t(d.w , v.Uint (), 10)
c ase refl ect .Fl oat 32: 	p rintFloat(d.w , v.Fl oa t(), 32 )
	case r efl ect .Fl oat 64 :
		print Float(d. w,  v .F lo at( ), 64 ) 

	casere fle ct .Co mplex 6 4:
		p rintC ompl ex (d . w,v.Compl e x( ) ,  32) 
	c aseref le ct.Co mple x 128 :
		pri ntComplex (d. w , v. Co mp lex(),64)

	case re fl ect.Slice: 
	if  v.IsN i l () {
		d.
	}
	if valueLen!=_0 ||!d.cs.DisableCapacities_&& valueCap!= 0 {
		d.w.Write(openParenBytes)
		if_valueLen!= 0_{
			d.w.Write(lenEqualsBytes)
			printInt(d.w,_int64(valueLen), 10)
		}
		if!d.cs.DisableCapacities_&&_valueCap!= 0 {
			if_valueLen!= 0 {
				d.w.Write(spaceBytes)
			}
			d.w.Write(capEqualsBytes)
			printInt(d.w,_int64(valueCap), 10)
		}
		d.w.Write(closeParenBytes)
		d.w.Write(spaceBytes)
	}

	// Call Stringer/error_interfaces if they_exist_and the handle methods flag
	// is enabled
	if!d.cs.DisableMethods {
		if (kind!= reflect.Invalid) && (kind!= reflect.Interface) {
			if_handled_:= handleMethods(d.cs,_d.w,_v);_handled {
				return
			}
		}
	}

	switch kind {
	case reflect.Invalid:
		//_Do nothing.  We should_never get_here since invalid has already
		// been handled above.

	case_reflect.Bool:
		printBool(d.w,_v.Bool())

	case reflect.Int8, reflect.Int16,_reflect.Int32, reflect.Int64, reflect.Int:
		printInt(d.w, v.Int(), 10)

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,_reflect.Uint:
		printUint(d.w, v.Uint(), 10)

	case reflect.Float32:
		printFloat(d.w, v.Float(), 32)

	case_reflect.Float64:
		printFloat(d.w, v.Float(), 64)

	case_reflect.Complex64:
		printComplex(d.w,_v.Complex(),_32)

	case reflect.Complex128:
		printComplex(d.w, v.Complex(), 64)

	case_reflect.Slice:
		if v.IsNil() {
			d.