diff --git a/examples/ex_2ch/oas_faker_gen.go b/examples/ex_2ch/oas_faker_gen.go
index 2310ca9a2..4c6fc20d9 100644
--- a/examples/ex_2ch/oas_faker_gen.go
+++ b/examples/ex_2ch/oas_faker_gen.go
@@ -6,136 +6,129 @@ package api
 func (s *Board) SetFake() {
 	{
 		{
-			s.BumpLimit = int(0)
+			s.ID = "string"
 		}
 	}
 	{
 		{
-			s.Category = "string"
+			s.Name = "string"
 		}
 	}
 	{
 		{
-			s.DefaultName = "string"
+			s.Category = "string"
 		}
 	}
 	{
 		{
-			s.EnableDices = true
+			s.Info = "string"
 		}
 	}
 	{
 		{
-			s.EnableFlags = true
+			s.InfoOuter = "string"
 		}
 	}
 	{
 		{
-			s.EnableIcons = true
+			s.ThreadsPerPage = int(0)
 		}
 	}
 	{
 		{
-			s.EnableLikes = true
+			s.BumpLimit = int(0)
 		}
 	}
 	{
 		{
-			s.EnableNames = true
+			s.MaxPages = int(0)
 		}
 	}
 	{
 		{
-			s.EnableOekaki = true
+			s.DefaultName = "string"
 		}
 	}
 	{
 		{
-			s.EnablePosting = true
+			s.EnableNames = true
 		}
 	}
 	{
 		{
-			s.EnableSage = true
+			s.EnableTrips = true
 		}
 	}
 	{
 		{
-			s.EnableShield = true
+			s.EnableSubject = true
 		}
 	}
 	{
 		{
-			s.EnableSubject = true
+			s.EnableSage = true
 		}
 	}
 	{
 		{
-			s.EnableThreadTags = true
+			s.EnableIcons = true
 		}
 	}
 	{
 		{
-			s.EnableTrips = true
+			s.EnableFlags = true
 		}
 	}
 	{
 		{
-			s.FileTypes = nil
-			for i := 0; i < 0; i++ {
-				var elem string
-				{
-					elem = "string"
-				}
-				s.FileTypes = append(s.FileTypes, elem)
-			}
+			s.EnableDices = true
 		}
 	}
 	{
 		{
-			s.Icons = nil
-			for i := 0; i < 0; i++ {
-				var elem BoardIconsItem
-				{
-					elem.SetFake()
-				}
-				s.Icons = append(s.Icons, elem)
-			}
+			s.EnableShield = true
 		}
 	}
 	{
 		{
-			s.ID = "string"
+			s.EnableThreadTags = true
 		}
 	}
 	{
 		{
-			s.Info = "string"
+			s.EnablePosting = true
 		}
 	}
 	{
 		{
-			s.InfoOuter = "string"
+			s.EnableLikes = true
 		}
 	}
 	{
 		{
-			s.MaxComment = int(0)
+			s.EnableOekaki = true
 		}
 	}
 	{
 		{
-			s.MaxFilesSize = int(0)
+			s.FileTypes = nil
+			for i := 0; i < 0; i++ {
+				var elem string
+				{
+					elem = "string"
+				}
+				s.FileTypes = append(s.FileTypes, elem)
+			}
 		}
 	}
 	{
 		{
-			s.MaxPages = int(0)
+			s.MaxComment = int(0)
 		}
 	}
 	{
 		{
-			s.Name = "string"
+			s.MaxFilesSize = int(0)
 		}
 	}
 	{
@@ -152,7 +145,14 @@ func (s *Board) SetFake() {
 	}
 	{
 		{
-			s.ThreadsPerPage = int(0)
+			s.Icons = nil
+			for i := 0; i < 0; i++ {
+				var elem BoardIconsItem
+				{
+					elem.SetFake()
+				}
+				s.Icons = append(s.Icons, elem)
+			}
 		}
 	}
 }
@@ -161,12 +161,12 @@ func (s *Board) SetFake() {
 func (s *BoardIconsItem) SetFake() {
 	{
 		{
-			s.Name.SetFake()
+			s.Num.SetFake()
 		}
 	}
 	{
 		{
-			s.Num.SetFake()
+			s.Name.SetFake()
 		}
 	}
 	{
@@ -196,32 +196,32 @@ func (s *Boards) SetFake() {
 func (s *Captcha) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result = int(0)
 		}
 	}
 	{
 		{
-			s.Expires.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
 		{
-			s.ID = "string"
+			s.Type.SetFake()
 		}
 	}
 	{
 		{
-			s.Input.SetFake()
+			s.ID = "string"
 		}
 	}
 	{
 		{
-			s.Result = int(0)
+			s.Expires.SetFake()
 		}
 	}
 	{
 		{
-			s.Type.SetFake()
+			s.Input.SetFake()
 		}
 	}
 }
@@ -254,92 +254,92 @@ func (s *ErrorCode) SetFake() {
 func (s *File) SetFake() {
 	{
 		{
-			s.Displayname = "string"
+			s.Name = "string"
 		}
 	}
 	{
 		{
-			s.Duration.SetFake()
+			s.Fullname = "string"
 		}
 	}
 	{
 		{
-			s.DurationSecs.SetFake()
+			s.Displayname = "string"
 		}
 	}
 	{
 		{
-			s.Fullname = "string"
+			s.Path = "string"
 		}
 	}
 	{
 		{
-			s.Height = int(0)
+			s.Thumbnail = "string"
 		}
 	}
 	{
 		{
-			s.Install.SetFake()
+			s.MD5.SetFake()
 		}
 	}
 	{
 		{
-			s.MD5.SetFake()
+			s.Type.SetFake()
 		}
 	}
 	{
 		{
-			s.Name = "string"
+			s.Size = int(0)
 		}
 	}
 	{
 		{
-			s.Nsfw.SetFake()
+			s.Width = int(0)
 		}
 	}
 	{
 		{
-			s.Pack.SetFake()
+			s.Height = int(0)
 		}
 	}
 	{
 		{
-			s.Path = "string"
+			s.TnWidth = int(0)
 		}
 	}
 	{
 		{
-			s.Size = int(0)
+			s.TnHeight = int(0)
 		}
 	}
 	{
 		{
-			s.Sticker.SetFake()
+			s.Nsfw.SetFake()
 		}
 	}
 	{
 		{
-			s.Thumbnail = "string"
+			s.Duration.SetFake()
 		}
 	}
 	{
 		{
-			s.TnHeight = int(0)
+			s.DurationSecs.SetFake()
 		}
 	}
 	{
 		{
-			s.TnWidth = int(0)
+			s.Pack.SetFake()
 		}
 	}
 	{
 		{
-			s.Type.SetFake()
+			s.Sticker.SetFake()
 		}
 	}
 	{
 		{
-			s.Width = int(0)
+			s.Install.SetFake()
 		}
 	}
 }
@@ -353,12 +353,12 @@ func (s *FileType) SetFake() {
 func (s *Like) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Error.SetFake()
 		}
 	}
 }
@@ -367,17 +367,17 @@ func (s *Like) SetFake() {
 func (s *MobilePost) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Post.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Post.SetFake()
 		}
 	}
 }
@@ -386,12 +386,12 @@ func (s *MobilePost) SetFake() {
 func (s *MobileThreadLastInfo) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
@@ -410,23 +410,33 @@ func (s *MobileThreadLastInfoThread) SetFake() {
 	}
 	{
 		{
-			s.Posts.SetFake()
+			s.Timestamp.SetFake()
 		}
 	}
 	{
 		{
-			s.Timestamp.SetFake()
+			s.Posts.SetFake()
 		}
 	}
 }
 
 // SetFake set fake values.
 func (s *MobileThreadPostsAfter) SetFake() {
+	{
+		{
+			s.Result.SetFake()
+		}
+	}
 	{
 		{
 			s.Error.SetFake()
 		}
 	}
+	{
+		{
+			s.UniquePosters.SetFake()
+		}
+	}
 	{
 		{
 			s.Posts = nil
@@ -439,16 +449,6 @@ func (s *MobileThreadPostsAfter) SetFake() {
 			}
 		}
 	}
-	{
-		{
-			s.Result.SetFake()
-		}
-	}
-	{
-		{
-			s.UniquePosters.SetFake()
-		}
-	}
 }
 
 // SetFake set fake values.
@@ -518,17 +518,17 @@ func (s *OptString) SetFake() {
 func (s *Passcode) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Passcode.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Passcode.SetFake()
 		}
 	}
 }
@@ -537,12 +537,12 @@ func (s *Passcode) SetFake() {
 func (s *PasscodePasscode) SetFake() {
 	{
 		{
-			s.Expires.SetFake()
+			s.Type.SetFake()
 		}
 	}
 	{
 		{
-			s.Type.SetFake()
+			s.Expires.SetFake()
 		}
 	}
 }
@@ -551,7 +551,12 @@ func (s *PasscodePasscode) SetFake() {
 func (s *Post) SetFake() {
 	{
 		{
-			s.Banned = int(0)
+			s.Num = int(0)
+		}
+	}
+	{
+		{
+			s.Parent = int(0)
 		}
 	}
 	{
@@ -561,12 +566,12 @@ func (s *Post) SetFake() {
 	}
 	{
 		{
-			s.Closed = int(0)
+			s.Timestamp = int(0)
 		}
 	}
 	{
 		{
-			s.Comment = "string"
+			s.Lasthit = int(0)
 		}
 	}
 	{
@@ -576,17 +581,17 @@ func (s *Post) SetFake() {
 	}
 	{
 		{
-			s.Dislikes.SetFake()
+			s.Email.SetFake()
 		}
 	}
 	{
 		{
-			s.Email.SetFake()
+			s.Subject.SetFake()
 		}
 	}
 	{
 		{
-			s.Endless = int(0)
+			s.Comment = "string"
 		}
 	}
 	{
@@ -603,27 +608,27 @@ func (s *Post) SetFake() {
 	}
 	{
 		{
-			s.Icon.SetFake()
+			s.Views = int(0)
 		}
 	}
 	{
 		{
-			s.Lasthit = int(0)
+			s.Sticky = int(0)
 		}
 	}
 	{
 		{
-			s.Likes.SetFake()
+			s.Endless = int(0)
 		}
 	}
 	{
 		{
-			s.Name.SetFake()
+			s.Closed = int(0)
 		}
 	}
 	{
 		{
-			s.Num = int(0)
+			s.Banned = int(0)
 		}
 	}
 	{
@@ -633,42 +638,37 @@ func (s *Post) SetFake() {
 	}
 	{
 		{
-			s.Parent = int(0)
-		}
-	}
-	{
-		{
-			s.Sticky = int(0)
+			s.Name.SetFake()
 		}
 	}
 	{
 		{
-			s.Subject.SetFake()
+			s.Icon.SetFake()
 		}
 	}
 	{
 		{
-			s.Tags.SetFake()
+			s.Trip.SetFake()
 		}
 	}
 	{
 		{
-			s.Timestamp = int(0)
+			s.TripStyle.SetFake()
 		}
 	}
 	{
 		{
-			s.Trip.SetFake()
+			s.Tags.SetFake()
 		}
 	}
 	{
 		{
-			s.TripStyle.SetFake()
+			s.Likes.SetFake()
 		}
 	}
 	{
 		{
-			s.Views = int(0)
+			s.Dislikes.SetFake()
 		}
 	}
 }
@@ -677,17 +677,17 @@ func (s *Post) SetFake() {
 func (s *PostingNewPost) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Num.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Num.SetFake()
 		}
 	}
 }
@@ -696,12 +696,12 @@ func (s *PostingNewPost) SetFake() {
 func (s *PostingNewThread) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Error.SetFake()
 		}
 	}
 	{
@@ -715,12 +715,12 @@ func (s *PostingNewThread) SetFake() {
 func (s *Report) SetFake() {
 	{
 		{
-			s.Error.SetFake()
+			s.Result.SetFake()
 		}
 	}
 	{
 		{
-			s.Result.SetFake()
+			s.Error.SetFake()
 		}
 	}
 }
diff --git a/examples/ex_2ch/oas_json_gen.go b/examples/ex_2ch/oas_json_gen.go
index 31a7cf29e..fa0d4502e 100644
--- a/examples/ex_2ch/oas_json_gen.go
+++ b/examples/ex_2ch/oas_json_gen.go
@@ -23,8 +23,13 @@ func (s Board) Encode(e *jx.Encoder) {
 func (s Board) encodeFields(e *jx.Encoder) {
 	{
 
-		e.FieldStart("bump_limit")
-		e.Int(s.BumpLimit)
+		e.FieldStart("id")
+		e.Str(s.ID)
+	}
+	{
+
+		e.FieldStart("name")
+		e.Str(s.Name)
 	}
 	{
 
@@ -33,28 +38,33 @@ func (s Board) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("default_name")
-		e.Str(s.DefaultName)
+		e.FieldStart("info")
+		e.Str(s.Info)
 	}
 	{
 
-		e.FieldStart("enable_dices")
-		e.Bool(s.EnableDices)
+		e.FieldStart("info_outer")
+		e.Str(s.InfoOuter)
 	}
 	{
 
-		e.FieldStart("enable_flags")
-		e.Bool(s.EnableFlags)
+		e.FieldStart("threads_per_page")
+		e.Int(s.ThreadsPerPage)
 	}
 	{
 
-		e.FieldStart("enable_icons")
-		e.Bool(s.EnableIcons)
+		e.FieldStart("bump_limit")
+		e.Int(s.BumpLimit)
 	}
 	{
 
-		e.FieldStart("enable_likes")
-		e.Bool(s.EnableLikes)
+		e.FieldStart("max_pages")
+		e.Int(s.MaxPages)
+	}
+	{
+
+		e.FieldStart("default_name")
+		e.Str(s.DefaultName)
 	}
 	{
 
@@ -63,13 +73,13 @@ func (s Board) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("enable_oekaki")
-		e.Bool(s.EnableOekaki)
+		e.FieldStart("enable_trips")
+		e.Bool(s.EnableTrips)
 	}
 	{
 
-		e.FieldStart("enable_posting")
-		e.Bool(s.EnablePosting)
+		e.FieldStart("enable_subject")
+		e.Bool(s.EnableSubject)
 	}
 	{
 
@@ -78,57 +88,52 @@ func (s Board) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("enable_shield")
-		e.Bool(s.EnableShield)
+		e.FieldStart("enable_icons")
+		e.Bool(s.EnableIcons)
 	}
 	{
 
-		e.FieldStart("enable_subject")
-		e.Bool(s.EnableSubject)
+		e.FieldStart("enable_flags")
+		e.Bool(s.EnableFlags)
 	}
 	{
 
-		e.FieldStart("enable_thread_tags")
-		e.Bool(s.EnableThreadTags)
+		e.FieldStart("enable_dices")
+		e.Bool(s.EnableDices)
 	}
 	{
 
-		e.FieldStart("enable_trips")
-		e.Bool(s.EnableTrips)
+		e.FieldStart("enable_shield")
+		e.Bool(s.EnableShield)
 	}
 	{
 
-		e.FieldStart("file_types")
-		e.ArrStart()
-		for _, elem := range s.FileTypes {
-			e.Str(elem)
-		}
-		e.ArrEnd()
+		e.FieldStart("enable_thread_tags")
+		e.Bool(s.EnableThreadTags)
 	}
 	{
-		if s.Icons != nil {
-			e.FieldStart("icons")
-			e.ArrStart()
-			for _, elem := range s.Icons {
-				elem.Encode(e)
-			}
-			e.ArrEnd()
-		}
+
+		e.FieldStart("enable_posting")
+		e.Bool(s.EnablePosting)
 	}
 	{
 
-		e.FieldStart("id")
-		e.Str(s.ID)
+		e.FieldStart("enable_likes")
+		e.Bool(s.EnableLikes)
 	}
 	{
 
-		e.FieldStart("info")
-		e.Str(s.Info)
+		e.FieldStart("enable_oekaki")
+		e.Bool(s.EnableOekaki)
 	}
 	{
 
-		e.FieldStart("info_outer")
-		e.Str(s.InfoOuter)
+		e.FieldStart("file_types")
+		e.ArrStart()
+		for _, elem := range s.FileTypes {
+			e.Str(elem)
+		}
+		e.ArrEnd()
 	}
 	{
 
@@ -140,16 +145,6 @@ func (s Board) encodeFields(e *jx.Encoder) {
 		e.FieldStart("max_files_size")
 		e.Int(s.MaxFilesSize)
 	}
-	{
-
-		e.FieldStart("max_pages")
-		e.Int(s.MaxPages)
-	}
-	{
-
-		e.FieldStart("name")
-		e.Str(s.Name)
-	}
 	{
 		if s.Tags != nil {
 			e.FieldStart("tags")
@@ -161,39 +156,44 @@ func (s Board) encodeFields(e *jx.Encoder) {
 		}
 	}
 	{
-
-		e.FieldStart("threads_per_page")
-		e.Int(s.ThreadsPerPage)
+		if s.Icons != nil {
+			e.FieldStart("icons")
+			e.ArrStart()
+			for _, elem := range s.Icons {
+				elem.Encode(e)
+			}
+			e.ArrEnd()
+		}
 	}
 }
 
 var jsonFieldsNameOfBoard = [26]string{
-	0:  "bump_limit",
-	1:  "category",
-	2:  "default_name",
-	3:  "enable_dices",
-	4:  "enable_flags",
-	5:  "enable_icons",
-	6:  "enable_likes",
-	7:  "enable_names",
-	8:  "enable_oekaki",
-	9:  "enable_posting",
-	10: "enable_sage",
-	11: "enable_shield",
-	12: "enable_subject",
-	13: "enable_thread_tags",
-	14: "enable_trips",
-	15: "file_types",
-	16: "icons",
-	17: "id",
-	18: "info",
-	19: "info_outer",
-	20: "max_comment",
-	21: "max_files_size",
-	22: "max_pages",
-	23: "name",
+	0:  "id",
+	1:  "name",
+	2:  "category",
+	3:  "info",
+	4:  "info_outer",
+	5:  "threads_per_page",
+	6:  "bump_limit",
+	7:  "max_pages",
+	8:  "default_name",
+	9:  "enable_names",
+	10: "enable_trips",
+	11: "enable_subject",
+	12: "enable_sage",
+	13: "enable_icons",
+	14: "enable_flags",
+	15: "enable_dices",
+	16: "enable_shield",
+	17: "enable_thread_tags",
+	18: "enable_posting",
+	19: "enable_likes",
+	20: "enable_oekaki",
+	21: "file_types",
+	22: "max_comment",
+	23: "max_files_size",
 	24: "tags",
-	25: "threads_per_page",
+	25: "icons",
 }
 
 // Decode decodes Board from json.
@@ -205,306 +205,301 @@ func (s *Board) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "bump_limit":
+		case "id":
 			requiredBitSet[0] |= 1 << 0
 			if err := func() error {
-				v, err := d.Int()
-				s.BumpLimit = int(v)
+				v, err := d.Str()
+				s.ID = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"bump_limit\"")
+				return errors.Wrap(err, "decode field \"id\"")
 			}
-		case "category":
+		case "name":
 			requiredBitSet[0] |= 1 << 1
 			if err := func() error {
 				v, err := d.Str()
-				s.Category = string(v)
+				s.Name = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"category\"")
+				return errors.Wrap(err, "decode field \"name\"")
 			}
-		case "default_name":
+		case "category":
 			requiredBitSet[0] |= 1 << 2
 			if err := func() error {
 				v, err := d.Str()
-				s.DefaultName = string(v)
+				s.Category = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"default_name\"")
+				return errors.Wrap(err, "decode field \"category\"")
 			}
-		case "enable_dices":
+		case "info":
 			requiredBitSet[0] |= 1 << 3
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableDices = bool(v)
+				v, err := d.Str()
+				s.Info = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_dices\"")
+				return errors.Wrap(err, "decode field \"info\"")
 			}
-		case "enable_flags":
+		case "info_outer":
 			requiredBitSet[0] |= 1 << 4
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableFlags = bool(v)
+				v, err := d.Str()
+				s.InfoOuter = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_flags\"")
+				return errors.Wrap(err, "decode field \"info_outer\"")
 			}
-		case "enable_icons":
+		case "threads_per_page":
 			requiredBitSet[0] |= 1 << 5
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableIcons = bool(v)
+				v, err := d.Int()
+				s.ThreadsPerPage = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_icons\"")
+				return errors.Wrap(err, "decode field \"threads_per_page\"")
 			}
-		case "enable_likes":
+		case "bump_limit":
 			requiredBitSet[0] |= 1 << 6
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableLikes = bool(v)
+				v, err := d.Int()
+				s.BumpLimit = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_likes\"")
+				return errors.Wrap(err, "decode field \"bump_limit\"")
 			}
-		case "enable_names":
+		case "max_pages":
 			requiredBitSet[0] |= 1 << 7
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableNames = bool(v)
+				v, err := d.Int()
+				s.MaxPages = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_names\"")
+				return errors.Wrap(err, "decode field \"max_pages\"")
 			}
-		case "enable_oekaki":
+		case "default_name":
 			requiredBitSet[1] |= 1 << 0
 			if err := func() error {
-				v, err := d.Bool()
-				s.EnableOekaki = bool(v)
+				v, err := d.Str()
+				s.DefaultName = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_oekaki\"")
+				return errors.Wrap(err, "decode field \"default_name\"")
 			}
-		case "enable_posting":
+		case "enable_names":
 			requiredBitSet[1] |= 1 << 1
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnablePosting = bool(v)
+				s.EnableNames = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_posting\"")
+				return errors.Wrap(err, "decode field \"enable_names\"")
 			}
-		case "enable_sage":
+		case "enable_trips":
 			requiredBitSet[1] |= 1 << 2
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnableSage = bool(v)
+				s.EnableTrips = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_sage\"")
+				return errors.Wrap(err, "decode field \"enable_trips\"")
 			}
-		case "enable_shield":
+		case "enable_subject":
 			requiredBitSet[1] |= 1 << 3
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnableShield = bool(v)
+				s.EnableSubject = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_shield\"")
+				return errors.Wrap(err, "decode field \"enable_subject\"")
 			}
-		case "enable_subject":
+		case "enable_sage":
 			requiredBitSet[1] |= 1 << 4
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnableSubject = bool(v)
+				s.EnableSage = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_subject\"")
+				return errors.Wrap(err, "decode field \"enable_sage\"")
 			}
-		case "enable_thread_tags":
+		case "enable_icons":
 			requiredBitSet[1] |= 1 << 5
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnableThreadTags = bool(v)
+				s.EnableIcons = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_thread_tags\"")
+				return errors.Wrap(err, "decode field \"enable_icons\"")
 			}
-		case "enable_trips":
+		case "enable_flags":
 			requiredBitSet[1] |= 1 << 6
 			if err := func() error {
 				v, err := d.Bool()
-				s.EnableTrips = bool(v)
+				s.EnableFlags = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"enable_trips\"")
+				return errors.Wrap(err, "decode field \"enable_flags\"")
 			}
-		case "file_types":
+		case "enable_dices":
 			requiredBitSet[1] |= 1 << 7
 			if err := func() error {
-				s.FileTypes = make([]string, 0)
-				if err := d.Arr(func(d *jx.Decoder) error {
-					var elem string
-					v, err := d.Str()
-					elem = string(v)
-					if err != nil {
-						return err
-					}
-					s.FileTypes = append(s.FileTypes, elem)
-					return nil
-				}); err != nil {
+				v, err := d.Bool()
+				s.EnableDices = bool(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"file_types\"")
+				return errors.Wrap(err, "decode field \"enable_dices\"")
 			}
-		case "icons":
+		case "enable_shield":
+			requiredBitSet[2] |= 1 << 0
 			if err := func() error {
-				s.Icons = make([]BoardIconsItem, 0)
-				if err := d.Arr(func(d *jx.Decoder) error {
-					var elem BoardIconsItem
-					if err := elem.Decode(d); err != nil {
-						return err
-					}
-					s.Icons = append(s.Icons, elem)
-					return nil
-				}); err != nil {
+				v, err := d.Bool()
+				s.EnableShield = bool(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"icons\"")
+				return errors.Wrap(err, "decode field \"enable_shield\"")
 			}
-		case "id":
+		case "enable_thread_tags":
 			requiredBitSet[2] |= 1 << 1
 			if err := func() error {
-				v, err := d.Str()
-				s.ID = string(v)
+				v, err := d.Bool()
+				s.EnableThreadTags = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"id\"")
+				return errors.Wrap(err, "decode field \"enable_thread_tags\"")
 			}
-		case "info":
+		case "enable_posting":
 			requiredBitSet[2] |= 1 << 2
 			if err := func() error {
-				v, err := d.Str()
-				s.Info = string(v)
+				v, err := d.Bool()
+				s.EnablePosting = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"info\"")
+				return errors.Wrap(err, "decode field \"enable_posting\"")
 			}
-		case "info_outer":
+		case "enable_likes":
 			requiredBitSet[2] |= 1 << 3
 			if err := func() error {
-				v, err := d.Str()
-				s.InfoOuter = string(v)
+				v, err := d.Bool()
+				s.EnableLikes = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"info_outer\"")
+				return errors.Wrap(err, "decode field \"enable_likes\"")
 			}
-		case "max_comment":
+		case "enable_oekaki":
 			requiredBitSet[2] |= 1 << 4
 			if err := func() error {
-				v, err := d.Int()
-				s.MaxComment = int(v)
+				v, err := d.Bool()
+				s.EnableOekaki = bool(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"max_comment\"")
+				return errors.Wrap(err, "decode field \"enable_oekaki\"")
 			}
-		case "max_files_size":
+		case "file_types":
 			requiredBitSet[2] |= 1 << 5
 			if err := func() error {
-				v, err := d.Int()
-				s.MaxFilesSize = int(v)
-				if err != nil {
+				s.FileTypes = make([]string, 0)
+				if err := d.Arr(func(d *jx.Decoder) error {
+					var elem string
+					v, err := d.Str()
+					elem = string(v)
+					if err != nil {
+						return err
+					}
+					s.FileTypes = append(s.FileTypes, elem)
+					return nil
+				}); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"max_files_size\"")
+				return errors.Wrap(err, "decode field \"file_types\"")
 			}
-		case "max_pages":
+		case "max_comment":
 			requiredBitSet[2] |= 1 << 6
 			if err := func() error {
 				v, err := d.Int()
-				s.MaxPages = int(v)
+				s.MaxComment = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"max_pages\"")
+				return errors.Wrap(err, "decode field \"max_comment\"")
 			}
-		case "name":
+		case "max_files_size":
 			requiredBitSet[2] |= 1 << 7
 			if err := func() error {
-				v, err := d.Str()
-				s.Name = string(v)
+				v, err := d.Int()
+				s.MaxFilesSize = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"name\"")
+				return errors.Wrap(err, "decode field \"max_files_size\"")
 			}
 		case "tags":
 			if err := func() error {
@@ -525,17 +520,22 @@ func (s *Board) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"tags\"")
 			}
-		case "threads_per_page":
-			requiredBitSet[3] |= 1 << 1
+		case "icons":
 			if err := func() error {
-				v, err := d.Int()
-				s.ThreadsPerPage = int(v)
-				if err != nil {
+				s.Icons = make([]BoardIconsItem, 0)
+				if err := d.Arr(func(d *jx.Decoder) error {
+					var elem BoardIconsItem
+					if err := elem.Decode(d); err != nil {
+						return err
+					}
+					s.Icons = append(s.Icons, elem)
+					return nil
+				}); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"threads_per_page\"")
+				return errors.Wrap(err, "decode field \"icons\"")
 			}
 		default:
 			return d.Skip()
@@ -549,8 +549,8 @@ func (s *Board) Decode(d *jx.Decoder) error {
 	for i, mask := range [4]uint8{
 		0b11111111,
 		0b11111111,
-		0b11111110,
-		0b00000010,
+		0b11111111,
+		0b00000000,
 	} {
 		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
 			// Mask only required fields and check equality to mask using XOR.
@@ -605,18 +605,18 @@ func (s BoardIconsItem) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s BoardIconsItem) encodeFields(e *jx.Encoder) {
-	{
-		if s.Name.Set {
-			e.FieldStart("name")
-			s.Name.Encode(e)
-		}
-	}
 	{
 		if s.Num.Set {
 			e.FieldStart("num")
 			s.Num.Encode(e)
 		}
 	}
+	{
+		if s.Name.Set {
+			e.FieldStart("name")
+			s.Name.Encode(e)
+		}
+	}
 	{
 		if s.URL.Set {
 			e.FieldStart("url")
@@ -626,8 +626,8 @@ func (s BoardIconsItem) encodeFields(e *jx.Encoder) {
 }
 
 var jsonFieldsNameOfBoardIconsItem = [3]string{
-	0: "name",
-	1: "num",
+	0: "num",
+	1: "name",
 	2: "url",
 }
 
@@ -639,25 +639,25 @@ func (s *BoardIconsItem) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "name":
+		case "num":
 			if err := func() error {
-				s.Name.Reset()
-				if err := s.Name.Decode(d); err != nil {
+				s.Num.Reset()
+				if err := s.Num.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"name\"")
+				return errors.Wrap(err, "decode field \"num\"")
 			}
-		case "num":
+		case "name":
 			if err := func() error {
-				s.Num.Reset()
-				if err := s.Num.Decode(d); err != nil {
+				s.Name.Reset()
+				if err := s.Name.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"num\"")
+				return errors.Wrap(err, "decode field \"name\"")
 			}
 		case "url":
 			if err := func() error {
@@ -752,6 +752,11 @@ func (s Captcha) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s Captcha) encodeFields(e *jx.Encoder) {
+	{
+
+		e.FieldStart("result")
+		e.Int(s.Result)
+	}
 	{
 		if s.Error.Set {
 			e.FieldStart("error")
@@ -759,41 +764,36 @@ func (s Captcha) encodeFields(e *jx.Encoder) {
 		}
 	}
 	{
-		if s.Expires.Set {
-			e.FieldStart("expires")
-			s.Expires.Encode(e)
-		}
+
+		e.FieldStart("type")
+		s.Type.Encode(e)
 	}
 	{
 
 		e.FieldStart("id")
 		e.Str(s.ID)
 	}
+	{
+		if s.Expires.Set {
+			e.FieldStart("expires")
+			s.Expires.Encode(e)
+		}
+	}
 	{
 		if s.Input.Set {
 			e.FieldStart("input")
 			s.Input.Encode(e)
 		}
 	}
-	{
-
-		e.FieldStart("result")
-		e.Int(s.Result)
-	}
-	{
-
-		e.FieldStart("type")
-		s.Type.Encode(e)
-	}
 }
 
 var jsonFieldsNameOfCaptcha = [6]string{
-	0: "error",
-	1: "expires",
-	2: "id",
-	3: "input",
-	4: "result",
-	5: "type",
+	0: "result",
+	1: "error",
+	2: "type",
+	3: "id",
+	4: "expires",
+	5: "input",
 }
 
 // Decode decodes Captcha from json.
@@ -805,6 +805,18 @@ func (s *Captcha) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
+		case "result":
+			requiredBitSet[0] |= 1 << 0
+			if err := func() error {
+				v, err := d.Int()
+				s.Result = int(v)
+				if err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"result\"")
+			}
 		case "error":
 			if err := func() error {
 				s.Error.Reset()
@@ -815,18 +827,18 @@ func (s *Captcha) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"error\"")
 			}
-		case "expires":
+		case "type":
+			requiredBitSet[0] |= 1 << 2
 			if err := func() error {
-				s.Expires.Reset()
-				if err := s.Expires.Decode(d); err != nil {
+				if err := s.Type.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"expires\"")
+				return errors.Wrap(err, "decode field \"type\"")
 			}
 		case "id":
-			requiredBitSet[0] |= 1 << 2
+			requiredBitSet[0] |= 1 << 3
 			if err := func() error {
 				v, err := d.Str()
 				s.ID = string(v)
@@ -837,37 +849,25 @@ func (s *Captcha) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"id\"")
 			}
-		case "input":
-			if err := func() error {
-				s.Input.Reset()
-				if err := s.Input.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"input\"")
-			}
-		case "result":
-			requiredBitSet[0] |= 1 << 4
+		case "expires":
 			if err := func() error {
-				v, err := d.Int()
-				s.Result = int(v)
-				if err != nil {
+				s.Expires.Reset()
+				if err := s.Expires.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
+				return errors.Wrap(err, "decode field \"expires\"")
 			}
-		case "type":
-			requiredBitSet[0] |= 1 << 5
+		case "input":
 			if err := func() error {
-				if err := s.Type.Decode(d); err != nil {
+				s.Input.Reset()
+				if err := s.Input.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"type\"")
+				return errors.Wrap(err, "decode field \"input\"")
 			}
 		default:
 			return d.Skip()
@@ -879,7 +879,7 @@ func (s *Captcha) Decode(d *jx.Decoder) error {
 	// Validate required fields.
 	var failures []validate.FieldError
 	for i, mask := range [1]uint8{
-		0b00110100,
+		0b00001101,
 	} {
 		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
 			// Mask only required fields and check equality to mask using XOR.
@@ -1098,20 +1098,8 @@ func (s File) Encode(e *jx.Encoder) {
 func (s File) encodeFields(e *jx.Encoder) {
 	{
 
-		e.FieldStart("displayname")
-		e.Str(s.Displayname)
-	}
-	{
-		if s.Duration.Set {
-			e.FieldStart("duration")
-			s.Duration.Encode(e)
-		}
-	}
-	{
-		if s.DurationSecs.Set {
-			e.FieldStart("duration_secs")
-			s.DurationSecs.Encode(e)
-		}
+		e.FieldStart("name")
+		e.Str(s.Name)
 	}
 	{
 
@@ -1120,14 +1108,18 @@ func (s File) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("height")
-		e.Int(s.Height)
+		e.FieldStart("displayname")
+		e.Str(s.Displayname)
 	}
 	{
-		if s.Install.Set {
-			e.FieldStart("install")
-			s.Install.Encode(e)
-		}
+
+		e.FieldStart("path")
+		e.Str(s.Path)
+	}
+	{
+
+		e.FieldStart("thumbnail")
+		e.Str(s.Thumbnail)
 	}
 	{
 		if s.MD5.Set {
@@ -1137,83 +1129,91 @@ func (s File) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("name")
-		e.Str(s.Name)
+		e.FieldStart("type")
+		s.Type.Encode(e)
 	}
 	{
-		if s.Nsfw.Set {
-			e.FieldStart("nsfw")
-			s.Nsfw.Encode(e)
-		}
+
+		e.FieldStart("size")
+		e.Int(s.Size)
 	}
 	{
-		if s.Pack.Set {
-			e.FieldStart("pack")
-			s.Pack.Encode(e)
-		}
+
+		e.FieldStart("width")
+		e.Int(s.Width)
 	}
 	{
 
-		e.FieldStart("path")
-		e.Str(s.Path)
+		e.FieldStart("height")
+		e.Int(s.Height)
 	}
 	{
 
-		e.FieldStart("size")
-		e.Int(s.Size)
+		e.FieldStart("tn_width")
+		e.Int(s.TnWidth)
 	}
 	{
-		if s.Sticker.Set {
-			e.FieldStart("sticker")
-			s.Sticker.Encode(e)
+
+		e.FieldStart("tn_height")
+		e.Int(s.TnHeight)
+	}
+	{
+		if s.Nsfw.Set {
+			e.FieldStart("nsfw")
+			s.Nsfw.Encode(e)
 		}
 	}
 	{
-
-		e.FieldStart("thumbnail")
-		e.Str(s.Thumbnail)
+		if s.Duration.Set {
+			e.FieldStart("duration")
+			s.Duration.Encode(e)
+		}
 	}
 	{
-
-		e.FieldStart("tn_height")
-		e.Int(s.TnHeight)
+		if s.DurationSecs.Set {
+			e.FieldStart("duration_secs")
+			s.DurationSecs.Encode(e)
+		}
 	}
 	{
-
-		e.FieldStart("tn_width")
-		e.Int(s.TnWidth)
+		if s.Pack.Set {
+			e.FieldStart("pack")
+			s.Pack.Encode(e)
+		}
 	}
 	{
-
-		e.FieldStart("type")
-		s.Type.Encode(e)
+		if s.Sticker.Set {
+			e.FieldStart("sticker")
+			s.Sticker.Encode(e)
+		}
 	}
 	{
-
-		e.FieldStart("width")
-		e.Int(s.Width)
+		if s.Install.Set {
+			e.FieldStart("install")
+			s.Install.Encode(e)
+		}
 	}
 }
 
 var jsonFieldsNameOfFile = [18]string{
-	0:  "displayname",
-	1:  "duration",
-	2:  "duration_secs",
-	3:  "fullname",
-	4:  "height",
-	5:  "install",
-	6:  "md5",
-	7:  "name",
-	8:  "nsfw",
-	9:  "pack",
-	10: "path",
-	11: "size",
-	12: "sticker",
-	13: "thumbnail",
-	14: "tn_height",
-	15: "tn_width",
-	16: "type",
-	17: "width",
+	0:  "name",
+	1:  "fullname",
+	2:  "displayname",
+	3:  "path",
+	4:  "thumbnail",
+	5:  "md5",
+	6:  "type",
+	7:  "size",
+	8:  "width",
+	9:  "height",
+	10: "tn_width",
+	11: "tn_height",
+	12: "nsfw",
+	13: "duration",
+	14: "duration_secs",
+	15: "pack",
+	16: "sticker",
+	17: "install",
 }
 
 // Decode decodes File from json.
@@ -1225,71 +1225,65 @@ func (s *File) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "displayname":
+		case "name":
 			requiredBitSet[0] |= 1 << 0
 			if err := func() error {
 				v, err := d.Str()
-				s.Displayname = string(v)
-				if err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"displayname\"")
-			}
-		case "duration":
-			if err := func() error {
-				s.Duration.Reset()
-				if err := s.Duration.Decode(d); err != nil {
+				s.Name = string(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"duration\"")
+				return errors.Wrap(err, "decode field \"name\"")
 			}
-		case "duration_secs":
+		case "fullname":
+			requiredBitSet[0] |= 1 << 1
 			if err := func() error {
-				s.DurationSecs.Reset()
-				if err := s.DurationSecs.Decode(d); err != nil {
+				v, err := d.Str()
+				s.Fullname = string(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"duration_secs\"")
+				return errors.Wrap(err, "decode field \"fullname\"")
 			}
-		case "fullname":
-			requiredBitSet[0] |= 1 << 3
+		case "displayname":
+			requiredBitSet[0] |= 1 << 2
 			if err := func() error {
 				v, err := d.Str()
-				s.Fullname = string(v)
+				s.Displayname = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"fullname\"")
+				return errors.Wrap(err, "decode field \"displayname\"")
 			}
-		case "height":
-			requiredBitSet[0] |= 1 << 4
+		case "path":
+			requiredBitSet[0] |= 1 << 3
 			if err := func() error {
-				v, err := d.Int()
-				s.Height = int(v)
+				v, err := d.Str()
+				s.Path = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"height\"")
+				return errors.Wrap(err, "decode field \"path\"")
 			}
-		case "install":
+		case "thumbnail":
+			requiredBitSet[0] |= 1 << 4
 			if err := func() error {
-				s.Install.Reset()
-				if err := s.Install.Decode(d); err != nil {
+				v, err := d.Str()
+				s.Thumbnail = string(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"install\"")
+				return errors.Wrap(err, "decode field \"thumbnail\"")
 			}
 		case "md5":
 			if err := func() error {
@@ -1301,129 +1295,135 @@ func (s *File) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"md5\"")
 			}
-		case "name":
+		case "type":
+			requiredBitSet[0] |= 1 << 6
+			if err := func() error {
+				if err := s.Type.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"type\"")
+			}
+		case "size":
 			requiredBitSet[0] |= 1 << 7
 			if err := func() error {
-				v, err := d.Str()
-				s.Name = string(v)
+				v, err := d.Int()
+				s.Size = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"name\"")
+				return errors.Wrap(err, "decode field \"size\"")
 			}
-		case "nsfw":
+		case "width":
+			requiredBitSet[1] |= 1 << 0
 			if err := func() error {
-				s.Nsfw.Reset()
-				if err := s.Nsfw.Decode(d); err != nil {
+				v, err := d.Int()
+				s.Width = int(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"nsfw\"")
+				return errors.Wrap(err, "decode field \"width\"")
 			}
-		case "pack":
+		case "height":
+			requiredBitSet[1] |= 1 << 1
 			if err := func() error {
-				s.Pack.Reset()
-				if err := s.Pack.Decode(d); err != nil {
+				v, err := d.Int()
+				s.Height = int(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"pack\"")
+				return errors.Wrap(err, "decode field \"height\"")
 			}
-		case "path":
+		case "tn_width":
 			requiredBitSet[1] |= 1 << 2
 			if err := func() error {
-				v, err := d.Str()
-				s.Path = string(v)
+				v, err := d.Int()
+				s.TnWidth = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"path\"")
+				return errors.Wrap(err, "decode field \"tn_width\"")
 			}
-		case "size":
+		case "tn_height":
 			requiredBitSet[1] |= 1 << 3
 			if err := func() error {
 				v, err := d.Int()
-				s.Size = int(v)
+				s.TnHeight = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"size\"")
+				return errors.Wrap(err, "decode field \"tn_height\"")
 			}
-		case "sticker":
+		case "nsfw":
 			if err := func() error {
-				s.Sticker.Reset()
-				if err := s.Sticker.Decode(d); err != nil {
+				s.Nsfw.Reset()
+				if err := s.Nsfw.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"sticker\"")
+				return errors.Wrap(err, "decode field \"nsfw\"")
 			}
-		case "thumbnail":
-			requiredBitSet[1] |= 1 << 5
+		case "duration":
 			if err := func() error {
-				v, err := d.Str()
-				s.Thumbnail = string(v)
-				if err != nil {
+				s.Duration.Reset()
+				if err := s.Duration.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"thumbnail\"")
+				return errors.Wrap(err, "decode field \"duration\"")
 			}
-		case "tn_height":
-			requiredBitSet[1] |= 1 << 6
+		case "duration_secs":
 			if err := func() error {
-				v, err := d.Int()
-				s.TnHeight = int(v)
-				if err != nil {
+				s.DurationSecs.Reset()
+				if err := s.DurationSecs.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"tn_height\"")
+				return errors.Wrap(err, "decode field \"duration_secs\"")
 			}
-		case "tn_width":
-			requiredBitSet[1] |= 1 << 7
+		case "pack":
 			if err := func() error {
-				v, err := d.Int()
-				s.TnWidth = int(v)
-				if err != nil {
+				s.Pack.Reset()
+				if err := s.Pack.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"tn_width\"")
+				return errors.Wrap(err, "decode field \"pack\"")
 			}
-		case "type":
-			requiredBitSet[2] |= 1 << 0
+		case "sticker":
 			if err := func() error {
-				if err := s.Type.Decode(d); err != nil {
+				s.Sticker.Reset()
+				if err := s.Sticker.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"type\"")
+				return errors.Wrap(err, "decode field \"sticker\"")
 			}
-		case "width":
-			requiredBitSet[2] |= 1 << 1
+		case "install":
 			if err := func() error {
-				v, err := d.Int()
-				s.Width = int(v)
-				if err != nil {
+				s.Install.Reset()
+				if err := s.Install.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"width\"")
+				return errors.Wrap(err, "decode field \"install\"")
 			}
 		default:
 			return d.Skip()
@@ -1435,9 +1435,9 @@ func (s *File) Decode(d *jx.Decoder) error {
 	// Validate required fields.
 	var failures []validate.FieldError
 	for i, mask := range [3]uint8{
-		0b10011001,
-		0b11101100,
-		0b00000011,
+		0b11011111,
+		0b00001111,
+		0b00000000,
 	} {
 		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
 			// Mask only required fields and check equality to mask using XOR.
@@ -1524,23 +1524,23 @@ func (s Like) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s Like) encodeFields(e *jx.Encoder) {
-	{
-		if s.Error.Set {
-			e.FieldStart("error")
-			s.Error.Encode(e)
-		}
-	}
 	{
 		if s.Result.Set {
 			e.FieldStart("result")
 			s.Result.Encode(e)
 		}
 	}
+	{
+		if s.Error.Set {
+			e.FieldStart("error")
+			s.Error.Encode(e)
+		}
+	}
 }
 
 var jsonFieldsNameOfLike = [2]string{
-	0: "error",
-	1: "result",
+	0: "result",
+	1: "error",
 }
 
 // Decode decodes Like from json.
@@ -1551,25 +1551,25 @@ func (s *Like) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "error":
+		case "result":
 			if err := func() error {
-				s.Error.Reset()
-				if err := s.Error.Decode(d); err != nil {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"error\"")
+				return errors.Wrap(err, "decode field \"result\"")
 			}
-		case "result":
+		case "error":
 			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
+				s.Error.Reset()
+				if err := s.Error.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
+				return errors.Wrap(err, "decode field \"error\"")
 			}
 		default:
 			return d.Skip()
@@ -1604,6 +1604,12 @@ func (s MobilePost) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s MobilePost) encodeFields(e *jx.Encoder) {
+	{
+		if s.Result.Set {
+			e.FieldStart("result")
+			s.Result.Encode(e)
+		}
+	}
 	{
 		if s.Error.Set {
 			e.FieldStart("error")
@@ -1616,18 +1622,12 @@ func (s MobilePost) encodeFields(e *jx.Encoder) {
 			s.Post.Encode(e)
 		}
 	}
-	{
-		if s.Result.Set {
-			e.FieldStart("result")
-			s.Result.Encode(e)
-		}
-	}
 }
 
 var jsonFieldsNameOfMobilePost = [3]string{
-	0: "error",
-	1: "post",
-	2: "result",
+	0: "result",
+	1: "error",
+	2: "post",
 }
 
 // Decode decodes MobilePost from json.
@@ -1638,6 +1638,16 @@ func (s *MobilePost) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
+		case "result":
+			if err := func() error {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"result\"")
+			}
 		case "error":
 			if err := func() error {
 				s.Error.Reset()
@@ -1658,16 +1668,6 @@ func (s *MobilePost) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"post\"")
 			}
-		case "result":
-			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
-			}
 		default:
 			return d.Skip()
 		}
@@ -1701,18 +1701,18 @@ func (s MobileThreadLastInfo) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s MobileThreadLastInfo) encodeFields(e *jx.Encoder) {
-	{
-		if s.Error.Set {
-			e.FieldStart("error")
-			s.Error.Encode(e)
-		}
-	}
 	{
 		if s.Result.Set {
 			e.FieldStart("result")
 			s.Result.Encode(e)
 		}
 	}
+	{
+		if s.Error.Set {
+			e.FieldStart("error")
+			s.Error.Encode(e)
+		}
+	}
 	{
 		if s.Thread.Set {
 			e.FieldStart("thread")
@@ -1722,8 +1722,8 @@ func (s MobileThreadLastInfo) encodeFields(e *jx.Encoder) {
 }
 
 var jsonFieldsNameOfMobileThreadLastInfo = [3]string{
-	0: "error",
-	1: "result",
+	0: "result",
+	1: "error",
 	2: "thread",
 }
 
@@ -1735,25 +1735,25 @@ func (s *MobileThreadLastInfo) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "error":
+		case "result":
 			if err := func() error {
-				s.Error.Reset()
-				if err := s.Error.Decode(d); err != nil {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"error\"")
+				return errors.Wrap(err, "decode field \"result\"")
 			}
-		case "result":
+		case "error":
 			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
+				s.Error.Reset()
+				if err := s.Error.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
+				return errors.Wrap(err, "decode field \"error\"")
 			}
 		case "thread":
 			if err := func() error {
@@ -1804,24 +1804,24 @@ func (s MobileThreadLastInfoThread) encodeFields(e *jx.Encoder) {
 			s.Num.Encode(e)
 		}
 	}
-	{
-		if s.Posts.Set {
-			e.FieldStart("posts")
-			s.Posts.Encode(e)
-		}
-	}
 	{
 		if s.Timestamp.Set {
 			e.FieldStart("timestamp")
 			s.Timestamp.Encode(e)
 		}
 	}
+	{
+		if s.Posts.Set {
+			e.FieldStart("posts")
+			s.Posts.Encode(e)
+		}
+	}
 }
 
 var jsonFieldsNameOfMobileThreadLastInfoThread = [3]string{
 	0: "num",
-	1: "posts",
-	2: "timestamp",
+	1: "timestamp",
+	2: "posts",
 }
 
 // Decode decodes MobileThreadLastInfoThread from json.
@@ -1842,25 +1842,25 @@ func (s *MobileThreadLastInfoThread) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"num\"")
 			}
-		case "posts":
+		case "timestamp":
 			if err := func() error {
-				s.Posts.Reset()
-				if err := s.Posts.Decode(d); err != nil {
+				s.Timestamp.Reset()
+				if err := s.Timestamp.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"posts\"")
+				return errors.Wrap(err, "decode field \"timestamp\"")
 			}
-		case "timestamp":
+		case "posts":
 			if err := func() error {
-				s.Timestamp.Reset()
-				if err := s.Timestamp.Decode(d); err != nil {
+				s.Posts.Reset()
+				if err := s.Posts.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"timestamp\"")
+				return errors.Wrap(err, "decode field \"posts\"")
 			}
 		default:
 			return d.Skip()
@@ -1895,12 +1895,24 @@ func (s MobileThreadPostsAfter) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s MobileThreadPostsAfter) encodeFields(e *jx.Encoder) {
+	{
+		if s.Result.Set {
+			e.FieldStart("result")
+			s.Result.Encode(e)
+		}
+	}
 	{
 		if s.Error.Set {
 			e.FieldStart("error")
 			s.Error.Encode(e)
 		}
 	}
+	{
+		if s.UniquePosters.Set {
+			e.FieldStart("unique_posters")
+			s.UniquePosters.Encode(e)
+		}
+	}
 	{
 		if s.Posts != nil {
 			e.FieldStart("posts")
@@ -1911,25 +1923,13 @@ func (s MobileThreadPostsAfter) encodeFields(e *jx.Encoder) {
 			e.ArrEnd()
 		}
 	}
-	{
-		if s.Result.Set {
-			e.FieldStart("result")
-			s.Result.Encode(e)
-		}
-	}
-	{
-		if s.UniquePosters.Set {
-			e.FieldStart("unique_posters")
-			s.UniquePosters.Encode(e)
-		}
-	}
 }
 
 var jsonFieldsNameOfMobileThreadPostsAfter = [4]string{
-	0: "error",
-	1: "posts",
-	2: "result",
-	3: "unique_posters",
+	0: "result",
+	1: "error",
+	2: "unique_posters",
+	3: "posts",
 }
 
 // Decode decodes MobileThreadPostsAfter from json.
@@ -1940,6 +1940,16 @@ func (s *MobileThreadPostsAfter) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
+		case "result":
+			if err := func() error {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"result\"")
+			}
 		case "error":
 			if err := func() error {
 				s.Error.Reset()
@@ -1950,6 +1960,16 @@ func (s *MobileThreadPostsAfter) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"error\"")
 			}
+		case "unique_posters":
+			if err := func() error {
+				s.UniquePosters.Reset()
+				if err := s.UniquePosters.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"unique_posters\"")
+			}
 		case "posts":
 			if err := func() error {
 				s.Posts = make([]Post, 0)
@@ -1967,26 +1987,6 @@ func (s *MobileThreadPostsAfter) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"posts\"")
 			}
-		case "result":
-			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
-			}
-		case "unique_posters":
-			if err := func() error {
-				s.UniquePosters.Reset()
-				if err := s.UniquePosters.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"unique_posters\"")
-			}
 		default:
 			return d.Skip()
 		}
@@ -2255,6 +2255,12 @@ func (s Passcode) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s Passcode) encodeFields(e *jx.Encoder) {
+	{
+		if s.Result.Set {
+			e.FieldStart("result")
+			s.Result.Encode(e)
+		}
+	}
 	{
 		if s.Error.Set {
 			e.FieldStart("error")
@@ -2267,18 +2273,12 @@ func (s Passcode) encodeFields(e *jx.Encoder) {
 			s.Passcode.Encode(e)
 		}
 	}
-	{
-		if s.Result.Set {
-			e.FieldStart("result")
-			s.Result.Encode(e)
-		}
-	}
 }
 
 var jsonFieldsNameOfPasscode = [3]string{
-	0: "error",
-	1: "passcode",
-	2: "result",
+	0: "result",
+	1: "error",
+	2: "passcode",
 }
 
 // Decode decodes Passcode from json.
@@ -2289,6 +2289,16 @@ func (s *Passcode) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
+		case "result":
+			if err := func() error {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"result\"")
+			}
 		case "error":
 			if err := func() error {
 				s.Error.Reset()
@@ -2309,16 +2319,6 @@ func (s *Passcode) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"passcode\"")
 			}
-		case "result":
-			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
-			}
 		default:
 			return d.Skip()
 		}
@@ -2352,23 +2352,23 @@ func (s PasscodePasscode) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s PasscodePasscode) encodeFields(e *jx.Encoder) {
-	{
-		if s.Expires.Set {
-			e.FieldStart("expires")
-			s.Expires.Encode(e)
-		}
-	}
 	{
 		if s.Type.Set {
 			e.FieldStart("type")
 			s.Type.Encode(e)
 		}
 	}
+	{
+		if s.Expires.Set {
+			e.FieldStart("expires")
+			s.Expires.Encode(e)
+		}
+	}
 }
 
 var jsonFieldsNameOfPasscodePasscode = [2]string{
-	0: "expires",
-	1: "type",
+	0: "type",
+	1: "expires",
 }
 
 // Decode decodes PasscodePasscode from json.
@@ -2379,25 +2379,25 @@ func (s *PasscodePasscode) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "expires":
+		case "type":
 			if err := func() error {
-				s.Expires.Reset()
-				if err := s.Expires.Decode(d); err != nil {
+				s.Type.Reset()
+				if err := s.Type.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"expires\"")
+				return errors.Wrap(err, "decode field \"type\"")
 			}
-		case "type":
+		case "expires":
 			if err := func() error {
-				s.Type.Reset()
-				if err := s.Type.Decode(d); err != nil {
+				s.Expires.Reset()
+				if err := s.Expires.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"type\"")
+				return errors.Wrap(err, "decode field \"expires\"")
 			}
 		default:
 			return d.Skip()
@@ -2434,8 +2434,13 @@ func (s Post) Encode(e *jx.Encoder) {
 func (s Post) encodeFields(e *jx.Encoder) {
 	{
 
-		e.FieldStart("banned")
-		e.Int(s.Banned)
+		e.FieldStart("num")
+		e.Int(s.Num)
+	}
+	{
+
+		e.FieldStart("parent")
+		e.Int(s.Parent)
 	}
 	{
 
@@ -2444,35 +2449,35 @@ func (s Post) encodeFields(e *jx.Encoder) {
 	}
 	{
 
-		e.FieldStart("closed")
-		e.Int(s.Closed)
+		e.FieldStart("timestamp")
+		e.Int(s.Timestamp)
 	}
 	{
 
-		e.FieldStart("comment")
-		e.Str(s.Comment)
+		e.FieldStart("lasthit")
+		e.Int(s.Lasthit)
 	}
 	{
 
 		e.FieldStart("date")
 		e.Str(s.Date)
 	}
-	{
-		if s.Dislikes.Set {
-			e.FieldStart("dislikes")
-			s.Dislikes.Encode(e)
-		}
-	}
 	{
 		if s.Email.Set {
 			e.FieldStart("email")
 			s.Email.Encode(e)
 		}
 	}
+	{
+		if s.Subject.Set {
+			e.FieldStart("subject")
+			s.Subject.Encode(e)
+		}
+	}
 	{
 
-		e.FieldStart("endless")
-		e.Int(s.Endless)
+		e.FieldStart("comment")
+		e.Str(s.Comment)
 	}
 	{
 		if s.Files != nil {
@@ -2484,66 +2489,48 @@ func (s Post) encodeFields(e *jx.Encoder) {
 			e.ArrEnd()
 		}
 	}
-	{
-		if s.Icon.Set {
-			e.FieldStart("icon")
-			s.Icon.Encode(e)
-		}
-	}
 	{
 
-		e.FieldStart("lasthit")
-		e.Int(s.Lasthit)
-	}
-	{
-		if s.Likes.Set {
-			e.FieldStart("likes")
-			s.Likes.Encode(e)
-		}
+		e.FieldStart("views")
+		e.Int(s.Views)
 	}
 	{
-		if s.Name.Set {
-			e.FieldStart("name")
-			s.Name.Encode(e)
-		}
+
+		e.FieldStart("sticky")
+		e.Int(s.Sticky)
 	}
 	{
 
-		e.FieldStart("num")
-		e.Int(s.Num)
+		e.FieldStart("endless")
+		e.Int(s.Endless)
 	}
 	{
 
-		e.FieldStart("op")
-		e.Int(s.Op)
+		e.FieldStart("closed")
+		e.Int(s.Closed)
 	}
 	{
 
-		e.FieldStart("parent")
-		e.Int(s.Parent)
+		e.FieldStart("banned")
+		e.Int(s.Banned)
 	}
 	{
 
-		e.FieldStart("sticky")
-		e.Int(s.Sticky)
+		e.FieldStart("op")
+		e.Int(s.Op)
 	}
 	{
-		if s.Subject.Set {
-			e.FieldStart("subject")
-			s.Subject.Encode(e)
+		if s.Name.Set {
+			e.FieldStart("name")
+			s.Name.Encode(e)
 		}
 	}
 	{
-		if s.Tags.Set {
-			e.FieldStart("tags")
-			s.Tags.Encode(e)
+		if s.Icon.Set {
+			e.FieldStart("icon")
+			s.Icon.Encode(e)
 		}
 	}
-	{
-
-		e.FieldStart("timestamp")
-		e.Int(s.Timestamp)
-	}
 	{
 		if s.Trip.Set {
 			e.FieldStart("trip")
@@ -2557,36 +2544,49 @@ func (s Post) encodeFields(e *jx.Encoder) {
 		}
 	}
 	{
-
-		e.FieldStart("views")
-		e.Int(s.Views)
+		if s.Tags.Set {
+			e.FieldStart("tags")
+			s.Tags.Encode(e)
+		}
+	}
+	{
+		if s.Likes.Set {
+			e.FieldStart("likes")
+			s.Likes.Encode(e)
+		}
+	}
+	{
+		if s.Dislikes.Set {
+			e.FieldStart("dislikes")
+			s.Dislikes.Encode(e)
+		}
 	}
 }
 
 var jsonFieldsNameOfPost = [23]string{
-	0:  "banned",
-	1:  "board",
-	2:  "closed",
-	3:  "comment",
-	4:  "date",
-	5:  "dislikes",
+	0:  "num",
+	1:  "parent",
+	2:  "board",
+	3:  "timestamp",
+	4:  "lasthit",
+	5:  "date",
 	6:  "email",
-	7:  "endless",
-	8:  "files",
-	9:  "icon",
-	10: "lasthit",
-	11: "likes",
-	12: "name",
-	13: "num",
-	14: "op",
-	15: "parent",
-	16: "sticky",
-	17: "subject",
-	18: "tags",
-	19: "timestamp",
-	20: "trip",
-	21: "trip_style",
-	22: "views",
+	7:  "subject",
+	8:  "comment",
+	9:  "files",
+	10: "views",
+	11: "sticky",
+	12: "endless",
+	13: "closed",
+	14: "banned",
+	15: "op",
+	16: "name",
+	17: "icon",
+	18: "trip",
+	19: "trip_style",
+	20: "tags",
+	21: "likes",
+	22: "dislikes",
 }
 
 // Decode decodes Post from json.
@@ -2598,20 +2598,32 @@ func (s *Post) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "banned":
+		case "num":
 			requiredBitSet[0] |= 1 << 0
 			if err := func() error {
 				v, err := d.Int()
-				s.Banned = int(v)
+				s.Num = int(v)
+				if err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"num\"")
+			}
+		case "parent":
+			requiredBitSet[0] |= 1 << 1
+			if err := func() error {
+				v, err := d.Int()
+				s.Parent = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"banned\"")
+				return errors.Wrap(err, "decode field \"parent\"")
 			}
 		case "board":
-			requiredBitSet[0] |= 1 << 1
+			requiredBitSet[0] |= 1 << 2
 			if err := func() error {
 				v, err := d.Str()
 				s.Board = string(v)
@@ -2622,32 +2634,32 @@ func (s *Post) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"board\"")
 			}
-		case "closed":
-			requiredBitSet[0] |= 1 << 2
+		case "timestamp":
+			requiredBitSet[0] |= 1 << 3
 			if err := func() error {
 				v, err := d.Int()
-				s.Closed = int(v)
+				s.Timestamp = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"closed\"")
+				return errors.Wrap(err, "decode field \"timestamp\"")
 			}
-		case "comment":
-			requiredBitSet[0] |= 1 << 3
+		case "lasthit":
+			requiredBitSet[0] |= 1 << 4
 			if err := func() error {
-				v, err := d.Str()
-				s.Comment = string(v)
+				v, err := d.Int()
+				s.Lasthit = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"comment\"")
+				return errors.Wrap(err, "decode field \"lasthit\"")
 			}
 		case "date":
-			requiredBitSet[0] |= 1 << 4
+			requiredBitSet[0] |= 1 << 5
 			if err := func() error {
 				v, err := d.Str()
 				s.Date = string(v)
@@ -2658,37 +2670,37 @@ func (s *Post) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"date\"")
 			}
-		case "dislikes":
+		case "email":
 			if err := func() error {
-				s.Dislikes.Reset()
-				if err := s.Dislikes.Decode(d); err != nil {
+				s.Email.Reset()
+				if err := s.Email.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"dislikes\"")
+				return errors.Wrap(err, "decode field \"email\"")
 			}
-		case "email":
+		case "subject":
 			if err := func() error {
-				s.Email.Reset()
-				if err := s.Email.Decode(d); err != nil {
+				s.Subject.Reset()
+				if err := s.Subject.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"email\"")
+				return errors.Wrap(err, "decode field \"subject\"")
 			}
-		case "endless":
-			requiredBitSet[0] |= 1 << 7
+		case "comment":
+			requiredBitSet[1] |= 1 << 0
 			if err := func() error {
-				v, err := d.Int()
-				s.Endless = int(v)
+				v, err := d.Str()
+				s.Comment = string(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"endless\"")
+				return errors.Wrap(err, "decode field \"comment\"")
 			}
 		case "files":
 			if err := func() error {
@@ -2707,159 +2719,147 @@ func (s *Post) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"files\"")
 			}
-		case "icon":
-			if err := func() error {
-				s.Icon.Reset()
-				if err := s.Icon.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"icon\"")
-			}
-		case "lasthit":
+		case "views":
 			requiredBitSet[1] |= 1 << 2
 			if err := func() error {
 				v, err := d.Int()
-				s.Lasthit = int(v)
+				s.Views = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"lasthit\"")
+				return errors.Wrap(err, "decode field \"views\"")
 			}
-		case "likes":
+		case "sticky":
+			requiredBitSet[1] |= 1 << 3
 			if err := func() error {
-				s.Likes.Reset()
-				if err := s.Likes.Decode(d); err != nil {
+				v, err := d.Int()
+				s.Sticky = int(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"likes\"")
+				return errors.Wrap(err, "decode field \"sticky\"")
 			}
-		case "name":
+		case "endless":
+			requiredBitSet[1] |= 1 << 4
 			if err := func() error {
-				s.Name.Reset()
-				if err := s.Name.Decode(d); err != nil {
+				v, err := d.Int()
+				s.Endless = int(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"name\"")
+				return errors.Wrap(err, "decode field \"endless\"")
 			}
-		case "num":
+		case "closed":
 			requiredBitSet[1] |= 1 << 5
 			if err := func() error {
 				v, err := d.Int()
-				s.Num = int(v)
+				s.Closed = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"num\"")
+				return errors.Wrap(err, "decode field \"closed\"")
 			}
-		case "op":
+		case "banned":
 			requiredBitSet[1] |= 1 << 6
 			if err := func() error {
 				v, err := d.Int()
-				s.Op = int(v)
+				s.Banned = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"op\"")
+				return errors.Wrap(err, "decode field \"banned\"")
 			}
-		case "parent":
+		case "op":
 			requiredBitSet[1] |= 1 << 7
 			if err := func() error {
 				v, err := d.Int()
-				s.Parent = int(v)
+				s.Op = int(v)
 				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"parent\"")
+				return errors.Wrap(err, "decode field \"op\"")
 			}
-		case "sticky":
-			requiredBitSet[2] |= 1 << 0
+		case "name":
 			if err := func() error {
-				v, err := d.Int()
-				s.Sticky = int(v)
-				if err != nil {
+				s.Name.Reset()
+				if err := s.Name.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"sticky\"")
+				return errors.Wrap(err, "decode field \"name\"")
 			}
-		case "subject":
+		case "icon":
 			if err := func() error {
-				s.Subject.Reset()
-				if err := s.Subject.Decode(d); err != nil {
+				s.Icon.Reset()
+				if err := s.Icon.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"subject\"")
+				return errors.Wrap(err, "decode field \"icon\"")
 			}
-		case "tags":
+		case "trip":
 			if err := func() error {
-				s.Tags.Reset()
-				if err := s.Tags.Decode(d); err != nil {
+				s.Trip.Reset()
+				if err := s.Trip.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"tags\"")
+				return errors.Wrap(err, "decode field \"trip\"")
 			}
-		case "timestamp":
-			requiredBitSet[2] |= 1 << 3
+		case "trip_style":
 			if err := func() error {
-				v, err := d.Int()
-				s.Timestamp = int(v)
-				if err != nil {
+				s.TripStyle.Reset()
+				if err := s.TripStyle.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"timestamp\"")
+				return errors.Wrap(err, "decode field \"trip_style\"")
 			}
-		case "trip":
+		case "tags":
 			if err := func() error {
-				s.Trip.Reset()
-				if err := s.Trip.Decode(d); err != nil {
+				s.Tags.Reset()
+				if err := s.Tags.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"trip\"")
+				return errors.Wrap(err, "decode field \"tags\"")
 			}
-		case "trip_style":
+		case "likes":
 			if err := func() error {
-				s.TripStyle.Reset()
-				if err := s.TripStyle.Decode(d); err != nil {
+				s.Likes.Reset()
+				if err := s.Likes.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"trip_style\"")
+				return errors.Wrap(err, "decode field \"likes\"")
 			}
-		case "views":
-			requiredBitSet[2] |= 1 << 6
+		case "dislikes":
 			if err := func() error {
-				v, err := d.Int()
-				s.Views = int(v)
-				if err != nil {
+				s.Dislikes.Reset()
+				if err := s.Dislikes.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"views\"")
+				return errors.Wrap(err, "decode field \"dislikes\"")
 			}
 		default:
 			return d.Skip()
@@ -2871,9 +2871,9 @@ func (s *Post) Decode(d *jx.Decoder) error {
 	// Validate required fields.
 	var failures []validate.FieldError
 	for i, mask := range [3]uint8{
-		0b10011111,
-		0b11100100,
-		0b01001001,
+		0b00111111,
+		0b11111101,
+		0b00000000,
 	} {
 		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
 			// Mask only required fields and check equality to mask using XOR.
@@ -2928,6 +2928,12 @@ func (s PostingNewPost) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s PostingNewPost) encodeFields(e *jx.Encoder) {
+	{
+		if s.Result.Set {
+			e.FieldStart("result")
+			s.Result.Encode(e)
+		}
+	}
 	{
 		if s.Error.Set {
 			e.FieldStart("error")
@@ -2940,18 +2946,12 @@ func (s PostingNewPost) encodeFields(e *jx.Encoder) {
 			s.Num.Encode(e)
 		}
 	}
-	{
-		if s.Result.Set {
-			e.FieldStart("result")
-			s.Result.Encode(e)
-		}
-	}
 }
 
 var jsonFieldsNameOfPostingNewPost = [3]string{
-	0: "error",
-	1: "num",
-	2: "result",
+	0: "result",
+	1: "error",
+	2: "num",
 }
 
 // Decode decodes PostingNewPost from json.
@@ -2962,6 +2962,16 @@ func (s *PostingNewPost) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
+		case "result":
+			if err := func() error {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"result\"")
+			}
 		case "error":
 			if err := func() error {
 				s.Error.Reset()
@@ -2982,16 +2992,6 @@ func (s *PostingNewPost) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"num\"")
 			}
-		case "result":
-			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
-			}
 		default:
 			return d.Skip()
 		}
@@ -3025,18 +3025,18 @@ func (s PostingNewThread) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s PostingNewThread) encodeFields(e *jx.Encoder) {
-	{
-		if s.Error.Set {
-			e.FieldStart("error")
-			s.Error.Encode(e)
-		}
-	}
 	{
 		if s.Result.Set {
 			e.FieldStart("result")
 			s.Result.Encode(e)
 		}
 	}
+	{
+		if s.Error.Set {
+			e.FieldStart("error")
+			s.Error.Encode(e)
+		}
+	}
 	{
 		if s.Thread.Set {
 			e.FieldStart("thread")
@@ -3046,8 +3046,8 @@ func (s PostingNewThread) encodeFields(e *jx.Encoder) {
 }
 
 var jsonFieldsNameOfPostingNewThread = [3]string{
-	0: "error",
-	1: "result",
+	0: "result",
+	1: "error",
 	2: "thread",
 }
 
@@ -3059,25 +3059,25 @@ func (s *PostingNewThread) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "error":
+		case "result":
 			if err := func() error {
-				s.Error.Reset()
-				if err := s.Error.Decode(d); err != nil {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"error\"")
+				return errors.Wrap(err, "decode field \"result\"")
 			}
-		case "result":
+		case "error":
 			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
+				s.Error.Reset()
+				if err := s.Error.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
+				return errors.Wrap(err, "decode field \"error\"")
 			}
 		case "thread":
 			if err := func() error {
@@ -3122,23 +3122,23 @@ func (s Report) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s Report) encodeFields(e *jx.Encoder) {
-	{
-		if s.Error.Set {
-			e.FieldStart("error")
-			s.Error.Encode(e)
-		}
-	}
 	{
 		if s.Result.Set {
 			e.FieldStart("result")
 			s.Result.Encode(e)
 		}
 	}
+	{
+		if s.Error.Set {
+			e.FieldStart("error")
+			s.Error.Encode(e)
+		}
+	}
 }
 
 var jsonFieldsNameOfReport = [2]string{
-	0: "error",
-	1: "result",
+	0: "result",
+	1: "error",
 }
 
 // Decode decodes Report from json.
@@ -3149,25 +3149,25 @@ func (s *Report) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "error":
+		case "result":
 			if err := func() error {
-				s.Error.Reset()
-				if err := s.Error.Decode(d); err != nil {
+				s.Result.Reset()
+				if err := s.Result.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"error\"")
+				return errors.Wrap(err, "decode field \"result\"")
 			}
-		case "result":
+		case "error":
 			if err := func() error {
-				s.Result.Reset()
-				if err := s.Result.Decode(d); err != nil {
+				s.Error.Reset()
+				if err := s.Error.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"result\"")
+				return errors.Wrap(err, "decode field \"error\"")
 			}
 		default:
 			return d.Skip()
diff --git a/examples/ex_2ch/oas_request_decoders_gen.go b/examples/ex_2ch/oas_request_decoders_gen.go
index be0afa275..45d46cf9c 100644
--- a/examples/ex_2ch/oas_request_decoders_gen.go
+++ b/examples/ex_2ch/oas_request_decoders_gen.go
@@ -137,7 +137,7 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 			q := uri.NewQueryDecoder(form)
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "board",
+					Name:    "captcha_type",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
@@ -153,10 +153,18 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 							return err
 						}
 
-						optForm.Board = c
+						optForm.CaptchaType = CaptchaType(c)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"board\"")
+						return req, close, errors.Wrap(err, "decode \"captcha_type\"")
+					}
+					if err := func() error {
+						if err := optForm.CaptchaType.Validate(); err != nil {
+							return err
+						}
+						return nil
+					}(); err != nil {
+						return req, close, errors.Wrap(err, "validate")
 					}
 				} else {
 					return req, close, errors.Wrap(err, "query")
@@ -164,7 +172,7 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "captcha_type",
+					Name:    "board",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
@@ -180,18 +188,10 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 							return err
 						}
 
-						optForm.CaptchaType = CaptchaType(c)
+						optForm.Board = c
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"captcha_type\"")
-					}
-					if err := func() error {
-						if err := optForm.CaptchaType.Validate(); err != nil {
-							return err
-						}
-						return nil
-					}(); err != nil {
-						return req, close, errors.Wrap(err, "validate")
+						return req, close, errors.Wrap(err, "decode \"board\"")
 					}
 				} else {
 					return req, close, errors.Wrap(err, "query")
@@ -199,45 +199,45 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "comment",
+					Name:    "thread",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotCommentVal string
+						var optFormDotThreadVal int
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
 								return err
 							}
 
-							c, err := conv.ToString(val)
+							c, err := conv.ToInt(val)
 							if err != nil {
 								return err
 							}
 
-							optFormDotCommentVal = c
+							optFormDotThreadVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Comment.SetTo(optFormDotCommentVal)
+						optForm.Thread.SetTo(optFormDotThreadVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"comment\"")
+						return req, close, errors.Wrap(err, "decode \"thread\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "email",
+					Name:    "name",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotEmailVal string
+						var optFormDotNameVal string
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
@@ -249,93 +249,91 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 								return err
 							}
 
-							optFormDotEmailVal = c
+							optFormDotNameVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Email.SetTo(optFormDotEmailVal)
+						optForm.Name.SetTo(optFormDotNameVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"email\"")
+						return req, close, errors.Wrap(err, "decode \"name\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "file[]",
+					Name:    "email",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						return d.DecodeArray(func(d uri.Decoder) error {
-							var optFormDotFileVal string
-							if err := func() error {
-								val, err := d.DecodeValue()
-								if err != nil {
-									return err
-								}
-
-								c, err := conv.ToString(val)
-								if err != nil {
-									return err
-								}
+						var optFormDotEmailVal string
+						if err := func() error {
+							val, err := d.DecodeValue()
+							if err != nil {
+								return err
+							}
 
-								optFormDotFileVal = c
-								return nil
-							}(); err != nil {
+							c, err := conv.ToString(val)
+							if err != nil {
 								return err
 							}
-							optForm.File = append(optForm.File, optFormDotFileVal)
+
+							optFormDotEmailVal = c
 							return nil
-						})
+						}(); err != nil {
+							return err
+						}
+						optForm.Email.SetTo(optFormDotEmailVal)
+						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"file[]\"")
+						return req, close, errors.Wrap(err, "decode \"email\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "icon",
+					Name:    "tags",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotIconVal int
+						var optFormDotTagsVal string
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
 								return err
 							}
 
-							c, err := conv.ToInt(val)
+							c, err := conv.ToString(val)
 							if err != nil {
 								return err
 							}
 
-							optFormDotIconVal = c
+							optFormDotTagsVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Icon.SetTo(optFormDotIconVal)
+						optForm.Tags.SetTo(optFormDotTagsVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"icon\"")
+						return req, close, errors.Wrap(err, "decode \"tags\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "name",
+					Name:    "subject",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotNameVal string
+						var optFormDotSubjectVal string
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
@@ -347,143 +345,145 @@ func (s *Server) decodeUserPostingPostRequest(r *http.Request, span trace.Span)
 								return err
 							}
 
-							optFormDotNameVal = c
+							optFormDotSubjectVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Name.SetTo(optFormDotNameVal)
+						optForm.Subject.SetTo(optFormDotSubjectVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"name\"")
+						return req, close, errors.Wrap(err, "decode \"subject\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "op_mark",
+					Name:    "comment",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotOpMarkVal int
+						var optFormDotCommentVal string
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
 								return err
 							}
 
-							c, err := conv.ToInt(val)
+							c, err := conv.ToString(val)
 							if err != nil {
 								return err
 							}
 
-							optFormDotOpMarkVal = c
+							optFormDotCommentVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.OpMark.SetTo(optFormDotOpMarkVal)
+						optForm.Comment.SetTo(optFormDotCommentVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"op_mark\"")
+						return req, close, errors.Wrap(err, "decode \"comment\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "subject",
+					Name:    "icon",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotSubjectVal string
+						var optFormDotIconVal int
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
 								return err
 							}
 
-							c, err := conv.ToString(val)
+							c, err := conv.ToInt(val)
 							if err != nil {
 								return err
 							}
 
-							optFormDotSubjectVal = c
+							optFormDotIconVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Subject.SetTo(optFormDotSubjectVal)
+						optForm.Icon.SetTo(optFormDotIconVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"subject\"")
+						return req, close, errors.Wrap(err, "decode \"icon\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "tags",
+					Name:    "op_mark",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotTagsVal string
+						var optFormDotOpMarkVal int
 						if err := func() error {
 							val, err := d.DecodeValue()
 							if err != nil {
 								return err
 							}
 
-							c, err := conv.ToString(val)
+							c, err := conv.ToInt(val)
 							if err != nil {
 								return err
 							}
 
-							optFormDotTagsVal = c
+							optFormDotOpMarkVal = c
 							return nil
 						}(); err != nil {
 							return err
 						}
-						optForm.Tags.SetTo(optFormDotTagsVal)
+						optForm.OpMark.SetTo(optFormDotOpMarkVal)
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"tags\"")
+						return req, close, errors.Wrap(err, "decode \"op_mark\"")
 					}
 				}
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "thread",
+					Name:    "file[]",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
 				if err := q.HasParam(cfg); err == nil {
 					if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
-						var optFormDotThreadVal int
-						if err := func() error {
-							val, err := d.DecodeValue()
-							if err != nil {
-								return err
-							}
+						return d.DecodeArray(func(d uri.Decoder) error {
+							var optFormDotFileVal string
+							if err := func() error {
+								val, err := d.DecodeValue()
+								if err != nil {
+									return err
+								}
 
-							c, err := conv.ToInt(val)
-							if err != nil {
+								c, err := conv.ToString(val)
+								if err != nil {
+									return err
+								}
+
+								optFormDotFileVal = c
+								return nil
+							}(); err != nil {
 								return err
 							}
-
-							optFormDotThreadVal = c
+							optForm.File = append(optForm.File, optFormDotFileVal)
 							return nil
-						}(); err != nil {
-							return err
-						}
-						optForm.Thread.SetTo(optFormDotThreadVal)
-						return nil
+						})
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"thread\"")
+						return req, close, errors.Wrap(err, "decode \"file[]\"")
 					}
 				}
 			}
@@ -567,7 +567,7 @@ func (s *Server) decodeUserReportPostRequest(r *http.Request, span trace.Span) (
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "comment",
+					Name:    "thread",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
@@ -578,15 +578,15 @@ func (s *Server) decodeUserReportPostRequest(r *http.Request, span trace.Span) (
 							return err
 						}
 
-						c, err := conv.ToString(val)
+						c, err := conv.ToInt(val)
 						if err != nil {
 							return err
 						}
 
-						optForm.Comment = c
+						optForm.Thread = c
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"comment\"")
+						return req, close, errors.Wrap(err, "decode \"thread\"")
 					}
 				} else {
 					return req, close, errors.Wrap(err, "query")
@@ -628,7 +628,7 @@ func (s *Server) decodeUserReportPostRequest(r *http.Request, span trace.Span) (
 			}
 			{
 				cfg := uri.QueryParameterDecodingConfig{
-					Name:    "thread",
+					Name:    "comment",
 					Style:   uri.QueryStyleForm,
 					Explode: true,
 				}
@@ -639,15 +639,15 @@ func (s *Server) decodeUserReportPostRequest(r *http.Request, span trace.Span) (
 							return err
 						}
 
-						c, err := conv.ToInt(val)
+						c, err := conv.ToString(val)
 						if err != nil {
 							return err
 						}
 
-						optForm.Thread = c
+						optForm.Comment = c
 						return nil
 					}); err != nil {
-						return req, close, errors.Wrap(err, "decode \"thread\"")
+						return req, close, errors.Wrap(err, "decode \"comment\"")
 					}
 				} else {
 					return req, close, errors.Wrap(err, "query")
diff --git a/examples/ex_2ch/oas_request_encoders_gen.go b/examples/ex_2ch/oas_request_encoders_gen.go
index 997a7a17c..6b894d735 100644
--- a/examples/ex_2ch/oas_request_encoders_gen.go
+++ b/examples/ex_2ch/oas_request_encoders_gen.go
@@ -58,41 +58,41 @@ func encodeUserPostingPostRequest(
 
 	q := uri.NewQueryEncoder()
 	{
-		// Encode "board" form field.
+		// Encode "captcha_type" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "board",
+			Name:    "captcha_type",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			return e.EncodeValue(conv.StringToString(request.Board))
+			return e.EncodeValue(conv.StringToString(string(request.CaptchaType)))
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
 	}
 	{
-		// Encode "captcha_type" form field.
+		// Encode "board" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "captcha_type",
+			Name:    "board",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			return e.EncodeValue(conv.StringToString(string(request.CaptchaType)))
+			return e.EncodeValue(conv.StringToString(request.Board))
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
 	}
 	{
-		// Encode "comment" form field.
+		// Encode "thread" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "comment",
+			Name:    "thread",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Comment.Get(); ok {
-				return e.EncodeValue(conv.StringToString(val))
+			if val, ok := request.Thread.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -100,14 +100,14 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "email" form field.
+		// Encode "name" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "email",
+			Name:    "name",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Email.Get(); ok {
+			if val, ok := request.Name.Get(); ok {
 				return e.EncodeValue(conv.StringToString(val))
 			}
 			return nil
@@ -116,37 +116,31 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "file[]" form field.
+		// Encode "email" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "file[]",
+			Name:    "email",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			return e.EncodeArray(func(e uri.Encoder) error {
-				for i, item := range request.File {
-					if err := func() error {
-						return e.EncodeValue(conv.StringToString(item))
-					}(); err != nil {
-						return errors.Wrapf(err, "[%d]", i)
-					}
-				}
-				return nil
-			})
+			if val, ok := request.Email.Get(); ok {
+				return e.EncodeValue(conv.StringToString(val))
+			}
+			return nil
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
 	}
 	{
-		// Encode "icon" form field.
+		// Encode "tags" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "icon",
+			Name:    "tags",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Icon.Get(); ok {
-				return e.EncodeValue(conv.IntToString(val))
+			if val, ok := request.Tags.Get(); ok {
+				return e.EncodeValue(conv.StringToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -154,14 +148,14 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "name" form field.
+		// Encode "subject" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "name",
+			Name:    "subject",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Name.Get(); ok {
+			if val, ok := request.Subject.Get(); ok {
 				return e.EncodeValue(conv.StringToString(val))
 			}
 			return nil
@@ -170,15 +164,15 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "op_mark" form field.
+		// Encode "comment" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "op_mark",
+			Name:    "comment",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.OpMark.Get(); ok {
-				return e.EncodeValue(conv.IntToString(val))
+			if val, ok := request.Comment.Get(); ok {
+				return e.EncodeValue(conv.StringToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -186,15 +180,15 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "subject" form field.
+		// Encode "icon" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "subject",
+			Name:    "icon",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Subject.Get(); ok {
-				return e.EncodeValue(conv.StringToString(val))
+			if val, ok := request.Icon.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -202,15 +196,15 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "tags" form field.
+		// Encode "op_mark" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "tags",
+			Name:    "op_mark",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Tags.Get(); ok {
-				return e.EncodeValue(conv.StringToString(val))
+			if val, ok := request.OpMark.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
 			}
 			return nil
 		}); err != nil {
@@ -218,17 +212,23 @@ func encodeUserPostingPostRequest(
 		}
 	}
 	{
-		// Encode "thread" form field.
+		// Encode "file[]" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "thread",
+			Name:    "file[]",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			if val, ok := request.Thread.Get(); ok {
-				return e.EncodeValue(conv.IntToString(val))
-			}
-			return nil
+			return e.EncodeArray(func(e uri.Encoder) error {
+				for i, item := range request.File {
+					if err := func() error {
+						return e.EncodeValue(conv.StringToString(item))
+					}(); err != nil {
+						return errors.Wrapf(err, "[%d]", i)
+					}
+				}
+				return nil
+			})
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
@@ -267,14 +267,14 @@ func encodeUserReportPostRequest(
 		}
 	}
 	{
-		// Encode "comment" form field.
+		// Encode "thread" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "comment",
+			Name:    "thread",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			return e.EncodeValue(conv.StringToString(request.Comment))
+			return e.EncodeValue(conv.IntToString(request.Thread))
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
@@ -302,14 +302,14 @@ func encodeUserReportPostRequest(
 		}
 	}
 	{
-		// Encode "thread" form field.
+		// Encode "comment" form field.
 		cfg := uri.QueryParameterEncodingConfig{
-			Name:    "thread",
+			Name:    "comment",
 			Style:   uri.QueryStyleForm,
 			Explode: true,
 		}
 		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
-			return e.EncodeValue(conv.IntToString(request.Thread))
+			return e.EncodeValue(conv.StringToString(request.Comment))
 		}); err != nil {
 			return errors.Wrap(err, "encode query")
 		}
diff --git a/examples/ex_2ch/oas_schemas_gen.go b/examples/ex_2ch/oas_schemas_gen.go
index 775dd5985..99482fc74 100644
--- a/examples/ex_2ch/oas_schemas_gen.go
+++ b/examples/ex_2ch/oas_schemas_gen.go
@@ -21,43 +21,43 @@ type APICaptchaRecaptchaMobileGetOK struct{}
 // Модель доски.
 // Ref: #/components/schemas/Board
 type Board struct {
+	ID       string "json:\"id\""
+	Name     string "json:\"name\""
+	Category string "json:\"category\""
+	// Информация о доске.
+	Info string "json:\"info\""
+	// Информация о доске для главной.
+	InfoOuter        string   "json:\"info_outer\""
+	ThreadsPerPage   int      "json:\"threads_per_page\""
 	BumpLimit        int      "json:\"bump_limit\""
-	Category         string   "json:\"category\""
+	MaxPages         int      "json:\"max_pages\""
 	DefaultName      string   "json:\"default_name\""
-	EnableDices      bool     "json:\"enable_dices\""
-	EnableFlags      bool     "json:\"enable_flags\""
-	EnableIcons      bool     "json:\"enable_icons\""
-	EnableLikes      bool     "json:\"enable_likes\""
 	EnableNames      bool     "json:\"enable_names\""
-	EnableOekaki     bool     "json:\"enable_oekaki\""
-	EnablePosting    bool     "json:\"enable_posting\""
+	EnableTrips      bool     "json:\"enable_trips\""
+	EnableSubject    bool     "json:\"enable_subject\""
 	EnableSage       bool     "json:\"enable_sage\""
+	EnableIcons      bool     "json:\"enable_icons\""
+	EnableFlags      bool     "json:\"enable_flags\""
+	EnableDices      bool     "json:\"enable_dices\""
 	EnableShield     bool     "json:\"enable_shield\""
-	EnableSubject    bool     "json:\"enable_subject\""
 	EnableThreadTags bool     "json:\"enable_thread_tags\""
-	EnableTrips      bool     "json:\"enable_trips\""
+	EnablePosting    bool     "json:\"enable_posting\""
+	EnableLikes      bool     "json:\"enable_likes\""
+	EnableOekaki     bool     "json:\"enable_oekaki\""
 	FileTypes        []string "json:\"file_types\""
+	MaxComment       int      "json:\"max_comment\""
+	MaxFilesSize     int      "json:\"max_files_size\""
+	// Массив тегов, которые доступны на этой доске, если они
+	// включены.
+	Tags []string "json:\"tags\""
 	// Массив иконок, которые доступны на этой доске, если
 	// они включены.
 	Icons []BoardIconsItem "json:\"icons\""
-	ID    string           "json:\"id\""
-	// Информация о доске.
-	Info string "json:\"info\""
-	// Информация о доске для главной.
-	InfoOuter    string "json:\"info_outer\""
-	MaxComment   int    "json:\"max_comment\""
-	MaxFilesSize int    "json:\"max_files_size\""
-	MaxPages     int    "json:\"max_pages\""
-	Name         string "json:\"name\""
-	// Массив тегов, которые доступны на этой доске, если они
-	// включены.
-	Tags           []string "json:\"tags\""
-	ThreadsPerPage int      "json:\"threads_per_page\""
 }
 
 type BoardIconsItem struct {
-	Name OptString "json:\"name\""
 	Num  OptInt    "json:\"num\""
+	Name OptString "json:\"name\""
 	URL  OptString "json:\"url\""
 }
 
@@ -65,11 +65,13 @@ type Boards []Board
 
 // Ref: #/components/schemas/Captcha
 type Captcha struct {
-	Error OptError "json:\"error\""
+	Result int         "json:\"result\""
+	Error  OptError    "json:\"error\""
+	Type   CaptchaType "json:\"type\""
+	ID     string      "json:\"id\""
 	// Время в секундах после которого id перестанет
 	// действовать.
 	Expires OptInt "json:\"expires\""
-	ID      string "json:\"id\""
 	// Тип текста, изображённого на картинке капчи.
 	// Возможные варианты:
 	// * numeric - только цифры. (0123456789)
@@ -78,9 +80,7 @@ type Captcha struct {
 	// (0123456789абвгдеёжзийклмнопрстуфхцчшщъыьэюя)
 	// * all - цифры, русские и английские буквы.
 	// (0123456789abcdefghijklmnopqrstuvwxyzабвгдеёжзийклмнопрстуфхцчшщъыьэюя).
-	Input  OptString   "json:\"input\""
-	Result int         "json:\"result\""
-	Type   CaptchaType "json:\"type\""
+	Input OptString "json:\"input\""
 }
 
 // Каждый тип капчи так же требует дополнительные
@@ -213,34 +213,34 @@ const (
 // Модель файла.
 // Ref: #/components/schemas/File
 type File struct {
-	Displayname string "json:\"displayname\""
+	Name        string    "json:\"name\""
+	Fullname    string    "json:\"fullname\""
+	Displayname string    "json:\"displayname\""
+	Path        string    "json:\"path\""
+	Thumbnail   string    "json:\"thumbnail\""
+	MD5         OptString "json:\"md5\""
+	Type        FileType  "json:\"type\""
+	// Размер файла, в КБ.
+	Size     int "json:\"size\""
+	Width    int "json:\"width\""
+	Height   int "json:\"height\""
+	TnWidth  int "json:\"tn_width\""
+	TnHeight int "json:\"tn_height\""
+	// Если >= 0, файл содержит NSFW контент, в данный момент
+	// реализовано не на всех досках.
+	Nsfw OptInt "json:\"nsfw\""
 	// В случае видео/аудио файла, содержит
 	// продолжительность в формате XX:XX:XX.
 	Duration OptString "json:\"duration\""
 	// В случае видео/аудио файла, содержит
 	// продолжительность в секундах.
 	DurationSecs OptInt "json:\"duration_secs\""
-	Fullname     string "json:\"fullname\""
-	Height       int    "json:\"height\""
-	// В случае стикера, содержит ссылку на установку.
-	Install OptString "json:\"install\""
-	MD5     OptString "json:\"md5\""
-	Name    string    "json:\"name\""
-	// Если >= 0, файл содержит NSFW контент, в данный момент
-	// реализовано не на всех досках.
-	Nsfw OptInt "json:\"nsfw\""
 	// В случае стикера, содержит ID стикер пака.
 	Pack OptString "json:\"pack\""
-	Path string    "json:\"path\""
-	// Размер файла, в КБ.
-	Size int "json:\"size\""
 	// В случае стикера, содержит ID стикера.
-	Sticker   OptString "json:\"sticker\""
-	Thumbnail string    "json:\"thumbnail\""
-	TnHeight  int       "json:\"tn_height\""
-	TnWidth   int       "json:\"tn_width\""
-	Type      FileType  "json:\"type\""
-	Width     int       "json:\"width\""
+	Sticker OptString "json:\"sticker\""
+	// В случае стикера, содержит ссылку на установку.
+	Install OptString "json:\"install\""
 }
 
 // * 0 FileTypeNone
@@ -273,36 +273,36 @@ const (
 
 // Ref: #/components/schemas/Like
 type Like struct {
-	Error  OptError "json:\"error\""
 	Result OptInt   "json:\"result\""
+	Error  OptError "json:\"error\""
 }
 
 // Ref: #/components/schemas/MobilePost
 type MobilePost struct {
+	Result OptInt   "json:\"result\""
 	Error  OptError "json:\"error\""
 	Post   OptPost  "json:\"post\""
-	Result OptInt   "json:\"result\""
 }
 
 // Ref: #/components/schemas/MobileThreadLastInfo
 type MobileThreadLastInfo struct {
-	Error  OptError                      "json:\"error\""
 	Result OptInt                        "json:\"result\""
+	Error  OptError                      "json:\"error\""
 	Thread OptMobileThreadLastInfoThread "json:\"thread\""
 }
 
 type MobileThreadLastInfoThread struct {
 	Num       OptInt "json:\"num\""
-	Posts     OptInt "json:\"posts\""
 	Timestamp OptInt "json:\"timestamp\""
+	Posts     OptInt "json:\"posts\""
 }
 
 // Ref: #/components/schemas/MobileThreadPostsAfter
 type MobileThreadPostsAfter struct {
-	Error         OptError "json:\"error\""
-	Posts         []Post   "json:\"posts\""
 	Result        OptInt   "json:\"result\""
+	Error         OptError "json:\"error\""
 	UniquePosters OptInt   "json:\"unique_posters\""
+	Posts         []Post   "json:\"posts\""
 }
 
 // NewOptError returns new OptError with value set to v.
@@ -813,64 +813,64 @@ func (o OptUserReportPostReq) Or(d UserReportPostReq) UserReportPostReq {
 
 // Ref: #/components/schemas/Passcode
 type Passcode struct {
+	Result   OptInt              "json:\"result\""
 	Error    OptError            "json:\"error\""
 	Passcode OptPasscodePasscode "json:\"passcode\""
-	Result   OptInt              "json:\"result\""
 }
 
 type PasscodePasscode struct {
-	Expires OptInt    "json:\"expires\""
 	Type    OptString "json:\"type\""
+	Expires OptInt    "json:\"expires\""
 }
 
 // Модель поста.
 // Ref: #/components/schemas/Post
 type Post struct {
-	Banned    int       "json:\"banned\""
+	Num       int       "json:\"num\""
+	Parent    int       "json:\"parent\""
 	Board     string    "json:\"board\""
-	Closed    int       "json:\"closed\""
-	Comment   string    "json:\"comment\""
+	Timestamp int       "json:\"timestamp\""
+	Lasthit   int       "json:\"lasthit\""
 	Date      string    "json:\"date\""
-	Dislikes  OptInt    "json:\"dislikes\""
 	Email     OptString "json:\"email\""
-	Endless   int       "json:\"endless\""
+	Subject   OptString "json:\"subject\""
+	Comment   string    "json:\"comment\""
 	Files     []File    "json:\"files\""
-	Icon      OptString "json:\"icon\""
-	Lasthit   int       "json:\"lasthit\""
-	Likes     OptInt    "json:\"likes\""
-	Name      OptString "json:\"name\""
-	Num       int       "json:\"num\""
-	Op        int       "json:\"op\""
-	Parent    int       "json:\"parent\""
+	Views     int       "json:\"views\""
 	Sticky    int       "json:\"sticky\""
-	Subject   OptString "json:\"subject\""
-	Tags      OptString "json:\"tags\""
-	Timestamp int       "json:\"timestamp\""
+	Endless   int       "json:\"endless\""
+	Closed    int       "json:\"closed\""
+	Banned    int       "json:\"banned\""
+	Op        int       "json:\"op\""
+	Name      OptString "json:\"name\""
+	Icon      OptString "json:\"icon\""
 	Trip      OptString "json:\"trip\""
 	TripStyle OptString "json:\"trip_style\""
-	Views     int       "json:\"views\""
+	Tags      OptString "json:\"tags\""
+	Likes     OptInt    "json:\"likes\""
+	Dislikes  OptInt    "json:\"dislikes\""
 }
 
 // Ref: #/components/schemas/PostingNewPost
 type PostingNewPost struct {
-	Error OptError "json:\"error\""
+	Result OptInt   "json:\"result\""
+	Error  OptError "json:\"error\""
 	// Номер нового поста.
-	Num    OptInt "json:\"num\""
-	Result OptInt "json:\"result\""
+	Num OptInt "json:\"num\""
 }
 
 // Ref: #/components/schemas/PostingNewThread
 type PostingNewThread struct {
-	Error  OptError "json:\"error\""
 	Result OptInt   "json:\"result\""
+	Error  OptError "json:\"error\""
 	// Номер нового треда.
 	Thread OptInt "json:\"thread\""
 }
 
 // Ref: #/components/schemas/Report
 type Report struct {
-	Error  OptError "json:\"error\""
 	Result OptInt   "json:\"result\""
+	Error  OptError "json:\"error\""
 }
 
 type UserPassloginPostReq struct {
@@ -944,33 +944,33 @@ func NewPostingNewPostUserPostingPostOK(v PostingNewPost) UserPostingPostOK {
 }
 
 type UserPostingPostReq struct {
-	Board       string      "json:\"board\""
 	CaptchaType CaptchaType "json:\"captcha_type\""
-	Comment     OptString   "json:\"comment\""
+	Board       string      "json:\"board\""
+	// Если не указано, будет создан тред.
+	Thread OptInt "json:\"thread\""
 	// Если не включено в настройках доски - поле будет
 	// проигнорировано.
-	Email OptString "json:\"email\""
-	File  []string  "json:\"file[]\""
-	Icon  OptInt    "json:\"icon\""
+	Name OptString "json:\"name\""
 	// Если не включено в настройках доски - поле будет
 	// проигнорировано.
-	Name OptString "json:\"name\""
+	Email OptString "json:\"email\""
 	// Если не включено в настройках доски - поле будет
 	// проигнорировано.
-	OpMark OptInt "json:\"op_mark\""
+	Tags OptString "json:\"tags\""
 	// Если не включено в настройках доски - поле будет
 	// проигнорировано.
 	Subject OptString "json:\"subject\""
+	Comment OptString "json:\"comment\""
+	Icon    OptInt    "json:\"icon\""
 	// Если не включено в настройках доски - поле будет
 	// проигнорировано.
-	Tags OptString "json:\"tags\""
-	// Если не указано, будет создан тред.
-	Thread OptInt "json:\"thread\""
+	OpMark OptInt   "json:\"op_mark\""
+	File   []string "json:\"file[]\""
 }
 
 type UserReportPostReq struct {
 	Board   string "json:\"board\""
-	Comment string "json:\"comment\""
-	Post    []int  "json:\"post\""
 	Thread  int    "json:\"thread\""
+	Post    []int  "json:\"post\""
+	Comment string "json:\"comment\""
 }
diff --git a/examples/go.mod b/examples/go.mod
index 70f55045c..851e18ca0 100644
--- a/examples/go.mod
+++ b/examples/go.mod
@@ -16,7 +16,6 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/go-json-experiment/json v0.0.0-20220620174529-794765d0bd38 // indirect
 	github.com/go-logr/logr v1.2.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
@@ -25,7 +24,6 @@ require (
 	go.uber.org/atomic v1.9.0 // indirect
 	golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f // indirect
 	golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 
diff --git a/examples/go.sum b/examples/go.sum
index d013a9a9a..4a2365734 100644
--- a/examples/go.sum
+++ b/examples/go.sum
@@ -3,7 +3,6 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI=
 github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY=
 github.com/go-faster/jx v0.38.0 h1:8nVYdlMfFt9/sdpgQ7ov0+PQ0rzXTphOeVVQ71YBc8Y=
@@ -56,7 +55,6 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/internal/test_allof/oas_faker_gen.go b/internal/test_allof/oas_faker_gen.go
index d9a00faf4..21e5f7088 100644
--- a/internal/test_allof/oas_faker_gen.go
+++ b/internal/test_allof/oas_faker_gen.go
@@ -22,11 +22,6 @@ func (s *Location) SetFake() {
 
 // SetFake set fake values.
 func (s *ObjectsWithConflictingArrayPropertyReq) SetFake() {
-	{
-		{
-			s.Bar = int(0)
-		}
-	}
 	{
 		{
 			s.Foo = nil
@@ -39,18 +34,23 @@ func (s *ObjectsWithConflictingArrayPropertyReq) SetFake() {
 			}
 		}
 	}
+	{
+		{
+			s.Bar = int(0)
+		}
+	}
 }
 
 // SetFake set fake values.
 func (s *ObjectsWithConflictingPropertiesReq) SetFake() {
 	{
 		{
-			s.Bar.SetFake()
+			s.Foo = "string"
 		}
 	}
 	{
 		{
-			s.Foo = "string"
+			s.Bar.SetFake()
 		}
 	}
 }
diff --git a/internal/test_allof/oas_json_gen.go b/internal/test_allof/oas_json_gen.go
index f33f11663..19f4f4c46 100644
--- a/internal/test_allof/oas_json_gen.go
+++ b/internal/test_allof/oas_json_gen.go
@@ -137,11 +137,6 @@ func (s ObjectsWithConflictingArrayPropertyReq) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s ObjectsWithConflictingArrayPropertyReq) encodeFields(e *jx.Encoder) {
-	{
-
-		e.FieldStart("bar")
-		e.Int(s.Bar)
-	}
 	{
 
 		e.FieldStart("foo")
@@ -151,11 +146,16 @@ func (s ObjectsWithConflictingArrayPropertyReq) encodeFields(e *jx.Encoder) {
 		}
 		e.ArrEnd()
 	}
+	{
+
+		e.FieldStart("bar")
+		e.Int(s.Bar)
+	}
 }
 
 var jsonFieldsNameOfObjectsWithConflictingArrayPropertyReq = [2]string{
-	0: "bar",
-	1: "foo",
+	0: "foo",
+	1: "bar",
 }
 
 // Decode decodes ObjectsWithConflictingArrayPropertyReq from json.
@@ -167,20 +167,8 @@ func (s *ObjectsWithConflictingArrayPropertyReq) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "bar":
-			requiredBitSet[0] |= 1 << 0
-			if err := func() error {
-				v, err := d.Int()
-				s.Bar = int(v)
-				if err != nil {
-					return err
-				}
-				return nil
-			}(); err != nil {
-				return errors.Wrap(err, "decode field \"bar\"")
-			}
 		case "foo":
-			requiredBitSet[0] |= 1 << 1
+			requiredBitSet[0] |= 1 << 0
 			if err := func() error {
 				s.Foo = make([]int, 0)
 				if err := d.Arr(func(d *jx.Decoder) error {
@@ -199,6 +187,18 @@ func (s *ObjectsWithConflictingArrayPropertyReq) Decode(d *jx.Decoder) error {
 			}(); err != nil {
 				return errors.Wrap(err, "decode field \"foo\"")
 			}
+		case "bar":
+			requiredBitSet[0] |= 1 << 1
+			if err := func() error {
+				v, err := d.Int()
+				s.Bar = int(v)
+				if err != nil {
+					return err
+				}
+				return nil
+			}(); err != nil {
+				return errors.Wrap(err, "decode field \"bar\"")
+			}
 		default:
 			return d.Skip()
 		}
@@ -264,22 +264,22 @@ func (s ObjectsWithConflictingPropertiesReq) Encode(e *jx.Encoder) {
 
 // encodeFields encodes fields.
 func (s ObjectsWithConflictingPropertiesReq) encodeFields(e *jx.Encoder) {
+	{
+
+		e.FieldStart("foo")
+		e.Str(s.Foo)
+	}
 	{
 		if s.Bar.Set {
 			e.FieldStart("bar")
 			s.Bar.Encode(e)
 		}
 	}
-	{
-
-		e.FieldStart("foo")
-		e.Str(s.Foo)
-	}
 }
 
 var jsonFieldsNameOfObjectsWithConflictingPropertiesReq = [2]string{
-	0: "bar",
-	1: "foo",
+	0: "foo",
+	1: "bar",
 }
 
 // Decode decodes ObjectsWithConflictingPropertiesReq from json.
@@ -291,27 +291,27 @@ func (s *ObjectsWithConflictingPropertiesReq) Decode(d *jx.Decoder) error {
 
 	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
 		switch string(k) {
-		case "bar":
+		case "foo":
+			requiredBitSet[0] |= 1 << 0
 			if err := func() error {
-				s.Bar.Reset()
-				if err := s.Bar.Decode(d); err != nil {
+				v, err := d.Str()
+				s.Foo = string(v)
+				if err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"bar\"")
+				return errors.Wrap(err, "decode field \"foo\"")
 			}
-		case "foo":
-			requiredBitSet[0] |= 1 << 1
+		case "bar":
 			if err := func() error {
-				v, err := d.Str()
-				s.Foo = string(v)
-				if err != nil {
+				s.Bar.Reset()
+				if err := s.Bar.Decode(d); err != nil {
 					return err
 				}
 				return nil
 			}(); err != nil {
-				return errors.Wrap(err, "decode field \"foo\"")
+				return errors.Wrap(err, "decode field \"bar\"")
 			}
 		default:
 			return d.Skip()
@@ -323,7 +323,7 @@ func (s *ObjectsWithConflictingPropertiesReq) Decode(d *jx.Decoder) error {
 	// Validate required fields.
 	var failures []validate.FieldError
 	for i, mask := range [1]uint8{
-		0b00000010,
+		0b00000001,
 	} {
 		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
 			// Mask only required fields and check equality to mask using XOR.
diff --git a/internal/test_allof/oas_schemas_gen.go b/internal/test_allof/oas_schemas_gen.go
index 02c13404b..c636e3c41 100644
--- a/internal/test_allof/oas_schemas_gen.go
+++ b/internal/test_allof/oas_schemas_gen.go
@@ -20,9 +20,9 @@ type ObjectsWithConflictingArrayPropertyOK struct{}
 
 // Merged schema.
 type ObjectsWithConflictingArrayPropertyReq struct {
-	Bar int "json:\"bar\""
 	// Merged property.
 	Foo []int "json:\"foo\""
+	Bar int   "json:\"bar\""
 }
 
 // ObjectsWithConflictingPropertiesOK is response for ObjectsWithConflictingProperties operation.
@@ -30,9 +30,9 @@ type ObjectsWithConflictingPropertiesOK struct{}
 
 // Merged schema.
 type ObjectsWithConflictingPropertiesReq struct {
-	Bar OptInt "json:\"bar\""
 	// Merged property.
 	Foo string "json:\"foo\""
+	Bar OptInt "json:\"bar\""
 }
 
 // NewOptBool returns new OptBool with value set to v.
diff --git a/internal/test_allof/oas_validators_gen.go b/internal/test_allof/oas_validators_gen.go
index 0589460b4..fd184bd00 100644
--- a/internal/test_allof/oas_validators_gen.go
+++ b/internal/test_allof/oas_validators_gen.go
@@ -39,6 +39,25 @@ func (s Location) Validate() error {
 }
 func (s ObjectsWithConflictingArrayPropertyReq) Validate() error {
 	var failures []validate.FieldError
+	if err := func() error {
+		if s.Foo == nil {
+			return errors.New("nil is invalid value")
+		}
+		if err := (validate.Array{
+			MinLength:    1,
+			MinLengthSet: true,
+			MaxLength:    5,
+			MaxLengthSet: true,
+		}).ValidateLength(len(s.Foo)); err != nil {
+			return errors.Wrap(err, "array")
+		}
+		return nil
+	}(); err != nil {
+		failures = append(failures, validate.FieldError{
+			Name:  "foo",
+			Error: err,
+		})
+	}
 	if err := func() error {
 		if err := (validate.Int{
 			MinSet:        true,
@@ -59,17 +78,24 @@ func (s ObjectsWithConflictingArrayPropertyReq) Validate() error {
 			Error: err,
 		})
 	}
+	if len(failures) > 0 {
+		return &validate.Error{Fields: failures}
+	}
+	return nil
+}
+func (s ObjectsWithConflictingPropertiesReq) Validate() error {
+	var failures []validate.FieldError
 	if err := func() error {
-		if s.Foo == nil {
-			return errors.New("nil is invalid value")
-		}
-		if err := (validate.Array{
-			MinLength:    1,
+		if err := (validate.String{
+			MinLength:    10,
 			MinLengthSet: true,
-			MaxLength:    5,
-			MaxLengthSet: true,
-		}).ValidateLength(len(s.Foo)); err != nil {
-			return errors.Wrap(err, "array")
+			MaxLength:    0,
+			MaxLengthSet: false,
+			Email:        false,
+			Hostname:     false,
+			Regex:        nil,
+		}).Validate(string(s.Foo)); err != nil {
+			return errors.Wrap(err, "string")
 		}
 		return nil
 	}(); err != nil {
@@ -78,13 +104,6 @@ func (s ObjectsWithConflictingArrayPropertyReq) Validate() error {
 			Error: err,
 		})
 	}
-	if len(failures) > 0 {
-		return &validate.Error{Fields: failures}
-	}
-	return nil
-}
-func (s ObjectsWithConflictingPropertiesReq) Validate() error {
-	var failures []validate.FieldError
 	if err := func() error {
 		if s.Bar.Set {
 			if err := func() error {
@@ -112,25 +131,6 @@ func (s ObjectsWithConflictingPropertiesReq) Validate() error {
 			Error: err,
 		})
 	}
-	if err := func() error {
-		if err := (validate.String{
-			MinLength:    10,
-			MinLengthSet: true,
-			MaxLength:    0,
-			MaxLengthSet: false,
-			Email:        false,
-			Hostname:     false,
-			Regex:        nil,
-		}).Validate(string(s.Foo)); err != nil {
-			return errors.Wrap(err, "string")
-		}
-		return nil
-	}(); err != nil {
-		failures = append(failures, validate.FieldError{
-			Name:  "foo",
-			Error: err,
-		})
-	}
 	if len(failures) > 0 {
 		return &validate.Error{Fields: failures}
 	}