}
	// write "b"
	err = en.Append(0xa1, 0x62)
	if err != nil {
		return
	}
	err = en.WriteString(z.bucket)
	if err != nil {
		err = msgp.WrapError(err, "bucket")
		return
	}
	// write "flt"
	err = en.Append(0xa3, 0x66, 0x6c, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.filter)
	if err != nil {
		err = msgp.WrapError(err, "filter")
		return
	}
	// write "id"

		return
	}
	for za0001 := range z.Resources {
		err = en.WriteString(z.Resources[za0001])
		if err != nil {
			err = msgp.WrapError(err, "Resources", za0001)
			return
		}
	}
	// write "Owner"
	err = en.Append(0xa5, 0x4f, 0x77, 0x6e, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteString(z.Owner)
	if err != nil {
		err = msgp.WrapError(err, "Owner")
		return
	}

			if err != nil {
				err = msgp.WrapError(err, "Checksums")
				return
			}
			for za0001, za0002 := range z.Checksums {
				err = en.WriteString(za0001)
				if err != nil {
					err = msgp.WrapError(err, "Checksums")
					return
				}
				err = en.WriteString(za0002)
				if err != nil {
					err = msgp.WrapError(err, "Checksums", za0001)
					return
				}
			}
		}

	} else {
		for idx, column := range orderBy.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column.Column)
			if column.Desc {
				builder.WriteString(" DESC")
			}
		}
	}
}

// MergeClause merge order by clauses
func (orderBy OrderBy) MergeClause(clause *Clause) {
	if v, ok := clause.Expression.(OrderBy); ok {

	// write "ID"
	err = en.Append(0x86, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "User"
	err = en.Append(0xa4, 0x55, 0x73, 0x65, 0x72)
	if err != nil {
		return
	}
	err = en.WriteString(z.User)
	if err != nil {
		err = msgp.WrapError(err, "User")
		return
	}
	// write "Started"

		return
	}
	for za0001, za0002 := range z.Entries {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "Entries")
			return
		}
		// map header, size 3
		// write "b"
		err = en.Append(0x83, 0xa1, 0x62)
		if err != nil {
			return
		}
		err = en.WriteString(za0002.Bucket)
		if err != nil {
			err = msgp.WrapError(err, "Entries", za0001, "Bucket")

        smb.useUnicode = false;
        String testString = "Hello World";
        byte[] buffer = new byte[testString.length() + 1];
        int len = smb.writeString(testString, buffer, 0);
        assertEquals(testString.length() + 1, len);
        String readString = smb.readString(buffer, 0);
        assertEquals(testString, readString);
    }

    @Test

		// readability.
		w.Header().Set("Content-Type", "text/plain")
		var b strings.Builder
		b.WriteString("| Name | Type | Help | Labels |\n")
		b.WriteString("| ---- | ---- | ---- | ------ |\n")
		for _, metric := range metrics {
			b.WriteString(metric.TableRow())
		}
		w.Write([]byte(b.String()))
	})
}

	if err != nil {
		return
	}
	err = en.WriteString(z.Bucket)
	if err != nil {
		err = msgp.WrapError(err, "Bucket")
		return
	}
	// write "Object"
	err = en.Append(0xa6, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Object)
	if err != nil {
		err = msgp.WrapError(err, "Object")
		return
	}

pkg strings, method (*Builder) Write([]uint8) (int, error)
pkg strings, method (*Builder) WriteByte(uint8) error
pkg strings, method (*Builder) WriteRune(int32) (int, error)
pkg strings, method (*Builder) WriteString(string) (int, error)
pkg strings, type Builder struct
pkg syscall (freebsd-386), const SYS_UTIMENSAT = 547
pkg syscall (freebsd-386), const SYS_UTIMENSAT ideal-int
pkg syscall (freebsd-386-cgo), const SYS_UTIMENSAT = 547