Merge pull request #37212 from gmarek/ms

Automatic merge from submit-queue (batch tested with PRs 45534, 37212, 46613, 46350)

Add unversioned.MicroTime type

Ref. #36752

cc @smarterclayton @wojtek-t @dchen1107 @timothysc @bgrant0607

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/BUILD

@@ -15,6 +15,7 @@ go_test(
         "group_version_test.go",
         "helpers_test.go",
         "labels_test.go",
+        "micro_time_test.go",
         "time_test.go",
         "types_test.go",
     ],
@@ -38,6 +39,8 @@ go_library(
         "helpers.go",
         "labels.go",
         "meta.go",
+        "micro_time.go",
+        "micro_time_proto.go",
         "register.go",
         "time.go",
         "time_proto.go",

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go

@@ -46,6 +46,7 @@ limitations under the License.
 		LabelSelectorRequirement
 		ListMeta
 		ListOptions
+		MicroTime
 		ObjectMeta
 		OwnerReference
 		Preconditions
@@ -175,59 +176,63 @@ func (m *ListOptions) Reset()                    { *m = ListOptions{} }
 func (*ListOptions) ProtoMessage()               {}
 func (*ListOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
 
+func (m *MicroTime) Reset()                    { *m = MicroTime{} }
+func (*MicroTime) ProtoMessage()               {}
+func (*MicroTime) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
+
 func (m *ObjectMeta) Reset()                    { *m = ObjectMeta{} }
 func (*ObjectMeta) ProtoMessage()               {}
-func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
+func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
 
 func (m *OwnerReference) Reset()                    { *m = OwnerReference{} }
 func (*OwnerReference) ProtoMessage()               {}
-func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
+func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
 
 func (m *Preconditions) Reset()                    { *m = Preconditions{} }
 func (*Preconditions) ProtoMessage()               {}
-func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
+func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
 
 func (m *RootPaths) Reset()                    { *m = RootPaths{} }
 func (*RootPaths) ProtoMessage()               {}
-func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
+func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
 
 func (m *ServerAddressByClientCIDR) Reset()      { *m = ServerAddressByClientCIDR{} }
 func (*ServerAddressByClientCIDR) ProtoMessage() {}
 func (*ServerAddressByClientCIDR) Descriptor() ([]byte, []int) {
-	return fileDescriptorGenerated, []int{25}
+	return fileDescriptorGenerated, []int{26}
 }
 
 func (m *Status) Reset()                    { *m = Status{} }
 func (*Status) ProtoMessage()               {}
-func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
+func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
 
 func (m *StatusCause) Reset()                    { *m = StatusCause{} }
 func (*StatusCause) ProtoMessage()               {}
-func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
+func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
 
 func (m *StatusDetails) Reset()                    { *m = StatusDetails{} }
 func (*StatusDetails) ProtoMessage()               {}
-func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
+func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
 
 func (m *Time) Reset()                    { *m = Time{} }
 func (*Time) ProtoMessage()               {}
-func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
+func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
 
 func (m *Timestamp) Reset()                    { *m = Timestamp{} }
 func (*Timestamp) ProtoMessage()               {}
-func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
+func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} }
 
 func (m *TypeMeta) Reset()                    { *m = TypeMeta{} }
 func (*TypeMeta) ProtoMessage()               {}
-func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} }
+func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
 
 func (m *Verbs) Reset()                    { *m = Verbs{} }
 func (*Verbs) ProtoMessage()               {}
-func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
+func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
 
 func (m *WatchEvent) Reset()                    { *m = WatchEvent{} }
 func (*WatchEvent) ProtoMessage()               {}
-func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
+func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
 
 func init() {
 	proto.RegisterType((*APIGroup)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroup")
@@ -251,6 +256,7 @@ func init() {
 	proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement")
 	proto.RegisterType((*ListMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta")
 	proto.RegisterType((*ListOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListOptions")
+	proto.RegisterType((*MicroTime)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.MicroTime")
 	proto.RegisterType((*ObjectMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta")
 	proto.RegisterType((*OwnerReference)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.OwnerReference")
 	proto.RegisterType((*Preconditions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Preconditions")
@@ -7292,151 +7298,151 @@ func init() {
 }
 
 var fileDescriptorGenerated = []byte{
-	// 2322 bytes of a gzipped FileDescriptorProto
+	// 2330 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcd, 0x6f, 0x23, 0x49,
 	0x15, 0x4f, 0x3b, 0xb1, 0xc7, 0x7e, 0x8e, 0xf3, 0x51, 0x9b, 0x01, 0x6f, 0x04, 0x71, 0xb6, 0x77,
-	0xb5, 0x9a, 0x85, 0x59, 0x9b, 0x64, 0x61, 0x35, 0x0c, 0x30, 0x90, 0x8e, 0x33, 0xa3, 0x68, 0xe7,
+	0xb5, 0x9a, 0x85, 0x59, 0x9b, 0x64, 0x61, 0x35, 0x0c, 0x30, 0x90, 0x8e, 0x33, 0xa3, 0x68, 0x27,
-	0xc3, 0xaa, 0xec, 0x0c, 0x62, 0x18, 0x21, 0x3a, 0xdd, 0x15, 0xa7, 0x49, 0xbb, 0xbb, 0xa9, 0x2a,
+	0x33, 0x56, 0x65, 0x67, 0x10, 0xc3, 0x08, 0xd1, 0xe9, 0xae, 0x38, 0x4d, 0xda, 0xdd, 0xbd, 0x55,
-	0x67, 0x12, 0xf6, 0xc0, 0x1e, 0x40, 0xe2, 0x80, 0xd0, 0x1c, 0xf7, 0x84, 0x66, 0x04, 0x7f, 0x01,
+	0xe5, 0xcc, 0x84, 0x3d, 0xb0, 0x07, 0x90, 0x38, 0x20, 0x34, 0x47, 0x4e, 0x68, 0x47, 0xf0, 0x17,
-	0x77, 0x38, 0x21, 0x31, 0xc7, 0x95, 0xb8, 0x70, 0x40, 0xd6, 0x8e, 0xf7, 0xc0, 0x09, 0x71, 0x8f,
+	0x70, 0x87, 0x13, 0x12, 0x73, 0x5c, 0x89, 0x0b, 0x07, 0x64, 0xed, 0x78, 0x0f, 0x9c, 0x10, 0xf7,
-	0x84, 0x84, 0xaa, 0xba, 0xfa, 0xcb, 0x8e, 0x37, 0xed, 0x9d, 0x3d, 0x70, 0x8a, 0xfb, 0x7d, 0xfc,
+	0x48, 0x48, 0xa8, 0xaa, 0xab, 0xbf, 0xec, 0x78, 0xd3, 0xde, 0x59, 0xa1, 0x3d, 0xb9, 0xeb, 0x7d,
-	0xde, 0xab, 0x7a, 0xaf, 0xde, 0x7b, 0x55, 0x81, 0x3b, 0x47, 0xd7, 0x58, 0xd3, 0xf1, 0x5b, 0x47,
+	0xfc, 0xde, 0xab, 0xaa, 0x57, 0xef, 0xbd, 0x2a, 0xc3, 0xde, 0xf1, 0x35, 0xd6, 0x74, 0xfc, 0xd6,
-	0xfd, 0x7d, 0x42, 0x3d, 0xc2, 0x09, 0x6b, 0x1d, 0x13, 0xcf, 0xf6, 0x69, 0x4b, 0x31, 0xcc, 0xc0,
+	0x71, 0xff, 0x80, 0x50, 0x8f, 0x70, 0xc2, 0x5a, 0x27, 0xc4, 0xb3, 0x7d, 0xda, 0x52, 0x0c, 0x33,
-	0xe9, 0x99, 0xd6, 0xa1, 0xe3, 0x11, 0x7a, 0xda, 0x0a, 0x8e, 0xba, 0x82, 0xc0, 0x5a, 0x3d, 0xc2,
+	0x70, 0x7a, 0xa6, 0x75, 0xe4, 0x78, 0x84, 0x9e, 0xb6, 0x82, 0xe3, 0xae, 0x20, 0xb0, 0x56, 0x8f,
-	0xcd, 0xd6, 0xf1, 0x46, 0xab, 0x4b, 0x3c, 0x42, 0x4d, 0x4e, 0xec, 0x66, 0x40, 0x7d, 0xee, 0xa3,
+	0x70, 0xb3, 0x75, 0xb2, 0xd1, 0xea, 0x12, 0x8f, 0x50, 0x93, 0x13, 0xbb, 0x19, 0x50, 0x9f, 0xfb,
-	0x37, 0x42, 0xad, 0x66, 0x5a, 0xab, 0x19, 0x1c, 0x75, 0x05, 0x81, 0x35, 0x85, 0x56, 0xf3, 0x78,
+	0xe8, 0xb5, 0x50, 0xab, 0x99, 0xd6, 0x6a, 0x06, 0xc7, 0x5d, 0x41, 0x60, 0x4d, 0xa1, 0xd5, 0x3c,
-	0x63, 0xf5, 0xed, 0xae, 0xc3, 0x0f, 0xfb, 0xfb, 0x4d, 0xcb, 0xef, 0xb5, 0xba, 0x7e, 0xd7, 0x6f,
+	0xd9, 0x58, 0x7d, 0xb3, 0xeb, 0xf0, 0xa3, 0xfe, 0x41, 0xd3, 0xf2, 0x7b, 0xad, 0xae, 0xdf, 0xf5,
-	0x49, 0xe5, 0xfd, 0xfe, 0x81, 0xfc, 0x92, 0x1f, 0xf2, 0x57, 0x08, 0xba, 0x3a, 0xd1, 0x15, 0xda,
+	0x5b, 0x52, 0xf9, 0xa0, 0x7f, 0x28, 0x47, 0x72, 0x20, 0xbf, 0x42, 0xd0, 0xd5, 0x89, 0xae, 0xd0,
-	0xf7, 0xb8, 0xd3, 0x23, 0xa3, 0x5e, 0xac, 0xbe, 0x7b, 0x91, 0x02, 0xb3, 0x0e, 0x49, 0xcf, 0x1c,
+	0xbe, 0xc7, 0x9d, 0x1e, 0x19, 0xf5, 0x62, 0xf5, 0xed, 0x8b, 0x14, 0x98, 0x75, 0x44, 0x7a, 0xe6,
-	0xd3, 0x7b, 0x67, 0x92, 0x5e, 0x9f, 0x3b, 0x6e, 0xcb, 0xf1, 0x38, 0xe3, 0x74, 0x54, 0x49, 0xff,
+	0x98, 0xde, 0x5b, 0x93, 0xf4, 0xfa, 0xdc, 0x71, 0x5b, 0x8e, 0xc7, 0x19, 0xa7, 0xa3, 0x4a, 0xfa,
-	0xdb, 0x2c, 0x94, 0xb7, 0x3a, 0xbb, 0xb7, 0xa8, 0xdf, 0x0f, 0xd0, 0x3a, 0xcc, 0x79, 0x66, 0x8f,
+	0xdf, 0x66, 0xa1, 0xbc, 0xd5, 0xd9, 0xbd, 0x45, 0xfd, 0x7e, 0x80, 0xd6, 0x61, 0xce, 0x33, 0x7b,
-	0xd4, 0xb5, 0x75, 0xed, 0x4a, 0xc5, 0x98, 0x7f, 0x3e, 0x68, 0xcc, 0x0c, 0x07, 0x8d, 0xb9, 0xbb,
+	0xa4, 0xae, 0xad, 0x6b, 0x57, 0x2a, 0xc6, 0xfc, 0xb3, 0x41, 0x63, 0x66, 0x38, 0x68, 0xcc, 0xdd,
-	0x66, 0x8f, 0x60, 0xc9, 0x41, 0x2e, 0x94, 0x8f, 0x09, 0x65, 0x8e, 0xef, 0xb1, 0x7a, 0x61, 0x7d,
+	0x31, 0x7b, 0x04, 0x4b, 0x0e, 0x72, 0xa1, 0x7c, 0x42, 0x28, 0x73, 0x7c, 0x8f, 0xd5, 0x0b, 0xeb,
-	0xf6, 0x4a, 0x75, 0xf3, 0x46, 0x33, 0xcf, 0xa6, 0x35, 0xa5, 0x81, 0x07, 0xa1, 0xea, 0x4d, 0x9f,
+	0xb3, 0x57, 0xaa, 0x9b, 0x37, 0x9a, 0x79, 0x16, 0xad, 0x29, 0x0d, 0xdc, 0x0f, 0x55, 0x6f, 0xfa,
-	0xb6, 0x1d, 0x66, 0xf9, 0xc7, 0x84, 0x9e, 0x1a, 0x4b, 0xca, 0x4a, 0x59, 0x31, 0x19, 0x8e, 0x2d,
+	0xb4, 0xed, 0x30, 0xcb, 0x3f, 0x21, 0xf4, 0xd4, 0x58, 0x52, 0x56, 0xca, 0x8a, 0xc9, 0x70, 0x6c,
-	0xa0, 0x5f, 0x69, 0xb0, 0x14, 0x50, 0x72, 0x40, 0x28, 0x25, 0xb6, 0xe2, 0xd7, 0x67, 0xd7, 0xb5,
+	0x01, 0xfd, 0x52, 0x83, 0xa5, 0x80, 0x92, 0x43, 0x42, 0x29, 0xb1, 0x15, 0xbf, 0x3e, 0xbb, 0xae,
-	0x2f, 0xc0, 0x6c, 0x5d, 0x99, 0x5d, 0xea, 0x8c, 0xe0, 0xe3, 0x31, 0x8b, 0xe8, 0x0f, 0x1a, 0xac,
+	0x7d, 0x0e, 0x66, 0xeb, 0xca, 0xec, 0x52, 0x67, 0x04, 0x1f, 0x8f, 0x59, 0x44, 0x7f, 0xd0, 0x60,
-	0x32, 0x42, 0x8f, 0x09, 0xdd, 0xb2, 0x6d, 0x4a, 0x18, 0x33, 0x4e, 0xb7, 0x5d, 0x87, 0x78, 0x7c,
+	0x95, 0x11, 0x7a, 0x42, 0xe8, 0x96, 0x6d, 0x53, 0xc2, 0x98, 0x71, 0xba, 0xed, 0x3a, 0xc4, 0xe3,
-	0x7b, 0xb7, 0x8d, 0x59, 0x7d, 0x4e, 0xee, 0xc3, 0xf7, 0xf3, 0x39, 0xb4, 0x37, 0x09, 0xc7, 0xd0,
+	0xdb, 0xbb, 0x6d, 0xcc, 0xea, 0x73, 0x72, 0x1d, 0xbe, 0x9f, 0xcf, 0xa1, 0xfd, 0x49, 0x38, 0x86,
-	0x95, 0x47, 0xab, 0x13, 0x45, 0x18, 0xfe, 0x0c, 0x37, 0xf4, 0x03, 0x98, 0x8f, 0x02, 0x79, 0xdb,
+	0xae, 0x3c, 0x5a, 0x9d, 0x28, 0xc2, 0xf0, 0xa7, 0xb8, 0xa1, 0x1f, 0xc2, 0x7c, 0xb4, 0x91, 0xb7,
-	0x61, 0x1c, 0x3d, 0x80, 0x52, 0x57, 0x7c, 0xb0, 0xba, 0x26, 0x1d, 0x6c, 0xe6, 0x73, 0x30, 0xc2,
+	0x1d, 0xc6, 0xd1, 0x7d, 0x28, 0x75, 0xc5, 0x80, 0xd5, 0x35, 0xe9, 0x60, 0x33, 0x9f, 0x83, 0x11,
-	0x30, 0x16, 0x94, 0x3f, 0x25, 0xf9, 0xc9, 0xb0, 0x42, 0xd3, 0xff, 0x5c, 0x80, 0xea, 0x56, 0x67,
+	0x86, 0xb1, 0xa0, 0xfc, 0x29, 0xc9, 0x21, 0xc3, 0x0a, 0x4d, 0xff, 0x73, 0x01, 0xaa, 0x5b, 0x9d,
-	0x17, 0x13, 0xe6, 0xf7, 0xa9, 0x45, 0x72, 0x24, 0xcd, 0x26, 0x80, 0xf8, 0xcb, 0x02, 0xd3, 0x22,
+	0x5d, 0x4c, 0x98, 0xdf, 0xa7, 0x16, 0xc9, 0x11, 0x34, 0x9b, 0x00, 0xe2, 0x97, 0x05, 0xa6, 0x45,
-	0x76, 0xbd, 0xb0, 0xae, 0x5d, 0x29, 0x1b, 0x48, 0xc9, 0xc1, 0xdd, 0x98, 0x83, 0x53, 0x52, 0x02,
+	0xec, 0x7a, 0x61, 0x5d, 0xbb, 0x52, 0x36, 0x90, 0x92, 0x83, 0x3b, 0x31, 0x07, 0xa7, 0xa4, 0x04,
-	0xf5, 0xc8, 0xf1, 0x6c, 0x19, 0xed, 0x14, 0xea, 0x7b, 0x8e, 0x67, 0x63, 0xc9, 0x41, 0xb7, 0xa1,
+	0xea, 0xb1, 0xe3, 0xd9, 0x72, 0xb7, 0x53, 0xa8, 0xef, 0x38, 0x9e, 0x8d, 0x25, 0x07, 0xdd, 0x86,
-	0x78, 0x4c, 0xe8, 0xbe, 0xd8, 0x7f, 0x91, 0x10, 0x5f, 0xcf, 0xb7, 0xbc, 0x07, 0x42, 0xc5, 0xa8,
+	0xe2, 0x09, 0xa1, 0x07, 0x62, 0xfd, 0x45, 0x40, 0x7c, 0x3d, 0xdf, 0xf4, 0xee, 0x0b, 0x15, 0xa3,
-	0x0c, 0x07, 0x8d, 0xa2, 0xfc, 0x89, 0x43, 0x10, 0xd4, 0x04, 0x60, 0x87, 0x3e, 0xe5, 0xd2, 0x9d,
+	0x32, 0x1c, 0x34, 0x8a, 0xf2, 0x13, 0x87, 0x20, 0xa8, 0x09, 0xc0, 0x8e, 0x7c, 0xca, 0xa5, 0x3b,
-	0x7a, 0x71, 0x7d, 0xf6, 0x4a, 0xc5, 0x58, 0x10, 0xfe, 0xed, 0xc5, 0x54, 0x9c, 0x92, 0x40, 0xd7,
+	0xf5, 0xe2, 0xfa, 0xec, 0x95, 0x8a, 0xb1, 0x20, 0xfc, 0xdb, 0x8f, 0xa9, 0x38, 0x25, 0x81, 0xae,
-	0x60, 0x9e, 0x39, 0x5e, 0xb7, 0xef, 0x9a, 0x54, 0x10, 0xea, 0x25, 0xe9, 0xe7, 0x8a, 0xf2, 0x73,
+	0xc1, 0x3c, 0x73, 0xbc, 0x6e, 0xdf, 0x35, 0xa9, 0x20, 0xd4, 0x4b, 0xd2, 0xcf, 0x15, 0xe5, 0xe7,
-	0x7e, 0x2f, 0xc5, 0xc3, 0x19, 0x49, 0xfd, 0x4f, 0x1a, 0x2c, 0xa6, 0xf6, 0x4f, 0xc6, 0xea, 0x1a,
+	0xfc, 0x7e, 0x8a, 0x87, 0x33, 0x92, 0xfa, 0x9f, 0x34, 0x58, 0x4c, 0xad, 0x9f, 0xdc, 0xab, 0x6b,
-	0xcc, 0x77, 0x53, 0x99, 0xaa, 0xf6, 0x32, 0x46, 0x4b, 0x67, 0x31, 0xce, 0x48, 0x22, 0x02, 0x15,
+	0x30, 0xdf, 0x4d, 0x45, 0xaa, 0x5a, 0xcb, 0x18, 0x2d, 0x1d, 0xc5, 0x38, 0x23, 0x89, 0x08, 0x54,
-	0xaa, 0x90, 0xa2, 0x13, 0xb9, 0x91, 0x3b, 0xd0, 0x91, 0x0f, 0x89, 0xa5, 0x14, 0x91, 0xe1, 0x04,
+	0xa8, 0x42, 0x8a, 0x4e, 0xe4, 0x46, 0xee, 0x8d, 0x8e, 0x7c, 0x48, 0x2c, 0xa5, 0x88, 0x0c, 0x27,
-	0x59, 0xff, 0x97, 0x26, 0x83, 0x1e, 0x9d, 0x51, 0x74, 0x25, 0x55, 0x07, 0x34, 0xb9, 0x59, 0xf3,
+	0xc8, 0xfa, 0xbf, 0x34, 0xb9, 0xe9, 0xd1, 0x19, 0x45, 0x57, 0x52, 0x79, 0x40, 0x93, 0x8b, 0x35,
-	0x13, 0xce, 0xf0, 0x05, 0x87, 0xa7, 0xf0, 0x7f, 0x71, 0x78, 0xae, 0x97, 0x3f, 0x7a, 0xda, 0x98,
+	0x3f, 0xe1, 0x0c, 0x5f, 0x70, 0x78, 0x0a, 0x5f, 0x88, 0xc3, 0x73, 0xbd, 0xfc, 0xbb, 0x0f, 0x1b,
-	0xf9, 0xf0, 0x9f, 0xeb, 0x33, 0xfa, 0xa7, 0x05, 0xa8, 0xb5, 0x89, 0x4b, 0x38, 0xb9, 0x17, 0x70,
+	0x33, 0x1f, 0xfc, 0x73, 0x7d, 0x46, 0xff, 0xa4, 0x00, 0xb5, 0x36, 0x71, 0x09, 0x27, 0x77, 0x03,
-	0xb9, 0x82, 0x9b, 0x80, 0xba, 0xd4, 0xb4, 0x48, 0x87, 0x50, 0xc7, 0xb7, 0xf7, 0x88, 0xe5, 0x7b,
+	0x2e, 0x67, 0x70, 0x13, 0x50, 0x97, 0x9a, 0x16, 0xe9, 0x10, 0xea, 0xf8, 0xf6, 0x3e, 0xb1, 0x7c,
-	0x36, 0x93, 0x21, 0x9a, 0x35, 0xbe, 0x34, 0x1c, 0x34, 0xd0, 0xad, 0x31, 0x2e, 0x3e, 0x47, 0x03,
+	0xcf, 0x66, 0x72, 0x8b, 0x66, 0x8d, 0x2f, 0x0d, 0x07, 0x0d, 0x74, 0x6b, 0x8c, 0x8b, 0xcf, 0xd1,
-	0xb9, 0x50, 0x0b, 0xa8, 0xfc, 0xed, 0x70, 0x55, 0x40, 0x45, 0xe2, 0xbe, 0x93, 0x6f, 0xed, 0x9d,
+	0x40, 0x2e, 0xd4, 0x02, 0x2a, 0xbf, 0x1d, 0xae, 0x12, 0xa8, 0x08, 0xdc, 0xb7, 0xf2, 0xcd, 0xbd,
-	0xb4, 0xaa, 0xb1, 0x3c, 0x1c, 0x34, 0x6a, 0x19, 0x12, 0xce, 0x82, 0xa3, 0x1f, 0xc0, 0x92, 0x4f,
+	0x93, 0x56, 0x35, 0x96, 0x87, 0x83, 0x46, 0x2d, 0x43, 0xc2, 0x59, 0x70, 0xf4, 0x03, 0x58, 0xf2,
-	0x83, 0x43, 0xd3, 0x6b, 0x93, 0x80, 0x78, 0x36, 0xf1, 0x38, 0x93, 0x87, 0xa9, 0x6c, 0xac, 0x88,
+	0x69, 0x70, 0x64, 0x7a, 0x6d, 0x12, 0x10, 0xcf, 0x26, 0x1e, 0x67, 0xf2, 0x30, 0x95, 0x8d, 0x15,
-	0xb2, 0x77, 0x6f, 0x84, 0x87, 0xc7, 0xa4, 0xd1, 0x43, 0x58, 0x0e, 0xa8, 0x1f, 0x98, 0x5d, 0x53,
+	0x91, 0xf6, 0xee, 0x8e, 0xf0, 0xf0, 0x98, 0x34, 0x7a, 0x00, 0xcb, 0x01, 0xf5, 0x03, 0xb3, 0x6b,
-	0x20, 0x76, 0x7c, 0xd7, 0xb1, 0x4e, 0xe5, 0x61, 0xab, 0x18, 0x57, 0x87, 0x83, 0xc6, 0x72, 0x67,
+	0x0a, 0xc4, 0x8e, 0xef, 0x3a, 0xd6, 0xa9, 0x3c, 0x6c, 0x15, 0xe3, 0xea, 0x70, 0xd0, 0x58, 0xee,
-	0x94, 0x79, 0x36, 0x68, 0xbc, 0x22, 0xb7, 0x4e, 0x50, 0x12, 0x26, 0x1e, 0x87, 0xd1, 0x77, 0xa1,
+	0x8c, 0x32, 0xcf, 0x06, 0x8d, 0x97, 0xe4, 0xd2, 0x09, 0x4a, 0xc2, 0xc4, 0xe3, 0x30, 0xfa, 0x2e,
-	0xdc, 0xee, 0x53, 0x49, 0x41, 0xdf, 0x83, 0xb2, 0xad, 0x7e, 0xab, 0x5d, 0x7d, 0x2d, 0xea, 0x09,
+	0x94, 0xdb, 0x7d, 0x2a, 0x29, 0xe8, 0x7b, 0x50, 0xb6, 0xd5, 0xb7, 0x5a, 0xd5, 0x57, 0xa2, 0x9a,
-	0x91, 0xcc, 0xd9, 0xa0, 0x51, 0x13, 0xad, 0xaf, 0x19, 0x11, 0x70, 0xac, 0xa2, 0x3f, 0x82, 0xda,
+	0x10, 0xc9, 0x9c, 0x0d, 0x1a, 0x35, 0x51, 0xfa, 0x9a, 0x11, 0x01, 0xc7, 0x2a, 0xfa, 0x43, 0xa8,
-	0xce, 0x49, 0xe0, 0x53, 0x1e, 0xc5, 0xeb, 0x4d, 0x28, 0x11, 0x49, 0x90, 0x68, 0xe5, 0xa4, 0x90,
+	0xed, 0x3c, 0x0e, 0x7c, 0xca, 0xa3, 0xfd, 0x7a, 0x1d, 0x4a, 0x44, 0x12, 0x24, 0x5a, 0x39, 0x49,
-	0x85, 0x62, 0x58, 0x71, 0xd1, 0xeb, 0x50, 0x24, 0x27, 0xa6, 0xc5, 0x55, 0x45, 0xaa, 0x29, 0xb1,
+	0x64, 0xa1, 0x18, 0x56, 0x5c, 0xf4, 0x2a, 0x14, 0xc9, 0x63, 0xd3, 0xe2, 0x2a, 0x23, 0xd5, 0x94,
-	0xe2, 0x8e, 0x20, 0xe2, 0x90, 0xa7, 0x3f, 0xd3, 0x00, 0x6e, 0x91, 0x18, 0x7b, 0x0b, 0x16, 0xa3,
+	0x58, 0x71, 0x47, 0x10, 0x71, 0xc8, 0xd3, 0x9f, 0x6a, 0x00, 0xb7, 0x48, 0x8c, 0xbd, 0x05, 0x8b,
-	0x43, 0x91, 0x3d, 0xab, 0x5f, 0x56, 0xda, 0x8b, 0x38, 0xcb, 0xc6, 0xa3, 0xf2, 0xa8, 0x03, 0x2b,
+	0xd1, 0xa1, 0xc8, 0x9e, 0xd5, 0x2f, 0x2b, 0xed, 0x45, 0x9c, 0x65, 0xe3, 0x51, 0x79, 0xd4, 0x81,
-	0x8e, 0x67, 0xb9, 0x7d, 0x9b, 0xdc, 0xf7, 0x1c, 0xcf, 0xe1, 0x8e, 0xe9, 0x3a, 0xbf, 0x88, 0xeb,
+	0x15, 0xc7, 0xb3, 0xdc, 0xbe, 0x4d, 0xee, 0x79, 0x8e, 0xe7, 0x70, 0xc7, 0x74, 0x9d, 0x9f, 0xc7,
-	0xe2, 0x57, 0x14, 0xce, 0xca, 0xee, 0x39, 0x32, 0xf8, 0x5c, 0x4d, 0xfd, 0x11, 0x54, 0x64, 0x85,
+	0x79, 0xf1, 0x2b, 0x0a, 0x67, 0x65, 0xf7, 0x1c, 0x19, 0x7c, 0xae, 0xa6, 0xfe, 0x10, 0x2a, 0x32,
-	0x10, 0xc5, 0x51, 0xac, 0x4a, 0x16, 0x08, 0xe5, 0x57, 0xbc, 0x2a, 0x29, 0x81, 0x43, 0x5e, 0x5c,
+	0x43, 0x88, 0xe4, 0x28, 0x66, 0x25, 0x13, 0x84, 0xf2, 0x2b, 0x9e, 0x95, 0x94, 0xc0, 0x21, 0x2f,
-	0x5d, 0x0b, 0x93, 0xaa, 0x6b, 0xea, 0x40, 0xb8, 0x50, 0x0b, 0x75, 0xa3, 0x82, 0x9f, 0xcb, 0xc2,
+	0xce, 0xae, 0x85, 0x49, 0xd9, 0x35, 0x75, 0x20, 0x5c, 0xa8, 0x85, 0xba, 0x51, 0xc2, 0xcf, 0x65,
-	0x55, 0x28, 0x47, 0x0b, 0x57, 0x56, 0xe2, 0x46, 0x1f, 0x01, 0xe1, 0x58, 0x22, 0x65, 0xed, 0x10,
+	0xe1, 0x2a, 0x94, 0xa3, 0x89, 0x2b, 0x2b, 0x71, 0xa1, 0x8f, 0x80, 0x70, 0x2c, 0x91, 0xb2, 0x76,
-	0x32, 0xd5, 0x2e, 0x9f, 0xb1, 0xb7, 0xe0, 0x92, 0xaa, 0x37, 0xca, 0xd6, 0xa2, 0x12, 0xbb, 0x14,
+	0x04, 0x99, 0x6c, 0x97, 0xcf, 0xd8, 0x1b, 0x70, 0x49, 0xe5, 0x1b, 0x65, 0x6b, 0x51, 0x89, 0x5d,
-	0x45, 0x21, 0xe2, 0xa7, 0x2c, 0xfd, 0x12, 0xea, 0x93, 0xa6, 0x83, 0x97, 0xa8, 0xc7, 0xf9, 0x5d,
+	0x8a, 0x76, 0x21, 0xe2, 0xa7, 0x2c, 0xfd, 0x02, 0xea, 0x93, 0xba, 0x83, 0x17, 0xc8, 0xc7, 0xf9,
-	0xd1, 0x7f, 0xa7, 0xc1, 0x52, 0x1a, 0x29, 0x7f, 0xf8, 0xf2, 0x1b, 0xb9, 0xb8, 0x8f, 0xa6, 0x76,
+	0x5d, 0xd1, 0x7f, 0xab, 0xc1, 0x52, 0x1a, 0x29, 0xff, 0xf6, 0xe5, 0x37, 0x72, 0x71, 0x1d, 0x4d,
-	0xe4, 0xf7, 0x1a, 0xac, 0x64, 0x96, 0x36, 0x55, 0xc4, 0xa7, 0x70, 0x2a, 0x9d, 0x1c, 0xb3, 0x53,
+	0xad, 0xc8, 0xef, 0x35, 0x58, 0xc9, 0x4c, 0x6d, 0xaa, 0x1d, 0x9f, 0xc2, 0xa9, 0x74, 0x70, 0xcc,
-	0x24, 0x47, 0x0b, 0xaa, 0xbb, 0x71, 0xde, 0xd3, 0x8b, 0x27, 0x0f, 0xfd, 0x2f, 0x1a, 0xcc, 0xa7,
+	0x4e, 0x11, 0x1c, 0x2d, 0xa8, 0xee, 0xc6, 0x71, 0x4f, 0x2f, 0xee, 0x3c, 0xf4, 0xbf, 0x68, 0x30,
-	0x34, 0x18, 0x7a, 0x04, 0x97, 0x44, 0x7d, 0x73, 0xbc, 0xae, 0x9a, 0x8a, 0x72, 0x36, 0xcb, 0x14,
+	0x9f, 0xd2, 0x60, 0xe8, 0x21, 0x5c, 0x12, 0xf9, 0xcd, 0xf1, 0xba, 0xaa, 0x2b, 0xca, 0x59, 0x2c,
-	0x48, 0xb2, 0xae, 0x4e, 0x88, 0x84, 0x23, 0x48, 0xd4, 0x81, 0x12, 0x25, 0xac, 0xef, 0x72, 0x55,
+	0x53, 0x20, 0xc9, 0xbc, 0x3a, 0x21, 0x12, 0x8e, 0x20, 0x51, 0x07, 0x4a, 0x94, 0xb0, 0xbe, 0xcb,
-	0xda, 0xaf, 0xe6, 0x6c, 0x6b, 0xdc, 0xe4, 0x7d, 0x66, 0x80, 0xa8, 0x51, 0x58, 0xea, 0x63, 0x85,
+	0x55, 0x6a, 0xbf, 0x9a, 0xb3, 0xac, 0x71, 0x93, 0xf7, 0x99, 0x01, 0x22, 0x47, 0x61, 0xa9, 0x8f,
-	0xa3, 0xff, 0xbd, 0x00, 0xb5, 0xdb, 0xe6, 0x3e, 0x71, 0xf7, 0x88, 0x4b, 0x2c, 0xee, 0x53, 0xf4,
+	0x15, 0x8e, 0xfe, 0xf7, 0x02, 0xd4, 0x6e, 0x9b, 0x07, 0xc4, 0xdd, 0x27, 0x2e, 0xb1, 0xb8, 0x4f,
-	0x01, 0x54, 0x7b, 0x26, 0xb7, 0x0e, 0x25, 0x35, 0x9a, 0xed, 0xda, 0xf9, 0x0c, 0x65, 0x90, 0x9a,
+	0xd1, 0xfb, 0x50, 0xed, 0x99, 0xdc, 0x3a, 0x92, 0xd4, 0xa8, 0xb7, 0x6b, 0xe7, 0x33, 0x94, 0x41,
-	0x77, 0x12, 0x98, 0x1d, 0x8f, 0xd3, 0x53, 0xe3, 0x15, 0xb5, 0xb0, 0x6a, 0x8a, 0x83, 0xd3, 0xd6,
+	0x6a, 0xee, 0x25, 0x30, 0x3b, 0x1e, 0xa7, 0xa7, 0xc6, 0x4b, 0x6a, 0x62, 0xd5, 0x14, 0x07, 0xa7,
-	0xe4, 0x40, 0x2e, 0xbf, 0x77, 0x4e, 0x02, 0xd1, 0x44, 0xa7, 0xbf, 0x07, 0x64, 0x5c, 0xc0, 0xe4,
+	0xad, 0xc9, 0x86, 0x5c, 0x8e, 0x77, 0x1e, 0x07, 0xa2, 0x88, 0x4e, 0x7f, 0x0f, 0xc8, 0xb8, 0x80,
-	0xe7, 0x7d, 0x87, 0x92, 0x1e, 0xf1, 0x78, 0x32, 0x90, 0xdf, 0x19, 0xc1, 0xc7, 0x63, 0x16, 0x57,
+	0xc9, 0x7b, 0x7d, 0x87, 0x92, 0x1e, 0xf1, 0x78, 0xd2, 0x90, 0xef, 0x8d, 0xe0, 0xe3, 0x31, 0x8b,
-	0x6f, 0xc0, 0xd2, 0xa8, 0xf3, 0x68, 0x09, 0x66, 0x8f, 0xc8, 0x69, 0x98, 0x0b, 0x58, 0xfc, 0x44,
+	0xab, 0x37, 0x60, 0x69, 0xd4, 0x79, 0xb4, 0x04, 0xb3, 0xc7, 0xe4, 0x34, 0x8c, 0x05, 0x2c, 0x3e,
-	0x2b, 0x50, 0x3c, 0x36, 0xdd, 0xbe, 0xaa, 0x3f, 0x38, 0xfc, 0xb8, 0x5e, 0xb8, 0xa6, 0xe9, 0x7f,
+	0xd1, 0x0a, 0x14, 0x4f, 0x4c, 0xb7, 0xaf, 0xf2, 0x0f, 0x0e, 0x07, 0xd7, 0x0b, 0xd7, 0x34, 0xfd,
-	0xd4, 0xa0, 0x3e, 0xc9, 0x11, 0xf4, 0xd5, 0x14, 0x90, 0x51, 0x55, 0x5e, 0xcd, 0xbe, 0x47, 0x4e,
+	0x8f, 0x1a, 0xd4, 0x27, 0x39, 0x82, 0xbe, 0x9a, 0x02, 0x32, 0xaa, 0xca, 0xab, 0xd9, 0x77, 0xc8,
-	0x43, 0xd4, 0x1d, 0x28, 0xfb, 0x81, 0xb8, 0x42, 0xf9, 0x54, 0xe5, 0xf9, 0x5b, 0x51, 0xee, 0xde,
+	0x69, 0x88, 0xba, 0x03, 0x65, 0x3f, 0x10, 0x57, 0x28, 0x9f, 0xaa, 0x38, 0x7f, 0x23, 0x8a, 0xdd,
-	0x53, 0xf4, 0xb3, 0x41, 0xe3, 0x72, 0x06, 0x3e, 0x62, 0xe0, 0x58, 0x15, 0xe9, 0x50, 0x92, 0xfe,
+	0xbb, 0x8a, 0x7e, 0x36, 0x68, 0x5c, 0xce, 0xc0, 0x47, 0x0c, 0x1c, 0xab, 0x22, 0x1d, 0x4a, 0xd2,
-	0x88, 0xa6, 0x2c, 0xc6, 0x27, 0x19, 0xfc, 0x07, 0x92, 0x82, 0x15, 0x47, 0xff, 0x00, 0xca, 0x62,
+	0x1f, 0x51, 0x94, 0x45, 0xfb, 0x24, 0x37, 0xff, 0xbe, 0xa4, 0x60, 0xc5, 0xd1, 0xdf, 0x87, 0xb2,
-	0x3a, 0xbc, 0x43, 0xb8, 0x29, 0x8e, 0x0c, 0x23, 0xee, 0xc1, 0x6d, 0xc7, 0x3b, 0x52, 0xae, 0xc5,
+	0xe8, 0x0e, 0xf7, 0x08, 0x37, 0xc5, 0x91, 0x61, 0xc4, 0x3d, 0xbc, 0xed, 0x78, 0xc7, 0xca, 0xb5,
-	0x47, 0x66, 0x4f, 0xd1, 0x71, 0x2c, 0x71, 0x5e, 0x9b, 0x2a, 0x4c, 0xd7, 0xa6, 0xf4, 0xff, 0x16,
+	0xf8, 0xc8, 0xec, 0x2b, 0x3a, 0x8e, 0x25, 0xce, 0x2b, 0x53, 0x85, 0xe9, 0xca, 0x94, 0xfe, 0xdf,
-	0xa0, 0x2a, 0xac, 0x47, 0x9d, 0xef, 0x3b, 0x50, 0x73, 0xd3, 0x6b, 0x52, 0x5e, 0x5c, 0x56, 0x80,
+	0x02, 0x54, 0x85, 0xf5, 0xa8, 0xf2, 0x7d, 0x07, 0x6a, 0x6e, 0x7a, 0x4e, 0xca, 0x8b, 0xcb, 0x0a,
-	0xd9, 0x2c, 0xc5, 0x59, 0x59, 0xa1, 0x7c, 0xe0, 0x10, 0xd7, 0x8e, 0x95, 0x0b, 0x59, 0xe5, 0x9b,
+	0x30, 0x1b, 0xa5, 0x38, 0x2b, 0x2b, 0x94, 0x0f, 0x1d, 0xe2, 0xda, 0xb1, 0x72, 0x21, 0xab, 0x7c,
-	0x69, 0x26, 0xce, 0xca, 0x8a, 0xea, 0xf3, 0x58, 0x44, 0x5b, 0x8d, 0x2f, 0x71, 0xf5, 0xf9, 0xa1,
+	0x33, 0xcd, 0xc4, 0x59, 0x59, 0x91, 0x7d, 0x1e, 0x89, 0xdd, 0x56, 0xed, 0x4b, 0x9c, 0x7d, 0x7e,
-	0x20, 0xe2, 0x90, 0x77, 0xde, 0x8a, 0xe7, 0xa6, 0x6c, 0xcc, 0xd7, 0x61, 0x41, 0xcc, 0x18, 0x7e,
+	0x28, 0x88, 0x38, 0xe4, 0x9d, 0x37, 0xe3, 0xb9, 0x29, 0x0b, 0xf3, 0x75, 0x58, 0x10, 0x3d, 0x86,
-	0x9f, 0x47, 0x33, 0x5e, 0x51, 0x4e, 0x23, 0x68, 0x38, 0x68, 0x2c, 0xbc, 0x9f, 0xe1, 0xe0, 0x11,
+	0xdf, 0xe7, 0x51, 0x8f, 0x57, 0x94, 0xdd, 0x08, 0x1a, 0x0e, 0x1a, 0x0b, 0xef, 0x66, 0x38, 0x78,
-	0xc9, 0x89, 0x4d, 0xbd, 0xf4, 0xb9, 0x9b, 0xfa, 0xbf, 0x01, 0xe0, 0xde, 0xfe, 0xcf, 0x88, 0x15,
+	0x44, 0x72, 0x62, 0x51, 0x2f, 0x7d, 0xe6, 0xa2, 0xfe, 0x1e, 0x54, 0xf6, 0x1c, 0x8b, 0xfa, 0xc2,
-	0xc6, 0xff, 0xe2, 0x5b, 0x96, 0xe8, 0x59, 0xea, 0x72, 0x2f, 0x6f, 0x24, 0x85, 0x91, 0x9e, 0x95,
+	0xb0, 0xc8, 0xad, 0x2c, 0xd3, 0x77, 0xc6, 0x39, 0x28, 0x72, 0x28, 0xe2, 0x8b, 0xd5, 0xf2, 0x4c,
-	0xe2, 0xe1, 0x8c, 0x24, 0x6a, 0x41, 0x25, 0xbe, 0x79, 0xa9, 0x7a, 0xbc, 0xac, 0xd4, 0x2a, 0xf1,
+	0xcf, 0x0f, 0xbb, 0xcb, 0x62, 0xb2, 0x5a, 0x77, 0x04, 0x11, 0x87, 0xbc, 0xeb, 0x2b, 0x22, 0xa5,
-	0xf5, 0x0c, 0x27, 0x32, 0x99, 0x64, 0x9c, 0xbb, 0x30, 0x19, 0x0d, 0x98, 0xed, 0x3b, 0xb6, 0xdc,
+	0xfe, 0xfa, 0x69, 0x63, 0xe6, 0xc9, 0xd3, 0xc6, 0xcc, 0x87, 0x4f, 0x55, 0x7a, 0xfd, 0x37, 0x00,
-	0xcc, 0x8a, 0xf1, 0x8d, 0xe8, 0x40, 0xdd, 0xdf, 0x6d, 0x9f, 0x0d, 0x1a, 0xaf, 0x4d, 0x7a, 0xb3,
+	0xdc, 0x3d, 0xf8, 0x19, 0xb1, 0xc2, 0x90, 0xbb, 0xf8, 0x62, 0x27, 0xca, 0xa4, 0x7a, 0x4f, 0x90,
-	0xe0, 0xa7, 0x01, 0x61, 0xcd, 0xfb, 0xbb, 0x6d, 0x2c, 0x94, 0xcf, 0x0b, 0x6f, 0x69, 0xca, 0xf0,
+	0x97, 0xa0, 0xc2, 0x48, 0x99, 0x4c, 0xf1, 0x70, 0x46, 0x12, 0xb5, 0xa0, 0x12, 0x5f, 0xf6, 0x54,
-	0x6e, 0x02, 0xa8, 0x55, 0x0b, 0xed, 0x4b, 0x61, 0x68, 0xa3, 0x5b, 0xe8, 0xad, 0x98, 0x83, 0x53,
+	0x09, 0x58, 0x56, 0x6a, 0x95, 0xf8, 0x46, 0x88, 0x13, 0x99, 0x4c, 0xfc, 0xcf, 0x5d, 0x18, 0xff,
-	0x52, 0x88, 0xc1, 0xb2, 0x45, 0x89, 0xfc, 0x2d, 0x12, 0x80, 0x71, 0xb3, 0x17, 0xd4, 0xcb, 0xb2,
+	0x06, 0xcc, 0xf6, 0x1d, 0x5b, 0xee, 0x5f, 0xc5, 0xf8, 0x46, 0x74, 0x86, 0xef, 0xed, 0xb6, 0xcf,
-	0xb6, 0x7f, 0x2d, 0x5f, 0xbd, 0x13, 0x6a, 0xc6, 0xab, 0xca, 0xcc, 0xf2, 0xf6, 0x28, 0x18, 0x1e,
+	0x06, 0x8d, 0x57, 0x26, 0x3d, 0x93, 0xf0, 0xd3, 0x80, 0xb0, 0xe6, 0xbd, 0xdd, 0x36, 0x16, 0xca,
-	0xc7, 0x47, 0x3e, 0x2c, 0xdb, 0x6a, 0x8a, 0x4e, 0x8c, 0x56, 0xa6, 0x36, 0x7a, 0x59, 0x18, 0x6c,
+	0xe7, 0x45, 0x54, 0x69, 0xca, 0x88, 0xda, 0x04, 0x50, 0xb3, 0x16, 0xda, 0x97, 0xc2, 0x68, 0x8a,
-	0x8f, 0x02, 0xe1, 0x71, 0x6c, 0xf4, 0x13, 0x58, 0x8d, 0x88, 0xe3, 0x57, 0x99, 0x3a, 0xc8, 0x9d,
+	0x2e, 0xbe, 0xb7, 0x62, 0x0e, 0x4e, 0x49, 0x21, 0x06, 0xcb, 0x16, 0x25, 0xf2, 0x5b, 0x6c, 0x3d,
-	0x5a, 0x13, 0x97, 0xab, 0xf6, 0x44, 0x29, 0xfc, 0x19, 0x08, 0xc8, 0x86, 0x92, 0x1b, 0x76, 0xab,
+	0xe3, 0x66, 0x2f, 0xa8, 0x97, 0x65, 0x39, 0xf9, 0x5a, 0xbe, 0x14, 0x2b, 0xd4, 0x8c, 0x97, 0x95,
-	0xaa, 0x6c, 0x15, 0xdf, 0xcd, 0xb7, 0x8a, 0x24, 0xfb, 0x9b, 0xe9, 0x2e, 0x15, 0x8f, 0xf3, 0xaa,
+	0x99, 0xe5, 0xed, 0x51, 0x30, 0x3c, 0x8e, 0x8f, 0x7c, 0x58, 0xb6, 0x55, 0xe3, 0x9e, 0x18, 0xad,
-	0x41, 0x29, 0x6c, 0x74, 0x02, 0x55, 0xd3, 0xf3, 0x7c, 0x6e, 0x86, 0x97, 0xab, 0x79, 0x69, 0x6a,
+	0x4c, 0x6d, 0xf4, 0xb2, 0x30, 0xd8, 0x1e, 0x05, 0xc2, 0xe3, 0xd8, 0xe8, 0x27, 0xb0, 0x1a, 0x11,
-	0x6b, 0x6a, 0x53, 0x5b, 0x09, 0xc6, 0x48, 0x57, 0x4c, 0x71, 0x70, 0xda, 0x14, 0x7a, 0x0c, 0x8b,
+	0xc7, 0x6f, 0x4f, 0x75, 0x90, 0x2b, 0xb5, 0x26, 0xee, 0x73, 0xed, 0x89, 0x52, 0xf8, 0x53, 0x10,
-	0xfe, 0x63, 0x8f, 0x50, 0x4c, 0x0e, 0x08, 0x25, 0x9e, 0xb8, 0x89, 0xd7, 0xa4, 0xf5, 0x6f, 0xe6,
+	0x90, 0x0d, 0x25, 0x37, 0x2c, 0x90, 0x55, 0x59, 0x9d, 0xbe, 0x9b, 0x6f, 0x16, 0x49, 0xf4, 0x37,
-	0xb4, 0x9e, 0x51, 0x4e, 0x52, 0x3a, 0x4b, 0x67, 0x78, 0xd4, 0x0a, 0x6a, 0x02, 0x1c, 0x38, 0x9e,
+	0xd3, 0x85, 0x31, 0xbe, 0x41, 0xa8, 0x9a, 0xa8, 0xb0, 0xd1, 0x63, 0xa8, 0x9a, 0x9e, 0xe7, 0x73,
-	0x9a, 0x6d, 0xea, 0x0b, 0xc9, 0xa3, 0xc5, 0xcd, 0x98, 0x8a, 0x53, 0x12, 0xe8, 0x5b, 0x50, 0xb5,
+	0x33, 0xbc, 0xcf, 0xcd, 0x4b, 0x53, 0x5b, 0x53, 0x9b, 0xda, 0x4a, 0x30, 0x46, 0x0a, 0x71, 0x8a,
-	0xdc, 0x3e, 0xe3, 0x24, 0x7c, 0xb3, 0x58, 0x94, 0x27, 0x28, 0x5e, 0xdf, 0x76, 0xc2, 0xc2, 0x69,
+	0x83, 0xd3, 0xa6, 0xd0, 0x23, 0x58, 0xf4, 0x1f, 0x79, 0x84, 0x62, 0x72, 0x48, 0x28, 0xf1, 0xc4,
-	0x39, 0x74, 0x08, 0xf3, 0x4e, 0x6a, 0x88, 0xaa, 0x2f, 0xc9, 0x5c, 0xdc, 0x9c, 0x7a, 0x72, 0x62,
+	0xe5, 0xbf, 0x26, 0xad, 0x7f, 0x33, 0xa7, 0xf5, 0x8c, 0x72, 0x12, 0xd2, 0x59, 0x3a, 0xc3, 0xa3,
-	0xc6, 0x92, 0xa8, 0x44, 0x69, 0x0a, 0xce, 0x20, 0xaf, 0x7e, 0x1b, 0xaa, 0x9f, 0xb3, 0xa7, 0x8b,
+	0x56, 0x50, 0x13, 0xe0, 0xd0, 0xf1, 0x54, 0x3b, 0x55, 0x5f, 0x48, 0xde, 0x49, 0x6e, 0xc6, 0x54,
-	0x99, 0x60, 0x34, 0x74, 0x53, 0xcd, 0x04, 0x7f, 0x2d, 0xc0, 0x42, 0x76, 0xc3, 0xe3, 0xd9, 0x59,
+	0x9c, 0x92, 0x40, 0xdf, 0x82, 0xaa, 0xe5, 0xf6, 0x19, 0x27, 0xe1, 0x33, 0xc9, 0xa2, 0x3c, 0x41,
-	0x9b, 0xf8, 0x06, 0x15, 0x55, 0xe5, 0xd9, 0x89, 0x55, 0x59, 0x15, 0xbf, 0xb9, 0x97, 0x29, 0x7e,
+	0xf1, 0xfc, 0xb6, 0x13, 0x16, 0x4e, 0xcb, 0xa1, 0x23, 0x98, 0x77, 0x52, 0x7d, 0x5b, 0x7d, 0x49,
-	0x9b, 0x00, 0x66, 0xe0, 0x44, 0x75, 0x2f, 0xac, 0xa3, 0x71, 0xe5, 0x4a, 0x5e, 0x65, 0x70, 0x4a,
+	0xc6, 0xe2, 0xe6, 0xd4, 0xcd, 0x1a, 0x33, 0x96, 0x44, 0x26, 0x4a, 0x53, 0x70, 0x06, 0x79, 0xf5,
-	0x4a, 0xa4, 0x86, 0xe5, 0x7b, 0x9c, 0xfa, 0xae, 0x4b, 0xa8, 0x6a, 0x43, 0x32, 0x35, 0xb6, 0x63,
+	0xdb, 0x50, 0xfd, 0x8c, 0x6d, 0x84, 0x68, 0x43, 0x46, 0xb7, 0x6e, 0xaa, 0x36, 0xe4, 0xaf, 0x05,
-	0x2a, 0x4e, 0x49, 0xa0, 0x9b, 0x80, 0xf6, 0x5d, 0xdf, 0x3a, 0x92, 0x5b, 0x10, 0x9d, 0x73, 0x59,
+	0x58, 0xc8, 0x2e, 0x78, 0xdc, 0xae, 0x6b, 0x13, 0x9f, 0xbd, 0xa2, 0xac, 0x3c, 0x3b, 0x31, 0x2b,
-	0x25, 0xcb, 0xe1, 0x23, 0x87, 0x31, 0xc6, 0xc5, 0xe7, 0x68, 0xe8, 0xf7, 0x20, 0xfb, 0x2c, 0x81,
+	0xab, 0xe4, 0x37, 0xf7, 0x22, 0xc9, 0x6f, 0x13, 0xc0, 0x0c, 0x9c, 0x28, 0xef, 0x85, 0x79, 0x34,
-	0x6e, 0x84, 0x1b, 0xa0, 0xc5, 0xef, 0x06, 0xd3, 0x2d, 0x5e, 0xbf, 0x0a, 0x15, 0xec, 0xfb, 0xbc,
+	0xce, 0x5c, 0xc9, 0x43, 0x10, 0x4e, 0x49, 0x89, 0xd0, 0xb0, 0x7c, 0x8f, 0x53, 0xdf, 0x75, 0x09,
-	0x63, 0xf2, 0x43, 0x86, 0x1a, 0x50, 0x0c, 0xc4, 0x0f, 0xf5, 0xe6, 0x24, 0x9f, 0xf1, 0x24, 0x07,
+	0x55, 0x95, 0x4f, 0x86, 0xc6, 0x76, 0x4c, 0xc5, 0x29, 0x09, 0x74, 0x13, 0xd0, 0x81, 0xeb, 0x5b,
-	0x87, 0x74, 0xfd, 0xb7, 0x1a, 0xbc, 0x3a, 0xf1, 0x09, 0x48, 0x6c, 0xa4, 0x15, 0x7f, 0x29, 0x97,
+	0xc7, 0x72, 0x09, 0xa2, 0x73, 0x2e, 0xb3, 0x64, 0x39, 0x7c, 0x57, 0x31, 0xc6, 0xb8, 0xf8, 0x1c,
-	0xe2, 0x8d, 0x4c, 0xe4, 0x70, 0x4a, 0x4a, 0x8c, 0x2e, 0x99, 0x77, 0xa3, 0xd1, 0xd1, 0x25, 0x63,
+	0x0d, 0xfd, 0x2e, 0x64, 0x5f, 0x42, 0xd0, 0x8d, 0x70, 0x01, 0xb4, 0xf8, 0xa9, 0x62, 0xba, 0xc9,
-	0x0d, 0x67, 0x65, 0xf5, 0xff, 0x14, 0xa0, 0x14, 0x4e, 0xf7, 0xe8, 0x11, 0x94, 0xc5, 0x91, 0xb0,
+	0xeb, 0x57, 0xa1, 0x82, 0x7d, 0x9f, 0x77, 0x4c, 0x7e, 0xc4, 0x50, 0x03, 0x8a, 0x81, 0xf8, 0x50,
-	0x4d, 0x6e, 0x4a, 0xcb, 0xb9, 0x1f, 0x64, 0xa3, 0x11, 0x30, 0xe9, 0xb1, 0x11, 0x05, 0xc7, 0x88,
+	0xcf, 0x5c, 0xf2, 0xe5, 0x50, 0x72, 0x70, 0x48, 0xd7, 0x7f, 0xa3, 0xc1, 0xcb, 0x13, 0x5f, 0x9d,
-	0xe8, 0x4d, 0x28, 0x31, 0x69, 0x47, 0xb9, 0x17, 0x17, 0xc9, 0xd0, 0x3a, 0x56, 0x5c, 0x71, 0x49,
+	0xc4, 0x42, 0x5a, 0xf1, 0x48, 0xb9, 0x14, 0x2f, 0x64, 0x22, 0x87, 0x53, 0x52, 0xa2, 0x5b, 0xca,
-	0xeb, 0x11, 0xc6, 0xcc, 0x6e, 0x94, 0xb3, 0xf1, 0x65, 0xe6, 0x4e, 0x48, 0xc6, 0x11, 0x1f, 0xbd,
+	0x3c, 0x55, 0x8d, 0x76, 0x4b, 0x19, 0x6b, 0x38, 0x2b, 0xab, 0xff, 0xa7, 0x00, 0xa5, 0xf0, 0x42,
-	0x2b, 0x2e, 0x33, 0x26, 0x8b, 0x07, 0xa9, 0xb5, 0x08, 0x12, 0x4b, 0xea, 0xd9, 0xa0, 0x31, 0xaf,
+	0x81, 0x1e, 0x42, 0x59, 0x1c, 0x09, 0xdb, 0xe4, 0xa6, 0xb4, 0x9c, 0xfb, 0x0d, 0x38, 0xea, 0x3a,
-	0xc0, 0xe5, 0x37, 0x56, 0xd2, 0xe8, 0x21, 0x5c, 0xb2, 0x09, 0x37, 0x1d, 0x37, 0x9c, 0x9f, 0x72,
+	0x93, 0x1a, 0x1b, 0x51, 0x70, 0x8c, 0x88, 0x5e, 0x87, 0x12, 0x93, 0x76, 0x94, 0x7b, 0x71, 0x92,
-	0x3f, 0x70, 0x85, 0x60, 0xed, 0x50, 0xd5, 0xa8, 0x0a, 0x9f, 0xd4, 0x07, 0x8e, 0x00, 0xc5, 0x79,
+	0x0c, 0xad, 0x63, 0xc5, 0x15, 0xbd, 0x4b, 0x8f, 0x30, 0x66, 0x76, 0xa3, 0x98, 0x8d, 0x7b, 0x97,
-	0xb3, 0x7c, 0x3b, 0x7c, 0x6d, 0x2d, 0x26, 0xe7, 0x6d, 0xdb, 0xb7, 0x09, 0x96, 0x1c, 0xfd, 0x89,
+	0xbd, 0x90, 0x8c, 0x23, 0x3e, 0x7a, 0x5b, 0xdc, 0x9f, 0x4c, 0x16, 0xf7, 0x6e, 0x6b, 0x11, 0x24,
-	0x06, 0xd5, 0x10, 0x69, 0xdb, 0xec, 0x33, 0x82, 0x36, 0xe2, 0x55, 0x84, 0xe1, 0x8e, 0x5a, 0xf1,
+	0x96, 0xd4, 0xb3, 0x41, 0x63, 0x5e, 0x81, 0xcb, 0x31, 0x56, 0xd2, 0xe8, 0x01, 0x5c, 0xb2, 0x09,
-	0xdc, 0xfb, 0xa7, 0x01, 0x39, 0x1b, 0x34, 0x2a, 0x52, 0x4c, 0x7c, 0xc4, 0x0b, 0x48, 0xed, 0x51,
+	0x37, 0x1d, 0x37, 0x6c, 0xd9, 0x72, 0xbf, 0xa9, 0x85, 0x60, 0xed, 0x50, 0xd5, 0xa8, 0x0a, 0x9f,
-	0xe1, 0x82, 0x3d, 0x7a, 0x1d, 0x8a, 0x72, 0x56, 0x55, 0x9b, 0x19, 0x8f, 0xa6, 0x72, 0x9e, 0xc5,
+	0xd4, 0x00, 0x47, 0x80, 0xe2, 0xbc, 0x59, 0xbe, 0x1d, 0x3e, 0xf0, 0x16, 0x93, 0xf3, 0xb6, 0xed,
-	0x21, 0x4f, 0xff, 0xa4, 0x00, 0xb5, 0xcc, 0xe2, 0x72, 0x0c, 0x73, 0xf1, 0x8d, 0xbb, 0x90, 0xe3,
+	0xdb, 0x04, 0x4b, 0x8e, 0xfe, 0x44, 0x83, 0x6a, 0x88, 0xb4, 0x6d, 0xf6, 0x19, 0x41, 0x1b, 0xf1,
-	0x15, 0x67, 0xf2, 0x1b, 0xf9, 0x8f, 0xa0, 0x64, 0x89, 0xf5, 0x45, 0xff, 0xa4, 0xd8, 0x98, 0x26,
+	0x2c, 0xc2, 0xed, 0x8e, 0x4a, 0xf1, 0xdc, 0xbb, 0xa7, 0x01, 0x39, 0x1b, 0x34, 0x2a, 0x52, 0x4c,
-	0x14, 0x72, 0x67, 0x92, 0x4c, 0x92, 0x9f, 0x0c, 0x2b, 0x40, 0x74, 0x0b, 0x96, 0x29, 0xe1, 0xf4,
+	0x0c, 0xe2, 0x09, 0xa4, 0xd6, 0xa8, 0x70, 0xc1, 0x1a, 0xbd, 0x0a, 0x45, 0xd9, 0x1e, 0xab, 0xc5,
-	0x74, 0xeb, 0x80, 0x13, 0x9a, 0x1e, 0x98, 0x8b, 0xc9, 0xb8, 0x83, 0x47, 0x05, 0xf0, 0xb8, 0x4e,
+	0x8c, 0xfb, 0x3b, 0xd9, 0x42, 0xe3, 0x90, 0xa7, 0x7f, 0x5c, 0x80, 0x5a, 0x66, 0x72, 0x39, 0x9a,
-	0x54, 0x21, 0x4b, 0x2f, 0x51, 0x21, 0x75, 0x17, 0xe6, 0xc4, 0x38, 0x23, 0x42, 0xc7, 0x32, 0xef,
+	0xb9, 0xf8, 0x92, 0x5f, 0xc8, 0xf1, 0x70, 0x34, 0xf9, 0x59, 0xfe, 0x47, 0x50, 0xb2, 0xc4, 0xfc,
-	0xb3, 0x71, 0xe8, 0x22, 0x07, 0x22, 0xbe, 0xd8, 0x61, 0xcf, 0xf4, 0xfc, 0xf0, 0xc0, 0x14, 0x93,
+	0xa2, 0xff, 0x45, 0x36, 0xa6, 0xd9, 0x0a, 0xb9, 0x32, 0x49, 0x24, 0xc9, 0x21, 0xc3, 0x0a, 0x10,
-	0x1d, 0xbe, 0x2b, 0x88, 0x38, 0xe4, 0x5d, 0x5f, 0xf9, 0xe8, 0x69, 0x63, 0xe6, 0x37, 0xcf, 0x1a,
+	0xdd, 0x82, 0x65, 0x4a, 0x38, 0x3d, 0xdd, 0x3a, 0xe4, 0x84, 0xa6, 0x7b, 0xf4, 0x62, 0xd2, 0xee,
-	0x33, 0x4f, 0x9e, 0x35, 0x66, 0x9e, 0x3e, 0x53, 0xcf, 0x10, 0x3f, 0x86, 0x4a, 0x32, 0x3c, 0x7d,
+	0xe0, 0x51, 0x01, 0x3c, 0xae, 0x13, 0x65, 0xc8, 0xd2, 0x0b, 0x64, 0x48, 0xdd, 0x85, 0xb9, 0xff,
-	0xc1, 0x26, 0xf5, 0x9f, 0x42, 0x59, 0x64, 0x63, 0x34, 0xf4, 0x5f, 0xd0, 0x80, 0xb2, 0xad, 0xa1,
+	0x63, 0x6b, 0xfe, 0x63, 0xa8, 0x24, 0xcd, 0xd3, 0xe7, 0x6c, 0x52, 0xff, 0x29, 0x94, 0x45, 0x34,
-	0x90, 0xa7, 0x35, 0xe8, 0x9b, 0x10, 0xfe, 0xeb, 0x43, 0x54, 0x53, 0x87, 0x93, 0x5e, 0xa6, 0x9a,
+	0x46, 0x4d, 0xff, 0x05, 0x05, 0x28, 0x5b, 0x1a, 0x0a, 0x79, 0x4a, 0x83, 0xbe, 0x09, 0xe1, 0xbf,
-	0xee, 0x0a, 0x02, 0x0e, 0xe9, 0xa9, 0x97, 0x97, 0x5f, 0x6b, 0x00, 0xf2, 0xbe, 0xb5, 0x73, 0x2c,
+	0x2d, 0x22, 0x9b, 0x3a, 0x9c, 0xf4, 0x32, 0xd9, 0x74, 0x57, 0x10, 0x70, 0x48, 0x4f, 0x3d, 0xf6,
-	0xee, 0xc8, 0xeb, 0x30, 0x27, 0x22, 0x30, 0xea, 0x98, 0x3c, 0x46, 0x92, 0x83, 0xee, 0x43, 0xc9,
+	0xfc, 0x4a, 0x03, 0x90, 0x57, 0xbc, 0x9d, 0x13, 0x71, 0x2d, 0x5f, 0x87, 0x39, 0xb1, 0x03, 0xa3,
-	0x97, 0x43, 0x95, 0x7a, 0x0a, 0x79, 0x7b, 0x62, 0xe6, 0xa9, 0xff, 0x6a, 0x36, 0xb1, 0xf9, 0x78,
+	0x8e, 0xc9, 0x63, 0x24, 0x39, 0xe8, 0x1e, 0x94, 0x7c, 0xd9, 0x54, 0xa9, 0xd7, 0x97, 0x37, 0x27,
-	0xe7, 0x84, 0x13, 0x4f, 0xf8, 0x98, 0x64, 0x5d, 0x38, 0x99, 0x61, 0x05, 0x66, 0xbc, 0xf1, 0xfc,
+	0x46, 0x9e, 0xfa, 0x23, 0xb5, 0x89, 0xcd, 0x47, 0x3b, 0x8f, 0x39, 0xf1, 0x84, 0x8f, 0x49, 0xd4,
-	0xc5, 0xda, 0xcc, 0xc7, 0x2f, 0xd6, 0x66, 0xfe, 0xf1, 0x62, 0x6d, 0xe6, 0xc3, 0xe1, 0x9a, 0xf6,
+	0x85, 0x9d, 0x19, 0x56, 0x60, 0xc6, 0x6b, 0xcf, 0x9e, 0xaf, 0xcd, 0x7c, 0xf4, 0x7c, 0x6d, 0xe6,
-	0x7c, 0xb8, 0xa6, 0x7d, 0x3c, 0x5c, 0xd3, 0x3e, 0x19, 0xae, 0x69, 0x4f, 0x3e, 0x5d, 0x9b, 0x79,
+	0x1f, 0xcf, 0xd7, 0x66, 0x3e, 0x18, 0xae, 0x69, 0xcf, 0x86, 0x6b, 0xda, 0x47, 0xc3, 0x35, 0xed,
-	0x58, 0x38, 0xde, 0xf8, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x0e, 0xfb, 0x43, 0x17, 0x1e,
+	0xe3, 0xe1, 0x9a, 0xf6, 0xe4, 0x93, 0xb5, 0x99, 0x07, 0x85, 0x93, 0x8d, 0xff, 0x05, 0x00, 0x00,
-	0x00, 0x00,
+	0xff, 0xff, 0x03, 0x37, 0xed, 0x6d, 0x8a, 0x1e, 0x00, 0x00,
 }

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto

@@ -342,6 +342,24 @@ message ListOptions {
   optional int64 timeoutSeconds = 5;
 }
 
+// MicroTime is version of Time with microsecond level precision.
+// 
+// +protobuf.options.marshal=false
+// +protobuf.as=Timestamp
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+message MicroTime {
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  optional int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive. This field may be limited in precision depending on context.
+  optional int32 nanos = 2;
+}
+
 // ObjectMeta is metadata that all persisted resources must have, which includes all objects
 // users must create.
 message ObjectMeta {

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time.go

@@ -0,0 +1,184 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	"encoding/json"
+	"time"
+
+	"k8s.io/apimachinery/pkg/openapi"
+
+	"github.com/go-openapi/spec"
+	"github.com/google/gofuzz"
+)
+
+const RFC3339Micro = "2006-01-02T15:04:05.000000Z07:00"
+
+// MicroTime is version of Time with microsecond level precision.
+//
+// +protobuf.options.marshal=false
+// +protobuf.as=Timestamp
+// +protobuf.options.(gogoproto.goproto_stringer)=false
+type MicroTime struct {
+	time.Time `protobuf:"-"`
+}
+
+// DeepCopy returns a deep-copy of the MicroTime value.  The underlying time.Time
+// type is effectively immutable in the time API, so it is safe to
+// copy-by-assign, despite the presence of (unexported) Pointer fields.
+func (t MicroTime) DeepCopy() MicroTime {
+	return t
+}
+
+// String returns the representation of the time.
+func (t MicroTime) String() string {
+	return t.Time.String()
+}
+
+// NewMicroTime returns a wrapped instance of the provided time
+func NewMicroTime(time time.Time) MicroTime {
+	return MicroTime{time}
+}
+
+// DateMicro returns the MicroTime corresponding to the supplied parameters
+// by wrapping time.Date.
+func DateMicro(year int, month time.Month, day, hour, min, sec, nsec int, loc *time.Location) MicroTime {
+	return MicroTime{time.Date(year, month, day, hour, min, sec, nsec, loc)}
+}
+
+// NowMicro returns the current local time.
+func NowMicro() MicroTime {
+	return MicroTime{time.Now()}
+}
+
+// IsZero returns true if the value is nil or time is zero.
+func (t *MicroTime) IsZero() bool {
+	if t == nil {
+		return true
+	}
+	return t.Time.IsZero()
+}
+
+// Before reports whether the time instant t is before u.
+func (t MicroTime) Before(u MicroTime) bool {
+	return t.Time.Before(u.Time)
+}
+
+// Equal reports whether the time instant t is equal to u.
+func (t MicroTime) Equal(u MicroTime) bool {
+	return t.Time.Equal(u.Time)
+}
+
+// BeforeTime reports whether the time instant t is before second-lever precision u.
+func (t MicroTime) BeforeTime(u Time) bool {
+	return t.Time.Before(u.Time)
+}
+
+// EqualTime reports whether the time instant t is equal to second-lever precision u.
+func (t MicroTime) EqualTime(u Time) bool {
+	return t.Time.Equal(u.Time)
+}
+
+// UnixMicro returns the local time corresponding to the given Unix time
+// by wrapping time.Unix.
+func UnixMicro(sec int64, nsec int64) MicroTime {
+	return MicroTime{time.Unix(sec, nsec)}
+}
+
+// UnmarshalJSON implements the json.Unmarshaller interface.
+func (t *MicroTime) UnmarshalJSON(b []byte) error {
+	if len(b) == 4 && string(b) == "null" {
+		t.Time = time.Time{}
+		return nil
+	}
+
+	var str string
+	json.Unmarshal(b, &str)
+
+	pt, err := time.Parse(RFC3339Micro, str)
+	if err != nil {
+		return err
+	}
+
+	t.Time = pt.Local()
+	return nil
+}
+
+// UnmarshalQueryParameter converts from a URL query parameter value to an object
+func (t *MicroTime) UnmarshalQueryParameter(str string) error {
+	if len(str) == 0 {
+		t.Time = time.Time{}
+		return nil
+	}
+	// Tolerate requests from older clients that used JSON serialization to build query params
+	if len(str) == 4 && str == "null" {
+		t.Time = time.Time{}
+		return nil
+	}
+
+	pt, err := time.Parse(RFC3339Micro, str)
+	if err != nil {
+		return err
+	}
+
+	t.Time = pt.Local()
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (t MicroTime) MarshalJSON() ([]byte, error) {
+	if t.IsZero() {
+		// Encode unset/nil objects as JSON's "null".
+		return []byte("null"), nil
+	}
+
+	return json.Marshal(t.UTC().Format(RFC3339Micro))
+}
+
+func (_ MicroTime) OpenAPIDefinition() openapi.OpenAPIDefinition {
+	return openapi.OpenAPIDefinition{
+		Schema: spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{"string"},
+				Format: "date-time",
+			},
+		},
+	}
+}
+
+// MarshalQueryParameter converts to a URL query parameter value
+func (t MicroTime) MarshalQueryParameter() (string, error) {
+	if t.IsZero() {
+		// Encode unset/nil objects as an empty string
+		return "", nil
+	}
+
+	return t.UTC().Format(RFC3339Micro), nil
+}
+
+// Fuzz satisfies fuzz.Interface.
+func (t *MicroTime) Fuzz(c fuzz.Continue) {
+	if t == nil {
+		return
+	}
+	// Allow for about 1000 years of randomness.  Leave off nanoseconds
+	// because JSON doesn't represent them so they can't round-trip
+	// properly.
+	t.Time = time.Unix(c.Rand.Int63n(1000*365*24*60*60*1000*1000), 0)
+}
+
+var _ fuzz.Interface = &MicroTime{}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_proto.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	"time"
+)
+
+// Timestamp is declared in time_proto.go
+
+// Timestamp returns the Time as a new Timestamp value.
+func (m *MicroTime) ProtoMicroTime() *Timestamp {
+	if m == nil {
+		return &Timestamp{}
+	}
+	return &Timestamp{
+		Seconds: m.Time.Unix(),
+		Nanos:   int32(m.Time.Nanosecond()),
+	}
+}
+
+// Size implements the protobuf marshalling interface.
+func (m *MicroTime) Size() (n int) {
+	if m == nil || m.Time.IsZero() {
+		return 0
+	}
+	return m.ProtoMicroTime().Size()
+}
+
+// Reset implements the protobuf marshalling interface.
+func (m *MicroTime) Unmarshal(data []byte) error {
+	if len(data) == 0 {
+		m.Time = time.Time{}
+		return nil
+	}
+	p := Timestamp{}
+	if err := p.Unmarshal(data); err != nil {
+		return err
+	}
+	m.Time = time.Unix(p.Seconds, int64(p.Nanos)).Local()
+	return nil
+}
+
+// Marshal implements the protobuf marshalling interface.
+func (m *MicroTime) Marshal() (data []byte, err error) {
+	if m == nil || m.Time.IsZero() {
+		return nil, nil
+	}
+	return m.ProtoMicroTime().Marshal()
+}
+
+// MarshalTo implements the protobuf marshalling interface.
+func (m *MicroTime) MarshalTo(data []byte) (int, error) {
+	if m == nil || m.Time.IsZero() {
+		return 0, nil
+	}
+	return m.ProtoMicroTime().MarshalTo(data)
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_test.go

@@ -0,0 +1,139 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/ghodss/yaml"
+)
+
+type MicroTimeHolder struct {
+	T MicroTime `json:"t"`
+}
+
+func TestMicroTimeMarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  MicroTime
+		result string
+	}{
+		{MicroTime{}, "t: null\n"},
+		{DateMicro(1998, time.May, 5, 1, 5, 5, 50, time.FixedZone("test", -4*60*60)), "t: 1998-05-05T05:05:05.000000Z\n"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "t: 1998-05-05T05:05:05.000000Z\n"},
+	}
+
+	for _, c := range cases {
+		input := MicroTimeHolder{c.input}
+		result, err := yaml.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestMicroTimeUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  string
+		result MicroTime
+	}{
+		{"t: null\n", MicroTime{}},
+		{"t: 1998-05-05T05:05:05.000000Z\n", MicroTime{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result MicroTimeHolder
+		if err := yaml.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestMicroTimeMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  MicroTime
+		result string
+	}{
+		{MicroTime{}, "{\"t\":null}"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 50, time.UTC), "{\"t\":\"1998-05-05T05:05:05.000000Z\"}"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "{\"t\":\"1998-05-05T05:05:05.000000Z\"}"},
+	}
+
+	for _, c := range cases {
+		input := MicroTimeHolder{c.input}
+		result, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestMicroTimeUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result MicroTime
+	}{
+		{"{\"t\":null}", MicroTime{}},
+		{"{\"t\":\"1998-05-05T05:05:05.000000Z\"}", MicroTime{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result MicroTimeHolder
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestMicroTimeProto(t *testing.T) {
+	cases := []struct {
+		input MicroTime
+	}{
+		{MicroTime{}},
+		{DateMicro(1998, time.May, 5, 1, 5, 5, 50, time.Local)},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.Local)},
+	}
+
+	for _, c := range cases {
+		input := c.input
+		data, err := input.Marshal()
+		if err != nil {
+			t.Fatalf("Failed to marshal input: '%v': %v", input, err)
+		}
+		time := MicroTime{}
+		if err := time.Unmarshal(data); err != nil {
+			t.Fatalf("Failed to unmarshal output: '%v': %v", input, err)
+		}
+		if !reflect.DeepEqual(input, time) {
+			t.Errorf("Marshal->Unmarshal is not idempotent: '%v' vs '%v'", input, time)
+		}
+	}
+}

staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/zz_generated.deepcopy.go

@@ -52,6 +52,7 @@ func GetGeneratedDeepCopyFuncs() []conversion.GeneratedDeepCopyFunc {
 		{Fn: DeepCopy_v1_LabelSelectorRequirement, InType: reflect.TypeOf(&LabelSelectorRequirement{})},
 		{Fn: DeepCopy_v1_ListMeta, InType: reflect.TypeOf(&ListMeta{})},
 		{Fn: DeepCopy_v1_ListOptions, InType: reflect.TypeOf(&ListOptions{})},
+		{Fn: DeepCopy_v1_MicroTime, InType: reflect.TypeOf(&MicroTime{})},
 		{Fn: DeepCopy_v1_ObjectMeta, InType: reflect.TypeOf(&ObjectMeta{})},
 		{Fn: DeepCopy_v1_OwnerReference, InType: reflect.TypeOf(&OwnerReference{})},
 		{Fn: DeepCopy_v1_Patch, InType: reflect.TypeOf(&Patch{})},
@@ -412,6 +413,16 @@ func DeepCopy_v1_ListOptions(in interface{}, out interface{}, c *conversion.Clon
 	}
 }
 
+// DeepCopy_v1_MicroTime is an autogenerated deepcopy function.
+func DeepCopy_v1_MicroTime(in interface{}, out interface{}, c *conversion.Cloner) error {
+	{
+		in := in.(*MicroTime)
+		out := out.(*MicroTime)
+		*out = in.DeepCopy()
+		return nil
+	}
+}
+
 // DeepCopy_v1_ObjectMeta is an autogenerated deepcopy function.
 func DeepCopy_v1_ObjectMeta(in interface{}, out interface{}, c *conversion.Cloner) error {
 	{