extensions are working! extensions are working!

10 files changed, 10360 insertions, 831 deletions

diff --git a/nexgb/conn.go b/nexgb/conn.go
index 235402d..02396d4 100644
--- a/nexgb/conn.go
+++ b/nexgb/conn.go
@@ -10,7 +10,8 @@ import (
 	"strings"
 )
 
-// connect connects to the X server given in the 'display' string.
+// connect connects to the X server given in the 'display' string,
+// and does all the necessary setup handshaking.
 // If 'display' is empty it will be taken from os.Getenv("DISPLAY").
 // Note that you should read and understand the "Connection Setup" of the
 // X Protocol Reference Manual before changing this function:
@@ -87,6 +88,7 @@ func (c *Conn) connect(display string) error {
 	return nil
 }
 
+// dial initializes the actual net connection with X.
 func (c *Conn) dial(display string) error {
 	if len(display) == 0 {
 		display = os.Getenv("DISPLAY")
diff --git a/nexgb/cookie.go b/nexgb/cookie.go
index 502ccbf..7f54a22 100644
--- a/nexgb/cookie.go
+++ b/nexgb/cookie.go
@@ -4,16 +4,28 @@ import (
 	"errors"
 )
 
+// cookie is the internal representation of a cookie, where one is generated
+// for *every* request sent by XGB.
+// 'cookie' is most frequently used by embedding it into a more specific
+// kind of cookie, i.e., 'GetInputFocusCookie'.
 type cookie struct {
+	conn *Conn
 	Sequence        uint16
 	replyChan chan []byte
 	errorChan chan error
 	pingChan chan bool
 }
 
-func (c *Conn) newCookie(checked, reply bool) cookie {
-	cookie := cookie{
-		Sequence: c.newSequenceId(),
+// newCookie creates a new cookie with the correct channels initialized
+// depending upon the values of 'checked' and 'reply'. Together, there are
+// four different kinds of cookies. (See more detailed comments in the
+// function for more info on those.)
+// Note that a sequence number is not set until just before the request
+// corresponding to this cookie is sent over the wire.
+func (c *Conn) newCookie(checked, reply bool) *cookie {
+	cookie := &cookie{
+		conn: c,
+		Sequence: 0, // we add the sequence id just before sending a request
 		replyChan: nil,
 		errorChan: nil,
 		pingChan: nil,
@@ -48,6 +60,8 @@ func (c *Conn) newCookie(checked, reply bool) cookie {
 	return cookie
 }
 
+// reply detects whether this is a checked or unchecked cookie, and calls
+// 'replyChecked' or 'replyUnchecked' appropriately.
 func (c cookie) reply() ([]byte, error) {
 	// checked
 	if c.errorChan != nil {
@@ -56,6 +70,10 @@ func (c cookie) reply() ([]byte, error) {
 	return c.replyUnchecked()
 }
 
+// replyChecked waits for a response on either the replyChan or errorChan
+// channels. If the former arrives, the bytes are returned with a nil error.
+// If the latter arrives, no bytes are returned (nil) and the error received
+// is returned.
 func (c cookie) replyChecked() ([]byte, error) {
 	if c.replyChan == nil {
 		return nil, errors.New("Cannot call 'replyChecked' on a cookie that " +
@@ -75,6 +93,12 @@ func (c cookie) replyChecked() ([]byte, error) {
 	panic("unreachable")
 }
 
+// replyChecked waits for a response on either the replyChan or pingChan
+// channels. If the former arrives, the bytes are returned with a nil error.
+// If the latter arrives, no bytes are returned (nil) and a nil error
+// is returned. (In the latter case, the corresponding error can be retrieved
+// from (Wait|Poll)ForEvent asynchronously.)
+// In all honesty, you *probably* don't want to use this method.
 func (c cookie) replyUnchecked() ([]byte, error) {
 	if c.replyChan == nil {
 		return nil, errors.New("Cannot call 'replyUnchecked' on a cookie " +
@@ -90,7 +114,15 @@ func (c cookie) replyUnchecked() ([]byte, error) {
 	panic("unreachable")
 }
 
-func (c cookie) Check() error {
+// check is used for checked requests that have no replies. It is a mechanism
+// by which to report "success" or "error" in a synchronous fashion. (Therefore,
+// unchecked requests without replies cannot use this method.)
+// If the request causes an error, it is sent to this cookie's errorChan.
+// If the request was successful, there is no response from the server.
+// Thus, pingChan is sent a value when the *next* reply is read.
+// If no more replies are being processed, we force a round trip request with
+// GetInputFocus.
+func (c cookie) check() error {
 	if c.replyChan != nil {
 		return errors.New("Cannot call 'Check' on a cookie that is " +
 			"expecting a *reply*. Use 'Reply' instead.")
@@ -100,6 +132,17 @@ func (c cookie) Check() error {
 			"not expecting a possible *error*.")
 	}
 
+	// First do a quick non-blocking check to see if we've been pinged.
+	select {
+	case err := <-c.errorChan:
+		return err
+	case <-c.pingChan:
+		return nil
+	default:
+	}
+
+	// Now force a round trip and try again, but block this time.
+	c.conn.GetInputFocus().Reply()
 	select {
 	case err := <-c.errorChan:
 		return err
diff --git a/nexgb/examples/atom.go b/nexgb/examples/atom.go
index c64acee..2cb7132 100644
--- a/nexgb/examples/atom.go
+++ b/nexgb/examples/atom.go
@@ -18,7 +18,7 @@ func main() {
 	}
 
 	aname := "_NET_ACTIVE_WINDOW"
-	atom, err := X.InternAtom(true, uint16(len(aname)), aname)
+	atom, err := X.InternAtom(true, uint16(len(aname)), aname).Reply()
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/nexgb/examples/property.go b/nexgb/examples/property.go
index 2477df4..45144c7 100644
--- a/nexgb/examples/property.go
+++ b/nexgb/examples/property.go
@@ -27,13 +27,15 @@ func main() {
 	root := X.DefaultScreen().Root
 
 	aname := "_NET_ACTIVE_WINDOW"
-	atom, err := X.InternAtom(true, uint16(len(aname)), aname)
+	atom, err := X.InternAtom(true, uint16(len(aname)), aname).Reply()
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	reply, err := X.GetProperty(false, root, atom.Atom, xgb.GetPropertyTypeAny,
-		0, (1<<32)-1)
+	reply, err := X.GetProperty(false, root, atom.Atom,
+		xgb.GetPropertyTypeAny, 0, (1<<32)-1).Reply()
+	if err != nil {
+		log.Fatal(err)
+	}
 	log.Printf("%X", get32(reply.Value))
 }
-
diff --git a/nexgb/randr.go b/nexgb/randr.go
new file mode 100644
index 0000000..fdb10ca
--- /dev/null
+++ b/nexgb/randr.go
@@ -0,0 +1,3988 @@
+package xgb
+
+/*
+	This file was generated by randr.xml on May 5 2012 6:06:50pm EDT.
+	This file is automatically generated. Edit at your peril!
+*/
+
+// Imports are not necessary for XGB because everything is 
+// in one package. They are still listed here for reference.
+// import "xproto"
+// import "render"
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+// Skipping definition for base type 'Float'
+
+const (
+	RandrRotationRotate0   = 1
+	RandrRotationRotate90  = 2
+	RandrRotationRotate180 = 4
+	RandrRotationRotate270 = 8
+	RandrRotationReflectX  = 16
+	RandrRotationReflectY  = 32
+)
+
+const (
+	RandrSetConfigSuccess           = 0
+	RandrSetConfigInvalidConfigTime = 1
+	RandrSetConfigInvalidTime       = 2
+	RandrSetConfigFailed            = 3
+)
+
+const (
+	RandrNotifyMaskScreenChange   = 1
+	RandrNotifyMaskCrtcChange     = 2
+	RandrNotifyMaskOutputChange   = 4
+	RandrNotifyMaskOutputProperty = 8
+)
+
+const (
+	RandrModeFlagHsyncPositive  = 1
+	RandrModeFlagHsyncNegative  = 2
+	RandrModeFlagVsyncPositive  = 4
+	RandrModeFlagVsyncNegative  = 8
+	RandrModeFlagInterlace      = 16
+	RandrModeFlagDoubleScan     = 32
+	RandrModeFlagCsync          = 64
+	RandrModeFlagCsyncPositive  = 128
+	RandrModeFlagCsyncNegative  = 256
+	RandrModeFlagHskewPresent   = 512
+	RandrModeFlagBcast          = 1024
+	RandrModeFlagPixelMultiplex = 2048
+	RandrModeFlagDoubleClock    = 4096
+	RandrModeFlagHalveClock     = 8192
+)
+
+const (
+	RandrConnectionConnected    = 0
+	RandrConnectionDisconnected = 1
+	RandrConnectionUnknown      = 2
+)
+
+const (
+	RandrNotifyCrtcChange     = 0
+	RandrNotifyOutputChange   = 1
+	RandrNotifyOutputProperty = 2
+)
+
+// Skipping resource definition of 'Mode'
+
+// Skipping resource definition of 'Crtc'
+
+// Skipping resource definition of 'Output'
+
+// 'RandrScreenSize' struct definition
+// Size: 8
+type RandrScreenSize struct {
+	Width   uint16
+	Height  uint16
+	Mwidth  uint16
+	Mheight uint16
+}
+
+// Struct read RandrScreenSize
+func ReadRandrScreenSize(buf []byte, v *RandrScreenSize) int {
+	b := 0
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.Mwidth = Get16(buf[b:])
+	b += 2
+
+	v.Mheight = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read RandrScreenSize
+func ReadRandrScreenSizeList(buf []byte, dest []RandrScreenSize) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrScreenSize{}
+		b += ReadRandrScreenSize(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrScreenSize
+func (v RandrScreenSize) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.Mwidth)
+	b += 2
+
+	Put16(buf[b:], v.Mheight)
+	b += 2
+
+	return buf
+}
+
+// Write struct list RandrScreenSize
+func RandrScreenSizeListBytes(buf []byte, list []RandrScreenSize) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RandrRefreshRates' struct definition
+// Size: (2 + pad((int(NRates) * 2)))
+type RandrRefreshRates struct {
+	NRates uint16
+	Rates  []uint16 // size: pad((int(NRates) * 2))
+}
+
+// Struct read RandrRefreshRates
+func ReadRandrRefreshRates(buf []byte, v *RandrRefreshRates) int {
+	b := 0
+
+	v.NRates = Get16(buf[b:])
+	b += 2
+
+	v.Rates = make([]uint16, v.NRates)
+	for i := 0; i < int(v.NRates); i++ {
+		v.Rates[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	return b
+}
+
+// Struct list read RandrRefreshRates
+func ReadRandrRefreshRatesList(buf []byte, dest []RandrRefreshRates) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrRefreshRates{}
+		b += ReadRandrRefreshRates(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrRefreshRates
+func (v RandrRefreshRates) Bytes() []byte {
+	buf := make([]byte, (2 + pad((int(v.NRates) * 2))))
+	b := 0
+
+	Put16(buf[b:], v.NRates)
+	b += 2
+
+	for i := 0; i < int(v.NRates); i++ {
+		Put16(buf[b:], v.Rates[i])
+		b += 2
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Write struct list RandrRefreshRates
+func RandrRefreshRatesListBytes(buf []byte, list []RandrRefreshRates) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size RandrRefreshRates
+func RandrRefreshRatesListSize(list []RandrRefreshRates) int {
+	size := 0
+	for _, item := range list {
+		size += (2 + pad((int(item.NRates) * 2)))
+	}
+	return size
+}
+
+// 'RandrModeInfo' struct definition
+// Size: 32
+type RandrModeInfo struct {
+	Id         uint32
+	Width      uint16
+	Height     uint16
+	DotClock   uint32
+	HsyncStart uint16
+	HsyncEnd   uint16
+	Htotal     uint16
+	Hskew      uint16
+	VsyncStart uint16
+	VsyncEnd   uint16
+	Vtotal     uint16
+	NameLen    uint16
+	ModeFlags  uint32
+}
+
+// Struct read RandrModeInfo
+func ReadRandrModeInfo(buf []byte, v *RandrModeInfo) int {
+	b := 0
+
+	v.Id = Get32(buf[b:])
+	b += 4
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.DotClock = Get32(buf[b:])
+	b += 4
+
+	v.HsyncStart = Get16(buf[b:])
+	b += 2
+
+	v.HsyncEnd = Get16(buf[b:])
+	b += 2
+
+	v.Htotal = Get16(buf[b:])
+	b += 2
+
+	v.Hskew = Get16(buf[b:])
+	b += 2
+
+	v.VsyncStart = Get16(buf[b:])
+	b += 2
+
+	v.VsyncEnd = Get16(buf[b:])
+	b += 2
+
+	v.Vtotal = Get16(buf[b:])
+	b += 2
+
+	v.NameLen = Get16(buf[b:])
+	b += 2
+
+	v.ModeFlags = Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// Struct list read RandrModeInfo
+func ReadRandrModeInfoList(buf []byte, dest []RandrModeInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrModeInfo{}
+		b += ReadRandrModeInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrModeInfo
+func (v RandrModeInfo) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	Put32(buf[b:], v.Id)
+	b += 4
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put32(buf[b:], v.DotClock)
+	b += 4
+
+	Put16(buf[b:], v.HsyncStart)
+	b += 2
+
+	Put16(buf[b:], v.HsyncEnd)
+	b += 2
+
+	Put16(buf[b:], v.Htotal)
+	b += 2
+
+	Put16(buf[b:], v.Hskew)
+	b += 2
+
+	Put16(buf[b:], v.VsyncStart)
+	b += 2
+
+	Put16(buf[b:], v.VsyncEnd)
+	b += 2
+
+	Put16(buf[b:], v.Vtotal)
+	b += 2
+
+	Put16(buf[b:], v.NameLen)
+	b += 2
+
+	Put32(buf[b:], v.ModeFlags)
+	b += 4
+
+	return buf
+}
+
+// Write struct list RandrModeInfo
+func RandrModeInfoListBytes(buf []byte, list []RandrModeInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RandrCrtcChange' struct definition
+// Size: 28
+type RandrCrtcChange struct {
+	Timestamp Timestamp
+	Window    Id
+	Crtc      Id
+	Mode      Id
+	Rotation  uint16
+	// padding: 2 bytes
+	X      int16
+	Y      int16
+	Width  uint16
+	Height uint16
+}
+
+// Struct read RandrCrtcChange
+func ReadRandrCrtcChange(buf []byte, v *RandrCrtcChange) int {
+	b := 0
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Crtc = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Mode = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Rotation = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read RandrCrtcChange
+func ReadRandrCrtcChangeList(buf []byte, dest []RandrCrtcChange) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrCrtcChange{}
+		b += ReadRandrCrtcChange(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrCrtcChange
+func (v RandrCrtcChange) Bytes() []byte {
+	buf := make([]byte, 28)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Timestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Crtc))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Mode))
+	b += 4
+
+	Put16(buf[b:], v.Rotation)
+	b += 2
+
+	b += 2 // padding
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	return buf
+}
+
+// Write struct list RandrCrtcChange
+func RandrCrtcChangeListBytes(buf []byte, list []RandrCrtcChange) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RandrOutputChange' struct definition
+// Size: 28
+type RandrOutputChange struct {
+	Timestamp       Timestamp
+	ConfigTimestamp Timestamp
+	Window          Id
+	Output          Id
+	Crtc            Id
+	Mode            Id
+	Rotation        uint16
+	Connection      byte
+	SubpixelOrder   byte
+}
+
+// Struct read RandrOutputChange
+func ReadRandrOutputChange(buf []byte, v *RandrOutputChange) int {
+	b := 0
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Output = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Crtc = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Mode = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Rotation = Get16(buf[b:])
+	b += 2
+
+	v.Connection = buf[b]
+	b += 1
+
+	v.SubpixelOrder = buf[b]
+	b += 1
+
+	return b
+}
+
+// Struct list read RandrOutputChange
+func ReadRandrOutputChangeList(buf []byte, dest []RandrOutputChange) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrOutputChange{}
+		b += ReadRandrOutputChange(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrOutputChange
+func (v RandrOutputChange) Bytes() []byte {
+	buf := make([]byte, 28)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Timestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(v.ConfigTimestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Output))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Crtc))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Mode))
+	b += 4
+
+	Put16(buf[b:], v.Rotation)
+	b += 2
+
+	buf[b] = v.Connection
+	b += 1
+
+	buf[b] = v.SubpixelOrder
+	b += 1
+
+	return buf
+}
+
+// Write struct list RandrOutputChange
+func RandrOutputChangeListBytes(buf []byte, list []RandrOutputChange) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RandrOutputProperty' struct definition
+// Size: 28
+type RandrOutputProperty struct {
+	Window    Id
+	Output    Id
+	Atom      Id
+	Timestamp Timestamp
+	Status    byte
+	// padding: 11 bytes
+}
+
+// Struct read RandrOutputProperty
+func ReadRandrOutputProperty(buf []byte, v *RandrOutputProperty) int {
+	b := 0
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Output = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Atom = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Status = buf[b]
+	b += 1
+
+	b += 11 // padding
+
+	return b
+}
+
+// Struct list read RandrOutputProperty
+func ReadRandrOutputPropertyList(buf []byte, dest []RandrOutputProperty) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrOutputProperty{}
+		b += ReadRandrOutputProperty(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RandrOutputProperty
+func (v RandrOutputProperty) Bytes() []byte {
+	buf := make([]byte, 28)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Window))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Output))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Atom))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Timestamp))
+	b += 4
+
+	buf[b] = v.Status
+	b += 1
+
+	b += 11 // padding
+
+	return buf
+}
+
+// Write struct list RandrOutputProperty
+func RandrOutputPropertyListBytes(buf []byte, list []RandrOutputProperty) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Union definition RandrNotifyDataUnion
+// Note that to *create* a Union, you should *never* create
+// this struct directly (unless you know what you're doing).
+// Instead use one of the following constructors for 'RandrNotifyDataUnion':
+//     NewRandrNotifyDataUnionCc(Cc RandrCrtcChange) RandrNotifyDataUnion
+//     NewRandrNotifyDataUnionOc(Oc RandrOutputChange) RandrNotifyDataUnion
+//     NewRandrNotifyDataUnionOp(Op RandrOutputProperty) RandrNotifyDataUnion
+type RandrNotifyDataUnion struct {
+	Cc RandrCrtcChange
+	Oc RandrOutputChange
+	Op RandrOutputProperty
+}
+
+// Union constructor for RandrNotifyDataUnion for field Cc.
+func NewRandrNotifyDataUnionCc(Cc RandrCrtcChange) RandrNotifyDataUnion {
+	var b int
+	buf := make([]byte, 28)
+
+	{
+		structBytes := Cc.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	// Create the Union type
+	v := RandrNotifyDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Cc = RandrCrtcChange{}
+	b += ReadRandrCrtcChange(buf[b:], &v.Cc)
+
+	b = 0 // always read the same bytes
+	v.Oc = RandrOutputChange{}
+	b += ReadRandrOutputChange(buf[b:], &v.Oc)
+
+	b = 0 // always read the same bytes
+	v.Op = RandrOutputProperty{}
+	b += ReadRandrOutputProperty(buf[b:], &v.Op)
+
+	return v
+}
+
+// Union constructor for RandrNotifyDataUnion for field Oc.
+func NewRandrNotifyDataUnionOc(Oc RandrOutputChange) RandrNotifyDataUnion {
+	var b int
+	buf := make([]byte, 28)
+
+	{
+		structBytes := Oc.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	// Create the Union type
+	v := RandrNotifyDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Cc = RandrCrtcChange{}
+	b += ReadRandrCrtcChange(buf[b:], &v.Cc)
+
+	b = 0 // always read the same bytes
+	v.Oc = RandrOutputChange{}
+	b += ReadRandrOutputChange(buf[b:], &v.Oc)
+
+	b = 0 // always read the same bytes
+	v.Op = RandrOutputProperty{}
+	b += ReadRandrOutputProperty(buf[b:], &v.Op)
+
+	return v
+}
+
+// Union constructor for RandrNotifyDataUnion for field Op.
+func NewRandrNotifyDataUnionOp(Op RandrOutputProperty) RandrNotifyDataUnion {
+	var b int
+	buf := make([]byte, 28)
+
+	{
+		structBytes := Op.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	// Create the Union type
+	v := RandrNotifyDataUnion{}
+
+	// Now copy buf into all fields
+
+	b = 0 // always read the same bytes
+	v.Cc = RandrCrtcChange{}
+	b += ReadRandrCrtcChange(buf[b:], &v.Cc)
+
+	b = 0 // always read the same bytes
+	v.Oc = RandrOutputChange{}
+	b += ReadRandrOutputChange(buf[b:], &v.Oc)
+
+	b = 0 // always read the same bytes
+	v.Op = RandrOutputProperty{}
+	b += ReadRandrOutputProperty(buf[b:], &v.Op)
+
+	return v
+}
+
+// Union read RandrNotifyDataUnion
+func ReadRandrNotifyDataUnion(buf []byte, v *RandrNotifyDataUnion) int {
+	var b int
+
+	b = 0 // re-read the same bytes
+	v.Cc = RandrCrtcChange{}
+	b += ReadRandrCrtcChange(buf[b:], &v.Cc)
+
+	b = 0 // re-read the same bytes
+	v.Oc = RandrOutputChange{}
+	b += ReadRandrOutputChange(buf[b:], &v.Oc)
+
+	b = 0 // re-read the same bytes
+	v.Op = RandrOutputProperty{}
+	b += ReadRandrOutputProperty(buf[b:], &v.Op)
+
+	return 28
+}
+
+// Union list read RandrNotifyDataUnion
+func ReadRandrNotifyDataUnionList(buf []byte, dest []RandrNotifyDataUnion) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RandrNotifyDataUnion{}
+		b += ReadRandrNotifyDataUnion(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Union write RandrNotifyDataUnion
+// Each field in a union must contain the same data.
+// So simply pick the first field and write that to the wire.
+func (v RandrNotifyDataUnion) Bytes() []byte {
+	buf := make([]byte, 28)
+	b := 0
+
+	{
+		structBytes := v.Cc.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return buf
+}
+
+// Union list write RandrNotifyDataUnion
+func RandrNotifyDataUnionListBytes(buf []byte, list []RandrNotifyDataUnion) int {
+	b := 0
+	var unionBytes []byte
+	for _, item := range list {
+		unionBytes = item.Bytes()
+		copy(buf[b:], unionBytes)
+		b += pad(len(unionBytes))
+	}
+	return b
+}
+
+// Event definition RandrScreenChangeNotify (0)
+// Size: 32
+
+const RandrScreenChangeNotify = 0
+
+type RandrScreenChangeNotifyEvent struct {
+	Sequence        uint16
+	Rotation        byte
+	Timestamp       Timestamp
+	ConfigTimestamp Timestamp
+	Root            Id
+	RequestWindow   Id
+	SizeID          uint16
+	SubpixelOrder   uint16
+	Width           uint16
+	Height          uint16
+	Mwidth          uint16
+	Mheight         uint16
+}
+
+// Event read RandrScreenChangeNotify
+func NewRandrScreenChangeNotifyEvent(buf []byte) Event {
+	v := RandrScreenChangeNotifyEvent{}
+	b := 1 // don't read event number
+
+	v.Rotation = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.RequestWindow = Id(Get32(buf[b:]))
+	b += 4
+
+	v.SizeID = Get16(buf[b:])
+	b += 2
+
+	v.SubpixelOrder = Get16(buf[b:])
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.Mwidth = Get16(buf[b:])
+	b += 2
+
+	v.Mheight = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+// Event write RandrScreenChangeNotify
+func (v RandrScreenChangeNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 0
+	b += 1
+
+	buf[b] = v.Rotation
+	b += 1
+
+	b += 2 // skip sequence number
+
+	Put32(buf[b:], uint32(v.Timestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(v.ConfigTimestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Root))
+	b += 4
+
+	Put32(buf[b:], uint32(v.RequestWindow))
+	b += 4
+
+	Put16(buf[b:], v.SizeID)
+	b += 2
+
+	Put16(buf[b:], v.SubpixelOrder)
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], v.Mwidth)
+	b += 2
+
+	Put16(buf[b:], v.Mheight)
+	b += 2
+
+	return buf
+}
+
+func (v RandrScreenChangeNotifyEvent) ImplementsEvent() {}
+
+func (v RandrScreenChangeNotifyEvent) SequenceId() uint16 {
+	return v.Sequence
+}
+
+func (v RandrScreenChangeNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 11)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Rotation: %d", v.Rotation))
+	fieldVals = append(fieldVals, sprintf("Timestamp: %d", v.Timestamp))
+	fieldVals = append(fieldVals, sprintf("ConfigTimestamp: %d", v.ConfigTimestamp))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("RequestWindow: %d", v.RequestWindow))
+	fieldVals = append(fieldVals, sprintf("SizeID: %d", v.SizeID))
+	fieldVals = append(fieldVals, sprintf("SubpixelOrder: %d", v.SubpixelOrder))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("Mwidth: %d", v.Mwidth))
+	fieldVals = append(fieldVals, sprintf("Mheight: %d", v.Mheight))
+	return "RandrScreenChangeNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newEventFuncs[0] = NewRandrScreenChangeNotifyEvent
+}
+
+// Event definition RandrNotify (1)
+// Size: 32
+
+const RandrNotify = 1
+
+type RandrNotifyEvent struct {
+	Sequence uint16
+	SubCode  byte
+	U        RandrNotifyDataUnion
+}
+
+// Event read RandrNotify
+func NewRandrNotifyEvent(buf []byte) Event {
+	v := RandrNotifyEvent{}
+	b := 1 // don't read event number
+
+	v.SubCode = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.U = RandrNotifyDataUnion{}
+	b += ReadRandrNotifyDataUnion(buf[b:], &v.U)
+
+	return v
+}
+
+// Event write RandrNotify
+func (v RandrNotifyEvent) Bytes() []byte {
+	buf := make([]byte, 32)
+	b := 0
+
+	// write event number
+	buf[b] = 1
+	b += 1
+
+	buf[b] = v.SubCode
+	b += 1
+
+	b += 2 // skip sequence number
+
+	{
+		unionBytes := v.U.Bytes()
+		copy(buf[b:], unionBytes)
+		b += pad(len(unionBytes))
+	}
+
+	return buf
+}
+
+func (v RandrNotifyEvent) ImplementsEvent() {}
+
+func (v RandrNotifyEvent) SequenceId() uint16 {
+	return v.Sequence
+}
+
+func (v RandrNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 2)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("SubCode: %d", v.SubCode))
+	return "RandrNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newEventFuncs[1] = NewRandrNotifyEvent
+}
+
+// Error definition RandrBadOutput (0)
+// Size: 32
+
+const BadRandrBadOutput = 0
+
+type RandrBadOutputError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RandrBadOutput
+func NewRandrBadOutputError(buf []byte) Error {
+	v := RandrBadOutputError{}
+	v.NiceName = "RandrBadOutput"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RandrBadOutputError) ImplementsError() {}
+
+func (err RandrBadOutputError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RandrBadOutputError) BadId() Id {
+	return 0
+}
+
+func (err RandrBadOutputError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRandrBadOutput {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[0] = NewRandrBadOutputError
+}
+
+// Error definition RandrBadCrtc (1)
+// Size: 32
+
+const BadRandrBadCrtc = 1
+
+type RandrBadCrtcError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RandrBadCrtc
+func NewRandrBadCrtcError(buf []byte) Error {
+	v := RandrBadCrtcError{}
+	v.NiceName = "RandrBadCrtc"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RandrBadCrtcError) ImplementsError() {}
+
+func (err RandrBadCrtcError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RandrBadCrtcError) BadId() Id {
+	return 0
+}
+
+func (err RandrBadCrtcError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRandrBadCrtc {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[1] = NewRandrBadCrtcError
+}
+
+// Error definition RandrBadMode (2)
+// Size: 32
+
+const BadRandrBadMode = 2
+
+type RandrBadModeError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RandrBadMode
+func NewRandrBadModeError(buf []byte) Error {
+	v := RandrBadModeError{}
+	v.NiceName = "RandrBadMode"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RandrBadModeError) ImplementsError() {}
+
+func (err RandrBadModeError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RandrBadModeError) BadId() Id {
+	return 0
+}
+
+func (err RandrBadModeError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRandrBadMode {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[2] = NewRandrBadModeError
+}
+
+// Request RandrQueryVersion
+// size: 12
+type RandrQueryVersionCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrQueryVersion(MajorVersion uint32, MinorVersion uint32) RandrQueryVersionCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrQueryVersionRequest(MajorVersion, MinorVersion), cookie)
+	return RandrQueryVersionCookie{cookie}
+}
+
+func (c *Conn) RandrQueryVersionUnchecked(MajorVersion uint32, MinorVersion uint32) RandrQueryVersionCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrQueryVersionRequest(MajorVersion, MinorVersion), cookie)
+	return RandrQueryVersionCookie{cookie}
+}
+
+// Request reply for RandrQueryVersion
+// size: 32
+type RandrQueryVersionReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	MajorVersion uint32
+	MinorVersion uint32
+	// padding: 16 bytes
+}
+
+// Waits and reads reply data from request RandrQueryVersion
+func (cook RandrQueryVersionCookie) Reply() (*RandrQueryVersionReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrQueryVersionReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrQueryVersion
+func randrQueryVersionReply(buf []byte) *RandrQueryVersionReply {
+	v := new(RandrQueryVersionReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.MajorVersion = Get32(buf[b:])
+	b += 4
+
+	v.MinorVersion = Get32(buf[b:])
+	b += 4
+
+	b += 16 // padding
+
+	return v
+}
+
+func (cook RandrQueryVersionCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrQueryVersion
+func (c *Conn) randrQueryVersionRequest(MajorVersion uint32, MinorVersion uint32) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 0 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], MajorVersion)
+	b += 4
+
+	Put32(buf[b:], MinorVersion)
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetScreenConfig
+// size: 24
+type RandrSetScreenConfigCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrSetScreenConfig(Window Id, Timestamp Timestamp, ConfigTimestamp Timestamp, SizeID uint16, Rotation uint16, Rate uint16) RandrSetScreenConfigCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrSetScreenConfigRequest(Window, Timestamp, ConfigTimestamp, SizeID, Rotation, Rate), cookie)
+	return RandrSetScreenConfigCookie{cookie}
+}
+
+func (c *Conn) RandrSetScreenConfigUnchecked(Window Id, Timestamp Timestamp, ConfigTimestamp Timestamp, SizeID uint16, Rotation uint16, Rate uint16) RandrSetScreenConfigCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrSetScreenConfigRequest(Window, Timestamp, ConfigTimestamp, SizeID, Rotation, Rate), cookie)
+	return RandrSetScreenConfigCookie{cookie}
+}
+
+// Request reply for RandrSetScreenConfig
+// size: 32
+type RandrSetScreenConfigReply struct {
+	Sequence        uint16
+	Length          uint32
+	Status          byte
+	NewTimestamp    Timestamp
+	ConfigTimestamp Timestamp
+	Root            Id
+	SubpixelOrder   uint16
+	// padding: 10 bytes
+}
+
+// Waits and reads reply data from request RandrSetScreenConfig
+func (cook RandrSetScreenConfigCookie) Reply() (*RandrSetScreenConfigReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrSetScreenConfigReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrSetScreenConfig
+func randrSetScreenConfigReply(buf []byte) *RandrSetScreenConfigReply {
+	v := new(RandrSetScreenConfigReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NewTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.SubpixelOrder = Get16(buf[b:])
+	b += 2
+
+	b += 10 // padding
+
+	return v
+}
+
+func (cook RandrSetScreenConfigCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetScreenConfig
+func (c *Conn) randrSetScreenConfigRequest(Window Id, Timestamp Timestamp, ConfigTimestamp Timestamp, SizeID uint16, Rotation uint16, Rate uint16) []byte {
+	size := 24
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 2 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Timestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(ConfigTimestamp))
+	b += 4
+
+	Put16(buf[b:], SizeID)
+	b += 2
+
+	Put16(buf[b:], Rotation)
+	b += 2
+
+	Put16(buf[b:], Rate)
+	b += 2
+
+	b += 2 // padding
+
+	return buf
+}
+
+// Request RandrSelectInput
+// size: 12
+type RandrSelectInputCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrSelectInput
+func (c *Conn) RandrSelectInput(Window Id, Enable uint16) RandrSelectInputCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrSelectInputRequest(Window, Enable), cookie)
+	return RandrSelectInputCookie{cookie}
+}
+
+func (c *Conn) RandrSelectInputChecked(Window Id, Enable uint16) RandrSelectInputCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrSelectInputRequest(Window, Enable), cookie)
+	return RandrSelectInputCookie{cookie}
+}
+
+func (cook RandrSelectInputCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSelectInput
+func (c *Conn) randrSelectInputRequest(Window Id, Enable uint16) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 4 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], Enable)
+	b += 2
+
+	b += 2 // padding
+
+	return buf
+}
+
+// Request RandrGetScreenInfo
+// size: 8
+type RandrGetScreenInfoCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetScreenInfo(Window Id) RandrGetScreenInfoCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetScreenInfoRequest(Window), cookie)
+	return RandrGetScreenInfoCookie{cookie}
+}
+
+func (c *Conn) RandrGetScreenInfoUnchecked(Window Id) RandrGetScreenInfoCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetScreenInfoRequest(Window), cookie)
+	return RandrGetScreenInfoCookie{cookie}
+}
+
+// Request reply for RandrGetScreenInfo
+// size: ((32 + pad((int(NSizes) * 8))) + RandrRefreshRatesListSize(Rates))
+type RandrGetScreenInfoReply struct {
+	Sequence        uint16
+	Length          uint32
+	Rotations       byte
+	Root            Id
+	Timestamp       Timestamp
+	ConfigTimestamp Timestamp
+	NSizes          uint16
+	SizeID          uint16
+	Rotation        uint16
+	Rate            uint16
+	NInfo           uint16
+	// padding: 2 bytes
+	Sizes []RandrScreenSize   // size: pad((int(NSizes) * 8))
+	Rates []RandrRefreshRates // size: RandrRefreshRatesListSize(Rates)
+}
+
+// Waits and reads reply data from request RandrGetScreenInfo
+func (cook RandrGetScreenInfoCookie) Reply() (*RandrGetScreenInfoReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetScreenInfoReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetScreenInfo
+func randrGetScreenInfoReply(buf []byte) *RandrGetScreenInfoReply {
+	v := new(RandrGetScreenInfoReply)
+	b := 1 // skip reply determinant
+
+	v.Rotations = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Root = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.NSizes = Get16(buf[b:])
+	b += 2
+
+	v.SizeID = Get16(buf[b:])
+	b += 2
+
+	v.Rotation = Get16(buf[b:])
+	b += 2
+
+	v.Rate = Get16(buf[b:])
+	b += 2
+
+	v.NInfo = Get16(buf[b:])
+	b += 2
+
+	b += 2 // padding
+
+	v.Sizes = make([]RandrScreenSize, v.NSizes)
+	b += ReadRandrScreenSizeList(buf[b:], v.Sizes)
+
+	v.Rates = make([]RandrRefreshRates, (int(v.NInfo) - int(v.NSizes)))
+	b += ReadRandrRefreshRatesList(buf[b:], v.Rates)
+
+	return v
+}
+
+func (cook RandrGetScreenInfoCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetScreenInfo
+func (c *Conn) randrGetScreenInfoRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 5 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetScreenSizeRange
+// size: 8
+type RandrGetScreenSizeRangeCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetScreenSizeRange(Window Id) RandrGetScreenSizeRangeCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetScreenSizeRangeRequest(Window), cookie)
+	return RandrGetScreenSizeRangeCookie{cookie}
+}
+
+func (c *Conn) RandrGetScreenSizeRangeUnchecked(Window Id) RandrGetScreenSizeRangeCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetScreenSizeRangeRequest(Window), cookie)
+	return RandrGetScreenSizeRangeCookie{cookie}
+}
+
+// Request reply for RandrGetScreenSizeRange
+// size: 32
+type RandrGetScreenSizeRangeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	MinWidth  uint16
+	MinHeight uint16
+	MaxWidth  uint16
+	MaxHeight uint16
+	// padding: 16 bytes
+}
+
+// Waits and reads reply data from request RandrGetScreenSizeRange
+func (cook RandrGetScreenSizeRangeCookie) Reply() (*RandrGetScreenSizeRangeReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetScreenSizeRangeReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetScreenSizeRange
+func randrGetScreenSizeRangeReply(buf []byte) *RandrGetScreenSizeRangeReply {
+	v := new(RandrGetScreenSizeRangeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.MinWidth = Get16(buf[b:])
+	b += 2
+
+	v.MinHeight = Get16(buf[b:])
+	b += 2
+
+	v.MaxWidth = Get16(buf[b:])
+	b += 2
+
+	v.MaxHeight = Get16(buf[b:])
+	b += 2
+
+	b += 16 // padding
+
+	return v
+}
+
+func (cook RandrGetScreenSizeRangeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetScreenSizeRange
+func (c *Conn) randrGetScreenSizeRangeRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 6 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetScreenSize
+// size: 20
+type RandrSetScreenSizeCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrSetScreenSize
+func (c *Conn) RandrSetScreenSize(Window Id, Width uint16, Height uint16, MmWidth uint32, MmHeight uint32) RandrSetScreenSizeCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrSetScreenSizeRequest(Window, Width, Height, MmWidth, MmHeight), cookie)
+	return RandrSetScreenSizeCookie{cookie}
+}
+
+func (c *Conn) RandrSetScreenSizeChecked(Window Id, Width uint16, Height uint16, MmWidth uint32, MmHeight uint32) RandrSetScreenSizeCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrSetScreenSizeRequest(Window, Width, Height, MmWidth, MmHeight), cookie)
+	return RandrSetScreenSizeCookie{cookie}
+}
+
+func (cook RandrSetScreenSizeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetScreenSize
+func (c *Conn) randrSetScreenSizeRequest(Window Id, Width uint16, Height uint16, MmWidth uint32, MmHeight uint32) []byte {
+	size := 20
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 7 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put32(buf[b:], MmWidth)
+	b += 4
+
+	Put32(buf[b:], MmHeight)
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetScreenResources
+// size: 8
+type RandrGetScreenResourcesCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetScreenResources(Window Id) RandrGetScreenResourcesCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetScreenResourcesRequest(Window), cookie)
+	return RandrGetScreenResourcesCookie{cookie}
+}
+
+func (c *Conn) RandrGetScreenResourcesUnchecked(Window Id) RandrGetScreenResourcesCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetScreenResourcesRequest(Window), cookie)
+	return RandrGetScreenResourcesCookie{cookie}
+}
+
+// Request reply for RandrGetScreenResources
+// size: ((((32 + pad((int(NumCrtcs) * 4))) + pad((int(NumOutputs) * 4))) + pad((int(NumModes) * 32))) + pad((int(NamesLen) * 1)))
+type RandrGetScreenResourcesReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Timestamp       Timestamp
+	ConfigTimestamp Timestamp
+	NumCrtcs        uint16
+	NumOutputs      uint16
+	NumModes        uint16
+	NamesLen        uint16
+	// padding: 8 bytes
+	Crtcs   []Id            // size: pad((int(NumCrtcs) * 4))
+	Outputs []Id            // size: pad((int(NumOutputs) * 4))
+	Modes   []RandrModeInfo // size: pad((int(NumModes) * 32))
+	Names   []byte          // size: pad((int(NamesLen) * 1))
+}
+
+// Waits and reads reply data from request RandrGetScreenResources
+func (cook RandrGetScreenResourcesCookie) Reply() (*RandrGetScreenResourcesReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetScreenResourcesReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetScreenResources
+func randrGetScreenResourcesReply(buf []byte) *RandrGetScreenResourcesReply {
+	v := new(RandrGetScreenResourcesReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.NumCrtcs = Get16(buf[b:])
+	b += 2
+
+	v.NumOutputs = Get16(buf[b:])
+	b += 2
+
+	v.NumModes = Get16(buf[b:])
+	b += 2
+
+	v.NamesLen = Get16(buf[b:])
+	b += 2
+
+	b += 8 // padding
+
+	v.Crtcs = make([]Id, v.NumCrtcs)
+	for i := 0; i < int(v.NumCrtcs); i++ {
+		v.Crtcs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Outputs = make([]Id, v.NumOutputs)
+	for i := 0; i < int(v.NumOutputs); i++ {
+		v.Outputs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Modes = make([]RandrModeInfo, v.NumModes)
+	b += ReadRandrModeInfoList(buf[b:], v.Modes)
+
+	v.Names = make([]byte, v.NamesLen)
+	copy(v.Names[:v.NamesLen], buf[b:])
+	b += pad(int(v.NamesLen))
+
+	return v
+}
+
+func (cook RandrGetScreenResourcesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetScreenResources
+func (c *Conn) randrGetScreenResourcesRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 8 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetOutputInfo
+// size: 12
+type RandrGetOutputInfoCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetOutputInfo(Output Id, ConfigTimestamp Timestamp) RandrGetOutputInfoCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetOutputInfoRequest(Output, ConfigTimestamp), cookie)
+	return RandrGetOutputInfoCookie{cookie}
+}
+
+func (c *Conn) RandrGetOutputInfoUnchecked(Output Id, ConfigTimestamp Timestamp) RandrGetOutputInfoCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetOutputInfoRequest(Output, ConfigTimestamp), cookie)
+	return RandrGetOutputInfoCookie{cookie}
+}
+
+// Request reply for RandrGetOutputInfo
+// size: ((((36 + pad((int(NumCrtcs) * 4))) + pad((int(NumModes) * 4))) + pad((int(NumClones) * 4))) + pad((int(NameLen) * 1)))
+type RandrGetOutputInfoReply struct {
+	Sequence      uint16
+	Length        uint32
+	Status        byte
+	Timestamp     Timestamp
+	Crtc          Id
+	MmWidth       uint32
+	MmHeight      uint32
+	Connection    byte
+	SubpixelOrder byte
+	NumCrtcs      uint16
+	NumModes      uint16
+	NumPreferred  uint16
+	NumClones     uint16
+	NameLen       uint16
+	Crtcs         []Id   // size: pad((int(NumCrtcs) * 4))
+	Modes         []Id   // size: pad((int(NumModes) * 4))
+	Clones        []Id   // size: pad((int(NumClones) * 4))
+	Name          []byte // size: pad((int(NameLen) * 1))
+}
+
+// Waits and reads reply data from request RandrGetOutputInfo
+func (cook RandrGetOutputInfoCookie) Reply() (*RandrGetOutputInfoReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetOutputInfoReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetOutputInfo
+func randrGetOutputInfoReply(buf []byte) *RandrGetOutputInfoReply {
+	v := new(RandrGetOutputInfoReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Crtc = Id(Get32(buf[b:]))
+	b += 4
+
+	v.MmWidth = Get32(buf[b:])
+	b += 4
+
+	v.MmHeight = Get32(buf[b:])
+	b += 4
+
+	v.Connection = buf[b]
+	b += 1
+
+	v.SubpixelOrder = buf[b]
+	b += 1
+
+	v.NumCrtcs = Get16(buf[b:])
+	b += 2
+
+	v.NumModes = Get16(buf[b:])
+	b += 2
+
+	v.NumPreferred = Get16(buf[b:])
+	b += 2
+
+	v.NumClones = Get16(buf[b:])
+	b += 2
+
+	v.NameLen = Get16(buf[b:])
+	b += 2
+
+	v.Crtcs = make([]Id, v.NumCrtcs)
+	for i := 0; i < int(v.NumCrtcs); i++ {
+		v.Crtcs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Modes = make([]Id, v.NumModes)
+	for i := 0; i < int(v.NumModes); i++ {
+		v.Modes[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Clones = make([]Id, v.NumClones)
+	for i := 0; i < int(v.NumClones); i++ {
+		v.Clones[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Name = make([]byte, v.NameLen)
+	copy(v.Name[:v.NameLen], buf[b:])
+	b += pad(int(v.NameLen))
+
+	return v
+}
+
+func (cook RandrGetOutputInfoCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetOutputInfo
+func (c *Conn) randrGetOutputInfoRequest(Output Id, ConfigTimestamp Timestamp) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 9 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(ConfigTimestamp))
+	b += 4
+
+	return buf
+}
+
+// Request RandrListOutputProperties
+// size: 8
+type RandrListOutputPropertiesCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrListOutputProperties(Output Id) RandrListOutputPropertiesCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrListOutputPropertiesRequest(Output), cookie)
+	return RandrListOutputPropertiesCookie{cookie}
+}
+
+func (c *Conn) RandrListOutputPropertiesUnchecked(Output Id) RandrListOutputPropertiesCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrListOutputPropertiesRequest(Output), cookie)
+	return RandrListOutputPropertiesCookie{cookie}
+}
+
+// Request reply for RandrListOutputProperties
+// size: (32 + pad((int(NumAtoms) * 4)))
+type RandrListOutputPropertiesReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NumAtoms uint16
+	// padding: 22 bytes
+	Atoms []Id // size: pad((int(NumAtoms) * 4))
+}
+
+// Waits and reads reply data from request RandrListOutputProperties
+func (cook RandrListOutputPropertiesCookie) Reply() (*RandrListOutputPropertiesReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrListOutputPropertiesReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrListOutputProperties
+func randrListOutputPropertiesReply(buf []byte) *RandrListOutputPropertiesReply {
+	v := new(RandrListOutputPropertiesReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NumAtoms = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Atoms = make([]Id, v.NumAtoms)
+	for i := 0; i < int(v.NumAtoms); i++ {
+		v.Atoms[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RandrListOutputPropertiesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrListOutputProperties
+func (c *Conn) randrListOutputPropertiesRequest(Output Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 10 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	return buf
+}
+
+// Request RandrQueryOutputProperty
+// size: 12
+type RandrQueryOutputPropertyCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrQueryOutputProperty(Output Id, Property Id) RandrQueryOutputPropertyCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrQueryOutputPropertyRequest(Output, Property), cookie)
+	return RandrQueryOutputPropertyCookie{cookie}
+}
+
+func (c *Conn) RandrQueryOutputPropertyUnchecked(Output Id, Property Id) RandrQueryOutputPropertyCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrQueryOutputPropertyRequest(Output, Property), cookie)
+	return RandrQueryOutputPropertyCookie{cookie}
+}
+
+// Request reply for RandrQueryOutputProperty
+// size: (32 + pad((int(Length) * 4)))
+type RandrQueryOutputPropertyReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Pending   bool
+	Range     bool
+	Immutable bool
+	// padding: 21 bytes
+	ValidValues []int32 // size: pad((int(Length) * 4))
+}
+
+// Waits and reads reply data from request RandrQueryOutputProperty
+func (cook RandrQueryOutputPropertyCookie) Reply() (*RandrQueryOutputPropertyReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrQueryOutputPropertyReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrQueryOutputProperty
+func randrQueryOutputPropertyReply(buf []byte) *RandrQueryOutputPropertyReply {
+	v := new(RandrQueryOutputPropertyReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	if buf[b] == 1 {
+		v.Pending = true
+	} else {
+		v.Pending = false
+	}
+	b += 1
+
+	if buf[b] == 1 {
+		v.Range = true
+	} else {
+		v.Range = false
+	}
+	b += 1
+
+	if buf[b] == 1 {
+		v.Immutable = true
+	} else {
+		v.Immutable = false
+	}
+	b += 1
+
+	b += 21 // padding
+
+	v.ValidValues = make([]int32, v.Length)
+	for i := 0; i < int(v.Length); i++ {
+		v.ValidValues[i] = int32(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RandrQueryOutputPropertyCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrQueryOutputProperty
+func (c *Conn) randrQueryOutputPropertyRequest(Output Id, Property Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 11 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	return buf
+}
+
+// Request RandrConfigureOutputProperty
+// size: pad((16 + pad((len(Values) * 4))))
+type RandrConfigureOutputPropertyCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrConfigureOutputProperty
+func (c *Conn) RandrConfigureOutputProperty(Output Id, Property Id, Pending bool, Range bool, Values []int32) RandrConfigureOutputPropertyCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrConfigureOutputPropertyRequest(Output, Property, Pending, Range, Values), cookie)
+	return RandrConfigureOutputPropertyCookie{cookie}
+}
+
+func (c *Conn) RandrConfigureOutputPropertyChecked(Output Id, Property Id, Pending bool, Range bool, Values []int32) RandrConfigureOutputPropertyCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrConfigureOutputPropertyRequest(Output, Property, Pending, Range, Values), cookie)
+	return RandrConfigureOutputPropertyCookie{cookie}
+}
+
+func (cook RandrConfigureOutputPropertyCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrConfigureOutputProperty
+func (c *Conn) randrConfigureOutputPropertyRequest(Output Id, Property Id, Pending bool, Range bool, Values []int32) []byte {
+	size := pad((16 + pad((len(Values) * 4))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 12 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	if Pending {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	if Range {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 2 // padding
+
+	for i := 0; i < int(len(Values)); i++ {
+		Put32(buf[b:], uint32(Values[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RandrChangeOutputProperty
+// size: pad((24 + pad((((int(NumUnits) * int(Format)) / 8) * 1))))
+type RandrChangeOutputPropertyCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrChangeOutputProperty
+func (c *Conn) RandrChangeOutputProperty(Output Id, Property Id, Type Id, Format byte, Mode byte, NumUnits uint32, Data []byte) RandrChangeOutputPropertyCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrChangeOutputPropertyRequest(Output, Property, Type, Format, Mode, NumUnits, Data), cookie)
+	return RandrChangeOutputPropertyCookie{cookie}
+}
+
+func (c *Conn) RandrChangeOutputPropertyChecked(Output Id, Property Id, Type Id, Format byte, Mode byte, NumUnits uint32, Data []byte) RandrChangeOutputPropertyCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrChangeOutputPropertyRequest(Output, Property, Type, Format, Mode, NumUnits, Data), cookie)
+	return RandrChangeOutputPropertyCookie{cookie}
+}
+
+func (cook RandrChangeOutputPropertyCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrChangeOutputProperty
+func (c *Conn) randrChangeOutputPropertyRequest(Output Id, Property Id, Type Id, Format byte, Mode byte, NumUnits uint32, Data []byte) []byte {
+	size := pad((24 + pad((((int(NumUnits) * int(Format)) / 8) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 13 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	Put32(buf[b:], uint32(Type))
+	b += 4
+
+	buf[b] = Format
+	b += 1
+
+	buf[b] = Mode
+	b += 1
+
+	b += 2 // padding
+
+	Put32(buf[b:], NumUnits)
+	b += 4
+
+	copy(buf[b:], Data[:((int(NumUnits)*int(Format))/8)])
+	b += pad(int(((int(NumUnits) * int(Format)) / 8)))
+
+	return buf
+}
+
+// Request RandrDeleteOutputProperty
+// size: 12
+type RandrDeleteOutputPropertyCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrDeleteOutputProperty
+func (c *Conn) RandrDeleteOutputProperty(Output Id, Property Id) RandrDeleteOutputPropertyCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrDeleteOutputPropertyRequest(Output, Property), cookie)
+	return RandrDeleteOutputPropertyCookie{cookie}
+}
+
+func (c *Conn) RandrDeleteOutputPropertyChecked(Output Id, Property Id) RandrDeleteOutputPropertyCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrDeleteOutputPropertyRequest(Output, Property), cookie)
+	return RandrDeleteOutputPropertyCookie{cookie}
+}
+
+func (cook RandrDeleteOutputPropertyCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrDeleteOutputProperty
+func (c *Conn) randrDeleteOutputPropertyRequest(Output Id, Property Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 14 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetOutputProperty
+// size: 28
+type RandrGetOutputPropertyCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetOutputProperty(Output Id, Property Id, Type Id, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) RandrGetOutputPropertyCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetOutputPropertyRequest(Output, Property, Type, LongOffset, LongLength, Delete, Pending), cookie)
+	return RandrGetOutputPropertyCookie{cookie}
+}
+
+func (c *Conn) RandrGetOutputPropertyUnchecked(Output Id, Property Id, Type Id, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) RandrGetOutputPropertyCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetOutputPropertyRequest(Output, Property, Type, LongOffset, LongLength, Delete, Pending), cookie)
+	return RandrGetOutputPropertyCookie{cookie}
+}
+
+// Request reply for RandrGetOutputProperty
+// size: (32 + pad(((int(NumItems) * (int(Format) / 8)) * 1)))
+type RandrGetOutputPropertyReply struct {
+	Sequence   uint16
+	Length     uint32
+	Format     byte
+	Type       Id
+	BytesAfter uint32
+	NumItems   uint32
+	// padding: 12 bytes
+	Data []byte // size: pad(((int(NumItems) * (int(Format) / 8)) * 1))
+}
+
+// Waits and reads reply data from request RandrGetOutputProperty
+func (cook RandrGetOutputPropertyCookie) Reply() (*RandrGetOutputPropertyReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetOutputPropertyReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetOutputProperty
+func randrGetOutputPropertyReply(buf []byte) *RandrGetOutputPropertyReply {
+	v := new(RandrGetOutputPropertyReply)
+	b := 1 // skip reply determinant
+
+	v.Format = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Type = Id(Get32(buf[b:]))
+	b += 4
+
+	v.BytesAfter = Get32(buf[b:])
+	b += 4
+
+	v.NumItems = Get32(buf[b:])
+	b += 4
+
+	b += 12 // padding
+
+	v.Data = make([]byte, (int(v.NumItems) * (int(v.Format) / 8)))
+	copy(v.Data[:(int(v.NumItems)*(int(v.Format)/8))], buf[b:])
+	b += pad(int((int(v.NumItems) * (int(v.Format) / 8))))
+
+	return v
+}
+
+func (cook RandrGetOutputPropertyCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetOutputProperty
+func (c *Conn) randrGetOutputPropertyRequest(Output Id, Property Id, Type Id, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) []byte {
+	size := 28
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 15 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Property))
+	b += 4
+
+	Put32(buf[b:], uint32(Type))
+	b += 4
+
+	Put32(buf[b:], LongOffset)
+	b += 4
+
+	Put32(buf[b:], LongLength)
+	b += 4
+
+	if Delete {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	if Pending {
+		buf[b] = 1
+	} else {
+		buf[b] = 0
+	}
+	b += 1
+
+	b += 2 // padding
+
+	return buf
+}
+
+// Request RandrCreateMode
+// size: pad((40 + pad((len(Name) * 1))))
+type RandrCreateModeCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrCreateMode(Window Id, ModeInfo RandrModeInfo, Name string) RandrCreateModeCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrCreateModeRequest(Window, ModeInfo, Name), cookie)
+	return RandrCreateModeCookie{cookie}
+}
+
+func (c *Conn) RandrCreateModeUnchecked(Window Id, ModeInfo RandrModeInfo, Name string) RandrCreateModeCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrCreateModeRequest(Window, ModeInfo, Name), cookie)
+	return RandrCreateModeCookie{cookie}
+}
+
+// Request reply for RandrCreateMode
+// size: 32
+type RandrCreateModeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Mode Id
+	// padding: 20 bytes
+}
+
+// Waits and reads reply data from request RandrCreateMode
+func (cook RandrCreateModeCookie) Reply() (*RandrCreateModeReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrCreateModeReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrCreateMode
+func randrCreateModeReply(buf []byte) *RandrCreateModeReply {
+	v := new(RandrCreateModeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Mode = Id(Get32(buf[b:]))
+	b += 4
+
+	b += 20 // padding
+
+	return v
+}
+
+func (cook RandrCreateModeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrCreateMode
+func (c *Conn) randrCreateModeRequest(Window Id, ModeInfo RandrModeInfo, Name string) []byte {
+	size := pad((40 + pad((len(Name) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 16 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	{
+		structBytes := ModeInfo.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	copy(buf[b:], Name[:len(Name)])
+	b += pad(int(len(Name)))
+
+	return buf
+}
+
+// Request RandrDestroyMode
+// size: 8
+type RandrDestroyModeCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrDestroyMode
+func (c *Conn) RandrDestroyMode(Mode Id) RandrDestroyModeCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrDestroyModeRequest(Mode), cookie)
+	return RandrDestroyModeCookie{cookie}
+}
+
+func (c *Conn) RandrDestroyModeChecked(Mode Id) RandrDestroyModeCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrDestroyModeRequest(Mode), cookie)
+	return RandrDestroyModeCookie{cookie}
+}
+
+func (cook RandrDestroyModeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrDestroyMode
+func (c *Conn) randrDestroyModeRequest(Mode Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 17 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Mode))
+	b += 4
+
+	return buf
+}
+
+// Request RandrAddOutputMode
+// size: 12
+type RandrAddOutputModeCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrAddOutputMode
+func (c *Conn) RandrAddOutputMode(Output Id, Mode Id) RandrAddOutputModeCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrAddOutputModeRequest(Output, Mode), cookie)
+	return RandrAddOutputModeCookie{cookie}
+}
+
+func (c *Conn) RandrAddOutputModeChecked(Output Id, Mode Id) RandrAddOutputModeCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrAddOutputModeRequest(Output, Mode), cookie)
+	return RandrAddOutputModeCookie{cookie}
+}
+
+func (cook RandrAddOutputModeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrAddOutputMode
+func (c *Conn) randrAddOutputModeRequest(Output Id, Mode Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 18 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Mode))
+	b += 4
+
+	return buf
+}
+
+// Request RandrDeleteOutputMode
+// size: 12
+type RandrDeleteOutputModeCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrDeleteOutputMode
+func (c *Conn) RandrDeleteOutputMode(Output Id, Mode Id) RandrDeleteOutputModeCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrDeleteOutputModeRequest(Output, Mode), cookie)
+	return RandrDeleteOutputModeCookie{cookie}
+}
+
+func (c *Conn) RandrDeleteOutputModeChecked(Output Id, Mode Id) RandrDeleteOutputModeCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrDeleteOutputModeRequest(Output, Mode), cookie)
+	return RandrDeleteOutputModeCookie{cookie}
+}
+
+func (cook RandrDeleteOutputModeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrDeleteOutputMode
+func (c *Conn) randrDeleteOutputModeRequest(Output Id, Mode Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 19 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	Put32(buf[b:], uint32(Mode))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetCrtcInfo
+// size: 12
+type RandrGetCrtcInfoCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetCrtcInfo(Crtc Id, ConfigTimestamp Timestamp) RandrGetCrtcInfoCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetCrtcInfoRequest(Crtc, ConfigTimestamp), cookie)
+	return RandrGetCrtcInfoCookie{cookie}
+}
+
+func (c *Conn) RandrGetCrtcInfoUnchecked(Crtc Id, ConfigTimestamp Timestamp) RandrGetCrtcInfoCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetCrtcInfoRequest(Crtc, ConfigTimestamp), cookie)
+	return RandrGetCrtcInfoCookie{cookie}
+}
+
+// Request reply for RandrGetCrtcInfo
+// size: ((32 + pad((int(NumOutputs) * 4))) + pad((int(NumPossibleOutputs) * 4)))
+type RandrGetCrtcInfoReply struct {
+	Sequence           uint16
+	Length             uint32
+	Status             byte
+	Timestamp          Timestamp
+	X                  int16
+	Y                  int16
+	Width              uint16
+	Height             uint16
+	Mode               Id
+	Rotation           uint16
+	Rotations          uint16
+	NumOutputs         uint16
+	NumPossibleOutputs uint16
+	Outputs            []Id // size: pad((int(NumOutputs) * 4))
+	Possible           []Id // size: pad((int(NumPossibleOutputs) * 4))
+}
+
+// Waits and reads reply data from request RandrGetCrtcInfo
+func (cook RandrGetCrtcInfoCookie) Reply() (*RandrGetCrtcInfoReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetCrtcInfoReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetCrtcInfo
+func randrGetCrtcInfoReply(buf []byte) *RandrGetCrtcInfoReply {
+	v := new(RandrGetCrtcInfoReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.Mode = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Rotation = Get16(buf[b:])
+	b += 2
+
+	v.Rotations = Get16(buf[b:])
+	b += 2
+
+	v.NumOutputs = Get16(buf[b:])
+	b += 2
+
+	v.NumPossibleOutputs = Get16(buf[b:])
+	b += 2
+
+	v.Outputs = make([]Id, v.NumOutputs)
+	for i := 0; i < int(v.NumOutputs); i++ {
+		v.Outputs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Possible = make([]Id, v.NumPossibleOutputs)
+	for i := 0; i < int(v.NumPossibleOutputs); i++ {
+		v.Possible[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RandrGetCrtcInfoCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetCrtcInfo
+func (c *Conn) randrGetCrtcInfoRequest(Crtc Id, ConfigTimestamp Timestamp) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 20 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	Put32(buf[b:], uint32(ConfigTimestamp))
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetCrtcConfig
+// size: pad((28 + pad((len(Outputs) * 4))))
+type RandrSetCrtcConfigCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrSetCrtcConfig(Crtc Id, Timestamp Timestamp, ConfigTimestamp Timestamp, X int16, Y int16, Mode Id, Rotation uint16, Outputs []Id) RandrSetCrtcConfigCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrSetCrtcConfigRequest(Crtc, Timestamp, ConfigTimestamp, X, Y, Mode, Rotation, Outputs), cookie)
+	return RandrSetCrtcConfigCookie{cookie}
+}
+
+func (c *Conn) RandrSetCrtcConfigUnchecked(Crtc Id, Timestamp Timestamp, ConfigTimestamp Timestamp, X int16, Y int16, Mode Id, Rotation uint16, Outputs []Id) RandrSetCrtcConfigCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrSetCrtcConfigRequest(Crtc, Timestamp, ConfigTimestamp, X, Y, Mode, Rotation, Outputs), cookie)
+	return RandrSetCrtcConfigCookie{cookie}
+}
+
+// Request reply for RandrSetCrtcConfig
+// size: 32
+type RandrSetCrtcConfigReply struct {
+	Sequence  uint16
+	Length    uint32
+	Status    byte
+	Timestamp Timestamp
+	// padding: 20 bytes
+}
+
+// Waits and reads reply data from request RandrSetCrtcConfig
+func (cook RandrSetCrtcConfigCookie) Reply() (*RandrSetCrtcConfigReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrSetCrtcConfigReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrSetCrtcConfig
+func randrSetCrtcConfigReply(buf []byte) *RandrSetCrtcConfigReply {
+	v := new(RandrSetCrtcConfigReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	b += 20 // padding
+
+	return v
+}
+
+func (cook RandrSetCrtcConfigCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetCrtcConfig
+func (c *Conn) randrSetCrtcConfigRequest(Crtc Id, Timestamp Timestamp, ConfigTimestamp Timestamp, X int16, Y int16, Mode Id, Rotation uint16, Outputs []Id) []byte {
+	size := pad((28 + pad((len(Outputs) * 4))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 21 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	Put32(buf[b:], uint32(Timestamp))
+	b += 4
+
+	Put32(buf[b:], uint32(ConfigTimestamp))
+	b += 4
+
+	Put16(buf[b:], uint16(X))
+	b += 2
+
+	Put16(buf[b:], uint16(Y))
+	b += 2
+
+	Put32(buf[b:], uint32(Mode))
+	b += 4
+
+	Put16(buf[b:], Rotation)
+	b += 2
+
+	b += 2 // padding
+
+	for i := 0; i < int(len(Outputs)); i++ {
+		Put32(buf[b:], uint32(Outputs[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RandrGetCrtcGammaSize
+// size: 8
+type RandrGetCrtcGammaSizeCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetCrtcGammaSize(Crtc Id) RandrGetCrtcGammaSizeCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetCrtcGammaSizeRequest(Crtc), cookie)
+	return RandrGetCrtcGammaSizeCookie{cookie}
+}
+
+func (c *Conn) RandrGetCrtcGammaSizeUnchecked(Crtc Id) RandrGetCrtcGammaSizeCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetCrtcGammaSizeRequest(Crtc), cookie)
+	return RandrGetCrtcGammaSizeCookie{cookie}
+}
+
+// Request reply for RandrGetCrtcGammaSize
+// size: 32
+type RandrGetCrtcGammaSizeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Size uint16
+	// padding: 22 bytes
+}
+
+// Waits and reads reply data from request RandrGetCrtcGammaSize
+func (cook RandrGetCrtcGammaSizeCookie) Reply() (*RandrGetCrtcGammaSizeReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetCrtcGammaSizeReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetCrtcGammaSize
+func randrGetCrtcGammaSizeReply(buf []byte) *RandrGetCrtcGammaSizeReply {
+	v := new(RandrGetCrtcGammaSizeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Size = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	return v
+}
+
+func (cook RandrGetCrtcGammaSizeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetCrtcGammaSize
+func (c *Conn) randrGetCrtcGammaSizeRequest(Crtc Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 22 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetCrtcGamma
+// size: 8
+type RandrGetCrtcGammaCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetCrtcGamma(Crtc Id) RandrGetCrtcGammaCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetCrtcGammaRequest(Crtc), cookie)
+	return RandrGetCrtcGammaCookie{cookie}
+}
+
+func (c *Conn) RandrGetCrtcGammaUnchecked(Crtc Id) RandrGetCrtcGammaCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetCrtcGammaRequest(Crtc), cookie)
+	return RandrGetCrtcGammaCookie{cookie}
+}
+
+// Request reply for RandrGetCrtcGamma
+// size: (((32 + pad((int(Size) * 2))) + pad((int(Size) * 2))) + pad((int(Size) * 2)))
+type RandrGetCrtcGammaReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Size uint16
+	// padding: 22 bytes
+	Red   []uint16 // size: pad((int(Size) * 2))
+	Green []uint16 // size: pad((int(Size) * 2))
+	Blue  []uint16 // size: pad((int(Size) * 2))
+}
+
+// Waits and reads reply data from request RandrGetCrtcGamma
+func (cook RandrGetCrtcGammaCookie) Reply() (*RandrGetCrtcGammaReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetCrtcGammaReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetCrtcGamma
+func randrGetCrtcGammaReply(buf []byte) *RandrGetCrtcGammaReply {
+	v := new(RandrGetCrtcGammaReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Size = Get16(buf[b:])
+	b += 2
+
+	b += 22 // padding
+
+	v.Red = make([]uint16, v.Size)
+	for i := 0; i < int(v.Size); i++ {
+		v.Red[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	v.Green = make([]uint16, v.Size)
+	for i := 0; i < int(v.Size); i++ {
+		v.Green[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	v.Blue = make([]uint16, v.Size)
+	for i := 0; i < int(v.Size); i++ {
+		v.Blue[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RandrGetCrtcGammaCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetCrtcGamma
+func (c *Conn) randrGetCrtcGammaRequest(Crtc Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 23 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetCrtcGamma
+// size: pad((((12 + pad((int(Size) * 2))) + pad((int(Size) * 2))) + pad((int(Size) * 2))))
+type RandrSetCrtcGammaCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrSetCrtcGamma
+func (c *Conn) RandrSetCrtcGamma(Crtc Id, Size uint16, Red []uint16, Green []uint16, Blue []uint16) RandrSetCrtcGammaCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrSetCrtcGammaRequest(Crtc, Size, Red, Green, Blue), cookie)
+	return RandrSetCrtcGammaCookie{cookie}
+}
+
+func (c *Conn) RandrSetCrtcGammaChecked(Crtc Id, Size uint16, Red []uint16, Green []uint16, Blue []uint16) RandrSetCrtcGammaCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrSetCrtcGammaRequest(Crtc, Size, Red, Green, Blue), cookie)
+	return RandrSetCrtcGammaCookie{cookie}
+}
+
+func (cook RandrSetCrtcGammaCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetCrtcGamma
+func (c *Conn) randrSetCrtcGammaRequest(Crtc Id, Size uint16, Red []uint16, Green []uint16, Blue []uint16) []byte {
+	size := pad((((12 + pad((int(Size) * 2))) + pad((int(Size) * 2))) + pad((int(Size) * 2))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 24 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	Put16(buf[b:], Size)
+	b += 2
+
+	b += 2 // padding
+
+	for i := 0; i < int(Size); i++ {
+		Put16(buf[b:], Red[i])
+		b += 2
+	}
+	b = pad(b)
+
+	for i := 0; i < int(Size); i++ {
+		Put16(buf[b:], Green[i])
+		b += 2
+	}
+	b = pad(b)
+
+	for i := 0; i < int(Size); i++ {
+		Put16(buf[b:], Blue[i])
+		b += 2
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RandrGetScreenResourcesCurrent
+// size: 8
+type RandrGetScreenResourcesCurrentCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetScreenResourcesCurrent(Window Id) RandrGetScreenResourcesCurrentCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetScreenResourcesCurrentRequest(Window), cookie)
+	return RandrGetScreenResourcesCurrentCookie{cookie}
+}
+
+func (c *Conn) RandrGetScreenResourcesCurrentUnchecked(Window Id) RandrGetScreenResourcesCurrentCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetScreenResourcesCurrentRequest(Window), cookie)
+	return RandrGetScreenResourcesCurrentCookie{cookie}
+}
+
+// Request reply for RandrGetScreenResourcesCurrent
+// size: ((((32 + pad((int(NumCrtcs) * 4))) + pad((int(NumOutputs) * 4))) + pad((int(NumModes) * 32))) + pad((int(NamesLen) * 1)))
+type RandrGetScreenResourcesCurrentReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Timestamp       Timestamp
+	ConfigTimestamp Timestamp
+	NumCrtcs        uint16
+	NumOutputs      uint16
+	NumModes        uint16
+	NamesLen        uint16
+	// padding: 8 bytes
+	Crtcs   []Id            // size: pad((int(NumCrtcs) * 4))
+	Outputs []Id            // size: pad((int(NumOutputs) * 4))
+	Modes   []RandrModeInfo // size: pad((int(NumModes) * 32))
+	Names   []byte          // size: pad((int(NamesLen) * 1))
+}
+
+// Waits and reads reply data from request RandrGetScreenResourcesCurrent
+func (cook RandrGetScreenResourcesCurrentCookie) Reply() (*RandrGetScreenResourcesCurrentReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetScreenResourcesCurrentReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetScreenResourcesCurrent
+func randrGetScreenResourcesCurrentReply(buf []byte) *RandrGetScreenResourcesCurrentReply {
+	v := new(RandrGetScreenResourcesCurrentReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.ConfigTimestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.NumCrtcs = Get16(buf[b:])
+	b += 2
+
+	v.NumOutputs = Get16(buf[b:])
+	b += 2
+
+	v.NumModes = Get16(buf[b:])
+	b += 2
+
+	v.NamesLen = Get16(buf[b:])
+	b += 2
+
+	b += 8 // padding
+
+	v.Crtcs = make([]Id, v.NumCrtcs)
+	for i := 0; i < int(v.NumCrtcs); i++ {
+		v.Crtcs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Outputs = make([]Id, v.NumOutputs)
+	for i := 0; i < int(v.NumOutputs); i++ {
+		v.Outputs[i] = Id(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	v.Modes = make([]RandrModeInfo, v.NumModes)
+	b += ReadRandrModeInfoList(buf[b:], v.Modes)
+
+	v.Names = make([]byte, v.NamesLen)
+	copy(v.Names[:v.NamesLen], buf[b:])
+	b += pad(int(v.NamesLen))
+
+	return v
+}
+
+func (cook RandrGetScreenResourcesCurrentCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetScreenResourcesCurrent
+func (c *Conn) randrGetScreenResourcesCurrentRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 25 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetCrtcTransform
+// size: pad(((48 + pad((int(FilterLen) * 1))) + pad((len(FilterParams) * 4))))
+type RandrSetCrtcTransformCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrSetCrtcTransform
+func (c *Conn) RandrSetCrtcTransform(Crtc Id, Transform RenderTransform, FilterLen uint16, FilterName string, FilterParams []RenderFixed) RandrSetCrtcTransformCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrSetCrtcTransformRequest(Crtc, Transform, FilterLen, FilterName, FilterParams), cookie)
+	return RandrSetCrtcTransformCookie{cookie}
+}
+
+func (c *Conn) RandrSetCrtcTransformChecked(Crtc Id, Transform RenderTransform, FilterLen uint16, FilterName string, FilterParams []RenderFixed) RandrSetCrtcTransformCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrSetCrtcTransformRequest(Crtc, Transform, FilterLen, FilterName, FilterParams), cookie)
+	return RandrSetCrtcTransformCookie{cookie}
+}
+
+func (cook RandrSetCrtcTransformCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetCrtcTransform
+func (c *Conn) randrSetCrtcTransformRequest(Crtc Id, Transform RenderTransform, FilterLen uint16, FilterName string, FilterParams []RenderFixed) []byte {
+	size := pad(((48 + pad((int(FilterLen) * 1))) + pad((len(FilterParams) * 4))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 26 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	{
+		structBytes := Transform.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	Put16(buf[b:], FilterLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], FilterName[:FilterLen])
+	b += pad(int(FilterLen))
+
+	for i := 0; i < int(len(FilterParams)); i++ {
+		Put32(buf[b:], uint32(FilterParams[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RandrGetCrtcTransform
+// size: 8
+type RandrGetCrtcTransformCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetCrtcTransform(Crtc Id) RandrGetCrtcTransformCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetCrtcTransformRequest(Crtc), cookie)
+	return RandrGetCrtcTransformCookie{cookie}
+}
+
+func (c *Conn) RandrGetCrtcTransformUnchecked(Crtc Id) RandrGetCrtcTransformCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetCrtcTransformRequest(Crtc), cookie)
+	return RandrGetCrtcTransformCookie{cookie}
+}
+
+// Request reply for RandrGetCrtcTransform
+// size: ((((96 + pad((int(PendingLen) * 1))) + pad((int(PendingNparams) * 4))) + pad((int(CurrentLen) * 1))) + pad((int(CurrentNparams) * 4)))
+type RandrGetCrtcTransformReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	PendingTransform RenderTransform
+	HasTransforms    bool
+	// padding: 3 bytes
+	CurrentTransform RenderTransform
+	// padding: 4 bytes
+	PendingLen        uint16
+	PendingNparams    uint16
+	CurrentLen        uint16
+	CurrentNparams    uint16
+	PendingFilterName string        // size: pad((int(PendingLen) * 1))
+	PendingParams     []RenderFixed // size: pad((int(PendingNparams) * 4))
+	CurrentFilterName string        // size: pad((int(CurrentLen) * 1))
+	CurrentParams     []RenderFixed // size: pad((int(CurrentNparams) * 4))
+}
+
+// Waits and reads reply data from request RandrGetCrtcTransform
+func (cook RandrGetCrtcTransformCookie) Reply() (*RandrGetCrtcTransformReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetCrtcTransformReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetCrtcTransform
+func randrGetCrtcTransformReply(buf []byte) *RandrGetCrtcTransformReply {
+	v := new(RandrGetCrtcTransformReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.PendingTransform = RenderTransform{}
+	b += ReadRenderTransform(buf[b:], &v.PendingTransform)
+
+	if buf[b] == 1 {
+		v.HasTransforms = true
+	} else {
+		v.HasTransforms = false
+	}
+	b += 1
+
+	b += 3 // padding
+
+	v.CurrentTransform = RenderTransform{}
+	b += ReadRenderTransform(buf[b:], &v.CurrentTransform)
+
+	b += 4 // padding
+
+	v.PendingLen = Get16(buf[b:])
+	b += 2
+
+	v.PendingNparams = Get16(buf[b:])
+	b += 2
+
+	v.CurrentLen = Get16(buf[b:])
+	b += 2
+
+	v.CurrentNparams = Get16(buf[b:])
+	b += 2
+
+	{
+		byteString := make([]byte, v.PendingLen)
+		copy(byteString[:v.PendingLen], buf[b:])
+		v.PendingFilterName = string(byteString)
+		b += pad(int(v.PendingLen))
+	}
+
+	v.PendingParams = make([]RenderFixed, v.PendingNparams)
+	for i := 0; i < int(v.PendingNparams); i++ {
+		v.PendingParams[i] = RenderFixed(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	{
+		byteString := make([]byte, v.CurrentLen)
+		copy(byteString[:v.CurrentLen], buf[b:])
+		v.CurrentFilterName = string(byteString)
+		b += pad(int(v.CurrentLen))
+	}
+
+	v.CurrentParams = make([]RenderFixed, v.CurrentNparams)
+	for i := 0; i < int(v.CurrentNparams); i++ {
+		v.CurrentParams[i] = RenderFixed(Get32(buf[b:]))
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RandrGetCrtcTransformCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetCrtcTransform
+func (c *Conn) randrGetCrtcTransformRequest(Crtc Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 27 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetPanning
+// size: 8
+type RandrGetPanningCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetPanning(Crtc Id) RandrGetPanningCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetPanningRequest(Crtc), cookie)
+	return RandrGetPanningCookie{cookie}
+}
+
+func (c *Conn) RandrGetPanningUnchecked(Crtc Id) RandrGetPanningCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetPanningRequest(Crtc), cookie)
+	return RandrGetPanningCookie{cookie}
+}
+
+// Request reply for RandrGetPanning
+// size: 36
+type RandrGetPanningReply struct {
+	Sequence     uint16
+	Length       uint32
+	Status       byte
+	Timestamp    Timestamp
+	Left         uint16
+	Top          uint16
+	Width        uint16
+	Height       uint16
+	TrackLeft    uint16
+	TrackTop     uint16
+	TrackWidth   uint16
+	TrackHeight  uint16
+	BorderLeft   int16
+	BorderTop    int16
+	BorderRight  int16
+	BorderBottom int16
+}
+
+// Waits and reads reply data from request RandrGetPanning
+func (cook RandrGetPanningCookie) Reply() (*RandrGetPanningReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetPanningReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetPanning
+func randrGetPanningReply(buf []byte) *RandrGetPanningReply {
+	v := new(RandrGetPanningReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	v.Left = Get16(buf[b:])
+	b += 2
+
+	v.Top = Get16(buf[b:])
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.TrackLeft = Get16(buf[b:])
+	b += 2
+
+	v.TrackTop = Get16(buf[b:])
+	b += 2
+
+	v.TrackWidth = Get16(buf[b:])
+	b += 2
+
+	v.TrackHeight = Get16(buf[b:])
+	b += 2
+
+	v.BorderLeft = int16(Get16(buf[b:]))
+	b += 2
+
+	v.BorderTop = int16(Get16(buf[b:]))
+	b += 2
+
+	v.BorderRight = int16(Get16(buf[b:]))
+	b += 2
+
+	v.BorderBottom = int16(Get16(buf[b:]))
+	b += 2
+
+	return v
+}
+
+func (cook RandrGetPanningCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetPanning
+func (c *Conn) randrGetPanningRequest(Crtc Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 28 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	return buf
+}
+
+// Request RandrSetPanning
+// size: 36
+type RandrSetPanningCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrSetPanning(Crtc Id, Timestamp Timestamp, Left uint16, Top uint16, Width uint16, Height uint16, TrackLeft uint16, TrackTop uint16, TrackWidth uint16, TrackHeight uint16, BorderLeft int16, BorderTop int16, BorderRight int16, BorderBottom int16) RandrSetPanningCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrSetPanningRequest(Crtc, Timestamp, Left, Top, Width, Height, TrackLeft, TrackTop, TrackWidth, TrackHeight, BorderLeft, BorderTop, BorderRight, BorderBottom), cookie)
+	return RandrSetPanningCookie{cookie}
+}
+
+func (c *Conn) RandrSetPanningUnchecked(Crtc Id, Timestamp Timestamp, Left uint16, Top uint16, Width uint16, Height uint16, TrackLeft uint16, TrackTop uint16, TrackWidth uint16, TrackHeight uint16, BorderLeft int16, BorderTop int16, BorderRight int16, BorderBottom int16) RandrSetPanningCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrSetPanningRequest(Crtc, Timestamp, Left, Top, Width, Height, TrackLeft, TrackTop, TrackWidth, TrackHeight, BorderLeft, BorderTop, BorderRight, BorderBottom), cookie)
+	return RandrSetPanningCookie{cookie}
+}
+
+// Request reply for RandrSetPanning
+// size: 12
+type RandrSetPanningReply struct {
+	Sequence  uint16
+	Length    uint32
+	Status    byte
+	Timestamp Timestamp
+}
+
+// Waits and reads reply data from request RandrSetPanning
+func (cook RandrSetPanningCookie) Reply() (*RandrSetPanningReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrSetPanningReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrSetPanning
+func randrSetPanningReply(buf []byte) *RandrSetPanningReply {
+	v := new(RandrSetPanningReply)
+	b := 1 // skip reply determinant
+
+	v.Status = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Timestamp = Timestamp(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+func (cook RandrSetPanningCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetPanning
+func (c *Conn) randrSetPanningRequest(Crtc Id, Timestamp Timestamp, Left uint16, Top uint16, Width uint16, Height uint16, TrackLeft uint16, TrackTop uint16, TrackWidth uint16, TrackHeight uint16, BorderLeft int16, BorderTop int16, BorderRight int16, BorderBottom int16) []byte {
+	size := 36
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 29 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Crtc))
+	b += 4
+
+	Put32(buf[b:], uint32(Timestamp))
+	b += 4
+
+	Put16(buf[b:], Left)
+	b += 2
+
+	Put16(buf[b:], Top)
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	Put16(buf[b:], TrackLeft)
+	b += 2
+
+	Put16(buf[b:], TrackTop)
+	b += 2
+
+	Put16(buf[b:], TrackWidth)
+	b += 2
+
+	Put16(buf[b:], TrackHeight)
+	b += 2
+
+	Put16(buf[b:], uint16(BorderLeft))
+	b += 2
+
+	Put16(buf[b:], uint16(BorderTop))
+	b += 2
+
+	Put16(buf[b:], uint16(BorderRight))
+	b += 2
+
+	Put16(buf[b:], uint16(BorderBottom))
+	b += 2
+
+	return buf
+}
+
+// Request RandrSetOutputPrimary
+// size: 12
+type RandrSetOutputPrimaryCookie struct {
+	*cookie
+}
+
+// Write request to wire for RandrSetOutputPrimary
+func (c *Conn) RandrSetOutputPrimary(Window Id, Output Id) RandrSetOutputPrimaryCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.randrSetOutputPrimaryRequest(Window, Output), cookie)
+	return RandrSetOutputPrimaryCookie{cookie}
+}
+
+func (c *Conn) RandrSetOutputPrimaryChecked(Window Id, Output Id) RandrSetOutputPrimaryCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.randrSetOutputPrimaryRequest(Window, Output), cookie)
+	return RandrSetOutputPrimaryCookie{cookie}
+}
+
+func (cook RandrSetOutputPrimaryCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrSetOutputPrimary
+func (c *Conn) randrSetOutputPrimaryRequest(Window Id, Output Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 30 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put32(buf[b:], uint32(Output))
+	b += 4
+
+	return buf
+}
+
+// Request RandrGetOutputPrimary
+// size: 8
+type RandrGetOutputPrimaryCookie struct {
+	*cookie
+}
+
+func (c *Conn) RandrGetOutputPrimary(Window Id) RandrGetOutputPrimaryCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.randrGetOutputPrimaryRequest(Window), cookie)
+	return RandrGetOutputPrimaryCookie{cookie}
+}
+
+func (c *Conn) RandrGetOutputPrimaryUnchecked(Window Id) RandrGetOutputPrimaryCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.randrGetOutputPrimaryRequest(Window), cookie)
+	return RandrGetOutputPrimaryCookie{cookie}
+}
+
+// Request reply for RandrGetOutputPrimary
+// size: 12
+type RandrGetOutputPrimaryReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Output Id
+}
+
+// Waits and reads reply data from request RandrGetOutputPrimary
+func (cook RandrGetOutputPrimaryCookie) Reply() (*RandrGetOutputPrimaryReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return randrGetOutputPrimaryReply(buf), nil
+}
+
+// Read reply into structure from buffer for RandrGetOutputPrimary
+func randrGetOutputPrimaryReply(buf []byte) *RandrGetOutputPrimaryReply {
+	v := new(RandrGetOutputPrimaryReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Output = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+func (cook RandrGetOutputPrimaryCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RandrGetOutputPrimary
+func (c *Conn) randrGetOutputPrimaryRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RANDR"]
+	b += 1
+
+	buf[b] = 31 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	return buf
+}
diff --git a/nexgb/render.go b/nexgb/render.go
new file mode 100644
index 0000000..069ce76
--- /dev/null
+++ b/nexgb/render.go
@@ -0,0 +1,3506 @@
+package xgb
+
+/*
+	This file was generated by render.xml on May 5 2012 6:07:02pm EDT.
+	This file is automatically generated. Edit at your peril!
+*/
+
+// Imports are not necessary for XGB because everything is 
+// in one package. They are still listed here for reference.
+// import "xproto"
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+// Skipping definition for base type 'Float'
+
+const (
+	RenderPictTypeIndexed = 0
+	RenderPictTypeDirect  = 1
+)
+
+const (
+	RenderPictureNone = 0
+)
+
+const (
+	RenderPictOpClear               = 0
+	RenderPictOpSrc                 = 1
+	RenderPictOpDst                 = 2
+	RenderPictOpOver                = 3
+	RenderPictOpOverReverse         = 4
+	RenderPictOpIn                  = 5
+	RenderPictOpInReverse           = 6
+	RenderPictOpOut                 = 7
+	RenderPictOpOutReverse          = 8
+	RenderPictOpAtop                = 9
+	RenderPictOpAtopReverse         = 10
+	RenderPictOpXor                 = 11
+	RenderPictOpAdd                 = 12
+	RenderPictOpSaturate            = 13
+	RenderPictOpDisjointClear       = 16
+	RenderPictOpDisjointSrc         = 17
+	RenderPictOpDisjointDst         = 18
+	RenderPictOpDisjointOver        = 19
+	RenderPictOpDisjointOverReverse = 20
+	RenderPictOpDisjointIn          = 21
+	RenderPictOpDisjointInReverse   = 22
+	RenderPictOpDisjointOut         = 23
+	RenderPictOpDisjointOutReverse  = 24
+	RenderPictOpDisjointAtop        = 25
+	RenderPictOpDisjointAtopReverse = 26
+	RenderPictOpDisjointXor         = 27
+	RenderPictOpConjointClear       = 32
+	RenderPictOpConjointSrc         = 33
+	RenderPictOpConjointDst         = 34
+	RenderPictOpConjointOver        = 35
+	RenderPictOpConjointOverReverse = 36
+	RenderPictOpConjointIn          = 37
+	RenderPictOpConjointInReverse   = 38
+	RenderPictOpConjointOut         = 39
+	RenderPictOpConjointOutReverse  = 40
+	RenderPictOpConjointAtop        = 41
+	RenderPictOpConjointAtopReverse = 42
+	RenderPictOpConjointXor         = 43
+	RenderPictOpMultiply            = 48
+	RenderPictOpScreen              = 49
+	RenderPictOpOverlay             = 50
+	RenderPictOpDarken              = 51
+	RenderPictOpLighten             = 52
+	RenderPictOpColorDodge          = 53
+	RenderPictOpColorBurn           = 54
+	RenderPictOpHardLight           = 55
+	RenderPictOpSoftLight           = 56
+	RenderPictOpDifference          = 57
+	RenderPictOpExclusion           = 58
+	RenderPictOpHSLHue              = 59
+	RenderPictOpHSLSaturation       = 60
+	RenderPictOpHSLColor            = 61
+	RenderPictOpHSLLuminosity       = 62
+)
+
+const (
+	RenderPolyEdgeSharp  = 0
+	RenderPolyEdgeSmooth = 1
+)
+
+const (
+	RenderPolyModePrecise   = 0
+	RenderPolyModeImprecise = 1
+)
+
+const (
+	RenderCpRepeat           = 1
+	RenderCpAlphaMap         = 2
+	RenderCpAlphaXOrigin     = 4
+	RenderCpAlphaYOrigin     = 8
+	RenderCpClipXOrigin      = 16
+	RenderCpClipYOrigin      = 32
+	RenderCpClipMask         = 64
+	RenderCpGraphicsExposure = 128
+	RenderCpSubwindowMode    = 256
+	RenderCpPolyEdge         = 512
+	RenderCpPolyMode         = 1024
+	RenderCpDither           = 2048
+	RenderCpComponentAlpha   = 4096
+)
+
+const (
+	RenderSubPixelUnknown       = 0
+	RenderSubPixelHorizontalRGB = 1
+	RenderSubPixelHorizontalBGR = 2
+	RenderSubPixelVerticalRGB   = 3
+	RenderSubPixelVerticalBGR   = 4
+	RenderSubPixelNone          = 5
+)
+
+const (
+	RenderRepeatNone    = 0
+	RenderRepeatNormal  = 1
+	RenderRepeatPad     = 2
+	RenderRepeatReflect = 3
+)
+
+// Skipping resource definition of 'Glyphset'
+
+// Skipping resource definition of 'Picture'
+
+// Skipping resource definition of 'Pictformat'
+
+type RenderGlyph uint32
+
+type RenderFixed int32
+
+// 'RenderDirectformat' struct definition
+// Size: 16
+type RenderDirectformat struct {
+	RedShift   uint16
+	RedMask    uint16
+	GreenShift uint16
+	GreenMask  uint16
+	BlueShift  uint16
+	BlueMask   uint16
+	AlphaShift uint16
+	AlphaMask  uint16
+}
+
+// Struct read RenderDirectformat
+func ReadRenderDirectformat(buf []byte, v *RenderDirectformat) int {
+	b := 0
+
+	v.RedShift = Get16(buf[b:])
+	b += 2
+
+	v.RedMask = Get16(buf[b:])
+	b += 2
+
+	v.GreenShift = Get16(buf[b:])
+	b += 2
+
+	v.GreenMask = Get16(buf[b:])
+	b += 2
+
+	v.BlueShift = Get16(buf[b:])
+	b += 2
+
+	v.BlueMask = Get16(buf[b:])
+	b += 2
+
+	v.AlphaShift = Get16(buf[b:])
+	b += 2
+
+	v.AlphaMask = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read RenderDirectformat
+func ReadRenderDirectformatList(buf []byte, dest []RenderDirectformat) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderDirectformat{}
+		b += ReadRenderDirectformat(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderDirectformat
+func (v RenderDirectformat) Bytes() []byte {
+	buf := make([]byte, 16)
+	b := 0
+
+	Put16(buf[b:], v.RedShift)
+	b += 2
+
+	Put16(buf[b:], v.RedMask)
+	b += 2
+
+	Put16(buf[b:], v.GreenShift)
+	b += 2
+
+	Put16(buf[b:], v.GreenMask)
+	b += 2
+
+	Put16(buf[b:], v.BlueShift)
+	b += 2
+
+	Put16(buf[b:], v.BlueMask)
+	b += 2
+
+	Put16(buf[b:], v.AlphaShift)
+	b += 2
+
+	Put16(buf[b:], v.AlphaMask)
+	b += 2
+
+	return buf
+}
+
+// Write struct list RenderDirectformat
+func RenderDirectformatListBytes(buf []byte, list []RenderDirectformat) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderPictforminfo' struct definition
+// Size: 28
+type RenderPictforminfo struct {
+	Id    Id
+	Type  byte
+	Depth byte
+	// padding: 2 bytes
+	Direct   RenderDirectformat
+	Colormap Id
+}
+
+// Struct read RenderPictforminfo
+func ReadRenderPictforminfo(buf []byte, v *RenderPictforminfo) int {
+	b := 0
+
+	v.Id = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Type = buf[b]
+	b += 1
+
+	v.Depth = buf[b]
+	b += 1
+
+	b += 2 // padding
+
+	v.Direct = RenderDirectformat{}
+	b += ReadRenderDirectformat(buf[b:], &v.Direct)
+
+	v.Colormap = Id(Get32(buf[b:]))
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderPictforminfo
+func ReadRenderPictforminfoList(buf []byte, dest []RenderPictforminfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderPictforminfo{}
+		b += ReadRenderPictforminfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderPictforminfo
+func (v RenderPictforminfo) Bytes() []byte {
+	buf := make([]byte, 28)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Id))
+	b += 4
+
+	buf[b] = v.Type
+	b += 1
+
+	buf[b] = v.Depth
+	b += 1
+
+	b += 2 // padding
+
+	{
+		structBytes := v.Direct.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	Put32(buf[b:], uint32(v.Colormap))
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderPictforminfo
+func RenderPictforminfoListBytes(buf []byte, list []RenderPictforminfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderPictvisual' struct definition
+// Size: 8
+type RenderPictvisual struct {
+	Visual Visualid
+	Format Id
+}
+
+// Struct read RenderPictvisual
+func ReadRenderPictvisual(buf []byte, v *RenderPictvisual) int {
+	b := 0
+
+	v.Visual = Visualid(Get32(buf[b:]))
+	b += 4
+
+	v.Format = Id(Get32(buf[b:]))
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderPictvisual
+func ReadRenderPictvisualList(buf []byte, dest []RenderPictvisual) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderPictvisual{}
+		b += ReadRenderPictvisual(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderPictvisual
+func (v RenderPictvisual) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Visual))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Format))
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderPictvisual
+func RenderPictvisualListBytes(buf []byte, list []RenderPictvisual) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderPictdepth' struct definition
+// Size: (8 + pad((int(NumVisuals) * 8)))
+type RenderPictdepth struct {
+	Depth byte
+	// padding: 1 bytes
+	NumVisuals uint16
+	// padding: 4 bytes
+	Visuals []RenderPictvisual // size: pad((int(NumVisuals) * 8))
+}
+
+// Struct read RenderPictdepth
+func ReadRenderPictdepth(buf []byte, v *RenderPictdepth) int {
+	b := 0
+
+	v.Depth = buf[b]
+	b += 1
+
+	b += 1 // padding
+
+	v.NumVisuals = Get16(buf[b:])
+	b += 2
+
+	b += 4 // padding
+
+	v.Visuals = make([]RenderPictvisual, v.NumVisuals)
+	b += ReadRenderPictvisualList(buf[b:], v.Visuals)
+
+	return b
+}
+
+// Struct list read RenderPictdepth
+func ReadRenderPictdepthList(buf []byte, dest []RenderPictdepth) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderPictdepth{}
+		b += ReadRenderPictdepth(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderPictdepth
+func (v RenderPictdepth) Bytes() []byte {
+	buf := make([]byte, (8 + pad((int(v.NumVisuals) * 8))))
+	b := 0
+
+	buf[b] = v.Depth
+	b += 1
+
+	b += 1 // padding
+
+	Put16(buf[b:], v.NumVisuals)
+	b += 2
+
+	b += 4 // padding
+
+	b += RenderPictvisualListBytes(buf[b:], v.Visuals)
+
+	return buf
+}
+
+// Write struct list RenderPictdepth
+func RenderPictdepthListBytes(buf []byte, list []RenderPictdepth) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size RenderPictdepth
+func RenderPictdepthListSize(list []RenderPictdepth) int {
+	size := 0
+	for _, item := range list {
+		size += (8 + pad((int(item.NumVisuals) * 8)))
+	}
+	return size
+}
+
+// 'RenderPictscreen' struct definition
+// Size: (8 + RenderPictdepthListSize(Depths))
+type RenderPictscreen struct {
+	NumDepths uint32
+	Fallback  Id
+	Depths    []RenderPictdepth // size: RenderPictdepthListSize(Depths)
+}
+
+// Struct read RenderPictscreen
+func ReadRenderPictscreen(buf []byte, v *RenderPictscreen) int {
+	b := 0
+
+	v.NumDepths = Get32(buf[b:])
+	b += 4
+
+	v.Fallback = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Depths = make([]RenderPictdepth, v.NumDepths)
+	b += ReadRenderPictdepthList(buf[b:], v.Depths)
+
+	return b
+}
+
+// Struct list read RenderPictscreen
+func ReadRenderPictscreenList(buf []byte, dest []RenderPictscreen) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderPictscreen{}
+		b += ReadRenderPictscreen(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderPictscreen
+func (v RenderPictscreen) Bytes() []byte {
+	buf := make([]byte, (8 + RenderPictdepthListSize(v.Depths)))
+	b := 0
+
+	Put32(buf[b:], v.NumDepths)
+	b += 4
+
+	Put32(buf[b:], uint32(v.Fallback))
+	b += 4
+
+	b += RenderPictdepthListBytes(buf[b:], v.Depths)
+
+	return buf
+}
+
+// Write struct list RenderPictscreen
+func RenderPictscreenListBytes(buf []byte, list []RenderPictscreen) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Struct list size RenderPictscreen
+func RenderPictscreenListSize(list []RenderPictscreen) int {
+	size := 0
+	for _, item := range list {
+		size += (8 + RenderPictdepthListSize(item.Depths))
+	}
+	return size
+}
+
+// 'RenderIndexvalue' struct definition
+// Size: 12
+type RenderIndexvalue struct {
+	Pixel uint32
+	Red   uint16
+	Green uint16
+	Blue  uint16
+	Alpha uint16
+}
+
+// Struct read RenderIndexvalue
+func ReadRenderIndexvalue(buf []byte, v *RenderIndexvalue) int {
+	b := 0
+
+	v.Pixel = Get32(buf[b:])
+	b += 4
+
+	v.Red = Get16(buf[b:])
+	b += 2
+
+	v.Green = Get16(buf[b:])
+	b += 2
+
+	v.Blue = Get16(buf[b:])
+	b += 2
+
+	v.Alpha = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read RenderIndexvalue
+func ReadRenderIndexvalueList(buf []byte, dest []RenderIndexvalue) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderIndexvalue{}
+		b += ReadRenderIndexvalue(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderIndexvalue
+func (v RenderIndexvalue) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put32(buf[b:], v.Pixel)
+	b += 4
+
+	Put16(buf[b:], v.Red)
+	b += 2
+
+	Put16(buf[b:], v.Green)
+	b += 2
+
+	Put16(buf[b:], v.Blue)
+	b += 2
+
+	Put16(buf[b:], v.Alpha)
+	b += 2
+
+	return buf
+}
+
+// Write struct list RenderIndexvalue
+func RenderIndexvalueListBytes(buf []byte, list []RenderIndexvalue) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderColor' struct definition
+// Size: 8
+type RenderColor struct {
+	Red   uint16
+	Green uint16
+	Blue  uint16
+	Alpha uint16
+}
+
+// Struct read RenderColor
+func ReadRenderColor(buf []byte, v *RenderColor) int {
+	b := 0
+
+	v.Red = Get16(buf[b:])
+	b += 2
+
+	v.Green = Get16(buf[b:])
+	b += 2
+
+	v.Blue = Get16(buf[b:])
+	b += 2
+
+	v.Alpha = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read RenderColor
+func ReadRenderColorList(buf []byte, dest []RenderColor) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderColor{}
+		b += ReadRenderColor(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderColor
+func (v RenderColor) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], v.Red)
+	b += 2
+
+	Put16(buf[b:], v.Green)
+	b += 2
+
+	Put16(buf[b:], v.Blue)
+	b += 2
+
+	Put16(buf[b:], v.Alpha)
+	b += 2
+
+	return buf
+}
+
+// Write struct list RenderColor
+func RenderColorListBytes(buf []byte, list []RenderColor) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderPointfix' struct definition
+// Size: 8
+type RenderPointfix struct {
+	X RenderFixed
+	Y RenderFixed
+}
+
+// Struct read RenderPointfix
+func ReadRenderPointfix(buf []byte, v *RenderPointfix) int {
+	b := 0
+
+	v.X = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Y = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderPointfix
+func ReadRenderPointfixList(buf []byte, dest []RenderPointfix) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderPointfix{}
+		b += ReadRenderPointfix(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderPointfix
+func (v RenderPointfix) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put32(buf[b:], uint32(v.X))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Y))
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderPointfix
+func RenderPointfixListBytes(buf []byte, list []RenderPointfix) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderLinefix' struct definition
+// Size: 16
+type RenderLinefix struct {
+	P1 RenderPointfix
+	P2 RenderPointfix
+}
+
+// Struct read RenderLinefix
+func ReadRenderLinefix(buf []byte, v *RenderLinefix) int {
+	b := 0
+
+	v.P1 = RenderPointfix{}
+	b += ReadRenderPointfix(buf[b:], &v.P1)
+
+	v.P2 = RenderPointfix{}
+	b += ReadRenderPointfix(buf[b:], &v.P2)
+
+	return b
+}
+
+// Struct list read RenderLinefix
+func ReadRenderLinefixList(buf []byte, dest []RenderLinefix) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderLinefix{}
+		b += ReadRenderLinefix(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderLinefix
+func (v RenderLinefix) Bytes() []byte {
+	buf := make([]byte, 16)
+	b := 0
+
+	{
+		structBytes := v.P1.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := v.P2.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Write struct list RenderLinefix
+func RenderLinefixListBytes(buf []byte, list []RenderLinefix) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderTriangle' struct definition
+// Size: 24
+type RenderTriangle struct {
+	P1 RenderPointfix
+	P2 RenderPointfix
+	P3 RenderPointfix
+}
+
+// Struct read RenderTriangle
+func ReadRenderTriangle(buf []byte, v *RenderTriangle) int {
+	b := 0
+
+	v.P1 = RenderPointfix{}
+	b += ReadRenderPointfix(buf[b:], &v.P1)
+
+	v.P2 = RenderPointfix{}
+	b += ReadRenderPointfix(buf[b:], &v.P2)
+
+	v.P3 = RenderPointfix{}
+	b += ReadRenderPointfix(buf[b:], &v.P3)
+
+	return b
+}
+
+// Struct list read RenderTriangle
+func ReadRenderTriangleList(buf []byte, dest []RenderTriangle) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderTriangle{}
+		b += ReadRenderTriangle(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderTriangle
+func (v RenderTriangle) Bytes() []byte {
+	buf := make([]byte, 24)
+	b := 0
+
+	{
+		structBytes := v.P1.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := v.P2.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := v.P3.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Write struct list RenderTriangle
+func RenderTriangleListBytes(buf []byte, list []RenderTriangle) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderTrapezoid' struct definition
+// Size: 40
+type RenderTrapezoid struct {
+	Top    RenderFixed
+	Bottom RenderFixed
+	Left   RenderLinefix
+	Right  RenderLinefix
+}
+
+// Struct read RenderTrapezoid
+func ReadRenderTrapezoid(buf []byte, v *RenderTrapezoid) int {
+	b := 0
+
+	v.Top = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Bottom = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Left = RenderLinefix{}
+	b += ReadRenderLinefix(buf[b:], &v.Left)
+
+	v.Right = RenderLinefix{}
+	b += ReadRenderLinefix(buf[b:], &v.Right)
+
+	return b
+}
+
+// Struct list read RenderTrapezoid
+func ReadRenderTrapezoidList(buf []byte, dest []RenderTrapezoid) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderTrapezoid{}
+		b += ReadRenderTrapezoid(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderTrapezoid
+func (v RenderTrapezoid) Bytes() []byte {
+	buf := make([]byte, 40)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Top))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Bottom))
+	b += 4
+
+	{
+		structBytes := v.Left.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := v.Right.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Write struct list RenderTrapezoid
+func RenderTrapezoidListBytes(buf []byte, list []RenderTrapezoid) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderGlyphinfo' struct definition
+// Size: 12
+type RenderGlyphinfo struct {
+	Width  uint16
+	Height uint16
+	X      int16
+	Y      int16
+	XOff   int16
+	YOff   int16
+}
+
+// Struct read RenderGlyphinfo
+func ReadRenderGlyphinfo(buf []byte, v *RenderGlyphinfo) int {
+	b := 0
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	v.X = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Y = int16(Get16(buf[b:]))
+	b += 2
+
+	v.XOff = int16(Get16(buf[b:]))
+	b += 2
+
+	v.YOff = int16(Get16(buf[b:]))
+	b += 2
+
+	return b
+}
+
+// Struct list read RenderGlyphinfo
+func ReadRenderGlyphinfoList(buf []byte, dest []RenderGlyphinfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderGlyphinfo{}
+		b += ReadRenderGlyphinfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderGlyphinfo
+func (v RenderGlyphinfo) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	Put16(buf[b:], uint16(v.X))
+	b += 2
+
+	Put16(buf[b:], uint16(v.Y))
+	b += 2
+
+	Put16(buf[b:], uint16(v.XOff))
+	b += 2
+
+	Put16(buf[b:], uint16(v.YOff))
+	b += 2
+
+	return buf
+}
+
+// Write struct list RenderGlyphinfo
+func RenderGlyphinfoListBytes(buf []byte, list []RenderGlyphinfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderTransform' struct definition
+// Size: 36
+type RenderTransform struct {
+	Matrix11 RenderFixed
+	Matrix12 RenderFixed
+	Matrix13 RenderFixed
+	Matrix21 RenderFixed
+	Matrix22 RenderFixed
+	Matrix23 RenderFixed
+	Matrix31 RenderFixed
+	Matrix32 RenderFixed
+	Matrix33 RenderFixed
+}
+
+// Struct read RenderTransform
+func ReadRenderTransform(buf []byte, v *RenderTransform) int {
+	b := 0
+
+	v.Matrix11 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix12 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix13 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix21 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix22 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix23 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix31 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix32 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Matrix33 = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderTransform
+func ReadRenderTransformList(buf []byte, dest []RenderTransform) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderTransform{}
+		b += ReadRenderTransform(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderTransform
+func (v RenderTransform) Bytes() []byte {
+	buf := make([]byte, 36)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Matrix11))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix12))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix13))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix21))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix22))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix23))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix31))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix32))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Matrix33))
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderTransform
+func RenderTransformListBytes(buf []byte, list []RenderTransform) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderAnimcursorelt' struct definition
+// Size: 8
+type RenderAnimcursorelt struct {
+	Cursor Id
+	Delay  uint32
+}
+
+// Struct read RenderAnimcursorelt
+func ReadRenderAnimcursorelt(buf []byte, v *RenderAnimcursorelt) int {
+	b := 0
+
+	v.Cursor = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Delay = Get32(buf[b:])
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderAnimcursorelt
+func ReadRenderAnimcursoreltList(buf []byte, dest []RenderAnimcursorelt) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderAnimcursorelt{}
+		b += ReadRenderAnimcursorelt(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderAnimcursorelt
+func (v RenderAnimcursorelt) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put32(buf[b:], uint32(v.Cursor))
+	b += 4
+
+	Put32(buf[b:], v.Delay)
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderAnimcursorelt
+func RenderAnimcursoreltListBytes(buf []byte, list []RenderAnimcursorelt) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderSpanfix' struct definition
+// Size: 12
+type RenderSpanfix struct {
+	L RenderFixed
+	R RenderFixed
+	Y RenderFixed
+}
+
+// Struct read RenderSpanfix
+func ReadRenderSpanfix(buf []byte, v *RenderSpanfix) int {
+	b := 0
+
+	v.L = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.R = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	v.Y = RenderFixed(Get32(buf[b:]))
+	b += 4
+
+	return b
+}
+
+// Struct list read RenderSpanfix
+func ReadRenderSpanfixList(buf []byte, dest []RenderSpanfix) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderSpanfix{}
+		b += ReadRenderSpanfix(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderSpanfix
+func (v RenderSpanfix) Bytes() []byte {
+	buf := make([]byte, 12)
+	b := 0
+
+	Put32(buf[b:], uint32(v.L))
+	b += 4
+
+	Put32(buf[b:], uint32(v.R))
+	b += 4
+
+	Put32(buf[b:], uint32(v.Y))
+	b += 4
+
+	return buf
+}
+
+// Write struct list RenderSpanfix
+func RenderSpanfixListBytes(buf []byte, list []RenderSpanfix) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// 'RenderTrap' struct definition
+// Size: 24
+type RenderTrap struct {
+	Top RenderSpanfix
+	Bot RenderSpanfix
+}
+
+// Struct read RenderTrap
+func ReadRenderTrap(buf []byte, v *RenderTrap) int {
+	b := 0
+
+	v.Top = RenderSpanfix{}
+	b += ReadRenderSpanfix(buf[b:], &v.Top)
+
+	v.Bot = RenderSpanfix{}
+	b += ReadRenderSpanfix(buf[b:], &v.Bot)
+
+	return b
+}
+
+// Struct list read RenderTrap
+func ReadRenderTrapList(buf []byte, dest []RenderTrap) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = RenderTrap{}
+		b += ReadRenderTrap(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write RenderTrap
+func (v RenderTrap) Bytes() []byte {
+	buf := make([]byte, 24)
+	b := 0
+
+	{
+		structBytes := v.Top.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := v.Bot.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Write struct list RenderTrap
+func RenderTrapListBytes(buf []byte, list []RenderTrap) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Error definition RenderPictFormat (0)
+// Size: 32
+
+const BadRenderPictFormat = 0
+
+type RenderPictFormatError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RenderPictFormat
+func NewRenderPictFormatError(buf []byte) Error {
+	v := RenderPictFormatError{}
+	v.NiceName = "RenderPictFormat"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RenderPictFormatError) ImplementsError() {}
+
+func (err RenderPictFormatError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RenderPictFormatError) BadId() Id {
+	return 0
+}
+
+func (err RenderPictFormatError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRenderPictFormat {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[0] = NewRenderPictFormatError
+}
+
+// Error definition RenderPicture (1)
+// Size: 32
+
+const BadRenderPicture = 1
+
+type RenderPictureError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RenderPicture
+func NewRenderPictureError(buf []byte) Error {
+	v := RenderPictureError{}
+	v.NiceName = "RenderPicture"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RenderPictureError) ImplementsError() {}
+
+func (err RenderPictureError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RenderPictureError) BadId() Id {
+	return 0
+}
+
+func (err RenderPictureError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRenderPicture {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[1] = NewRenderPictureError
+}
+
+// Error definition RenderPictOp (2)
+// Size: 32
+
+const BadRenderPictOp = 2
+
+type RenderPictOpError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RenderPictOp
+func NewRenderPictOpError(buf []byte) Error {
+	v := RenderPictOpError{}
+	v.NiceName = "RenderPictOp"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RenderPictOpError) ImplementsError() {}
+
+func (err RenderPictOpError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RenderPictOpError) BadId() Id {
+	return 0
+}
+
+func (err RenderPictOpError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRenderPictOp {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[2] = NewRenderPictOpError
+}
+
+// Error definition RenderGlyphSet (3)
+// Size: 32
+
+const BadRenderGlyphSet = 3
+
+type RenderGlyphSetError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RenderGlyphSet
+func NewRenderGlyphSetError(buf []byte) Error {
+	v := RenderGlyphSetError{}
+	v.NiceName = "RenderGlyphSet"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RenderGlyphSetError) ImplementsError() {}
+
+func (err RenderGlyphSetError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RenderGlyphSetError) BadId() Id {
+	return 0
+}
+
+func (err RenderGlyphSetError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRenderGlyphSet {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[3] = NewRenderGlyphSetError
+}
+
+// Error definition RenderGlyph (4)
+// Size: 32
+
+const BadRenderGlyph = 4
+
+type RenderGlyphError struct {
+	Sequence uint16
+	NiceName string
+}
+
+// Error read RenderGlyph
+func NewRenderGlyphError(buf []byte) Error {
+	v := RenderGlyphError{}
+	v.NiceName = "RenderGlyph"
+
+	b := 1 // skip error determinant
+	b += 1 // don't read error number
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (err RenderGlyphError) ImplementsError() {}
+
+func (err RenderGlyphError) SequenceId() uint16 {
+	return err.Sequence
+}
+
+func (err RenderGlyphError) BadId() Id {
+	return 0
+}
+
+func (err RenderGlyphError) Error() string {
+	fieldVals := make([]string, 0, 0)
+	fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+	return "BadRenderGlyph {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+	newErrorFuncs[4] = NewRenderGlyphError
+}
+
+// Request RenderQueryVersion
+// size: 12
+type RenderQueryVersionCookie struct {
+	*cookie
+}
+
+func (c *Conn) RenderQueryVersion(ClientMajorVersion uint32, ClientMinorVersion uint32) RenderQueryVersionCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.renderQueryVersionRequest(ClientMajorVersion, ClientMinorVersion), cookie)
+	return RenderQueryVersionCookie{cookie}
+}
+
+func (c *Conn) RenderQueryVersionUnchecked(ClientMajorVersion uint32, ClientMinorVersion uint32) RenderQueryVersionCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.renderQueryVersionRequest(ClientMajorVersion, ClientMinorVersion), cookie)
+	return RenderQueryVersionCookie{cookie}
+}
+
+// Request reply for RenderQueryVersion
+// size: 32
+type RenderQueryVersionReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	MajorVersion uint32
+	MinorVersion uint32
+	// padding: 16 bytes
+}
+
+// Waits and reads reply data from request RenderQueryVersion
+func (cook RenderQueryVersionCookie) Reply() (*RenderQueryVersionReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return renderQueryVersionReply(buf), nil
+}
+
+// Read reply into structure from buffer for RenderQueryVersion
+func renderQueryVersionReply(buf []byte) *RenderQueryVersionReply {
+	v := new(RenderQueryVersionReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.MajorVersion = Get32(buf[b:])
+	b += 4
+
+	v.MinorVersion = Get32(buf[b:])
+	b += 4
+
+	b += 16 // padding
+
+	return v
+}
+
+func (cook RenderQueryVersionCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderQueryVersion
+func (c *Conn) renderQueryVersionRequest(ClientMajorVersion uint32, ClientMinorVersion uint32) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 0 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], ClientMajorVersion)
+	b += 4
+
+	Put32(buf[b:], ClientMinorVersion)
+	b += 4
+
+	return buf
+}
+
+// Request RenderQueryPictFormats
+// size: 4
+type RenderQueryPictFormatsCookie struct {
+	*cookie
+}
+
+func (c *Conn) RenderQueryPictFormats() RenderQueryPictFormatsCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.renderQueryPictFormatsRequest(), cookie)
+	return RenderQueryPictFormatsCookie{cookie}
+}
+
+func (c *Conn) RenderQueryPictFormatsUnchecked() RenderQueryPictFormatsCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.renderQueryPictFormatsRequest(), cookie)
+	return RenderQueryPictFormatsCookie{cookie}
+}
+
+// Request reply for RenderQueryPictFormats
+// size: (((32 + pad((int(NumFormats) * 28))) + RenderPictscreenListSize(Screens)) + pad((int(NumSubpixel) * 4)))
+type RenderQueryPictFormatsReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NumFormats  uint32
+	NumScreens  uint32
+	NumDepths   uint32
+	NumVisuals  uint32
+	NumSubpixel uint32
+	// padding: 4 bytes
+	Formats   []RenderPictforminfo // size: pad((int(NumFormats) * 28))
+	Screens   []RenderPictscreen   // size: RenderPictscreenListSize(Screens)
+	Subpixels []uint32             // size: pad((int(NumSubpixel) * 4))
+}
+
+// Waits and reads reply data from request RenderQueryPictFormats
+func (cook RenderQueryPictFormatsCookie) Reply() (*RenderQueryPictFormatsReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return renderQueryPictFormatsReply(buf), nil
+}
+
+// Read reply into structure from buffer for RenderQueryPictFormats
+func renderQueryPictFormatsReply(buf []byte) *RenderQueryPictFormatsReply {
+	v := new(RenderQueryPictFormatsReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NumFormats = Get32(buf[b:])
+	b += 4
+
+	v.NumScreens = Get32(buf[b:])
+	b += 4
+
+	v.NumDepths = Get32(buf[b:])
+	b += 4
+
+	v.NumVisuals = Get32(buf[b:])
+	b += 4
+
+	v.NumSubpixel = Get32(buf[b:])
+	b += 4
+
+	b += 4 // padding
+
+	v.Formats = make([]RenderPictforminfo, v.NumFormats)
+	b += ReadRenderPictforminfoList(buf[b:], v.Formats)
+
+	v.Screens = make([]RenderPictscreen, v.NumScreens)
+	b += ReadRenderPictscreenList(buf[b:], v.Screens)
+
+	v.Subpixels = make([]uint32, v.NumSubpixel)
+	for i := 0; i < int(v.NumSubpixel); i++ {
+		v.Subpixels[i] = Get32(buf[b:])
+		b += 4
+	}
+	b = pad(b)
+
+	return v
+}
+
+func (cook RenderQueryPictFormatsCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderQueryPictFormats
+func (c *Conn) renderQueryPictFormatsRequest() []byte {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 1 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}
+
+// Request RenderQueryPictIndexValues
+// size: 8
+type RenderQueryPictIndexValuesCookie struct {
+	*cookie
+}
+
+func (c *Conn) RenderQueryPictIndexValues(Format Id) RenderQueryPictIndexValuesCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.renderQueryPictIndexValuesRequest(Format), cookie)
+	return RenderQueryPictIndexValuesCookie{cookie}
+}
+
+func (c *Conn) RenderQueryPictIndexValuesUnchecked(Format Id) RenderQueryPictIndexValuesCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.renderQueryPictIndexValuesRequest(Format), cookie)
+	return RenderQueryPictIndexValuesCookie{cookie}
+}
+
+// Request reply for RenderQueryPictIndexValues
+// size: (32 + pad((int(NumValues) * 12)))
+type RenderQueryPictIndexValuesReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NumValues uint32
+	// padding: 20 bytes
+	Values []RenderIndexvalue // size: pad((int(NumValues) * 12))
+}
+
+// Waits and reads reply data from request RenderQueryPictIndexValues
+func (cook RenderQueryPictIndexValuesCookie) Reply() (*RenderQueryPictIndexValuesReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return renderQueryPictIndexValuesReply(buf), nil
+}
+
+// Read reply into structure from buffer for RenderQueryPictIndexValues
+func renderQueryPictIndexValuesReply(buf []byte) *RenderQueryPictIndexValuesReply {
+	v := new(RenderQueryPictIndexValuesReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NumValues = Get32(buf[b:])
+	b += 4
+
+	b += 20 // padding
+
+	v.Values = make([]RenderIndexvalue, v.NumValues)
+	b += ReadRenderIndexvalueList(buf[b:], v.Values)
+
+	return v
+}
+
+func (cook RenderQueryPictIndexValuesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderQueryPictIndexValues
+func (c *Conn) renderQueryPictIndexValuesRequest(Format Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 2 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Format))
+	b += 4
+
+	return buf
+}
+
+// Request RenderCreatePicture
+// size: pad((16 + (4 + pad((4 * popCount(int(ValueMask)))))))
+type RenderCreatePictureCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreatePicture
+func (c *Conn) RenderCreatePicture(Pid Id, Drawable Id, Format Id, ValueMask uint32, ValueList []uint32) RenderCreatePictureCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreatePictureRequest(Pid, Drawable, Format, ValueMask, ValueList), cookie)
+	return RenderCreatePictureCookie{cookie}
+}
+
+func (c *Conn) RenderCreatePictureChecked(Pid Id, Drawable Id, Format Id, ValueMask uint32, ValueList []uint32) RenderCreatePictureCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreatePictureRequest(Pid, Drawable, Format, ValueMask, ValueList), cookie)
+	return RenderCreatePictureCookie{cookie}
+}
+
+func (cook RenderCreatePictureCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreatePicture
+func (c *Conn) renderCreatePictureRequest(Pid Id, Drawable Id, Format Id, ValueMask uint32, ValueList []uint32) []byte {
+	size := pad((16 + (4 + pad((4 * popCount(int(ValueMask)))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 4 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Pid))
+	b += 4
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	Put32(buf[b:], uint32(Format))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RenderChangePicture
+// size: pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+type RenderChangePictureCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderChangePicture
+func (c *Conn) RenderChangePicture(Picture Id, ValueMask uint32, ValueList []uint32) RenderChangePictureCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderChangePictureRequest(Picture, ValueMask, ValueList), cookie)
+	return RenderChangePictureCookie{cookie}
+}
+
+func (c *Conn) RenderChangePictureChecked(Picture Id, ValueMask uint32, ValueList []uint32) RenderChangePictureCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderChangePictureRequest(Picture, ValueMask, ValueList), cookie)
+	return RenderChangePictureCookie{cookie}
+}
+
+func (cook RenderChangePictureCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderChangePicture
+func (c *Conn) renderChangePictureRequest(Picture Id, ValueMask uint32, ValueList []uint32) []byte {
+	size := pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 5 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	Put32(buf[b:], ValueMask)
+	b += 4
+	for i := 0; i < popCount(int(ValueMask)); i++ {
+		Put32(buf[b:], ValueList[i])
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RenderSetPictureClipRectangles
+// size: pad((12 + pad((len(Rectangles) * 8))))
+type RenderSetPictureClipRectanglesCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderSetPictureClipRectangles
+func (c *Conn) RenderSetPictureClipRectangles(Picture Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) RenderSetPictureClipRectanglesCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderSetPictureClipRectanglesRequest(Picture, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
+	return RenderSetPictureClipRectanglesCookie{cookie}
+}
+
+func (c *Conn) RenderSetPictureClipRectanglesChecked(Picture Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) RenderSetPictureClipRectanglesCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderSetPictureClipRectanglesRequest(Picture, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
+	return RenderSetPictureClipRectanglesCookie{cookie}
+}
+
+func (cook RenderSetPictureClipRectanglesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderSetPictureClipRectangles
+func (c *Conn) renderSetPictureClipRectanglesRequest(Picture Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) []byte {
+	size := pad((12 + pad((len(Rectangles) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 6 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	Put16(buf[b:], uint16(ClipXOrigin))
+	b += 2
+
+	Put16(buf[b:], uint16(ClipYOrigin))
+	b += 2
+
+	b += RectangleListBytes(buf[b:], Rectangles)
+
+	return buf
+}
+
+// Request RenderFreePicture
+// size: 8
+type RenderFreePictureCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderFreePicture
+func (c *Conn) RenderFreePicture(Picture Id) RenderFreePictureCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderFreePictureRequest(Picture), cookie)
+	return RenderFreePictureCookie{cookie}
+}
+
+func (c *Conn) RenderFreePictureChecked(Picture Id) RenderFreePictureCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderFreePictureRequest(Picture), cookie)
+	return RenderFreePictureCookie{cookie}
+}
+
+func (cook RenderFreePictureCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderFreePicture
+func (c *Conn) renderFreePictureRequest(Picture Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 7 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	return buf
+}
+
+// Request RenderComposite
+// size: 36
+type RenderCompositeCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderComposite
+func (c *Conn) RenderComposite(Op byte, Src Id, Mask Id, Dst Id, SrcX int16, SrcY int16, MaskX int16, MaskY int16, DstX int16, DstY int16, Width uint16, Height uint16) RenderCompositeCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCompositeRequest(Op, Src, Mask, Dst, SrcX, SrcY, MaskX, MaskY, DstX, DstY, Width, Height), cookie)
+	return RenderCompositeCookie{cookie}
+}
+
+func (c *Conn) RenderCompositeChecked(Op byte, Src Id, Mask Id, Dst Id, SrcX int16, SrcY int16, MaskX int16, MaskY int16, DstX int16, DstY int16, Width uint16, Height uint16) RenderCompositeCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCompositeRequest(Op, Src, Mask, Dst, SrcX, SrcY, MaskX, MaskY, DstX, DstY, Width, Height), cookie)
+	return RenderCompositeCookie{cookie}
+}
+
+func (cook RenderCompositeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderComposite
+func (c *Conn) renderCompositeRequest(Op byte, Src Id, Mask Id, Dst Id, SrcX int16, SrcY int16, MaskX int16, MaskY int16, DstX int16, DstY int16, Width uint16, Height uint16) []byte {
+	size := 36
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 8 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Mask))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	Put16(buf[b:], uint16(MaskX))
+	b += 2
+
+	Put16(buf[b:], uint16(MaskY))
+	b += 2
+
+	Put16(buf[b:], uint16(DstX))
+	b += 2
+
+	Put16(buf[b:], uint16(DstY))
+	b += 2
+
+	Put16(buf[b:], Width)
+	b += 2
+
+	Put16(buf[b:], Height)
+	b += 2
+
+	return buf
+}
+
+// Request RenderTrapezoids
+// size: pad((24 + pad((len(Traps) * 40))))
+type RenderTrapezoidsCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderTrapezoids
+func (c *Conn) RenderTrapezoids(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Traps []RenderTrapezoid) RenderTrapezoidsCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderTrapezoidsRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Traps), cookie)
+	return RenderTrapezoidsCookie{cookie}
+}
+
+func (c *Conn) RenderTrapezoidsChecked(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Traps []RenderTrapezoid) RenderTrapezoidsCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderTrapezoidsRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Traps), cookie)
+	return RenderTrapezoidsCookie{cookie}
+}
+
+func (cook RenderTrapezoidsCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderTrapezoids
+func (c *Conn) renderTrapezoidsRequest(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Traps []RenderTrapezoid) []byte {
+	size := pad((24 + pad((len(Traps) * 40))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 10 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	b += RenderTrapezoidListBytes(buf[b:], Traps)
+
+	return buf
+}
+
+// Request RenderTriangles
+// size: pad((24 + pad((len(Triangles) * 24))))
+type RenderTrianglesCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderTriangles
+func (c *Conn) RenderTriangles(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Triangles []RenderTriangle) RenderTrianglesCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderTrianglesRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Triangles), cookie)
+	return RenderTrianglesCookie{cookie}
+}
+
+func (c *Conn) RenderTrianglesChecked(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Triangles []RenderTriangle) RenderTrianglesCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderTrianglesRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Triangles), cookie)
+	return RenderTrianglesCookie{cookie}
+}
+
+func (cook RenderTrianglesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderTriangles
+func (c *Conn) renderTrianglesRequest(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Triangles []RenderTriangle) []byte {
+	size := pad((24 + pad((len(Triangles) * 24))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 11 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	b += RenderTriangleListBytes(buf[b:], Triangles)
+
+	return buf
+}
+
+// Request RenderTriStrip
+// size: pad((24 + pad((len(Points) * 8))))
+type RenderTriStripCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderTriStrip
+func (c *Conn) RenderTriStrip(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) RenderTriStripCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderTriStripRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Points), cookie)
+	return RenderTriStripCookie{cookie}
+}
+
+func (c *Conn) RenderTriStripChecked(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) RenderTriStripCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderTriStripRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Points), cookie)
+	return RenderTriStripCookie{cookie}
+}
+
+func (cook RenderTriStripCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderTriStrip
+func (c *Conn) renderTriStripRequest(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) []byte {
+	size := pad((24 + pad((len(Points) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 12 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	b += RenderPointfixListBytes(buf[b:], Points)
+
+	return buf
+}
+
+// Request RenderTriFan
+// size: pad((24 + pad((len(Points) * 8))))
+type RenderTriFanCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderTriFan
+func (c *Conn) RenderTriFan(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) RenderTriFanCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderTriFanRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Points), cookie)
+	return RenderTriFanCookie{cookie}
+}
+
+func (c *Conn) RenderTriFanChecked(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) RenderTriFanCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderTriFanRequest(Op, Src, Dst, MaskFormat, SrcX, SrcY, Points), cookie)
+	return RenderTriFanCookie{cookie}
+}
+
+func (cook RenderTriFanCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderTriFan
+func (c *Conn) renderTriFanRequest(Op byte, Src Id, Dst Id, MaskFormat Id, SrcX int16, SrcY int16, Points []RenderPointfix) []byte {
+	size := pad((24 + pad((len(Points) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 13 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	b += RenderPointfixListBytes(buf[b:], Points)
+
+	return buf
+}
+
+// Request RenderCreateGlyphSet
+// size: 12
+type RenderCreateGlyphSetCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateGlyphSet
+func (c *Conn) RenderCreateGlyphSet(Gsid Id, Format Id) RenderCreateGlyphSetCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateGlyphSetRequest(Gsid, Format), cookie)
+	return RenderCreateGlyphSetCookie{cookie}
+}
+
+func (c *Conn) RenderCreateGlyphSetChecked(Gsid Id, Format Id) RenderCreateGlyphSetCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateGlyphSetRequest(Gsid, Format), cookie)
+	return RenderCreateGlyphSetCookie{cookie}
+}
+
+func (cook RenderCreateGlyphSetCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateGlyphSet
+func (c *Conn) renderCreateGlyphSetRequest(Gsid Id, Format Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 17 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gsid))
+	b += 4
+
+	Put32(buf[b:], uint32(Format))
+	b += 4
+
+	return buf
+}
+
+// Request RenderReferenceGlyphSet
+// size: 12
+type RenderReferenceGlyphSetCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderReferenceGlyphSet
+func (c *Conn) RenderReferenceGlyphSet(Gsid Id, Existing Id) RenderReferenceGlyphSetCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderReferenceGlyphSetRequest(Gsid, Existing), cookie)
+	return RenderReferenceGlyphSetCookie{cookie}
+}
+
+func (c *Conn) RenderReferenceGlyphSetChecked(Gsid Id, Existing Id) RenderReferenceGlyphSetCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderReferenceGlyphSetRequest(Gsid, Existing), cookie)
+	return RenderReferenceGlyphSetCookie{cookie}
+}
+
+func (cook RenderReferenceGlyphSetCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderReferenceGlyphSet
+func (c *Conn) renderReferenceGlyphSetRequest(Gsid Id, Existing Id) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 18 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Gsid))
+	b += 4
+
+	Put32(buf[b:], uint32(Existing))
+	b += 4
+
+	return buf
+}
+
+// Request RenderFreeGlyphSet
+// size: 8
+type RenderFreeGlyphSetCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderFreeGlyphSet
+func (c *Conn) RenderFreeGlyphSet(Glyphset Id) RenderFreeGlyphSetCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderFreeGlyphSetRequest(Glyphset), cookie)
+	return RenderFreeGlyphSetCookie{cookie}
+}
+
+func (c *Conn) RenderFreeGlyphSetChecked(Glyphset Id) RenderFreeGlyphSetCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderFreeGlyphSetRequest(Glyphset), cookie)
+	return RenderFreeGlyphSetCookie{cookie}
+}
+
+func (cook RenderFreeGlyphSetCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderFreeGlyphSet
+func (c *Conn) renderFreeGlyphSetRequest(Glyphset Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 19 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	return buf
+}
+
+// Request RenderAddGlyphs
+// size: pad((((12 + pad((int(GlyphsLen) * 4))) + pad((int(GlyphsLen) * 12))) + pad((len(Data) * 1))))
+type RenderAddGlyphsCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderAddGlyphs
+func (c *Conn) RenderAddGlyphs(Glyphset Id, GlyphsLen uint32, Glyphids []uint32, Glyphs []RenderGlyphinfo, Data []byte) RenderAddGlyphsCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderAddGlyphsRequest(Glyphset, GlyphsLen, Glyphids, Glyphs, Data), cookie)
+	return RenderAddGlyphsCookie{cookie}
+}
+
+func (c *Conn) RenderAddGlyphsChecked(Glyphset Id, GlyphsLen uint32, Glyphids []uint32, Glyphs []RenderGlyphinfo, Data []byte) RenderAddGlyphsCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderAddGlyphsRequest(Glyphset, GlyphsLen, Glyphids, Glyphs, Data), cookie)
+	return RenderAddGlyphsCookie{cookie}
+}
+
+func (cook RenderAddGlyphsCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderAddGlyphs
+func (c *Conn) renderAddGlyphsRequest(Glyphset Id, GlyphsLen uint32, Glyphids []uint32, Glyphs []RenderGlyphinfo, Data []byte) []byte {
+	size := pad((((12 + pad((int(GlyphsLen) * 4))) + pad((int(GlyphsLen) * 12))) + pad((len(Data) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 20 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	Put32(buf[b:], GlyphsLen)
+	b += 4
+
+	for i := 0; i < int(GlyphsLen); i++ {
+		Put32(buf[b:], Glyphids[i])
+		b += 4
+	}
+	b = pad(b)
+
+	b += RenderGlyphinfoListBytes(buf[b:], Glyphs)
+
+	copy(buf[b:], Data[:len(Data)])
+	b += pad(int(len(Data)))
+
+	return buf
+}
+
+// Request RenderFreeGlyphs
+// size: pad((8 + pad((len(Glyphs) * 4))))
+type RenderFreeGlyphsCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderFreeGlyphs
+func (c *Conn) RenderFreeGlyphs(Glyphset Id, Glyphs []RenderGlyph) RenderFreeGlyphsCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderFreeGlyphsRequest(Glyphset, Glyphs), cookie)
+	return RenderFreeGlyphsCookie{cookie}
+}
+
+func (c *Conn) RenderFreeGlyphsChecked(Glyphset Id, Glyphs []RenderGlyph) RenderFreeGlyphsCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderFreeGlyphsRequest(Glyphset, Glyphs), cookie)
+	return RenderFreeGlyphsCookie{cookie}
+}
+
+func (cook RenderFreeGlyphsCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderFreeGlyphs
+func (c *Conn) renderFreeGlyphsRequest(Glyphset Id, Glyphs []RenderGlyph) []byte {
+	size := pad((8 + pad((len(Glyphs) * 4))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 22 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	for i := 0; i < int(len(Glyphs)); i++ {
+		Put32(buf[b:], uint32(Glyphs[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RenderCompositeGlyphs8
+// size: pad((28 + pad((len(Glyphcmds) * 1))))
+type RenderCompositeGlyphs8Cookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCompositeGlyphs8
+func (c *Conn) RenderCompositeGlyphs8(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs8Cookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCompositeGlyphs8Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs8Cookie{cookie}
+}
+
+func (c *Conn) RenderCompositeGlyphs8Checked(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs8Cookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCompositeGlyphs8Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs8Cookie{cookie}
+}
+
+func (cook RenderCompositeGlyphs8Cookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCompositeGlyphs8
+func (c *Conn) renderCompositeGlyphs8Request(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) []byte {
+	size := pad((28 + pad((len(Glyphcmds) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 23 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
+	b += pad(int(len(Glyphcmds)))
+
+	return buf
+}
+
+// Request RenderCompositeGlyphs16
+// size: pad((28 + pad((len(Glyphcmds) * 1))))
+type RenderCompositeGlyphs16Cookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCompositeGlyphs16
+func (c *Conn) RenderCompositeGlyphs16(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs16Cookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCompositeGlyphs16Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs16Cookie{cookie}
+}
+
+func (c *Conn) RenderCompositeGlyphs16Checked(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs16Cookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCompositeGlyphs16Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs16Cookie{cookie}
+}
+
+func (cook RenderCompositeGlyphs16Cookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCompositeGlyphs16
+func (c *Conn) renderCompositeGlyphs16Request(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) []byte {
+	size := pad((28 + pad((len(Glyphcmds) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 24 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
+	b += pad(int(len(Glyphcmds)))
+
+	return buf
+}
+
+// Request RenderCompositeGlyphs32
+// size: pad((28 + pad((len(Glyphcmds) * 1))))
+type RenderCompositeGlyphs32Cookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCompositeGlyphs32
+func (c *Conn) RenderCompositeGlyphs32(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs32Cookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCompositeGlyphs32Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs32Cookie{cookie}
+}
+
+func (c *Conn) RenderCompositeGlyphs32Checked(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) RenderCompositeGlyphs32Cookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCompositeGlyphs32Request(Op, Src, Dst, MaskFormat, Glyphset, SrcX, SrcY, Glyphcmds), cookie)
+	return RenderCompositeGlyphs32Cookie{cookie}
+}
+
+func (cook RenderCompositeGlyphs32Cookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCompositeGlyphs32
+func (c *Conn) renderCompositeGlyphs32Request(Op byte, Src Id, Dst Id, MaskFormat Id, Glyphset Id, SrcX int16, SrcY int16, Glyphcmds []byte) []byte {
+	size := pad((28 + pad((len(Glyphcmds) * 1))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 25 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Src))
+	b += 4
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	Put32(buf[b:], uint32(MaskFormat))
+	b += 4
+
+	Put32(buf[b:], uint32(Glyphset))
+	b += 4
+
+	Put16(buf[b:], uint16(SrcX))
+	b += 2
+
+	Put16(buf[b:], uint16(SrcY))
+	b += 2
+
+	copy(buf[b:], Glyphcmds[:len(Glyphcmds)])
+	b += pad(int(len(Glyphcmds)))
+
+	return buf
+}
+
+// Request RenderFillRectangles
+// size: pad((20 + pad((len(Rects) * 8))))
+type RenderFillRectanglesCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderFillRectangles
+func (c *Conn) RenderFillRectangles(Op byte, Dst Id, Color RenderColor, Rects []Rectangle) RenderFillRectanglesCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderFillRectanglesRequest(Op, Dst, Color, Rects), cookie)
+	return RenderFillRectanglesCookie{cookie}
+}
+
+func (c *Conn) RenderFillRectanglesChecked(Op byte, Dst Id, Color RenderColor, Rects []Rectangle) RenderFillRectanglesCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderFillRectanglesRequest(Op, Dst, Color, Rects), cookie)
+	return RenderFillRectanglesCookie{cookie}
+}
+
+func (cook RenderFillRectanglesCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderFillRectangles
+func (c *Conn) renderFillRectanglesRequest(Op byte, Dst Id, Color RenderColor, Rects []Rectangle) []byte {
+	size := pad((20 + pad((len(Rects) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 26 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Op
+	b += 1
+
+	b += 3 // padding
+
+	Put32(buf[b:], uint32(Dst))
+	b += 4
+
+	{
+		structBytes := Color.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	b += RectangleListBytes(buf[b:], Rects)
+
+	return buf
+}
+
+// Request RenderCreateCursor
+// size: 16
+type RenderCreateCursorCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateCursor
+func (c *Conn) RenderCreateCursor(Cid Id, Source Id, X uint16, Y uint16) RenderCreateCursorCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateCursorRequest(Cid, Source, X, Y), cookie)
+	return RenderCreateCursorCookie{cookie}
+}
+
+func (c *Conn) RenderCreateCursorChecked(Cid Id, Source Id, X uint16, Y uint16) RenderCreateCursorCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateCursorRequest(Cid, Source, X, Y), cookie)
+	return RenderCreateCursorCookie{cookie}
+}
+
+func (cook RenderCreateCursorCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateCursor
+func (c *Conn) renderCreateCursorRequest(Cid Id, Source Id, X uint16, Y uint16) []byte {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 27 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cid))
+	b += 4
+
+	Put32(buf[b:], uint32(Source))
+	b += 4
+
+	Put16(buf[b:], X)
+	b += 2
+
+	Put16(buf[b:], Y)
+	b += 2
+
+	return buf
+}
+
+// Request RenderSetPictureTransform
+// size: 44
+type RenderSetPictureTransformCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderSetPictureTransform
+func (c *Conn) RenderSetPictureTransform(Picture Id, Transform RenderTransform) RenderSetPictureTransformCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderSetPictureTransformRequest(Picture, Transform), cookie)
+	return RenderSetPictureTransformCookie{cookie}
+}
+
+func (c *Conn) RenderSetPictureTransformChecked(Picture Id, Transform RenderTransform) RenderSetPictureTransformCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderSetPictureTransformRequest(Picture, Transform), cookie)
+	return RenderSetPictureTransformCookie{cookie}
+}
+
+func (cook RenderSetPictureTransformCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderSetPictureTransform
+func (c *Conn) renderSetPictureTransformRequest(Picture Id, Transform RenderTransform) []byte {
+	size := 44
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 28 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	{
+		structBytes := Transform.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Request RenderQueryFilters
+// size: 8
+type RenderQueryFiltersCookie struct {
+	*cookie
+}
+
+func (c *Conn) RenderQueryFilters(Drawable Id) RenderQueryFiltersCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.renderQueryFiltersRequest(Drawable), cookie)
+	return RenderQueryFiltersCookie{cookie}
+}
+
+func (c *Conn) RenderQueryFiltersUnchecked(Drawable Id) RenderQueryFiltersCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.renderQueryFiltersRequest(Drawable), cookie)
+	return RenderQueryFiltersCookie{cookie}
+}
+
+// Request reply for RenderQueryFilters
+// size: ((32 + pad((int(NumAliases) * 2))) + StrListSize(Filters))
+type RenderQueryFiltersReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	NumAliases uint32
+	NumFilters uint32
+	// padding: 16 bytes
+	Aliases []uint16 // size: pad((int(NumAliases) * 2))
+	Filters []Str    // size: StrListSize(Filters)
+}
+
+// Waits and reads reply data from request RenderQueryFilters
+func (cook RenderQueryFiltersCookie) Reply() (*RenderQueryFiltersReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return renderQueryFiltersReply(buf), nil
+}
+
+// Read reply into structure from buffer for RenderQueryFilters
+func renderQueryFiltersReply(buf []byte) *RenderQueryFiltersReply {
+	v := new(RenderQueryFiltersReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.NumAliases = Get32(buf[b:])
+	b += 4
+
+	v.NumFilters = Get32(buf[b:])
+	b += 4
+
+	b += 16 // padding
+
+	v.Aliases = make([]uint16, v.NumAliases)
+	for i := 0; i < int(v.NumAliases); i++ {
+		v.Aliases[i] = Get16(buf[b:])
+		b += 2
+	}
+	b = pad(b)
+
+	v.Filters = make([]Str, v.NumFilters)
+	b += ReadStrList(buf[b:], v.Filters)
+
+	return v
+}
+
+func (cook RenderQueryFiltersCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderQueryFilters
+func (c *Conn) renderQueryFiltersRequest(Drawable Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 29 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Drawable))
+	b += 4
+
+	return buf
+}
+
+// Request RenderSetPictureFilter
+// size: pad(((12 + pad((int(FilterLen) * 1))) + pad((len(Values) * 4))))
+type RenderSetPictureFilterCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderSetPictureFilter
+func (c *Conn) RenderSetPictureFilter(Picture Id, FilterLen uint16, Filter string, Values []RenderFixed) RenderSetPictureFilterCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderSetPictureFilterRequest(Picture, FilterLen, Filter, Values), cookie)
+	return RenderSetPictureFilterCookie{cookie}
+}
+
+func (c *Conn) RenderSetPictureFilterChecked(Picture Id, FilterLen uint16, Filter string, Values []RenderFixed) RenderSetPictureFilterCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderSetPictureFilterRequest(Picture, FilterLen, Filter, Values), cookie)
+	return RenderSetPictureFilterCookie{cookie}
+}
+
+func (cook RenderSetPictureFilterCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderSetPictureFilter
+func (c *Conn) renderSetPictureFilterRequest(Picture Id, FilterLen uint16, Filter string, Values []RenderFixed) []byte {
+	size := pad(((12 + pad((int(FilterLen) * 1))) + pad((len(Values) * 4))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 30 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	Put16(buf[b:], FilterLen)
+	b += 2
+
+	b += 2 // padding
+
+	copy(buf[b:], Filter[:FilterLen])
+	b += pad(int(FilterLen))
+
+	for i := 0; i < int(len(Values)); i++ {
+		Put32(buf[b:], uint32(Values[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	return buf
+}
+
+// Request RenderCreateAnimCursor
+// size: pad((8 + pad((len(Cursors) * 8))))
+type RenderCreateAnimCursorCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateAnimCursor
+func (c *Conn) RenderCreateAnimCursor(Cid Id, Cursors []RenderAnimcursorelt) RenderCreateAnimCursorCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateAnimCursorRequest(Cid, Cursors), cookie)
+	return RenderCreateAnimCursorCookie{cookie}
+}
+
+func (c *Conn) RenderCreateAnimCursorChecked(Cid Id, Cursors []RenderAnimcursorelt) RenderCreateAnimCursorCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateAnimCursorRequest(Cid, Cursors), cookie)
+	return RenderCreateAnimCursorCookie{cookie}
+}
+
+func (cook RenderCreateAnimCursorCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateAnimCursor
+func (c *Conn) renderCreateAnimCursorRequest(Cid Id, Cursors []RenderAnimcursorelt) []byte {
+	size := pad((8 + pad((len(Cursors) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 31 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Cid))
+	b += 4
+
+	b += RenderAnimcursoreltListBytes(buf[b:], Cursors)
+
+	return buf
+}
+
+// Request RenderAddTraps
+// size: pad((12 + pad((len(Traps) * 24))))
+type RenderAddTrapsCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderAddTraps
+func (c *Conn) RenderAddTraps(Picture Id, XOff int16, YOff int16, Traps []RenderTrap) RenderAddTrapsCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderAddTrapsRequest(Picture, XOff, YOff, Traps), cookie)
+	return RenderAddTrapsCookie{cookie}
+}
+
+func (c *Conn) RenderAddTrapsChecked(Picture Id, XOff int16, YOff int16, Traps []RenderTrap) RenderAddTrapsCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderAddTrapsRequest(Picture, XOff, YOff, Traps), cookie)
+	return RenderAddTrapsCookie{cookie}
+}
+
+func (cook RenderAddTrapsCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderAddTraps
+func (c *Conn) renderAddTrapsRequest(Picture Id, XOff int16, YOff int16, Traps []RenderTrap) []byte {
+	size := pad((12 + pad((len(Traps) * 24))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 32 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	Put16(buf[b:], uint16(XOff))
+	b += 2
+
+	Put16(buf[b:], uint16(YOff))
+	b += 2
+
+	b += RenderTrapListBytes(buf[b:], Traps)
+
+	return buf
+}
+
+// Request RenderCreateSolidFill
+// size: 16
+type RenderCreateSolidFillCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateSolidFill
+func (c *Conn) RenderCreateSolidFill(Picture Id, Color RenderColor) RenderCreateSolidFillCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateSolidFillRequest(Picture, Color), cookie)
+	return RenderCreateSolidFillCookie{cookie}
+}
+
+func (c *Conn) RenderCreateSolidFillChecked(Picture Id, Color RenderColor) RenderCreateSolidFillCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateSolidFillRequest(Picture, Color), cookie)
+	return RenderCreateSolidFillCookie{cookie}
+}
+
+func (cook RenderCreateSolidFillCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateSolidFill
+func (c *Conn) renderCreateSolidFillRequest(Picture Id, Color RenderColor) []byte {
+	size := 16
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 33 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	{
+		structBytes := Color.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	return buf
+}
+
+// Request RenderCreateLinearGradient
+// size: pad(((28 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+type RenderCreateLinearGradientCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateLinearGradient
+func (c *Conn) RenderCreateLinearGradient(Picture Id, P1 RenderPointfix, P2 RenderPointfix, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateLinearGradientCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateLinearGradientRequest(Picture, P1, P2, NumStops, Stops, Colors), cookie)
+	return RenderCreateLinearGradientCookie{cookie}
+}
+
+func (c *Conn) RenderCreateLinearGradientChecked(Picture Id, P1 RenderPointfix, P2 RenderPointfix, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateLinearGradientCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateLinearGradientRequest(Picture, P1, P2, NumStops, Stops, Colors), cookie)
+	return RenderCreateLinearGradientCookie{cookie}
+}
+
+func (cook RenderCreateLinearGradientCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateLinearGradient
+func (c *Conn) renderCreateLinearGradientRequest(Picture Id, P1 RenderPointfix, P2 RenderPointfix, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) []byte {
+	size := pad(((28 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 34 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	{
+		structBytes := P1.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := P2.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	Put32(buf[b:], NumStops)
+	b += 4
+
+	for i := 0; i < int(NumStops); i++ {
+		Put32(buf[b:], uint32(Stops[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	b += RenderColorListBytes(buf[b:], Colors)
+
+	return buf
+}
+
+// Request RenderCreateRadialGradient
+// size: pad(((36 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+type RenderCreateRadialGradientCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateRadialGradient
+func (c *Conn) RenderCreateRadialGradient(Picture Id, Inner RenderPointfix, Outer RenderPointfix, InnerRadius RenderFixed, OuterRadius RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateRadialGradientCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateRadialGradientRequest(Picture, Inner, Outer, InnerRadius, OuterRadius, NumStops, Stops, Colors), cookie)
+	return RenderCreateRadialGradientCookie{cookie}
+}
+
+func (c *Conn) RenderCreateRadialGradientChecked(Picture Id, Inner RenderPointfix, Outer RenderPointfix, InnerRadius RenderFixed, OuterRadius RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateRadialGradientCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateRadialGradientRequest(Picture, Inner, Outer, InnerRadius, OuterRadius, NumStops, Stops, Colors), cookie)
+	return RenderCreateRadialGradientCookie{cookie}
+}
+
+func (cook RenderCreateRadialGradientCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateRadialGradient
+func (c *Conn) renderCreateRadialGradientRequest(Picture Id, Inner RenderPointfix, Outer RenderPointfix, InnerRadius RenderFixed, OuterRadius RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) []byte {
+	size := pad(((36 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 35 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	{
+		structBytes := Inner.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	{
+		structBytes := Outer.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	Put32(buf[b:], uint32(InnerRadius))
+	b += 4
+
+	Put32(buf[b:], uint32(OuterRadius))
+	b += 4
+
+	Put32(buf[b:], NumStops)
+	b += 4
+
+	for i := 0; i < int(NumStops); i++ {
+		Put32(buf[b:], uint32(Stops[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	b += RenderColorListBytes(buf[b:], Colors)
+
+	return buf
+}
+
+// Request RenderCreateConicalGradient
+// size: pad(((24 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+type RenderCreateConicalGradientCookie struct {
+	*cookie
+}
+
+// Write request to wire for RenderCreateConicalGradient
+func (c *Conn) RenderCreateConicalGradient(Picture Id, Center RenderPointfix, Angle RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateConicalGradientCookie {
+	cookie := c.newCookie(false, false)
+	c.newRequest(c.renderCreateConicalGradientRequest(Picture, Center, Angle, NumStops, Stops, Colors), cookie)
+	return RenderCreateConicalGradientCookie{cookie}
+}
+
+func (c *Conn) RenderCreateConicalGradientChecked(Picture Id, Center RenderPointfix, Angle RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) RenderCreateConicalGradientCookie {
+	cookie := c.newCookie(true, false)
+	c.newRequest(c.renderCreateConicalGradientRequest(Picture, Center, Angle, NumStops, Stops, Colors), cookie)
+	return RenderCreateConicalGradientCookie{cookie}
+}
+
+func (cook RenderCreateConicalGradientCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for RenderCreateConicalGradient
+func (c *Conn) renderCreateConicalGradientRequest(Picture Id, Center RenderPointfix, Angle RenderFixed, NumStops uint32, Stops []RenderFixed, Colors []RenderColor) []byte {
+	size := pad(((24 + pad((int(NumStops) * 4))) + pad((int(NumStops) * 8))))
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["RENDER"]
+	b += 1
+
+	buf[b] = 36 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], uint32(Picture))
+	b += 4
+
+	{
+		structBytes := Center.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+
+	Put32(buf[b:], uint32(Angle))
+	b += 4
+
+	Put32(buf[b:], NumStops)
+	b += 4
+
+	for i := 0; i < int(NumStops); i++ {
+		Put32(buf[b:], uint32(Stops[i]))
+		b += 4
+	}
+	b = pad(b)
+
+	b += RenderColorListBytes(buf[b:], Colors)
+
+	return buf
+}
diff --git a/nexgb/xgb.go b/nexgb/xgb.go
index b453427..26c0138 100644
--- a/nexgb/xgb.go
+++ b/nexgb/xgb.go
@@ -17,6 +17,11 @@ import (
 )
 
 const (
+	// cookieBuffer represents the queue size of cookies existing at any
+	// point in time. The size of the buffer is really only important when
+	// there are many requests without replies made in sequence. Once the
+	// buffer fills, a round trip request is made to clear the buffer.
+	cookieBuffer = 1000
 	readBuffer  = 100
 	writeBuffer = 100
 )
@@ -32,7 +37,7 @@ type Conn struct {
 	extensions    map[string]byte
 
 	eventChan         chan eventOrError
-	cookieChan chan cookie
+	cookieChan chan *cookie
 	xidChan chan xid
 	seqChan chan uint16
 	reqChan chan *request
@@ -68,7 +73,7 @@ func NewConnDisplay(display string) (*Conn, error) {
 
 	conn.extensions = make(map[string]byte)
 
-	conn.cookieChan = make(chan cookie, 100)
+	conn.cookieChan = make(chan *cookie, cookieBuffer)
 	conn.xidChan = make(chan xid, 5)
 	conn.seqChan = make(chan uint16, 20)
 	conn.reqChan = make(chan *request, 100)
@@ -87,6 +92,12 @@ func (c *Conn) Close() {
 	c.conn.Close()
 }
 
+// DefaultScreen returns the Screen info for the default screen, which is
+// 0 or the one given in the display argument to Dial.
+func (c *Conn) DefaultScreen() *ScreenInfo {
+	return &c.Setup.Roots[c.defaultScreen]
+}
+
 // Id is used for all X identifiers, such as windows, pixmaps, and GCs.
 type Id uint32
 
@@ -95,6 +106,7 @@ type Id uint32
 type Event interface {
 	ImplementsEvent()
 	Bytes() []byte
+	String() string
 }
 
 // newEventFuncs is a map from event numbers to functions that create
@@ -188,7 +200,8 @@ func (c *Conn) newSequenceId() uint16 {
 // to match up replies with requests.
 // Since sequence ids can only be 16 bit integers we start over at zero when it 
 // comes time to wrap.
-// FIXME: 65,536 requests without replies cannot be made in a single sequence.
+// N.B. As long as the cookie buffer is less than 2^16, there are no limitations
+// on the number (or kind) of requests made in sequence.
 func (c *Conn) generateSeqIds() {
 	seqid := uint16(1)
 	for {
@@ -206,13 +219,14 @@ func (c *Conn) generateSeqIds() {
 // The cookie is used to match up the reply/error.
 type request struct {
 	buf []byte
-	cookie cookie
+	cookie *cookie
 }
 
 // newRequest takes the bytes an a cookie, constructs a request type,
-// and sends it over the Conn.reqChan channel. It then returns the cookie
-// (for convenience).
-func (c *Conn) newRequest(buf []byte, cookie cookie) {
+// and sends it over the Conn.reqChan channel.
+// Note that the sequence number is added to the cookie after it is sent
+// over the request channel.
+func (c *Conn) newRequest(buf []byte, cookie *cookie) {
 	c.reqChan <- &request{buf: buf, cookie: cookie}
 }
 
@@ -220,15 +234,38 @@ func (c *Conn) newRequest(buf []byte, cookie cookie) {
 // the bytes to the wire and adds the cookie to the cookie queue.
 func (c *Conn) sendRequests() {
 	for req := range c.reqChan {
+		// ho there! if the cookie channel is nearly full, force a round
+		// trip to clear out the cookie buffer.
+		// Note that we circumvent the request channel, because we're *in*
+		// the request channel.
+		if len(c.cookieChan) == cookieBuffer - 1 {
+			cookie := c.newCookie(true, true)
+			cookie.Sequence = c.newSequenceId()
+			c.cookieChan <- cookie
+			if !c.writeBuffer(c.getInputFocusRequest()) {
+				return
+			}
+			GetInputFocusCookie{cookie}.Reply() // wait for the buffer to clear
+		}
+
+		req.cookie.Sequence = c.newSequenceId()
 		c.cookieChan <- req.cookie
-		if _, err := c.conn.Write(req.buf); err != nil {
-			fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err)
-			close(c.reqChan)
+		if !c.writeBuffer(req.buf) {
 			return
 		}
 	}
 }
 
+// writeBuffer is a convenience function for writing a byte slice to the wire.
+func (c *Conn) writeBuffer(buf []byte) bool {
+	if _, err := c.conn.Write(buf); err != nil {
+		fmt.Fprintf(os.Stderr, "x protocol write error: %s\n", err)
+		close(c.reqChan)
+		return false
+	}
+	return true
+}
+
 // readResponses is a goroutine that reads events, errors and
 // replies off the wire.
 // When an event is read, it is always added to the event channel.
@@ -260,7 +297,15 @@ func (c *Conn) readResponses() {
 		case 0: // This is an error
 			// Use the constructor function for this error (that is auto
 			// generated) by looking it up by the error number.
-			err = newErrorFuncs[int(buf[1])](buf)
+			newErrFun, ok := newErrorFuncs[int(buf[1])]
+			if !ok {
+				fmt.Fprintf(os.Stderr,
+					"BUG: " +
+					"Could not find error constructor function for error " +
+					"with number %d.", buf[1])
+				continue
+			}
+			err = newErrFun(buf)
 			seq = err.SequenceId()
 
 			// This error is either sent to the event channel or a specific
@@ -291,22 +336,23 @@ func (c *Conn) readResponses() {
 			// Note that we AND the event number with 127 so that we ignore
 			// the most significant bit (which is set when it was sent from
 			// a SendEvent request).
-			event = newEventFuncs[int(buf[0] & 127)](buf)
-			// seq = event.SequenceId() // 0 for KeymapNotify 
+			evNum := int(buf[0] & 127)
+			newEventFun, ok := newEventFuncs[evNum]
+			if !ok {
+				fmt.Fprintf(os.Stderr,
+					"BUG: " +
+					"Could not find event constructor function for event " +
+					"with number %d.", evNum)
+				continue
+			}
+
+			event = newEventFun(buf)
 
 			// Put the event into the queue.
 			c.eventChan <- event
 
 			// No more processing for events.
 			continue
-
-			// If this was a KeymapNotify event, then we don't do any more
-			// processing since we don't have any sequence id.
-			// if event != nil { 
-				// if _, ok := event.(KeymapNotifyEvent); ok { 
-					// continue 
-				// } 
-			// } 
 		}
 
 		// At this point, we have a sequence number and we're either
@@ -326,12 +372,17 @@ func (c *Conn) readResponses() {
 						cookie.errorChan <- err
 					} else { // asynchronous processing
 						c.eventChan <- err
+						// if this is an unchecked reply, ping the cookie too
+						if cookie.pingChan != nil {
+							cookie.pingChan <- true
+						}
 					}
 				} else { // this is a reply
 					if cookie.replyChan == nil {
 						fmt.Fprintf(os.Stderr,
 							"Reply with sequence id %d does not have a " +
 							"cookie with a valid reply channel.\n", seq)
+						continue
 					} else {
 						cookie.replyChan <- replyBytes
 					}
@@ -344,10 +395,14 @@ func (c *Conn) readResponses() {
 			case cookie.replyChan != nil && cookie.errorChan != nil:
 				fmt.Fprintf(os.Stderr,
 					"Found cookie with sequence id %d that is expecting a " +
-					"reply but will never get it.\n", cookie.Sequence)
+					"reply but will never get it. Currently on sequence " +
+					"number %d\n", cookie.Sequence, seq)
 			// Unchecked requests with replies
 			case cookie.replyChan != nil && cookie.pingChan != nil:
-				cookie.pingChan <- true
+				fmt.Fprintf(os.Stderr,
+					"Found cookie with sequence id %d that is expecting a " +
+					"reply (and not an error) but will never get it. " +
+					"Currently on sequence number %d\n", cookie.Sequence, seq)
 			// Checked requests without replies
 			case cookie.pingChan != nil && cookie.errorChan != nil:
 				cookie.pingChan <- true
@@ -368,6 +423,7 @@ func processEventOrError(everr eventOrError) (Event, Error) {
 		return nil, ee
 	default:
 		fmt.Fprintf(os.Stderr, "Invalid event/error type: %T\n", everr)
+		return nil, nil
 	}
 	panic("unreachable")
 }
diff --git a/nexgb/xgb_help.go b/nexgb/xgb_help.go
index f7b4948..b54ab41 100644
--- a/nexgb/xgb_help.go
+++ b/nexgb/xgb_help.go
@@ -5,20 +5,6 @@ import (
 	"strings"
 )
 
-// getExtensionOpcode retrieves the extension opcode from the extensions map.
-// If one doesn't exist, just return 0. An X error will likely result.
-func (c *Conn) getExtensionOpcode(name string) byte {
-	return c.extensions[name]
-}
-
-func (c *Conn) bytesPadding(buf []byte) []byte {
-	return append(buf, make([]byte, pad(len(buf))-len(buf))...)
-}
-
-func (c *Conn) bytesString(str string) []byte {
-	return c.bytesPadding([]byte(str))
-}
-
 // stringsJoin is an alias to strings.Join. It allows us to avoid having to
 // import 'strings' in each of the generated Go files.
 func stringsJoin(ss []string, sep string) string {
@@ -31,13 +17,29 @@ func sprintf(format string, v ...interface{}) string {
 }
 
 // Pad a length to align on 4 bytes.
-func pad(n int) int { return (n + 3) & ^3 }
+func pad(n int) int {
+	return (n + 3) & ^3
+}
+
+// popCount counts the number of bits set in a value list mask.
+func popCount(mask0 int) int {
+	mask := uint32(mask0)
+	n := 0
+	for i := uint32(0); i < 32; i++ {
+		if mask&(1<<i) != 0 {
+			n++
+		}
+	}
+	return n
+}
 
+// Put16 takes a 16 bit integer and copies it into a byte slice.
 func Put16(buf []byte, v uint16) {
 	buf[0] = byte(v)
 	buf[1] = byte(v >> 8)
 }
 
+// Put32 takes a 32 bit integer and copies it into a byte slice.
 func Put32(buf []byte, v uint32) {
 	buf[0] = byte(v)
 	buf[1] = byte(v >> 8)
@@ -45,6 +47,7 @@ func Put32(buf []byte, v uint32) {
 	buf[3] = byte(v >> 24)
 }
 
+// Put64 takes a 64 bit integer and copies it into a byte slice.
 func Put64(buf []byte, v uint64) {
 	buf[0] = byte(v)
 	buf[1] = byte(v >> 8)
@@ -56,12 +59,14 @@ func Put64(buf []byte, v uint64) {
 	buf[7] = byte(v >> 56)
 }
 
+// Get16 constructs a 16 bit integer from the beginning of a byte slice.
 func Get16(buf []byte) uint16 {
 	v := uint16(buf[0])
 	v |= uint16(buf[1]) << 8
 	return v
 }
 
+// Get32 constructs a 32 bit integer from the beginning of a byte slice.
 func Get32(buf []byte) uint32 {
 	v := uint32(buf[0])
 	v |= uint32(buf[1]) << 8
@@ -70,6 +75,7 @@ func Get32(buf []byte) uint32 {
 	return v
 }
 
+// Get64 constructs a 64 bit integer from the beginning of a byte slice.
 func Get64(buf []byte) uint64 {
 	v := uint64(buf[0])
 	v |= uint64(buf[1]) << 8
@@ -81,19 +87,3 @@ func Get64(buf []byte) uint64 {
 	v |= uint64(buf[7]) << 56
 	return v
 }
-
-// Voodoo to count the number of bits set in a value list mask.
-func popCount(mask0 int) int {
-	mask := uint32(mask0)
-	n := 0
-	for i := uint32(0); i < 32; i++ {
-		if mask&(1<<i) != 0 {
-			n++
-		}
-	}
-	return n
-}
-
-// DefaultScreen returns the Screen info for the default screen, which is
-// 0 or the one given in the display argument to Dial.
-func (c *Conn) DefaultScreen() *ScreenInfo { return &c.Setup.Roots[c.defaultScreen] }
diff --git a/nexgb/xinerama.go b/nexgb/xinerama.go
new file mode 100644
index 0000000..c2e031c
--- /dev/null
+++ b/nexgb/xinerama.go
@@ -0,0 +1,629 @@
+package xgb
+
+/*
+	This file was generated by xinerama.xml on May 5 2012 5:56:52pm EDT.
+	This file is automatically generated. Edit at your peril!
+*/
+
+// Imports are not necessary for XGB because everything is 
+// in one package. They are still listed here for reference.
+// import "xproto"
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+// Skipping definition for base type 'Float'
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// 'XineramaScreenInfo' struct definition
+// Size: 8
+type XineramaScreenInfo struct {
+	XOrg   int16
+	YOrg   int16
+	Width  uint16
+	Height uint16
+}
+
+// Struct read XineramaScreenInfo
+func ReadXineramaScreenInfo(buf []byte, v *XineramaScreenInfo) int {
+	b := 0
+
+	v.XOrg = int16(Get16(buf[b:]))
+	b += 2
+
+	v.YOrg = int16(Get16(buf[b:]))
+	b += 2
+
+	v.Width = Get16(buf[b:])
+	b += 2
+
+	v.Height = Get16(buf[b:])
+	b += 2
+
+	return b
+}
+
+// Struct list read XineramaScreenInfo
+func ReadXineramaScreenInfoList(buf []byte, dest []XineramaScreenInfo) int {
+	b := 0
+	for i := 0; i < len(dest); i++ {
+		dest[i] = XineramaScreenInfo{}
+		b += ReadXineramaScreenInfo(buf[b:], &dest[i])
+	}
+	return pad(b)
+}
+
+// Struct write XineramaScreenInfo
+func (v XineramaScreenInfo) Bytes() []byte {
+	buf := make([]byte, 8)
+	b := 0
+
+	Put16(buf[b:], uint16(v.XOrg))
+	b += 2
+
+	Put16(buf[b:], uint16(v.YOrg))
+	b += 2
+
+	Put16(buf[b:], v.Width)
+	b += 2
+
+	Put16(buf[b:], v.Height)
+	b += 2
+
+	return buf
+}
+
+// Write struct list XineramaScreenInfo
+func XineramaScreenInfoListBytes(buf []byte, list []XineramaScreenInfo) int {
+	b := 0
+	var structBytes []byte
+	for _, item := range list {
+		structBytes = item.Bytes()
+		copy(buf[b:], structBytes)
+		b += pad(len(structBytes))
+	}
+	return b
+}
+
+// Request XineramaQueryVersion
+// size: 8
+type XineramaQueryVersionCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaQueryVersion(Major byte, Minor byte) XineramaQueryVersionCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaQueryVersionRequest(Major, Minor), cookie)
+	return XineramaQueryVersionCookie{cookie}
+}
+
+func (c *Conn) XineramaQueryVersionUnchecked(Major byte, Minor byte) XineramaQueryVersionCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaQueryVersionRequest(Major, Minor), cookie)
+	return XineramaQueryVersionCookie{cookie}
+}
+
+// Request reply for XineramaQueryVersion
+// size: 12
+type XineramaQueryVersionReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Major uint16
+	Minor uint16
+}
+
+// Waits and reads reply data from request XineramaQueryVersion
+func (cook XineramaQueryVersionCookie) Reply() (*XineramaQueryVersionReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaQueryVersionReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaQueryVersion
+func xineramaQueryVersionReply(buf []byte) *XineramaQueryVersionReply {
+	v := new(XineramaQueryVersionReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Major = Get16(buf[b:])
+	b += 2
+
+	v.Minor = Get16(buf[b:])
+	b += 2
+
+	return v
+}
+
+func (cook XineramaQueryVersionCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaQueryVersion
+func (c *Conn) xineramaQueryVersionRequest(Major byte, Minor byte) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 0 // request opcode
+	b += 1
+
+	buf[b] = Major
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	buf[b] = Minor
+	b += 1
+
+	return buf
+}
+
+// Request XineramaGetState
+// size: 8
+type XineramaGetStateCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaGetState(Window Id) XineramaGetStateCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaGetStateRequest(Window), cookie)
+	return XineramaGetStateCookie{cookie}
+}
+
+func (c *Conn) XineramaGetStateUnchecked(Window Id) XineramaGetStateCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaGetStateRequest(Window), cookie)
+	return XineramaGetStateCookie{cookie}
+}
+
+// Request reply for XineramaGetState
+// size: 12
+type XineramaGetStateReply struct {
+	Sequence uint16
+	Length   uint32
+	State    byte
+	Window   Id
+}
+
+// Waits and reads reply data from request XineramaGetState
+func (cook XineramaGetStateCookie) Reply() (*XineramaGetStateReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaGetStateReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaGetState
+func xineramaGetStateReply(buf []byte) *XineramaGetStateReply {
+	v := new(XineramaGetStateReply)
+	b := 1 // skip reply determinant
+
+	v.State = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+func (cook XineramaGetStateCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaGetState
+func (c *Conn) xineramaGetStateRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 1 // request opcode
+	b += 1
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}
+
+// Request XineramaGetScreenCount
+// size: 8
+type XineramaGetScreenCountCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaGetScreenCount(Window Id) XineramaGetScreenCountCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaGetScreenCountRequest(Window), cookie)
+	return XineramaGetScreenCountCookie{cookie}
+}
+
+func (c *Conn) XineramaGetScreenCountUnchecked(Window Id) XineramaGetScreenCountCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaGetScreenCountRequest(Window), cookie)
+	return XineramaGetScreenCountCookie{cookie}
+}
+
+// Request reply for XineramaGetScreenCount
+// size: 12
+type XineramaGetScreenCountReply struct {
+	Sequence    uint16
+	Length      uint32
+	ScreenCount byte
+	Window      Id
+}
+
+// Waits and reads reply data from request XineramaGetScreenCount
+func (cook XineramaGetScreenCountCookie) Reply() (*XineramaGetScreenCountReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaGetScreenCountReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaGetScreenCount
+func xineramaGetScreenCountReply(buf []byte) *XineramaGetScreenCountReply {
+	v := new(XineramaGetScreenCountReply)
+	b := 1 // skip reply determinant
+
+	v.ScreenCount = buf[b]
+	b += 1
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	return v
+}
+
+func (cook XineramaGetScreenCountCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaGetScreenCount
+func (c *Conn) xineramaGetScreenCountRequest(Window Id) []byte {
+	size := 8
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 2 // request opcode
+	b += 1
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}
+
+// Request XineramaGetScreenSize
+// size: 12
+type XineramaGetScreenSizeCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaGetScreenSize(Window Id, Screen uint32) XineramaGetScreenSizeCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaGetScreenSizeRequest(Window, Screen), cookie)
+	return XineramaGetScreenSizeCookie{cookie}
+}
+
+func (c *Conn) XineramaGetScreenSizeUnchecked(Window Id, Screen uint32) XineramaGetScreenSizeCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaGetScreenSizeRequest(Window, Screen), cookie)
+	return XineramaGetScreenSizeCookie{cookie}
+}
+
+// Request reply for XineramaGetScreenSize
+// size: 24
+type XineramaGetScreenSizeReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Width  uint32
+	Height uint32
+	Window Id
+	Screen uint32
+}
+
+// Waits and reads reply data from request XineramaGetScreenSize
+func (cook XineramaGetScreenSizeCookie) Reply() (*XineramaGetScreenSizeReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaGetScreenSizeReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaGetScreenSize
+func xineramaGetScreenSizeReply(buf []byte) *XineramaGetScreenSizeReply {
+	v := new(XineramaGetScreenSizeReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Width = Get32(buf[b:])
+	b += 4
+
+	v.Height = Get32(buf[b:])
+	b += 4
+
+	v.Window = Id(Get32(buf[b:]))
+	b += 4
+
+	v.Screen = Get32(buf[b:])
+	b += 4
+
+	return v
+}
+
+func (cook XineramaGetScreenSizeCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaGetScreenSize
+func (c *Conn) xineramaGetScreenSizeRequest(Window Id, Screen uint32) []byte {
+	size := 12
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 3 // request opcode
+	b += 1
+
+	Put32(buf[b:], uint32(Window))
+	b += 4
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	Put32(buf[b:], Screen)
+	b += 4
+
+	return buf
+}
+
+// Request XineramaIsActive
+// size: 4
+type XineramaIsActiveCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaIsActive() XineramaIsActiveCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaIsActiveRequest(), cookie)
+	return XineramaIsActiveCookie{cookie}
+}
+
+func (c *Conn) XineramaIsActiveUnchecked() XineramaIsActiveCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaIsActiveRequest(), cookie)
+	return XineramaIsActiveCookie{cookie}
+}
+
+// Request reply for XineramaIsActive
+// size: 12
+type XineramaIsActiveReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	State uint32
+}
+
+// Waits and reads reply data from request XineramaIsActive
+func (cook XineramaIsActiveCookie) Reply() (*XineramaIsActiveReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaIsActiveReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaIsActive
+func xineramaIsActiveReply(buf []byte) *XineramaIsActiveReply {
+	v := new(XineramaIsActiveReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.State = Get32(buf[b:])
+	b += 4
+
+	return v
+}
+
+func (cook XineramaIsActiveCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaIsActive
+func (c *Conn) xineramaIsActiveRequest() []byte {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 4 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}
+
+// Request XineramaQueryScreens
+// size: 4
+type XineramaQueryScreensCookie struct {
+	*cookie
+}
+
+func (c *Conn) XineramaQueryScreens() XineramaQueryScreensCookie {
+	cookie := c.newCookie(true, true)
+	c.newRequest(c.xineramaQueryScreensRequest(), cookie)
+	return XineramaQueryScreensCookie{cookie}
+}
+
+func (c *Conn) XineramaQueryScreensUnchecked() XineramaQueryScreensCookie {
+	cookie := c.newCookie(false, true)
+	c.newRequest(c.xineramaQueryScreensRequest(), cookie)
+	return XineramaQueryScreensCookie{cookie}
+}
+
+// Request reply for XineramaQueryScreens
+// size: (32 + pad((int(Number) * 8)))
+type XineramaQueryScreensReply struct {
+	Sequence uint16
+	Length   uint32
+	// padding: 1 bytes
+	Number uint32
+	// padding: 20 bytes
+	ScreenInfo []XineramaScreenInfo // size: pad((int(Number) * 8))
+}
+
+// Waits and reads reply data from request XineramaQueryScreens
+func (cook XineramaQueryScreensCookie) Reply() (*XineramaQueryScreensReply, error) {
+	buf, err := cook.reply()
+	if err != nil {
+		return nil, err
+	}
+	if buf == nil {
+		return nil, nil
+	}
+	return xineramaQueryScreensReply(buf), nil
+}
+
+// Read reply into structure from buffer for XineramaQueryScreens
+func xineramaQueryScreensReply(buf []byte) *XineramaQueryScreensReply {
+	v := new(XineramaQueryScreensReply)
+	b := 1 // skip reply determinant
+
+	b += 1 // padding
+
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
+	v.Number = Get32(buf[b:])
+	b += 4
+
+	b += 20 // padding
+
+	v.ScreenInfo = make([]XineramaScreenInfo, v.Number)
+	b += ReadXineramaScreenInfoList(buf[b:], v.ScreenInfo)
+
+	return v
+}
+
+func (cook XineramaQueryScreensCookie) Check() error {
+	return cook.check()
+}
+
+// Write request to wire for XineramaQueryScreens
+func (c *Conn) xineramaQueryScreensRequest() []byte {
+	size := 4
+	b := 0
+	buf := make([]byte, size)
+
+	buf[b] = c.extensions["XINERAMA"]
+	b += 1
+
+	buf[b] = 5 // request opcode
+	b += 1
+
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
+	return buf
+}
diff --git a/nexgb/xproto.go b/nexgb/xproto.go
index d56f0a1..32fa6dd 100644
--- a/nexgb/xproto.go
+++ b/nexgb/xproto.go
@@ -1,10 +1,16 @@
 package xgb
 
 /*
-	This file was generated by xproto.xml on May 5 2012 2:50:11am EDT.
+	This file was generated by xproto.xml on May 5 2012 5:43:45pm EDT.
 	This file is automatically generated. Edit at your peril!
 */
 
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
 // Skipping definition for base type 'Int8'
 
 // Skipping definition for base type 'Card16'
@@ -25,12 +31,6 @@ package xgb
 
 // Skipping definition for base type 'Int16'
 
-// Skipping definition for base type 'Int32'
-
-// Skipping definition for base type 'Void'
-
-// Skipping definition for base type 'Byte'
-
 const (
 	VisualClassStaticGray  = 0
 	VisualClassGrayScale   = 1
@@ -2731,6 +2731,23 @@ func (v KeyPressEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v KeyPressEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
+	return "KeyPress {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[2] = NewKeyPressEvent
 }
@@ -2865,6 +2882,23 @@ func (v ButtonPressEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ButtonPressEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
+	return "ButtonPress {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[4] = NewButtonPressEvent
 }
@@ -2999,6 +3033,23 @@ func (v MotionNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v MotionNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
+	return "MotionNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[6] = NewMotionNotifyEvent
 }
@@ -3127,6 +3178,24 @@ func (v EnterNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v EnterNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
+	fieldVals = append(fieldVals, sprintf("SameScreenFocus: %d", v.SameScreenFocus))
+	return "EnterNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[7] = NewEnterNotifyEvent
 }
@@ -3197,6 +3266,15 @@ func (v FocusInEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v FocusInEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
+	return "FocusIn {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[9] = NewFocusInEvent
 }
@@ -3243,6 +3321,11 @@ func (v KeymapNotifyEvent) SequenceId() uint16 {
 	return uint16(0)
 }
 
+func (v KeymapNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 1)
+	return "KeymapNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[11] = NewKeymapNotifyEvent
 }
@@ -3339,6 +3422,18 @@ func (v ExposeEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ExposeEvent) String() string {
+	fieldVals := make([]string, 0, 8)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
+	return "Expose {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[12] = NewExposeEvent
 }
@@ -3449,6 +3544,20 @@ func (v GraphicsExposureEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v GraphicsExposureEvent) String() string {
+	fieldVals := make([]string, 0, 10)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Drawable: %d", v.Drawable))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", v.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", v.MajorOpcode))
+	return "GraphicsExposure {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[13] = NewGraphicsExposureEvent
 }
@@ -3524,6 +3633,15 @@ func (v NoExposureEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v NoExposureEvent) String() string {
+	fieldVals := make([]string, 0, 5)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Drawable: %d", v.Drawable))
+	fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", v.MinorOpcode))
+	fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", v.MajorOpcode))
+	return "NoExposure {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[14] = NewNoExposureEvent
 }
@@ -3592,6 +3710,14 @@ func (v VisibilityNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v VisibilityNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	return "VisibilityNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[15] = NewVisibilityNotifyEvent
 }
@@ -3710,6 +3836,20 @@ func (v CreateNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v CreateNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 10)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Parent: %d", v.Parent))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("BorderWidth: %d", v.BorderWidth))
+	fieldVals = append(fieldVals, sprintf("OverrideRedirect: %t", v.OverrideRedirect))
+	return "CreateNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[16] = NewCreateNotifyEvent
 }
@@ -3773,6 +3913,14 @@ func (v DestroyNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v DestroyNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 3)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	return "DestroyNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[17] = NewDestroyNotifyEvent
 }
@@ -3856,6 +4004,15 @@ func (v UnmapNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v UnmapNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 5)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("FromConfigure: %t", v.FromConfigure))
+	return "UnmapNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[18] = NewUnmapNotifyEvent
 }
@@ -3939,6 +4096,15 @@ func (v MapNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v MapNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 5)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("OverrideRedirect: %t", v.OverrideRedirect))
+	return "MapNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[19] = NewMapNotifyEvent
 }
@@ -4002,6 +4168,14 @@ func (v MapRequestEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v MapRequestEvent) String() string {
+	fieldVals := make([]string, 0, 3)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Parent: %d", v.Parent))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	return "MapRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[20] = NewMapRequestEvent
 }
@@ -4106,6 +4280,18 @@ func (v ReparentNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ReparentNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 8)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Parent: %d", v.Parent))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("OverrideRedirect: %t", v.OverrideRedirect))
+	return "ReparentNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[21] = NewReparentNotifyEvent
 }
@@ -4231,6 +4417,21 @@ func (v ConfigureNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ConfigureNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 11)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("AboveSibling: %d", v.AboveSibling))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("BorderWidth: %d", v.BorderWidth))
+	fieldVals = append(fieldVals, sprintf("OverrideRedirect: %t", v.OverrideRedirect))
+	return "ConfigureNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[22] = NewConfigureNotifyEvent
 }
@@ -4345,6 +4546,22 @@ func (v ConfigureRequestEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ConfigureRequestEvent) String() string {
+	fieldVals := make([]string, 0, 10)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("StackMode: %d", v.StackMode))
+	fieldVals = append(fieldVals, sprintf("Parent: %d", v.Parent))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Sibling: %d", v.Sibling))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	fieldVals = append(fieldVals, sprintf("BorderWidth: %d", v.BorderWidth))
+	fieldVals = append(fieldVals, sprintf("ValueMask: %d", v.ValueMask))
+	return "ConfigureRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[23] = NewConfigureRequestEvent
 }
@@ -4422,6 +4639,16 @@ func (v GravityNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v GravityNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 5)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("X: %d", v.X))
+	fieldVals = append(fieldVals, sprintf("Y: %d", v.Y))
+	return "GravityNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[24] = NewGravityNotifyEvent
 }
@@ -4492,6 +4719,15 @@ func (v ResizeRequestEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ResizeRequestEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Width: %d", v.Width))
+	fieldVals = append(fieldVals, sprintf("Height: %d", v.Height))
+	return "ResizeRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[25] = NewResizeRequestEvent
 }
@@ -4572,6 +4808,15 @@ func (v CirculateNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v CirculateNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 6)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Place: %d", v.Place))
+	return "CirculateNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[26] = NewCirculateNotifyEvent
 }
@@ -4654,6 +4899,16 @@ func (v PropertyNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v PropertyNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 6)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Atom: %d", v.Atom))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	return "PropertyNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[28] = NewPropertyNotifyEvent
 }
@@ -4724,6 +4979,15 @@ func (v SelectionClearEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v SelectionClearEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Owner: %d", v.Owner))
+	fieldVals = append(fieldVals, sprintf("Selection: %d", v.Selection))
+	return "SelectionClear {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[29] = NewSelectionClearEvent
 }
@@ -4815,6 +5079,18 @@ func (v SelectionRequestEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v SelectionRequestEvent) String() string {
+	fieldVals := make([]string, 0, 7)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Owner: %d", v.Owner))
+	fieldVals = append(fieldVals, sprintf("Requestor: %d", v.Requestor))
+	fieldVals = append(fieldVals, sprintf("Selection: %d", v.Selection))
+	fieldVals = append(fieldVals, sprintf("Target: %d", v.Target))
+	fieldVals = append(fieldVals, sprintf("Property: %d", v.Property))
+	return "SelectionRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[30] = NewSelectionRequestEvent
 }
@@ -4899,6 +5175,17 @@ func (v SelectionNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v SelectionNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 6)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Requestor: %d", v.Requestor))
+	fieldVals = append(fieldVals, sprintf("Selection: %d", v.Selection))
+	fieldVals = append(fieldVals, sprintf("Target: %d", v.Target))
+	fieldVals = append(fieldVals, sprintf("Property: %d", v.Property))
+	return "SelectionNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[31] = NewSelectionNotifyEvent
 }
@@ -4989,6 +5276,16 @@ func (v ColormapNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ColormapNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 6)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Colormap: %d", v.Colormap))
+	fieldVals = append(fieldVals, sprintf("New: %t", v.New))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	return "ColormapNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[32] = NewColormapNotifyEvent
 }
@@ -5064,6 +5361,15 @@ func (v ClientMessageEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ClientMessageEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Format: %d", v.Format))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Type: %d", v.Type))
+	return "ClientMessage {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[33] = NewClientMessageEvent
 }
@@ -5139,6 +5445,15 @@ func (v MappingNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v MappingNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 5)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Request: %d", v.Request))
+	fieldVals = append(fieldVals, sprintf("FirstKeycode: %d", v.FirstKeycode))
+	fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
+	return "MappingNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[34] = NewMappingNotifyEvent
 }
@@ -5163,6 +5478,23 @@ func (v KeyReleaseEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v KeyReleaseEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
+	return "KeyRelease {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[3] = NewKeyReleaseEvent
 }
@@ -5187,6 +5519,23 @@ func (v ButtonReleaseEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v ButtonReleaseEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("SameScreen: %t", v.SameScreen))
+	return "ButtonRelease {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[5] = NewButtonReleaseEvent
 }
@@ -5211,6 +5560,24 @@ func (v LeaveNotifyEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v LeaveNotifyEvent) String() string {
+	fieldVals := make([]string, 0, 12)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Time: %d", v.Time))
+	fieldVals = append(fieldVals, sprintf("Root: %d", v.Root))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Child: %d", v.Child))
+	fieldVals = append(fieldVals, sprintf("RootX: %d", v.RootX))
+	fieldVals = append(fieldVals, sprintf("RootY: %d", v.RootY))
+	fieldVals = append(fieldVals, sprintf("EventX: %d", v.EventX))
+	fieldVals = append(fieldVals, sprintf("EventY: %d", v.EventY))
+	fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+	fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
+	fieldVals = append(fieldVals, sprintf("SameScreenFocus: %d", v.SameScreenFocus))
+	return "LeaveNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[8] = NewLeaveNotifyEvent
 }
@@ -5235,6 +5602,15 @@ func (v FocusOutEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v FocusOutEvent) String() string {
+	fieldVals := make([]string, 0, 4)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Detail: %d", v.Detail))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Mode: %d", v.Mode))
+	return "FocusOut {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[10] = NewFocusOutEvent
 }
@@ -5259,6 +5635,15 @@ func (v CirculateRequestEvent) SequenceId() uint16 {
 	return v.Sequence
 }
 
+func (v CirculateRequestEvent) String() string {
+	fieldVals := make([]string, 0, 6)
+	fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+	fieldVals = append(fieldVals, sprintf("Event: %d", v.Event))
+	fieldVals = append(fieldVals, sprintf("Window: %d", v.Window))
+	fieldVals = append(fieldVals, sprintf("Place: %d", v.Place))
+	return "CirculateRequest {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
 func init() {
 	newEventFuncs[27] = NewCirculateRequestEvent
 }
@@ -5931,23 +6316,29 @@ func init() {
 
 // Request CreateWindow
 // size: pad((28 + (4 + pad((4 * popCount(int(ValueMask)))))))
-type CreateWindowCookie cookie
+type CreateWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreateWindow
 func (c *Conn) CreateWindow(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Visualid, ValueMask uint32, ValueList []uint32) CreateWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createWindowRequest(Depth, Wid, Parent, X, Y, Width, Height, BorderWidth, Class, Visual, ValueMask, ValueList), cookie)
-	return CreateWindowCookie(cookie)
+	c.newRequest(c.createWindowRequest(Depth, Wid, Parent, X, Y, Width, Height, BorderWidth, Class, Visual, ValueMask, ValueList), cookie)
+	return CreateWindowCookie{cookie}
 }
 
 func (c *Conn) CreateWindowChecked(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Visualid, ValueMask uint32, ValueList []uint32) CreateWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createWindowRequest(Depth, Wid, Parent, X, Y, Width, Height, BorderWidth, Class, Visual, ValueMask, ValueList), cookie)
-	return CreateWindowCookie(cookie)
+	c.newRequest(c.createWindowRequest(Depth, Wid, Parent, X, Y, Width, Height, BorderWidth, Class, Visual, ValueMask, ValueList), cookie)
+	return CreateWindowCookie{cookie}
+}
+
+func (cook CreateWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreateWindow
-func createWindowRequest(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Visualid, ValueMask uint32, ValueList []uint32) []byte {
+func (c *Conn) createWindowRequest(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Visualid, ValueMask uint32, ValueList []uint32) []byte {
 	size := pad((28 + (4 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -6001,23 +6392,29 @@ func createWindowRequest(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width
 
 // Request ChangeWindowAttributes
 // size: pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
-type ChangeWindowAttributesCookie cookie
+type ChangeWindowAttributesCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeWindowAttributes
 func (c *Conn) ChangeWindowAttributes(Window Id, ValueMask uint32, ValueList []uint32) ChangeWindowAttributesCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeWindowAttributesRequest(Window, ValueMask, ValueList), cookie)
-	return ChangeWindowAttributesCookie(cookie)
+	c.newRequest(c.changeWindowAttributesRequest(Window, ValueMask, ValueList), cookie)
+	return ChangeWindowAttributesCookie{cookie}
 }
 
 func (c *Conn) ChangeWindowAttributesChecked(Window Id, ValueMask uint32, ValueList []uint32) ChangeWindowAttributesCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeWindowAttributesRequest(Window, ValueMask, ValueList), cookie)
-	return ChangeWindowAttributesCookie(cookie)
+	c.newRequest(c.changeWindowAttributesRequest(Window, ValueMask, ValueList), cookie)
+	return ChangeWindowAttributesCookie{cookie}
+}
+
+func (cook ChangeWindowAttributesCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeWindowAttributes
-func changeWindowAttributesRequest(Window Id, ValueMask uint32, ValueList []uint32) []byte {
+func (c *Conn) changeWindowAttributesRequest(Window Id, ValueMask uint32, ValueList []uint32) []byte {
 	size := pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -6046,18 +6443,20 @@ func changeWindowAttributesRequest(Window Id, ValueMask uint32, ValueList []uint
 
 // Request GetWindowAttributes
 // size: 8
-type GetWindowAttributesCookie cookie
+type GetWindowAttributesCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetWindowAttributes(Window Id) GetWindowAttributesCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getWindowAttributesRequest(Window), cookie)
-	return GetWindowAttributesCookie(cookie)
+	c.newRequest(c.getWindowAttributesRequest(Window), cookie)
+	return GetWindowAttributesCookie{cookie}
 }
 
 func (c *Conn) GetWindowAttributesUnchecked(Window Id) GetWindowAttributesCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getWindowAttributesRequest(Window), cookie)
-	return GetWindowAttributesCookie(cookie)
+	c.newRequest(c.getWindowAttributesRequest(Window), cookie)
+	return GetWindowAttributesCookie{cookie}
 }
 
 // Request reply for GetWindowAttributes
@@ -6085,10 +6484,13 @@ type GetWindowAttributesReply struct {
 
 // Waits and reads reply data from request GetWindowAttributes
 func (cook GetWindowAttributesCookie) Reply() (*GetWindowAttributesReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getWindowAttributesReply(buf), nil
 }
 
@@ -6165,8 +6567,12 @@ func getWindowAttributesReply(buf []byte) *GetWindowAttributesReply {
 	return v
 }
 
+func (cook GetWindowAttributesCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetWindowAttributes
-func getWindowAttributesRequest(Window Id) []byte {
+func (c *Conn) getWindowAttributesRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6187,23 +6593,29 @@ func getWindowAttributesRequest(Window Id) []byte {
 
 // Request DestroyWindow
 // size: 8
-type DestroyWindowCookie cookie
+type DestroyWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for DestroyWindow
 func (c *Conn) DestroyWindow(Window Id) DestroyWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(destroyWindowRequest(Window), cookie)
-	return DestroyWindowCookie(cookie)
+	c.newRequest(c.destroyWindowRequest(Window), cookie)
+	return DestroyWindowCookie{cookie}
 }
 
 func (c *Conn) DestroyWindowChecked(Window Id) DestroyWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(destroyWindowRequest(Window), cookie)
-	return DestroyWindowCookie(cookie)
+	c.newRequest(c.destroyWindowRequest(Window), cookie)
+	return DestroyWindowCookie{cookie}
+}
+
+func (cook DestroyWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for DestroyWindow
-func destroyWindowRequest(Window Id) []byte {
+func (c *Conn) destroyWindowRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6224,23 +6636,29 @@ func destroyWindowRequest(Window Id) []byte {
 
 // Request DestroySubwindows
 // size: 8
-type DestroySubwindowsCookie cookie
+type DestroySubwindowsCookie struct {
+	*cookie
+}
 
 // Write request to wire for DestroySubwindows
 func (c *Conn) DestroySubwindows(Window Id) DestroySubwindowsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(destroySubwindowsRequest(Window), cookie)
-	return DestroySubwindowsCookie(cookie)
+	c.newRequest(c.destroySubwindowsRequest(Window), cookie)
+	return DestroySubwindowsCookie{cookie}
 }
 
 func (c *Conn) DestroySubwindowsChecked(Window Id) DestroySubwindowsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(destroySubwindowsRequest(Window), cookie)
-	return DestroySubwindowsCookie(cookie)
+	c.newRequest(c.destroySubwindowsRequest(Window), cookie)
+	return DestroySubwindowsCookie{cookie}
+}
+
+func (cook DestroySubwindowsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for DestroySubwindows
-func destroySubwindowsRequest(Window Id) []byte {
+func (c *Conn) destroySubwindowsRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6261,23 +6679,29 @@ func destroySubwindowsRequest(Window Id) []byte {
 
 // Request ChangeSaveSet
 // size: 8
-type ChangeSaveSetCookie cookie
+type ChangeSaveSetCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeSaveSet
 func (c *Conn) ChangeSaveSet(Mode byte, Window Id) ChangeSaveSetCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeSaveSetRequest(Mode, Window), cookie)
-	return ChangeSaveSetCookie(cookie)
+	c.newRequest(c.changeSaveSetRequest(Mode, Window), cookie)
+	return ChangeSaveSetCookie{cookie}
 }
 
 func (c *Conn) ChangeSaveSetChecked(Mode byte, Window Id) ChangeSaveSetCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeSaveSetRequest(Mode, Window), cookie)
-	return ChangeSaveSetCookie(cookie)
+	c.newRequest(c.changeSaveSetRequest(Mode, Window), cookie)
+	return ChangeSaveSetCookie{cookie}
+}
+
+func (cook ChangeSaveSetCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeSaveSet
-func changeSaveSetRequest(Mode byte, Window Id) []byte {
+func (c *Conn) changeSaveSetRequest(Mode byte, Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6299,23 +6723,29 @@ func changeSaveSetRequest(Mode byte, Window Id) []byte {
 
 // Request ReparentWindow
 // size: 16
-type ReparentWindowCookie cookie
+type ReparentWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for ReparentWindow
 func (c *Conn) ReparentWindow(Window Id, Parent Id, X int16, Y int16) ReparentWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(reparentWindowRequest(Window, Parent, X, Y), cookie)
-	return ReparentWindowCookie(cookie)
+	c.newRequest(c.reparentWindowRequest(Window, Parent, X, Y), cookie)
+	return ReparentWindowCookie{cookie}
 }
 
 func (c *Conn) ReparentWindowChecked(Window Id, Parent Id, X int16, Y int16) ReparentWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(reparentWindowRequest(Window, Parent, X, Y), cookie)
-	return ReparentWindowCookie(cookie)
+	c.newRequest(c.reparentWindowRequest(Window, Parent, X, Y), cookie)
+	return ReparentWindowCookie{cookie}
+}
+
+func (cook ReparentWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ReparentWindow
-func reparentWindowRequest(Window Id, Parent Id, X int16, Y int16) []byte {
+func (c *Conn) reparentWindowRequest(Window Id, Parent Id, X int16, Y int16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -6345,23 +6775,29 @@ func reparentWindowRequest(Window Id, Parent Id, X int16, Y int16) []byte {
 
 // Request MapWindow
 // size: 8
-type MapWindowCookie cookie
+type MapWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for MapWindow
 func (c *Conn) MapWindow(Window Id) MapWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(mapWindowRequest(Window), cookie)
-	return MapWindowCookie(cookie)
+	c.newRequest(c.mapWindowRequest(Window), cookie)
+	return MapWindowCookie{cookie}
 }
 
 func (c *Conn) MapWindowChecked(Window Id) MapWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(mapWindowRequest(Window), cookie)
-	return MapWindowCookie(cookie)
+	c.newRequest(c.mapWindowRequest(Window), cookie)
+	return MapWindowCookie{cookie}
+}
+
+func (cook MapWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for MapWindow
-func mapWindowRequest(Window Id) []byte {
+func (c *Conn) mapWindowRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6382,23 +6818,29 @@ func mapWindowRequest(Window Id) []byte {
 
 // Request MapSubwindows
 // size: 8
-type MapSubwindowsCookie cookie
+type MapSubwindowsCookie struct {
+	*cookie
+}
 
 // Write request to wire for MapSubwindows
 func (c *Conn) MapSubwindows(Window Id) MapSubwindowsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(mapSubwindowsRequest(Window), cookie)
-	return MapSubwindowsCookie(cookie)
+	c.newRequest(c.mapSubwindowsRequest(Window), cookie)
+	return MapSubwindowsCookie{cookie}
 }
 
 func (c *Conn) MapSubwindowsChecked(Window Id) MapSubwindowsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(mapSubwindowsRequest(Window), cookie)
-	return MapSubwindowsCookie(cookie)
+	c.newRequest(c.mapSubwindowsRequest(Window), cookie)
+	return MapSubwindowsCookie{cookie}
+}
+
+func (cook MapSubwindowsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for MapSubwindows
-func mapSubwindowsRequest(Window Id) []byte {
+func (c *Conn) mapSubwindowsRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6419,23 +6861,29 @@ func mapSubwindowsRequest(Window Id) []byte {
 
 // Request UnmapWindow
 // size: 8
-type UnmapWindowCookie cookie
+type UnmapWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for UnmapWindow
 func (c *Conn) UnmapWindow(Window Id) UnmapWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(unmapWindowRequest(Window), cookie)
-	return UnmapWindowCookie(cookie)
+	c.newRequest(c.unmapWindowRequest(Window), cookie)
+	return UnmapWindowCookie{cookie}
 }
 
 func (c *Conn) UnmapWindowChecked(Window Id) UnmapWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(unmapWindowRequest(Window), cookie)
-	return UnmapWindowCookie(cookie)
+	c.newRequest(c.unmapWindowRequest(Window), cookie)
+	return UnmapWindowCookie{cookie}
+}
+
+func (cook UnmapWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UnmapWindow
-func unmapWindowRequest(Window Id) []byte {
+func (c *Conn) unmapWindowRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6456,23 +6904,29 @@ func unmapWindowRequest(Window Id) []byte {
 
 // Request UnmapSubwindows
 // size: 8
-type UnmapSubwindowsCookie cookie
+type UnmapSubwindowsCookie struct {
+	*cookie
+}
 
 // Write request to wire for UnmapSubwindows
 func (c *Conn) UnmapSubwindows(Window Id) UnmapSubwindowsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(unmapSubwindowsRequest(Window), cookie)
-	return UnmapSubwindowsCookie(cookie)
+	c.newRequest(c.unmapSubwindowsRequest(Window), cookie)
+	return UnmapSubwindowsCookie{cookie}
 }
 
 func (c *Conn) UnmapSubwindowsChecked(Window Id) UnmapSubwindowsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(unmapSubwindowsRequest(Window), cookie)
-	return UnmapSubwindowsCookie(cookie)
+	c.newRequest(c.unmapSubwindowsRequest(Window), cookie)
+	return UnmapSubwindowsCookie{cookie}
+}
+
+func (cook UnmapSubwindowsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UnmapSubwindows
-func unmapSubwindowsRequest(Window Id) []byte {
+func (c *Conn) unmapSubwindowsRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6493,23 +6947,29 @@ func unmapSubwindowsRequest(Window Id) []byte {
 
 // Request ConfigureWindow
 // size: pad((10 + (2 + pad((4 * popCount(int(ValueMask)))))))
-type ConfigureWindowCookie cookie
+type ConfigureWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for ConfigureWindow
 func (c *Conn) ConfigureWindow(Window Id, ValueMask uint16, ValueList []uint32) ConfigureWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(configureWindowRequest(Window, ValueMask, ValueList), cookie)
-	return ConfigureWindowCookie(cookie)
+	c.newRequest(c.configureWindowRequest(Window, ValueMask, ValueList), cookie)
+	return ConfigureWindowCookie{cookie}
 }
 
 func (c *Conn) ConfigureWindowChecked(Window Id, ValueMask uint16, ValueList []uint32) ConfigureWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(configureWindowRequest(Window, ValueMask, ValueList), cookie)
-	return ConfigureWindowCookie(cookie)
+	c.newRequest(c.configureWindowRequest(Window, ValueMask, ValueList), cookie)
+	return ConfigureWindowCookie{cookie}
+}
+
+func (cook ConfigureWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ConfigureWindow
-func configureWindowRequest(Window Id, ValueMask uint16, ValueList []uint32) []byte {
+func (c *Conn) configureWindowRequest(Window Id, ValueMask uint16, ValueList []uint32) []byte {
 	size := pad((10 + (2 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -6541,23 +7001,29 @@ func configureWindowRequest(Window Id, ValueMask uint16, ValueList []uint32) []b
 
 // Request CirculateWindow
 // size: 8
-type CirculateWindowCookie cookie
+type CirculateWindowCookie struct {
+	*cookie
+}
 
 // Write request to wire for CirculateWindow
 func (c *Conn) CirculateWindow(Direction byte, Window Id) CirculateWindowCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(circulateWindowRequest(Direction, Window), cookie)
-	return CirculateWindowCookie(cookie)
+	c.newRequest(c.circulateWindowRequest(Direction, Window), cookie)
+	return CirculateWindowCookie{cookie}
 }
 
 func (c *Conn) CirculateWindowChecked(Direction byte, Window Id) CirculateWindowCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(circulateWindowRequest(Direction, Window), cookie)
-	return CirculateWindowCookie(cookie)
+	c.newRequest(c.circulateWindowRequest(Direction, Window), cookie)
+	return CirculateWindowCookie{cookie}
+}
+
+func (cook CirculateWindowCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CirculateWindow
-func circulateWindowRequest(Direction byte, Window Id) []byte {
+func (c *Conn) circulateWindowRequest(Direction byte, Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6579,18 +7045,20 @@ func circulateWindowRequest(Direction byte, Window Id) []byte {
 
 // Request GetGeometry
 // size: 8
-type GetGeometryCookie cookie
+type GetGeometryCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetGeometry(Drawable Id) GetGeometryCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getGeometryRequest(Drawable), cookie)
-	return GetGeometryCookie(cookie)
+	c.newRequest(c.getGeometryRequest(Drawable), cookie)
+	return GetGeometryCookie{cookie}
 }
 
 func (c *Conn) GetGeometryUnchecked(Drawable Id) GetGeometryCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getGeometryRequest(Drawable), cookie)
-	return GetGeometryCookie(cookie)
+	c.newRequest(c.getGeometryRequest(Drawable), cookie)
+	return GetGeometryCookie{cookie}
 }
 
 // Request reply for GetGeometry
@@ -6610,10 +7078,13 @@ type GetGeometryReply struct {
 
 // Waits and reads reply data from request GetGeometry
 func (cook GetGeometryCookie) Reply() (*GetGeometryReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getGeometryReply(buf), nil
 }
 
@@ -6654,8 +7125,12 @@ func getGeometryReply(buf []byte) *GetGeometryReply {
 	return v
 }
 
+func (cook GetGeometryCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetGeometry
-func getGeometryRequest(Drawable Id) []byte {
+func (c *Conn) getGeometryRequest(Drawable Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6676,18 +7151,20 @@ func getGeometryRequest(Drawable Id) []byte {
 
 // Request QueryTree
 // size: 8
-type QueryTreeCookie cookie
+type QueryTreeCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryTree(Window Id) QueryTreeCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryTreeRequest(Window), cookie)
-	return QueryTreeCookie(cookie)
+	c.newRequest(c.queryTreeRequest(Window), cookie)
+	return QueryTreeCookie{cookie}
 }
 
 func (c *Conn) QueryTreeUnchecked(Window Id) QueryTreeCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryTreeRequest(Window), cookie)
-	return QueryTreeCookie(cookie)
+	c.newRequest(c.queryTreeRequest(Window), cookie)
+	return QueryTreeCookie{cookie}
 }
 
 // Request reply for QueryTree
@@ -6705,10 +7182,13 @@ type QueryTreeReply struct {
 
 // Waits and reads reply data from request QueryTree
 func (cook QueryTreeCookie) Reply() (*QueryTreeReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryTreeReply(buf), nil
 }
 
@@ -6746,8 +7226,12 @@ func queryTreeReply(buf []byte) *QueryTreeReply {
 	return v
 }
 
+func (cook QueryTreeCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryTree
-func queryTreeRequest(Window Id) []byte {
+func (c *Conn) queryTreeRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6768,18 +7252,20 @@ func queryTreeRequest(Window Id) []byte {
 
 // Request InternAtom
 // size: pad((8 + pad((int(NameLen) * 1))))
-type InternAtomCookie cookie
+type InternAtomCookie struct {
+	*cookie
+}
 
 func (c *Conn) InternAtom(OnlyIfExists bool, NameLen uint16, Name string) InternAtomCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(internAtomRequest(OnlyIfExists, NameLen, Name), cookie)
-	return InternAtomCookie(cookie)
+	c.newRequest(c.internAtomRequest(OnlyIfExists, NameLen, Name), cookie)
+	return InternAtomCookie{cookie}
 }
 
 func (c *Conn) InternAtomUnchecked(OnlyIfExists bool, NameLen uint16, Name string) InternAtomCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(internAtomRequest(OnlyIfExists, NameLen, Name), cookie)
-	return InternAtomCookie(cookie)
+	c.newRequest(c.internAtomRequest(OnlyIfExists, NameLen, Name), cookie)
+	return InternAtomCookie{cookie}
 }
 
 // Request reply for InternAtom
@@ -6793,10 +7279,13 @@ type InternAtomReply struct {
 
 // Waits and reads reply data from request InternAtom
 func (cook InternAtomCookie) Reply() (*InternAtomReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return internAtomReply(buf), nil
 }
 
@@ -6819,8 +7308,12 @@ func internAtomReply(buf []byte) *InternAtomReply {
 	return v
 }
 
+func (cook InternAtomCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for InternAtom
-func internAtomRequest(OnlyIfExists bool, NameLen uint16, Name string) []byte {
+func (c *Conn) internAtomRequest(OnlyIfExists bool, NameLen uint16, Name string) []byte {
 	size := pad((8 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -6851,18 +7344,20 @@ func internAtomRequest(OnlyIfExists bool, NameLen uint16, Name string) []byte {
 
 // Request GetAtomName
 // size: 8
-type GetAtomNameCookie cookie
+type GetAtomNameCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetAtomName(Atom Id) GetAtomNameCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getAtomNameRequest(Atom), cookie)
-	return GetAtomNameCookie(cookie)
+	c.newRequest(c.getAtomNameRequest(Atom), cookie)
+	return GetAtomNameCookie{cookie}
 }
 
 func (c *Conn) GetAtomNameUnchecked(Atom Id) GetAtomNameCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getAtomNameRequest(Atom), cookie)
-	return GetAtomNameCookie(cookie)
+	c.newRequest(c.getAtomNameRequest(Atom), cookie)
+	return GetAtomNameCookie{cookie}
 }
 
 // Request reply for GetAtomName
@@ -6878,10 +7373,13 @@ type GetAtomNameReply struct {
 
 // Waits and reads reply data from request GetAtomName
 func (cook GetAtomNameCookie) Reply() (*GetAtomNameReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getAtomNameReply(buf), nil
 }
 
@@ -6913,8 +7411,12 @@ func getAtomNameReply(buf []byte) *GetAtomNameReply {
 	return v
 }
 
+func (cook GetAtomNameCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetAtomName
-func getAtomNameRequest(Atom Id) []byte {
+func (c *Conn) getAtomNameRequest(Atom Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -6935,23 +7437,29 @@ func getAtomNameRequest(Atom Id) []byte {
 
 // Request ChangeProperty
 // size: pad((24 + pad((((int(DataLen) * int(Format)) / 8) * 1))))
-type ChangePropertyCookie cookie
+type ChangePropertyCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeProperty
 func (c *Conn) ChangeProperty(Mode byte, Window Id, Property Id, Type Id, Format byte, DataLen uint32, Data []byte) ChangePropertyCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changePropertyRequest(Mode, Window, Property, Type, Format, DataLen, Data), cookie)
-	return ChangePropertyCookie(cookie)
+	c.newRequest(c.changePropertyRequest(Mode, Window, Property, Type, Format, DataLen, Data), cookie)
+	return ChangePropertyCookie{cookie}
 }
 
 func (c *Conn) ChangePropertyChecked(Mode byte, Window Id, Property Id, Type Id, Format byte, DataLen uint32, Data []byte) ChangePropertyCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changePropertyRequest(Mode, Window, Property, Type, Format, DataLen, Data), cookie)
-	return ChangePropertyCookie(cookie)
+	c.newRequest(c.changePropertyRequest(Mode, Window, Property, Type, Format, DataLen, Data), cookie)
+	return ChangePropertyCookie{cookie}
+}
+
+func (cook ChangePropertyCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeProperty
-func changePropertyRequest(Mode byte, Window Id, Property Id, Type Id, Format byte, DataLen uint32, Data []byte) []byte {
+func (c *Conn) changePropertyRequest(Mode byte, Window Id, Property Id, Type Id, Format byte, DataLen uint32, Data []byte) []byte {
 	size := pad((24 + pad((((int(DataLen) * int(Format)) / 8) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -6990,23 +7498,29 @@ func changePropertyRequest(Mode byte, Window Id, Property Id, Type Id, Format by
 
 // Request DeleteProperty
 // size: 12
-type DeletePropertyCookie cookie
+type DeletePropertyCookie struct {
+	*cookie
+}
 
 // Write request to wire for DeleteProperty
 func (c *Conn) DeleteProperty(Window Id, Property Id) DeletePropertyCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(deletePropertyRequest(Window, Property), cookie)
-	return DeletePropertyCookie(cookie)
+	c.newRequest(c.deletePropertyRequest(Window, Property), cookie)
+	return DeletePropertyCookie{cookie}
 }
 
 func (c *Conn) DeletePropertyChecked(Window Id, Property Id) DeletePropertyCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(deletePropertyRequest(Window, Property), cookie)
-	return DeletePropertyCookie(cookie)
+	c.newRequest(c.deletePropertyRequest(Window, Property), cookie)
+	return DeletePropertyCookie{cookie}
+}
+
+func (cook DeletePropertyCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for DeleteProperty
-func deletePropertyRequest(Window Id, Property Id) []byte {
+func (c *Conn) deletePropertyRequest(Window Id, Property Id) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -7030,18 +7544,20 @@ func deletePropertyRequest(Window Id, Property Id) []byte {
 
 // Request GetProperty
 // size: 24
-type GetPropertyCookie cookie
+type GetPropertyCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetProperty(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) GetPropertyCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength), cookie)
-	return GetPropertyCookie(cookie)
+	c.newRequest(c.getPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength), cookie)
+	return GetPropertyCookie{cookie}
 }
 
 func (c *Conn) GetPropertyUnchecked(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) GetPropertyCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength), cookie)
-	return GetPropertyCookie(cookie)
+	c.newRequest(c.getPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength), cookie)
+	return GetPropertyCookie{cookie}
 }
 
 // Request reply for GetProperty
@@ -7059,10 +7575,13 @@ type GetPropertyReply struct {
 
 // Waits and reads reply data from request GetProperty
 func (cook GetPropertyCookie) Reply() (*GetPropertyReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getPropertyReply(buf), nil
 }
 
@@ -7098,8 +7617,12 @@ func getPropertyReply(buf []byte) *GetPropertyReply {
 	return v
 }
 
+func (cook GetPropertyCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetProperty
-func getPropertyRequest(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) []byte {
+func (c *Conn) getPropertyRequest(Delete bool, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) []byte {
 	size := 24
 	b := 0
 	buf := make([]byte, size)
@@ -7137,18 +7660,20 @@ func getPropertyRequest(Delete bool, Window Id, Property Id, Type Id, LongOffset
 
 // Request ListProperties
 // size: 8
-type ListPropertiesCookie cookie
+type ListPropertiesCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListProperties(Window Id) ListPropertiesCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listPropertiesRequest(Window), cookie)
-	return ListPropertiesCookie(cookie)
+	c.newRequest(c.listPropertiesRequest(Window), cookie)
+	return ListPropertiesCookie{cookie}
 }
 
 func (c *Conn) ListPropertiesUnchecked(Window Id) ListPropertiesCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listPropertiesRequest(Window), cookie)
-	return ListPropertiesCookie(cookie)
+	c.newRequest(c.listPropertiesRequest(Window), cookie)
+	return ListPropertiesCookie{cookie}
 }
 
 // Request reply for ListProperties
@@ -7164,10 +7689,13 @@ type ListPropertiesReply struct {
 
 // Waits and reads reply data from request ListProperties
 func (cook ListPropertiesCookie) Reply() (*ListPropertiesReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listPropertiesReply(buf), nil
 }
 
@@ -7199,8 +7727,12 @@ func listPropertiesReply(buf []byte) *ListPropertiesReply {
 	return v
 }
 
+func (cook ListPropertiesCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListProperties
-func listPropertiesRequest(Window Id) []byte {
+func (c *Conn) listPropertiesRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -7221,23 +7753,29 @@ func listPropertiesRequest(Window Id) []byte {
 
 // Request SetSelectionOwner
 // size: 16
-type SetSelectionOwnerCookie cookie
+type SetSelectionOwnerCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetSelectionOwner
 func (c *Conn) SetSelectionOwner(Owner Id, Selection Id, Time Timestamp) SetSelectionOwnerCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setSelectionOwnerRequest(Owner, Selection, Time), cookie)
-	return SetSelectionOwnerCookie(cookie)
+	c.newRequest(c.setSelectionOwnerRequest(Owner, Selection, Time), cookie)
+	return SetSelectionOwnerCookie{cookie}
 }
 
 func (c *Conn) SetSelectionOwnerChecked(Owner Id, Selection Id, Time Timestamp) SetSelectionOwnerCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setSelectionOwnerRequest(Owner, Selection, Time), cookie)
-	return SetSelectionOwnerCookie(cookie)
+	c.newRequest(c.setSelectionOwnerRequest(Owner, Selection, Time), cookie)
+	return SetSelectionOwnerCookie{cookie}
+}
+
+func (cook SetSelectionOwnerCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetSelectionOwner
-func setSelectionOwnerRequest(Owner Id, Selection Id, Time Timestamp) []byte {
+func (c *Conn) setSelectionOwnerRequest(Owner Id, Selection Id, Time Timestamp) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -7264,18 +7802,20 @@ func setSelectionOwnerRequest(Owner Id, Selection Id, Time Timestamp) []byte {
 
 // Request GetSelectionOwner
 // size: 8
-type GetSelectionOwnerCookie cookie
+type GetSelectionOwnerCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetSelectionOwner(Selection Id) GetSelectionOwnerCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getSelectionOwnerRequest(Selection), cookie)
-	return GetSelectionOwnerCookie(cookie)
+	c.newRequest(c.getSelectionOwnerRequest(Selection), cookie)
+	return GetSelectionOwnerCookie{cookie}
 }
 
 func (c *Conn) GetSelectionOwnerUnchecked(Selection Id) GetSelectionOwnerCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getSelectionOwnerRequest(Selection), cookie)
-	return GetSelectionOwnerCookie(cookie)
+	c.newRequest(c.getSelectionOwnerRequest(Selection), cookie)
+	return GetSelectionOwnerCookie{cookie}
 }
 
 // Request reply for GetSelectionOwner
@@ -7289,10 +7829,13 @@ type GetSelectionOwnerReply struct {
 
 // Waits and reads reply data from request GetSelectionOwner
 func (cook GetSelectionOwnerCookie) Reply() (*GetSelectionOwnerReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getSelectionOwnerReply(buf), nil
 }
 
@@ -7315,8 +7858,12 @@ func getSelectionOwnerReply(buf []byte) *GetSelectionOwnerReply {
 	return v
 }
 
+func (cook GetSelectionOwnerCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetSelectionOwner
-func getSelectionOwnerRequest(Selection Id) []byte {
+func (c *Conn) getSelectionOwnerRequest(Selection Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -7337,23 +7884,29 @@ func getSelectionOwnerRequest(Selection Id) []byte {
 
 // Request ConvertSelection
 // size: 24
-type ConvertSelectionCookie cookie
+type ConvertSelectionCookie struct {
+	*cookie
+}
 
 // Write request to wire for ConvertSelection
 func (c *Conn) ConvertSelection(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) ConvertSelectionCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(convertSelectionRequest(Requestor, Selection, Target, Property, Time), cookie)
-	return ConvertSelectionCookie(cookie)
+	c.newRequest(c.convertSelectionRequest(Requestor, Selection, Target, Property, Time), cookie)
+	return ConvertSelectionCookie{cookie}
 }
 
 func (c *Conn) ConvertSelectionChecked(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) ConvertSelectionCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(convertSelectionRequest(Requestor, Selection, Target, Property, Time), cookie)
-	return ConvertSelectionCookie(cookie)
+	c.newRequest(c.convertSelectionRequest(Requestor, Selection, Target, Property, Time), cookie)
+	return ConvertSelectionCookie{cookie}
+}
+
+func (cook ConvertSelectionCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ConvertSelection
-func convertSelectionRequest(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) []byte {
+func (c *Conn) convertSelectionRequest(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) []byte {
 	size := 24
 	b := 0
 	buf := make([]byte, size)
@@ -7386,23 +7939,29 @@ func convertSelectionRequest(Requestor Id, Selection Id, Target Id, Property Id,
 
 // Request SendEvent
 // size: pad((12 + pad(32)))
-type SendEventCookie cookie
+type SendEventCookie struct {
+	*cookie
+}
 
 // Write request to wire for SendEvent
 func (c *Conn) SendEvent(Propagate bool, Destination Id, EventMask uint32, Event string) SendEventCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(sendEventRequest(Propagate, Destination, EventMask, Event), cookie)
-	return SendEventCookie(cookie)
+	c.newRequest(c.sendEventRequest(Propagate, Destination, EventMask, Event), cookie)
+	return SendEventCookie{cookie}
 }
 
 func (c *Conn) SendEventChecked(Propagate bool, Destination Id, EventMask uint32, Event string) SendEventCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(sendEventRequest(Propagate, Destination, EventMask, Event), cookie)
-	return SendEventCookie(cookie)
+	c.newRequest(c.sendEventRequest(Propagate, Destination, EventMask, Event), cookie)
+	return SendEventCookie{cookie}
+}
+
+func (cook SendEventCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SendEvent
-func sendEventRequest(Propagate bool, Destination Id, EventMask uint32, Event string) []byte {
+func (c *Conn) sendEventRequest(Propagate bool, Destination Id, EventMask uint32, Event string) []byte {
 	size := pad((12 + pad(32)))
 	b := 0
 	buf := make([]byte, size)
@@ -7434,18 +7993,20 @@ func sendEventRequest(Propagate bool, Destination Id, EventMask uint32, Event st
 
 // Request GrabPointer
 // size: 24
-type GrabPointerCookie cookie
+type GrabPointerCookie struct {
+	*cookie
+}
 
 func (c *Conn) GrabPointer(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) GrabPointerCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(grabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time), cookie)
-	return GrabPointerCookie(cookie)
+	c.newRequest(c.grabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time), cookie)
+	return GrabPointerCookie{cookie}
 }
 
 func (c *Conn) GrabPointerUnchecked(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) GrabPointerCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(grabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time), cookie)
-	return GrabPointerCookie(cookie)
+	c.newRequest(c.grabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time), cookie)
+	return GrabPointerCookie{cookie}
 }
 
 // Request reply for GrabPointer
@@ -7458,10 +8019,13 @@ type GrabPointerReply struct {
 
 // Waits and reads reply data from request GrabPointer
 func (cook GrabPointerCookie) Reply() (*GrabPointerReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return grabPointerReply(buf), nil
 }
 
@@ -7473,11 +8037,21 @@ func grabPointerReply(buf []byte) *GrabPointerReply {
 	v.Status = buf[b]
 	b += 1
 
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
 	return v
 }
 
+func (cook GrabPointerCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GrabPointer
-func grabPointerRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) []byte {
+func (c *Conn) grabPointerRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) []byte {
 	size := 24
 	b := 0
 	buf := make([]byte, size)
@@ -7521,23 +8095,29 @@ func grabPointerRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, Point
 
 // Request UngrabPointer
 // size: 8
-type UngrabPointerCookie cookie
+type UngrabPointerCookie struct {
+	*cookie
+}
 
 // Write request to wire for UngrabPointer
 func (c *Conn) UngrabPointer(Time Timestamp) UngrabPointerCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(ungrabPointerRequest(Time), cookie)
-	return UngrabPointerCookie(cookie)
+	c.newRequest(c.ungrabPointerRequest(Time), cookie)
+	return UngrabPointerCookie{cookie}
 }
 
 func (c *Conn) UngrabPointerChecked(Time Timestamp) UngrabPointerCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(ungrabPointerRequest(Time), cookie)
-	return UngrabPointerCookie(cookie)
+	c.newRequest(c.ungrabPointerRequest(Time), cookie)
+	return UngrabPointerCookie{cookie}
+}
+
+func (cook UngrabPointerCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UngrabPointer
-func ungrabPointerRequest(Time Timestamp) []byte {
+func (c *Conn) ungrabPointerRequest(Time Timestamp) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -7558,23 +8138,29 @@ func ungrabPointerRequest(Time Timestamp) []byte {
 
 // Request GrabButton
 // size: 24
-type GrabButtonCookie cookie
+type GrabButtonCookie struct {
+	*cookie
+}
 
 // Write request to wire for GrabButton
 func (c *Conn) GrabButton(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) GrabButtonCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(grabButtonRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Button, Modifiers), cookie)
-	return GrabButtonCookie(cookie)
+	c.newRequest(c.grabButtonRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Button, Modifiers), cookie)
+	return GrabButtonCookie{cookie}
 }
 
 func (c *Conn) GrabButtonChecked(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) GrabButtonCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(grabButtonRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Button, Modifiers), cookie)
-	return GrabButtonCookie(cookie)
+	c.newRequest(c.grabButtonRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Button, Modifiers), cookie)
+	return GrabButtonCookie{cookie}
+}
+
+func (cook GrabButtonCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for GrabButton
-func grabButtonRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) []byte {
+func (c *Conn) grabButtonRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) []byte {
 	size := 24
 	b := 0
 	buf := make([]byte, size)
@@ -7623,23 +8209,29 @@ func grabButtonRequest(OwnerEvents bool, GrabWindow Id, EventMask uint16, Pointe
 
 // Request UngrabButton
 // size: 12
-type UngrabButtonCookie cookie
+type UngrabButtonCookie struct {
+	*cookie
+}
 
 // Write request to wire for UngrabButton
 func (c *Conn) UngrabButton(Button byte, GrabWindow Id, Modifiers uint16) UngrabButtonCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(ungrabButtonRequest(Button, GrabWindow, Modifiers), cookie)
-	return UngrabButtonCookie(cookie)
+	c.newRequest(c.ungrabButtonRequest(Button, GrabWindow, Modifiers), cookie)
+	return UngrabButtonCookie{cookie}
 }
 
 func (c *Conn) UngrabButtonChecked(Button byte, GrabWindow Id, Modifiers uint16) UngrabButtonCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(ungrabButtonRequest(Button, GrabWindow, Modifiers), cookie)
-	return UngrabButtonCookie(cookie)
+	c.newRequest(c.ungrabButtonRequest(Button, GrabWindow, Modifiers), cookie)
+	return UngrabButtonCookie{cookie}
+}
+
+func (cook UngrabButtonCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UngrabButton
-func ungrabButtonRequest(Button byte, GrabWindow Id, Modifiers uint16) []byte {
+func (c *Conn) ungrabButtonRequest(Button byte, GrabWindow Id, Modifiers uint16) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -7666,23 +8258,29 @@ func ungrabButtonRequest(Button byte, GrabWindow Id, Modifiers uint16) []byte {
 
 // Request ChangeActivePointerGrab
 // size: 16
-type ChangeActivePointerGrabCookie cookie
+type ChangeActivePointerGrabCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeActivePointerGrab
 func (c *Conn) ChangeActivePointerGrab(Cursor Id, Time Timestamp, EventMask uint16) ChangeActivePointerGrabCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeActivePointerGrabRequest(Cursor, Time, EventMask), cookie)
-	return ChangeActivePointerGrabCookie(cookie)
+	c.newRequest(c.changeActivePointerGrabRequest(Cursor, Time, EventMask), cookie)
+	return ChangeActivePointerGrabCookie{cookie}
 }
 
 func (c *Conn) ChangeActivePointerGrabChecked(Cursor Id, Time Timestamp, EventMask uint16) ChangeActivePointerGrabCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeActivePointerGrabRequest(Cursor, Time, EventMask), cookie)
-	return ChangeActivePointerGrabCookie(cookie)
+	c.newRequest(c.changeActivePointerGrabRequest(Cursor, Time, EventMask), cookie)
+	return ChangeActivePointerGrabCookie{cookie}
+}
+
+func (cook ChangeActivePointerGrabCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeActivePointerGrab
-func changeActivePointerGrabRequest(Cursor Id, Time Timestamp, EventMask uint16) []byte {
+func (c *Conn) changeActivePointerGrabRequest(Cursor Id, Time Timestamp, EventMask uint16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -7711,18 +8309,20 @@ func changeActivePointerGrabRequest(Cursor Id, Time Timestamp, EventMask uint16)
 
 // Request GrabKeyboard
 // size: 16
-type GrabKeyboardCookie cookie
+type GrabKeyboardCookie struct {
+	*cookie
+}
 
 func (c *Conn) GrabKeyboard(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) GrabKeyboardCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(grabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode), cookie)
-	return GrabKeyboardCookie(cookie)
+	c.newRequest(c.grabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode), cookie)
+	return GrabKeyboardCookie{cookie}
 }
 
 func (c *Conn) GrabKeyboardUnchecked(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) GrabKeyboardCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(grabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode), cookie)
-	return GrabKeyboardCookie(cookie)
+	c.newRequest(c.grabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode), cookie)
+	return GrabKeyboardCookie{cookie}
 }
 
 // Request reply for GrabKeyboard
@@ -7735,10 +8335,13 @@ type GrabKeyboardReply struct {
 
 // Waits and reads reply data from request GrabKeyboard
 func (cook GrabKeyboardCookie) Reply() (*GrabKeyboardReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return grabKeyboardReply(buf), nil
 }
 
@@ -7750,11 +8353,21 @@ func grabKeyboardReply(buf []byte) *GrabKeyboardReply {
 	v.Status = buf[b]
 	b += 1
 
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
 	return v
 }
 
+func (cook GrabKeyboardCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GrabKeyboard
-func grabKeyboardRequest(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) []byte {
+func (c *Conn) grabKeyboardRequest(OwnerEvents bool, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -7791,23 +8404,29 @@ func grabKeyboardRequest(OwnerEvents bool, GrabWindow Id, Time Timestamp, Pointe
 
 // Request UngrabKeyboard
 // size: 8
-type UngrabKeyboardCookie cookie
+type UngrabKeyboardCookie struct {
+	*cookie
+}
 
 // Write request to wire for UngrabKeyboard
 func (c *Conn) UngrabKeyboard(Time Timestamp) UngrabKeyboardCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(ungrabKeyboardRequest(Time), cookie)
-	return UngrabKeyboardCookie(cookie)
+	c.newRequest(c.ungrabKeyboardRequest(Time), cookie)
+	return UngrabKeyboardCookie{cookie}
 }
 
 func (c *Conn) UngrabKeyboardChecked(Time Timestamp) UngrabKeyboardCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(ungrabKeyboardRequest(Time), cookie)
-	return UngrabKeyboardCookie(cookie)
+	c.newRequest(c.ungrabKeyboardRequest(Time), cookie)
+	return UngrabKeyboardCookie{cookie}
+}
+
+func (cook UngrabKeyboardCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UngrabKeyboard
-func ungrabKeyboardRequest(Time Timestamp) []byte {
+func (c *Conn) ungrabKeyboardRequest(Time Timestamp) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -7828,23 +8447,29 @@ func ungrabKeyboardRequest(Time Timestamp) []byte {
 
 // Request GrabKey
 // size: 16
-type GrabKeyCookie cookie
+type GrabKeyCookie struct {
+	*cookie
+}
 
 // Write request to wire for GrabKey
 func (c *Conn) GrabKey(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keycode, PointerMode byte, KeyboardMode byte) GrabKeyCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(grabKeyRequest(OwnerEvents, GrabWindow, Modifiers, Key, PointerMode, KeyboardMode), cookie)
-	return GrabKeyCookie(cookie)
+	c.newRequest(c.grabKeyRequest(OwnerEvents, GrabWindow, Modifiers, Key, PointerMode, KeyboardMode), cookie)
+	return GrabKeyCookie{cookie}
 }
 
 func (c *Conn) GrabKeyChecked(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keycode, PointerMode byte, KeyboardMode byte) GrabKeyCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(grabKeyRequest(OwnerEvents, GrabWindow, Modifiers, Key, PointerMode, KeyboardMode), cookie)
-	return GrabKeyCookie(cookie)
+	c.newRequest(c.grabKeyRequest(OwnerEvents, GrabWindow, Modifiers, Key, PointerMode, KeyboardMode), cookie)
+	return GrabKeyCookie{cookie}
+}
+
+func (cook GrabKeyCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for GrabKey
-func grabKeyRequest(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keycode, PointerMode byte, KeyboardMode byte) []byte {
+func (c *Conn) grabKeyRequest(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keycode, PointerMode byte, KeyboardMode byte) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -7884,23 +8509,29 @@ func grabKeyRequest(OwnerEvents bool, GrabWindow Id, Modifiers uint16, Key Keyco
 
 // Request UngrabKey
 // size: 12
-type UngrabKeyCookie cookie
+type UngrabKeyCookie struct {
+	*cookie
+}
 
 // Write request to wire for UngrabKey
 func (c *Conn) UngrabKey(Key Keycode, GrabWindow Id, Modifiers uint16) UngrabKeyCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(ungrabKeyRequest(Key, GrabWindow, Modifiers), cookie)
-	return UngrabKeyCookie(cookie)
+	c.newRequest(c.ungrabKeyRequest(Key, GrabWindow, Modifiers), cookie)
+	return UngrabKeyCookie{cookie}
 }
 
 func (c *Conn) UngrabKeyChecked(Key Keycode, GrabWindow Id, Modifiers uint16) UngrabKeyCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(ungrabKeyRequest(Key, GrabWindow, Modifiers), cookie)
-	return UngrabKeyCookie(cookie)
+	c.newRequest(c.ungrabKeyRequest(Key, GrabWindow, Modifiers), cookie)
+	return UngrabKeyCookie{cookie}
+}
+
+func (cook UngrabKeyCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UngrabKey
-func ungrabKeyRequest(Key Keycode, GrabWindow Id, Modifiers uint16) []byte {
+func (c *Conn) ungrabKeyRequest(Key Keycode, GrabWindow Id, Modifiers uint16) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -7927,23 +8558,29 @@ func ungrabKeyRequest(Key Keycode, GrabWindow Id, Modifiers uint16) []byte {
 
 // Request AllowEvents
 // size: 8
-type AllowEventsCookie cookie
+type AllowEventsCookie struct {
+	*cookie
+}
 
 // Write request to wire for AllowEvents
 func (c *Conn) AllowEvents(Mode byte, Time Timestamp) AllowEventsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(allowEventsRequest(Mode, Time), cookie)
-	return AllowEventsCookie(cookie)
+	c.newRequest(c.allowEventsRequest(Mode, Time), cookie)
+	return AllowEventsCookie{cookie}
 }
 
 func (c *Conn) AllowEventsChecked(Mode byte, Time Timestamp) AllowEventsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(allowEventsRequest(Mode, Time), cookie)
-	return AllowEventsCookie(cookie)
+	c.newRequest(c.allowEventsRequest(Mode, Time), cookie)
+	return AllowEventsCookie{cookie}
+}
+
+func (cook AllowEventsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for AllowEvents
-func allowEventsRequest(Mode byte, Time Timestamp) []byte {
+func (c *Conn) allowEventsRequest(Mode byte, Time Timestamp) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -7965,23 +8602,29 @@ func allowEventsRequest(Mode byte, Time Timestamp) []byte {
 
 // Request GrabServer
 // size: 4
-type GrabServerCookie cookie
+type GrabServerCookie struct {
+	*cookie
+}
 
 // Write request to wire for GrabServer
 func (c *Conn) GrabServer() GrabServerCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(grabServerRequest(), cookie)
-	return GrabServerCookie(cookie)
+	c.newRequest(c.grabServerRequest(), cookie)
+	return GrabServerCookie{cookie}
 }
 
 func (c *Conn) GrabServerChecked() GrabServerCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(grabServerRequest(), cookie)
-	return GrabServerCookie(cookie)
+	c.newRequest(c.grabServerRequest(), cookie)
+	return GrabServerCookie{cookie}
+}
+
+func (cook GrabServerCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for GrabServer
-func grabServerRequest() []byte {
+func (c *Conn) grabServerRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -7989,28 +8632,38 @@ func grabServerRequest() []byte {
 	buf[b] = 36 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request UngrabServer
 // size: 4
-type UngrabServerCookie cookie
+type UngrabServerCookie struct {
+	*cookie
+}
 
 // Write request to wire for UngrabServer
 func (c *Conn) UngrabServer() UngrabServerCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(ungrabServerRequest(), cookie)
-	return UngrabServerCookie(cookie)
+	c.newRequest(c.ungrabServerRequest(), cookie)
+	return UngrabServerCookie{cookie}
 }
 
 func (c *Conn) UngrabServerChecked() UngrabServerCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(ungrabServerRequest(), cookie)
-	return UngrabServerCookie(cookie)
+	c.newRequest(c.ungrabServerRequest(), cookie)
+	return UngrabServerCookie{cookie}
+}
+
+func (cook UngrabServerCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UngrabServer
-func ungrabServerRequest() []byte {
+func (c *Conn) ungrabServerRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -8018,23 +8671,29 @@ func ungrabServerRequest() []byte {
 	buf[b] = 37 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request QueryPointer
 // size: 8
-type QueryPointerCookie cookie
+type QueryPointerCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryPointer(Window Id) QueryPointerCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryPointerRequest(Window), cookie)
-	return QueryPointerCookie(cookie)
+	c.newRequest(c.queryPointerRequest(Window), cookie)
+	return QueryPointerCookie{cookie}
 }
 
 func (c *Conn) QueryPointerUnchecked(Window Id) QueryPointerCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryPointerRequest(Window), cookie)
-	return QueryPointerCookie(cookie)
+	c.newRequest(c.queryPointerRequest(Window), cookie)
+	return QueryPointerCookie{cookie}
 }
 
 // Request reply for QueryPointer
@@ -8055,10 +8714,13 @@ type QueryPointerReply struct {
 
 // Waits and reads reply data from request QueryPointer
 func (cook QueryPointerCookie) Reply() (*QueryPointerReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryPointerReply(buf), nil
 }
 
@@ -8106,8 +8768,12 @@ func queryPointerReply(buf []byte) *QueryPointerReply {
 	return v
 }
 
+func (cook QueryPointerCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryPointer
-func queryPointerRequest(Window Id) []byte {
+func (c *Conn) queryPointerRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -8128,18 +8794,20 @@ func queryPointerRequest(Window Id) []byte {
 
 // Request GetMotionEvents
 // size: 16
-type GetMotionEventsCookie cookie
+type GetMotionEventsCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetMotionEvents(Window Id, Start Timestamp, Stop Timestamp) GetMotionEventsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getMotionEventsRequest(Window, Start, Stop), cookie)
-	return GetMotionEventsCookie(cookie)
+	c.newRequest(c.getMotionEventsRequest(Window, Start, Stop), cookie)
+	return GetMotionEventsCookie{cookie}
 }
 
 func (c *Conn) GetMotionEventsUnchecked(Window Id, Start Timestamp, Stop Timestamp) GetMotionEventsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getMotionEventsRequest(Window, Start, Stop), cookie)
-	return GetMotionEventsCookie(cookie)
+	c.newRequest(c.getMotionEventsRequest(Window, Start, Stop), cookie)
+	return GetMotionEventsCookie{cookie}
 }
 
 // Request reply for GetMotionEvents
@@ -8155,10 +8823,13 @@ type GetMotionEventsReply struct {
 
 // Waits and reads reply data from request GetMotionEvents
 func (cook GetMotionEventsCookie) Reply() (*GetMotionEventsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getMotionEventsReply(buf), nil
 }
 
@@ -8186,8 +8857,12 @@ func getMotionEventsReply(buf []byte) *GetMotionEventsReply {
 	return v
 }
 
+func (cook GetMotionEventsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetMotionEvents
-func getMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) []byte {
+func (c *Conn) getMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -8214,18 +8889,20 @@ func getMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) []byte {
 
 // Request TranslateCoordinates
 // size: 16
-type TranslateCoordinatesCookie cookie
+type TranslateCoordinatesCookie struct {
+	*cookie
+}
 
 func (c *Conn) TranslateCoordinates(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) TranslateCoordinatesCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(translateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY), cookie)
-	return TranslateCoordinatesCookie(cookie)
+	c.newRequest(c.translateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY), cookie)
+	return TranslateCoordinatesCookie{cookie}
 }
 
 func (c *Conn) TranslateCoordinatesUnchecked(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) TranslateCoordinatesCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(translateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY), cookie)
-	return TranslateCoordinatesCookie(cookie)
+	c.newRequest(c.translateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY), cookie)
+	return TranslateCoordinatesCookie{cookie}
 }
 
 // Request reply for TranslateCoordinates
@@ -8241,10 +8918,13 @@ type TranslateCoordinatesReply struct {
 
 // Waits and reads reply data from request TranslateCoordinates
 func (cook TranslateCoordinatesCookie) Reply() (*TranslateCoordinatesReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return translateCoordinatesReply(buf), nil
 }
 
@@ -8278,8 +8958,12 @@ func translateCoordinatesReply(buf []byte) *TranslateCoordinatesReply {
 	return v
 }
 
+func (cook TranslateCoordinatesCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for TranslateCoordinates
-func translateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) []byte {
+func (c *Conn) translateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -8309,23 +8993,29 @@ func translateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY in
 
 // Request WarpPointer
 // size: 24
-type WarpPointerCookie cookie
+type WarpPointerCookie struct {
+	*cookie
+}
 
 // Write request to wire for WarpPointer
 func (c *Conn) WarpPointer(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) WarpPointerCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(warpPointerRequest(SrcWindow, DstWindow, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY), cookie)
-	return WarpPointerCookie(cookie)
+	c.newRequest(c.warpPointerRequest(SrcWindow, DstWindow, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY), cookie)
+	return WarpPointerCookie{cookie}
 }
 
 func (c *Conn) WarpPointerChecked(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) WarpPointerCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(warpPointerRequest(SrcWindow, DstWindow, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY), cookie)
-	return WarpPointerCookie(cookie)
+	c.newRequest(c.warpPointerRequest(SrcWindow, DstWindow, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY), cookie)
+	return WarpPointerCookie{cookie}
+}
+
+func (cook WarpPointerCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for WarpPointer
-func warpPointerRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) []byte {
+func (c *Conn) warpPointerRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) []byte {
 	size := 24
 	b := 0
 	buf := make([]byte, size)
@@ -8367,23 +9057,29 @@ func warpPointerRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcW
 
 // Request SetInputFocus
 // size: 12
-type SetInputFocusCookie cookie
+type SetInputFocusCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetInputFocus
 func (c *Conn) SetInputFocus(RevertTo byte, Focus Id, Time Timestamp) SetInputFocusCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setInputFocusRequest(RevertTo, Focus, Time), cookie)
-	return SetInputFocusCookie(cookie)
+	c.newRequest(c.setInputFocusRequest(RevertTo, Focus, Time), cookie)
+	return SetInputFocusCookie{cookie}
 }
 
 func (c *Conn) SetInputFocusChecked(RevertTo byte, Focus Id, Time Timestamp) SetInputFocusCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setInputFocusRequest(RevertTo, Focus, Time), cookie)
-	return SetInputFocusCookie(cookie)
+	c.newRequest(c.setInputFocusRequest(RevertTo, Focus, Time), cookie)
+	return SetInputFocusCookie{cookie}
+}
+
+func (cook SetInputFocusCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetInputFocus
-func setInputFocusRequest(RevertTo byte, Focus Id, Time Timestamp) []byte {
+func (c *Conn) setInputFocusRequest(RevertTo byte, Focus Id, Time Timestamp) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -8408,18 +9104,20 @@ func setInputFocusRequest(RevertTo byte, Focus Id, Time Timestamp) []byte {
 
 // Request GetInputFocus
 // size: 4
-type GetInputFocusCookie cookie
+type GetInputFocusCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetInputFocus() GetInputFocusCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getInputFocusRequest(), cookie)
-	return GetInputFocusCookie(cookie)
+	c.newRequest(c.getInputFocusRequest(), cookie)
+	return GetInputFocusCookie{cookie}
 }
 
 func (c *Conn) GetInputFocusUnchecked() GetInputFocusCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getInputFocusRequest(), cookie)
-	return GetInputFocusCookie(cookie)
+	c.newRequest(c.getInputFocusRequest(), cookie)
+	return GetInputFocusCookie{cookie}
 }
 
 // Request reply for GetInputFocus
@@ -8433,10 +9131,13 @@ type GetInputFocusReply struct {
 
 // Waits and reads reply data from request GetInputFocus
 func (cook GetInputFocusCookie) Reply() (*GetInputFocusReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getInputFocusReply(buf), nil
 }
 
@@ -8460,8 +9161,12 @@ func getInputFocusReply(buf []byte) *GetInputFocusReply {
 	return v
 }
 
+func (cook GetInputFocusCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetInputFocus
-func getInputFocusRequest() []byte {
+func (c *Conn) getInputFocusRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -8469,23 +9174,29 @@ func getInputFocusRequest() []byte {
 	buf[b] = 43 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request QueryKeymap
 // size: 4
-type QueryKeymapCookie cookie
+type QueryKeymapCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryKeymap() QueryKeymapCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryKeymapRequest(), cookie)
-	return QueryKeymapCookie(cookie)
+	c.newRequest(c.queryKeymapRequest(), cookie)
+	return QueryKeymapCookie{cookie}
 }
 
 func (c *Conn) QueryKeymapUnchecked() QueryKeymapCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryKeymapRequest(), cookie)
-	return QueryKeymapCookie(cookie)
+	c.newRequest(c.queryKeymapRequest(), cookie)
+	return QueryKeymapCookie{cookie}
 }
 
 // Request reply for QueryKeymap
@@ -8499,10 +9210,13 @@ type QueryKeymapReply struct {
 
 // Waits and reads reply data from request QueryKeymap
 func (cook QueryKeymapCookie) Reply() (*QueryKeymapReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryKeymapReply(buf), nil
 }
 
@@ -8526,8 +9240,12 @@ func queryKeymapReply(buf []byte) *QueryKeymapReply {
 	return v
 }
 
+func (cook QueryKeymapCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryKeymap
-func queryKeymapRequest() []byte {
+func (c *Conn) queryKeymapRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -8535,28 +9253,38 @@ func queryKeymapRequest() []byte {
 	buf[b] = 44 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request OpenFont
 // size: pad((12 + pad((int(NameLen) * 1))))
-type OpenFontCookie cookie
+type OpenFontCookie struct {
+	*cookie
+}
 
 // Write request to wire for OpenFont
 func (c *Conn) OpenFont(Fid Id, NameLen uint16, Name string) OpenFontCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(openFontRequest(Fid, NameLen, Name), cookie)
-	return OpenFontCookie(cookie)
+	c.newRequest(c.openFontRequest(Fid, NameLen, Name), cookie)
+	return OpenFontCookie{cookie}
 }
 
 func (c *Conn) OpenFontChecked(Fid Id, NameLen uint16, Name string) OpenFontCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(openFontRequest(Fid, NameLen, Name), cookie)
-	return OpenFontCookie(cookie)
+	c.newRequest(c.openFontRequest(Fid, NameLen, Name), cookie)
+	return OpenFontCookie{cookie}
+}
+
+func (cook OpenFontCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for OpenFont
-func openFontRequest(Fid Id, NameLen uint16, Name string) []byte {
+func (c *Conn) openFontRequest(Fid Id, NameLen uint16, Name string) []byte {
 	size := pad((12 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -8585,23 +9313,29 @@ func openFontRequest(Fid Id, NameLen uint16, Name string) []byte {
 
 // Request CloseFont
 // size: 8
-type CloseFontCookie cookie
+type CloseFontCookie struct {
+	*cookie
+}
 
 // Write request to wire for CloseFont
 func (c *Conn) CloseFont(Font Id) CloseFontCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(closeFontRequest(Font), cookie)
-	return CloseFontCookie(cookie)
+	c.newRequest(c.closeFontRequest(Font), cookie)
+	return CloseFontCookie{cookie}
 }
 
 func (c *Conn) CloseFontChecked(Font Id) CloseFontCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(closeFontRequest(Font), cookie)
-	return CloseFontCookie(cookie)
+	c.newRequest(c.closeFontRequest(Font), cookie)
+	return CloseFontCookie{cookie}
+}
+
+func (cook CloseFontCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CloseFont
-func closeFontRequest(Font Id) []byte {
+func (c *Conn) closeFontRequest(Font Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -8622,18 +9356,20 @@ func closeFontRequest(Font Id) []byte {
 
 // Request QueryFont
 // size: 8
-type QueryFontCookie cookie
+type QueryFontCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryFont(Font Id) QueryFontCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryFontRequest(Font), cookie)
-	return QueryFontCookie(cookie)
+	c.newRequest(c.queryFontRequest(Font), cookie)
+	return QueryFontCookie{cookie}
 }
 
 func (c *Conn) QueryFontUnchecked(Font Id) QueryFontCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryFontRequest(Font), cookie)
-	return QueryFontCookie(cookie)
+	c.newRequest(c.queryFontRequest(Font), cookie)
+	return QueryFontCookie{cookie}
 }
 
 // Request reply for QueryFont
@@ -8663,10 +9399,13 @@ type QueryFontReply struct {
 
 // Waits and reads reply data from request QueryFont
 func (cook QueryFontCookie) Reply() (*QueryFontReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryFontReply(buf), nil
 }
 
@@ -8739,8 +9478,12 @@ func queryFontReply(buf []byte) *QueryFontReply {
 	return v
 }
 
+func (cook QueryFontCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryFont
-func queryFontRequest(Font Id) []byte {
+func (c *Conn) queryFontRequest(Font Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -8761,18 +9504,20 @@ func queryFontRequest(Font Id) []byte {
 
 // Request QueryTextExtents
 // size: pad((8 + pad((len(String) * 2))))
-type QueryTextExtentsCookie cookie
+type QueryTextExtentsCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryTextExtents(Font Id, String []Char2b, StringLen uint16) QueryTextExtentsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryTextExtentsRequest(Font, String, StringLen), cookie)
-	return QueryTextExtentsCookie(cookie)
+	c.newRequest(c.queryTextExtentsRequest(Font, String, StringLen), cookie)
+	return QueryTextExtentsCookie{cookie}
 }
 
 func (c *Conn) QueryTextExtentsUnchecked(Font Id, String []Char2b, StringLen uint16) QueryTextExtentsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryTextExtentsRequest(Font, String, StringLen), cookie)
-	return QueryTextExtentsCookie(cookie)
+	c.newRequest(c.queryTextExtentsRequest(Font, String, StringLen), cookie)
+	return QueryTextExtentsCookie{cookie}
 }
 
 // Request reply for QueryTextExtents
@@ -8792,10 +9537,13 @@ type QueryTextExtentsReply struct {
 
 // Waits and reads reply data from request QueryTextExtents
 func (cook QueryTextExtentsCookie) Reply() (*QueryTextExtentsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryTextExtentsReply(buf), nil
 }
 
@@ -8837,8 +9585,12 @@ func queryTextExtentsReply(buf []byte) *QueryTextExtentsReply {
 	return v
 }
 
+func (cook QueryTextExtentsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryTextExtents
-func queryTextExtentsRequest(Font Id, String []Char2b, StringLen uint16) []byte {
+func (c *Conn) queryTextExtentsRequest(Font Id, String []Char2b, StringLen uint16) []byte {
 	size := pad((8 + pad((len(String) * 2))))
 	b := 0
 	buf := make([]byte, size)
@@ -8864,18 +9616,20 @@ func queryTextExtentsRequest(Font Id, String []Char2b, StringLen uint16) []byte
 
 // Request ListFonts
 // size: pad((8 + pad((int(PatternLen) * 1))))
-type ListFontsCookie cookie
+type ListFontsCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListFonts(MaxNames uint16, PatternLen uint16, Pattern string) ListFontsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listFontsRequest(MaxNames, PatternLen, Pattern), cookie)
-	return ListFontsCookie(cookie)
+	c.newRequest(c.listFontsRequest(MaxNames, PatternLen, Pattern), cookie)
+	return ListFontsCookie{cookie}
 }
 
 func (c *Conn) ListFontsUnchecked(MaxNames uint16, PatternLen uint16, Pattern string) ListFontsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listFontsRequest(MaxNames, PatternLen, Pattern), cookie)
-	return ListFontsCookie(cookie)
+	c.newRequest(c.listFontsRequest(MaxNames, PatternLen, Pattern), cookie)
+	return ListFontsCookie{cookie}
 }
 
 // Request reply for ListFonts
@@ -8891,10 +9645,13 @@ type ListFontsReply struct {
 
 // Waits and reads reply data from request ListFonts
 func (cook ListFontsCookie) Reply() (*ListFontsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listFontsReply(buf), nil
 }
 
@@ -8922,8 +9679,12 @@ func listFontsReply(buf []byte) *ListFontsReply {
 	return v
 }
 
+func (cook ListFontsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListFonts
-func listFontsRequest(MaxNames uint16, PatternLen uint16, Pattern string) []byte {
+func (c *Conn) listFontsRequest(MaxNames uint16, PatternLen uint16, Pattern string) []byte {
 	size := pad((8 + pad((int(PatternLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -8950,18 +9711,20 @@ func listFontsRequest(MaxNames uint16, PatternLen uint16, Pattern string) []byte
 
 // Request ListFontsWithInfo
 // size: pad((8 + pad((int(PatternLen) * 1))))
-type ListFontsWithInfoCookie cookie
+type ListFontsWithInfoCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListFontsWithInfo(MaxNames uint16, PatternLen uint16, Pattern string) ListFontsWithInfoCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listFontsWithInfoRequest(MaxNames, PatternLen, Pattern), cookie)
-	return ListFontsWithInfoCookie(cookie)
+	c.newRequest(c.listFontsWithInfoRequest(MaxNames, PatternLen, Pattern), cookie)
+	return ListFontsWithInfoCookie{cookie}
 }
 
 func (c *Conn) ListFontsWithInfoUnchecked(MaxNames uint16, PatternLen uint16, Pattern string) ListFontsWithInfoCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listFontsWithInfoRequest(MaxNames, PatternLen, Pattern), cookie)
-	return ListFontsWithInfoCookie(cookie)
+	c.newRequest(c.listFontsWithInfoRequest(MaxNames, PatternLen, Pattern), cookie)
+	return ListFontsWithInfoCookie{cookie}
 }
 
 // Request reply for ListFontsWithInfo
@@ -8991,10 +9754,13 @@ type ListFontsWithInfoReply struct {
 
 // Waits and reads reply data from request ListFontsWithInfo
 func (cook ListFontsWithInfoCookie) Reply() (*ListFontsWithInfoReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listFontsWithInfoReply(buf), nil
 }
 
@@ -9072,8 +9838,12 @@ func listFontsWithInfoReply(buf []byte) *ListFontsWithInfoReply {
 	return v
 }
 
+func (cook ListFontsWithInfoCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListFontsWithInfo
-func listFontsWithInfoRequest(MaxNames uint16, PatternLen uint16, Pattern string) []byte {
+func (c *Conn) listFontsWithInfoRequest(MaxNames uint16, PatternLen uint16, Pattern string) []byte {
 	size := pad((8 + pad((int(PatternLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -9100,23 +9870,29 @@ func listFontsWithInfoRequest(MaxNames uint16, PatternLen uint16, Pattern string
 
 // Request SetFontPath
 // size: pad((8 + StrListSize(Font)))
-type SetFontPathCookie cookie
+type SetFontPathCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetFontPath
 func (c *Conn) SetFontPath(FontQty uint16, Font []Str) SetFontPathCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setFontPathRequest(FontQty, Font), cookie)
-	return SetFontPathCookie(cookie)
+	c.newRequest(c.setFontPathRequest(FontQty, Font), cookie)
+	return SetFontPathCookie{cookie}
 }
 
 func (c *Conn) SetFontPathChecked(FontQty uint16, Font []Str) SetFontPathCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setFontPathRequest(FontQty, Font), cookie)
-	return SetFontPathCookie(cookie)
+	c.newRequest(c.setFontPathRequest(FontQty, Font), cookie)
+	return SetFontPathCookie{cookie}
+}
+
+func (cook SetFontPathCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetFontPath
-func setFontPathRequest(FontQty uint16, Font []Str) []byte {
+func (c *Conn) setFontPathRequest(FontQty uint16, Font []Str) []byte {
 	size := pad((8 + StrListSize(Font)))
 	b := 0
 	buf := make([]byte, size)
@@ -9141,18 +9917,20 @@ func setFontPathRequest(FontQty uint16, Font []Str) []byte {
 
 // Request GetFontPath
 // size: 4
-type GetFontPathCookie cookie
+type GetFontPathCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetFontPath() GetFontPathCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getFontPathRequest(), cookie)
-	return GetFontPathCookie(cookie)
+	c.newRequest(c.getFontPathRequest(), cookie)
+	return GetFontPathCookie{cookie}
 }
 
 func (c *Conn) GetFontPathUnchecked() GetFontPathCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getFontPathRequest(), cookie)
-	return GetFontPathCookie(cookie)
+	c.newRequest(c.getFontPathRequest(), cookie)
+	return GetFontPathCookie{cookie}
 }
 
 // Request reply for GetFontPath
@@ -9168,10 +9946,13 @@ type GetFontPathReply struct {
 
 // Waits and reads reply data from request GetFontPath
 func (cook GetFontPathCookie) Reply() (*GetFontPathReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getFontPathReply(buf), nil
 }
 
@@ -9199,8 +9980,12 @@ func getFontPathReply(buf []byte) *GetFontPathReply {
 	return v
 }
 
+func (cook GetFontPathCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetFontPath
-func getFontPathRequest() []byte {
+func (c *Conn) getFontPathRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -9208,28 +9993,38 @@ func getFontPathRequest() []byte {
 	buf[b] = 52 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request CreatePixmap
 // size: 16
-type CreatePixmapCookie cookie
+type CreatePixmapCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreatePixmap
 func (c *Conn) CreatePixmap(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) CreatePixmapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createPixmapRequest(Depth, Pid, Drawable, Width, Height), cookie)
-	return CreatePixmapCookie(cookie)
+	c.newRequest(c.createPixmapRequest(Depth, Pid, Drawable, Width, Height), cookie)
+	return CreatePixmapCookie{cookie}
 }
 
 func (c *Conn) CreatePixmapChecked(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) CreatePixmapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createPixmapRequest(Depth, Pid, Drawable, Width, Height), cookie)
-	return CreatePixmapCookie(cookie)
+	c.newRequest(c.createPixmapRequest(Depth, Pid, Drawable, Width, Height), cookie)
+	return CreatePixmapCookie{cookie}
+}
+
+func (cook CreatePixmapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreatePixmap
-func createPixmapRequest(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) []byte {
+func (c *Conn) createPixmapRequest(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -9260,23 +10055,29 @@ func createPixmapRequest(Depth byte, Pid Id, Drawable Id, Width uint16, Height u
 
 // Request FreePixmap
 // size: 8
-type FreePixmapCookie cookie
+type FreePixmapCookie struct {
+	*cookie
+}
 
 // Write request to wire for FreePixmap
 func (c *Conn) FreePixmap(Pixmap Id) FreePixmapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(freePixmapRequest(Pixmap), cookie)
-	return FreePixmapCookie(cookie)
+	c.newRequest(c.freePixmapRequest(Pixmap), cookie)
+	return FreePixmapCookie{cookie}
 }
 
 func (c *Conn) FreePixmapChecked(Pixmap Id) FreePixmapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(freePixmapRequest(Pixmap), cookie)
-	return FreePixmapCookie(cookie)
+	c.newRequest(c.freePixmapRequest(Pixmap), cookie)
+	return FreePixmapCookie{cookie}
+}
+
+func (cook FreePixmapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FreePixmap
-func freePixmapRequest(Pixmap Id) []byte {
+func (c *Conn) freePixmapRequest(Pixmap Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -9297,23 +10098,29 @@ func freePixmapRequest(Pixmap Id) []byte {
 
 // Request CreateGC
 // size: pad((12 + (4 + pad((4 * popCount(int(ValueMask)))))))
-type CreateGCCookie cookie
+type CreateGCCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreateGC
 func (c *Conn) CreateGC(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) CreateGCCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createGCRequest(Cid, Drawable, ValueMask, ValueList), cookie)
-	return CreateGCCookie(cookie)
+	c.newRequest(c.createGCRequest(Cid, Drawable, ValueMask, ValueList), cookie)
+	return CreateGCCookie{cookie}
 }
 
 func (c *Conn) CreateGCChecked(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) CreateGCCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createGCRequest(Cid, Drawable, ValueMask, ValueList), cookie)
-	return CreateGCCookie(cookie)
+	c.newRequest(c.createGCRequest(Cid, Drawable, ValueMask, ValueList), cookie)
+	return CreateGCCookie{cookie}
+}
+
+func (cook CreateGCCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreateGC
-func createGCRequest(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) []byte {
+func (c *Conn) createGCRequest(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) []byte {
 	size := pad((12 + (4 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -9345,23 +10152,29 @@ func createGCRequest(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32)
 
 // Request ChangeGC
 // size: pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
-type ChangeGCCookie cookie
+type ChangeGCCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeGC
 func (c *Conn) ChangeGC(Gc Id, ValueMask uint32, ValueList []uint32) ChangeGCCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeGCRequest(Gc, ValueMask, ValueList), cookie)
-	return ChangeGCCookie(cookie)
+	c.newRequest(c.changeGCRequest(Gc, ValueMask, ValueList), cookie)
+	return ChangeGCCookie{cookie}
 }
 
 func (c *Conn) ChangeGCChecked(Gc Id, ValueMask uint32, ValueList []uint32) ChangeGCCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeGCRequest(Gc, ValueMask, ValueList), cookie)
-	return ChangeGCCookie(cookie)
+	c.newRequest(c.changeGCRequest(Gc, ValueMask, ValueList), cookie)
+	return ChangeGCCookie{cookie}
+}
+
+func (cook ChangeGCCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeGC
-func changeGCRequest(Gc Id, ValueMask uint32, ValueList []uint32) []byte {
+func (c *Conn) changeGCRequest(Gc Id, ValueMask uint32, ValueList []uint32) []byte {
 	size := pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -9390,23 +10203,29 @@ func changeGCRequest(Gc Id, ValueMask uint32, ValueList []uint32) []byte {
 
 // Request CopyGC
 // size: 16
-type CopyGCCookie cookie
+type CopyGCCookie struct {
+	*cookie
+}
 
 // Write request to wire for CopyGC
 func (c *Conn) CopyGC(SrcGc Id, DstGc Id, ValueMask uint32) CopyGCCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(copyGCRequest(SrcGc, DstGc, ValueMask), cookie)
-	return CopyGCCookie(cookie)
+	c.newRequest(c.copyGCRequest(SrcGc, DstGc, ValueMask), cookie)
+	return CopyGCCookie{cookie}
 }
 
 func (c *Conn) CopyGCChecked(SrcGc Id, DstGc Id, ValueMask uint32) CopyGCCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(copyGCRequest(SrcGc, DstGc, ValueMask), cookie)
-	return CopyGCCookie(cookie)
+	c.newRequest(c.copyGCRequest(SrcGc, DstGc, ValueMask), cookie)
+	return CopyGCCookie{cookie}
+}
+
+func (cook CopyGCCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CopyGC
-func copyGCRequest(SrcGc Id, DstGc Id, ValueMask uint32) []byte {
+func (c *Conn) copyGCRequest(SrcGc Id, DstGc Id, ValueMask uint32) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -9433,23 +10252,29 @@ func copyGCRequest(SrcGc Id, DstGc Id, ValueMask uint32) []byte {
 
 // Request SetDashes
 // size: pad((12 + pad((int(DashesLen) * 1))))
-type SetDashesCookie cookie
+type SetDashesCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetDashes
 func (c *Conn) SetDashes(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte) SetDashesCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setDashesRequest(Gc, DashOffset, DashesLen, Dashes), cookie)
-	return SetDashesCookie(cookie)
+	c.newRequest(c.setDashesRequest(Gc, DashOffset, DashesLen, Dashes), cookie)
+	return SetDashesCookie{cookie}
 }
 
 func (c *Conn) SetDashesChecked(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte) SetDashesCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setDashesRequest(Gc, DashOffset, DashesLen, Dashes), cookie)
-	return SetDashesCookie(cookie)
+	c.newRequest(c.setDashesRequest(Gc, DashOffset, DashesLen, Dashes), cookie)
+	return SetDashesCookie{cookie}
+}
+
+func (cook SetDashesCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetDashes
-func setDashesRequest(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte) []byte {
+func (c *Conn) setDashesRequest(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte) []byte {
 	size := pad((12 + pad((int(DashesLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -9479,23 +10304,29 @@ func setDashesRequest(Gc Id, DashOffset uint16, DashesLen uint16, Dashes []byte)
 
 // Request SetClipRectangles
 // size: pad((12 + pad((len(Rectangles) * 8))))
-type SetClipRectanglesCookie cookie
+type SetClipRectanglesCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetClipRectangles
 func (c *Conn) SetClipRectangles(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) SetClipRectanglesCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setClipRectanglesRequest(Ordering, Gc, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
-	return SetClipRectanglesCookie(cookie)
+	c.newRequest(c.setClipRectanglesRequest(Ordering, Gc, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
+	return SetClipRectanglesCookie{cookie}
 }
 
 func (c *Conn) SetClipRectanglesChecked(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) SetClipRectanglesCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setClipRectanglesRequest(Ordering, Gc, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
-	return SetClipRectanglesCookie(cookie)
+	c.newRequest(c.setClipRectanglesRequest(Ordering, Gc, ClipXOrigin, ClipYOrigin, Rectangles), cookie)
+	return SetClipRectanglesCookie{cookie}
+}
+
+func (cook SetClipRectanglesCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetClipRectangles
-func setClipRectanglesRequest(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) []byte {
+func (c *Conn) setClipRectanglesRequest(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) []byte {
 	size := pad((12 + pad((len(Rectangles) * 8))))
 	b := 0
 	buf := make([]byte, size)
@@ -9525,23 +10356,29 @@ func setClipRectanglesRequest(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrig
 
 // Request FreeGC
 // size: 8
-type FreeGCCookie cookie
+type FreeGCCookie struct {
+	*cookie
+}
 
 // Write request to wire for FreeGC
 func (c *Conn) FreeGC(Gc Id) FreeGCCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(freeGCRequest(Gc), cookie)
-	return FreeGCCookie(cookie)
+	c.newRequest(c.freeGCRequest(Gc), cookie)
+	return FreeGCCookie{cookie}
 }
 
 func (c *Conn) FreeGCChecked(Gc Id) FreeGCCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(freeGCRequest(Gc), cookie)
-	return FreeGCCookie(cookie)
+	c.newRequest(c.freeGCRequest(Gc), cookie)
+	return FreeGCCookie{cookie}
+}
+
+func (cook FreeGCCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FreeGC
-func freeGCRequest(Gc Id) []byte {
+func (c *Conn) freeGCRequest(Gc Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -9562,23 +10399,29 @@ func freeGCRequest(Gc Id) []byte {
 
 // Request ClearArea
 // size: 16
-type ClearAreaCookie cookie
+type ClearAreaCookie struct {
+	*cookie
+}
 
 // Write request to wire for ClearArea
 func (c *Conn) ClearArea(Exposures bool, Window Id, X int16, Y int16, Width uint16, Height uint16) ClearAreaCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(clearAreaRequest(Exposures, Window, X, Y, Width, Height), cookie)
-	return ClearAreaCookie(cookie)
+	c.newRequest(c.clearAreaRequest(Exposures, Window, X, Y, Width, Height), cookie)
+	return ClearAreaCookie{cookie}
 }
 
 func (c *Conn) ClearAreaChecked(Exposures bool, Window Id, X int16, Y int16, Width uint16, Height uint16) ClearAreaCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(clearAreaRequest(Exposures, Window, X, Y, Width, Height), cookie)
-	return ClearAreaCookie(cookie)
+	c.newRequest(c.clearAreaRequest(Exposures, Window, X, Y, Width, Height), cookie)
+	return ClearAreaCookie{cookie}
+}
+
+func (cook ClearAreaCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ClearArea
-func clearAreaRequest(Exposures bool, Window Id, X int16, Y int16, Width uint16, Height uint16) []byte {
+func (c *Conn) clearAreaRequest(Exposures bool, Window Id, X int16, Y int16, Width uint16, Height uint16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -9616,23 +10459,29 @@ func clearAreaRequest(Exposures bool, Window Id, X int16, Y int16, Width uint16,
 
 // Request CopyArea
 // size: 28
-type CopyAreaCookie cookie
+type CopyAreaCookie struct {
+	*cookie
+}
 
 // Write request to wire for CopyArea
 func (c *Conn) CopyArea(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) CopyAreaCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(copyAreaRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height), cookie)
-	return CopyAreaCookie(cookie)
+	c.newRequest(c.copyAreaRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height), cookie)
+	return CopyAreaCookie{cookie}
 }
 
 func (c *Conn) CopyAreaChecked(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) CopyAreaCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(copyAreaRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height), cookie)
-	return CopyAreaCookie(cookie)
+	c.newRequest(c.copyAreaRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height), cookie)
+	return CopyAreaCookie{cookie}
+}
+
+func (cook CopyAreaCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CopyArea
-func copyAreaRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) []byte {
+func (c *Conn) copyAreaRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) []byte {
 	size := 28
 	b := 0
 	buf := make([]byte, size)
@@ -9677,23 +10526,29 @@ func copyAreaRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int
 
 // Request CopyPlane
 // size: 32
-type CopyPlaneCookie cookie
+type CopyPlaneCookie struct {
+	*cookie
+}
 
 // Write request to wire for CopyPlane
 func (c *Conn) CopyPlane(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) CopyPlaneCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(copyPlaneRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height, BitPlane), cookie)
-	return CopyPlaneCookie(cookie)
+	c.newRequest(c.copyPlaneRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height, BitPlane), cookie)
+	return CopyPlaneCookie{cookie}
 }
 
 func (c *Conn) CopyPlaneChecked(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) CopyPlaneCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(copyPlaneRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height, BitPlane), cookie)
-	return CopyPlaneCookie(cookie)
+	c.newRequest(c.copyPlaneRequest(SrcDrawable, DstDrawable, Gc, SrcX, SrcY, DstX, DstY, Width, Height, BitPlane), cookie)
+	return CopyPlaneCookie{cookie}
+}
+
+func (cook CopyPlaneCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CopyPlane
-func copyPlaneRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) []byte {
+func (c *Conn) copyPlaneRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) []byte {
 	size := 32
 	b := 0
 	buf := make([]byte, size)
@@ -9741,23 +10596,29 @@ func copyPlaneRequest(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY in
 
 // Request PolyPoint
 // size: pad((12 + pad((len(Points) * 4))))
-type PolyPointCookie cookie
+type PolyPointCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyPoint
 func (c *Conn) PolyPoint(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) PolyPointCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyPointRequest(CoordinateMode, Drawable, Gc, Points), cookie)
-	return PolyPointCookie(cookie)
+	c.newRequest(c.polyPointRequest(CoordinateMode, Drawable, Gc, Points), cookie)
+	return PolyPointCookie{cookie}
 }
 
 func (c *Conn) PolyPointChecked(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) PolyPointCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyPointRequest(CoordinateMode, Drawable, Gc, Points), cookie)
-	return PolyPointCookie(cookie)
+	c.newRequest(c.polyPointRequest(CoordinateMode, Drawable, Gc, Points), cookie)
+	return PolyPointCookie{cookie}
+}
+
+func (cook PolyPointCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyPoint
-func polyPointRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) []byte {
+func (c *Conn) polyPointRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) []byte {
 	size := pad((12 + pad((len(Points) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -9784,23 +10645,29 @@ func polyPointRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) [
 
 // Request PolyLine
 // size: pad((12 + pad((len(Points) * 4))))
-type PolyLineCookie cookie
+type PolyLineCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyLine
 func (c *Conn) PolyLine(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) PolyLineCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyLineRequest(CoordinateMode, Drawable, Gc, Points), cookie)
-	return PolyLineCookie(cookie)
+	c.newRequest(c.polyLineRequest(CoordinateMode, Drawable, Gc, Points), cookie)
+	return PolyLineCookie{cookie}
 }
 
 func (c *Conn) PolyLineChecked(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) PolyLineCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyLineRequest(CoordinateMode, Drawable, Gc, Points), cookie)
-	return PolyLineCookie(cookie)
+	c.newRequest(c.polyLineRequest(CoordinateMode, Drawable, Gc, Points), cookie)
+	return PolyLineCookie{cookie}
+}
+
+func (cook PolyLineCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyLine
-func polyLineRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) []byte {
+func (c *Conn) polyLineRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) []byte {
 	size := pad((12 + pad((len(Points) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -9827,23 +10694,29 @@ func polyLineRequest(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) []
 
 // Request PolySegment
 // size: pad((12 + pad((len(Segments) * 8))))
-type PolySegmentCookie cookie
+type PolySegmentCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolySegment
 func (c *Conn) PolySegment(Drawable Id, Gc Id, Segments []Segment) PolySegmentCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polySegmentRequest(Drawable, Gc, Segments), cookie)
-	return PolySegmentCookie(cookie)
+	c.newRequest(c.polySegmentRequest(Drawable, Gc, Segments), cookie)
+	return PolySegmentCookie{cookie}
 }
 
 func (c *Conn) PolySegmentChecked(Drawable Id, Gc Id, Segments []Segment) PolySegmentCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polySegmentRequest(Drawable, Gc, Segments), cookie)
-	return PolySegmentCookie(cookie)
+	c.newRequest(c.polySegmentRequest(Drawable, Gc, Segments), cookie)
+	return PolySegmentCookie{cookie}
+}
+
+func (cook PolySegmentCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolySegment
-func polySegmentRequest(Drawable Id, Gc Id, Segments []Segment) []byte {
+func (c *Conn) polySegmentRequest(Drawable Id, Gc Id, Segments []Segment) []byte {
 	size := pad((12 + pad((len(Segments) * 8))))
 	b := 0
 	buf := make([]byte, size)
@@ -9869,23 +10742,29 @@ func polySegmentRequest(Drawable Id, Gc Id, Segments []Segment) []byte {
 
 // Request PolyRectangle
 // size: pad((12 + pad((len(Rectangles) * 8))))
-type PolyRectangleCookie cookie
+type PolyRectangleCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyRectangle
 func (c *Conn) PolyRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) PolyRectangleCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyRectangleRequest(Drawable, Gc, Rectangles), cookie)
-	return PolyRectangleCookie(cookie)
+	c.newRequest(c.polyRectangleRequest(Drawable, Gc, Rectangles), cookie)
+	return PolyRectangleCookie{cookie}
 }
 
 func (c *Conn) PolyRectangleChecked(Drawable Id, Gc Id, Rectangles []Rectangle) PolyRectangleCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyRectangleRequest(Drawable, Gc, Rectangles), cookie)
-	return PolyRectangleCookie(cookie)
+	c.newRequest(c.polyRectangleRequest(Drawable, Gc, Rectangles), cookie)
+	return PolyRectangleCookie{cookie}
+}
+
+func (cook PolyRectangleCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyRectangle
-func polyRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte {
+func (c *Conn) polyRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte {
 	size := pad((12 + pad((len(Rectangles) * 8))))
 	b := 0
 	buf := make([]byte, size)
@@ -9911,23 +10790,29 @@ func polyRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte {
 
 // Request PolyArc
 // size: pad((12 + pad((len(Arcs) * 12))))
-type PolyArcCookie cookie
+type PolyArcCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyArc
 func (c *Conn) PolyArc(Drawable Id, Gc Id, Arcs []Arc) PolyArcCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyArcRequest(Drawable, Gc, Arcs), cookie)
-	return PolyArcCookie(cookie)
+	c.newRequest(c.polyArcRequest(Drawable, Gc, Arcs), cookie)
+	return PolyArcCookie{cookie}
 }
 
 func (c *Conn) PolyArcChecked(Drawable Id, Gc Id, Arcs []Arc) PolyArcCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyArcRequest(Drawable, Gc, Arcs), cookie)
-	return PolyArcCookie(cookie)
+	c.newRequest(c.polyArcRequest(Drawable, Gc, Arcs), cookie)
+	return PolyArcCookie{cookie}
+}
+
+func (cook PolyArcCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyArc
-func polyArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
+func (c *Conn) polyArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
 	size := pad((12 + pad((len(Arcs) * 12))))
 	b := 0
 	buf := make([]byte, size)
@@ -9953,23 +10838,29 @@ func polyArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
 
 // Request FillPoly
 // size: pad((16 + pad((len(Points) * 4))))
-type FillPolyCookie cookie
+type FillPolyCookie struct {
+	*cookie
+}
 
 // Write request to wire for FillPoly
 func (c *Conn) FillPoly(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) FillPolyCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(fillPolyRequest(Drawable, Gc, Shape, CoordinateMode, Points), cookie)
-	return FillPolyCookie(cookie)
+	c.newRequest(c.fillPolyRequest(Drawable, Gc, Shape, CoordinateMode, Points), cookie)
+	return FillPolyCookie{cookie}
 }
 
 func (c *Conn) FillPolyChecked(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) FillPolyCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(fillPolyRequest(Drawable, Gc, Shape, CoordinateMode, Points), cookie)
-	return FillPolyCookie(cookie)
+	c.newRequest(c.fillPolyRequest(Drawable, Gc, Shape, CoordinateMode, Points), cookie)
+	return FillPolyCookie{cookie}
+}
+
+func (cook FillPolyCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FillPoly
-func fillPolyRequest(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) []byte {
+func (c *Conn) fillPolyRequest(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) []byte {
 	size := pad((16 + pad((len(Points) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -10003,23 +10894,29 @@ func fillPolyRequest(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points
 
 // Request PolyFillRectangle
 // size: pad((12 + pad((len(Rectangles) * 8))))
-type PolyFillRectangleCookie cookie
+type PolyFillRectangleCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyFillRectangle
 func (c *Conn) PolyFillRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) PolyFillRectangleCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyFillRectangleRequest(Drawable, Gc, Rectangles), cookie)
-	return PolyFillRectangleCookie(cookie)
+	c.newRequest(c.polyFillRectangleRequest(Drawable, Gc, Rectangles), cookie)
+	return PolyFillRectangleCookie{cookie}
 }
 
 func (c *Conn) PolyFillRectangleChecked(Drawable Id, Gc Id, Rectangles []Rectangle) PolyFillRectangleCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyFillRectangleRequest(Drawable, Gc, Rectangles), cookie)
-	return PolyFillRectangleCookie(cookie)
+	c.newRequest(c.polyFillRectangleRequest(Drawable, Gc, Rectangles), cookie)
+	return PolyFillRectangleCookie{cookie}
+}
+
+func (cook PolyFillRectangleCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyFillRectangle
-func polyFillRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte {
+func (c *Conn) polyFillRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte {
 	size := pad((12 + pad((len(Rectangles) * 8))))
 	b := 0
 	buf := make([]byte, size)
@@ -10045,23 +10942,29 @@ func polyFillRectangleRequest(Drawable Id, Gc Id, Rectangles []Rectangle) []byte
 
 // Request PolyFillArc
 // size: pad((12 + pad((len(Arcs) * 12))))
-type PolyFillArcCookie cookie
+type PolyFillArcCookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyFillArc
 func (c *Conn) PolyFillArc(Drawable Id, Gc Id, Arcs []Arc) PolyFillArcCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyFillArcRequest(Drawable, Gc, Arcs), cookie)
-	return PolyFillArcCookie(cookie)
+	c.newRequest(c.polyFillArcRequest(Drawable, Gc, Arcs), cookie)
+	return PolyFillArcCookie{cookie}
 }
 
 func (c *Conn) PolyFillArcChecked(Drawable Id, Gc Id, Arcs []Arc) PolyFillArcCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyFillArcRequest(Drawable, Gc, Arcs), cookie)
-	return PolyFillArcCookie(cookie)
+	c.newRequest(c.polyFillArcRequest(Drawable, Gc, Arcs), cookie)
+	return PolyFillArcCookie{cookie}
+}
+
+func (cook PolyFillArcCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyFillArc
-func polyFillArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
+func (c *Conn) polyFillArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
 	size := pad((12 + pad((len(Arcs) * 12))))
 	b := 0
 	buf := make([]byte, size)
@@ -10087,23 +10990,29 @@ func polyFillArcRequest(Drawable Id, Gc Id, Arcs []Arc) []byte {
 
 // Request PutImage
 // size: pad((24 + pad((len(Data) * 1))))
-type PutImageCookie cookie
+type PutImageCookie struct {
+	*cookie
+}
 
 // Write request to wire for PutImage
 func (c *Conn) PutImage(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) PutImageCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(putImageRequest(Format, Drawable, Gc, Width, Height, DstX, DstY, LeftPad, Depth, Data), cookie)
-	return PutImageCookie(cookie)
+	c.newRequest(c.putImageRequest(Format, Drawable, Gc, Width, Height, DstX, DstY, LeftPad, Depth, Data), cookie)
+	return PutImageCookie{cookie}
 }
 
 func (c *Conn) PutImageChecked(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) PutImageCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(putImageRequest(Format, Drawable, Gc, Width, Height, DstX, DstY, LeftPad, Depth, Data), cookie)
-	return PutImageCookie(cookie)
+	c.newRequest(c.putImageRequest(Format, Drawable, Gc, Width, Height, DstX, DstY, LeftPad, Depth, Data), cookie)
+	return PutImageCookie{cookie}
+}
+
+func (cook PutImageCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PutImage
-func putImageRequest(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) []byte {
+func (c *Conn) putImageRequest(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) []byte {
 	size := pad((24 + pad((len(Data) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -10151,18 +11060,20 @@ func putImageRequest(Format byte, Drawable Id, Gc Id, Width uint16, Height uint1
 
 // Request GetImage
 // size: 20
-type GetImageCookie cookie
+type GetImageCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetImage(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) GetImageCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask), cookie)
-	return GetImageCookie(cookie)
+	c.newRequest(c.getImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask), cookie)
+	return GetImageCookie{cookie}
 }
 
 func (c *Conn) GetImageUnchecked(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) GetImageCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask), cookie)
-	return GetImageCookie(cookie)
+	c.newRequest(c.getImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask), cookie)
+	return GetImageCookie{cookie}
 }
 
 // Request reply for GetImage
@@ -10178,10 +11089,13 @@ type GetImageReply struct {
 
 // Waits and reads reply data from request GetImage
 func (cook GetImageCookie) Reply() (*GetImageReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getImageReply(buf), nil
 }
 
@@ -10211,8 +11125,12 @@ func getImageReply(buf []byte) *GetImageReply {
 	return v
 }
 
+func (cook GetImageCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetImage
-func getImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) []byte {
+func (c *Conn) getImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) []byte {
 	size := 20
 	b := 0
 	buf := make([]byte, size)
@@ -10249,23 +11167,29 @@ func getImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, H
 
 // Request PolyText8
 // size: pad((16 + pad((len(Items) * 1))))
-type PolyText8Cookie cookie
+type PolyText8Cookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyText8
 func (c *Conn) PolyText8(Drawable Id, Gc Id, X int16, Y int16, Items []byte) PolyText8Cookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyText8Request(Drawable, Gc, X, Y, Items), cookie)
-	return PolyText8Cookie(cookie)
+	c.newRequest(c.polyText8Request(Drawable, Gc, X, Y, Items), cookie)
+	return PolyText8Cookie{cookie}
 }
 
 func (c *Conn) PolyText8Checked(Drawable Id, Gc Id, X int16, Y int16, Items []byte) PolyText8Cookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyText8Request(Drawable, Gc, X, Y, Items), cookie)
-	return PolyText8Cookie(cookie)
+	c.newRequest(c.polyText8Request(Drawable, Gc, X, Y, Items), cookie)
+	return PolyText8Cookie{cookie}
+}
+
+func (cook PolyText8Cookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyText8
-func polyText8Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byte {
+func (c *Conn) polyText8Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byte {
 	size := pad((16 + pad((len(Items) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -10298,23 +11222,29 @@ func polyText8Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byte
 
 // Request PolyText16
 // size: pad((16 + pad((len(Items) * 1))))
-type PolyText16Cookie cookie
+type PolyText16Cookie struct {
+	*cookie
+}
 
 // Write request to wire for PolyText16
 func (c *Conn) PolyText16(Drawable Id, Gc Id, X int16, Y int16, Items []byte) PolyText16Cookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(polyText16Request(Drawable, Gc, X, Y, Items), cookie)
-	return PolyText16Cookie(cookie)
+	c.newRequest(c.polyText16Request(Drawable, Gc, X, Y, Items), cookie)
+	return PolyText16Cookie{cookie}
 }
 
 func (c *Conn) PolyText16Checked(Drawable Id, Gc Id, X int16, Y int16, Items []byte) PolyText16Cookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(polyText16Request(Drawable, Gc, X, Y, Items), cookie)
-	return PolyText16Cookie(cookie)
+	c.newRequest(c.polyText16Request(Drawable, Gc, X, Y, Items), cookie)
+	return PolyText16Cookie{cookie}
+}
+
+func (cook PolyText16Cookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for PolyText16
-func polyText16Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byte {
+func (c *Conn) polyText16Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byte {
 	size := pad((16 + pad((len(Items) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -10347,23 +11277,29 @@ func polyText16Request(Drawable Id, Gc Id, X int16, Y int16, Items []byte) []byt
 
 // Request ImageText8
 // size: pad((16 + pad((int(StringLen) * 1))))
-type ImageText8Cookie cookie
+type ImageText8Cookie struct {
+	*cookie
+}
 
 // Write request to wire for ImageText8
 func (c *Conn) ImageText8(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String string) ImageText8Cookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(imageText8Request(StringLen, Drawable, Gc, X, Y, String), cookie)
-	return ImageText8Cookie(cookie)
+	c.newRequest(c.imageText8Request(StringLen, Drawable, Gc, X, Y, String), cookie)
+	return ImageText8Cookie{cookie}
 }
 
 func (c *Conn) ImageText8Checked(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String string) ImageText8Cookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(imageText8Request(StringLen, Drawable, Gc, X, Y, String), cookie)
-	return ImageText8Cookie(cookie)
+	c.newRequest(c.imageText8Request(StringLen, Drawable, Gc, X, Y, String), cookie)
+	return ImageText8Cookie{cookie}
+}
+
+func (cook ImageText8Cookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ImageText8
-func imageText8Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String string) []byte {
+func (c *Conn) imageText8Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String string) []byte {
 	size := pad((16 + pad((int(StringLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -10397,23 +11333,29 @@ func imageText8Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, Str
 
 // Request ImageText16
 // size: pad((16 + pad((int(StringLen) * 2))))
-type ImageText16Cookie cookie
+type ImageText16Cookie struct {
+	*cookie
+}
 
 // Write request to wire for ImageText16
 func (c *Conn) ImageText16(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String []Char2b) ImageText16Cookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(imageText16Request(StringLen, Drawable, Gc, X, Y, String), cookie)
-	return ImageText16Cookie(cookie)
+	c.newRequest(c.imageText16Request(StringLen, Drawable, Gc, X, Y, String), cookie)
+	return ImageText16Cookie{cookie}
 }
 
 func (c *Conn) ImageText16Checked(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String []Char2b) ImageText16Cookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(imageText16Request(StringLen, Drawable, Gc, X, Y, String), cookie)
-	return ImageText16Cookie(cookie)
+	c.newRequest(c.imageText16Request(StringLen, Drawable, Gc, X, Y, String), cookie)
+	return ImageText16Cookie{cookie}
+}
+
+func (cook ImageText16Cookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ImageText16
-func imageText16Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String []Char2b) []byte {
+func (c *Conn) imageText16Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, String []Char2b) []byte {
 	size := pad((16 + pad((int(StringLen) * 2))))
 	b := 0
 	buf := make([]byte, size)
@@ -10446,23 +11388,29 @@ func imageText16Request(StringLen byte, Drawable Id, Gc Id, X int16, Y int16, St
 
 // Request CreateColormap
 // size: 16
-type CreateColormapCookie cookie
+type CreateColormapCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreateColormap
 func (c *Conn) CreateColormap(Alloc byte, Mid Id, Window Id, Visual Visualid) CreateColormapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createColormapRequest(Alloc, Mid, Window, Visual), cookie)
-	return CreateColormapCookie(cookie)
+	c.newRequest(c.createColormapRequest(Alloc, Mid, Window, Visual), cookie)
+	return CreateColormapCookie{cookie}
 }
 
 func (c *Conn) CreateColormapChecked(Alloc byte, Mid Id, Window Id, Visual Visualid) CreateColormapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createColormapRequest(Alloc, Mid, Window, Visual), cookie)
-	return CreateColormapCookie(cookie)
+	c.newRequest(c.createColormapRequest(Alloc, Mid, Window, Visual), cookie)
+	return CreateColormapCookie{cookie}
+}
+
+func (cook CreateColormapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreateColormap
-func createColormapRequest(Alloc byte, Mid Id, Window Id, Visual Visualid) []byte {
+func (c *Conn) createColormapRequest(Alloc byte, Mid Id, Window Id, Visual Visualid) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -10490,23 +11438,29 @@ func createColormapRequest(Alloc byte, Mid Id, Window Id, Visual Visualid) []byt
 
 // Request FreeColormap
 // size: 8
-type FreeColormapCookie cookie
+type FreeColormapCookie struct {
+	*cookie
+}
 
 // Write request to wire for FreeColormap
 func (c *Conn) FreeColormap(Cmap Id) FreeColormapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(freeColormapRequest(Cmap), cookie)
-	return FreeColormapCookie(cookie)
+	c.newRequest(c.freeColormapRequest(Cmap), cookie)
+	return FreeColormapCookie{cookie}
 }
 
 func (c *Conn) FreeColormapChecked(Cmap Id) FreeColormapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(freeColormapRequest(Cmap), cookie)
-	return FreeColormapCookie(cookie)
+	c.newRequest(c.freeColormapRequest(Cmap), cookie)
+	return FreeColormapCookie{cookie}
+}
+
+func (cook FreeColormapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FreeColormap
-func freeColormapRequest(Cmap Id) []byte {
+func (c *Conn) freeColormapRequest(Cmap Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -10527,23 +11481,29 @@ func freeColormapRequest(Cmap Id) []byte {
 
 // Request CopyColormapAndFree
 // size: 12
-type CopyColormapAndFreeCookie cookie
+type CopyColormapAndFreeCookie struct {
+	*cookie
+}
 
 // Write request to wire for CopyColormapAndFree
 func (c *Conn) CopyColormapAndFree(Mid Id, SrcCmap Id) CopyColormapAndFreeCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(copyColormapAndFreeRequest(Mid, SrcCmap), cookie)
-	return CopyColormapAndFreeCookie(cookie)
+	c.newRequest(c.copyColormapAndFreeRequest(Mid, SrcCmap), cookie)
+	return CopyColormapAndFreeCookie{cookie}
 }
 
 func (c *Conn) CopyColormapAndFreeChecked(Mid Id, SrcCmap Id) CopyColormapAndFreeCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(copyColormapAndFreeRequest(Mid, SrcCmap), cookie)
-	return CopyColormapAndFreeCookie(cookie)
+	c.newRequest(c.copyColormapAndFreeRequest(Mid, SrcCmap), cookie)
+	return CopyColormapAndFreeCookie{cookie}
+}
+
+func (cook CopyColormapAndFreeCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CopyColormapAndFree
-func copyColormapAndFreeRequest(Mid Id, SrcCmap Id) []byte {
+func (c *Conn) copyColormapAndFreeRequest(Mid Id, SrcCmap Id) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -10567,23 +11527,29 @@ func copyColormapAndFreeRequest(Mid Id, SrcCmap Id) []byte {
 
 // Request InstallColormap
 // size: 8
-type InstallColormapCookie cookie
+type InstallColormapCookie struct {
+	*cookie
+}
 
 // Write request to wire for InstallColormap
 func (c *Conn) InstallColormap(Cmap Id) InstallColormapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(installColormapRequest(Cmap), cookie)
-	return InstallColormapCookie(cookie)
+	c.newRequest(c.installColormapRequest(Cmap), cookie)
+	return InstallColormapCookie{cookie}
 }
 
 func (c *Conn) InstallColormapChecked(Cmap Id) InstallColormapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(installColormapRequest(Cmap), cookie)
-	return InstallColormapCookie(cookie)
+	c.newRequest(c.installColormapRequest(Cmap), cookie)
+	return InstallColormapCookie{cookie}
+}
+
+func (cook InstallColormapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for InstallColormap
-func installColormapRequest(Cmap Id) []byte {
+func (c *Conn) installColormapRequest(Cmap Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -10604,23 +11570,29 @@ func installColormapRequest(Cmap Id) []byte {
 
 // Request UninstallColormap
 // size: 8
-type UninstallColormapCookie cookie
+type UninstallColormapCookie struct {
+	*cookie
+}
 
 // Write request to wire for UninstallColormap
 func (c *Conn) UninstallColormap(Cmap Id) UninstallColormapCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(uninstallColormapRequest(Cmap), cookie)
-	return UninstallColormapCookie(cookie)
+	c.newRequest(c.uninstallColormapRequest(Cmap), cookie)
+	return UninstallColormapCookie{cookie}
 }
 
 func (c *Conn) UninstallColormapChecked(Cmap Id) UninstallColormapCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(uninstallColormapRequest(Cmap), cookie)
-	return UninstallColormapCookie(cookie)
+	c.newRequest(c.uninstallColormapRequest(Cmap), cookie)
+	return UninstallColormapCookie{cookie}
+}
+
+func (cook UninstallColormapCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for UninstallColormap
-func uninstallColormapRequest(Cmap Id) []byte {
+func (c *Conn) uninstallColormapRequest(Cmap Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -10641,18 +11613,20 @@ func uninstallColormapRequest(Cmap Id) []byte {
 
 // Request ListInstalledColormaps
 // size: 8
-type ListInstalledColormapsCookie cookie
+type ListInstalledColormapsCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListInstalledColormaps(Window Id) ListInstalledColormapsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listInstalledColormapsRequest(Window), cookie)
-	return ListInstalledColormapsCookie(cookie)
+	c.newRequest(c.listInstalledColormapsRequest(Window), cookie)
+	return ListInstalledColormapsCookie{cookie}
 }
 
 func (c *Conn) ListInstalledColormapsUnchecked(Window Id) ListInstalledColormapsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listInstalledColormapsRequest(Window), cookie)
-	return ListInstalledColormapsCookie(cookie)
+	c.newRequest(c.listInstalledColormapsRequest(Window), cookie)
+	return ListInstalledColormapsCookie{cookie}
 }
 
 // Request reply for ListInstalledColormaps
@@ -10668,10 +11642,13 @@ type ListInstalledColormapsReply struct {
 
 // Waits and reads reply data from request ListInstalledColormaps
 func (cook ListInstalledColormapsCookie) Reply() (*ListInstalledColormapsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listInstalledColormapsReply(buf), nil
 }
 
@@ -10703,8 +11680,12 @@ func listInstalledColormapsReply(buf []byte) *ListInstalledColormapsReply {
 	return v
 }
 
+func (cook ListInstalledColormapsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListInstalledColormaps
-func listInstalledColormapsRequest(Window Id) []byte {
+func (c *Conn) listInstalledColormapsRequest(Window Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -10725,18 +11706,20 @@ func listInstalledColormapsRequest(Window Id) []byte {
 
 // Request AllocColor
 // size: 16
-type AllocColorCookie cookie
+type AllocColorCookie struct {
+	*cookie
+}
 
 func (c *Conn) AllocColor(Cmap Id, Red uint16, Green uint16, Blue uint16) AllocColorCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(allocColorRequest(Cmap, Red, Green, Blue), cookie)
-	return AllocColorCookie(cookie)
+	c.newRequest(c.allocColorRequest(Cmap, Red, Green, Blue), cookie)
+	return AllocColorCookie{cookie}
 }
 
 func (c *Conn) AllocColorUnchecked(Cmap Id, Red uint16, Green uint16, Blue uint16) AllocColorCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(allocColorRequest(Cmap, Red, Green, Blue), cookie)
-	return AllocColorCookie(cookie)
+	c.newRequest(c.allocColorRequest(Cmap, Red, Green, Blue), cookie)
+	return AllocColorCookie{cookie}
 }
 
 // Request reply for AllocColor
@@ -10754,10 +11737,13 @@ type AllocColorReply struct {
 
 // Waits and reads reply data from request AllocColor
 func (cook AllocColorCookie) Reply() (*AllocColorReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return allocColorReply(buf), nil
 }
 
@@ -10791,8 +11777,12 @@ func allocColorReply(buf []byte) *AllocColorReply {
 	return v
 }
 
+func (cook AllocColorCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for AllocColor
-func allocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) []byte {
+func (c *Conn) allocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -10824,18 +11814,20 @@ func allocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) []byte {
 
 // Request AllocNamedColor
 // size: pad((12 + pad((int(NameLen) * 1))))
-type AllocNamedColorCookie cookie
+type AllocNamedColorCookie struct {
+	*cookie
+}
 
 func (c *Conn) AllocNamedColor(Cmap Id, NameLen uint16, Name string) AllocNamedColorCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(allocNamedColorRequest(Cmap, NameLen, Name), cookie)
-	return AllocNamedColorCookie(cookie)
+	c.newRequest(c.allocNamedColorRequest(Cmap, NameLen, Name), cookie)
+	return AllocNamedColorCookie{cookie}
 }
 
 func (c *Conn) AllocNamedColorUnchecked(Cmap Id, NameLen uint16, Name string) AllocNamedColorCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(allocNamedColorRequest(Cmap, NameLen, Name), cookie)
-	return AllocNamedColorCookie(cookie)
+	c.newRequest(c.allocNamedColorRequest(Cmap, NameLen, Name), cookie)
+	return AllocNamedColorCookie{cookie}
 }
 
 // Request reply for AllocNamedColor
@@ -10855,10 +11847,13 @@ type AllocNamedColorReply struct {
 
 // Waits and reads reply data from request AllocNamedColor
 func (cook AllocNamedColorCookie) Reply() (*AllocNamedColorReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return allocNamedColorReply(buf), nil
 }
 
@@ -10899,8 +11894,12 @@ func allocNamedColorReply(buf []byte) *AllocNamedColorReply {
 	return v
 }
 
+func (cook AllocNamedColorCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for AllocNamedColor
-func allocNamedColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
+func (c *Conn) allocNamedColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
 	size := pad((12 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -10929,18 +11928,20 @@ func allocNamedColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
 
 // Request AllocColorCells
 // size: 12
-type AllocColorCellsCookie cookie
+type AllocColorCellsCookie struct {
+	*cookie
+}
 
 func (c *Conn) AllocColorCells(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) AllocColorCellsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(allocColorCellsRequest(Contiguous, Cmap, Colors, Planes), cookie)
-	return AllocColorCellsCookie(cookie)
+	c.newRequest(c.allocColorCellsRequest(Contiguous, Cmap, Colors, Planes), cookie)
+	return AllocColorCellsCookie{cookie}
 }
 
 func (c *Conn) AllocColorCellsUnchecked(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) AllocColorCellsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(allocColorCellsRequest(Contiguous, Cmap, Colors, Planes), cookie)
-	return AllocColorCellsCookie(cookie)
+	c.newRequest(c.allocColorCellsRequest(Contiguous, Cmap, Colors, Planes), cookie)
+	return AllocColorCellsCookie{cookie}
 }
 
 // Request reply for AllocColorCells
@@ -10958,10 +11959,13 @@ type AllocColorCellsReply struct {
 
 // Waits and reads reply data from request AllocColorCells
 func (cook AllocColorCellsCookie) Reply() (*AllocColorCellsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return allocColorCellsReply(buf), nil
 }
 
@@ -11003,8 +12007,12 @@ func allocColorCellsReply(buf []byte) *AllocColorCellsReply {
 	return v
 }
 
+func (cook AllocColorCellsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for AllocColorCells
-func allocColorCellsRequest(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) []byte {
+func (c *Conn) allocColorCellsRequest(Contiguous bool, Cmap Id, Colors uint16, Planes uint16) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -11036,18 +12044,20 @@ func allocColorCellsRequest(Contiguous bool, Cmap Id, Colors uint16, Planes uint
 
 // Request AllocColorPlanes
 // size: 16
-type AllocColorPlanesCookie cookie
+type AllocColorPlanesCookie struct {
+	*cookie
+}
 
 func (c *Conn) AllocColorPlanes(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) AllocColorPlanesCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(allocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues), cookie)
-	return AllocColorPlanesCookie(cookie)
+	c.newRequest(c.allocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues), cookie)
+	return AllocColorPlanesCookie{cookie}
 }
 
 func (c *Conn) AllocColorPlanesUnchecked(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) AllocColorPlanesCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(allocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues), cookie)
-	return AllocColorPlanesCookie(cookie)
+	c.newRequest(c.allocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues), cookie)
+	return AllocColorPlanesCookie{cookie}
 }
 
 // Request reply for AllocColorPlanes
@@ -11067,10 +12077,13 @@ type AllocColorPlanesReply struct {
 
 // Waits and reads reply data from request AllocColorPlanes
 func (cook AllocColorPlanesCookie) Reply() (*AllocColorPlanesReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return allocColorPlanesReply(buf), nil
 }
 
@@ -11113,8 +12126,12 @@ func allocColorPlanesReply(buf []byte) *AllocColorPlanesReply {
 	return v
 }
 
+func (cook AllocColorPlanesCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for AllocColorPlanes
-func allocColorPlanesRequest(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) []byte {
+func (c *Conn) allocColorPlanesRequest(Contiguous bool, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) []byte {
 	size := 16
 	b := 0
 	buf := make([]byte, size)
@@ -11152,23 +12169,29 @@ func allocColorPlanesRequest(Contiguous bool, Cmap Id, Colors uint16, Reds uint1
 
 // Request FreeColors
 // size: pad((12 + pad((len(Pixels) * 4))))
-type FreeColorsCookie cookie
+type FreeColorsCookie struct {
+	*cookie
+}
 
 // Write request to wire for FreeColors
 func (c *Conn) FreeColors(Cmap Id, PlaneMask uint32, Pixels []uint32) FreeColorsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(freeColorsRequest(Cmap, PlaneMask, Pixels), cookie)
-	return FreeColorsCookie(cookie)
+	c.newRequest(c.freeColorsRequest(Cmap, PlaneMask, Pixels), cookie)
+	return FreeColorsCookie{cookie}
 }
 
 func (c *Conn) FreeColorsChecked(Cmap Id, PlaneMask uint32, Pixels []uint32) FreeColorsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(freeColorsRequest(Cmap, PlaneMask, Pixels), cookie)
-	return FreeColorsCookie(cookie)
+	c.newRequest(c.freeColorsRequest(Cmap, PlaneMask, Pixels), cookie)
+	return FreeColorsCookie{cookie}
+}
+
+func (cook FreeColorsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FreeColors
-func freeColorsRequest(Cmap Id, PlaneMask uint32, Pixels []uint32) []byte {
+func (c *Conn) freeColorsRequest(Cmap Id, PlaneMask uint32, Pixels []uint32) []byte {
 	size := pad((12 + pad((len(Pixels) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -11198,23 +12221,29 @@ func freeColorsRequest(Cmap Id, PlaneMask uint32, Pixels []uint32) []byte {
 
 // Request StoreColors
 // size: pad((8 + pad((len(Items) * 12))))
-type StoreColorsCookie cookie
+type StoreColorsCookie struct {
+	*cookie
+}
 
 // Write request to wire for StoreColors
 func (c *Conn) StoreColors(Cmap Id, Items []Coloritem) StoreColorsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(storeColorsRequest(Cmap, Items), cookie)
-	return StoreColorsCookie(cookie)
+	c.newRequest(c.storeColorsRequest(Cmap, Items), cookie)
+	return StoreColorsCookie{cookie}
 }
 
 func (c *Conn) StoreColorsChecked(Cmap Id, Items []Coloritem) StoreColorsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(storeColorsRequest(Cmap, Items), cookie)
-	return StoreColorsCookie(cookie)
+	c.newRequest(c.storeColorsRequest(Cmap, Items), cookie)
+	return StoreColorsCookie{cookie}
+}
+
+func (cook StoreColorsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for StoreColors
-func storeColorsRequest(Cmap Id, Items []Coloritem) []byte {
+func (c *Conn) storeColorsRequest(Cmap Id, Items []Coloritem) []byte {
 	size := pad((8 + pad((len(Items) * 12))))
 	b := 0
 	buf := make([]byte, size)
@@ -11237,23 +12266,29 @@ func storeColorsRequest(Cmap Id, Items []Coloritem) []byte {
 
 // Request StoreNamedColor
 // size: pad((16 + pad((int(NameLen) * 1))))
-type StoreNamedColorCookie cookie
+type StoreNamedColorCookie struct {
+	*cookie
+}
 
 // Write request to wire for StoreNamedColor
 func (c *Conn) StoreNamedColor(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, Name string) StoreNamedColorCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(storeNamedColorRequest(Flags, Cmap, Pixel, NameLen, Name), cookie)
-	return StoreNamedColorCookie(cookie)
+	c.newRequest(c.storeNamedColorRequest(Flags, Cmap, Pixel, NameLen, Name), cookie)
+	return StoreNamedColorCookie{cookie}
 }
 
 func (c *Conn) StoreNamedColorChecked(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, Name string) StoreNamedColorCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(storeNamedColorRequest(Flags, Cmap, Pixel, NameLen, Name), cookie)
-	return StoreNamedColorCookie(cookie)
+	c.newRequest(c.storeNamedColorRequest(Flags, Cmap, Pixel, NameLen, Name), cookie)
+	return StoreNamedColorCookie{cookie}
+}
+
+func (cook StoreNamedColorCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for StoreNamedColor
-func storeNamedColorRequest(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, Name string) []byte {
+func (c *Conn) storeNamedColorRequest(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, Name string) []byte {
 	size := pad((16 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -11286,18 +12321,20 @@ func storeNamedColorRequest(Flags byte, Cmap Id, Pixel uint32, NameLen uint16, N
 
 // Request QueryColors
 // size: pad((8 + pad((len(Pixels) * 4))))
-type QueryColorsCookie cookie
+type QueryColorsCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryColors(Cmap Id, Pixels []uint32) QueryColorsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryColorsRequest(Cmap, Pixels), cookie)
-	return QueryColorsCookie(cookie)
+	c.newRequest(c.queryColorsRequest(Cmap, Pixels), cookie)
+	return QueryColorsCookie{cookie}
 }
 
 func (c *Conn) QueryColorsUnchecked(Cmap Id, Pixels []uint32) QueryColorsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryColorsRequest(Cmap, Pixels), cookie)
-	return QueryColorsCookie(cookie)
+	c.newRequest(c.queryColorsRequest(Cmap, Pixels), cookie)
+	return QueryColorsCookie{cookie}
 }
 
 // Request reply for QueryColors
@@ -11313,10 +12350,13 @@ type QueryColorsReply struct {
 
 // Waits and reads reply data from request QueryColors
 func (cook QueryColorsCookie) Reply() (*QueryColorsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryColorsReply(buf), nil
 }
 
@@ -11344,8 +12384,12 @@ func queryColorsReply(buf []byte) *QueryColorsReply {
 	return v
 }
 
+func (cook QueryColorsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryColors
-func queryColorsRequest(Cmap Id, Pixels []uint32) []byte {
+func (c *Conn) queryColorsRequest(Cmap Id, Pixels []uint32) []byte {
 	size := pad((8 + pad((len(Pixels) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -11372,18 +12416,20 @@ func queryColorsRequest(Cmap Id, Pixels []uint32) []byte {
 
 // Request LookupColor
 // size: pad((12 + pad((int(NameLen) * 1))))
-type LookupColorCookie cookie
+type LookupColorCookie struct {
+	*cookie
+}
 
 func (c *Conn) LookupColor(Cmap Id, NameLen uint16, Name string) LookupColorCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(lookupColorRequest(Cmap, NameLen, Name), cookie)
-	return LookupColorCookie(cookie)
+	c.newRequest(c.lookupColorRequest(Cmap, NameLen, Name), cookie)
+	return LookupColorCookie{cookie}
 }
 
 func (c *Conn) LookupColorUnchecked(Cmap Id, NameLen uint16, Name string) LookupColorCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(lookupColorRequest(Cmap, NameLen, Name), cookie)
-	return LookupColorCookie(cookie)
+	c.newRequest(c.lookupColorRequest(Cmap, NameLen, Name), cookie)
+	return LookupColorCookie{cookie}
 }
 
 // Request reply for LookupColor
@@ -11402,10 +12448,13 @@ type LookupColorReply struct {
 
 // Waits and reads reply data from request LookupColor
 func (cook LookupColorCookie) Reply() (*LookupColorReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return lookupColorReply(buf), nil
 }
 
@@ -11443,8 +12492,12 @@ func lookupColorReply(buf []byte) *LookupColorReply {
 	return v
 }
 
+func (cook LookupColorCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for LookupColor
-func lookupColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
+func (c *Conn) lookupColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
 	size := pad((12 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -11473,23 +12526,29 @@ func lookupColorRequest(Cmap Id, NameLen uint16, Name string) []byte {
 
 // Request CreateCursor
 // size: 32
-type CreateCursorCookie cookie
+type CreateCursorCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreateCursor
 func (c *Conn) CreateCursor(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) CreateCursorCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createCursorRequest(Cid, Source, Mask, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue, X, Y), cookie)
-	return CreateCursorCookie(cookie)
+	c.newRequest(c.createCursorRequest(Cid, Source, Mask, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue, X, Y), cookie)
+	return CreateCursorCookie{cookie}
 }
 
 func (c *Conn) CreateCursorChecked(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) CreateCursorCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createCursorRequest(Cid, Source, Mask, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue, X, Y), cookie)
-	return CreateCursorCookie(cookie)
+	c.newRequest(c.createCursorRequest(Cid, Source, Mask, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue, X, Y), cookie)
+	return CreateCursorCookie{cookie}
+}
+
+func (cook CreateCursorCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreateCursor
-func createCursorRequest(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) []byte {
+func (c *Conn) createCursorRequest(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) []byte {
 	size := 32
 	b := 0
 	buf := make([]byte, size)
@@ -11540,23 +12599,29 @@ func createCursorRequest(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen u
 
 // Request CreateGlyphCursor
 // size: 32
-type CreateGlyphCursorCookie cookie
+type CreateGlyphCursorCookie struct {
+	*cookie
+}
 
 // Write request to wire for CreateGlyphCursor
 func (c *Conn) CreateGlyphCursor(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) CreateGlyphCursorCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(createGlyphCursorRequest(Cid, SourceFont, MaskFont, SourceChar, MaskChar, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
-	return CreateGlyphCursorCookie(cookie)
+	c.newRequest(c.createGlyphCursorRequest(Cid, SourceFont, MaskFont, SourceChar, MaskChar, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
+	return CreateGlyphCursorCookie{cookie}
 }
 
 func (c *Conn) CreateGlyphCursorChecked(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) CreateGlyphCursorCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(createGlyphCursorRequest(Cid, SourceFont, MaskFont, SourceChar, MaskChar, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
-	return CreateGlyphCursorCookie(cookie)
+	c.newRequest(c.createGlyphCursorRequest(Cid, SourceFont, MaskFont, SourceChar, MaskChar, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
+	return CreateGlyphCursorCookie{cookie}
+}
+
+func (cook CreateGlyphCursorCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for CreateGlyphCursor
-func createGlyphCursorRequest(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) []byte {
+func (c *Conn) createGlyphCursorRequest(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) []byte {
 	size := 32
 	b := 0
 	buf := make([]byte, size)
@@ -11607,23 +12672,29 @@ func createGlyphCursorRequest(Cid Id, SourceFont Id, MaskFont Id, SourceChar uin
 
 // Request FreeCursor
 // size: 8
-type FreeCursorCookie cookie
+type FreeCursorCookie struct {
+	*cookie
+}
 
 // Write request to wire for FreeCursor
 func (c *Conn) FreeCursor(Cursor Id) FreeCursorCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(freeCursorRequest(Cursor), cookie)
-	return FreeCursorCookie(cookie)
+	c.newRequest(c.freeCursorRequest(Cursor), cookie)
+	return FreeCursorCookie{cookie}
 }
 
 func (c *Conn) FreeCursorChecked(Cursor Id) FreeCursorCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(freeCursorRequest(Cursor), cookie)
-	return FreeCursorCookie(cookie)
+	c.newRequest(c.freeCursorRequest(Cursor), cookie)
+	return FreeCursorCookie{cookie}
+}
+
+func (cook FreeCursorCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for FreeCursor
-func freeCursorRequest(Cursor Id) []byte {
+func (c *Conn) freeCursorRequest(Cursor Id) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -11644,23 +12715,29 @@ func freeCursorRequest(Cursor Id) []byte {
 
 // Request RecolorCursor
 // size: 20
-type RecolorCursorCookie cookie
+type RecolorCursorCookie struct {
+	*cookie
+}
 
 // Write request to wire for RecolorCursor
 func (c *Conn) RecolorCursor(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) RecolorCursorCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(recolorCursorRequest(Cursor, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
-	return RecolorCursorCookie(cookie)
+	c.newRequest(c.recolorCursorRequest(Cursor, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
+	return RecolorCursorCookie{cookie}
 }
 
 func (c *Conn) RecolorCursorChecked(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) RecolorCursorCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(recolorCursorRequest(Cursor, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
-	return RecolorCursorCookie(cookie)
+	c.newRequest(c.recolorCursorRequest(Cursor, ForeRed, ForeGreen, ForeBlue, BackRed, BackGreen, BackBlue), cookie)
+	return RecolorCursorCookie{cookie}
+}
+
+func (cook RecolorCursorCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for RecolorCursor
-func recolorCursorRequest(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) []byte {
+func (c *Conn) recolorCursorRequest(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) []byte {
 	size := 20
 	b := 0
 	buf := make([]byte, size)
@@ -11699,18 +12776,20 @@ func recolorCursorRequest(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue
 
 // Request QueryBestSize
 // size: 12
-type QueryBestSizeCookie cookie
+type QueryBestSizeCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryBestSize(Class byte, Drawable Id, Width uint16, Height uint16) QueryBestSizeCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryBestSizeRequest(Class, Drawable, Width, Height), cookie)
-	return QueryBestSizeCookie(cookie)
+	c.newRequest(c.queryBestSizeRequest(Class, Drawable, Width, Height), cookie)
+	return QueryBestSizeCookie{cookie}
 }
 
 func (c *Conn) QueryBestSizeUnchecked(Class byte, Drawable Id, Width uint16, Height uint16) QueryBestSizeCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryBestSizeRequest(Class, Drawable, Width, Height), cookie)
-	return QueryBestSizeCookie(cookie)
+	c.newRequest(c.queryBestSizeRequest(Class, Drawable, Width, Height), cookie)
+	return QueryBestSizeCookie{cookie}
 }
 
 // Request reply for QueryBestSize
@@ -11725,10 +12804,13 @@ type QueryBestSizeReply struct {
 
 // Waits and reads reply data from request QueryBestSize
 func (cook QueryBestSizeCookie) Reply() (*QueryBestSizeReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryBestSizeReply(buf), nil
 }
 
@@ -11754,8 +12836,12 @@ func queryBestSizeReply(buf []byte) *QueryBestSizeReply {
 	return v
 }
 
+func (cook QueryBestSizeCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryBestSize
-func queryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16) []byte {
+func (c *Conn) queryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -11783,18 +12869,20 @@ func queryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16)
 
 // Request QueryExtension
 // size: pad((8 + pad((int(NameLen) * 1))))
-type QueryExtensionCookie cookie
+type QueryExtensionCookie struct {
+	*cookie
+}
 
 func (c *Conn) QueryExtension(NameLen uint16, Name string) QueryExtensionCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(queryExtensionRequest(NameLen, Name), cookie)
-	return QueryExtensionCookie(cookie)
+	c.newRequest(c.queryExtensionRequest(NameLen, Name), cookie)
+	return QueryExtensionCookie{cookie}
 }
 
 func (c *Conn) QueryExtensionUnchecked(NameLen uint16, Name string) QueryExtensionCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(queryExtensionRequest(NameLen, Name), cookie)
-	return QueryExtensionCookie(cookie)
+	c.newRequest(c.queryExtensionRequest(NameLen, Name), cookie)
+	return QueryExtensionCookie{cookie}
 }
 
 // Request reply for QueryExtension
@@ -11811,10 +12899,13 @@ type QueryExtensionReply struct {
 
 // Waits and reads reply data from request QueryExtension
 func (cook QueryExtensionCookie) Reply() (*QueryExtensionReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return queryExtensionReply(buf), nil
 }
 
@@ -11850,8 +12941,12 @@ func queryExtensionReply(buf []byte) *QueryExtensionReply {
 	return v
 }
 
+func (cook QueryExtensionCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for QueryExtension
-func queryExtensionRequest(NameLen uint16, Name string) []byte {
+func (c *Conn) queryExtensionRequest(NameLen uint16, Name string) []byte {
 	size := pad((8 + pad((int(NameLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -11877,18 +12972,20 @@ func queryExtensionRequest(NameLen uint16, Name string) []byte {
 
 // Request ListExtensions
 // size: 4
-type ListExtensionsCookie cookie
+type ListExtensionsCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListExtensions() ListExtensionsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listExtensionsRequest(), cookie)
-	return ListExtensionsCookie(cookie)
+	c.newRequest(c.listExtensionsRequest(), cookie)
+	return ListExtensionsCookie{cookie}
 }
 
 func (c *Conn) ListExtensionsUnchecked() ListExtensionsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listExtensionsRequest(), cookie)
-	return ListExtensionsCookie(cookie)
+	c.newRequest(c.listExtensionsRequest(), cookie)
+	return ListExtensionsCookie{cookie}
 }
 
 // Request reply for ListExtensions
@@ -11903,10 +13000,13 @@ type ListExtensionsReply struct {
 
 // Waits and reads reply data from request ListExtensions
 func (cook ListExtensionsCookie) Reply() (*ListExtensionsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listExtensionsReply(buf), nil
 }
 
@@ -11932,8 +13032,12 @@ func listExtensionsReply(buf []byte) *ListExtensionsReply {
 	return v
 }
 
+func (cook ListExtensionsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListExtensions
-func listExtensionsRequest() []byte {
+func (c *Conn) listExtensionsRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -11941,28 +13045,38 @@ func listExtensionsRequest() []byte {
 	buf[b] = 99 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request ChangeKeyboardMapping
 // size: pad((8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4))))
-type ChangeKeyboardMappingCookie cookie
+type ChangeKeyboardMappingCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeKeyboardMapping
 func (c *Conn) ChangeKeyboardMapping(KeycodeCount byte, FirstKeycode Keycode, KeysymsPerKeycode byte, Keysyms []Keysym) ChangeKeyboardMappingCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeKeyboardMappingRequest(KeycodeCount, FirstKeycode, KeysymsPerKeycode, Keysyms), cookie)
-	return ChangeKeyboardMappingCookie(cookie)
+	c.newRequest(c.changeKeyboardMappingRequest(KeycodeCount, FirstKeycode, KeysymsPerKeycode, Keysyms), cookie)
+	return ChangeKeyboardMappingCookie{cookie}
 }
 
 func (c *Conn) ChangeKeyboardMappingChecked(KeycodeCount byte, FirstKeycode Keycode, KeysymsPerKeycode byte, Keysyms []Keysym) ChangeKeyboardMappingCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeKeyboardMappingRequest(KeycodeCount, FirstKeycode, KeysymsPerKeycode, Keysyms), cookie)
-	return ChangeKeyboardMappingCookie(cookie)
+	c.newRequest(c.changeKeyboardMappingRequest(KeycodeCount, FirstKeycode, KeysymsPerKeycode, Keysyms), cookie)
+	return ChangeKeyboardMappingCookie{cookie}
+}
+
+func (cook ChangeKeyboardMappingCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeKeyboardMapping
-func changeKeyboardMappingRequest(KeycodeCount byte, FirstKeycode Keycode, KeysymsPerKeycode byte, Keysyms []Keysym) []byte {
+func (c *Conn) changeKeyboardMappingRequest(KeycodeCount byte, FirstKeycode Keycode, KeysymsPerKeycode byte, Keysyms []Keysym) []byte {
 	size := pad((8 + pad(((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -11995,18 +13109,20 @@ func changeKeyboardMappingRequest(KeycodeCount byte, FirstKeycode Keycode, Keysy
 
 // Request GetKeyboardMapping
 // size: 8
-type GetKeyboardMappingCookie cookie
+type GetKeyboardMappingCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetKeyboardMapping(FirstKeycode Keycode, Count byte) GetKeyboardMappingCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getKeyboardMappingRequest(FirstKeycode, Count), cookie)
-	return GetKeyboardMappingCookie(cookie)
+	c.newRequest(c.getKeyboardMappingRequest(FirstKeycode, Count), cookie)
+	return GetKeyboardMappingCookie{cookie}
 }
 
 func (c *Conn) GetKeyboardMappingUnchecked(FirstKeycode Keycode, Count byte) GetKeyboardMappingCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getKeyboardMappingRequest(FirstKeycode, Count), cookie)
-	return GetKeyboardMappingCookie(cookie)
+	c.newRequest(c.getKeyboardMappingRequest(FirstKeycode, Count), cookie)
+	return GetKeyboardMappingCookie{cookie}
 }
 
 // Request reply for GetKeyboardMapping
@@ -12021,10 +13137,13 @@ type GetKeyboardMappingReply struct {
 
 // Waits and reads reply data from request GetKeyboardMapping
 func (cook GetKeyboardMappingCookie) Reply() (*GetKeyboardMappingReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getKeyboardMappingReply(buf), nil
 }
 
@@ -12054,8 +13173,12 @@ func getKeyboardMappingReply(buf []byte) *GetKeyboardMappingReply {
 	return v
 }
 
+func (cook GetKeyboardMappingCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetKeyboardMapping
-func getKeyboardMappingRequest(FirstKeycode Keycode, Count byte) []byte {
+func (c *Conn) getKeyboardMappingRequest(FirstKeycode Keycode, Count byte) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -12079,23 +13202,29 @@ func getKeyboardMappingRequest(FirstKeycode Keycode, Count byte) []byte {
 
 // Request ChangeKeyboardControl
 // size: pad((4 + (4 + pad((4 * popCount(int(ValueMask)))))))
-type ChangeKeyboardControlCookie cookie
+type ChangeKeyboardControlCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeKeyboardControl
 func (c *Conn) ChangeKeyboardControl(ValueMask uint32, ValueList []uint32) ChangeKeyboardControlCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeKeyboardControlRequest(ValueMask, ValueList), cookie)
-	return ChangeKeyboardControlCookie(cookie)
+	c.newRequest(c.changeKeyboardControlRequest(ValueMask, ValueList), cookie)
+	return ChangeKeyboardControlCookie{cookie}
 }
 
 func (c *Conn) ChangeKeyboardControlChecked(ValueMask uint32, ValueList []uint32) ChangeKeyboardControlCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeKeyboardControlRequest(ValueMask, ValueList), cookie)
-	return ChangeKeyboardControlCookie(cookie)
+	c.newRequest(c.changeKeyboardControlRequest(ValueMask, ValueList), cookie)
+	return ChangeKeyboardControlCookie{cookie}
+}
+
+func (cook ChangeKeyboardControlCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeKeyboardControl
-func changeKeyboardControlRequest(ValueMask uint32, ValueList []uint32) []byte {
+func (c *Conn) changeKeyboardControlRequest(ValueMask uint32, ValueList []uint32) []byte {
 	size := pad((4 + (4 + pad((4 * popCount(int(ValueMask)))))))
 	b := 0
 	buf := make([]byte, size)
@@ -12121,18 +13250,20 @@ func changeKeyboardControlRequest(ValueMask uint32, ValueList []uint32) []byte {
 
 // Request GetKeyboardControl
 // size: 4
-type GetKeyboardControlCookie cookie
+type GetKeyboardControlCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetKeyboardControl() GetKeyboardControlCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getKeyboardControlRequest(), cookie)
-	return GetKeyboardControlCookie(cookie)
+	c.newRequest(c.getKeyboardControlRequest(), cookie)
+	return GetKeyboardControlCookie{cookie}
 }
 
 func (c *Conn) GetKeyboardControlUnchecked() GetKeyboardControlCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getKeyboardControlRequest(), cookie)
-	return GetKeyboardControlCookie(cookie)
+	c.newRequest(c.getKeyboardControlRequest(), cookie)
+	return GetKeyboardControlCookie{cookie}
 }
 
 // Request reply for GetKeyboardControl
@@ -12152,10 +13283,13 @@ type GetKeyboardControlReply struct {
 
 // Waits and reads reply data from request GetKeyboardControl
 func (cook GetKeyboardControlCookie) Reply() (*GetKeyboardControlReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getKeyboardControlReply(buf), nil
 }
 
@@ -12197,8 +13331,12 @@ func getKeyboardControlReply(buf []byte) *GetKeyboardControlReply {
 	return v
 }
 
+func (cook GetKeyboardControlCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetKeyboardControl
-func getKeyboardControlRequest() []byte {
+func (c *Conn) getKeyboardControlRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12206,28 +13344,38 @@ func getKeyboardControlRequest() []byte {
 	buf[b] = 103 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request Bell
 // size: 4
-type BellCookie cookie
+type BellCookie struct {
+	*cookie
+}
 
 // Write request to wire for Bell
 func (c *Conn) Bell(Percent int8) BellCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(bellRequest(Percent), cookie)
-	return BellCookie(cookie)
+	c.newRequest(c.bellRequest(Percent), cookie)
+	return BellCookie{cookie}
 }
 
 func (c *Conn) BellChecked(Percent int8) BellCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(bellRequest(Percent), cookie)
-	return BellCookie(cookie)
+	c.newRequest(c.bellRequest(Percent), cookie)
+	return BellCookie{cookie}
+}
+
+func (cook BellCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for Bell
-func bellRequest(Percent int8) []byte {
+func (c *Conn) bellRequest(Percent int8) []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12238,28 +13386,37 @@ func bellRequest(Percent int8) []byte {
 	buf[b] = byte(Percent)
 	b += 1
 
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request ChangePointerControl
 // size: 12
-type ChangePointerControlCookie cookie
+type ChangePointerControlCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangePointerControl
 func (c *Conn) ChangePointerControl(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration bool, DoThreshold bool) ChangePointerControlCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changePointerControlRequest(AccelerationNumerator, AccelerationDenominator, Threshold, DoAcceleration, DoThreshold), cookie)
-	return ChangePointerControlCookie(cookie)
+	c.newRequest(c.changePointerControlRequest(AccelerationNumerator, AccelerationDenominator, Threshold, DoAcceleration, DoThreshold), cookie)
+	return ChangePointerControlCookie{cookie}
 }
 
 func (c *Conn) ChangePointerControlChecked(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration bool, DoThreshold bool) ChangePointerControlCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changePointerControlRequest(AccelerationNumerator, AccelerationDenominator, Threshold, DoAcceleration, DoThreshold), cookie)
-	return ChangePointerControlCookie(cookie)
+	c.newRequest(c.changePointerControlRequest(AccelerationNumerator, AccelerationDenominator, Threshold, DoAcceleration, DoThreshold), cookie)
+	return ChangePointerControlCookie{cookie}
+}
+
+func (cook ChangePointerControlCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangePointerControl
-func changePointerControlRequest(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration bool, DoThreshold bool) []byte {
+func (c *Conn) changePointerControlRequest(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration bool, DoThreshold bool) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -12300,18 +13457,20 @@ func changePointerControlRequest(AccelerationNumerator int16, AccelerationDenomi
 
 // Request GetPointerControl
 // size: 4
-type GetPointerControlCookie cookie
+type GetPointerControlCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetPointerControl() GetPointerControlCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getPointerControlRequest(), cookie)
-	return GetPointerControlCookie(cookie)
+	c.newRequest(c.getPointerControlRequest(), cookie)
+	return GetPointerControlCookie{cookie}
 }
 
 func (c *Conn) GetPointerControlUnchecked() GetPointerControlCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getPointerControlRequest(), cookie)
-	return GetPointerControlCookie(cookie)
+	c.newRequest(c.getPointerControlRequest(), cookie)
+	return GetPointerControlCookie{cookie}
 }
 
 // Request reply for GetPointerControl
@@ -12328,10 +13487,13 @@ type GetPointerControlReply struct {
 
 // Waits and reads reply data from request GetPointerControl
 func (cook GetPointerControlCookie) Reply() (*GetPointerControlReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getPointerControlReply(buf), nil
 }
 
@@ -12362,8 +13524,12 @@ func getPointerControlReply(buf []byte) *GetPointerControlReply {
 	return v
 }
 
+func (cook GetPointerControlCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetPointerControl
-func getPointerControlRequest() []byte {
+func (c *Conn) getPointerControlRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12371,28 +13537,38 @@ func getPointerControlRequest() []byte {
 	buf[b] = 106 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request SetScreenSaver
 // size: 12
-type SetScreenSaverCookie cookie
+type SetScreenSaverCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetScreenSaver
 func (c *Conn) SetScreenSaver(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) SetScreenSaverCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setScreenSaverRequest(Timeout, Interval, PreferBlanking, AllowExposures), cookie)
-	return SetScreenSaverCookie(cookie)
+	c.newRequest(c.setScreenSaverRequest(Timeout, Interval, PreferBlanking, AllowExposures), cookie)
+	return SetScreenSaverCookie{cookie}
 }
 
 func (c *Conn) SetScreenSaverChecked(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) SetScreenSaverCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setScreenSaverRequest(Timeout, Interval, PreferBlanking, AllowExposures), cookie)
-	return SetScreenSaverCookie(cookie)
+	c.newRequest(c.setScreenSaverRequest(Timeout, Interval, PreferBlanking, AllowExposures), cookie)
+	return SetScreenSaverCookie{cookie}
+}
+
+func (cook SetScreenSaverCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetScreenSaver
-func setScreenSaverRequest(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) []byte {
+func (c *Conn) setScreenSaverRequest(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) []byte {
 	size := 12
 	b := 0
 	buf := make([]byte, size)
@@ -12422,18 +13598,20 @@ func setScreenSaverRequest(Timeout int16, Interval int16, PreferBlanking byte, A
 
 // Request GetScreenSaver
 // size: 4
-type GetScreenSaverCookie cookie
+type GetScreenSaverCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetScreenSaver() GetScreenSaverCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getScreenSaverRequest(), cookie)
-	return GetScreenSaverCookie(cookie)
+	c.newRequest(c.getScreenSaverRequest(), cookie)
+	return GetScreenSaverCookie{cookie}
 }
 
 func (c *Conn) GetScreenSaverUnchecked() GetScreenSaverCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getScreenSaverRequest(), cookie)
-	return GetScreenSaverCookie(cookie)
+	c.newRequest(c.getScreenSaverRequest(), cookie)
+	return GetScreenSaverCookie{cookie}
 }
 
 // Request reply for GetScreenSaver
@@ -12451,10 +13629,13 @@ type GetScreenSaverReply struct {
 
 // Waits and reads reply data from request GetScreenSaver
 func (cook GetScreenSaverCookie) Reply() (*GetScreenSaverReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getScreenSaverReply(buf), nil
 }
 
@@ -12488,8 +13669,12 @@ func getScreenSaverReply(buf []byte) *GetScreenSaverReply {
 	return v
 }
 
+func (cook GetScreenSaverCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetScreenSaver
-func getScreenSaverRequest() []byte {
+func (c *Conn) getScreenSaverRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12497,28 +13682,38 @@ func getScreenSaverRequest() []byte {
 	buf[b] = 108 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request ChangeHosts
 // size: pad((8 + pad((int(AddressLen) * 1))))
-type ChangeHostsCookie cookie
+type ChangeHostsCookie struct {
+	*cookie
+}
 
 // Write request to wire for ChangeHosts
 func (c *Conn) ChangeHosts(Mode byte, Family byte, AddressLen uint16, Address []byte) ChangeHostsCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(changeHostsRequest(Mode, Family, AddressLen, Address), cookie)
-	return ChangeHostsCookie(cookie)
+	c.newRequest(c.changeHostsRequest(Mode, Family, AddressLen, Address), cookie)
+	return ChangeHostsCookie{cookie}
 }
 
 func (c *Conn) ChangeHostsChecked(Mode byte, Family byte, AddressLen uint16, Address []byte) ChangeHostsCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(changeHostsRequest(Mode, Family, AddressLen, Address), cookie)
-	return ChangeHostsCookie(cookie)
+	c.newRequest(c.changeHostsRequest(Mode, Family, AddressLen, Address), cookie)
+	return ChangeHostsCookie{cookie}
+}
+
+func (cook ChangeHostsCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ChangeHosts
-func changeHostsRequest(Mode byte, Family byte, AddressLen uint16, Address []byte) []byte {
+func (c *Conn) changeHostsRequest(Mode byte, Family byte, AddressLen uint16, Address []byte) []byte {
 	size := pad((8 + pad((int(AddressLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -12548,18 +13743,20 @@ func changeHostsRequest(Mode byte, Family byte, AddressLen uint16, Address []byt
 
 // Request ListHosts
 // size: 4
-type ListHostsCookie cookie
+type ListHostsCookie struct {
+	*cookie
+}
 
 func (c *Conn) ListHosts() ListHostsCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(listHostsRequest(), cookie)
-	return ListHostsCookie(cookie)
+	c.newRequest(c.listHostsRequest(), cookie)
+	return ListHostsCookie{cookie}
 }
 
 func (c *Conn) ListHostsUnchecked() ListHostsCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(listHostsRequest(), cookie)
-	return ListHostsCookie(cookie)
+	c.newRequest(c.listHostsRequest(), cookie)
+	return ListHostsCookie{cookie}
 }
 
 // Request reply for ListHosts
@@ -12575,10 +13772,13 @@ type ListHostsReply struct {
 
 // Waits and reads reply data from request ListHosts
 func (cook ListHostsCookie) Reply() (*ListHostsReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return listHostsReply(buf), nil
 }
 
@@ -12607,8 +13807,12 @@ func listHostsReply(buf []byte) *ListHostsReply {
 	return v
 }
 
+func (cook ListHostsCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for ListHosts
-func listHostsRequest() []byte {
+func (c *Conn) listHostsRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12616,28 +13820,38 @@ func listHostsRequest() []byte {
 	buf[b] = 110 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request SetAccessControl
 // size: 4
-type SetAccessControlCookie cookie
+type SetAccessControlCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetAccessControl
 func (c *Conn) SetAccessControl(Mode byte) SetAccessControlCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setAccessControlRequest(Mode), cookie)
-	return SetAccessControlCookie(cookie)
+	c.newRequest(c.setAccessControlRequest(Mode), cookie)
+	return SetAccessControlCookie{cookie}
 }
 
 func (c *Conn) SetAccessControlChecked(Mode byte) SetAccessControlCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setAccessControlRequest(Mode), cookie)
-	return SetAccessControlCookie(cookie)
+	c.newRequest(c.setAccessControlRequest(Mode), cookie)
+	return SetAccessControlCookie{cookie}
+}
+
+func (cook SetAccessControlCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetAccessControl
-func setAccessControlRequest(Mode byte) []byte {
+func (c *Conn) setAccessControlRequest(Mode byte) []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12648,28 +13862,37 @@ func setAccessControlRequest(Mode byte) []byte {
 	buf[b] = Mode
 	b += 1
 
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request SetCloseDownMode
 // size: 4
-type SetCloseDownModeCookie cookie
+type SetCloseDownModeCookie struct {
+	*cookie
+}
 
 // Write request to wire for SetCloseDownMode
 func (c *Conn) SetCloseDownMode(Mode byte) SetCloseDownModeCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(setCloseDownModeRequest(Mode), cookie)
-	return SetCloseDownModeCookie(cookie)
+	c.newRequest(c.setCloseDownModeRequest(Mode), cookie)
+	return SetCloseDownModeCookie{cookie}
 }
 
 func (c *Conn) SetCloseDownModeChecked(Mode byte) SetCloseDownModeCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(setCloseDownModeRequest(Mode), cookie)
-	return SetCloseDownModeCookie(cookie)
+	c.newRequest(c.setCloseDownModeRequest(Mode), cookie)
+	return SetCloseDownModeCookie{cookie}
+}
+
+func (cook SetCloseDownModeCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for SetCloseDownMode
-func setCloseDownModeRequest(Mode byte) []byte {
+func (c *Conn) setCloseDownModeRequest(Mode byte) []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12680,28 +13903,37 @@ func setCloseDownModeRequest(Mode byte) []byte {
 	buf[b] = Mode
 	b += 1
 
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request KillClient
 // size: 8
-type KillClientCookie cookie
+type KillClientCookie struct {
+	*cookie
+}
 
 // Write request to wire for KillClient
 func (c *Conn) KillClient(Resource uint32) KillClientCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(killClientRequest(Resource), cookie)
-	return KillClientCookie(cookie)
+	c.newRequest(c.killClientRequest(Resource), cookie)
+	return KillClientCookie{cookie}
 }
 
 func (c *Conn) KillClientChecked(Resource uint32) KillClientCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(killClientRequest(Resource), cookie)
-	return KillClientCookie(cookie)
+	c.newRequest(c.killClientRequest(Resource), cookie)
+	return KillClientCookie{cookie}
+}
+
+func (cook KillClientCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for KillClient
-func killClientRequest(Resource uint32) []byte {
+func (c *Conn) killClientRequest(Resource uint32) []byte {
 	size := 8
 	b := 0
 	buf := make([]byte, size)
@@ -12722,23 +13954,29 @@ func killClientRequest(Resource uint32) []byte {
 
 // Request RotateProperties
 // size: pad((12 + pad((int(AtomsLen) * 4))))
-type RotatePropertiesCookie cookie
+type RotatePropertiesCookie struct {
+	*cookie
+}
 
 // Write request to wire for RotateProperties
 func (c *Conn) RotateProperties(Window Id, AtomsLen uint16, Delta int16, Atoms []Id) RotatePropertiesCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(rotatePropertiesRequest(Window, AtomsLen, Delta, Atoms), cookie)
-	return RotatePropertiesCookie(cookie)
+	c.newRequest(c.rotatePropertiesRequest(Window, AtomsLen, Delta, Atoms), cookie)
+	return RotatePropertiesCookie{cookie}
 }
 
 func (c *Conn) RotatePropertiesChecked(Window Id, AtomsLen uint16, Delta int16, Atoms []Id) RotatePropertiesCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(rotatePropertiesRequest(Window, AtomsLen, Delta, Atoms), cookie)
-	return RotatePropertiesCookie(cookie)
+	c.newRequest(c.rotatePropertiesRequest(Window, AtomsLen, Delta, Atoms), cookie)
+	return RotatePropertiesCookie{cookie}
+}
+
+func (cook RotatePropertiesCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for RotateProperties
-func rotatePropertiesRequest(Window Id, AtomsLen uint16, Delta int16, Atoms []Id) []byte {
+func (c *Conn) rotatePropertiesRequest(Window Id, AtomsLen uint16, Delta int16, Atoms []Id) []byte {
 	size := pad((12 + pad((int(AtomsLen) * 4))))
 	b := 0
 	buf := make([]byte, size)
@@ -12771,23 +14009,29 @@ func rotatePropertiesRequest(Window Id, AtomsLen uint16, Delta int16, Atoms []Id
 
 // Request ForceScreenSaver
 // size: 4
-type ForceScreenSaverCookie cookie
+type ForceScreenSaverCookie struct {
+	*cookie
+}
 
 // Write request to wire for ForceScreenSaver
 func (c *Conn) ForceScreenSaver(Mode byte) ForceScreenSaverCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(forceScreenSaverRequest(Mode), cookie)
-	return ForceScreenSaverCookie(cookie)
+	c.newRequest(c.forceScreenSaverRequest(Mode), cookie)
+	return ForceScreenSaverCookie{cookie}
 }
 
 func (c *Conn) ForceScreenSaverChecked(Mode byte) ForceScreenSaverCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(forceScreenSaverRequest(Mode), cookie)
-	return ForceScreenSaverCookie(cookie)
+	c.newRequest(c.forceScreenSaverRequest(Mode), cookie)
+	return ForceScreenSaverCookie{cookie}
+}
+
+func (cook ForceScreenSaverCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for ForceScreenSaver
-func forceScreenSaverRequest(Mode byte) []byte {
+func (c *Conn) forceScreenSaverRequest(Mode byte) []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12798,23 +14042,28 @@ func forceScreenSaverRequest(Mode byte) []byte {
 	buf[b] = Mode
 	b += 1
 
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request SetPointerMapping
 // size: pad((4 + pad((int(MapLen) * 1))))
-type SetPointerMappingCookie cookie
+type SetPointerMappingCookie struct {
+	*cookie
+}
 
 func (c *Conn) SetPointerMapping(MapLen byte, Map []byte) SetPointerMappingCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(setPointerMappingRequest(MapLen, Map), cookie)
-	return SetPointerMappingCookie(cookie)
+	c.newRequest(c.setPointerMappingRequest(MapLen, Map), cookie)
+	return SetPointerMappingCookie{cookie}
 }
 
 func (c *Conn) SetPointerMappingUnchecked(MapLen byte, Map []byte) SetPointerMappingCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(setPointerMappingRequest(MapLen, Map), cookie)
-	return SetPointerMappingCookie(cookie)
+	c.newRequest(c.setPointerMappingRequest(MapLen, Map), cookie)
+	return SetPointerMappingCookie{cookie}
 }
 
 // Request reply for SetPointerMapping
@@ -12827,10 +14076,13 @@ type SetPointerMappingReply struct {
 
 // Waits and reads reply data from request SetPointerMapping
 func (cook SetPointerMappingCookie) Reply() (*SetPointerMappingReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return setPointerMappingReply(buf), nil
 }
 
@@ -12842,11 +14094,21 @@ func setPointerMappingReply(buf []byte) *SetPointerMappingReply {
 	v.Status = buf[b]
 	b += 1
 
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
 	return v
 }
 
+func (cook SetPointerMappingCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for SetPointerMapping
-func setPointerMappingRequest(MapLen byte, Map []byte) []byte {
+func (c *Conn) setPointerMappingRequest(MapLen byte, Map []byte) []byte {
 	size := pad((4 + pad((int(MapLen) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -12868,18 +14130,20 @@ func setPointerMappingRequest(MapLen byte, Map []byte) []byte {
 
 // Request GetPointerMapping
 // size: 4
-type GetPointerMappingCookie cookie
+type GetPointerMappingCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetPointerMapping() GetPointerMappingCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getPointerMappingRequest(), cookie)
-	return GetPointerMappingCookie(cookie)
+	c.newRequest(c.getPointerMappingRequest(), cookie)
+	return GetPointerMappingCookie{cookie}
 }
 
 func (c *Conn) GetPointerMappingUnchecked() GetPointerMappingCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getPointerMappingRequest(), cookie)
-	return GetPointerMappingCookie(cookie)
+	c.newRequest(c.getPointerMappingRequest(), cookie)
+	return GetPointerMappingCookie{cookie}
 }
 
 // Request reply for GetPointerMapping
@@ -12894,10 +14158,13 @@ type GetPointerMappingReply struct {
 
 // Waits and reads reply data from request GetPointerMapping
 func (cook GetPointerMappingCookie) Reply() (*GetPointerMappingReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getPointerMappingReply(buf), nil
 }
 
@@ -12924,8 +14191,12 @@ func getPointerMappingReply(buf []byte) *GetPointerMappingReply {
 	return v
 }
 
+func (cook GetPointerMappingCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetPointerMapping
-func getPointerMappingRequest() []byte {
+func (c *Conn) getPointerMappingRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -12933,23 +14204,29 @@ func getPointerMappingRequest() []byte {
 	buf[b] = 117 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request SetModifierMapping
 // size: pad((4 + pad(((int(KeycodesPerModifier) * 8) * 1))))
-type SetModifierMappingCookie cookie
+type SetModifierMappingCookie struct {
+	*cookie
+}
 
 func (c *Conn) SetModifierMapping(KeycodesPerModifier byte, Keycodes []Keycode) SetModifierMappingCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(setModifierMappingRequest(KeycodesPerModifier, Keycodes), cookie)
-	return SetModifierMappingCookie(cookie)
+	c.newRequest(c.setModifierMappingRequest(KeycodesPerModifier, Keycodes), cookie)
+	return SetModifierMappingCookie{cookie}
 }
 
 func (c *Conn) SetModifierMappingUnchecked(KeycodesPerModifier byte, Keycodes []Keycode) SetModifierMappingCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(setModifierMappingRequest(KeycodesPerModifier, Keycodes), cookie)
-	return SetModifierMappingCookie(cookie)
+	c.newRequest(c.setModifierMappingRequest(KeycodesPerModifier, Keycodes), cookie)
+	return SetModifierMappingCookie{cookie}
 }
 
 // Request reply for SetModifierMapping
@@ -12962,10 +14239,13 @@ type SetModifierMappingReply struct {
 
 // Waits and reads reply data from request SetModifierMapping
 func (cook SetModifierMappingCookie) Reply() (*SetModifierMappingReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return setModifierMappingReply(buf), nil
 }
 
@@ -12977,11 +14257,21 @@ func setModifierMappingReply(buf []byte) *SetModifierMappingReply {
 	v.Status = buf[b]
 	b += 1
 
+	v.Sequence = Get16(buf[b:])
+	b += 2
+
+	v.Length = Get32(buf[b:]) // 4-byte units
+	b += 4
+
 	return v
 }
 
+func (cook SetModifierMappingCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for SetModifierMapping
-func setModifierMappingRequest(KeycodesPerModifier byte, Keycodes []Keycode) []byte {
+func (c *Conn) setModifierMappingRequest(KeycodesPerModifier byte, Keycodes []Keycode) []byte {
 	size := pad((4 + pad(((int(KeycodesPerModifier) * 8) * 1))))
 	b := 0
 	buf := make([]byte, size)
@@ -13006,18 +14296,20 @@ func setModifierMappingRequest(KeycodesPerModifier byte, Keycodes []Keycode) []b
 
 // Request GetModifierMapping
 // size: 4
-type GetModifierMappingCookie cookie
+type GetModifierMappingCookie struct {
+	*cookie
+}
 
 func (c *Conn) GetModifierMapping() GetModifierMappingCookie {
 	cookie := c.newCookie(true, true)
-	c.newRequest(getModifierMappingRequest(), cookie)
-	return GetModifierMappingCookie(cookie)
+	c.newRequest(c.getModifierMappingRequest(), cookie)
+	return GetModifierMappingCookie{cookie}
 }
 
 func (c *Conn) GetModifierMappingUnchecked() GetModifierMappingCookie {
 	cookie := c.newCookie(false, true)
-	c.newRequest(getModifierMappingRequest(), cookie)
-	return GetModifierMappingCookie(cookie)
+	c.newRequest(c.getModifierMappingRequest(), cookie)
+	return GetModifierMappingCookie{cookie}
 }
 
 // Request reply for GetModifierMapping
@@ -13032,10 +14324,13 @@ type GetModifierMappingReply struct {
 
 // Waits and reads reply data from request GetModifierMapping
 func (cook GetModifierMappingCookie) Reply() (*GetModifierMappingReply, error) {
-	buf, err := cookie(cook).reply()
+	buf, err := cook.reply()
 	if err != nil {
 		return nil, err
 	}
+	if buf == nil {
+		return nil, nil
+	}
 	return getModifierMappingReply(buf), nil
 }
 
@@ -13065,8 +14360,12 @@ func getModifierMappingReply(buf []byte) *GetModifierMappingReply {
 	return v
 }
 
+func (cook GetModifierMappingCookie) Check() error {
+	return cook.check()
+}
+
 // Write request to wire for GetModifierMapping
-func getModifierMappingRequest() []byte {
+func (c *Conn) getModifierMappingRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -13074,28 +14373,38 @@ func getModifierMappingRequest() []byte {
 	buf[b] = 119 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }
 
 // Request NoOperation
 // size: 4
-type NoOperationCookie cookie
+type NoOperationCookie struct {
+	*cookie
+}
 
 // Write request to wire for NoOperation
 func (c *Conn) NoOperation() NoOperationCookie {
 	cookie := c.newCookie(false, false)
-	c.newRequest(noOperationRequest(), cookie)
-	return NoOperationCookie(cookie)
+	c.newRequest(c.noOperationRequest(), cookie)
+	return NoOperationCookie{cookie}
 }
 
 func (c *Conn) NoOperationChecked() NoOperationCookie {
 	cookie := c.newCookie(true, false)
-	c.newRequest(noOperationRequest(), cookie)
-	return NoOperationCookie(cookie)
+	c.newRequest(c.noOperationRequest(), cookie)
+	return NoOperationCookie{cookie}
+}
+
+func (cook NoOperationCookie) Check() error {
+	return cook.check()
 }
 
 // Write request to wire for NoOperation
-func noOperationRequest() []byte {
+func (c *Conn) noOperationRequest() []byte {
 	size := 4
 	b := 0
 	buf := make([]byte, size)
@@ -13103,5 +14412,9 @@ func noOperationRequest() []byte {
 	buf[b] = 127 // request opcode
 	b += 1
 
+	b += 1                         // padding
+	Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+	b += 2
+
 	return buf
 }