From 56c87835e3da3816e122893ebefe6a09182076bd Mon Sep 17 00:00:00 2001 From: Michael McLoughlin Date: Sun, 27 Nov 2022 15:39:31 -0800 Subject: [PATCH] fix reproducibility bug and regenerate --- build/zinstructions.go | 20 +- internal/inst/types.go | 16 + internal/inst/ztable.go | 69 +++ internal/load/load.go | 6 +- internal/opcodesextra/instructions.go | 9 +- x86/zctors.go | 10 +- x86/zctors_test.go | 18 + x86/zoptab.go | 792 +++++++++++++------------- 8 files changed, 536 insertions(+), 404 deletions(-) diff --git a/build/zinstructions.go b/build/zinstructions.go index 1251500b..a0cffd79 100644 --- a/build/zinstructions.go +++ b/build/zinstructions.go @@ -49999,9 +49999,12 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) { ctx.VGETMANTSS_Z(i, mx, x, k, x1 // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { @@ -50018,9 +50021,12 @@ func (c *Context) VGF2P8AFFINEINVQB(ops ...operand.Op) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB instruction to the active function. // Operates on the global context. @@ -50089,12 +50095,15 @@ func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) { // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. -func (c *Context) VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { - c.addinstruction(x86.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1)) +func (c *Context) VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { + c.addinstruction(x86.VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1)) } // VGF2P8AFFINEINVQB_Z: Galois Field Affine Transformation Inverse (Zeroing Masking). @@ -50102,12 +50111,17 @@ func (c *Context) VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm // // Construct and append a VGF2P8AFFINEINVQB.Z instruction to the active function. // Operates on the global context. -func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) { ctx.VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1) } +func VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) { + ctx.VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1) +} // VGF2P8AFFINEQB: Galois Field Affine Transformation. // diff --git a/internal/inst/types.go b/internal/inst/types.go index 0d65b96c..8d591c91 100644 --- a/internal/inst/types.go +++ b/internal/inst/types.go @@ -40,6 +40,13 @@ func (i Instruction) IsConditionalBranch() bool { return i.IsBranch() && i.Opcode != "JMP" } +// Clone the instruction. +func (i Instruction) Clone() Instruction { + c := i + c.Forms = i.Forms.Clone() + return c +} + // Forms is a collection of instruction forms. type Forms []Form @@ -78,6 +85,15 @@ func (fs Forms) IsNiladic() bool { return len(a) == 1 && a[0] == 0 } +// Clone the instruction forms. +func (fs Forms) Clone() Forms { + cs := make(Forms, 0, len(fs)) + for _, f := range fs { + cs = append(cs, f.Clone()) + } + return cs +} + // Form specifies one accepted set of operands for an instruction. type Form struct { // Instruction sets this instruction form requires. diff --git a/internal/inst/ztable.go b/internal/inst/ztable.go index 86333d80..bfb50fac 100644 --- a/internal/inst/ztable.go +++ b/internal/inst/ztable.go @@ -50685,6 +50685,29 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512F", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "zmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "zmm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, { ISA: []string{"AVX512F", "GFNI"}, Operands: []Operand{ @@ -50813,6 +50836,52 @@ var Instructions = []Instruction{ EncodingType: 0x4, Broadcast: true, }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "xmm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "xmm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x3}, + }, + EncodingType: 0x4, + }, + { + ISA: []string{"AVX512VL", "GFNI"}, + Operands: []Operand{ + {Type: "imm8", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "ymm", Action: 0x1}, + {Type: "k", Action: 0x1}, + {Type: "ymm", Action: 0x2}, + }, + EncodingType: 0x4, + Zeroing: true, + }, }, }, { diff --git a/internal/load/load.go b/internal/load/load.go index 1274106b..0cdb6743 100644 --- a/internal/load/load.go +++ b/internal/load/load.go @@ -126,6 +126,7 @@ func (l *Loader) Load() ([]inst.Instruction, error) { // Convert to a slice. Sort instructions and forms for reproducibility. is := make([]inst.Instruction, 0, len(im)) for _, i := range im { + sortforms(i.Forms) is = append(is, *i) } @@ -133,10 +134,6 @@ func (l *Loader) Load() ([]inst.Instruction, error) { return is[i].Opcode < is[j].Opcode }) - for _, i := range im { - sortforms(i.Forms) - } - return is, nil } @@ -834,7 +831,6 @@ func vexevex(fs []inst.Form) ([]inst.Form, error) { } if group[0].EncodingType != inst.EncodingTypeVEX || group[1].EncodingType != inst.EncodingTypeEVEX { - fmt.Println(group) return nil, errors.New("expected pair of VEX/EVEX encoded forms") } diff --git a/internal/opcodesextra/instructions.go b/internal/opcodesextra/instructions.go index d4834316..b4916e80 100644 --- a/internal/opcodesextra/instructions.go +++ b/internal/opcodesextra/instructions.go @@ -11,9 +11,16 @@ var sets = [][]*inst.Instruction{ // Instructions returns a list of extras to add to the instructions database. func Instructions() []*inst.Instruction { + // Concatenate and clone the instruction lists. It can be convenient for + // forms lists and other data structures to be shared in the curated lists, + // but we want to return distinct copies here to avoid subtle bugs in + // consumers. var is []*inst.Instruction for _, set := range sets { - is = append(is, set...) + for _, i := range set { + c := i.Clone() + is = append(is, &c) + } } return is } diff --git a/x86/zctors.go b/x86/zctors.go index 74b36f1d..85a2ee6a 100644 --- a/x86/zctors.go +++ b/x86/zctors.go @@ -21960,9 +21960,12 @@ func VGETMANTSS_Z(i, mx, x, k, x1 operand.Op) (*intrep.Instruction, error) { // VGF2P8AFFINEINVQB imm8 ymm ymm ymm // VGF2P8AFFINEINVQB imm8 m512 zmm k zmm // VGF2P8AFFINEINVQB imm8 m512 zmm zmm +// VGF2P8AFFINEINVQB imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB imm8 zmm zmm zmm // VGF2P8AFFINEINVQB imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB imm8 m256 ymm k ymm +// VGF2P8AFFINEINVQB imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB imm8 ymm ymm k ymm func VGF2P8AFFINEINVQB(ops ...operand.Op) (*intrep.Instruction, error) { return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{}, ops) } @@ -21997,10 +22000,13 @@ func VGF2P8AFFINEINVQB_BCST_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instructio // Forms: // // VGF2P8AFFINEINVQB.Z imm8 m512 zmm k zmm +// VGF2P8AFFINEINVQB.Z imm8 zmm zmm k zmm // VGF2P8AFFINEINVQB.Z imm8 m128 xmm k xmm // VGF2P8AFFINEINVQB.Z imm8 m256 ymm k ymm -func VGF2P8AFFINEINVQB_Z(i, m, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { - return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxZ}, []operand.Op{i, m, xyz, k, xyz1}) +// VGF2P8AFFINEINVQB.Z imm8 xmm xmm k xmm +// VGF2P8AFFINEINVQB.Z imm8 ymm ymm k ymm +func VGF2P8AFFINEINVQB_Z(i, mxyz, xyz, k, xyz1 operand.Op) (*intrep.Instruction, error) { + return build(opcVGF2P8AFFINEINVQB.Forms(), sffxs{sffxZ}, []operand.Op{i, mxyz, xyz, k, xyz1}) } // VGF2P8AFFINEQB: Galois Field Affine Transformation. diff --git a/x86/zctors_test.go b/x86/zctors_test.go index d4cf4cee..c7b707f2 100644 --- a/x86/zctors_test.go +++ b/x86/zctors_test.go @@ -23292,6 +23292,9 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm512, opzmm, opzmm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } if _, err := VGF2P8AFFINEINVQB(opimm8, opzmm, opzmm, opzmm); err != nil { t.Fatal(err) } @@ -23301,6 +23304,12 @@ func TestVGF2P8AFFINEINVQBValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB(opimm8, opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } } func TestVGF2P8AFFINEINVQB_BCSTValidFormsNoError(t *testing.T) { @@ -23340,12 +23349,21 @@ func TestVGF2P8AFFINEINVQB_ZValidFormsNoError(t *testing.T) { if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm512, opzmm, opk, opzmm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opzmm, opzmm, opk, opzmm); err != nil { + t.Fatal(err) + } if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm128, opxmm, opk, opxmm); err != nil { t.Fatal(err) } if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opm256, opymm, opk, opymm); err != nil { t.Fatal(err) } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opxmm, opxmm, opk, opxmm); err != nil { + t.Fatal(err) + } + if _, err := VGF2P8AFFINEINVQB_Z(opimm8, opymm, opymm, opk, opymm); err != nil { + t.Fatal(err) + } } func TestVGF2P8AFFINEQBValidFormsNoError(t *testing.T) { diff --git a/x86/zoptab.go b/x86/zoptab.go index d61f5e62..34608a4f 100644 --- a/x86/zoptab.go +++ b/x86/zoptab.go @@ -7894,6 +7894,8 @@ var forms = []form{ {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512F_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512F_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionR}, {uint8(oprndtypeZMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -7905,6 +7907,10 @@ var forms = []form{ {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST_Z, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEINVQB, sffxsclsBCST, 0, isasAVX512VL_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM64), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsNIL, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionRW}}}, + {opcVGF2P8AFFINEINVQB, sffxsclsZ, 0, isasAVX512VL_GFNI, 5, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeK), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM128), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeM256), false, actionR}, {uint8(oprndtypeYMM), false, actionR}, {uint8(oprndtypeYMM), false, actionW}}}, {opcVGF2P8AFFINEQB, sffxsclsNIL, 0, isasAVX_GFNI, 4, oprnds{{uint8(oprndtypeIMM8), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionR}, {uint8(oprndtypeXMM), false, actionW}}}, @@ -15310,413 +15316,413 @@ var opcformstable = [][]form{ forms[4865:4895], forms[4895:4904], forms[4904:4913], - forms[4913:4934], - forms[4934:4961], - forms[4961:4979], - forms[4979:4983], - forms[4983:4987], - forms[4987:4991], - forms[4991:4995], - forms[4995:4997], - forms[4997:5009], - forms[5009:5015], - forms[5015:5027], - forms[5027:5033], - forms[5033:5035], - forms[5035:5047], - forms[5047:5053], - forms[5053:5065], - forms[5065:5071], - forms[5071:5073], - forms[5073:5075], - forms[5075:5076], - forms[5076:5077], - forms[5077:5081], - forms[5081:5085], - forms[5085:5115], - forms[5115:5145], - forms[5145:5154], - forms[5154:5163], - forms[5163:5193], - forms[5193:5223], - forms[5223:5232], - forms[5232:5241], - forms[5241:5268], - forms[5268:5295], - forms[5295:5299], - forms[5299:5317], - forms[5317:5323], - forms[5323:5350], - forms[5350:5377], - forms[5377:5383], - forms[5383:5410], - forms[5410:5437], - forms[5437:5464], - forms[5464:5491], - forms[5491:5492], - forms[5492:5494], - forms[5494:5496], - forms[5496:5497], - forms[5497:5499], - forms[5499:5501], - forms[5501:5503], + forms[4913:4940], + forms[4940:4967], + forms[4967:4985], + forms[4985:4989], + forms[4989:4993], + forms[4993:4997], + forms[4997:5001], + forms[5001:5003], + forms[5003:5015], + forms[5015:5021], + forms[5021:5033], + forms[5033:5039], + forms[5039:5041], + forms[5041:5053], + forms[5053:5059], + forms[5059:5071], + forms[5071:5077], + forms[5077:5079], + forms[5079:5081], + forms[5081:5082], + forms[5082:5083], + forms[5083:5087], + forms[5087:5091], + forms[5091:5121], + forms[5121:5151], + forms[5151:5160], + forms[5160:5169], + forms[5169:5199], + forms[5199:5229], + forms[5229:5238], + forms[5238:5247], + forms[5247:5274], + forms[5274:5301], + forms[5301:5305], + forms[5305:5323], + forms[5323:5329], + forms[5329:5356], + forms[5356:5383], + forms[5383:5389], + forms[5389:5416], + forms[5416:5443], + forms[5443:5470], + forms[5470:5497], + forms[5497:5498], + forms[5498:5500], + forms[5500:5502], + forms[5502:5503], forms[5503:5505], - forms[5505:5508], - forms[5508:5511], + forms[5505:5507], + forms[5507:5509], + forms[5509:5511], forms[5511:5514], forms[5514:5517], - forms[5517:5522], - forms[5522:5530], - forms[5530:5548], - forms[5548:5566], - forms[5566:5574], - forms[5574:5601], - forms[5601:5628], - forms[5628:5632], - forms[5632:5662], - forms[5662:5692], - forms[5692:5701], - forms[5701:5710], - forms[5710:5737], - forms[5737:5764], - forms[5764:5782], - forms[5782:5809], - forms[5809:5836], - forms[5836:5854], - forms[5854:5881], - forms[5881:5899], - forms[5899:5926], - forms[5926:5944], - forms[5944:5962], - forms[5962:5989], - forms[5989:6016], - forms[6016:6034], - forms[6034:6052], - forms[6052:6070], - forms[6070:6088], - forms[6088:6106], - forms[6106:6124], - forms[6124:6128], - forms[6128:6155], - forms[6155:6159], - forms[6159:6186], - forms[6186:6213], - forms[6213:6240], - forms[6240:6258], - forms[6258:6276], - forms[6276:6280], - forms[6280:6298], - forms[6298:6325], - forms[6325:6352], - forms[6352:6370], - forms[6370:6374], - forms[6374:6378], - forms[6378:6405], - forms[6405:6432], - forms[6432:6435], - forms[6435:6438], - forms[6438:6465], - forms[6465:6492], - forms[6492:6494], - forms[6494:6506], - forms[6506:6524], - forms[6524:6540], - forms[6540:6562], - forms[6562:6584], - forms[6584:6600], - forms[6600:6602], - forms[6602:6604], - forms[6604:6620], - forms[6620:6642], - forms[6642:6664], - forms[6664:6680], - forms[6680:6682], - forms[6682:6684], - forms[6684:6702], - forms[6702:6714], - forms[6714:6732], - forms[6732:6750], - forms[6750:6762], - forms[6762:6774], - forms[6774:6792], - forms[6792:6810], - forms[6810:6837], - forms[6837:6864], - forms[6864:6866], - forms[6866:6868], - forms[6868:6886], - forms[6886:6904], - forms[6904:6922], - forms[6922:6949], - forms[6949:6976], - forms[6976:7003], - forms[7003:7030], - forms[7030:7048], - forms[7048:7102], - forms[7102:7156], - forms[7156:7192], - forms[7192:7210], - forms[7210:7246], - forms[7246:7264], - forms[7264:7291], - forms[7291:7318], - forms[7318:7345], - forms[7345:7372], - forms[7372:7390], - forms[7390:7408], - forms[7408:7426], - forms[7426:7444], - forms[7444:7446], - forms[7446:7448], - forms[7448:7450], + forms[5517:5520], + forms[5520:5523], + forms[5523:5528], + forms[5528:5536], + forms[5536:5554], + forms[5554:5572], + forms[5572:5580], + forms[5580:5607], + forms[5607:5634], + forms[5634:5638], + forms[5638:5668], + forms[5668:5698], + forms[5698:5707], + forms[5707:5716], + forms[5716:5743], + forms[5743:5770], + forms[5770:5788], + forms[5788:5815], + forms[5815:5842], + forms[5842:5860], + forms[5860:5887], + forms[5887:5905], + forms[5905:5932], + forms[5932:5950], + forms[5950:5968], + forms[5968:5995], + forms[5995:6022], + forms[6022:6040], + forms[6040:6058], + forms[6058:6076], + forms[6076:6094], + forms[6094:6112], + forms[6112:6130], + forms[6130:6134], + forms[6134:6161], + forms[6161:6165], + forms[6165:6192], + forms[6192:6219], + forms[6219:6246], + forms[6246:6264], + forms[6264:6282], + forms[6282:6286], + forms[6286:6304], + forms[6304:6331], + forms[6331:6358], + forms[6358:6376], + forms[6376:6380], + forms[6380:6384], + forms[6384:6411], + forms[6411:6438], + forms[6438:6441], + forms[6441:6444], + forms[6444:6471], + forms[6471:6498], + forms[6498:6500], + forms[6500:6512], + forms[6512:6530], + forms[6530:6546], + forms[6546:6568], + forms[6568:6590], + forms[6590:6606], + forms[6606:6608], + forms[6608:6610], + forms[6610:6626], + forms[6626:6648], + forms[6648:6670], + forms[6670:6686], + forms[6686:6688], + forms[6688:6690], + forms[6690:6708], + forms[6708:6720], + forms[6720:6738], + forms[6738:6756], + forms[6756:6768], + forms[6768:6780], + forms[6780:6798], + forms[6798:6816], + forms[6816:6843], + forms[6843:6870], + forms[6870:6872], + forms[6872:6874], + forms[6874:6892], + forms[6892:6910], + forms[6910:6928], + forms[6928:6955], + forms[6955:6982], + forms[6982:7009], + forms[7009:7036], + forms[7036:7054], + forms[7054:7108], + forms[7108:7162], + forms[7162:7198], + forms[7198:7216], + forms[7216:7252], + forms[7252:7270], + forms[7270:7297], + forms[7297:7324], + forms[7324:7351], + forms[7351:7378], + forms[7378:7396], + forms[7396:7414], + forms[7414:7432], + forms[7432:7450], forms[7450:7452], - forms[7452:7457], - forms[7457:7462], - forms[7462:7467], - forms[7467:7472], - forms[7472:7476], - forms[7476:7480], - forms[7480:7484], - forms[7484:7486], + forms[7452:7454], + forms[7454:7456], + forms[7456:7458], + forms[7458:7463], + forms[7463:7468], + forms[7468:7473], + forms[7473:7478], + forms[7478:7482], + forms[7482:7486], forms[7486:7490], - forms[7490:7494], - forms[7494:7498], - forms[7498:7500], - forms[7500:7502], - forms[7502:7504], + forms[7490:7492], + forms[7492:7496], + forms[7496:7500], + forms[7500:7504], forms[7504:7506], - forms[7506:7533], - forms[7533:7560], - forms[7560:7587], - forms[7587:7614], - forms[7614:7632], - forms[7632:7650], - forms[7650:7654], - forms[7654:7658], - forms[7658:7676], - forms[7676:7703], - forms[7703:7730], - forms[7730:7748], - forms[7748:7766], - forms[7766:7793], - forms[7793:7820], - forms[7820:7838], - forms[7838:7856], - forms[7856:7883], - forms[7883:7910], - forms[7910:7928], - forms[7928:7946], - forms[7946:7973], - forms[7973:8000], - forms[8000:8018], - forms[8018:8021], - forms[8021:8024], - forms[8024:8042], - forms[8042:8060], - forms[8060:8063], - forms[8063:8066], + forms[7506:7508], + forms[7508:7510], + forms[7510:7512], + forms[7512:7539], + forms[7539:7566], + forms[7566:7593], + forms[7593:7620], + forms[7620:7638], + forms[7638:7656], + forms[7656:7660], + forms[7660:7664], + forms[7664:7682], + forms[7682:7709], + forms[7709:7736], + forms[7736:7754], + forms[7754:7772], + forms[7772:7799], + forms[7799:7826], + forms[7826:7844], + forms[7844:7862], + forms[7862:7889], + forms[7889:7916], + forms[7916:7934], + forms[7934:7952], + forms[7952:7979], + forms[7979:8006], + forms[8006:8024], + forms[8024:8027], + forms[8027:8030], + forms[8030:8048], + forms[8048:8066], forms[8066:8069], forms[8069:8072], - forms[8072:8074], - forms[8074:8077], - forms[8077:8095], - forms[8095:8113], - forms[8113:8131], - forms[8131:8149], - forms[8149:8167], - forms[8167:8185], - forms[8185:8203], - forms[8203:8221], - forms[8221:8239], - forms[8239:8257], - forms[8257:8275], - forms[8275:8293], - forms[8293:8311], - forms[8311:8329], - forms[8329:8347], - forms[8347:8365], - forms[8365:8383], - forms[8383:8401], - forms[8401:8419], - forms[8419:8437], - forms[8437:8455], - forms[8455:8458], - forms[8458:8476], - forms[8476:8494], - forms[8494:8512], - forms[8512:8530], - forms[8530:8548], - forms[8548:8566], - forms[8566:8584], - forms[8584:8611], - forms[8611:8629], - forms[8629:8647], - forms[8647:8665], - forms[8665:8692], - forms[8692:8719], - forms[8719:8737], - forms[8737:8764], - forms[8764:8791], - forms[8791:8800], - forms[8800:8809], - forms[8809:8813], - forms[8813:8840], - forms[8840:8867], - forms[8867:8894], - forms[8894:8921], - forms[8921:8948], - forms[8948:8975], - forms[8975:9002], - forms[9002:9029], - forms[9029:9056], - forms[9056:9083], - forms[9083:9089], - forms[9089:9092], - forms[9092:9095], + forms[8072:8075], + forms[8075:8078], + forms[8078:8080], + forms[8080:8083], + forms[8083:8101], + forms[8101:8119], + forms[8119:8137], + forms[8137:8155], + forms[8155:8173], + forms[8173:8191], + forms[8191:8209], + forms[8209:8227], + forms[8227:8245], + forms[8245:8263], + forms[8263:8281], + forms[8281:8299], + forms[8299:8317], + forms[8317:8335], + forms[8335:8353], + forms[8353:8371], + forms[8371:8389], + forms[8389:8407], + forms[8407:8425], + forms[8425:8443], + forms[8443:8461], + forms[8461:8464], + forms[8464:8482], + forms[8482:8500], + forms[8500:8518], + forms[8518:8536], + forms[8536:8554], + forms[8554:8572], + forms[8572:8590], + forms[8590:8617], + forms[8617:8635], + forms[8635:8653], + forms[8653:8671], + forms[8671:8698], + forms[8698:8725], + forms[8725:8743], + forms[8743:8770], + forms[8770:8797], + forms[8797:8806], + forms[8806:8815], + forms[8815:8819], + forms[8819:8846], + forms[8846:8873], + forms[8873:8900], + forms[8900:8927], + forms[8927:8954], + forms[8954:8981], + forms[8981:9008], + forms[9008:9035], + forms[9035:9062], + forms[9062:9089], + forms[9089:9095], forms[9095:9098], forms[9098:9101], - forms[9101:9119], - forms[9119:9146], - forms[9146:9164], - forms[9164:9182], - forms[9182:9186], - forms[9186:9190], - forms[9190:9194], - forms[9194:9239], - forms[9239:9245], - forms[9245:9290], - forms[9290:9317], - forms[9317:9344], - forms[9344:9362], - forms[9362:9398], - forms[9398:9443], - forms[9443:9488], - forms[9488:9515], - forms[9515:9542], - forms[9542:9560], - forms[9560:9596], - forms[9596:9641], - forms[9641:9647], - forms[9647:9692], - forms[9692:9719], - forms[9719:9746], - forms[9746:9764], - forms[9764:9800], - forms[9800:9818], - forms[9818:9845], - forms[9845:9872], - forms[9872:9890], - forms[9890:9908], - forms[9908:9926], - forms[9926:9944], - forms[9944:9962], - forms[9962:9989], - forms[9989:10016], - forms[10016:10020], - forms[10020:10032], - forms[10032:10050], - forms[10050:10068], - forms[10068:10080], - forms[10080:10092], - forms[10092:10110], - forms[10110:10128], - forms[10128:10140], - forms[10140:10158], - forms[10158:10185], - forms[10185:10212], - forms[10212:10230], - forms[10230:10248], - forms[10248:10275], - forms[10275:10302], - forms[10302:10320], - forms[10320:10324], - forms[10324:10351], - forms[10351:10378], - forms[10378:10408], - forms[10408:10438], - forms[10438:10447], - forms[10447:10456], - forms[10456:10483], - forms[10483:10510], - forms[10510:10516], + forms[9101:9104], + forms[9104:9107], + forms[9107:9125], + forms[9125:9152], + forms[9152:9170], + forms[9170:9188], + forms[9188:9192], + forms[9192:9196], + forms[9196:9200], + forms[9200:9245], + forms[9245:9251], + forms[9251:9296], + forms[9296:9323], + forms[9323:9350], + forms[9350:9368], + forms[9368:9404], + forms[9404:9449], + forms[9449:9494], + forms[9494:9521], + forms[9521:9548], + forms[9548:9566], + forms[9566:9602], + forms[9602:9647], + forms[9647:9653], + forms[9653:9698], + forms[9698:9725], + forms[9725:9752], + forms[9752:9770], + forms[9770:9806], + forms[9806:9824], + forms[9824:9851], + forms[9851:9878], + forms[9878:9896], + forms[9896:9914], + forms[9914:9932], + forms[9932:9950], + forms[9950:9968], + forms[9968:9995], + forms[9995:10022], + forms[10022:10026], + forms[10026:10038], + forms[10038:10056], + forms[10056:10074], + forms[10074:10086], + forms[10086:10098], + forms[10098:10116], + forms[10116:10134], + forms[10134:10146], + forms[10146:10164], + forms[10164:10191], + forms[10191:10218], + forms[10218:10236], + forms[10236:10254], + forms[10254:10281], + forms[10281:10308], + forms[10308:10326], + forms[10326:10330], + forms[10330:10357], + forms[10357:10384], + forms[10384:10414], + forms[10414:10444], + forms[10444:10453], + forms[10453:10462], + forms[10462:10489], + forms[10489:10516], forms[10516:10522], - forms[10522:10534], - forms[10534:10546], - forms[10546:10555], - forms[10555:10564], - forms[10564:10568], - forms[10568:10570], - forms[10570:10597], - forms[10597:10624], - forms[10624:10630], + forms[10522:10528], + forms[10528:10540], + forms[10540:10552], + forms[10552:10561], + forms[10561:10570], + forms[10570:10574], + forms[10574:10576], + forms[10576:10603], + forms[10603:10630], forms[10630:10636], - forms[10636:10666], - forms[10666:10696], - forms[10696:10705], - forms[10705:10714], - forms[10714:10718], - forms[10718:10722], - forms[10722:10724], - forms[10724:10726], - forms[10726:10753], - forms[10753:10780], - forms[10780:10786], + forms[10636:10642], + forms[10642:10672], + forms[10672:10702], + forms[10702:10711], + forms[10711:10720], + forms[10720:10724], + forms[10724:10728], + forms[10728:10730], + forms[10730:10732], + forms[10732:10759], + forms[10759:10786], forms[10786:10792], - forms[10792:10804], - forms[10804:10816], - forms[10816:10825], - forms[10825:10834], - forms[10834:10838], - forms[10838:10840], - forms[10840:10870], - forms[10870:10900], - forms[10900:10909], - forms[10909:10918], - forms[10918:10921], - forms[10921:10924], + forms[10792:10798], + forms[10798:10810], + forms[10810:10822], + forms[10822:10831], + forms[10831:10840], + forms[10840:10844], + forms[10844:10846], + forms[10846:10876], + forms[10876:10906], + forms[10906:10915], + forms[10915:10924], forms[10924:10927], forms[10927:10930], - forms[10930:10948], - forms[10948:10966], - forms[10966:10984], - forms[10984:11002], - forms[11002:11029], - forms[11029:11056], - forms[11056:11086], - forms[11086:11116], - forms[11116:11125], - forms[11125:11134], - forms[11134:11135], - forms[11135:11165], - forms[11165:11195], - forms[11195:11204], - forms[11204:11213], - forms[11213:11217], - forms[11217:11221], - forms[11221:11224], - forms[11224:11227], - forms[11227:11254], - forms[11254:11281], - forms[11281:11308], - forms[11308:11335], - forms[11335:11362], - forms[11362:11389], - forms[11389:11390], - forms[11390:11391], - forms[11391:11393], - forms[11393:11395], - forms[11395:11397], + forms[10930:10933], + forms[10933:10936], + forms[10936:10954], + forms[10954:10972], + forms[10972:10990], + forms[10990:11008], + forms[11008:11035], + forms[11035:11062], + forms[11062:11092], + forms[11092:11122], + forms[11122:11131], + forms[11131:11140], + forms[11140:11141], + forms[11141:11171], + forms[11171:11201], + forms[11201:11210], + forms[11210:11219], + forms[11219:11223], + forms[11223:11227], + forms[11227:11230], + forms[11230:11233], + forms[11233:11260], + forms[11260:11287], + forms[11287:11314], + forms[11314:11341], + forms[11341:11368], + forms[11368:11395], + forms[11395:11396], + forms[11396:11397], forms[11397:11399], - forms[11399:11402], - forms[11402:11407], - forms[11407:11412], - forms[11412:11417], - forms[11417:11418], - forms[11418:11419], - forms[11419:11425], - forms[11425:11433], - forms[11433:11435], - forms[11435:11437], - forms[11437:11445], - forms[11445:11453], + forms[11399:11401], + forms[11401:11403], + forms[11403:11405], + forms[11405:11408], + forms[11408:11413], + forms[11413:11418], + forms[11418:11423], + forms[11423:11424], + forms[11424:11425], + forms[11425:11431], + forms[11431:11439], + forms[11439:11441], + forms[11441:11443], + forms[11443:11451], + forms[11451:11459], }