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

package httpsnoop

import (
	"io"
	"net/http"
	"testing"
)

func TestWrap(t *testing.T) {
	// combination 1/512
	{
		t.Log("http.ResponseWriter")
		inner := struct {
			http.ResponseWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 2/512
	{
		t.Log("http.ResponseWriter, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 3/512
	{
		t.Log("http.ResponseWriter, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 4/512
	{
		t.Log("http.ResponseWriter, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 5/512
	{
		t.Log("http.ResponseWriter, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 6/512
	{
		t.Log("http.ResponseWriter, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 7/512
	{
		t.Log("http.ResponseWriter, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 8/512
	{
		t.Log("http.ResponseWriter, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 9/512
	{
		t.Log("http.ResponseWriter, deadliner")
		inner := struct {
			http.ResponseWriter
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 10/512
	{
		t.Log("http.ResponseWriter, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 11/512
	{
		t.Log("http.ResponseWriter, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 12/512
	{
		t.Log("http.ResponseWriter, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 13/512
	{
		t.Log("http.ResponseWriter, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 14/512
	{
		t.Log("http.ResponseWriter, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 15/512
	{
		t.Log("http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 16/512
	{
		t.Log("http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 17/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 18/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 19/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 20/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 21/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 22/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 23/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 24/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 25/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 26/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 27/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 28/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 29/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 30/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 31/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 32/512
	{
		t.Log("http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 33/512
	{
		t.Log("http.ResponseWriter, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 34/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 35/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 36/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 37/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 38/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 39/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 40/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 41/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 42/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 43/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 44/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 45/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 46/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 47/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 48/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 49/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 50/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 51/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 52/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 53/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 54/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 55/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 56/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 57/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 58/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 59/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 60/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 61/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 62/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 63/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 64/512
	{
		t.Log("http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 65/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 66/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 67/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 68/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 69/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 70/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 71/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 72/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 73/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 74/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 75/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 76/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 77/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 78/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 79/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 80/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 81/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 82/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 83/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 84/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 85/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 86/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 87/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 88/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 89/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 90/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 91/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 92/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 93/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 94/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 95/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 96/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 97/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 98/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 99/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 100/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 101/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 102/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 103/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 104/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 105/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 106/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 107/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 108/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 109/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 110/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 111/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 112/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 113/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 114/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 115/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 116/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 117/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 118/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 119/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 120/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 121/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 122/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 123/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 124/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 125/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 126/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 127/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 128/512
	{
		t.Log("http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 129/512
	{
		t.Log("http.ResponseWriter, httpFlushError")
		inner := struct {
			http.ResponseWriter
			httpFlushError
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 130/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 131/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 132/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 133/512
	{
		t.Log("http.ResponseWriter, httpFlushError, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 134/512
	{
		t.Log("http.ResponseWriter, httpFlushError, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 135/512
	{
		t.Log("http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 136/512
	{
		t.Log("http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 137/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 138/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 139/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 140/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 141/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 142/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 143/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 144/512
	{
		t.Log("http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 145/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 146/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 147/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 148/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 149/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 150/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 151/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 152/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 153/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 154/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 155/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 156/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 157/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 158/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 159/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 160/512
	{
		t.Log("http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 161/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 162/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 163/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 164/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 165/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 166/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 167/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 168/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 169/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 170/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 171/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 172/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 173/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 174/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 175/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 176/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 177/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 178/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 179/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 180/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 181/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 182/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 183/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 184/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 185/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 186/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 187/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 188/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 189/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 190/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 191/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 192/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 193/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 194/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 195/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 196/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 197/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 198/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 199/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 200/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 201/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 202/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 203/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 204/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 205/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 206/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 207/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 208/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 209/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 210/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 211/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 212/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 213/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 214/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 215/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 216/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 217/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 218/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 219/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 220/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 221/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 222/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 223/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 224/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 225/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 226/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 227/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 228/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 229/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 230/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 231/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 232/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 233/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 234/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 235/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 236/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 237/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 238/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 239/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 240/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 241/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 242/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 243/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 244/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 245/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 246/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 247/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 248/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 249/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 250/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 251/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 252/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 253/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 254/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 255/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 256/512
	{
		t.Log("http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 257/512
	{
		t.Log("http.ResponseWriter, http.Flusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 258/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 259/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 260/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 261/512
	{
		t.Log("http.ResponseWriter, http.Flusher, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 262/512
	{
		t.Log("http.ResponseWriter, http.Flusher, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 263/512
	{
		t.Log("http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 264/512
	{
		t.Log("http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 265/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 266/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 267/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 268/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 269/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 270/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 271/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 272/512
	{
		t.Log("http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 273/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 274/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 275/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 276/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 277/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 278/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 279/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 280/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 281/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 282/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 283/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 284/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 285/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 286/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 287/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 288/512
	{
		t.Log("http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 289/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 290/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 291/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 292/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 293/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 294/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 295/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 296/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 297/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 298/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 299/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 300/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 301/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 302/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 303/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 304/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 305/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 306/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 307/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 308/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 309/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 310/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 311/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 312/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 313/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 314/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 315/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 316/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 317/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 318/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 319/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 320/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 321/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 322/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 323/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 324/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 325/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 326/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 327/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 328/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 329/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 330/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 331/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 332/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 333/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 334/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 335/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 336/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 337/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 338/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 339/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 340/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 341/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 342/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 343/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 344/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 345/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 346/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 347/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 348/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 349/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 350/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 351/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 352/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 353/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 354/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 355/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 356/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 357/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 358/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 359/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 360/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 361/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 362/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 363/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 364/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 365/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 366/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 367/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 368/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 369/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 370/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 371/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 372/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 373/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 374/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 375/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 376/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 377/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 378/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 379/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 380/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 381/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 382/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 383/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 384/512
	{
		t.Log("http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 385/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 386/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 387/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 388/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 389/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 390/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 391/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 392/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 393/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 394/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 395/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 396/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 397/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 398/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 399/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 400/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 401/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 402/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 403/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 404/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 405/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 406/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 407/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 408/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 409/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 410/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 411/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 412/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 413/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 414/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 415/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 416/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 417/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 418/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 419/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 420/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 421/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 422/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 423/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 424/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 425/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 426/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 427/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 428/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 429/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 430/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 431/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 432/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 433/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 434/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 435/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 436/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 437/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 438/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 439/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 440/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 441/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 442/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 443/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 444/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 445/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 446/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 447/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 448/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 449/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 450/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 451/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 452/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 453/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 454/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 455/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 456/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 457/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 458/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 459/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 460/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 461/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 462/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 463/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 464/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 465/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 466/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 467/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 468/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 469/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 470/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 471/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 472/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 473/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 474/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 475/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 476/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 477/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 478/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 479/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 480/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 481/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 482/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 483/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 484/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 485/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 486/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 487/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 488/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 489/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 490/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 491/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 492/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 493/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 494/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 495/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 496/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 497/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 498/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 499/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 500/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 501/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 502/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 503/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 504/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 505/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 506/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 507/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 508/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 509/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 510/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != false {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 511/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != false {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

	// combination 512/512
	{
		t.Log("http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter")
		inner := struct {
			http.ResponseWriter
			http.Flusher
			httpFlushError
			http.CloseNotifier
			http.Hijacker
			io.ReaderFrom
			deadliner
			fullDuplexEnabler
			http.Pusher
			io.StringWriter
		}{}
		w := Wrap(inner, Hooks{})
		if _, ok := w.(http.ResponseWriter); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Flusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(httpFlushError); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.CloseNotifier); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Hijacker); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.ReaderFrom); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(deadliner); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(fullDuplexEnabler); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(http.Pusher); ok != true {
			t.Error("unexpected interface")
		}
		if _, ok := w.(io.StringWriter); ok != true {
			t.Error("unexpected interface")
		}

		if w, ok := w.(Unwrapper); ok {
			if w.Unwrap() != inner {
				t.Error("w.Unwrap() failed")
			}
		} else {
			t.Error("Unwrapper interface not implemented")
		}
	}

}