// Code generated by "httpsnoop/codegen"; DO NOT EDIT.

package httpsnoop

import (
	"bufio"
	"io"
	"net"
	"net/http"
	"time"
)

// HeaderFunc is part of the http.ResponseWriter interface.
type HeaderFunc func() http.Header

// WriteHeaderFunc is part of the http.ResponseWriter interface.
type WriteHeaderFunc func(code int)

// WriteFunc is part of the http.ResponseWriter interface.
type WriteFunc func(b []byte) (int, error)

// FlushFunc is part of the http.Flusher interface.
type FlushFunc func()

// FlushErrorFunc is part of the httpFlushError interface.
type FlushErrorFunc func() error

// CloseNotifyFunc is part of the http.CloseNotifier interface.
type CloseNotifyFunc func() <-chan bool

// HijackFunc is part of the http.Hijacker interface.
type HijackFunc func() (net.Conn, *bufio.ReadWriter, error)

// ReadFromFunc is part of the io.ReaderFrom interface.
type ReadFromFunc func(src io.Reader) (int64, error)

// SetReadDeadlineFunc is part of the deadliner interface.
type SetReadDeadlineFunc func(deadline time.Time) error

// SetWriteDeadlineFunc is part of the deadliner interface.
type SetWriteDeadlineFunc func(deadline time.Time) error

// EnableFullDuplexFunc is part of the fullDuplexEnabler interface.
type EnableFullDuplexFunc func() error

// PushFunc is part of the http.Pusher interface.
type PushFunc func(target string, opts *http.PushOptions) error

// WriteStringFunc is part of the io.StringWriter interface.
type WriteStringFunc func(s string) (int, error)

// Hooks defines a set of method interceptors for methods included in
// http.ResponseWriter as well as some others. You can think of them as
// middleware for the function calls they target. See Wrap for more details.
//
// For each method, the exact matching hook takes precedence. For example,
// WriteString calls the WriteString hook when it is configured, even if a
// Write hook is also configured. If the exact hook is not configured, most
// methods call through to the underlying ResponseWriter directly.
//
// Two compatibility fallbacks preserve the behavior users had before Wrap
// learned about newer optional interfaces:
//   - If the underlying ResponseWriter implements io.StringWriter and
//     WriteString is called, but only the Write hook is configured, WriteString
//     is routed through the Write hook with []byte(s). If neither hook is
//     configured, WriteString calls the underlying WriteString method directly.
//   - If the underlying ResponseWriter implements both http.Flusher and
//     FlushError, and FlushError is called, but only the Flush hook is
//     configured, FlushError is routed through the Flush hook while preserving
//     the error returned by the underlying FlushError method. If neither hook is
//     configured, FlushError calls the underlying FlushError method directly.
type Hooks struct {
	Header           func(HeaderFunc) HeaderFunc
	WriteHeader      func(WriteHeaderFunc) WriteHeaderFunc
	Write            func(WriteFunc) WriteFunc
	Flush            func(FlushFunc) FlushFunc
	FlushError       func(FlushErrorFunc) FlushErrorFunc
	CloseNotify      func(CloseNotifyFunc) CloseNotifyFunc
	Hijack           func(HijackFunc) HijackFunc
	ReadFrom         func(ReadFromFunc) ReadFromFunc
	SetReadDeadline  func(SetReadDeadlineFunc) SetReadDeadlineFunc
	SetWriteDeadline func(SetWriteDeadlineFunc) SetWriteDeadlineFunc
	EnableFullDuplex func(EnableFullDuplexFunc) EnableFullDuplexFunc
	Push             func(PushFunc) PushFunc
	WriteString      func(WriteStringFunc) WriteStringFunc
}

// Wrap returns a wrapped version of w that provides the exact same interface
// as w. Specifically if w implements any combination of:
//
// - http.Flusher
// - httpFlushError
// - http.CloseNotifier
// - http.Hijacker
// - io.ReaderFrom
// - deadliner
// - fullDuplexEnabler
// - http.Pusher
// - io.StringWriter
//
// The wrapped version will implement the exact same combination. If no hooks
// are set, the wrapped version also behaves exactly as w. Hooks targeting
// methods not supported by w are ignored. Any other hooks will intercept the
// method they target and may modify the call's arguments and/or return values.
// The CaptureMetrics implementation serves as a working example for how the
// hooks can be used.
func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
	state := &rwState{w: w}
	var combo uint16
	if hooks.Header != nil {
		state.header = hooks.Header(w.Header)
	}
	if hooks.WriteHeader != nil {
		state.writeHeader = hooks.WriteHeader(w.WriteHeader)
	}
	if hooks.Write != nil {
		state.write = hooks.Write(w.Write)
	}
	if t0, i0 := w.(http.Flusher); i0 {
		combo |= 1 << 8
		if hooks.Flush != nil {
			state.flush = hooks.Flush(t0.Flush)
		}
	}
	if t1, i1 := w.(httpFlushError); i1 {
		combo |= 1 << 7
		if hooks.FlushError != nil {
			state.flushError = hooks.FlushError(t1.FlushError)
		} else if state.flush != nil {
			state.flushError = func() (err error) { hooks.Flush(func() { err = t1.FlushError() })(); return err }
		}
	}
	if t2, i2 := w.(http.CloseNotifier); i2 {
		combo |= 1 << 6
		if hooks.CloseNotify != nil {
			state.closeNotify = hooks.CloseNotify(t2.CloseNotify)
		}
	}
	if t3, i3 := w.(http.Hijacker); i3 {
		combo |= 1 << 5
		if hooks.Hijack != nil {
			state.hijack = hooks.Hijack(t3.Hijack)
		}
	}
	if t4, i4 := w.(io.ReaderFrom); i4 {
		combo |= 1 << 4
		if hooks.ReadFrom != nil {
			state.readFrom = hooks.ReadFrom(t4.ReadFrom)
		}
	}
	if t5, i5 := w.(deadliner); i5 {
		combo |= 1 << 3
		if hooks.SetReadDeadline != nil {
			state.setReadDeadline = hooks.SetReadDeadline(t5.SetReadDeadline)
		}
		if hooks.SetWriteDeadline != nil {
			state.setWriteDeadline = hooks.SetWriteDeadline(t5.SetWriteDeadline)
		}
	}
	if t6, i6 := w.(fullDuplexEnabler); i6 {
		combo |= 1 << 2
		if hooks.EnableFullDuplex != nil {
			state.enableFullDuplex = hooks.EnableFullDuplex(t6.EnableFullDuplex)
		}
	}
	if t7, i7 := w.(http.Pusher); i7 {
		combo |= 1 << 1
		if hooks.Push != nil {
			state.push = hooks.Push(t7.Push)
		}
	}
	if t8, i8 := w.(io.StringWriter); i8 {
		combo |= 1 << 0
		if hooks.WriteString != nil {
			state.writeString = hooks.WriteString(t8.WriteString)
		} else if state.write != nil {
			state.writeString = func(s string) (int, error) { return state.write([]byte(s)) }
		}
	}
	switch combo {
	case 0:
		return (*rw0)(state)
	case 1:
		return (*rw1)(state)
	case 2:
		return (*rw2)(state)
	case 3:
		return (*rw3)(state)
	case 4:
		return (*rw4)(state)
	case 5:
		return (*rw5)(state)
	case 6:
		return (*rw6)(state)
	case 7:
		return (*rw7)(state)
	case 8:
		return (*rw8)(state)
	case 9:
		return (*rw9)(state)
	case 10:
		return (*rw10)(state)
	case 11:
		return (*rw11)(state)
	case 12:
		return (*rw12)(state)
	case 13:
		return (*rw13)(state)
	case 14:
		return (*rw14)(state)
	case 15:
		return (*rw15)(state)
	case 16:
		return (*rw16)(state)
	case 17:
		return (*rw17)(state)
	case 18:
		return (*rw18)(state)
	case 19:
		return (*rw19)(state)
	case 20:
		return (*rw20)(state)
	case 21:
		return (*rw21)(state)
	case 22:
		return (*rw22)(state)
	case 23:
		return (*rw23)(state)
	case 24:
		return (*rw24)(state)
	case 25:
		return (*rw25)(state)
	case 26:
		return (*rw26)(state)
	case 27:
		return (*rw27)(state)
	case 28:
		return (*rw28)(state)
	case 29:
		return (*rw29)(state)
	case 30:
		return (*rw30)(state)
	case 31:
		return (*rw31)(state)
	case 32:
		return (*rw32)(state)
	case 33:
		return (*rw33)(state)
	case 34:
		return (*rw34)(state)
	case 35:
		return (*rw35)(state)
	case 36:
		return (*rw36)(state)
	case 37:
		return (*rw37)(state)
	case 38:
		return (*rw38)(state)
	case 39:
		return (*rw39)(state)
	case 40:
		return (*rw40)(state)
	case 41:
		return (*rw41)(state)
	case 42:
		return (*rw42)(state)
	case 43:
		return (*rw43)(state)
	case 44:
		return (*rw44)(state)
	case 45:
		return (*rw45)(state)
	case 46:
		return (*rw46)(state)
	case 47:
		return (*rw47)(state)
	case 48:
		return (*rw48)(state)
	case 49:
		return (*rw49)(state)
	case 50:
		return (*rw50)(state)
	case 51:
		return (*rw51)(state)
	case 52:
		return (*rw52)(state)
	case 53:
		return (*rw53)(state)
	case 54:
		return (*rw54)(state)
	case 55:
		return (*rw55)(state)
	case 56:
		return (*rw56)(state)
	case 57:
		return (*rw57)(state)
	case 58:
		return (*rw58)(state)
	case 59:
		return (*rw59)(state)
	case 60:
		return (*rw60)(state)
	case 61:
		return (*rw61)(state)
	case 62:
		return (*rw62)(state)
	case 63:
		return (*rw63)(state)
	case 64:
		return (*rw64)(state)
	case 65:
		return (*rw65)(state)
	case 66:
		return (*rw66)(state)
	case 67:
		return (*rw67)(state)
	case 68:
		return (*rw68)(state)
	case 69:
		return (*rw69)(state)
	case 70:
		return (*rw70)(state)
	case 71:
		return (*rw71)(state)
	case 72:
		return (*rw72)(state)
	case 73:
		return (*rw73)(state)
	case 74:
		return (*rw74)(state)
	case 75:
		return (*rw75)(state)
	case 76:
		return (*rw76)(state)
	case 77:
		return (*rw77)(state)
	case 78:
		return (*rw78)(state)
	case 79:
		return (*rw79)(state)
	case 80:
		return (*rw80)(state)
	case 81:
		return (*rw81)(state)
	case 82:
		return (*rw82)(state)
	case 83:
		return (*rw83)(state)
	case 84:
		return (*rw84)(state)
	case 85:
		return (*rw85)(state)
	case 86:
		return (*rw86)(state)
	case 87:
		return (*rw87)(state)
	case 88:
		return (*rw88)(state)
	case 89:
		return (*rw89)(state)
	case 90:
		return (*rw90)(state)
	case 91:
		return (*rw91)(state)
	case 92:
		return (*rw92)(state)
	case 93:
		return (*rw93)(state)
	case 94:
		return (*rw94)(state)
	case 95:
		return (*rw95)(state)
	case 96:
		return (*rw96)(state)
	case 97:
		return (*rw97)(state)
	case 98:
		return (*rw98)(state)
	case 99:
		return (*rw99)(state)
	case 100:
		return (*rw100)(state)
	case 101:
		return (*rw101)(state)
	case 102:
		return (*rw102)(state)
	case 103:
		return (*rw103)(state)
	case 104:
		return (*rw104)(state)
	case 105:
		return (*rw105)(state)
	case 106:
		return (*rw106)(state)
	case 107:
		return (*rw107)(state)
	case 108:
		return (*rw108)(state)
	case 109:
		return (*rw109)(state)
	case 110:
		return (*rw110)(state)
	case 111:
		return (*rw111)(state)
	case 112:
		return (*rw112)(state)
	case 113:
		return (*rw113)(state)
	case 114:
		return (*rw114)(state)
	case 115:
		return (*rw115)(state)
	case 116:
		return (*rw116)(state)
	case 117:
		return (*rw117)(state)
	case 118:
		return (*rw118)(state)
	case 119:
		return (*rw119)(state)
	case 120:
		return (*rw120)(state)
	case 121:
		return (*rw121)(state)
	case 122:
		return (*rw122)(state)
	case 123:
		return (*rw123)(state)
	case 124:
		return (*rw124)(state)
	case 125:
		return (*rw125)(state)
	case 126:
		return (*rw126)(state)
	case 127:
		return (*rw127)(state)
	case 128:
		return (*rw128)(state)
	case 129:
		return (*rw129)(state)
	case 130:
		return (*rw130)(state)
	case 131:
		return (*rw131)(state)
	case 132:
		return (*rw132)(state)
	case 133:
		return (*rw133)(state)
	case 134:
		return (*rw134)(state)
	case 135:
		return (*rw135)(state)
	case 136:
		return (*rw136)(state)
	case 137:
		return (*rw137)(state)
	case 138:
		return (*rw138)(state)
	case 139:
		return (*rw139)(state)
	case 140:
		return (*rw140)(state)
	case 141:
		return (*rw141)(state)
	case 142:
		return (*rw142)(state)
	case 143:
		return (*rw143)(state)
	case 144:
		return (*rw144)(state)
	case 145:
		return (*rw145)(state)
	case 146:
		return (*rw146)(state)
	case 147:
		return (*rw147)(state)
	case 148:
		return (*rw148)(state)
	case 149:
		return (*rw149)(state)
	case 150:
		return (*rw150)(state)
	case 151:
		return (*rw151)(state)
	case 152:
		return (*rw152)(state)
	case 153:
		return (*rw153)(state)
	case 154:
		return (*rw154)(state)
	case 155:
		return (*rw155)(state)
	case 156:
		return (*rw156)(state)
	case 157:
		return (*rw157)(state)
	case 158:
		return (*rw158)(state)
	case 159:
		return (*rw159)(state)
	case 160:
		return (*rw160)(state)
	case 161:
		return (*rw161)(state)
	case 162:
		return (*rw162)(state)
	case 163:
		return (*rw163)(state)
	case 164:
		return (*rw164)(state)
	case 165:
		return (*rw165)(state)
	case 166:
		return (*rw166)(state)
	case 167:
		return (*rw167)(state)
	case 168:
		return (*rw168)(state)
	case 169:
		return (*rw169)(state)
	case 170:
		return (*rw170)(state)
	case 171:
		return (*rw171)(state)
	case 172:
		return (*rw172)(state)
	case 173:
		return (*rw173)(state)
	case 174:
		return (*rw174)(state)
	case 175:
		return (*rw175)(state)
	case 176:
		return (*rw176)(state)
	case 177:
		return (*rw177)(state)
	case 178:
		return (*rw178)(state)
	case 179:
		return (*rw179)(state)
	case 180:
		return (*rw180)(state)
	case 181:
		return (*rw181)(state)
	case 182:
		return (*rw182)(state)
	case 183:
		return (*rw183)(state)
	case 184:
		return (*rw184)(state)
	case 185:
		return (*rw185)(state)
	case 186:
		return (*rw186)(state)
	case 187:
		return (*rw187)(state)
	case 188:
		return (*rw188)(state)
	case 189:
		return (*rw189)(state)
	case 190:
		return (*rw190)(state)
	case 191:
		return (*rw191)(state)
	case 192:
		return (*rw192)(state)
	case 193:
		return (*rw193)(state)
	case 194:
		return (*rw194)(state)
	case 195:
		return (*rw195)(state)
	case 196:
		return (*rw196)(state)
	case 197:
		return (*rw197)(state)
	case 198:
		return (*rw198)(state)
	case 199:
		return (*rw199)(state)
	case 200:
		return (*rw200)(state)
	case 201:
		return (*rw201)(state)
	case 202:
		return (*rw202)(state)
	case 203:
		return (*rw203)(state)
	case 204:
		return (*rw204)(state)
	case 205:
		return (*rw205)(state)
	case 206:
		return (*rw206)(state)
	case 207:
		return (*rw207)(state)
	case 208:
		return (*rw208)(state)
	case 209:
		return (*rw209)(state)
	case 210:
		return (*rw210)(state)
	case 211:
		return (*rw211)(state)
	case 212:
		return (*rw212)(state)
	case 213:
		return (*rw213)(state)
	case 214:
		return (*rw214)(state)
	case 215:
		return (*rw215)(state)
	case 216:
		return (*rw216)(state)
	case 217:
		return (*rw217)(state)
	case 218:
		return (*rw218)(state)
	case 219:
		return (*rw219)(state)
	case 220:
		return (*rw220)(state)
	case 221:
		return (*rw221)(state)
	case 222:
		return (*rw222)(state)
	case 223:
		return (*rw223)(state)
	case 224:
		return (*rw224)(state)
	case 225:
		return (*rw225)(state)
	case 226:
		return (*rw226)(state)
	case 227:
		return (*rw227)(state)
	case 228:
		return (*rw228)(state)
	case 229:
		return (*rw229)(state)
	case 230:
		return (*rw230)(state)
	case 231:
		return (*rw231)(state)
	case 232:
		return (*rw232)(state)
	case 233:
		return (*rw233)(state)
	case 234:
		return (*rw234)(state)
	case 235:
		return (*rw235)(state)
	case 236:
		return (*rw236)(state)
	case 237:
		return (*rw237)(state)
	case 238:
		return (*rw238)(state)
	case 239:
		return (*rw239)(state)
	case 240:
		return (*rw240)(state)
	case 241:
		return (*rw241)(state)
	case 242:
		return (*rw242)(state)
	case 243:
		return (*rw243)(state)
	case 244:
		return (*rw244)(state)
	case 245:
		return (*rw245)(state)
	case 246:
		return (*rw246)(state)
	case 247:
		return (*rw247)(state)
	case 248:
		return (*rw248)(state)
	case 249:
		return (*rw249)(state)
	case 250:
		return (*rw250)(state)
	case 251:
		return (*rw251)(state)
	case 252:
		return (*rw252)(state)
	case 253:
		return (*rw253)(state)
	case 254:
		return (*rw254)(state)
	case 255:
		return (*rw255)(state)
	case 256:
		return (*rw256)(state)
	case 257:
		return (*rw257)(state)
	case 258:
		return (*rw258)(state)
	case 259:
		return (*rw259)(state)
	case 260:
		return (*rw260)(state)
	case 261:
		return (*rw261)(state)
	case 262:
		return (*rw262)(state)
	case 263:
		return (*rw263)(state)
	case 264:
		return (*rw264)(state)
	case 265:
		return (*rw265)(state)
	case 266:
		return (*rw266)(state)
	case 267:
		return (*rw267)(state)
	case 268:
		return (*rw268)(state)
	case 269:
		return (*rw269)(state)
	case 270:
		return (*rw270)(state)
	case 271:
		return (*rw271)(state)
	case 272:
		return (*rw272)(state)
	case 273:
		return (*rw273)(state)
	case 274:
		return (*rw274)(state)
	case 275:
		return (*rw275)(state)
	case 276:
		return (*rw276)(state)
	case 277:
		return (*rw277)(state)
	case 278:
		return (*rw278)(state)
	case 279:
		return (*rw279)(state)
	case 280:
		return (*rw280)(state)
	case 281:
		return (*rw281)(state)
	case 282:
		return (*rw282)(state)
	case 283:
		return (*rw283)(state)
	case 284:
		return (*rw284)(state)
	case 285:
		return (*rw285)(state)
	case 286:
		return (*rw286)(state)
	case 287:
		return (*rw287)(state)
	case 288:
		return (*rw288)(state)
	case 289:
		return (*rw289)(state)
	case 290:
		return (*rw290)(state)
	case 291:
		return (*rw291)(state)
	case 292:
		return (*rw292)(state)
	case 293:
		return (*rw293)(state)
	case 294:
		return (*rw294)(state)
	case 295:
		return (*rw295)(state)
	case 296:
		return (*rw296)(state)
	case 297:
		return (*rw297)(state)
	case 298:
		return (*rw298)(state)
	case 299:
		return (*rw299)(state)
	case 300:
		return (*rw300)(state)
	case 301:
		return (*rw301)(state)
	case 302:
		return (*rw302)(state)
	case 303:
		return (*rw303)(state)
	case 304:
		return (*rw304)(state)
	case 305:
		return (*rw305)(state)
	case 306:
		return (*rw306)(state)
	case 307:
		return (*rw307)(state)
	case 308:
		return (*rw308)(state)
	case 309:
		return (*rw309)(state)
	case 310:
		return (*rw310)(state)
	case 311:
		return (*rw311)(state)
	case 312:
		return (*rw312)(state)
	case 313:
		return (*rw313)(state)
	case 314:
		return (*rw314)(state)
	case 315:
		return (*rw315)(state)
	case 316:
		return (*rw316)(state)
	case 317:
		return (*rw317)(state)
	case 318:
		return (*rw318)(state)
	case 319:
		return (*rw319)(state)
	case 320:
		return (*rw320)(state)
	case 321:
		return (*rw321)(state)
	case 322:
		return (*rw322)(state)
	case 323:
		return (*rw323)(state)
	case 324:
		return (*rw324)(state)
	case 325:
		return (*rw325)(state)
	case 326:
		return (*rw326)(state)
	case 327:
		return (*rw327)(state)
	case 328:
		return (*rw328)(state)
	case 329:
		return (*rw329)(state)
	case 330:
		return (*rw330)(state)
	case 331:
		return (*rw331)(state)
	case 332:
		return (*rw332)(state)
	case 333:
		return (*rw333)(state)
	case 334:
		return (*rw334)(state)
	case 335:
		return (*rw335)(state)
	case 336:
		return (*rw336)(state)
	case 337:
		return (*rw337)(state)
	case 338:
		return (*rw338)(state)
	case 339:
		return (*rw339)(state)
	case 340:
		return (*rw340)(state)
	case 341:
		return (*rw341)(state)
	case 342:
		return (*rw342)(state)
	case 343:
		return (*rw343)(state)
	case 344:
		return (*rw344)(state)
	case 345:
		return (*rw345)(state)
	case 346:
		return (*rw346)(state)
	case 347:
		return (*rw347)(state)
	case 348:
		return (*rw348)(state)
	case 349:
		return (*rw349)(state)
	case 350:
		return (*rw350)(state)
	case 351:
		return (*rw351)(state)
	case 352:
		return (*rw352)(state)
	case 353:
		return (*rw353)(state)
	case 354:
		return (*rw354)(state)
	case 355:
		return (*rw355)(state)
	case 356:
		return (*rw356)(state)
	case 357:
		return (*rw357)(state)
	case 358:
		return (*rw358)(state)
	case 359:
		return (*rw359)(state)
	case 360:
		return (*rw360)(state)
	case 361:
		return (*rw361)(state)
	case 362:
		return (*rw362)(state)
	case 363:
		return (*rw363)(state)
	case 364:
		return (*rw364)(state)
	case 365:
		return (*rw365)(state)
	case 366:
		return (*rw366)(state)
	case 367:
		return (*rw367)(state)
	case 368:
		return (*rw368)(state)
	case 369:
		return (*rw369)(state)
	case 370:
		return (*rw370)(state)
	case 371:
		return (*rw371)(state)
	case 372:
		return (*rw372)(state)
	case 373:
		return (*rw373)(state)
	case 374:
		return (*rw374)(state)
	case 375:
		return (*rw375)(state)
	case 376:
		return (*rw376)(state)
	case 377:
		return (*rw377)(state)
	case 378:
		return (*rw378)(state)
	case 379:
		return (*rw379)(state)
	case 380:
		return (*rw380)(state)
	case 381:
		return (*rw381)(state)
	case 382:
		return (*rw382)(state)
	case 383:
		return (*rw383)(state)
	case 384:
		return (*rw384)(state)
	case 385:
		return (*rw385)(state)
	case 386:
		return (*rw386)(state)
	case 387:
		return (*rw387)(state)
	case 388:
		return (*rw388)(state)
	case 389:
		return (*rw389)(state)
	case 390:
		return (*rw390)(state)
	case 391:
		return (*rw391)(state)
	case 392:
		return (*rw392)(state)
	case 393:
		return (*rw393)(state)
	case 394:
		return (*rw394)(state)
	case 395:
		return (*rw395)(state)
	case 396:
		return (*rw396)(state)
	case 397:
		return (*rw397)(state)
	case 398:
		return (*rw398)(state)
	case 399:
		return (*rw399)(state)
	case 400:
		return (*rw400)(state)
	case 401:
		return (*rw401)(state)
	case 402:
		return (*rw402)(state)
	case 403:
		return (*rw403)(state)
	case 404:
		return (*rw404)(state)
	case 405:
		return (*rw405)(state)
	case 406:
		return (*rw406)(state)
	case 407:
		return (*rw407)(state)
	case 408:
		return (*rw408)(state)
	case 409:
		return (*rw409)(state)
	case 410:
		return (*rw410)(state)
	case 411:
		return (*rw411)(state)
	case 412:
		return (*rw412)(state)
	case 413:
		return (*rw413)(state)
	case 414:
		return (*rw414)(state)
	case 415:
		return (*rw415)(state)
	case 416:
		return (*rw416)(state)
	case 417:
		return (*rw417)(state)
	case 418:
		return (*rw418)(state)
	case 419:
		return (*rw419)(state)
	case 420:
		return (*rw420)(state)
	case 421:
		return (*rw421)(state)
	case 422:
		return (*rw422)(state)
	case 423:
		return (*rw423)(state)
	case 424:
		return (*rw424)(state)
	case 425:
		return (*rw425)(state)
	case 426:
		return (*rw426)(state)
	case 427:
		return (*rw427)(state)
	case 428:
		return (*rw428)(state)
	case 429:
		return (*rw429)(state)
	case 430:
		return (*rw430)(state)
	case 431:
		return (*rw431)(state)
	case 432:
		return (*rw432)(state)
	case 433:
		return (*rw433)(state)
	case 434:
		return (*rw434)(state)
	case 435:
		return (*rw435)(state)
	case 436:
		return (*rw436)(state)
	case 437:
		return (*rw437)(state)
	case 438:
		return (*rw438)(state)
	case 439:
		return (*rw439)(state)
	case 440:
		return (*rw440)(state)
	case 441:
		return (*rw441)(state)
	case 442:
		return (*rw442)(state)
	case 443:
		return (*rw443)(state)
	case 444:
		return (*rw444)(state)
	case 445:
		return (*rw445)(state)
	case 446:
		return (*rw446)(state)
	case 447:
		return (*rw447)(state)
	case 448:
		return (*rw448)(state)
	case 449:
		return (*rw449)(state)
	case 450:
		return (*rw450)(state)
	case 451:
		return (*rw451)(state)
	case 452:
		return (*rw452)(state)
	case 453:
		return (*rw453)(state)
	case 454:
		return (*rw454)(state)
	case 455:
		return (*rw455)(state)
	case 456:
		return (*rw456)(state)
	case 457:
		return (*rw457)(state)
	case 458:
		return (*rw458)(state)
	case 459:
		return (*rw459)(state)
	case 460:
		return (*rw460)(state)
	case 461:
		return (*rw461)(state)
	case 462:
		return (*rw462)(state)
	case 463:
		return (*rw463)(state)
	case 464:
		return (*rw464)(state)
	case 465:
		return (*rw465)(state)
	case 466:
		return (*rw466)(state)
	case 467:
		return (*rw467)(state)
	case 468:
		return (*rw468)(state)
	case 469:
		return (*rw469)(state)
	case 470:
		return (*rw470)(state)
	case 471:
		return (*rw471)(state)
	case 472:
		return (*rw472)(state)
	case 473:
		return (*rw473)(state)
	case 474:
		return (*rw474)(state)
	case 475:
		return (*rw475)(state)
	case 476:
		return (*rw476)(state)
	case 477:
		return (*rw477)(state)
	case 478:
		return (*rw478)(state)
	case 479:
		return (*rw479)(state)
	case 480:
		return (*rw480)(state)
	case 481:
		return (*rw481)(state)
	case 482:
		return (*rw482)(state)
	case 483:
		return (*rw483)(state)
	case 484:
		return (*rw484)(state)
	case 485:
		return (*rw485)(state)
	case 486:
		return (*rw486)(state)
	case 487:
		return (*rw487)(state)
	case 488:
		return (*rw488)(state)
	case 489:
		return (*rw489)(state)
	case 490:
		return (*rw490)(state)
	case 491:
		return (*rw491)(state)
	case 492:
		return (*rw492)(state)
	case 493:
		return (*rw493)(state)
	case 494:
		return (*rw494)(state)
	case 495:
		return (*rw495)(state)
	case 496:
		return (*rw496)(state)
	case 497:
		return (*rw497)(state)
	case 498:
		return (*rw498)(state)
	case 499:
		return (*rw499)(state)
	case 500:
		return (*rw500)(state)
	case 501:
		return (*rw501)(state)
	case 502:
		return (*rw502)(state)
	case 503:
		return (*rw503)(state)
	case 504:
		return (*rw504)(state)
	case 505:
		return (*rw505)(state)
	case 506:
		return (*rw506)(state)
	case 507:
		return (*rw507)(state)
	case 508:
		return (*rw508)(state)
	case 509:
		return (*rw509)(state)
	case 510:
		return (*rw510)(state)
	case 511:
		return (*rw511)(state)
	}
	panic("unreachable")
}

type rwState struct {
	w                http.ResponseWriter
	header           HeaderFunc
	writeHeader      WriteHeaderFunc
	write            WriteFunc
	flush            FlushFunc
	flushError       FlushErrorFunc
	closeNotify      CloseNotifyFunc
	hijack           HijackFunc
	readFrom         ReadFromFunc
	setReadDeadline  SetReadDeadlineFunc
	setWriteDeadline SetWriteDeadlineFunc
	enableFullDuplex EnableFullDuplexFunc
	push             PushFunc
	writeString      WriteStringFunc
}

func (r *rwState) doHeader() http.Header {
	if r.header != nil {
		return r.header()
	}
	return r.w.Header()
}

func (r *rwState) doWriteHeader(code int) {
	if r.writeHeader != nil {
		r.writeHeader(code)
		return
	}
	r.w.WriteHeader(code)
}

func (r *rwState) doWrite(b []byte) (int, error) {
	if r.write != nil {
		return r.write(b)
	}
	return r.w.Write(b)
}

func (r *rwState) doFlush() {
	if r.flush != nil {
		r.flush()
		return
	}
	r.w.(http.Flusher).Flush()
}

func (r *rwState) doFlushError() error {
	if r.flushError != nil {
		return r.flushError()
	}
	return r.w.(httpFlushError).FlushError()
}

func (r *rwState) doCloseNotify() <-chan bool {
	if r.closeNotify != nil {
		return r.closeNotify()
	}
	return r.w.(http.CloseNotifier).CloseNotify()
}

func (r *rwState) doHijack() (net.Conn, *bufio.ReadWriter, error) {
	if r.hijack != nil {
		return r.hijack()
	}
	return r.w.(http.Hijacker).Hijack()
}

func (r *rwState) doReadFrom(src io.Reader) (int64, error) {
	if r.readFrom != nil {
		return r.readFrom(src)
	}
	return r.w.(io.ReaderFrom).ReadFrom(src)
}

func (r *rwState) doSetReadDeadline(deadline time.Time) error {
	if r.setReadDeadline != nil {
		return r.setReadDeadline(deadline)
	}
	return r.w.(deadliner).SetReadDeadline(deadline)
}

func (r *rwState) doSetWriteDeadline(deadline time.Time) error {
	if r.setWriteDeadline != nil {
		return r.setWriteDeadline(deadline)
	}
	return r.w.(deadliner).SetWriteDeadline(deadline)
}

func (r *rwState) doEnableFullDuplex() error {
	if r.enableFullDuplex != nil {
		return r.enableFullDuplex()
	}
	return r.w.(fullDuplexEnabler).EnableFullDuplex()
}

func (r *rwState) doPush(target string, opts *http.PushOptions) error {
	if r.push != nil {
		return r.push(target, opts)
	}
	return r.w.(http.Pusher).Push(target, opts)
}

func (r *rwState) doWriteString(s string) (int, error) {
	if r.writeString != nil {
		return r.writeString(s)
	}
	return r.w.(io.StringWriter).WriteString(s)
}

// combination 1/512: http.ResponseWriter
type rw0 rwState

func (w *rw0) Unwrap() http.ResponseWriter { return w.w }
func (w *rw0) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw0) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw0) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}

// combination 2/512: http.ResponseWriter, io.StringWriter
type rw1 rwState

func (w *rw1) Unwrap() http.ResponseWriter { return w.w }
func (w *rw1) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw1) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw1) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw1) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 3/512: http.ResponseWriter, http.Pusher
type rw2 rwState

func (w *rw2) Unwrap() http.ResponseWriter { return w.w }
func (w *rw2) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw2) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw2) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw2) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 4/512: http.ResponseWriter, http.Pusher, io.StringWriter
type rw3 rwState

func (w *rw3) Unwrap() http.ResponseWriter { return w.w }
func (w *rw3) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw3) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw3) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw3) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw3) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 5/512: http.ResponseWriter, fullDuplexEnabler
type rw4 rwState

func (w *rw4) Unwrap() http.ResponseWriter { return w.w }
func (w *rw4) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw4) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw4) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw4) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 6/512: http.ResponseWriter, fullDuplexEnabler, io.StringWriter
type rw5 rwState

func (w *rw5) Unwrap() http.ResponseWriter { return w.w }
func (w *rw5) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw5) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw5) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw5) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw5) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 7/512: http.ResponseWriter, fullDuplexEnabler, http.Pusher
type rw6 rwState

func (w *rw6) Unwrap() http.ResponseWriter { return w.w }
func (w *rw6) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw6) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw6) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw6) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw6) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 8/512: http.ResponseWriter, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw7 rwState

func (w *rw7) Unwrap() http.ResponseWriter { return w.w }
func (w *rw7) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw7) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw7) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw7) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw7) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw7) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 9/512: http.ResponseWriter, deadliner
type rw8 rwState

func (w *rw8) Unwrap() http.ResponseWriter { return w.w }
func (w *rw8) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw8) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw8) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw8) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw8) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 10/512: http.ResponseWriter, deadliner, io.StringWriter
type rw9 rwState

func (w *rw9) Unwrap() http.ResponseWriter { return w.w }
func (w *rw9) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw9) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw9) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw9) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw9) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw9) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 11/512: http.ResponseWriter, deadliner, http.Pusher
type rw10 rwState

func (w *rw10) Unwrap() http.ResponseWriter { return w.w }
func (w *rw10) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw10) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw10) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw10) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw10) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw10) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 12/512: http.ResponseWriter, deadliner, http.Pusher, io.StringWriter
type rw11 rwState

func (w *rw11) Unwrap() http.ResponseWriter { return w.w }
func (w *rw11) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw11) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw11) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw11) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw11) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw11) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw11) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 13/512: http.ResponseWriter, deadliner, fullDuplexEnabler
type rw12 rwState

func (w *rw12) Unwrap() http.ResponseWriter { return w.w }
func (w *rw12) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw12) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw12) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw12) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw12) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw12) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 14/512: http.ResponseWriter, deadliner, fullDuplexEnabler, io.StringWriter
type rw13 rwState

func (w *rw13) Unwrap() http.ResponseWriter { return w.w }
func (w *rw13) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw13) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw13) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw13) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw13) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw13) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw13) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 15/512: http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher
type rw14 rwState

func (w *rw14) Unwrap() http.ResponseWriter { return w.w }
func (w *rw14) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw14) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw14) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw14) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw14) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw14) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw14) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 16/512: http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw15 rwState

func (w *rw15) Unwrap() http.ResponseWriter { return w.w }
func (w *rw15) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw15) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw15) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw15) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw15) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw15) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw15) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw15) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 17/512: http.ResponseWriter, io.ReaderFrom
type rw16 rwState

func (w *rw16) Unwrap() http.ResponseWriter { return w.w }
func (w *rw16) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw16) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw16) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw16) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 18/512: http.ResponseWriter, io.ReaderFrom, io.StringWriter
type rw17 rwState

func (w *rw17) Unwrap() http.ResponseWriter { return w.w }
func (w *rw17) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw17) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw17) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw17) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw17) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 19/512: http.ResponseWriter, io.ReaderFrom, http.Pusher
type rw18 rwState

func (w *rw18) Unwrap() http.ResponseWriter { return w.w }
func (w *rw18) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw18) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw18) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw18) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw18) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 20/512: http.ResponseWriter, io.ReaderFrom, http.Pusher, io.StringWriter
type rw19 rwState

func (w *rw19) Unwrap() http.ResponseWriter { return w.w }
func (w *rw19) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw19) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw19) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw19) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw19) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw19) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 21/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler
type rw20 rwState

func (w *rw20) Unwrap() http.ResponseWriter { return w.w }
func (w *rw20) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw20) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw20) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw20) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw20) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 22/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw21 rwState

func (w *rw21) Unwrap() http.ResponseWriter { return w.w }
func (w *rw21) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw21) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw21) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw21) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw21) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw21) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 23/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw22 rwState

func (w *rw22) Unwrap() http.ResponseWriter { return w.w }
func (w *rw22) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw22) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw22) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw22) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw22) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw22) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 24/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw23 rwState

func (w *rw23) Unwrap() http.ResponseWriter { return w.w }
func (w *rw23) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw23) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw23) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw23) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw23) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw23) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw23) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 25/512: http.ResponseWriter, io.ReaderFrom, deadliner
type rw24 rwState

func (w *rw24) Unwrap() http.ResponseWriter { return w.w }
func (w *rw24) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw24) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw24) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw24) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw24) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw24) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 26/512: http.ResponseWriter, io.ReaderFrom, deadliner, io.StringWriter
type rw25 rwState

func (w *rw25) Unwrap() http.ResponseWriter { return w.w }
func (w *rw25) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw25) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw25) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw25) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw25) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw25) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw25) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 27/512: http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher
type rw26 rwState

func (w *rw26) Unwrap() http.ResponseWriter { return w.w }
func (w *rw26) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw26) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw26) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw26) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw26) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw26) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw26) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 28/512: http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw27 rwState

func (w *rw27) Unwrap() http.ResponseWriter { return w.w }
func (w *rw27) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw27) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw27) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw27) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw27) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw27) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw27) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw27) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 29/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw28 rwState

func (w *rw28) Unwrap() http.ResponseWriter { return w.w }
func (w *rw28) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw28) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw28) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw28) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw28) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw28) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw28) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 30/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw29 rwState

func (w *rw29) Unwrap() http.ResponseWriter { return w.w }
func (w *rw29) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw29) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw29) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw29) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw29) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw29) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw29) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw29) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 31/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw30 rwState

func (w *rw30) Unwrap() http.ResponseWriter { return w.w }
func (w *rw30) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw30) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw30) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw30) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw30) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw30) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw30) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw30) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 32/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw31 rwState

func (w *rw31) Unwrap() http.ResponseWriter { return w.w }
func (w *rw31) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw31) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw31) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw31) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw31) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw31) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw31) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw31) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw31) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 33/512: http.ResponseWriter, http.Hijacker
type rw32 rwState

func (w *rw32) Unwrap() http.ResponseWriter { return w.w }
func (w *rw32) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw32) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw32) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw32) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 34/512: http.ResponseWriter, http.Hijacker, io.StringWriter
type rw33 rwState

func (w *rw33) Unwrap() http.ResponseWriter { return w.w }
func (w *rw33) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw33) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw33) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw33) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw33) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 35/512: http.ResponseWriter, http.Hijacker, http.Pusher
type rw34 rwState

func (w *rw34) Unwrap() http.ResponseWriter { return w.w }
func (w *rw34) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw34) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw34) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw34) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw34) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 36/512: http.ResponseWriter, http.Hijacker, http.Pusher, io.StringWriter
type rw35 rwState

func (w *rw35) Unwrap() http.ResponseWriter { return w.w }
func (w *rw35) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw35) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw35) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw35) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw35) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw35) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 37/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler
type rw36 rwState

func (w *rw36) Unwrap() http.ResponseWriter { return w.w }
func (w *rw36) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw36) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw36) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw36) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw36) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 38/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw37 rwState

func (w *rw37) Unwrap() http.ResponseWriter { return w.w }
func (w *rw37) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw37) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw37) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw37) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw37) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw37) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 39/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw38 rwState

func (w *rw38) Unwrap() http.ResponseWriter { return w.w }
func (w *rw38) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw38) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw38) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw38) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw38) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw38) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 40/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw39 rwState

func (w *rw39) Unwrap() http.ResponseWriter { return w.w }
func (w *rw39) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw39) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw39) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw39) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw39) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw39) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw39) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 41/512: http.ResponseWriter, http.Hijacker, deadliner
type rw40 rwState

func (w *rw40) Unwrap() http.ResponseWriter { return w.w }
func (w *rw40) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw40) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw40) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw40) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw40) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw40) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 42/512: http.ResponseWriter, http.Hijacker, deadliner, io.StringWriter
type rw41 rwState

func (w *rw41) Unwrap() http.ResponseWriter { return w.w }
func (w *rw41) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw41) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw41) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw41) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw41) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw41) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw41) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 43/512: http.ResponseWriter, http.Hijacker, deadliner, http.Pusher
type rw42 rwState

func (w *rw42) Unwrap() http.ResponseWriter { return w.w }
func (w *rw42) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw42) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw42) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw42) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw42) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw42) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw42) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 44/512: http.ResponseWriter, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw43 rwState

func (w *rw43) Unwrap() http.ResponseWriter { return w.w }
func (w *rw43) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw43) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw43) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw43) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw43) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw43) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw43) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw43) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 45/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler
type rw44 rwState

func (w *rw44) Unwrap() http.ResponseWriter { return w.w }
func (w *rw44) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw44) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw44) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw44) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw44) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw44) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw44) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 46/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw45 rwState

func (w *rw45) Unwrap() http.ResponseWriter { return w.w }
func (w *rw45) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw45) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw45) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw45) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw45) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw45) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw45) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw45) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 47/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw46 rwState

func (w *rw46) Unwrap() http.ResponseWriter { return w.w }
func (w *rw46) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw46) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw46) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw46) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw46) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw46) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw46) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw46) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 48/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw47 rwState

func (w *rw47) Unwrap() http.ResponseWriter { return w.w }
func (w *rw47) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw47) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw47) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw47) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw47) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw47) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw47) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw47) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw47) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 49/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom
type rw48 rwState

func (w *rw48) Unwrap() http.ResponseWriter { return w.w }
func (w *rw48) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw48) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw48) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw48) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw48) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 50/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw49 rwState

func (w *rw49) Unwrap() http.ResponseWriter { return w.w }
func (w *rw49) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw49) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw49) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw49) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw49) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw49) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 51/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher
type rw50 rwState

func (w *rw50) Unwrap() http.ResponseWriter { return w.w }
func (w *rw50) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw50) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw50) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw50) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw50) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw50) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 52/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw51 rwState

func (w *rw51) Unwrap() http.ResponseWriter { return w.w }
func (w *rw51) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw51) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw51) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw51) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw51) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw51) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw51) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 53/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw52 rwState

func (w *rw52) Unwrap() http.ResponseWriter { return w.w }
func (w *rw52) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw52) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw52) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw52) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw52) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw52) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 54/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw53 rwState

func (w *rw53) Unwrap() http.ResponseWriter { return w.w }
func (w *rw53) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw53) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw53) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw53) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw53) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw53) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw53) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 55/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw54 rwState

func (w *rw54) Unwrap() http.ResponseWriter { return w.w }
func (w *rw54) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw54) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw54) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw54) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw54) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw54) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw54) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 56/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw55 rwState

func (w *rw55) Unwrap() http.ResponseWriter { return w.w }
func (w *rw55) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw55) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw55) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw55) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw55) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw55) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw55) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw55) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 57/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner
type rw56 rwState

func (w *rw56) Unwrap() http.ResponseWriter { return w.w }
func (w *rw56) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw56) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw56) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw56) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw56) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw56) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw56) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 58/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw57 rwState

func (w *rw57) Unwrap() http.ResponseWriter { return w.w }
func (w *rw57) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw57) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw57) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw57) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw57) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw57) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw57) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw57) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 59/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw58 rwState

func (w *rw58) Unwrap() http.ResponseWriter { return w.w }
func (w *rw58) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw58) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw58) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw58) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw58) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw58) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw58) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw58) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 60/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw59 rwState

func (w *rw59) Unwrap() http.ResponseWriter { return w.w }
func (w *rw59) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw59) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw59) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw59) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw59) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw59) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw59) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw59) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw59) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 61/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw60 rwState

func (w *rw60) Unwrap() http.ResponseWriter { return w.w }
func (w *rw60) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw60) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw60) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw60) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw60) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw60) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw60) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw60) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 62/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw61 rwState

func (w *rw61) Unwrap() http.ResponseWriter { return w.w }
func (w *rw61) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw61) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw61) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw61) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw61) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw61) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw61) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw61) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw61) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 63/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw62 rwState

func (w *rw62) Unwrap() http.ResponseWriter { return w.w }
func (w *rw62) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw62) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw62) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw62) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw62) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw62) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw62) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw62) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw62) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 64/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw63 rwState

func (w *rw63) Unwrap() http.ResponseWriter { return w.w }
func (w *rw63) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw63) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw63) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw63) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw63) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw63) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw63) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw63) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw63) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw63) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 65/512: http.ResponseWriter, http.CloseNotifier
type rw64 rwState

func (w *rw64) Unwrap() http.ResponseWriter { return w.w }
func (w *rw64) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw64) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw64) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw64) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}

// combination 66/512: http.ResponseWriter, http.CloseNotifier, io.StringWriter
type rw65 rwState

func (w *rw65) Unwrap() http.ResponseWriter { return w.w }
func (w *rw65) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw65) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw65) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw65) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw65) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 67/512: http.ResponseWriter, http.CloseNotifier, http.Pusher
type rw66 rwState

func (w *rw66) Unwrap() http.ResponseWriter { return w.w }
func (w *rw66) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw66) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw66) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw66) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw66) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 68/512: http.ResponseWriter, http.CloseNotifier, http.Pusher, io.StringWriter
type rw67 rwState

func (w *rw67) Unwrap() http.ResponseWriter { return w.w }
func (w *rw67) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw67) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw67) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw67) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw67) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw67) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 69/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler
type rw68 rwState

func (w *rw68) Unwrap() http.ResponseWriter { return w.w }
func (w *rw68) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw68) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw68) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw68) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw68) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 70/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
type rw69 rwState

func (w *rw69) Unwrap() http.ResponseWriter { return w.w }
func (w *rw69) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw69) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw69) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw69) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw69) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw69) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 71/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher
type rw70 rwState

func (w *rw70) Unwrap() http.ResponseWriter { return w.w }
func (w *rw70) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw70) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw70) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw70) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw70) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw70) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 72/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw71 rwState

func (w *rw71) Unwrap() http.ResponseWriter { return w.w }
func (w *rw71) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw71) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw71) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw71) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw71) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw71) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw71) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 73/512: http.ResponseWriter, http.CloseNotifier, deadliner
type rw72 rwState

func (w *rw72) Unwrap() http.ResponseWriter { return w.w }
func (w *rw72) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw72) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw72) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw72) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw72) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw72) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 74/512: http.ResponseWriter, http.CloseNotifier, deadliner, io.StringWriter
type rw73 rwState

func (w *rw73) Unwrap() http.ResponseWriter { return w.w }
func (w *rw73) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw73) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw73) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw73) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw73) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw73) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw73) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 75/512: http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher
type rw74 rwState

func (w *rw74) Unwrap() http.ResponseWriter { return w.w }
func (w *rw74) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw74) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw74) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw74) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw74) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw74) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw74) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 76/512: http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
type rw75 rwState

func (w *rw75) Unwrap() http.ResponseWriter { return w.w }
func (w *rw75) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw75) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw75) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw75) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw75) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw75) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw75) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw75) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 77/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler
type rw76 rwState

func (w *rw76) Unwrap() http.ResponseWriter { return w.w }
func (w *rw76) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw76) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw76) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw76) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw76) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw76) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw76) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 78/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
type rw77 rwState

func (w *rw77) Unwrap() http.ResponseWriter { return w.w }
func (w *rw77) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw77) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw77) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw77) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw77) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw77) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw77) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw77) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 79/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
type rw78 rwState

func (w *rw78) Unwrap() http.ResponseWriter { return w.w }
func (w *rw78) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw78) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw78) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw78) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw78) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw78) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw78) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw78) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 80/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw79 rwState

func (w *rw79) Unwrap() http.ResponseWriter { return w.w }
func (w *rw79) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw79) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw79) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw79) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw79) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw79) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw79) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw79) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw79) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 81/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom
type rw80 rwState

func (w *rw80) Unwrap() http.ResponseWriter { return w.w }
func (w *rw80) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw80) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw80) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw80) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw80) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 82/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, io.StringWriter
type rw81 rwState

func (w *rw81) Unwrap() http.ResponseWriter { return w.w }
func (w *rw81) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw81) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw81) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw81) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw81) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw81) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 83/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher
type rw82 rwState

func (w *rw82) Unwrap() http.ResponseWriter { return w.w }
func (w *rw82) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw82) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw82) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw82) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw82) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw82) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 84/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
type rw83 rwState

func (w *rw83) Unwrap() http.ResponseWriter { return w.w }
func (w *rw83) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw83) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw83) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw83) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw83) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw83) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw83) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 85/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
type rw84 rwState

func (w *rw84) Unwrap() http.ResponseWriter { return w.w }
func (w *rw84) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw84) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw84) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw84) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw84) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw84) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 86/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw85 rwState

func (w *rw85) Unwrap() http.ResponseWriter { return w.w }
func (w *rw85) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw85) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw85) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw85) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw85) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw85) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw85) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 87/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw86 rwState

func (w *rw86) Unwrap() http.ResponseWriter { return w.w }
func (w *rw86) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw86) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw86) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw86) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw86) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw86) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw86) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 88/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw87 rwState

func (w *rw87) Unwrap() http.ResponseWriter { return w.w }
func (w *rw87) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw87) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw87) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw87) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw87) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw87) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw87) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw87) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 89/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner
type rw88 rwState

func (w *rw88) Unwrap() http.ResponseWriter { return w.w }
func (w *rw88) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw88) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw88) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw88) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw88) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw88) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw88) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 90/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
type rw89 rwState

func (w *rw89) Unwrap() http.ResponseWriter { return w.w }
func (w *rw89) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw89) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw89) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw89) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw89) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw89) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw89) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw89) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 91/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
type rw90 rwState

func (w *rw90) Unwrap() http.ResponseWriter { return w.w }
func (w *rw90) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw90) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw90) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw90) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw90) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw90) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw90) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw90) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 92/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw91 rwState

func (w *rw91) Unwrap() http.ResponseWriter { return w.w }
func (w *rw91) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw91) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw91) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw91) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw91) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw91) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw91) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw91) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw91) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 93/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw92 rwState

func (w *rw92) Unwrap() http.ResponseWriter { return w.w }
func (w *rw92) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw92) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw92) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw92) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw92) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw92) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw92) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw92) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 94/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw93 rwState

func (w *rw93) Unwrap() http.ResponseWriter { return w.w }
func (w *rw93) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw93) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw93) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw93) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw93) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw93) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw93) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw93) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw93) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 95/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw94 rwState

func (w *rw94) Unwrap() http.ResponseWriter { return w.w }
func (w *rw94) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw94) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw94) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw94) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw94) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw94) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw94) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw94) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw94) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 96/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw95 rwState

func (w *rw95) Unwrap() http.ResponseWriter { return w.w }
func (w *rw95) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw95) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw95) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw95) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw95) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw95) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw95) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw95) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw95) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw95) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 97/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker
type rw96 rwState

func (w *rw96) Unwrap() http.ResponseWriter { return w.w }
func (w *rw96) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw96) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw96) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw96) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw96) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 98/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.StringWriter
type rw97 rwState

func (w *rw97) Unwrap() http.ResponseWriter { return w.w }
func (w *rw97) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw97) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw97) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw97) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw97) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw97) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 99/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher
type rw98 rwState

func (w *rw98) Unwrap() http.ResponseWriter { return w.w }
func (w *rw98) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw98) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw98) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw98) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw98) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw98) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 100/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
type rw99 rwState

func (w *rw99) Unwrap() http.ResponseWriter { return w.w }
func (w *rw99) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw99) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw99) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw99) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw99) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw99) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw99) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 101/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
type rw100 rwState

func (w *rw100) Unwrap() http.ResponseWriter { return w.w }
func (w *rw100) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw100) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw100) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw100) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw100) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw100) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 102/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw101 rwState

func (w *rw101) Unwrap() http.ResponseWriter { return w.w }
func (w *rw101) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw101) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw101) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw101) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw101) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw101) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw101) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 103/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw102 rwState

func (w *rw102) Unwrap() http.ResponseWriter { return w.w }
func (w *rw102) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw102) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw102) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw102) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw102) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw102) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw102) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 104/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw103 rwState

func (w *rw103) Unwrap() http.ResponseWriter { return w.w }
func (w *rw103) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw103) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw103) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw103) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw103) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw103) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw103) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw103) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 105/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner
type rw104 rwState

func (w *rw104) Unwrap() http.ResponseWriter { return w.w }
func (w *rw104) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw104) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw104) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw104) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw104) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw104) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw104) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 106/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
type rw105 rwState

func (w *rw105) Unwrap() http.ResponseWriter { return w.w }
func (w *rw105) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw105) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw105) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw105) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw105) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw105) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw105) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw105) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 107/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
type rw106 rwState

func (w *rw106) Unwrap() http.ResponseWriter { return w.w }
func (w *rw106) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw106) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw106) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw106) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw106) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw106) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw106) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw106) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 108/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw107 rwState

func (w *rw107) Unwrap() http.ResponseWriter { return w.w }
func (w *rw107) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw107) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw107) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw107) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw107) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw107) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw107) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw107) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw107) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 109/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
type rw108 rwState

func (w *rw108) Unwrap() http.ResponseWriter { return w.w }
func (w *rw108) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw108) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw108) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw108) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw108) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw108) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw108) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw108) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 110/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw109 rwState

func (w *rw109) Unwrap() http.ResponseWriter { return w.w }
func (w *rw109) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw109) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw109) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw109) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw109) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw109) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw109) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw109) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw109) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 111/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw110 rwState

func (w *rw110) Unwrap() http.ResponseWriter { return w.w }
func (w *rw110) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw110) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw110) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw110) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw110) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw110) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw110) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw110) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw110) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 112/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw111 rwState

func (w *rw111) Unwrap() http.ResponseWriter { return w.w }
func (w *rw111) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw111) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw111) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw111) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw111) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw111) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw111) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw111) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw111) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw111) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 113/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom
type rw112 rwState

func (w *rw112) Unwrap() http.ResponseWriter { return w.w }
func (w *rw112) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw112) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw112) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw112) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw112) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw112) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 114/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw113 rwState

func (w *rw113) Unwrap() http.ResponseWriter { return w.w }
func (w *rw113) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw113) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw113) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw113) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw113) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw113) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw113) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 115/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
type rw114 rwState

func (w *rw114) Unwrap() http.ResponseWriter { return w.w }
func (w *rw114) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw114) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw114) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw114) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw114) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw114) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw114) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 116/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw115 rwState

func (w *rw115) Unwrap() http.ResponseWriter { return w.w }
func (w *rw115) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw115) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw115) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw115) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw115) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw115) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw115) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw115) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 117/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw116 rwState

func (w *rw116) Unwrap() http.ResponseWriter { return w.w }
func (w *rw116) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw116) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw116) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw116) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw116) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw116) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw116) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 118/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw117 rwState

func (w *rw117) Unwrap() http.ResponseWriter { return w.w }
func (w *rw117) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw117) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw117) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw117) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw117) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw117) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw117) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw117) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 119/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw118 rwState

func (w *rw118) Unwrap() http.ResponseWriter { return w.w }
func (w *rw118) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw118) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw118) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw118) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw118) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw118) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw118) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw118) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 120/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw119 rwState

func (w *rw119) Unwrap() http.ResponseWriter { return w.w }
func (w *rw119) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw119) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw119) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw119) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw119) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw119) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw119) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw119) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw119) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 121/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
type rw120 rwState

func (w *rw120) Unwrap() http.ResponseWriter { return w.w }
func (w *rw120) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw120) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw120) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw120) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw120) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw120) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw120) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw120) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 122/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw121 rwState

func (w *rw121) Unwrap() http.ResponseWriter { return w.w }
func (w *rw121) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw121) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw121) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw121) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw121) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw121) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw121) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw121) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw121) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 123/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw122 rwState

func (w *rw122) Unwrap() http.ResponseWriter { return w.w }
func (w *rw122) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw122) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw122) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw122) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw122) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw122) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw122) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw122) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw122) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 124/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw123 rwState

func (w *rw123) Unwrap() http.ResponseWriter { return w.w }
func (w *rw123) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw123) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw123) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw123) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw123) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw123) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw123) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw123) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw123) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw123) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 125/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw124 rwState

func (w *rw124) Unwrap() http.ResponseWriter { return w.w }
func (w *rw124) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw124) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw124) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw124) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw124) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw124) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw124) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw124) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw124) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 126/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw125 rwState

func (w *rw125) Unwrap() http.ResponseWriter { return w.w }
func (w *rw125) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw125) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw125) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw125) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw125) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw125) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw125) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw125) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw125) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw125) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 127/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw126 rwState

func (w *rw126) Unwrap() http.ResponseWriter { return w.w }
func (w *rw126) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw126) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw126) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw126) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw126) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw126) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw126) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw126) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw126) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw126) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 128/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw127 rwState

func (w *rw127) Unwrap() http.ResponseWriter { return w.w }
func (w *rw127) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw127) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw127) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw127) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw127) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw127) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw127) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw127) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw127) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw127) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw127) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 129/512: http.ResponseWriter, httpFlushError
type rw128 rwState

func (w *rw128) Unwrap() http.ResponseWriter { return w.w }
func (w *rw128) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw128) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw128) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw128) FlushError() error {
	return (*rwState)(w).doFlushError()
}

// combination 130/512: http.ResponseWriter, httpFlushError, io.StringWriter
type rw129 rwState

func (w *rw129) Unwrap() http.ResponseWriter { return w.w }
func (w *rw129) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw129) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw129) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw129) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw129) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 131/512: http.ResponseWriter, httpFlushError, http.Pusher
type rw130 rwState

func (w *rw130) Unwrap() http.ResponseWriter { return w.w }
func (w *rw130) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw130) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw130) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw130) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw130) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 132/512: http.ResponseWriter, httpFlushError, http.Pusher, io.StringWriter
type rw131 rwState

func (w *rw131) Unwrap() http.ResponseWriter { return w.w }
func (w *rw131) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw131) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw131) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw131) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw131) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw131) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 133/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler
type rw132 rwState

func (w *rw132) Unwrap() http.ResponseWriter { return w.w }
func (w *rw132) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw132) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw132) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw132) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw132) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 134/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, io.StringWriter
type rw133 rwState

func (w *rw133) Unwrap() http.ResponseWriter { return w.w }
func (w *rw133) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw133) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw133) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw133) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw133) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw133) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 135/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher
type rw134 rwState

func (w *rw134) Unwrap() http.ResponseWriter { return w.w }
func (w *rw134) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw134) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw134) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw134) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw134) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw134) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 136/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw135 rwState

func (w *rw135) Unwrap() http.ResponseWriter { return w.w }
func (w *rw135) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw135) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw135) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw135) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw135) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw135) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw135) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 137/512: http.ResponseWriter, httpFlushError, deadliner
type rw136 rwState

func (w *rw136) Unwrap() http.ResponseWriter { return w.w }
func (w *rw136) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw136) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw136) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw136) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw136) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw136) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 138/512: http.ResponseWriter, httpFlushError, deadliner, io.StringWriter
type rw137 rwState

func (w *rw137) Unwrap() http.ResponseWriter { return w.w }
func (w *rw137) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw137) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw137) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw137) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw137) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw137) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw137) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 139/512: http.ResponseWriter, httpFlushError, deadliner, http.Pusher
type rw138 rwState

func (w *rw138) Unwrap() http.ResponseWriter { return w.w }
func (w *rw138) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw138) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw138) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw138) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw138) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw138) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw138) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 140/512: http.ResponseWriter, httpFlushError, deadliner, http.Pusher, io.StringWriter
type rw139 rwState

func (w *rw139) Unwrap() http.ResponseWriter { return w.w }
func (w *rw139) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw139) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw139) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw139) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw139) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw139) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw139) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw139) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 141/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler
type rw140 rwState

func (w *rw140) Unwrap() http.ResponseWriter { return w.w }
func (w *rw140) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw140) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw140) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw140) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw140) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw140) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw140) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 142/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter
type rw141 rwState

func (w *rw141) Unwrap() http.ResponseWriter { return w.w }
func (w *rw141) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw141) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw141) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw141) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw141) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw141) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw141) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw141) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 143/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher
type rw142 rwState

func (w *rw142) Unwrap() http.ResponseWriter { return w.w }
func (w *rw142) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw142) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw142) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw142) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw142) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw142) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw142) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw142) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 144/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw143 rwState

func (w *rw143) Unwrap() http.ResponseWriter { return w.w }
func (w *rw143) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw143) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw143) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw143) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw143) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw143) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw143) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw143) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw143) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 145/512: http.ResponseWriter, httpFlushError, io.ReaderFrom
type rw144 rwState

func (w *rw144) Unwrap() http.ResponseWriter { return w.w }
func (w *rw144) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw144) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw144) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw144) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw144) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 146/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, io.StringWriter
type rw145 rwState

func (w *rw145) Unwrap() http.ResponseWriter { return w.w }
func (w *rw145) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw145) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw145) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw145) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw145) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw145) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 147/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher
type rw146 rwState

func (w *rw146) Unwrap() http.ResponseWriter { return w.w }
func (w *rw146) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw146) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw146) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw146) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw146) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw146) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 148/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter
type rw147 rwState

func (w *rw147) Unwrap() http.ResponseWriter { return w.w }
func (w *rw147) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw147) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw147) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw147) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw147) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw147) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw147) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 149/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler
type rw148 rwState

func (w *rw148) Unwrap() http.ResponseWriter { return w.w }
func (w *rw148) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw148) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw148) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw148) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw148) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw148) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 150/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw149 rwState

func (w *rw149) Unwrap() http.ResponseWriter { return w.w }
func (w *rw149) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw149) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw149) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw149) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw149) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw149) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw149) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 151/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw150 rwState

func (w *rw150) Unwrap() http.ResponseWriter { return w.w }
func (w *rw150) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw150) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw150) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw150) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw150) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw150) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw150) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 152/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw151 rwState

func (w *rw151) Unwrap() http.ResponseWriter { return w.w }
func (w *rw151) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw151) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw151) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw151) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw151) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw151) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw151) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw151) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 153/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner
type rw152 rwState

func (w *rw152) Unwrap() http.ResponseWriter { return w.w }
func (w *rw152) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw152) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw152) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw152) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw152) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw152) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw152) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 154/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter
type rw153 rwState

func (w *rw153) Unwrap() http.ResponseWriter { return w.w }
func (w *rw153) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw153) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw153) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw153) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw153) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw153) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw153) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw153) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 155/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher
type rw154 rwState

func (w *rw154) Unwrap() http.ResponseWriter { return w.w }
func (w *rw154) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw154) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw154) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw154) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw154) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw154) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw154) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw154) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 156/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw155 rwState

func (w *rw155) Unwrap() http.ResponseWriter { return w.w }
func (w *rw155) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw155) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw155) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw155) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw155) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw155) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw155) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw155) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw155) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 157/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw156 rwState

func (w *rw156) Unwrap() http.ResponseWriter { return w.w }
func (w *rw156) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw156) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw156) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw156) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw156) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw156) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw156) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw156) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 158/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw157 rwState

func (w *rw157) Unwrap() http.ResponseWriter { return w.w }
func (w *rw157) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw157) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw157) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw157) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw157) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw157) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw157) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw157) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw157) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 159/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw158 rwState

func (w *rw158) Unwrap() http.ResponseWriter { return w.w }
func (w *rw158) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw158) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw158) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw158) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw158) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw158) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw158) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw158) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw158) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 160/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw159 rwState

func (w *rw159) Unwrap() http.ResponseWriter { return w.w }
func (w *rw159) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw159) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw159) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw159) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw159) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw159) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw159) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw159) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw159) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw159) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 161/512: http.ResponseWriter, httpFlushError, http.Hijacker
type rw160 rwState

func (w *rw160) Unwrap() http.ResponseWriter { return w.w }
func (w *rw160) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw160) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw160) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw160) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw160) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 162/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.StringWriter
type rw161 rwState

func (w *rw161) Unwrap() http.ResponseWriter { return w.w }
func (w *rw161) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw161) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw161) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw161) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw161) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw161) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 163/512: http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher
type rw162 rwState

func (w *rw162) Unwrap() http.ResponseWriter { return w.w }
func (w *rw162) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw162) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw162) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw162) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw162) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw162) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 164/512: http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter
type rw163 rwState

func (w *rw163) Unwrap() http.ResponseWriter { return w.w }
func (w *rw163) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw163) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw163) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw163) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw163) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw163) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw163) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 165/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler
type rw164 rwState

func (w *rw164) Unwrap() http.ResponseWriter { return w.w }
func (w *rw164) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw164) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw164) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw164) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw164) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw164) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 166/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw165 rwState

func (w *rw165) Unwrap() http.ResponseWriter { return w.w }
func (w *rw165) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw165) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw165) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw165) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw165) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw165) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw165) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 167/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw166 rwState

func (w *rw166) Unwrap() http.ResponseWriter { return w.w }
func (w *rw166) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw166) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw166) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw166) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw166) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw166) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw166) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 168/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw167 rwState

func (w *rw167) Unwrap() http.ResponseWriter { return w.w }
func (w *rw167) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw167) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw167) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw167) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw167) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw167) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw167) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw167) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 169/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner
type rw168 rwState

func (w *rw168) Unwrap() http.ResponseWriter { return w.w }
func (w *rw168) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw168) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw168) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw168) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw168) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw168) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw168) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 170/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, io.StringWriter
type rw169 rwState

func (w *rw169) Unwrap() http.ResponseWriter { return w.w }
func (w *rw169) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw169) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw169) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw169) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw169) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw169) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw169) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw169) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 171/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher
type rw170 rwState

func (w *rw170) Unwrap() http.ResponseWriter { return w.w }
func (w *rw170) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw170) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw170) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw170) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw170) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw170) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw170) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw170) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 172/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw171 rwState

func (w *rw171) Unwrap() http.ResponseWriter { return w.w }
func (w *rw171) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw171) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw171) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw171) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw171) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw171) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw171) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw171) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw171) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 173/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler
type rw172 rwState

func (w *rw172) Unwrap() http.ResponseWriter { return w.w }
func (w *rw172) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw172) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw172) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw172) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw172) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw172) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw172) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw172) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 174/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw173 rwState

func (w *rw173) Unwrap() http.ResponseWriter { return w.w }
func (w *rw173) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw173) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw173) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw173) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw173) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw173) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw173) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw173) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw173) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 175/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw174 rwState

func (w *rw174) Unwrap() http.ResponseWriter { return w.w }
func (w *rw174) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw174) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw174) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw174) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw174) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw174) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw174) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw174) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw174) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 176/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw175 rwState

func (w *rw175) Unwrap() http.ResponseWriter { return w.w }
func (w *rw175) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw175) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw175) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw175) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw175) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw175) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw175) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw175) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw175) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw175) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 177/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom
type rw176 rwState

func (w *rw176) Unwrap() http.ResponseWriter { return w.w }
func (w *rw176) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw176) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw176) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw176) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw176) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw176) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 178/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw177 rwState

func (w *rw177) Unwrap() http.ResponseWriter { return w.w }
func (w *rw177) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw177) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw177) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw177) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw177) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw177) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw177) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 179/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher
type rw178 rwState

func (w *rw178) Unwrap() http.ResponseWriter { return w.w }
func (w *rw178) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw178) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw178) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw178) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw178) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw178) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw178) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 180/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw179 rwState

func (w *rw179) Unwrap() http.ResponseWriter { return w.w }
func (w *rw179) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw179) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw179) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw179) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw179) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw179) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw179) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw179) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 181/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw180 rwState

func (w *rw180) Unwrap() http.ResponseWriter { return w.w }
func (w *rw180) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw180) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw180) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw180) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw180) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw180) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw180) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 182/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw181 rwState

func (w *rw181) Unwrap() http.ResponseWriter { return w.w }
func (w *rw181) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw181) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw181) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw181) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw181) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw181) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw181) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw181) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 183/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw182 rwState

func (w *rw182) Unwrap() http.ResponseWriter { return w.w }
func (w *rw182) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw182) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw182) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw182) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw182) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw182) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw182) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw182) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 184/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw183 rwState

func (w *rw183) Unwrap() http.ResponseWriter { return w.w }
func (w *rw183) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw183) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw183) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw183) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw183) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw183) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw183) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw183) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw183) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 185/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner
type rw184 rwState

func (w *rw184) Unwrap() http.ResponseWriter { return w.w }
func (w *rw184) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw184) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw184) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw184) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw184) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw184) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw184) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw184) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 186/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw185 rwState

func (w *rw185) Unwrap() http.ResponseWriter { return w.w }
func (w *rw185) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw185) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw185) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw185) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw185) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw185) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw185) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw185) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw185) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 187/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw186 rwState

func (w *rw186) Unwrap() http.ResponseWriter { return w.w }
func (w *rw186) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw186) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw186) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw186) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw186) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw186) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw186) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw186) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw186) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 188/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw187 rwState

func (w *rw187) Unwrap() http.ResponseWriter { return w.w }
func (w *rw187) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw187) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw187) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw187) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw187) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw187) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw187) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw187) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw187) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw187) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 189/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw188 rwState

func (w *rw188) Unwrap() http.ResponseWriter { return w.w }
func (w *rw188) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw188) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw188) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw188) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw188) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw188) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw188) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw188) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw188) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 190/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw189 rwState

func (w *rw189) Unwrap() http.ResponseWriter { return w.w }
func (w *rw189) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw189) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw189) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw189) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw189) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw189) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw189) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw189) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw189) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw189) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 191/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw190 rwState

func (w *rw190) Unwrap() http.ResponseWriter { return w.w }
func (w *rw190) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw190) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw190) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw190) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw190) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw190) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw190) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw190) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw190) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw190) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 192/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw191 rwState

func (w *rw191) Unwrap() http.ResponseWriter { return w.w }
func (w *rw191) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw191) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw191) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw191) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw191) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw191) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw191) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw191) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw191) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw191) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw191) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 193/512: http.ResponseWriter, httpFlushError, http.CloseNotifier
type rw192 rwState

func (w *rw192) Unwrap() http.ResponseWriter { return w.w }
func (w *rw192) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw192) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw192) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw192) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw192) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}

// combination 194/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.StringWriter
type rw193 rwState

func (w *rw193) Unwrap() http.ResponseWriter { return w.w }
func (w *rw193) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw193) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw193) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw193) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw193) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw193) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 195/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher
type rw194 rwState

func (w *rw194) Unwrap() http.ResponseWriter { return w.w }
func (w *rw194) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw194) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw194) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw194) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw194) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw194) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 196/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter
type rw195 rwState

func (w *rw195) Unwrap() http.ResponseWriter { return w.w }
func (w *rw195) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw195) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw195) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw195) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw195) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw195) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw195) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 197/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler
type rw196 rwState

func (w *rw196) Unwrap() http.ResponseWriter { return w.w }
func (w *rw196) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw196) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw196) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw196) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw196) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw196) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 198/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
type rw197 rwState

func (w *rw197) Unwrap() http.ResponseWriter { return w.w }
func (w *rw197) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw197) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw197) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw197) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw197) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw197) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw197) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 199/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher
type rw198 rwState

func (w *rw198) Unwrap() http.ResponseWriter { return w.w }
func (w *rw198) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw198) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw198) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw198) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw198) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw198) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw198) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 200/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw199 rwState

func (w *rw199) Unwrap() http.ResponseWriter { return w.w }
func (w *rw199) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw199) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw199) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw199) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw199) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw199) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw199) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw199) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 201/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner
type rw200 rwState

func (w *rw200) Unwrap() http.ResponseWriter { return w.w }
func (w *rw200) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw200) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw200) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw200) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw200) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw200) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw200) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 202/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter
type rw201 rwState

func (w *rw201) Unwrap() http.ResponseWriter { return w.w }
func (w *rw201) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw201) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw201) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw201) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw201) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw201) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw201) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw201) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 203/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher
type rw202 rwState

func (w *rw202) Unwrap() http.ResponseWriter { return w.w }
func (w *rw202) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw202) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw202) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw202) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw202) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw202) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw202) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw202) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 204/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
type rw203 rwState

func (w *rw203) Unwrap() http.ResponseWriter { return w.w }
func (w *rw203) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw203) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw203) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw203) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw203) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw203) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw203) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw203) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw203) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 205/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler
type rw204 rwState

func (w *rw204) Unwrap() http.ResponseWriter { return w.w }
func (w *rw204) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw204) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw204) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw204) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw204) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw204) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw204) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw204) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 206/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
type rw205 rwState

func (w *rw205) Unwrap() http.ResponseWriter { return w.w }
func (w *rw205) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw205) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw205) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw205) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw205) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw205) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw205) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw205) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw205) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 207/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
type rw206 rwState

func (w *rw206) Unwrap() http.ResponseWriter { return w.w }
func (w *rw206) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw206) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw206) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw206) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw206) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw206) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw206) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw206) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw206) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 208/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw207 rwState

func (w *rw207) Unwrap() http.ResponseWriter { return w.w }
func (w *rw207) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw207) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw207) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw207) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw207) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw207) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw207) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw207) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw207) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw207) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 209/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom
type rw208 rwState

func (w *rw208) Unwrap() http.ResponseWriter { return w.w }
func (w *rw208) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw208) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw208) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw208) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw208) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw208) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 210/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter
type rw209 rwState

func (w *rw209) Unwrap() http.ResponseWriter { return w.w }
func (w *rw209) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw209) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw209) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw209) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw209) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw209) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw209) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 211/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher
type rw210 rwState

func (w *rw210) Unwrap() http.ResponseWriter { return w.w }
func (w *rw210) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw210) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw210) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw210) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw210) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw210) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw210) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 212/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
type rw211 rwState

func (w *rw211) Unwrap() http.ResponseWriter { return w.w }
func (w *rw211) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw211) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw211) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw211) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw211) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw211) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw211) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw211) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 213/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
type rw212 rwState

func (w *rw212) Unwrap() http.ResponseWriter { return w.w }
func (w *rw212) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw212) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw212) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw212) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw212) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw212) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw212) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 214/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw213 rwState

func (w *rw213) Unwrap() http.ResponseWriter { return w.w }
func (w *rw213) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw213) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw213) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw213) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw213) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw213) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw213) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw213) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 215/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw214 rwState

func (w *rw214) Unwrap() http.ResponseWriter { return w.w }
func (w *rw214) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw214) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw214) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw214) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw214) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw214) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw214) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw214) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 216/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw215 rwState

func (w *rw215) Unwrap() http.ResponseWriter { return w.w }
func (w *rw215) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw215) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw215) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw215) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw215) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw215) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw215) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw215) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw215) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 217/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner
type rw216 rwState

func (w *rw216) Unwrap() http.ResponseWriter { return w.w }
func (w *rw216) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw216) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw216) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw216) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw216) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw216) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw216) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw216) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 218/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
type rw217 rwState

func (w *rw217) Unwrap() http.ResponseWriter { return w.w }
func (w *rw217) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw217) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw217) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw217) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw217) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw217) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw217) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw217) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw217) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 219/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
type rw218 rwState

func (w *rw218) Unwrap() http.ResponseWriter { return w.w }
func (w *rw218) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw218) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw218) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw218) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw218) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw218) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw218) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw218) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw218) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 220/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw219 rwState

func (w *rw219) Unwrap() http.ResponseWriter { return w.w }
func (w *rw219) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw219) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw219) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw219) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw219) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw219) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw219) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw219) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw219) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw219) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 221/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw220 rwState

func (w *rw220) Unwrap() http.ResponseWriter { return w.w }
func (w *rw220) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw220) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw220) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw220) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw220) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw220) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw220) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw220) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw220) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 222/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw221 rwState

func (w *rw221) Unwrap() http.ResponseWriter { return w.w }
func (w *rw221) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw221) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw221) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw221) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw221) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw221) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw221) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw221) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw221) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw221) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 223/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw222 rwState

func (w *rw222) Unwrap() http.ResponseWriter { return w.w }
func (w *rw222) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw222) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw222) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw222) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw222) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw222) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw222) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw222) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw222) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw222) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 224/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw223 rwState

func (w *rw223) Unwrap() http.ResponseWriter { return w.w }
func (w *rw223) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw223) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw223) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw223) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw223) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw223) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw223) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw223) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw223) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw223) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw223) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 225/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker
type rw224 rwState

func (w *rw224) Unwrap() http.ResponseWriter { return w.w }
func (w *rw224) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw224) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw224) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw224) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw224) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw224) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 226/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter
type rw225 rwState

func (w *rw225) Unwrap() http.ResponseWriter { return w.w }
func (w *rw225) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw225) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw225) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw225) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw225) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw225) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw225) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 227/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher
type rw226 rwState

func (w *rw226) Unwrap() http.ResponseWriter { return w.w }
func (w *rw226) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw226) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw226) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw226) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw226) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw226) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw226) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 228/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
type rw227 rwState

func (w *rw227) Unwrap() http.ResponseWriter { return w.w }
func (w *rw227) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw227) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw227) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw227) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw227) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw227) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw227) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw227) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 229/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
type rw228 rwState

func (w *rw228) Unwrap() http.ResponseWriter { return w.w }
func (w *rw228) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw228) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw228) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw228) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw228) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw228) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw228) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 230/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw229 rwState

func (w *rw229) Unwrap() http.ResponseWriter { return w.w }
func (w *rw229) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw229) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw229) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw229) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw229) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw229) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw229) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw229) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 231/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw230 rwState

func (w *rw230) Unwrap() http.ResponseWriter { return w.w }
func (w *rw230) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw230) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw230) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw230) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw230) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw230) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw230) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw230) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 232/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw231 rwState

func (w *rw231) Unwrap() http.ResponseWriter { return w.w }
func (w *rw231) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw231) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw231) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw231) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw231) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw231) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw231) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw231) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw231) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 233/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner
type rw232 rwState

func (w *rw232) Unwrap() http.ResponseWriter { return w.w }
func (w *rw232) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw232) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw232) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw232) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw232) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw232) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw232) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw232) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 234/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
type rw233 rwState

func (w *rw233) Unwrap() http.ResponseWriter { return w.w }
func (w *rw233) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw233) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw233) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw233) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw233) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw233) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw233) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw233) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw233) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 235/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
type rw234 rwState

func (w *rw234) Unwrap() http.ResponseWriter { return w.w }
func (w *rw234) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw234) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw234) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw234) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw234) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw234) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw234) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw234) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw234) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 236/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw235 rwState

func (w *rw235) Unwrap() http.ResponseWriter { return w.w }
func (w *rw235) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw235) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw235) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw235) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw235) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw235) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw235) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw235) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw235) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw235) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 237/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
type rw236 rwState

func (w *rw236) Unwrap() http.ResponseWriter { return w.w }
func (w *rw236) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw236) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw236) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw236) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw236) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw236) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw236) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw236) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw236) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 238/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw237 rwState

func (w *rw237) Unwrap() http.ResponseWriter { return w.w }
func (w *rw237) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw237) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw237) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw237) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw237) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw237) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw237) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw237) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw237) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw237) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 239/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw238 rwState

func (w *rw238) Unwrap() http.ResponseWriter { return w.w }
func (w *rw238) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw238) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw238) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw238) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw238) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw238) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw238) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw238) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw238) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw238) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 240/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw239 rwState

func (w *rw239) Unwrap() http.ResponseWriter { return w.w }
func (w *rw239) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw239) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw239) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw239) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw239) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw239) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw239) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw239) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw239) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw239) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw239) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 241/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom
type rw240 rwState

func (w *rw240) Unwrap() http.ResponseWriter { return w.w }
func (w *rw240) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw240) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw240) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw240) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw240) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw240) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw240) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 242/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw241 rwState

func (w *rw241) Unwrap() http.ResponseWriter { return w.w }
func (w *rw241) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw241) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw241) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw241) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw241) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw241) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw241) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw241) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 243/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
type rw242 rwState

func (w *rw242) Unwrap() http.ResponseWriter { return w.w }
func (w *rw242) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw242) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw242) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw242) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw242) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw242) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw242) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw242) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 244/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw243 rwState

func (w *rw243) Unwrap() http.ResponseWriter { return w.w }
func (w *rw243) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw243) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw243) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw243) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw243) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw243) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw243) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw243) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw243) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 245/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw244 rwState

func (w *rw244) Unwrap() http.ResponseWriter { return w.w }
func (w *rw244) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw244) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw244) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw244) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw244) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw244) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw244) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw244) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 246/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw245 rwState

func (w *rw245) Unwrap() http.ResponseWriter { return w.w }
func (w *rw245) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw245) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw245) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw245) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw245) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw245) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw245) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw245) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw245) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 247/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw246 rwState

func (w *rw246) Unwrap() http.ResponseWriter { return w.w }
func (w *rw246) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw246) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw246) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw246) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw246) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw246) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw246) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw246) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw246) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 248/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw247 rwState

func (w *rw247) Unwrap() http.ResponseWriter { return w.w }
func (w *rw247) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw247) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw247) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw247) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw247) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw247) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw247) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw247) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw247) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw247) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 249/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
type rw248 rwState

func (w *rw248) Unwrap() http.ResponseWriter { return w.w }
func (w *rw248) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw248) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw248) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw248) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw248) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw248) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw248) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw248) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw248) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 250/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw249 rwState

func (w *rw249) Unwrap() http.ResponseWriter { return w.w }
func (w *rw249) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw249) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw249) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw249) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw249) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw249) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw249) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw249) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw249) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw249) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 251/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw250 rwState

func (w *rw250) Unwrap() http.ResponseWriter { return w.w }
func (w *rw250) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw250) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw250) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw250) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw250) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw250) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw250) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw250) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw250) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw250) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 252/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw251 rwState

func (w *rw251) Unwrap() http.ResponseWriter { return w.w }
func (w *rw251) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw251) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw251) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw251) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw251) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw251) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw251) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw251) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw251) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw251) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw251) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 253/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw252 rwState

func (w *rw252) Unwrap() http.ResponseWriter { return w.w }
func (w *rw252) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw252) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw252) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw252) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw252) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw252) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw252) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw252) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw252) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw252) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 254/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw253 rwState

func (w *rw253) Unwrap() http.ResponseWriter { return w.w }
func (w *rw253) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw253) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw253) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw253) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw253) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw253) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw253) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw253) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw253) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw253) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw253) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 255/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw254 rwState

func (w *rw254) Unwrap() http.ResponseWriter { return w.w }
func (w *rw254) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw254) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw254) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw254) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw254) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw254) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw254) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw254) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw254) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw254) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw254) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 256/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw255 rwState

func (w *rw255) Unwrap() http.ResponseWriter { return w.w }
func (w *rw255) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw255) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw255) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw255) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw255) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw255) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw255) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw255) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw255) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw255) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw255) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw255) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 257/512: http.ResponseWriter, http.Flusher
type rw256 rwState

func (w *rw256) Unwrap() http.ResponseWriter { return w.w }
func (w *rw256) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw256) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw256) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw256) Flush() {
	(*rwState)(w).doFlush()
}

// combination 258/512: http.ResponseWriter, http.Flusher, io.StringWriter
type rw257 rwState

func (w *rw257) Unwrap() http.ResponseWriter { return w.w }
func (w *rw257) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw257) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw257) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw257) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw257) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 259/512: http.ResponseWriter, http.Flusher, http.Pusher
type rw258 rwState

func (w *rw258) Unwrap() http.ResponseWriter { return w.w }
func (w *rw258) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw258) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw258) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw258) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw258) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 260/512: http.ResponseWriter, http.Flusher, http.Pusher, io.StringWriter
type rw259 rwState

func (w *rw259) Unwrap() http.ResponseWriter { return w.w }
func (w *rw259) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw259) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw259) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw259) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw259) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw259) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 261/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler
type rw260 rwState

func (w *rw260) Unwrap() http.ResponseWriter { return w.w }
func (w *rw260) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw260) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw260) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw260) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw260) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 262/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, io.StringWriter
type rw261 rwState

func (w *rw261) Unwrap() http.ResponseWriter { return w.w }
func (w *rw261) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw261) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw261) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw261) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw261) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw261) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 263/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher
type rw262 rwState

func (w *rw262) Unwrap() http.ResponseWriter { return w.w }
func (w *rw262) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw262) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw262) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw262) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw262) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw262) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 264/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw263 rwState

func (w *rw263) Unwrap() http.ResponseWriter { return w.w }
func (w *rw263) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw263) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw263) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw263) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw263) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw263) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw263) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 265/512: http.ResponseWriter, http.Flusher, deadliner
type rw264 rwState

func (w *rw264) Unwrap() http.ResponseWriter { return w.w }
func (w *rw264) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw264) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw264) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw264) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw264) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw264) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 266/512: http.ResponseWriter, http.Flusher, deadliner, io.StringWriter
type rw265 rwState

func (w *rw265) Unwrap() http.ResponseWriter { return w.w }
func (w *rw265) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw265) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw265) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw265) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw265) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw265) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw265) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 267/512: http.ResponseWriter, http.Flusher, deadliner, http.Pusher
type rw266 rwState

func (w *rw266) Unwrap() http.ResponseWriter { return w.w }
func (w *rw266) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw266) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw266) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw266) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw266) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw266) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw266) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 268/512: http.ResponseWriter, http.Flusher, deadliner, http.Pusher, io.StringWriter
type rw267 rwState

func (w *rw267) Unwrap() http.ResponseWriter { return w.w }
func (w *rw267) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw267) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw267) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw267) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw267) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw267) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw267) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw267) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 269/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler
type rw268 rwState

func (w *rw268) Unwrap() http.ResponseWriter { return w.w }
func (w *rw268) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw268) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw268) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw268) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw268) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw268) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw268) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 270/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, io.StringWriter
type rw269 rwState

func (w *rw269) Unwrap() http.ResponseWriter { return w.w }
func (w *rw269) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw269) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw269) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw269) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw269) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw269) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw269) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw269) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 271/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher
type rw270 rwState

func (w *rw270) Unwrap() http.ResponseWriter { return w.w }
func (w *rw270) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw270) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw270) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw270) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw270) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw270) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw270) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw270) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 272/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw271 rwState

func (w *rw271) Unwrap() http.ResponseWriter { return w.w }
func (w *rw271) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw271) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw271) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw271) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw271) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw271) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw271) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw271) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw271) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 273/512: http.ResponseWriter, http.Flusher, io.ReaderFrom
type rw272 rwState

func (w *rw272) Unwrap() http.ResponseWriter { return w.w }
func (w *rw272) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw272) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw272) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw272) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw272) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 274/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, io.StringWriter
type rw273 rwState

func (w *rw273) Unwrap() http.ResponseWriter { return w.w }
func (w *rw273) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw273) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw273) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw273) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw273) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw273) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 275/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher
type rw274 rwState

func (w *rw274) Unwrap() http.ResponseWriter { return w.w }
func (w *rw274) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw274) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw274) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw274) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw274) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw274) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 276/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher, io.StringWriter
type rw275 rwState

func (w *rw275) Unwrap() http.ResponseWriter { return w.w }
func (w *rw275) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw275) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw275) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw275) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw275) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw275) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw275) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 277/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler
type rw276 rwState

func (w *rw276) Unwrap() http.ResponseWriter { return w.w }
func (w *rw276) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw276) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw276) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw276) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw276) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw276) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 278/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw277 rwState

func (w *rw277) Unwrap() http.ResponseWriter { return w.w }
func (w *rw277) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw277) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw277) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw277) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw277) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw277) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw277) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 279/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw278 rwState

func (w *rw278) Unwrap() http.ResponseWriter { return w.w }
func (w *rw278) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw278) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw278) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw278) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw278) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw278) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw278) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 280/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw279 rwState

func (w *rw279) Unwrap() http.ResponseWriter { return w.w }
func (w *rw279) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw279) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw279) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw279) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw279) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw279) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw279) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw279) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 281/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner
type rw280 rwState

func (w *rw280) Unwrap() http.ResponseWriter { return w.w }
func (w *rw280) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw280) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw280) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw280) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw280) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw280) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw280) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 282/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, io.StringWriter
type rw281 rwState

func (w *rw281) Unwrap() http.ResponseWriter { return w.w }
func (w *rw281) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw281) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw281) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw281) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw281) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw281) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw281) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw281) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 283/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher
type rw282 rwState

func (w *rw282) Unwrap() http.ResponseWriter { return w.w }
func (w *rw282) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw282) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw282) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw282) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw282) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw282) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw282) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw282) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 284/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw283 rwState

func (w *rw283) Unwrap() http.ResponseWriter { return w.w }
func (w *rw283) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw283) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw283) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw283) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw283) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw283) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw283) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw283) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw283) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 285/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw284 rwState

func (w *rw284) Unwrap() http.ResponseWriter { return w.w }
func (w *rw284) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw284) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw284) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw284) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw284) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw284) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw284) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw284) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 286/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw285 rwState

func (w *rw285) Unwrap() http.ResponseWriter { return w.w }
func (w *rw285) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw285) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw285) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw285) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw285) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw285) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw285) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw285) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw285) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 287/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw286 rwState

func (w *rw286) Unwrap() http.ResponseWriter { return w.w }
func (w *rw286) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw286) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw286) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw286) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw286) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw286) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw286) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw286) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw286) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 288/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw287 rwState

func (w *rw287) Unwrap() http.ResponseWriter { return w.w }
func (w *rw287) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw287) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw287) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw287) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw287) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw287) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw287) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw287) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw287) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw287) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 289/512: http.ResponseWriter, http.Flusher, http.Hijacker
type rw288 rwState

func (w *rw288) Unwrap() http.ResponseWriter { return w.w }
func (w *rw288) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw288) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw288) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw288) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw288) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 290/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.StringWriter
type rw289 rwState

func (w *rw289) Unwrap() http.ResponseWriter { return w.w }
func (w *rw289) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw289) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw289) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw289) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw289) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw289) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 291/512: http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher
type rw290 rwState

func (w *rw290) Unwrap() http.ResponseWriter { return w.w }
func (w *rw290) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw290) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw290) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw290) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw290) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw290) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 292/512: http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher, io.StringWriter
type rw291 rwState

func (w *rw291) Unwrap() http.ResponseWriter { return w.w }
func (w *rw291) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw291) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw291) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw291) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw291) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw291) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw291) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 293/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler
type rw292 rwState

func (w *rw292) Unwrap() http.ResponseWriter { return w.w }
func (w *rw292) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw292) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw292) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw292) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw292) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw292) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 294/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw293 rwState

func (w *rw293) Unwrap() http.ResponseWriter { return w.w }
func (w *rw293) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw293) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw293) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw293) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw293) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw293) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw293) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 295/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw294 rwState

func (w *rw294) Unwrap() http.ResponseWriter { return w.w }
func (w *rw294) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw294) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw294) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw294) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw294) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw294) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw294) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 296/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw295 rwState

func (w *rw295) Unwrap() http.ResponseWriter { return w.w }
func (w *rw295) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw295) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw295) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw295) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw295) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw295) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw295) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw295) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 297/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner
type rw296 rwState

func (w *rw296) Unwrap() http.ResponseWriter { return w.w }
func (w *rw296) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw296) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw296) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw296) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw296) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw296) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw296) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 298/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, io.StringWriter
type rw297 rwState

func (w *rw297) Unwrap() http.ResponseWriter { return w.w }
func (w *rw297) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw297) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw297) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw297) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw297) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw297) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw297) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw297) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 299/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher
type rw298 rwState

func (w *rw298) Unwrap() http.ResponseWriter { return w.w }
func (w *rw298) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw298) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw298) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw298) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw298) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw298) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw298) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw298) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 300/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw299 rwState

func (w *rw299) Unwrap() http.ResponseWriter { return w.w }
func (w *rw299) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw299) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw299) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw299) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw299) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw299) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw299) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw299) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw299) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 301/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler
type rw300 rwState

func (w *rw300) Unwrap() http.ResponseWriter { return w.w }
func (w *rw300) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw300) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw300) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw300) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw300) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw300) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw300) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw300) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 302/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw301 rwState

func (w *rw301) Unwrap() http.ResponseWriter { return w.w }
func (w *rw301) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw301) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw301) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw301) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw301) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw301) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw301) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw301) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw301) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 303/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw302 rwState

func (w *rw302) Unwrap() http.ResponseWriter { return w.w }
func (w *rw302) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw302) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw302) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw302) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw302) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw302) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw302) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw302) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw302) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 304/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw303 rwState

func (w *rw303) Unwrap() http.ResponseWriter { return w.w }
func (w *rw303) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw303) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw303) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw303) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw303) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw303) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw303) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw303) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw303) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw303) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 305/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom
type rw304 rwState

func (w *rw304) Unwrap() http.ResponseWriter { return w.w }
func (w *rw304) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw304) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw304) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw304) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw304) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw304) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 306/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw305 rwState

func (w *rw305) Unwrap() http.ResponseWriter { return w.w }
func (w *rw305) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw305) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw305) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw305) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw305) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw305) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw305) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 307/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher
type rw306 rwState

func (w *rw306) Unwrap() http.ResponseWriter { return w.w }
func (w *rw306) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw306) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw306) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw306) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw306) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw306) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw306) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 308/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw307 rwState

func (w *rw307) Unwrap() http.ResponseWriter { return w.w }
func (w *rw307) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw307) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw307) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw307) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw307) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw307) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw307) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw307) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 309/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw308 rwState

func (w *rw308) Unwrap() http.ResponseWriter { return w.w }
func (w *rw308) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw308) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw308) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw308) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw308) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw308) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw308) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 310/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw309 rwState

func (w *rw309) Unwrap() http.ResponseWriter { return w.w }
func (w *rw309) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw309) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw309) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw309) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw309) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw309) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw309) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw309) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 311/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw310 rwState

func (w *rw310) Unwrap() http.ResponseWriter { return w.w }
func (w *rw310) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw310) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw310) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw310) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw310) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw310) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw310) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw310) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 312/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw311 rwState

func (w *rw311) Unwrap() http.ResponseWriter { return w.w }
func (w *rw311) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw311) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw311) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw311) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw311) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw311) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw311) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw311) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw311) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 313/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner
type rw312 rwState

func (w *rw312) Unwrap() http.ResponseWriter { return w.w }
func (w *rw312) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw312) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw312) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw312) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw312) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw312) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw312) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw312) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 314/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw313 rwState

func (w *rw313) Unwrap() http.ResponseWriter { return w.w }
func (w *rw313) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw313) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw313) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw313) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw313) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw313) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw313) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw313) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw313) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 315/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw314 rwState

func (w *rw314) Unwrap() http.ResponseWriter { return w.w }
func (w *rw314) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw314) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw314) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw314) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw314) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw314) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw314) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw314) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw314) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 316/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw315 rwState

func (w *rw315) Unwrap() http.ResponseWriter { return w.w }
func (w *rw315) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw315) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw315) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw315) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw315) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw315) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw315) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw315) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw315) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw315) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 317/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw316 rwState

func (w *rw316) Unwrap() http.ResponseWriter { return w.w }
func (w *rw316) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw316) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw316) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw316) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw316) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw316) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw316) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw316) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw316) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 318/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw317 rwState

func (w *rw317) Unwrap() http.ResponseWriter { return w.w }
func (w *rw317) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw317) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw317) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw317) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw317) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw317) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw317) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw317) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw317) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw317) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 319/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw318 rwState

func (w *rw318) Unwrap() http.ResponseWriter { return w.w }
func (w *rw318) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw318) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw318) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw318) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw318) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw318) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw318) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw318) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw318) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw318) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 320/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw319 rwState

func (w *rw319) Unwrap() http.ResponseWriter { return w.w }
func (w *rw319) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw319) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw319) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw319) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw319) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw319) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw319) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw319) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw319) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw319) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw319) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 321/512: http.ResponseWriter, http.Flusher, http.CloseNotifier
type rw320 rwState

func (w *rw320) Unwrap() http.ResponseWriter { return w.w }
func (w *rw320) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw320) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw320) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw320) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw320) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}

// combination 322/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.StringWriter
type rw321 rwState

func (w *rw321) Unwrap() http.ResponseWriter { return w.w }
func (w *rw321) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw321) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw321) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw321) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw321) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw321) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 323/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher
type rw322 rwState

func (w *rw322) Unwrap() http.ResponseWriter { return w.w }
func (w *rw322) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw322) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw322) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw322) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw322) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw322) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 324/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher, io.StringWriter
type rw323 rwState

func (w *rw323) Unwrap() http.ResponseWriter { return w.w }
func (w *rw323) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw323) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw323) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw323) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw323) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw323) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw323) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 325/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler
type rw324 rwState

func (w *rw324) Unwrap() http.ResponseWriter { return w.w }
func (w *rw324) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw324) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw324) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw324) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw324) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw324) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 326/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
type rw325 rwState

func (w *rw325) Unwrap() http.ResponseWriter { return w.w }
func (w *rw325) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw325) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw325) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw325) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw325) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw325) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw325) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 327/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher
type rw326 rwState

func (w *rw326) Unwrap() http.ResponseWriter { return w.w }
func (w *rw326) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw326) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw326) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw326) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw326) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw326) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw326) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 328/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw327 rwState

func (w *rw327) Unwrap() http.ResponseWriter { return w.w }
func (w *rw327) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw327) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw327) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw327) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw327) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw327) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw327) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw327) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 329/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner
type rw328 rwState

func (w *rw328) Unwrap() http.ResponseWriter { return w.w }
func (w *rw328) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw328) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw328) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw328) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw328) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw328) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw328) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 330/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, io.StringWriter
type rw329 rwState

func (w *rw329) Unwrap() http.ResponseWriter { return w.w }
func (w *rw329) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw329) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw329) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw329) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw329) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw329) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw329) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw329) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 331/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher
type rw330 rwState

func (w *rw330) Unwrap() http.ResponseWriter { return w.w }
func (w *rw330) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw330) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw330) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw330) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw330) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw330) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw330) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw330) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 332/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
type rw331 rwState

func (w *rw331) Unwrap() http.ResponseWriter { return w.w }
func (w *rw331) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw331) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw331) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw331) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw331) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw331) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw331) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw331) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw331) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 333/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler
type rw332 rwState

func (w *rw332) Unwrap() http.ResponseWriter { return w.w }
func (w *rw332) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw332) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw332) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw332) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw332) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw332) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw332) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw332) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 334/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
type rw333 rwState

func (w *rw333) Unwrap() http.ResponseWriter { return w.w }
func (w *rw333) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw333) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw333) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw333) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw333) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw333) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw333) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw333) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw333) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 335/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
type rw334 rwState

func (w *rw334) Unwrap() http.ResponseWriter { return w.w }
func (w *rw334) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw334) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw334) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw334) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw334) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw334) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw334) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw334) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw334) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 336/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw335 rwState

func (w *rw335) Unwrap() http.ResponseWriter { return w.w }
func (w *rw335) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw335) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw335) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw335) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw335) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw335) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw335) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw335) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw335) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw335) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 337/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom
type rw336 rwState

func (w *rw336) Unwrap() http.ResponseWriter { return w.w }
func (w *rw336) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw336) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw336) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw336) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw336) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw336) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 338/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, io.StringWriter
type rw337 rwState

func (w *rw337) Unwrap() http.ResponseWriter { return w.w }
func (w *rw337) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw337) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw337) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw337) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw337) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw337) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw337) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 339/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher
type rw338 rwState

func (w *rw338) Unwrap() http.ResponseWriter { return w.w }
func (w *rw338) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw338) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw338) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw338) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw338) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw338) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw338) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 340/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
type rw339 rwState

func (w *rw339) Unwrap() http.ResponseWriter { return w.w }
func (w *rw339) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw339) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw339) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw339) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw339) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw339) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw339) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw339) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 341/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
type rw340 rwState

func (w *rw340) Unwrap() http.ResponseWriter { return w.w }
func (w *rw340) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw340) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw340) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw340) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw340) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw340) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw340) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 342/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw341 rwState

func (w *rw341) Unwrap() http.ResponseWriter { return w.w }
func (w *rw341) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw341) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw341) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw341) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw341) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw341) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw341) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw341) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 343/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw342 rwState

func (w *rw342) Unwrap() http.ResponseWriter { return w.w }
func (w *rw342) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw342) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw342) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw342) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw342) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw342) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw342) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw342) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 344/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw343 rwState

func (w *rw343) Unwrap() http.ResponseWriter { return w.w }
func (w *rw343) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw343) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw343) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw343) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw343) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw343) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw343) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw343) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw343) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 345/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner
type rw344 rwState

func (w *rw344) Unwrap() http.ResponseWriter { return w.w }
func (w *rw344) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw344) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw344) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw344) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw344) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw344) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw344) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw344) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 346/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
type rw345 rwState

func (w *rw345) Unwrap() http.ResponseWriter { return w.w }
func (w *rw345) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw345) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw345) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw345) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw345) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw345) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw345) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw345) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw345) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 347/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
type rw346 rwState

func (w *rw346) Unwrap() http.ResponseWriter { return w.w }
func (w *rw346) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw346) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw346) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw346) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw346) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw346) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw346) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw346) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw346) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 348/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw347 rwState

func (w *rw347) Unwrap() http.ResponseWriter { return w.w }
func (w *rw347) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw347) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw347) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw347) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw347) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw347) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw347) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw347) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw347) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw347) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 349/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw348 rwState

func (w *rw348) Unwrap() http.ResponseWriter { return w.w }
func (w *rw348) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw348) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw348) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw348) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw348) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw348) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw348) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw348) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw348) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 350/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw349 rwState

func (w *rw349) Unwrap() http.ResponseWriter { return w.w }
func (w *rw349) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw349) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw349) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw349) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw349) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw349) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw349) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw349) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw349) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw349) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 351/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw350 rwState

func (w *rw350) Unwrap() http.ResponseWriter { return w.w }
func (w *rw350) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw350) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw350) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw350) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw350) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw350) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw350) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw350) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw350) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw350) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 352/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw351 rwState

func (w *rw351) Unwrap() http.ResponseWriter { return w.w }
func (w *rw351) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw351) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw351) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw351) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw351) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw351) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw351) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw351) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw351) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw351) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw351) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 353/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker
type rw352 rwState

func (w *rw352) Unwrap() http.ResponseWriter { return w.w }
func (w *rw352) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw352) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw352) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw352) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw352) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw352) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 354/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.StringWriter
type rw353 rwState

func (w *rw353) Unwrap() http.ResponseWriter { return w.w }
func (w *rw353) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw353) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw353) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw353) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw353) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw353) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw353) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 355/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher
type rw354 rwState

func (w *rw354) Unwrap() http.ResponseWriter { return w.w }
func (w *rw354) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw354) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw354) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw354) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw354) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw354) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw354) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 356/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
type rw355 rwState

func (w *rw355) Unwrap() http.ResponseWriter { return w.w }
func (w *rw355) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw355) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw355) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw355) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw355) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw355) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw355) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw355) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 357/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
type rw356 rwState

func (w *rw356) Unwrap() http.ResponseWriter { return w.w }
func (w *rw356) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw356) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw356) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw356) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw356) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw356) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw356) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 358/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw357 rwState

func (w *rw357) Unwrap() http.ResponseWriter { return w.w }
func (w *rw357) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw357) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw357) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw357) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw357) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw357) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw357) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw357) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 359/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw358 rwState

func (w *rw358) Unwrap() http.ResponseWriter { return w.w }
func (w *rw358) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw358) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw358) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw358) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw358) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw358) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw358) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw358) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 360/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw359 rwState

func (w *rw359) Unwrap() http.ResponseWriter { return w.w }
func (w *rw359) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw359) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw359) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw359) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw359) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw359) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw359) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw359) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw359) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 361/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner
type rw360 rwState

func (w *rw360) Unwrap() http.ResponseWriter { return w.w }
func (w *rw360) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw360) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw360) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw360) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw360) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw360) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw360) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw360) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 362/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
type rw361 rwState

func (w *rw361) Unwrap() http.ResponseWriter { return w.w }
func (w *rw361) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw361) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw361) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw361) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw361) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw361) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw361) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw361) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw361) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 363/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
type rw362 rwState

func (w *rw362) Unwrap() http.ResponseWriter { return w.w }
func (w *rw362) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw362) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw362) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw362) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw362) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw362) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw362) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw362) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw362) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 364/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw363 rwState

func (w *rw363) Unwrap() http.ResponseWriter { return w.w }
func (w *rw363) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw363) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw363) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw363) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw363) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw363) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw363) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw363) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw363) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw363) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 365/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
type rw364 rwState

func (w *rw364) Unwrap() http.ResponseWriter { return w.w }
func (w *rw364) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw364) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw364) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw364) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw364) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw364) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw364) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw364) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw364) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 366/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw365 rwState

func (w *rw365) Unwrap() http.ResponseWriter { return w.w }
func (w *rw365) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw365) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw365) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw365) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw365) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw365) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw365) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw365) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw365) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw365) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 367/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw366 rwState

func (w *rw366) Unwrap() http.ResponseWriter { return w.w }
func (w *rw366) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw366) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw366) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw366) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw366) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw366) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw366) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw366) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw366) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw366) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 368/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw367 rwState

func (w *rw367) Unwrap() http.ResponseWriter { return w.w }
func (w *rw367) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw367) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw367) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw367) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw367) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw367) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw367) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw367) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw367) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw367) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw367) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 369/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom
type rw368 rwState

func (w *rw368) Unwrap() http.ResponseWriter { return w.w }
func (w *rw368) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw368) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw368) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw368) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw368) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw368) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw368) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 370/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw369 rwState

func (w *rw369) Unwrap() http.ResponseWriter { return w.w }
func (w *rw369) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw369) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw369) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw369) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw369) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw369) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw369) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw369) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 371/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
type rw370 rwState

func (w *rw370) Unwrap() http.ResponseWriter { return w.w }
func (w *rw370) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw370) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw370) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw370) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw370) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw370) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw370) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw370) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 372/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw371 rwState

func (w *rw371) Unwrap() http.ResponseWriter { return w.w }
func (w *rw371) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw371) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw371) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw371) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw371) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw371) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw371) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw371) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw371) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 373/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw372 rwState

func (w *rw372) Unwrap() http.ResponseWriter { return w.w }
func (w *rw372) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw372) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw372) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw372) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw372) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw372) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw372) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw372) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 374/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw373 rwState

func (w *rw373) Unwrap() http.ResponseWriter { return w.w }
func (w *rw373) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw373) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw373) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw373) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw373) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw373) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw373) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw373) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw373) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 375/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw374 rwState

func (w *rw374) Unwrap() http.ResponseWriter { return w.w }
func (w *rw374) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw374) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw374) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw374) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw374) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw374) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw374) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw374) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw374) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 376/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw375 rwState

func (w *rw375) Unwrap() http.ResponseWriter { return w.w }
func (w *rw375) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw375) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw375) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw375) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw375) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw375) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw375) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw375) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw375) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw375) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 377/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
type rw376 rwState

func (w *rw376) Unwrap() http.ResponseWriter { return w.w }
func (w *rw376) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw376) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw376) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw376) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw376) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw376) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw376) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw376) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw376) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 378/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw377 rwState

func (w *rw377) Unwrap() http.ResponseWriter { return w.w }
func (w *rw377) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw377) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw377) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw377) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw377) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw377) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw377) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw377) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw377) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw377) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 379/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw378 rwState

func (w *rw378) Unwrap() http.ResponseWriter { return w.w }
func (w *rw378) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw378) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw378) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw378) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw378) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw378) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw378) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw378) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw378) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw378) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 380/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw379 rwState

func (w *rw379) Unwrap() http.ResponseWriter { return w.w }
func (w *rw379) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw379) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw379) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw379) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw379) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw379) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw379) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw379) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw379) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw379) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw379) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 381/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw380 rwState

func (w *rw380) Unwrap() http.ResponseWriter { return w.w }
func (w *rw380) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw380) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw380) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw380) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw380) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw380) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw380) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw380) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw380) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw380) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 382/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw381 rwState

func (w *rw381) Unwrap() http.ResponseWriter { return w.w }
func (w *rw381) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw381) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw381) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw381) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw381) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw381) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw381) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw381) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw381) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw381) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw381) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 383/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw382 rwState

func (w *rw382) Unwrap() http.ResponseWriter { return w.w }
func (w *rw382) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw382) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw382) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw382) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw382) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw382) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw382) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw382) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw382) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw382) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw382) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 384/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw383 rwState

func (w *rw383) Unwrap() http.ResponseWriter { return w.w }
func (w *rw383) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw383) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw383) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw383) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw383) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw383) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw383) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw383) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw383) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw383) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw383) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw383) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 385/512: http.ResponseWriter, http.Flusher, httpFlushError
type rw384 rwState

func (w *rw384) Unwrap() http.ResponseWriter { return w.w }
func (w *rw384) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw384) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw384) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw384) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw384) FlushError() error {
	return (*rwState)(w).doFlushError()
}

// combination 386/512: http.ResponseWriter, http.Flusher, httpFlushError, io.StringWriter
type rw385 rwState

func (w *rw385) Unwrap() http.ResponseWriter { return w.w }
func (w *rw385) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw385) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw385) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw385) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw385) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw385) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 387/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher
type rw386 rwState

func (w *rw386) Unwrap() http.ResponseWriter { return w.w }
func (w *rw386) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw386) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw386) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw386) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw386) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw386) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 388/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher, io.StringWriter
type rw387 rwState

func (w *rw387) Unwrap() http.ResponseWriter { return w.w }
func (w *rw387) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw387) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw387) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw387) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw387) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw387) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw387) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 389/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler
type rw388 rwState

func (w *rw388) Unwrap() http.ResponseWriter { return w.w }
func (w *rw388) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw388) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw388) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw388) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw388) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw388) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 390/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, io.StringWriter
type rw389 rwState

func (w *rw389) Unwrap() http.ResponseWriter { return w.w }
func (w *rw389) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw389) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw389) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw389) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw389) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw389) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw389) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 391/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher
type rw390 rwState

func (w *rw390) Unwrap() http.ResponseWriter { return w.w }
func (w *rw390) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw390) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw390) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw390) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw390) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw390) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw390) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 392/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw391 rwState

func (w *rw391) Unwrap() http.ResponseWriter { return w.w }
func (w *rw391) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw391) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw391) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw391) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw391) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw391) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw391) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw391) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 393/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner
type rw392 rwState

func (w *rw392) Unwrap() http.ResponseWriter { return w.w }
func (w *rw392) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw392) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw392) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw392) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw392) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw392) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw392) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 394/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, io.StringWriter
type rw393 rwState

func (w *rw393) Unwrap() http.ResponseWriter { return w.w }
func (w *rw393) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw393) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw393) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw393) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw393) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw393) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw393) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw393) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 395/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher
type rw394 rwState

func (w *rw394) Unwrap() http.ResponseWriter { return w.w }
func (w *rw394) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw394) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw394) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw394) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw394) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw394) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw394) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw394) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 396/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher, io.StringWriter
type rw395 rwState

func (w *rw395) Unwrap() http.ResponseWriter { return w.w }
func (w *rw395) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw395) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw395) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw395) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw395) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw395) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw395) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw395) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw395) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 397/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler
type rw396 rwState

func (w *rw396) Unwrap() http.ResponseWriter { return w.w }
func (w *rw396) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw396) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw396) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw396) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw396) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw396) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw396) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw396) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 398/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter
type rw397 rwState

func (w *rw397) Unwrap() http.ResponseWriter { return w.w }
func (w *rw397) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw397) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw397) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw397) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw397) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw397) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw397) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw397) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw397) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 399/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher
type rw398 rwState

func (w *rw398) Unwrap() http.ResponseWriter { return w.w }
func (w *rw398) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw398) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw398) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw398) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw398) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw398) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw398) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw398) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw398) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 400/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw399 rwState

func (w *rw399) Unwrap() http.ResponseWriter { return w.w }
func (w *rw399) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw399) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw399) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw399) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw399) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw399) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw399) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw399) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw399) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw399) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 401/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom
type rw400 rwState

func (w *rw400) Unwrap() http.ResponseWriter { return w.w }
func (w *rw400) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw400) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw400) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw400) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw400) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw400) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 402/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, io.StringWriter
type rw401 rwState

func (w *rw401) Unwrap() http.ResponseWriter { return w.w }
func (w *rw401) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw401) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw401) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw401) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw401) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw401) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw401) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 403/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher
type rw402 rwState

func (w *rw402) Unwrap() http.ResponseWriter { return w.w }
func (w *rw402) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw402) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw402) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw402) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw402) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw402) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw402) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 404/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter
type rw403 rwState

func (w *rw403) Unwrap() http.ResponseWriter { return w.w }
func (w *rw403) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw403) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw403) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw403) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw403) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw403) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw403) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw403) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 405/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler
type rw404 rwState

func (w *rw404) Unwrap() http.ResponseWriter { return w.w }
func (w *rw404) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw404) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw404) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw404) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw404) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw404) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw404) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 406/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw405 rwState

func (w *rw405) Unwrap() http.ResponseWriter { return w.w }
func (w *rw405) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw405) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw405) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw405) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw405) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw405) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw405) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw405) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 407/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw406 rwState

func (w *rw406) Unwrap() http.ResponseWriter { return w.w }
func (w *rw406) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw406) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw406) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw406) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw406) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw406) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw406) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw406) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 408/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw407 rwState

func (w *rw407) Unwrap() http.ResponseWriter { return w.w }
func (w *rw407) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw407) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw407) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw407) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw407) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw407) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw407) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw407) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw407) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 409/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner
type rw408 rwState

func (w *rw408) Unwrap() http.ResponseWriter { return w.w }
func (w *rw408) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw408) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw408) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw408) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw408) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw408) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw408) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw408) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 410/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter
type rw409 rwState

func (w *rw409) Unwrap() http.ResponseWriter { return w.w }
func (w *rw409) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw409) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw409) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw409) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw409) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw409) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw409) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw409) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw409) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 411/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher
type rw410 rwState

func (w *rw410) Unwrap() http.ResponseWriter { return w.w }
func (w *rw410) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw410) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw410) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw410) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw410) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw410) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw410) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw410) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw410) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 412/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw411 rwState

func (w *rw411) Unwrap() http.ResponseWriter { return w.w }
func (w *rw411) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw411) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw411) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw411) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw411) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw411) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw411) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw411) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw411) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw411) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 413/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw412 rwState

func (w *rw412) Unwrap() http.ResponseWriter { return w.w }
func (w *rw412) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw412) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw412) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw412) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw412) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw412) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw412) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw412) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw412) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 414/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw413 rwState

func (w *rw413) Unwrap() http.ResponseWriter { return w.w }
func (w *rw413) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw413) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw413) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw413) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw413) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw413) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw413) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw413) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw413) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw413) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 415/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw414 rwState

func (w *rw414) Unwrap() http.ResponseWriter { return w.w }
func (w *rw414) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw414) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw414) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw414) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw414) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw414) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw414) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw414) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw414) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw414) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 416/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw415 rwState

func (w *rw415) Unwrap() http.ResponseWriter { return w.w }
func (w *rw415) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw415) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw415) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw415) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw415) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw415) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw415) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw415) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw415) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw415) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw415) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 417/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker
type rw416 rwState

func (w *rw416) Unwrap() http.ResponseWriter { return w.w }
func (w *rw416) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw416) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw416) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw416) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw416) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw416) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 418/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.StringWriter
type rw417 rwState

func (w *rw417) Unwrap() http.ResponseWriter { return w.w }
func (w *rw417) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw417) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw417) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw417) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw417) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw417) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw417) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 419/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher
type rw418 rwState

func (w *rw418) Unwrap() http.ResponseWriter { return w.w }
func (w *rw418) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw418) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw418) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw418) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw418) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw418) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw418) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 420/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter
type rw419 rwState

func (w *rw419) Unwrap() http.ResponseWriter { return w.w }
func (w *rw419) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw419) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw419) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw419) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw419) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw419) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw419) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw419) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 421/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler
type rw420 rwState

func (w *rw420) Unwrap() http.ResponseWriter { return w.w }
func (w *rw420) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw420) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw420) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw420) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw420) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw420) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw420) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 422/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw421 rwState

func (w *rw421) Unwrap() http.ResponseWriter { return w.w }
func (w *rw421) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw421) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw421) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw421) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw421) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw421) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw421) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw421) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 423/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw422 rwState

func (w *rw422) Unwrap() http.ResponseWriter { return w.w }
func (w *rw422) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw422) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw422) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw422) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw422) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw422) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw422) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw422) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 424/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw423 rwState

func (w *rw423) Unwrap() http.ResponseWriter { return w.w }
func (w *rw423) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw423) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw423) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw423) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw423) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw423) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw423) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw423) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw423) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 425/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner
type rw424 rwState

func (w *rw424) Unwrap() http.ResponseWriter { return w.w }
func (w *rw424) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw424) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw424) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw424) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw424) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw424) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw424) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw424) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 426/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, io.StringWriter
type rw425 rwState

func (w *rw425) Unwrap() http.ResponseWriter { return w.w }
func (w *rw425) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw425) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw425) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw425) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw425) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw425) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw425) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw425) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw425) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 427/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher
type rw426 rwState

func (w *rw426) Unwrap() http.ResponseWriter { return w.w }
func (w *rw426) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw426) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw426) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw426) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw426) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw426) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw426) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw426) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw426) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 428/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw427 rwState

func (w *rw427) Unwrap() http.ResponseWriter { return w.w }
func (w *rw427) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw427) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw427) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw427) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw427) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw427) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw427) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw427) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw427) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw427) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 429/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler
type rw428 rwState

func (w *rw428) Unwrap() http.ResponseWriter { return w.w }
func (w *rw428) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw428) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw428) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw428) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw428) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw428) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw428) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw428) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw428) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 430/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw429 rwState

func (w *rw429) Unwrap() http.ResponseWriter { return w.w }
func (w *rw429) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw429) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw429) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw429) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw429) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw429) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw429) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw429) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw429) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw429) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 431/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw430 rwState

func (w *rw430) Unwrap() http.ResponseWriter { return w.w }
func (w *rw430) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw430) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw430) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw430) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw430) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw430) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw430) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw430) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw430) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw430) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 432/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw431 rwState

func (w *rw431) Unwrap() http.ResponseWriter { return w.w }
func (w *rw431) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw431) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw431) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw431) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw431) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw431) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw431) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw431) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw431) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw431) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw431) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 433/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom
type rw432 rwState

func (w *rw432) Unwrap() http.ResponseWriter { return w.w }
func (w *rw432) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw432) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw432) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw432) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw432) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw432) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw432) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 434/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw433 rwState

func (w *rw433) Unwrap() http.ResponseWriter { return w.w }
func (w *rw433) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw433) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw433) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw433) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw433) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw433) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw433) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw433) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 435/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher
type rw434 rwState

func (w *rw434) Unwrap() http.ResponseWriter { return w.w }
func (w *rw434) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw434) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw434) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw434) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw434) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw434) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw434) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw434) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 436/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw435 rwState

func (w *rw435) Unwrap() http.ResponseWriter { return w.w }
func (w *rw435) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw435) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw435) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw435) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw435) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw435) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw435) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw435) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw435) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 437/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw436 rwState

func (w *rw436) Unwrap() http.ResponseWriter { return w.w }
func (w *rw436) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw436) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw436) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw436) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw436) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw436) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw436) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw436) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 438/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw437 rwState

func (w *rw437) Unwrap() http.ResponseWriter { return w.w }
func (w *rw437) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw437) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw437) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw437) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw437) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw437) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw437) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw437) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw437) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 439/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw438 rwState

func (w *rw438) Unwrap() http.ResponseWriter { return w.w }
func (w *rw438) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw438) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw438) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw438) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw438) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw438) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw438) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw438) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw438) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 440/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw439 rwState

func (w *rw439) Unwrap() http.ResponseWriter { return w.w }
func (w *rw439) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw439) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw439) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw439) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw439) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw439) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw439) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw439) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw439) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw439) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 441/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner
type rw440 rwState

func (w *rw440) Unwrap() http.ResponseWriter { return w.w }
func (w *rw440) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw440) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw440) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw440) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw440) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw440) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw440) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw440) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw440) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 442/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw441 rwState

func (w *rw441) Unwrap() http.ResponseWriter { return w.w }
func (w *rw441) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw441) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw441) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw441) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw441) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw441) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw441) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw441) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw441) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw441) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 443/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw442 rwState

func (w *rw442) Unwrap() http.ResponseWriter { return w.w }
func (w *rw442) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw442) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw442) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw442) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw442) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw442) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw442) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw442) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw442) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw442) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 444/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw443 rwState

func (w *rw443) Unwrap() http.ResponseWriter { return w.w }
func (w *rw443) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw443) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw443) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw443) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw443) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw443) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw443) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw443) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw443) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw443) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw443) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 445/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw444 rwState

func (w *rw444) Unwrap() http.ResponseWriter { return w.w }
func (w *rw444) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw444) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw444) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw444) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw444) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw444) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw444) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw444) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw444) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw444) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 446/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw445 rwState

func (w *rw445) Unwrap() http.ResponseWriter { return w.w }
func (w *rw445) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw445) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw445) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw445) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw445) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw445) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw445) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw445) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw445) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw445) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw445) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 447/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw446 rwState

func (w *rw446) Unwrap() http.ResponseWriter { return w.w }
func (w *rw446) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw446) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw446) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw446) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw446) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw446) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw446) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw446) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw446) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw446) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw446) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 448/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw447 rwState

func (w *rw447) Unwrap() http.ResponseWriter { return w.w }
func (w *rw447) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw447) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw447) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw447) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw447) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw447) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw447) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw447) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw447) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw447) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw447) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw447) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 449/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier
type rw448 rwState

func (w *rw448) Unwrap() http.ResponseWriter { return w.w }
func (w *rw448) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw448) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw448) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw448) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw448) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw448) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}

// combination 450/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.StringWriter
type rw449 rwState

func (w *rw449) Unwrap() http.ResponseWriter { return w.w }
func (w *rw449) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw449) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw449) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw449) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw449) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw449) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw449) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 451/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher
type rw450 rwState

func (w *rw450) Unwrap() http.ResponseWriter { return w.w }
func (w *rw450) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw450) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw450) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw450) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw450) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw450) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw450) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 452/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter
type rw451 rwState

func (w *rw451) Unwrap() http.ResponseWriter { return w.w }
func (w *rw451) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw451) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw451) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw451) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw451) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw451) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw451) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw451) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 453/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler
type rw452 rwState

func (w *rw452) Unwrap() http.ResponseWriter { return w.w }
func (w *rw452) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw452) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw452) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw452) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw452) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw452) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw452) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 454/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
type rw453 rwState

func (w *rw453) Unwrap() http.ResponseWriter { return w.w }
func (w *rw453) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw453) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw453) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw453) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw453) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw453) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw453) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw453) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 455/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher
type rw454 rwState

func (w *rw454) Unwrap() http.ResponseWriter { return w.w }
func (w *rw454) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw454) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw454) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw454) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw454) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw454) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw454) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw454) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 456/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw455 rwState

func (w *rw455) Unwrap() http.ResponseWriter { return w.w }
func (w *rw455) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw455) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw455) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw455) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw455) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw455) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw455) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw455) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw455) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 457/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner
type rw456 rwState

func (w *rw456) Unwrap() http.ResponseWriter { return w.w }
func (w *rw456) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw456) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw456) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw456) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw456) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw456) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw456) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw456) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 458/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter
type rw457 rwState

func (w *rw457) Unwrap() http.ResponseWriter { return w.w }
func (w *rw457) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw457) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw457) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw457) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw457) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw457) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw457) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw457) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw457) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 459/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher
type rw458 rwState

func (w *rw458) Unwrap() http.ResponseWriter { return w.w }
func (w *rw458) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw458) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw458) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw458) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw458) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw458) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw458) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw458) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw458) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 460/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
type rw459 rwState

func (w *rw459) Unwrap() http.ResponseWriter { return w.w }
func (w *rw459) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw459) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw459) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw459) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw459) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw459) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw459) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw459) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw459) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw459) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 461/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler
type rw460 rwState

func (w *rw460) Unwrap() http.ResponseWriter { return w.w }
func (w *rw460) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw460) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw460) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw460) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw460) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw460) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw460) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw460) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw460) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 462/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
type rw461 rwState

func (w *rw461) Unwrap() http.ResponseWriter { return w.w }
func (w *rw461) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw461) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw461) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw461) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw461) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw461) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw461) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw461) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw461) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw461) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 463/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
type rw462 rwState

func (w *rw462) Unwrap() http.ResponseWriter { return w.w }
func (w *rw462) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw462) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw462) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw462) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw462) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw462) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw462) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw462) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw462) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw462) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 464/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw463 rwState

func (w *rw463) Unwrap() http.ResponseWriter { return w.w }
func (w *rw463) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw463) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw463) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw463) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw463) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw463) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw463) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw463) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw463) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw463) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw463) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 465/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom
type rw464 rwState

func (w *rw464) Unwrap() http.ResponseWriter { return w.w }
func (w *rw464) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw464) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw464) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw464) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw464) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw464) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw464) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 466/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter
type rw465 rwState

func (w *rw465) Unwrap() http.ResponseWriter { return w.w }
func (w *rw465) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw465) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw465) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw465) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw465) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw465) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw465) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw465) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 467/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher
type rw466 rwState

func (w *rw466) Unwrap() http.ResponseWriter { return w.w }
func (w *rw466) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw466) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw466) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw466) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw466) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw466) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw466) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw466) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 468/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
type rw467 rwState

func (w *rw467) Unwrap() http.ResponseWriter { return w.w }
func (w *rw467) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw467) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw467) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw467) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw467) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw467) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw467) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw467) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw467) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 469/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
type rw468 rwState

func (w *rw468) Unwrap() http.ResponseWriter { return w.w }
func (w *rw468) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw468) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw468) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw468) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw468) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw468) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw468) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw468) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 470/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw469 rwState

func (w *rw469) Unwrap() http.ResponseWriter { return w.w }
func (w *rw469) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw469) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw469) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw469) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw469) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw469) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw469) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw469) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw469) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 471/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw470 rwState

func (w *rw470) Unwrap() http.ResponseWriter { return w.w }
func (w *rw470) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw470) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw470) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw470) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw470) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw470) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw470) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw470) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw470) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 472/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw471 rwState

func (w *rw471) Unwrap() http.ResponseWriter { return w.w }
func (w *rw471) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw471) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw471) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw471) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw471) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw471) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw471) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw471) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw471) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw471) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 473/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner
type rw472 rwState

func (w *rw472) Unwrap() http.ResponseWriter { return w.w }
func (w *rw472) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw472) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw472) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw472) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw472) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw472) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw472) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw472) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw472) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 474/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
type rw473 rwState

func (w *rw473) Unwrap() http.ResponseWriter { return w.w }
func (w *rw473) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw473) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw473) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw473) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw473) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw473) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw473) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw473) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw473) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw473) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 475/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
type rw474 rwState

func (w *rw474) Unwrap() http.ResponseWriter { return w.w }
func (w *rw474) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw474) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw474) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw474) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw474) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw474) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw474) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw474) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw474) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw474) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 476/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw475 rwState

func (w *rw475) Unwrap() http.ResponseWriter { return w.w }
func (w *rw475) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw475) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw475) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw475) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw475) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw475) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw475) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw475) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw475) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw475) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw475) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 477/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw476 rwState

func (w *rw476) Unwrap() http.ResponseWriter { return w.w }
func (w *rw476) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw476) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw476) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw476) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw476) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw476) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw476) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw476) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw476) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw476) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 478/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw477 rwState

func (w *rw477) Unwrap() http.ResponseWriter { return w.w }
func (w *rw477) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw477) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw477) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw477) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw477) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw477) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw477) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw477) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw477) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw477) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw477) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 479/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw478 rwState

func (w *rw478) Unwrap() http.ResponseWriter { return w.w }
func (w *rw478) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw478) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw478) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw478) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw478) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw478) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw478) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw478) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw478) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw478) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw478) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 480/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw479 rwState

func (w *rw479) Unwrap() http.ResponseWriter { return w.w }
func (w *rw479) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw479) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw479) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw479) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw479) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw479) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw479) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw479) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw479) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw479) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw479) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw479) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 481/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker
type rw480 rwState

func (w *rw480) Unwrap() http.ResponseWriter { return w.w }
func (w *rw480) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw480) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw480) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw480) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw480) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw480) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw480) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}

// combination 482/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter
type rw481 rwState

func (w *rw481) Unwrap() http.ResponseWriter { return w.w }
func (w *rw481) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw481) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw481) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw481) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw481) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw481) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw481) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw481) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 483/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher
type rw482 rwState

func (w *rw482) Unwrap() http.ResponseWriter { return w.w }
func (w *rw482) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw482) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw482) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw482) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw482) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw482) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw482) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw482) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 484/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
type rw483 rwState

func (w *rw483) Unwrap() http.ResponseWriter { return w.w }
func (w *rw483) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw483) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw483) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw483) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw483) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw483) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw483) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw483) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw483) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 485/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
type rw484 rwState

func (w *rw484) Unwrap() http.ResponseWriter { return w.w }
func (w *rw484) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw484) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw484) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw484) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw484) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw484) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw484) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw484) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 486/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
type rw485 rwState

func (w *rw485) Unwrap() http.ResponseWriter { return w.w }
func (w *rw485) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw485) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw485) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw485) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw485) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw485) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw485) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw485) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw485) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 487/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
type rw486 rwState

func (w *rw486) Unwrap() http.ResponseWriter { return w.w }
func (w *rw486) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw486) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw486) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw486) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw486) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw486) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw486) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw486) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw486) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 488/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw487 rwState

func (w *rw487) Unwrap() http.ResponseWriter { return w.w }
func (w *rw487) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw487) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw487) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw487) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw487) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw487) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw487) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw487) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw487) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw487) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 489/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner
type rw488 rwState

func (w *rw488) Unwrap() http.ResponseWriter { return w.w }
func (w *rw488) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw488) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw488) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw488) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw488) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw488) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw488) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw488) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw488) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 490/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
type rw489 rwState

func (w *rw489) Unwrap() http.ResponseWriter { return w.w }
func (w *rw489) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw489) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw489) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw489) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw489) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw489) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw489) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw489) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw489) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw489) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 491/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
type rw490 rwState

func (w *rw490) Unwrap() http.ResponseWriter { return w.w }
func (w *rw490) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw490) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw490) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw490) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw490) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw490) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw490) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw490) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw490) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw490) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 492/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
type rw491 rwState

func (w *rw491) Unwrap() http.ResponseWriter { return w.w }
func (w *rw491) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw491) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw491) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw491) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw491) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw491) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw491) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw491) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw491) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw491) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw491) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 493/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
type rw492 rwState

func (w *rw492) Unwrap() http.ResponseWriter { return w.w }
func (w *rw492) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw492) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw492) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw492) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw492) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw492) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw492) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw492) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw492) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw492) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 494/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
type rw493 rwState

func (w *rw493) Unwrap() http.ResponseWriter { return w.w }
func (w *rw493) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw493) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw493) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw493) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw493) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw493) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw493) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw493) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw493) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw493) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw493) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 495/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
type rw494 rwState

func (w *rw494) Unwrap() http.ResponseWriter { return w.w }
func (w *rw494) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw494) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw494) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw494) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw494) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw494) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw494) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw494) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw494) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw494) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw494) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 496/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw495 rwState

func (w *rw495) Unwrap() http.ResponseWriter { return w.w }
func (w *rw495) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw495) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw495) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw495) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw495) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw495) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw495) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw495) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw495) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw495) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw495) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw495) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 497/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom
type rw496 rwState

func (w *rw496) Unwrap() http.ResponseWriter { return w.w }
func (w *rw496) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw496) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw496) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw496) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw496) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw496) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw496) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw496) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}

// combination 498/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
type rw497 rwState

func (w *rw497) Unwrap() http.ResponseWriter { return w.w }
func (w *rw497) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw497) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw497) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw497) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw497) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw497) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw497) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw497) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw497) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 499/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
type rw498 rwState

func (w *rw498) Unwrap() http.ResponseWriter { return w.w }
func (w *rw498) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw498) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw498) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw498) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw498) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw498) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw498) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw498) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw498) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 500/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
type rw499 rwState

func (w *rw499) Unwrap() http.ResponseWriter { return w.w }
func (w *rw499) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw499) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw499) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw499) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw499) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw499) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw499) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw499) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw499) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw499) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 501/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
type rw500 rwState

func (w *rw500) Unwrap() http.ResponseWriter { return w.w }
func (w *rw500) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw500) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw500) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw500) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw500) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw500) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw500) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw500) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw500) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 502/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
type rw501 rwState

func (w *rw501) Unwrap() http.ResponseWriter { return w.w }
func (w *rw501) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw501) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw501) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw501) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw501) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw501) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw501) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw501) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw501) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw501) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 503/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
type rw502 rwState

func (w *rw502) Unwrap() http.ResponseWriter { return w.w }
func (w *rw502) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw502) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw502) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw502) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw502) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw502) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw502) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw502) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw502) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw502) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 504/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw503 rwState

func (w *rw503) Unwrap() http.ResponseWriter { return w.w }
func (w *rw503) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw503) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw503) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw503) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw503) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw503) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw503) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw503) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw503) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw503) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw503) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 505/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
type rw504 rwState

func (w *rw504) Unwrap() http.ResponseWriter { return w.w }
func (w *rw504) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw504) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw504) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw504) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw504) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw504) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw504) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw504) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw504) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw504) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}

// combination 506/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
type rw505 rwState

func (w *rw505) Unwrap() http.ResponseWriter { return w.w }
func (w *rw505) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw505) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw505) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw505) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw505) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw505) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw505) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw505) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw505) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw505) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw505) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 507/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
type rw506 rwState

func (w *rw506) Unwrap() http.ResponseWriter { return w.w }
func (w *rw506) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw506) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw506) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw506) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw506) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw506) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw506) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw506) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw506) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw506) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw506) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 508/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
type rw507 rwState

func (w *rw507) Unwrap() http.ResponseWriter { return w.w }
func (w *rw507) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw507) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw507) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw507) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw507) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw507) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw507) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw507) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw507) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw507) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw507) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw507) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 509/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
type rw508 rwState

func (w *rw508) Unwrap() http.ResponseWriter { return w.w }
func (w *rw508) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw508) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw508) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw508) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw508) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw508) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw508) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw508) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw508) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw508) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw508) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}

// combination 510/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
type rw509 rwState

func (w *rw509) Unwrap() http.ResponseWriter { return w.w }
func (w *rw509) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw509) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw509) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw509) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw509) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw509) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw509) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw509) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw509) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw509) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw509) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw509) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

// combination 511/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
type rw510 rwState

func (w *rw510) Unwrap() http.ResponseWriter { return w.w }
func (w *rw510) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw510) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw510) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw510) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw510) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw510) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw510) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw510) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw510) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw510) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw510) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw510) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}

// combination 512/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
type rw511 rwState

func (w *rw511) Unwrap() http.ResponseWriter { return w.w }
func (w *rw511) Header() http.Header {
	return (*rwState)(w).doHeader()
}
func (w *rw511) WriteHeader(code int) {
	(*rwState)(w).doWriteHeader(code)
}
func (w *rw511) Write(b []byte) (int, error) {
	return (*rwState)(w).doWrite(b)
}
func (w *rw511) Flush() {
	(*rwState)(w).doFlush()
}
func (w *rw511) FlushError() error {
	return (*rwState)(w).doFlushError()
}
func (w *rw511) CloseNotify() <-chan bool {
	return (*rwState)(w).doCloseNotify()
}
func (w *rw511) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	return (*rwState)(w).doHijack()
}
func (w *rw511) ReadFrom(src io.Reader) (int64, error) {
	return (*rwState)(w).doReadFrom(src)
}
func (w *rw511) SetReadDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetReadDeadline(deadline)
}
func (w *rw511) SetWriteDeadline(deadline time.Time) error {
	return (*rwState)(w).doSetWriteDeadline(deadline)
}
func (w *rw511) EnableFullDuplex() error {
	return (*rwState)(w).doEnableFullDuplex()
}
func (w *rw511) Push(target string, opts *http.PushOptions) error {
	return (*rwState)(w).doPush(target, opts)
}
func (w *rw511) WriteString(s string) (int, error) {
	return (*rwState)(w).doWriteString(s)
}

type Unwrapper interface {
	Unwrap() http.ResponseWriter
}

// Unwrap returns the underlying http.ResponseWriter from within zero or more
// layers of httpsnoop wrappers.
func Unwrap(w http.ResponseWriter) http.ResponseWriter {
	if rw, ok := w.(Unwrapper); ok {
		// recurse until rw.Unwrap() returns a non-Unwrapper
		return Unwrap(rw.Unwrap())
	}
	return w
}
