From 915cd4d3a7f7082c6504dc4945aacb0936edfabc Mon Sep 17 00:00:00 2001 From: Azam Soleimanian <49027816+Soleimani193@users.noreply.github.com> Date: Tue, 15 Oct 2024 10:11:43 +0200 Subject: [PATCH 01/12] Prover/splitter compiler (#74) * ignore queries over the eligible columns * adding the constraints * fix the golangci-lint error * organizing the package * adding a missing verifier check * support shifted version of verifier columns * adding a test case for verifier columns * readding the old splitter --- .../column/verifiercol/expand_verifcol.go | 1 - .../splitter/stitcher/stitcher_test.go | 296 --------------- .../splitter => stitch_split}/common.go | 0 .../stitch_split/splitter/constraints.go | 353 ++++++++++++++++++ .../stitch_split/splitter/splitter.go | 160 ++++++++ .../stitch_split/splitter/splitter_test.go | 289 ++++++++++++++ .../stitcher/constraints.go | 64 +++- .../stitcher/stitcher.go | 44 ++- .../stitch_split/stitcher/stitcher_test.go | 322 ++++++++++++++++ prover/protocol/query/global.go | 3 + prover/protocol/query/global_test.go | 24 +- prover/zkevm/prover/hash/packing/cld.go | 5 +- .../hash/packing/dedicated/len_consistency.go | 7 +- 13 files changed, 1225 insertions(+), 343 deletions(-) delete mode 100644 prover/protocol/compiler/splitter/splitter/stitcher/stitcher_test.go rename prover/protocol/compiler/{splitter/splitter => stitch_split}/common.go (100%) create mode 100644 prover/protocol/compiler/stitch_split/splitter/constraints.go create mode 100644 prover/protocol/compiler/stitch_split/splitter/splitter.go create mode 100644 prover/protocol/compiler/stitch_split/splitter/splitter_test.go rename prover/protocol/compiler/{splitter/splitter => stitch_split}/stitcher/constraints.go (81%) rename prover/protocol/compiler/{splitter/splitter => stitch_split}/stitcher/stitcher.go (91%) create mode 100644 prover/protocol/compiler/stitch_split/stitcher/stitcher_test.go diff --git a/prover/protocol/column/verifiercol/expand_verifcol.go b/prover/protocol/column/verifiercol/expand_verifcol.go index b984cc3e5..a631f4041 100644 --- a/prover/protocol/column/verifiercol/expand_verifcol.go +++ b/prover/protocol/column/verifiercol/expand_verifcol.go @@ -52,7 +52,6 @@ func (ex ExpandedVerifCol) GetColAssignment(run ifaces.Runtime) ifaces.ColAssign // GetColAssignment returns a gnark assignment of the current column func (ex ExpandedVerifCol) GetColAssignmentGnark(run ifaces.GnarkRuntime) []frontend.Variable { - assi := ex.Verifiercol.GetColAssignmentGnark(run) res := make([]frontend.Variable, ex.Size()) for i := 0; i < len(assi); i++ { diff --git a/prover/protocol/compiler/splitter/splitter/stitcher/stitcher_test.go b/prover/protocol/compiler/splitter/splitter/stitcher/stitcher_test.go deleted file mode 100644 index e0534173e..000000000 --- a/prover/protocol/compiler/splitter/splitter/stitcher/stitcher_test.go +++ /dev/null @@ -1,296 +0,0 @@ -package stitcher_test - -import ( - "testing" - - "github.com/consensys/linea-monorepo/prover/maths/common/smartvectors" - "github.com/consensys/linea-monorepo/prover/maths/field" - "github.com/consensys/linea-monorepo/prover/protocol/accessors" - "github.com/consensys/linea-monorepo/prover/protocol/coin" - "github.com/consensys/linea-monorepo/prover/protocol/column" - "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" - "github.com/consensys/linea-monorepo/prover/protocol/compiler/dummy" - "github.com/consensys/linea-monorepo/prover/protocol/compiler/splitter/splitter/stitcher" - "github.com/consensys/linea-monorepo/prover/protocol/ifaces" - "github.com/consensys/linea-monorepo/prover/protocol/query" - "github.com/consensys/linea-monorepo/prover/protocol/wizard" - "github.com/consensys/linea-monorepo/prover/symbolic" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestLocalEval(t *testing.T) { - - var a, b, c, d ifaces.Column - var q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12 query.LocalOpening - - define := func(builder *wizard.Builder) { - // declare columns of different sizes - a = builder.RegisterCommit("A", 2) - b = builder.RegisterCommit("B", 4) - c = builder.RegisterCommit("C", 8) - d = builder.RegisterCommit("D", 16) - - // Local opening at zero - q1 = builder.LocalOpening("Q00", a) - q2 = builder.LocalOpening("Q01", b) - q3 = builder.LocalOpening("Q02", c) - q4 = builder.LocalOpening("Q03", d) - - // Local opening at but shifted by one - q5 = builder.LocalOpening("Q10", column.Shift(a, 1)) - q6 = builder.LocalOpening("Q11", column.Shift(b, 1)) - q7 = builder.LocalOpening("Q12", column.Shift(c, 1)) - q8 = builder.LocalOpening("Q13", column.Shift(d, 1)) - - // Local opening at but shifted by one - q9 = builder.LocalOpening("Q20", column.Shift(a, -1)) - q10 = builder.LocalOpening("Q21", column.Shift(b, -1)) - q11 = builder.LocalOpening("Q22", column.Shift(c, -1)) - q12 = builder.LocalOpening("Q23", column.Shift(d, -1)) - } - - comp := wizard.Compile(define, stitcher.Stitcher(4, 8)) - - //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored - assert.Equal(t, column.Proof.String(), comp.Columns.Status("A").String()) - assert.Equal(t, column.Ignored.String(), comp.Columns.Status("B").String()) - assert.Equal(t, column.Committed.String(), comp.Columns.Status("C").String()) - assert.Equal(t, column.Committed.String(), comp.Columns.Status("D").String()) - - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q1.ID)) - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q2.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q3.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q4.ID)) - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q5.ID)) - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q6.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q7.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q8.ID)) - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q9.ID)) - assert.Equal(t, true, comp.QueriesParams.IsIgnored(q10.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q11.ID)) - assert.Equal(t, false, comp.QueriesParams.IsIgnored(q12.ID)) - - // manually compiles the comp - dummy.Compile(comp) - - proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { - // Assigns all the columns - assi.AssignColumn(a.GetColID(), smartvectors.ForTest(0, 1)) - assi.AssignColumn(b.GetColID(), smartvectors.ForTest(2, 3, 4, 5)) - assi.AssignColumn(c.GetColID(), smartvectors.ForTest(6, 7, 8, 9, 10, 11, 12, 13)) - assi.AssignColumn(d.GetColID(), smartvectors.ForTest(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)) - - // And the alleged results - assi.AssignLocalPoint("Q00", field.NewElement(0)) - assi.AssignLocalPoint("Q01", field.NewElement(2)) - assi.AssignLocalPoint("Q02", field.NewElement(6)) - assi.AssignLocalPoint("Q03", field.NewElement(15)) - assi.AssignLocalPoint("Q10", field.NewElement(1)) - assi.AssignLocalPoint("Q11", field.NewElement(3)) - assi.AssignLocalPoint("Q12", field.NewElement(7)) - assi.AssignLocalPoint("Q13", field.NewElement(16)) - assi.AssignLocalPoint("Q20", field.NewElement(1)) - assi.AssignLocalPoint("Q21", field.NewElement(5)) - assi.AssignLocalPoint("Q22", field.NewElement(13)) - assi.AssignLocalPoint("Q23", field.NewElement(30)) - }) - - err := wizard.Verify(comp, proof) - require.NoError(t, err) - -} - -func TestGlobalConstraintFibonacci(t *testing.T) { - - var a, b, c ifaces.Column - var q1, q2, q3 query.GlobalConstraint - - define := func(builder *wizard.Builder) { - // declare columns of different sizes - a = builder.RegisterCommit("B", 4) - // a = verifiercol.NewConstantCol(field.One(), 4) - b = builder.RegisterCommit("C", 8) - c = builder.RegisterCommit("D", 16) - - fibo := func(col ifaces.Column) *symbolic.Expression { - col_ := ifaces.ColumnAsVariable(col) - colNext := ifaces.ColumnAsVariable(column.Shift(col, 1)) - colNextNext := ifaces.ColumnAsVariable(column.Shift(col, 2)) - return colNextNext.Sub(colNext).Sub(col_) - } - - q1 = builder.GlobalConstraint("Q0", fibo(a)) - q2 = builder.GlobalConstraint("Q1", fibo(b)) - q3 = builder.GlobalConstraint("Q2", fibo(c)) - } - - comp := wizard.Compile(define, stitcher.Stitcher(8, 16)) - - //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q1.ID), "q1 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q2.ID), "q2 should not be ignored") - assert.Equal(t, false, comp.QueriesNoParams.IsIgnored(q3.ID), "q3 should not be ignored") - - // manually compiles the comp - dummy.Compile(comp) - - proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { - // Assigns all the columns - assi.AssignColumn(a.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(b.GetColID(), smartvectors.ForTest(1, 1, 2, 3, 5, 8, 13, 21)) - assi.AssignColumn(c.GetColID(), smartvectors.ForTest(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987)) - }) - - err := wizard.Verify(comp, proof) - require.NoError(t, err) - -} - -func TestLocalConstraintFibonacci(t *testing.T) { - - var a, b, c ifaces.Column - var q1, q2, q3 query.LocalConstraint - - define := func(builder *wizard.Builder) { - // declare columns of different sizes - a = builder.RegisterCommit("B", 4) - b = builder.RegisterCommit("C", 8) - c = builder.RegisterCommit("D", 16) - - fibo := func(col ifaces.Column) *symbolic.Expression { - col_ := ifaces.ColumnAsVariable(col) - colNext := ifaces.ColumnAsVariable(column.Shift(col, 1)) - colNextNext := ifaces.ColumnAsVariable(column.Shift(col, 2)) - return colNextNext.Sub(colNext).Sub(col_) - } - - q1 = builder.LocalConstraint("Q0", fibo(a)) - q2 = builder.LocalConstraint("Q1", fibo(b)) - q3 = builder.LocalConstraint("Q2", fibo(c)) - } - - comp := wizard.Compile(define, stitcher.Stitcher(8, 16)) - - //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q1.ID), "q1 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q2.ID), "q2 should not be ignored") - assert.Equal(t, false, comp.QueriesNoParams.IsIgnored(q3.ID), "q3 should not be ignored") - - // manually compiles the comp - dummy.Compile(comp) - - proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { - // Assigns all the columns - // Todo: Arbitrary changes of col values do not make the test failing - assi.AssignColumn(a.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(b.GetColID(), smartvectors.ForTest(1, 1, 2, 3, 5, 8, 13, 21)) - assi.AssignColumn(c.GetColID(), smartvectors.ForTest(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987)) - }) - - err := wizard.Verify(comp, proof) - require.NoError(t, err) - -} - -func TestGlobalMixedRounds(t *testing.T) { - - var a0, a1, a2, b0, b1, b2 ifaces.Column - var q0, q1, q2 query.LocalConstraint - - define := func(builder *wizard.Builder) { - // declare columns of different sizes - a0 = builder.RegisterCommit("A0", 4) - a1 = builder.RegisterCommit("A1", 4) - a2 = builder.RegisterCommit("A2", 4) - _ = builder.RegisterRandomCoin("COIN", coin.Field) - b0 = builder.RegisterCommit("B0", 4) - b1 = builder.RegisterCommit("B1", 4) - b2 = builder.RegisterCommit("B2", 4) - - q0 = builder.LocalConstraint("Q0", ifaces.ColumnAsVariable(a0).Sub(ifaces.ColumnAsVariable(b0))) - q1 = builder.LocalConstraint("Q1", ifaces.ColumnAsVariable(a1).Sub(ifaces.ColumnAsVariable(b1))) - q2 = builder.LocalConstraint("Q2", ifaces.ColumnAsVariable(a2).Sub(ifaces.ColumnAsVariable(b2))) - } - - comp := wizard.Compile(define, stitcher.Stitcher(4, 8)) - - //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q0.ID), "q0 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q1.ID), "q1 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q2.ID), "q2 should be ignored") - - // manually compiles the comp - dummy.Compile(comp) - - proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { - // Assigns all the columns - assi.AssignColumn(a0.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(a1.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(a2.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - _ = assi.GetRandomCoinField("COIN") // triggers going to the next round - assi.AssignColumn(b0.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(b1.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(b2.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - }) - - err := wizard.Verify(comp, proof) - require.NoError(t, err) -} - -func TestWithVerifCol(t *testing.T) { - var a, b, c, verifcol1, verifcol2 ifaces.Column - var q1, q2 query.GlobalConstraint - var q3 query.LocalConstraint - - define := func(builder *wizard.Builder) { - // declare columns of different sizes - a = builder.RegisterCommit("B", 4) - b = builder.RegisterCommit("C", 4) - // a new round - _ = builder.RegisterRandomCoin("COIN", coin.Field) - c = builder.RegisterCommit("D", 4) - // verifiercols - verifcol1 = verifiercol.NewConstantCol(field.NewElement(3), 4) - accessors := genAccessors([]int{1, 7, 5, 3}) - verifcol2 = verifiercol.NewFromAccessors(accessors, field.Zero(), 4) - - expr := symbolic.Sub(symbolic.Mul(a, verifcol1), b) - q1 = builder.GlobalConstraint("Q0", expr) - - expr = symbolic.Sub(symbolic.Add(a, verifcol2), c) - q2 = builder.GlobalConstraint("Q1", expr) - - q3 = builder.LocalConstraint("Q2", expr) - } - - comp := wizard.Compile(define, stitcher.Stitcher(4, 16)) - - //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q1.ID), "q1 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q2.ID), "q2 should be ignored") - assert.Equal(t, true, comp.QueriesNoParams.IsIgnored(q3.ID), "q2 should be ignored") - - // manually compiles the comp - dummy.Compile(comp) - - proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { - // Assigns all the columns - assi.AssignColumn(a.GetColID(), smartvectors.ForTest(1, 1, 2, 3)) - assi.AssignColumn(b.GetColID(), smartvectors.ForTest(3, 3, 6, 9)) - _ = assi.GetRandomCoinField("COIN") // triggers going to the next round - assi.AssignColumn(c.GetColID(), smartvectors.ForTest(2, 8, 7, 6)) - }) - - err := wizard.Verify(comp, proof) - require.NoError(t, err) - -} - -func genAccessors(a []int) (res []ifaces.Accessor) { - for i := range a { - t := accessors.NewConstant(field.NewElement(uint64(a[i]))) - res = append(res, t) - } - return res -} diff --git a/prover/protocol/compiler/splitter/splitter/common.go b/prover/protocol/compiler/stitch_split/common.go similarity index 100% rename from prover/protocol/compiler/splitter/splitter/common.go rename to prover/protocol/compiler/stitch_split/common.go diff --git a/prover/protocol/compiler/stitch_split/splitter/constraints.go b/prover/protocol/compiler/stitch_split/splitter/constraints.go new file mode 100644 index 000000000..7eb3787eb --- /dev/null +++ b/prover/protocol/compiler/stitch_split/splitter/constraints.go @@ -0,0 +1,353 @@ +package splitter + +import ( + "reflect" + + "github.com/consensys/linea-monorepo/prover/protocol/coin" + "github.com/consensys/linea-monorepo/prover/protocol/column" + "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" + alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split" + "github.com/consensys/linea-monorepo/prover/protocol/ifaces" + "github.com/consensys/linea-monorepo/prover/protocol/query" + "github.com/consensys/linea-monorepo/prover/protocol/variables" + "github.com/consensys/linea-monorepo/prover/protocol/wizard" + "github.com/consensys/linea-monorepo/prover/symbolic" + "github.com/consensys/linea-monorepo/prover/utils" + "github.com/consensys/linea-monorepo/prover/utils/collection" +) + +func (ctx splitterContext) constraints() { + ctx.LocalOpening() + ctx.LocalGlobalConstraints() +} + +func (ctx splitterContext) LocalOpening() { + for _, qName := range ctx.comp.QueriesParams.AllUnignoredKeys() { + // Filters out only the LocalOpening + q, ok := ctx.comp.QueriesParams.Data(qName).(query.LocalOpening) + if !ok { + utils.Panic("got an uncompilable query %v", qName) + } + + round := ctx.comp.QueriesParams.Round(q.ID) + + if !isColEligible(ctx.Splittings, q.Pol) { + continue + } + // mark the query as ignored + ctx.comp.QueriesParams.MarkAsIgnored(qName) + // Get the sub column + subCol := getSubColForLocal(ctx, q.Pol, 0) + // apply the local constrain over the subCol + newQ := ctx.comp.InsertLocalOpening(round, queryName(q.ID), subCol) + + // Registers the prover's step responsible for assigning the new query + ctx.comp.SubProvers.AppendToInner(round, func(run *wizard.ProverRuntime) { + y := run.QueriesParams.MustGet(q.ID).(query.LocalOpeningParams).Y + run.AssignLocalPoint(newQ.ID, y) + }) + + } +} + +func (ctx splitterContext) LocalGlobalConstraints() { + for _, qName := range ctx.comp.QueriesNoParams.AllUnignoredKeys() { + + q := ctx.comp.QueriesNoParams.Data(qName) + // round of definition of the query to compile + round := ctx.comp.QueriesNoParams.Round(qName) + + var board symbolic.ExpressionBoard + + switch q := q.(type) { + case query.LocalConstraint: + board = q.Board() + // detect if the expression is eligible; + // i.e., it contains columns of proper size with status Precomputed, committed, or verifiercol. + if !alliance.IsExprEligible(isColEligible, ctx.Splittings, board) { + continue + } + + // if the associated expression is eligible to the stitching, mark the query, over the sub columns, as ignored. + ctx.comp.QueriesNoParams.MarkAsIgnored(qName) + + // adjust the query over the sub columns + ctx.comp.InsertLocal(round, queryName(qName), ctx.adjustExpressionForLocal(q.Expression, 0)) + + case query.GlobalConstraint: + board = q.Board() + // detect if the expression is over the eligible columns. + if !alliance.IsExprEligible(isColEligible, ctx.Splittings, board) { + continue + } + + // if the associated expression is eligible to the stitching, mark the query, over the sub columns, as ignored. + ctx.comp.QueriesNoParams.MarkAsIgnored(qName) + + // adjust the query over the sub columns + numSlots := q.DomainSize / ctx.size + for slot := 0; slot < numSlots; slot++ { + + ctx.comp.InsertGlobal(round, + ifaces.QueryIDf("%v_SPLITTER_GLOBALQ_SLOT_%v", q.ID, slot), + ctx.adjustExpressionForGlobal(q.Expression, slot), + ) + + ctx.localQueriesForGapsInGlobal(q, slot, numSlots) + } + + default: + utils.Panic("got an uncompilable query %++v", qName) + } + } +} + +// it checks if a column registered in the compiler has the proper size and state for splitting. +func isColEligible(splittings alliance.MultiSummary, col ifaces.Column) bool { + natural := column.RootParents(col)[0] + _, found := splittings[col.Round()].ByBigCol[natural.GetColID()] + return found +} + +// It finds the subCol containing the first row of col, +// it then shifts the subCol so that its first row equals with the first row of col. +func getSubColForLocal(ctx splitterContext, col ifaces.Column, posInCol int) ifaces.Column { + round := col.Round() + // Sanity-check : only for the edge-case h.Size() < ctx.size + if col.Size() < ctx.size && posInCol != 0 { + utils.Panic("We have h.Size (%v) < ctx.size (%v) but num (%v) != 0 for %v", col.Size(), ctx.size, posInCol, col.GetColID()) + } + + if !col.IsComposite() { + switch col := col.(type) { + case verifiercol.VerifierCol: + // Create the split in live + return col.Split(ctx.comp, posInCol*ctx.size, (posInCol+1)*ctx.size) + default: + // No changes : it means this is a normal column and + // we shall take the corresponding slice. + return ctx.Splittings[round].ByBigCol[col.GetColID()][posInCol] + } + } + + switch inner := col.(type) { + case column.Shifted: + // Shift the subparent, if the offset is larger than the subparent + // we repercute it on the num + if inner.Offset < -ctx.size { + utils.Panic("unsupported, the offset is too negative") + } + + // find the subCol that contain the first row of col + position := utils.PositiveMod(column.StackOffsets(col), col.Size()) + subColID, offsetOfSubCol := position/ctx.size, position%ctx.size + + // The subCol is linked to the "root" of q.Pol (i.e., natural column associated with col) + parent := getSubColForLocal(ctx, inner.Parent, posInCol+subColID) + return column.Shift(parent, offsetOfSubCol) + + default: + utils.Panic("unexpected type %v", reflect.TypeOf(inner)) + } + panic("unreachable") +} + +// For the column 'col' and the given 'posInCol', +// it returns the subColumn from the natural column located in position 'posInNatural'. +// where the posInNatural is calculated via the offset in Col. +func getSubColForGlobal(ctx splitterContext, col ifaces.Column, posInCol int) ifaces.Column { + // Sanity-check : only for the edge-case h.Size() < ctx.size + round := col.Round() + if col.Size() < ctx.size { + if posInCol > 0 { + utils.Panic( + "tried to get share #%v of column %v, but this is an undersized column %v", + posInCol, col.GetColID(), col.Size(), + ) + } + + // Not a split column : returns the input directly + return col + } + + if !col.IsComposite() { + switch m := col.(type) { + case verifiercol.VerifierCol: + // Create the split in live + return m.Split(ctx.comp, posInCol*ctx.size, (posInCol+1)*ctx.size) + default: + // No changes; natural column + return ctx.Splittings[round].ByBigCol[col.GetColID()][posInCol] + } + } + + switch inner := col.(type) { + // Shift the subparent, if the offset is larger than the subparent + // we repercute it on the num + case column.Shifted: + + // This works fine assuming h.Size() > ctx.size + var ( + offset = inner.Offset + maxNumSubCol = col.Size() / ctx.size + subColID = (posInCol + (offset / ctx.size)) % maxNumSubCol + offsetOfSubCol = utils.PositiveMod(offset, ctx.size) + ) + // This indicates that the offset is so large + if subColID < 0 { + subColID = (col.Size() / ctx.size) + subColID + } + // The resulting offset should keep the same sign as the old one. This is + // because the sign indicates which range of position is touched by + // bound cancellation. + if offsetOfSubCol*offset < 0 { + offsetOfSubCol -= ctx.size + } + parent := getSubColForGlobal(ctx, inner.Parent, subColID) + return column.Shift(parent, offsetOfSubCol) + + default: + utils.Panic("unexpected type %v", reflect.TypeOf(inner)) + } + panic("unreachable") +} + +func queryName(oldQ ifaces.QueryID) ifaces.QueryID { + return ifaces.QueryIDf("%v_SPLITTER", oldQ) +} + +// it shift all the columns inside the expression by shift and then applies the local constraints. +func (ctx splitterContext) adjustExpressionForLocal( + expr *symbolic.Expression, shift int, +) *symbolic.Expression { + + board := expr.Board() + metadatas := board.ListVariableMetadata() + translationMap := collection.NewMapping[string, *symbolic.Expression]() + + for _, metadata := range metadatas { + // Replace the expression by the one + + switch m := metadata.(type) { + case ifaces.Column: + subCol := getSubColForLocal(ctx, column.Shift(m, shift), 0) + translationMap.InsertNew(m.String(), ifaces.ColumnAsVariable(subCol)) + // @Azam why we need these cases? + case coin.Info, ifaces.Accessor: + translationMap.InsertNew(m.String(), symbolic.NewVariable(m)) + case variables.X: + panic("unsupported, the value of `x` in the unsplit query and the split would be different") + case variables.PeriodicSample: + // for PeriodicSampling offset is always positive in forward direction, thus we need (-shift) + newSample := variables.NewPeriodicSample(m.T, utils.PositiveMod(m.Offset-shift, m.T)) + translationMap.InsertNew(m.String(), newSample) + default: + // Repass the same variable + translationMap.InsertNew(m.String(), symbolic.NewVariable(metadata)) + } + } + + newExpr := expr.Replay(translationMap) + return newExpr +} + +func (ctx splitterContext) adjustExpressionForGlobal( + expr *symbolic.Expression, slot int, +) *symbolic.Expression { + board := expr.Board() + metadatas := board.ListVariableMetadata() + translationMap := collection.NewMapping[string, *symbolic.Expression]() + + for _, metadata := range metadatas { + + // For each slot, get the expression obtained by replacing the commitment + // by the appropriated column. + + switch m := metadata.(type) { + case ifaces.Column: + // Pass the same variable + subCol := getSubColForGlobal(ctx, m, slot) + // Sanity-check : the subHandle should have the target size + if subCol.Size() != ctx.size { + utils.Panic( + "outgoing column %v should have size %v but has size %v (ingoing column was %v, with size %v)", + subCol.GetColID(), ctx.size, subCol.Size(), m.GetColID(), m.Size(), + ) + } + translationMap.InsertNew(m.String(), ifaces.ColumnAsVariable(subCol)) + case variables.X: + utils.Panic("unsupported, the value of `x` in the unsplit query and the split would be different") + case variables.PeriodicSample: + // Check that the period is not larger than the domain size. If + // the period is smaller this is a no-op because the period does + // not change. + translated := symbolic.NewVariable(metadata) + + if m.T > ctx.size { + + // Here, there are two possibilities. (1) The current slot is + // on a portion of the Periodic sample where everything is + // zero or (2) the current slot matchs a portion of the + // periodic sampling containing a 1. To determine which is + // the current situation, we need to find out where the slot + // is located compared to the period. + var ( + slotStartAt = (slot * ctx.size) % m.T + slotStopAt = slotStartAt + ctx.size + ) + + if m.Offset >= slotStartAt && m.Offset < slotStopAt { + translated = variables.NewPeriodicSample(ctx.size, m.Offset%ctx.size) + } else { + translated = symbolic.NewConstant(0) + } + } + + // And we can just pass it over because the period does not change + translationMap.InsertNew(m.String(), translated) + default: + // Repass the same variable (for coins or other types of single-valued variable) + translationMap.InsertNew(m.String(), symbolic.NewVariable(metadata)) + } + + } + return expr.Replay(translationMap) +} + +func (ctx splitterContext) localQueriesForGapsInGlobal(q query.GlobalConstraint, slot, numSlots int) { + + // Now, we need to cancel the expression at the beginning and/or the end + // For the first one, only cancel the end. For the last one, only cancel + // the beginning. + offsetRange := q.MinMaxOffset() + round := ctx.comp.QueriesNoParams.Round(q.ID) + nextStart := 0 + + if offsetRange.Min < 0 { + for i := 0; i < offsetRange.Min; i-- { + // And fill the gap with a local constraint + if slot > 0 || q.NoBoundCancel { + // adjust the query over the sub columns + ctx.comp.InsertLocal(round, + ifaces.QueryIDf("%v_LOCAL_GAPS_NEG_OFFSET_%v", q.ID, i), + ctx.adjustExpressionForLocal(q.Expression, slot*ctx.size-i)) + } + } + if offsetRange.Max > 0 { + nextStart = 1 + } + } + + if offsetRange.Max > 0 { + for i := nextStart; i < offsetRange.Max; i++ { + point := ctx.size - i - 1 // point at which we want to cancel the constraint + // And fill the gap with a local constraint + if slot < numSlots-1 || q.NoBoundCancel { + shift := slot*ctx.size + point + ctx.comp.InsertLocal(round, + ifaces.QueryIDf("%v_LOCAL_GAPS_POS_OFFSET_%v_%v", q.ID, slot, i), + ctx.adjustExpressionForLocal(q.Expression, shift)) + } + } + } +} diff --git a/prover/protocol/compiler/stitch_split/splitter/splitter.go b/prover/protocol/compiler/stitch_split/splitter/splitter.go new file mode 100644 index 000000000..e3da14acb --- /dev/null +++ b/prover/protocol/compiler/stitch_split/splitter/splitter.go @@ -0,0 +1,160 @@ +package splitter + +import ( + "github.com/consensys/linea-monorepo/prover/protocol/column" + alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split" + "github.com/consensys/linea-monorepo/prover/protocol/ifaces" + "github.com/consensys/linea-monorepo/prover/protocol/wizard" + "github.com/consensys/linea-monorepo/prover/utils" + "github.com/consensys/linea-monorepo/prover/utils/profiling" +) + +// Splitter +func Splitter(size int) func(*wizard.CompiledIOP) { + return func(comp *wizard.CompiledIOP) { + // it creates the splitting columns (from the eligible columns), and commits to them + ctx := newSplitter(comp, size) + // adjust the constraints accordingly over the stitchings of the sub columns. + ctx.constraints() + + // it assigns the stitching columns and delete the assignment of the sub columns. + comp.SubProvers.AppendToInner(comp.NumRounds()-1, func(run *wizard.ProverRuntime) { + for round := range ctx.Splittings { + for bigCol := range ctx.Splittings[round].ByBigCol { + run.Columns.TryDel(bigCol) + } + } + }) + } +} + +type splitterContext struct { + // the compiled IOP + comp *wizard.CompiledIOP + // the size for splitting the big columns + size int + // It collects the information about the splitting and subColumns. + // The index of Splittings is over the rounds. + Splittings []alliance.SummerizedAlliances +} + +func newSplitter(comp *wizard.CompiledIOP, size int) splitterContext { + numRound := comp.NumRounds() + ctx := splitterContext{ + comp: comp, + size: size, + Splittings: make([]alliance.SummerizedAlliances, numRound), + } + + ctx.ScanSplitCommit() + return ctx +} + +func (ctx *splitterContext) ScanSplitCommit() { + comp := ctx.comp + for round := 0; round < comp.NumRounds(); round++ { + for _, col := range comp.Columns.AllHandlesAtRound(round) { + + status := comp.Columns.Status(col.GetColID()) + + // 1. we expect no constraint over a mix of eligible columns and proof, thus ignore Proof columns + // 2. we expect no verifingKey column to fall withing the stitching interval (ctx.MinSize, ctx.MaxSize) + // 3. we expect no query over the ignored columns. + if status == column.Ignored || status == column.Proof || status == column.VerifyingKey { + continue + } + if col.Size() < ctx.size { + utils.Panic("stitcher is not working correctly, the small columns should have been handled by the stitcher") + } + + if col.Size()%ctx.size != 0 { + utils.Panic("the column size %v does not divide the splitting size %v", col.Size(), ctx.size) + } + if col.Size() == ctx.size { + continue + } + + // Create the subslices and give them the same status as their parents + numSubSlices := col.Size() / ctx.size + subSlices := make([]ifaces.Column, numSubSlices) + + // Note that the status of Verifiercol is not available via compiler. + // Thus, it is not handles here, we rather handle it during the constraints. + switch status { + // if the veriferKey is big, it should be declared as precomputed + case column.Precomputed, column.VerifyingKey: + // Then, on top of defining the new split column. We need to assign it + // directly. + precomp := comp.Precomputed.MustGet(col.GetColID()) + for i := 0; i < len(subSlices); i++ { + // InsertPrecomputed() automatically assigns the + // status "Precomputed". + subSlices[i] = comp.InsertPrecomputed( + nameHandleSlice(col, i, col.Size()/ctx.size), + precomp.SubVector(i*ctx.size, (i+1)*ctx.size), + ) + // For the verifyingKey, declare the status manually. + if status != column.Precomputed { + comp.Columns.SetStatus(subSlices[i].GetColID(), status) + } + } + + case column.Committed: + for i := 0; i < len(subSlices); i++ { + subSlices[i] = comp.InsertCommit(round, + nameHandleSlice(col, i, col.Size()/ctx.size), + ctx.size, + ) + } + default: + panic("Invalid Status") + } + + splitting := alliance.Alliance{ + BigCol: col, + SubCols: subSlices, + Round: round, + Status: status, + } + + (alliance.MultiSummary)(ctx.Splittings).InsertNew(splitting) + + // Mark the handle as ignored + comp.Columns.MarkAsIgnored(col.GetColID()) + } + ctx.comp.SubProvers.AppendToInner(round, ctx.Prove(round)) + } + +} + +func nameHandleSlice(h ifaces.Column, num, numSlots int) ifaces.ColID { + return ifaces.ColIDf("%v_SUBSLICE_%v_OVER_%v", h.GetColID(), num, numSlots) +} + +func (ctx splitterContext) Prove(round int) wizard.ProverStep { + + return func(run *wizard.ProverRuntime) { + stopTimer := profiling.LogTimer("splitter compiler") + defer stopTimer() + + for idBigCol, subCols := range ctx.Splittings[round].ByBigCol { + + // Sanity-check + bigCol := ctx.comp.Columns.GetHandle(idBigCol) + if len(subCols)*ctx.size != bigCol.Size() { + utils.Panic("Unexpected sizes %v * %v != %v", len(subCols), ctx.size, bigCol.Size()) + } + + // If the column is precomputed, it was already assigned + if ctx.comp.Precomputed.Exists(idBigCol) { + continue + } + + // assign the subColumns + witness := bigCol.GetColAssignment(run) + for i := 0; i < len(subCols); i++ { + run.AssignColumn(subCols[i].GetColID(), witness.SubVector(i*ctx.size, (i+1)*ctx.size)) + } + } + } +} diff --git a/prover/protocol/compiler/stitch_split/splitter/splitter_test.go b/prover/protocol/compiler/stitch_split/splitter/splitter_test.go new file mode 100644 index 000000000..70b65a953 --- /dev/null +++ b/prover/protocol/compiler/stitch_split/splitter/splitter_test.go @@ -0,0 +1,289 @@ +package splitter + +import ( + "testing" + + "github.com/consensys/linea-monorepo/prover/maths/common/smartvectors" + "github.com/consensys/linea-monorepo/prover/maths/common/vector" + "github.com/consensys/linea-monorepo/prover/maths/field" + "github.com/consensys/linea-monorepo/prover/protocol/accessors" + "github.com/consensys/linea-monorepo/prover/protocol/column" + "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" + "github.com/consensys/linea-monorepo/prover/protocol/compiler/dummy" + "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split/stitcher" + "github.com/consensys/linea-monorepo/prover/protocol/ifaces" + "github.com/consensys/linea-monorepo/prover/protocol/query" + "github.com/consensys/linea-monorepo/prover/protocol/variables" + "github.com/consensys/linea-monorepo/prover/protocol/wizard" + "github.com/consensys/linea-monorepo/prover/symbolic" + "github.com/sirupsen/logrus" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + P1 ifaces.ColID = "P1" + GLOBAL1 ifaces.QueryID = "GLOBAL1" + LOCAL1 ifaces.QueryID = "LOCAL1" +) + +func TestSplitterWithFixedPointOpening(t *testing.T) { + testSplitter(t, 16, fixedPointOpening) +} + +func TestSplitterFibo(t *testing.T) { + testSplitter(t, 16, singlePolyFibo(4)) + testSplitter(t, 4, singlePolyFibo(8)) + testSplitter(t, 4, singlePolyFibo(16)) +} + +func TestSplitterGlobalWithPeriodicSample(t *testing.T) { + testSplitter(t, 64, globalWithPeriodicSample(16, 8, 0)) + testSplitter(t, 64, globalWithPeriodicSample(256, 8, 1)) + testSplitter(t, 64, globalWithPeriodicSample(256, 8, 7)) +} + +func TestSplitterLocalWithPeriodicSample(t *testing.T) { + testSplitter(t, 64, localWithPeriodicSample(256, 8, 0)) + testSplitter(t, 64, localWithPeriodicSample(256, 8, 1)) + testSplitter(t, 64, localWithPeriodicSample(256, 8, 7)) +} + +func fixedPointOpening() (wizard.DefineFunc, wizard.ProverStep) { + n := 1 << 6 + definer := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, n) + _ = build.LocalOpening("O1", P1) + _ = build.LocalOpening("O2", column.Shift(P1, 3)) + _ = build.LocalOpening("O3", column.Shift(P1, 4)) + _ = build.LocalOpening("O4", column.Shift(P1, -1)) + } + + prover := func(run *wizard.ProverRuntime) { + p1_ := make([]field.Element, n) + for i := range p1_ { + p1_[i].SetUint64(uint64(i)) + } + p1 := smartvectors.NewRegular(p1_) + run.AssignColumn(P1, p1) + run.AssignLocalPoint("O1", p1.Get(0)) + run.AssignLocalPoint("O2", p1.Get(3)) + run.AssignLocalPoint("O3", p1.Get(4)) + run.AssignLocalPoint("O4", p1.Get(n-1)) + } + + return definer, prover +} + +func singlePolyFibo(size int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + builder := func(build *wizard.Builder) { + // Number of rows + P1 := build.RegisterCommit(P1, size) // overshadows P + + // P(X) = P(X/w) + P(X/w^2) + expr := ifaces.ColumnAsVariable(column.Shift(P1, -1)). + Add(ifaces.ColumnAsVariable(column.Shift(P1, -2))). + Sub(ifaces.ColumnAsVariable(P1)) + + _ = build.GlobalConstraint(GLOBAL1, expr) + _ = build.LocalConstraint(LOCAL1, ifaces.ColumnAsVariable(P1).Sub(symbolic.NewConstant(1))) + } + + prover := func(run *wizard.ProverRuntime) { + x := make([]field.Element, size) + x[0].SetOne() + x[1].SetOne() + for i := 2; i < size; i++ { + x[i].Add(&x[i-1], &x[i-2]) + } + run.AssignColumn(P1, smartvectors.NewRegular(x)) + } + + return builder, prover + } +} + +func globalWithPeriodicSample(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) // overshadows P + _ = build.GlobalConstraint(GLOBAL1, variables.NewPeriodicSample(period, offset).Mul(ifaces.ColumnAsVariable(P1))) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func localWithPeriodicSample(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) // overshadows P + _ = build.LocalConstraint(GLOBAL1, variables.NewPeriodicSample(period, offset).Mul(ifaces.ColumnAsVariable(P1))) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func testSplitter(t *testing.T, splitSize int, gen func() (wizard.DefineFunc, wizard.ProverStep)) { + + // Activates the logs for easy debugging + logrus.SetLevel(logrus.TraceLevel) + + builder, prover := gen() + comp := wizard.Compile(builder, stitcher.Stitcher(splitSize/2, splitSize), Splitter(splitSize), dummy.Compile) + proof := wizard.Prove(comp, prover) + err := wizard.Verify(comp, proof) + + require.NoError(t, err) + + for _, qName := range comp.QueriesNoParams.AllKeysAt(0) { + + switch q := comp.QueriesNoParams.Data(qName).(type) { + + case query.GlobalConstraint: + board := q.Expression.Board() + metadatas := board.ListVariableMetadata() + metadataNames := []string{} + for i := range metadatas { + metadataNames = append(metadataNames, metadatas[i].String()) + } + t.Logf("query %v - with metadata %v", q.ID, metadataNames) + case query.LocalConstraint: + board := q.Expression.Board() + metadatas := board.ListVariableMetadata() + metadataNames := []string{} + for i := range metadatas { + metadataNames = append(metadataNames, metadatas[i].String()) + } + t.Logf("query %v - with metadata %v", q.ID, metadataNames) + } + } +} + +func globalWithVerifColAndPeriodic(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) + verifcol1 := verifiercol.NewFromAccessors(genAccessors(0, size), field.Zero(), size) + verifcol2 := verifiercol.NewFromAccessors(genAccessors(2, size), field.Zero(), size) + _ = build.GlobalConstraint(LOCAL1, + symbolic.Sub( + + symbolic.Mul(symbolic.Sub(1, P1), + verifcol2), + + symbolic.Mul(variables.NewPeriodicSample(period, offset), + symbolic.Add(2, verifcol1))), + ) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func TestLocalEvalWithStatus(t *testing.T) { + + var b, c ifaces.Column + var q2, q3, q6, q7, q10, q11 query.LocalOpening + + define := func(builder *wizard.Builder) { + // declare columns of different sizes + b = builder.RegisterCommit("B", 4) + c = builder.RegisterCommit("C", 8) + + // Local opening at zero + q2 = builder.LocalOpening("Q01", b) + q3 = builder.LocalOpening("Q02", c) + + // Local opening at but shifted by one + q6 = builder.LocalOpening("Q11", column.Shift(b, 1)) + q7 = builder.LocalOpening("Q12", column.Shift(c, 1)) + + // Local opening but shifted by -1 + q10 = builder.LocalOpening("Q21", column.Shift(b, -1)) + q11 = builder.LocalOpening("Q22", column.Shift(c, -1)) + + } + + comp := wizard.Compile(define, Splitter(4)) + + //after splitting-compilation we expect that the eligible columns and their relevant queries be ignored + assert.Equal(t, column.Committed.String(), comp.Columns.Status("B").String()) + assert.Equal(t, column.Ignored.String(), comp.Columns.Status("C").String()) + + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q2.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q3.ID)) + + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q6.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q7.ID)) + + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q10.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q11.ID)) + + // manually compiles the comp + dummy.Compile(comp) + + proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { + // Assigns all the columns + assi.AssignColumn(b.GetColID(), smartvectors.ForTest(2, 3, 4, 5)) + assi.AssignColumn(c.GetColID(), smartvectors.ForTest(6, 7, 8, 9, 10, 11, 12, 13)) + + // And the alleged results + assi.AssignLocalPoint("Q01", field.NewElement(2)) + assi.AssignLocalPoint("Q02", field.NewElement(6)) + + assi.AssignLocalPoint("Q11", field.NewElement(3)) + assi.AssignLocalPoint("Q12", field.NewElement(7)) + + assi.AssignLocalPoint("Q21", field.NewElement(5)) + assi.AssignLocalPoint("Q22", field.NewElement(13)) + + }) + + err := wizard.Verify(comp, proof) + require.NoError(t, err) + +} + +func genAccessors(start, size int) (res []ifaces.Accessor) { + for i := start; i < size+start; i++ { + t := accessors.NewConstant(field.NewElement(uint64(i))) + res = append(res, t) + } + return res +} diff --git a/prover/protocol/compiler/splitter/splitter/stitcher/constraints.go b/prover/protocol/compiler/stitch_split/stitcher/constraints.go similarity index 81% rename from prover/protocol/compiler/splitter/splitter/stitcher/constraints.go rename to prover/protocol/compiler/stitch_split/stitcher/constraints.go index 41e032be3..7d269a2e7 100644 --- a/prover/protocol/compiler/splitter/splitter/stitcher/constraints.go +++ b/prover/protocol/compiler/stitch_split/stitcher/constraints.go @@ -5,7 +5,7 @@ import ( "github.com/consensys/linea-monorepo/prover/protocol/coin" "github.com/consensys/linea-monorepo/prover/protocol/column" "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" - alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/splitter/splitter" + alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split" "github.com/consensys/linea-monorepo/prover/protocol/ifaces" "github.com/consensys/linea-monorepo/prover/protocol/query" "github.com/consensys/linea-monorepo/prover/protocol/variables" @@ -47,6 +47,11 @@ func (ctx stitchingContext) LocalOpening() { if !isColEligible(ctx.Stitchings, q.Pol) { continue } + + switch m := q.Pol.(type) { + case verifiercol.VerifierCol: + utils.Panic("unsupported, received a localOpening over the verifier column %v", m.GetColID()) + } // mark the query as ignored ctx.comp.QueriesParams.MarkAsIgnored(qName) @@ -101,7 +106,7 @@ func (ctx stitchingContext) LocalGlobalConstraints() { ctx.comp.QueriesNoParams.MarkAsIgnored(qName) // adjust the query over the stitching columns - ctx.comp.InsertLocal(round, queryName(qName), ctx.adjustExpression(q.Expression, false)) + ctx.comp.InsertLocal(round, queryName(qName), ctx.adjustExpression(q.Expression, q.DomainSize, false)) case query.GlobalConstraint: board = q.Board() @@ -131,7 +136,7 @@ func (ctx stitchingContext) LocalGlobalConstraints() { // adjust the query over the stitching columns ctx.comp.InsertGlobal(round, queryName(qName), - ctx.adjustExpression(q.Expression, true), + ctx.adjustExpression(q.Expression, q.DomainSize, true), q.NoBoundCancel) default: @@ -143,31 +148,52 @@ func (ctx stitchingContext) LocalGlobalConstraints() { // Takes a sub column and returns the stitching column. // the stitching column is shifted such that the first row agrees with the first row of the sub column. // more detailed, such stitching column agrees with the the sub column up to a subsampling with offset zero. -func getStitchingCol(ctx stitchingContext, col ifaces.Column) ifaces.Column { +// the col should only be either verifiercol or eligible col. +// option is always empty, and used only for the recursive calls over the shifted columns. +func getStitchingCol(ctx stitchingContext, col ifaces.Column, option ...int) ifaces.Column { + var ( + stitchingCol ifaces.Column + newOffset int + round = col.Round() + ) switch m := col.(type) { + // case: verifier columns without shift case verifiercol.VerifierCol: scaling := ctx.MaxSize / col.Size() - return verifiercol.ExpandedVerifCol{ + // expand the veriferCol + stitchingCol = verifiercol.ExpandedVerifCol{ Verifiercol: m, Expansion: scaling, } - } - - // Extract the assumedly single col - natural := column.RootParents(col)[0] + if len(option) != 0 { + // if it is a shifted veriferCol, set the offset for shifting the expanded column + newOffset = option[0] * col.Size() + } + return column.Shift(stitchingCol, newOffset) + case column.Natural: + // find the stitching column + subColInfo := ctx.Stitchings[round].BySubCol[col.GetColID()] + stitchingCol = ctx.comp.Columns.GetHandle(subColInfo.NameBigCol) + scaling := stitchingCol.Size() / col.Size() + if len(option) != 0 { + newOffset = scaling * option[0] + } + newOffset = newOffset + subColInfo.PosInBigCol + return column.Shift(stitchingCol, newOffset) - round := col.Round() - subColInfo := ctx.Stitchings[round].BySubCol[natural.GetColID()] - stitchingCol := ctx.comp.Columns.GetHandle(subColInfo.NameBigCol) + case column.Shifted: + // Shift the stitching column by the right position + offset := column.StackOffsets(col) + col = column.RootParents(col)[0] + res := getStitchingCol(ctx, col, offset) + return res - // Shift the stitching column by the right position - position := column.StackOffsets(col) + default: - scaling := stitchingCol.Size() / natural.Size() - newPosition := scaling*position + subColInfo.PosInBigCol + panic("unsupported") - return column.Shift(stitchingCol, newPosition) + } } func queryName(oldQ ifaces.QueryID) ifaces.QueryID { @@ -179,7 +205,7 @@ func queryName(oldQ ifaces.QueryID) ifaces.QueryID { // This is due to the fact that the verifiercols are not tracked by the compiler and can not be stitched // via [scanAndClassifyEligibleColumns]. func (ctx *stitchingContext) adjustExpression( - expr *symbolic.Expression, + expr *symbolic.Expression, domainSize int, isGlobalConstraint bool, ) ( newExpr *symbolic.Expression, @@ -188,13 +214,11 @@ func (ctx *stitchingContext) adjustExpression( board := expr.Board() metadata := board.ListVariableMetadata() replaceMap := collection.NewMapping[string, *symbolic.Expression]() - domainSize := 0 for i := range metadata { switch m := metadata[i].(type) { case ifaces.Column: // it's always a compiled column - domainSize = m.Size() stitchingCol := getStitchingCol(*ctx, m) replaceMap.InsertNew(m.String(), ifaces.ColumnAsVariable(stitchingCol)) case coin.Info, ifaces.Accessor: diff --git a/prover/protocol/compiler/splitter/splitter/stitcher/stitcher.go b/prover/protocol/compiler/stitch_split/stitcher/stitcher.go similarity index 91% rename from prover/protocol/compiler/splitter/splitter/stitcher/stitcher.go rename to prover/protocol/compiler/stitch_split/stitcher/stitcher.go index 982474f25..9a0344c29 100644 --- a/prover/protocol/compiler/splitter/splitter/stitcher/stitcher.go +++ b/prover/protocol/compiler/stitch_split/stitcher/stitcher.go @@ -4,11 +4,8 @@ import ( "strings" "github.com/consensys/linea-monorepo/prover/maths/common/smartvectors" - "github.com/consensys/linea-monorepo/prover/maths/common/vector" - "github.com/consensys/linea-monorepo/prover/maths/field" "github.com/consensys/linea-monorepo/prover/protocol/column" - "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" - alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/splitter/splitter" + alliance "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split" "github.com/consensys/linea-monorepo/prover/protocol/ifaces" "github.com/consensys/linea-monorepo/prover/protocol/wizard" "github.com/consensys/linea-monorepo/prover/utils" @@ -39,7 +36,7 @@ func Stitcher(minSize, maxSize int) func(comp *wizard.CompiledIOP) { // it assigns the stitching columns and delete the assignment of the sub columns. comp.SubProvers.AppendToInner(comp.NumRounds()-1, func(run *wizard.ProverRuntime) { - for round := range comp.NumRounds() { + for round := range ctx.Stitchings { for subCol := range ctx.Stitchings[round].BySubCol { run.Columns.TryDel(subCol) } @@ -135,8 +132,12 @@ func (ctx *stitchingContext) ScanStitchCommit() { ctx.comp.SubProvers.AppendToInner(round, func(run *wizard.ProverRuntime) { stopTimer := profiling.LogTimer("stitching compiler") defer stopTimer() + var maxSizeGroup int + for idBigCol, subColumns := range ctx.Stitchings[round].ByBigCol { + maxSizeGroup = ctx.MaxSize / subColumns[0].Size() + // Sanity-check sizeBigCol := ctx.comp.Columns.GetHandle(idBigCol).Size() if sizeBigCol != ctx.MaxSize { @@ -154,10 +155,10 @@ func (ctx *stitchingContext) ScanStitchCommit() { witnesses[i] = subColumns[i].GetColAssignment(run) } assignement := smartvectors. - AllocateRegular(len(subColumns) * witnesses[0].Len()).(*smartvectors.Regular) + AllocateRegular(maxSizeGroup * witnesses[0].Len()).(*smartvectors.Regular) for i := range subColumns { for j := 0; j < witnesses[0].Len(); j++ { - (*assignement)[i+j*len(subColumns)] = witnesses[i].Get(j) + (*assignement)[i+j*maxSizeGroup] = witnesses[i].Get(j) } } run.AssignColumn(idBigCol, assignement) @@ -225,13 +226,6 @@ func groupCols(cols []ifaces.Column, numToStitch int) (groups [][]ifaces.Column) groups[i/numToStitch] = append(groups[i/numToStitch], col) } - lastGroup := &groups[len(groups)-1] - zeroCol := verifiercol.NewConstantCol(field.Zero(), size) - - for i := len(*lastGroup); i < numToStitch; i++ { - *lastGroup = append(*lastGroup, zeroCol) - } - return groups } @@ -253,15 +247,25 @@ func (ctx *stitchingContext) stitchGroup(s alliance.Alliance) { // Declare the new columns switch status { case column.Precomputed: - values := make([][]field.Element, len(group)) - for j := range values { - values[j] = smartvectors.IntoRegVec(ctx.comp.Precomputed.MustGet(group[j].GetColID())) + maxSizeGroup := ctx.MaxSize / group[0].Size() + actualSize := len(group) + + // get the assignment of the subColumns and interleave them + witnesses := make([]smartvectors.SmartVector, actualSize) + for i := range witnesses { + witnesses[i] = ctx.comp.Precomputed.MustGet(group[i].GetColID()) + } + assignement := smartvectors. + AllocateRegular(maxSizeGroup * witnesses[0].Len()).(*smartvectors.Regular) + for i := range witnesses { + for j := 0; j < witnesses[0].Len(); j++ { + (*assignement)[i+j*maxSizeGroup] = witnesses[i].Get(j) + } } - assignement := vector.Interleave(values...) + stitchingCol = ctx.comp.InsertPrecomputed( groupedName(group), - smartvectors.NewRegular(assignement), - ) + assignement) case column.Committed: stitchingCol = ctx.comp.InsertCommit( s.Round, diff --git a/prover/protocol/compiler/stitch_split/stitcher/stitcher_test.go b/prover/protocol/compiler/stitch_split/stitcher/stitcher_test.go new file mode 100644 index 000000000..fcb262abe --- /dev/null +++ b/prover/protocol/compiler/stitch_split/stitcher/stitcher_test.go @@ -0,0 +1,322 @@ +package stitcher_test + +import ( + "testing" + + "github.com/consensys/linea-monorepo/prover/maths/common/smartvectors" + "github.com/consensys/linea-monorepo/prover/maths/common/vector" + "github.com/consensys/linea-monorepo/prover/maths/field" + "github.com/consensys/linea-monorepo/prover/protocol/accessors" + "github.com/consensys/linea-monorepo/prover/protocol/column" + "github.com/consensys/linea-monorepo/prover/protocol/column/verifiercol" + "github.com/consensys/linea-monorepo/prover/protocol/compiler/dummy" + "github.com/consensys/linea-monorepo/prover/protocol/compiler/stitch_split/stitcher" + "github.com/consensys/linea-monorepo/prover/protocol/ifaces" + "github.com/consensys/linea-monorepo/prover/protocol/query" + "github.com/consensys/linea-monorepo/prover/protocol/variables" + "github.com/consensys/linea-monorepo/prover/protocol/wizard" + "github.com/consensys/linea-monorepo/prover/symbolic" + sym "github.com/consensys/linea-monorepo/prover/symbolic" + "github.com/sirupsen/logrus" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const ( + P1, P2 ifaces.ColID = "P1", "P2" + GLOBAL1, GLOBAL2 ifaces.QueryID = "GLOBAL1", "GLOBAL2" + LOCAL1 ifaces.QueryID = "LOCAL1" +) + +func TestLocalOpening(t *testing.T) { + testStitcher(t, 8, 16, localOpening(4)) +} + +func TestStitcherFibo(t *testing.T) { + testStitcher(t, 16, 32, singlePolyFibo(4)) + testStitcher(t, 4, 8, singlePolyFibo(8)) + testStitcher(t, 8, 16, singlePolyFibo(8)) +} + +func TestStitcherGlobalWithPeriodicSample(t *testing.T) { + testStitcher(t, 16, 64, globalWithPeriodicSample(16, 8, 0)) + testStitcher(t, 64, 256, globalWithPeriodicSample(256, 8, 1)) + testStitcher(t, 64, 128, globalWithPeriodicSample(256, 8, 7)) +} + +func TestStitcherLocalWithPeriodicSample(t *testing.T) { + testStitcher(t, 32, 64, localWithPeriodicSample(256, 8, 0)) + testStitcher(t, 16, 128, localWithPeriodicSample(256, 8, 1)) + testStitcher(t, 64, 256, localWithPeriodicSample(256, 8, 7)) +} + +func TestSplitterGlobalWithVerifColAndPerriodic(t *testing.T) { + testStitcher(t, 8, 64, globalWithVerifColAndPeriodic(8, 4, 0)) + testStitcher(t, 64, 128, globalWithVerifColAndPeriodic(256, 8, 1)) + testStitcher(t, 8, 16, globalWithVerifColAndPeriodic(256, 8, 7)) +} + +func TestLocalEvalWithStatus(t *testing.T) { + + var a, b, c, d ifaces.Column + var q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12 query.LocalOpening + + define := func(builder *wizard.Builder) { + // declare columns of different sizes + a = builder.RegisterCommit("A", 2) + b = builder.RegisterCommit("B", 4) + c = builder.RegisterCommit("C", 8) + d = builder.RegisterCommit("D", 16) + + // Local opening at zero + q1 = builder.LocalOpening("Q00", a) + q2 = builder.LocalOpening("Q01", b) + q3 = builder.LocalOpening("Q02", c) + q4 = builder.LocalOpening("Q03", d) + + // Local opening at but shifted by one + q5 = builder.LocalOpening("Q10", column.Shift(a, 1)) + q6 = builder.LocalOpening("Q11", column.Shift(b, 1)) + q7 = builder.LocalOpening("Q12", column.Shift(c, 1)) + q8 = builder.LocalOpening("Q13", column.Shift(d, 1)) + + // Local opening at but shifted by one + q9 = builder.LocalOpening("Q20", column.Shift(a, -1)) + q10 = builder.LocalOpening("Q21", column.Shift(b, -1)) + q11 = builder.LocalOpening("Q22", column.Shift(c, -1)) + q12 = builder.LocalOpening("Q23", column.Shift(d, -1)) + } + + comp := wizard.Compile(define, stitcher.Stitcher(4, 8)) + + //after stitcing-compilation we expect that the eligible columns and their relevant queries be ignored + assert.Equal(t, column.Proof.String(), comp.Columns.Status("A").String()) + assert.Equal(t, column.Ignored.String(), comp.Columns.Status("B").String()) + assert.Equal(t, column.Committed.String(), comp.Columns.Status("C").String()) + assert.Equal(t, column.Committed.String(), comp.Columns.Status("D").String()) + + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q1.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q2.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q3.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q4.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q5.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q6.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q7.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q8.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q9.ID)) + assert.Equal(t, true, comp.QueriesParams.IsIgnored(q10.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q11.ID)) + assert.Equal(t, false, comp.QueriesParams.IsIgnored(q12.ID)) + + // manually compiles the comp + dummy.Compile(comp) + + proof := wizard.Prove(comp, func(assi *wizard.ProverRuntime) { + // Assigns all the columns + assi.AssignColumn(a.GetColID(), smartvectors.ForTest(0, 1)) + assi.AssignColumn(b.GetColID(), smartvectors.ForTest(2, 3, 4, 5)) + assi.AssignColumn(c.GetColID(), smartvectors.ForTest(6, 7, 8, 9, 10, 11, 12, 13)) + assi.AssignColumn(d.GetColID(), smartvectors.ForTest(15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30)) + + // And the alleged results + assi.AssignLocalPoint("Q00", field.NewElement(0)) + assi.AssignLocalPoint("Q01", field.NewElement(2)) + assi.AssignLocalPoint("Q02", field.NewElement(6)) + assi.AssignLocalPoint("Q03", field.NewElement(15)) + assi.AssignLocalPoint("Q10", field.NewElement(1)) + assi.AssignLocalPoint("Q11", field.NewElement(3)) + assi.AssignLocalPoint("Q12", field.NewElement(7)) + assi.AssignLocalPoint("Q13", field.NewElement(16)) + assi.AssignLocalPoint("Q20", field.NewElement(1)) + assi.AssignLocalPoint("Q21", field.NewElement(5)) + assi.AssignLocalPoint("Q22", field.NewElement(13)) + assi.AssignLocalPoint("Q23", field.NewElement(30)) + }) + + err := wizard.Verify(comp, proof) + require.NoError(t, err) + +} + +func testStitcher(t *testing.T, minSize, maxSize int, gen func() (wizard.DefineFunc, wizard.ProverStep)) { + + // Activates the logs for easy debugging + logrus.SetLevel(logrus.TraceLevel) + + builder, prover := gen() + comp := wizard.Compile(builder, stitcher.Stitcher(minSize, maxSize), dummy.Compile) + proof := wizard.Prove(comp, prover) + err := wizard.Verify(comp, proof) + + require.NoError(t, err) + + for _, qName := range comp.QueriesNoParams.AllKeysAt(0) { + + switch q := comp.QueriesNoParams.Data(qName).(type) { + + case query.GlobalConstraint: + board := q.Expression.Board() + metadatas := board.ListVariableMetadata() + metadataNames := []string{} + for i := range metadatas { + metadataNames = append(metadataNames, metadatas[i].String()) + } + t.Logf("query %v - with metadata %v", q.ID, metadataNames) + case query.LocalConstraint: + board := q.Expression.Board() + metadatas := board.ListVariableMetadata() + metadataNames := []string{} + for i := range metadatas { + metadataNames = append(metadataNames, metadatas[i].String()) + } + t.Logf("query %v - with metadata %v", q.ID, metadataNames) + } + } +} + +func localOpening(n int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + definer := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, n) + _ = build.LocalOpening("O1", P1) + _ = build.LocalOpening("O2", column.Shift(P1, 3)) + _ = build.LocalOpening("O3", column.Shift(P1, 4)) + _ = build.LocalOpening("O4", column.Shift(P1, -1)) + } + + prover := func(run *wizard.ProverRuntime) { + p1_ := make([]field.Element, n) + for i := range p1_ { + p1_[i].SetUint64(uint64(i)) + } + p1 := smartvectors.NewRegular(p1_) + run.AssignColumn(P1, p1) + run.AssignLocalPoint("O1", p1.Get(0%n)) + run.AssignLocalPoint("O2", p1.Get(3%n)) + run.AssignLocalPoint("O3", p1.Get(4%n)) + run.AssignLocalPoint("O4", p1.Get(n-1)) + } + + return definer, prover + } +} + +func singlePolyFibo(size int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + builder := func(build *wizard.Builder) { + // Number of rows + P1 := build.RegisterCommit(P1, size) // overshadows P + P2 := build.RegisterCommit(P2, size) + + // P(X) = P(X/w) + P(X/w^2) + expr1 := sym.Sub( + sym.Add(column.Shift(P1, 1), P1), + column.Shift(P1, 2)) + + expr2 := sym.Sub( + sym.Add(column.Shift(P2, 1), P2), + column.Shift(P2, 2)) + + _ = build.GlobalConstraint(GLOBAL1, expr1) + _ = build.GlobalConstraint(GLOBAL2, expr2) + // _ = build.LocalConstraint(LOCAL1, sym.Sub(P1, 1)) + } + + prover := func(run *wizard.ProverRuntime) { + x := make([]field.Element, size) + x[0].SetOne() + x[1].SetOne() + for i := 2; i < size; i++ { + x[i].Add(&x[i-1], &x[i-2]) + } + run.AssignColumn(P1, smartvectors.NewRegular(x)) + run.AssignColumn(P2, smartvectors.NewRegular(x)) + } + + return builder, prover + } +} + +func globalWithPeriodicSample(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) // overshadows P + _ = build.GlobalConstraint(GLOBAL1, variables.NewPeriodicSample(period, offset).Mul(ifaces.ColumnAsVariable(P1))) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func localWithPeriodicSample(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) // overshadows P + _ = build.LocalConstraint(GLOBAL1, variables.NewPeriodicSample(period, offset).Mul(ifaces.ColumnAsVariable(P1))) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func globalWithVerifColAndPeriodic(size, period, offset int) func() (wizard.DefineFunc, wizard.ProverStep) { + return func() (wizard.DefineFunc, wizard.ProverStep) { + + builder := func(build *wizard.Builder) { + P1 := build.RegisterCommit(P1, size) + verifcol1 := verifiercol.NewFromAccessors(genAccessors(0, size), field.Zero(), size) + verifcol2 := verifiercol.NewFromAccessors(genAccessors(2, size), field.Zero(), size) + _ = build.GlobalConstraint(LOCAL1, + symbolic.Sub( + + symbolic.Mul(symbolic.Sub(1, P1), + verifcol2), + + symbolic.Mul(variables.NewPeriodicSample(period, offset), + symbolic.Add(2, verifcol1))), + ) + } + + prover := func(run *wizard.ProverRuntime) { + v := vector.Repeat(field.One(), size) + for i := 0; i < size; i++ { + if i%period == offset { + v[i].SetZero() + } + } + run.AssignColumn(P1, smartvectors.NewRegular(v)) + } + + return builder, prover + } +} + +func genAccessors(start, size int) (res []ifaces.Accessor) { + for i := start; i < size+start; i++ { + t := accessors.NewConstant(field.NewElement(uint64(i))) + res = append(res, t) + } + return res +} diff --git a/prover/protocol/query/global.go b/prover/protocol/query/global.go index e3f399dd1..63dbbc4c4 100644 --- a/prover/protocol/query/global.go +++ b/prover/protocol/query/global.go @@ -162,6 +162,9 @@ func (cs GlobalConstraint) Check(run ifaces.Runtime) error { stop -= offsetRange.Max } + start = max(start, 0) + stop = min(stop, cs.DomainSize) + for i := start; i < stop; i++ { resx := res.Get(i) diff --git a/prover/protocol/query/global_test.go b/prover/protocol/query/global_test.go index d4734ad7d..3a69cf216 100644 --- a/prover/protocol/query/global_test.go +++ b/prover/protocol/query/global_test.go @@ -16,7 +16,7 @@ import ( func TestGlobal(t *testing.T) { runTest(t, pythagoreTriplet, true) runTest(t, fibonacci, true) - + runTest(t, testDummyShifted, true) } func runTest(t *testing.T, gen GlobalConstraintGenerator, expectedCorrect bool) { @@ -98,3 +98,25 @@ func pythagoreTriplet() (wizard.DefineFunc, wizard.ProverStep) { return define, hLProver } + +func testDummyShifted() (wizard.DefineFunc, wizard.ProverStep) { + var ( + X, Y ifaces.ColID = "X", "Y" + ) + define := func(build *wizard.Builder) { + A := build.RegisterCommit(X, 4) + B := build.RegisterCommit(Y, 4) + + expr := symbolic.Sub(column.Shift(A, 1), + symbolic.Mul(2, column.Shift(B, 1))) + + build.InsertGlobal(0, "Q", expr) + } + Prover := func(run *wizard.ProverRuntime) { + x := smartvectors.ForTest(2, 8, 4, 0) + y := smartvectors.ForTest(1, 4, 2, 0) + run.AssignColumn(X, x) + run.AssignColumn(Y, y) + } + return define, Prover +} diff --git a/prover/zkevm/prover/hash/packing/cld.go b/prover/zkevm/prover/hash/packing/cld.go index c8ee6bde3..d6ef3ecd4 100644 --- a/prover/zkevm/prover/hash/packing/cld.go +++ b/prover/zkevm/prover/hash/packing/cld.go @@ -101,6 +101,7 @@ func newDecomposition(comp *wizard.CompiledIOP, inp decompositionInputs) decompo Table: decomposed.decomposedLimbs, TableLen: decomposed.decomposedLen, MaxLen: inp.param.LaneSizeBytes(), + Name: inp.Name, } decomposed.pa = dedicated.LengthConsistency(comp, lcInputs) @@ -113,8 +114,8 @@ func (decomposed *decomposition) insertCommit(comp *wizard.CompiledIOP) { createCol := common.CreateColFn(comp, DECOMPOSITION+"_"+decomposed.Inputs.Name, decomposed.size) for x := 0; x < decomposed.nbSlices; x++ { decomposed.decomposedLimbs = append(decomposed.decomposedLimbs, createCol("Decomposed_Limbs", x)) - decomposed.decomposedLen = append(decomposed.decomposedLen, createCol("Decomposed_Len", x)) - decomposed.decomposedLenPowers = append(decomposed.decomposedLenPowers, createCol("Decomposed_Len_Powers", x)) + decomposed.decomposedLen = append(decomposed.decomposedLen, createCol("Decomposed_Len_%v", x)) + decomposed.decomposedLenPowers = append(decomposed.decomposedLenPowers, createCol("Decomposed_Len_Powers_%v", x)) } decomposed.paIsZero = make([]wizard.ProverAction, decomposed.nbSlices) diff --git a/prover/zkevm/prover/hash/packing/dedicated/len_consistency.go b/prover/zkevm/prover/hash/packing/dedicated/len_consistency.go index c0153a3e9..bb24b77aa 100644 --- a/prover/zkevm/prover/hash/packing/dedicated/len_consistency.go +++ b/prover/zkevm/prover/hash/packing/dedicated/len_consistency.go @@ -2,7 +2,6 @@ package dedicated import ( "slices" - "strconv" "github.com/consensys/linea-monorepo/prover/maths/common/smartvectors" "github.com/consensys/linea-monorepo/prover/maths/field" @@ -23,6 +22,8 @@ type LcInputs struct { TableLen []ifaces.Column // max length in bytes. MaxLen int + // name of the table + Name string } // lengthConsistency stores the intermediate columns for [LengthConsistency] function. @@ -44,7 +45,7 @@ type lengthConsistency struct { func LengthConsistency(comp *wizard.CompiledIOP, inp LcInputs) *lengthConsistency { var ( - name = strconv.Itoa(len(comp.ListCommitments())) + name = inp.Name numCol = len(inp.Table) size = inp.Table[0].Size() numBytes = inp.MaxLen @@ -60,7 +61,7 @@ func LengthConsistency(comp *wizard.CompiledIOP, inp LcInputs) *lengthConsistenc for j := 0; j < numCol; j++ { res.bytesLen[j] = make([]ifaces.Column, numBytes) for k := range res.bytesLen[0] { - res.bytesLen[j][k] = createCol("BytesLen", j, k) + res.bytesLen[j][k] = createCol("BYTE_LEN_%v_%v", j, k) } } From f9aa7e7d4ddaba6288be3d7f274b00a1c2d1833c Mon Sep 17 00:00:00 2001 From: Azam Soleimanian <49027816+Soleimani193@users.noreply.github.com> Date: Tue, 15 Oct 2024 10:14:04 +0200 Subject: [PATCH 02/12] fixed the bug in the permutation (#155) --- .../protocol/compiler/permutation/compiler.go | 2 +- .../compiler/permutation/compiler_test.go | 135 ++++++++++++++++-- 2 files changed, 123 insertions(+), 14 deletions(-) diff --git a/prover/protocol/compiler/permutation/compiler.go b/prover/protocol/compiler/permutation/compiler.go index e92322869..1c8320dba 100644 --- a/prover/protocol/compiler/permutation/compiler.go +++ b/prover/protocol/compiler/permutation/compiler.go @@ -82,7 +82,7 @@ func dispatchPermutation( ) if isMultiColumn { - factor = wizardutils.RandLinCombColSymbolic(alpha, q.A[frag]) + factor = wizardutils.RandLinCombColSymbolic(alpha, aOrB[frag]) } factor = symbolic.Add(factor, beta) diff --git a/prover/protocol/compiler/permutation/compiler_test.go b/prover/protocol/compiler/permutation/compiler_test.go index ec81b911e..6dfc439d7 100644 --- a/prover/protocol/compiler/permutation/compiler_test.go +++ b/prover/protocol/compiler/permutation/compiler_test.go @@ -12,9 +12,10 @@ import ( func TestPermutationPass(t *testing.T) { testCases := []struct { - Define func(*wizard.Builder) - Prove func(*wizard.ProverRuntime) - Title string + Define func(*wizard.Builder) + Prove func(*wizard.ProverRuntime) + Title string + ShouldPass bool }{ { Define: func(builder *wizard.Builder) { @@ -28,7 +29,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B", smartvectors.ForTest(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) }, - Title: "single-column", + Title: "single-column", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -40,6 +42,7 @@ func TestPermutationPass(t *testing.T) { builder.RegisterCommit("B1", 16), builder.RegisterCommit("B2", 16), } + // the same permutation amon columns of a and b builder.Permutation("PERM", a, b) }, @@ -50,7 +53,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B2", smartvectors.ForTest(115, 114, 113, 112, 111, 110, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10)) }, - Title: "two-columnss", + Title: "two-columnss", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -62,6 +66,7 @@ func TestPermutationPass(t *testing.T) { builder.RegisterCommit("B1", 16), builder.RegisterCommit("B2", 16), } + // PERM1 does not have to be the same permutations as PERM2 builder.Permutation("PERM1", a[:1], b[:1]) builder.Permutation("PERM2", a[1:], b[1:]) }, @@ -73,7 +78,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B2", smartvectors.ForTest(115, 114, 113, 112, 111, 110, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10)) }, - Title: "two queries for one column", + Title: "two queries for one column", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -106,7 +112,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B4", smartvectors.ForTest(1225, 1224, 1223, 1222, 1222, 1220, 129, 128, 127, 126, 125, 124, 123, 122, 122, 120)) }, - Title: "4 queries for one column, all on one column", + Title: "4 queries for one column, all on one column", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -130,6 +137,7 @@ func TestPermutationPass(t *testing.T) { builder.RegisterCommit("B7", 8), builder.RegisterCommit("B8", 8), } + // the permutation between a[0] and b [0] is the same permutation as the one between a[1] and b[1] builder.Permutation("PERM1", a[0:2], b[0:2]) builder.Permutation("PERM2", a[2:4], b[2:4]) builder.Permutation("PERM3", a[4:6], b[4:6]) @@ -156,7 +164,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B8", smartvectors.ForTest(14, 15, 16, 17, 18, 19, 110, 13)) }, - Title: "4 queries for one column, all on two columns", + Title: "4 queries for one column, all on two columns", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -206,7 +215,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B8", smartvectors.ForTest(14, 15, 16, 17, 18, 19, 110, 13)) }, - Title: "4 queries for one column, all on two columns", + Title: "4 queries for one column, all on two columns", + ShouldPass: true, }, { Define: func(builder *wizard.Builder) { @@ -230,6 +240,7 @@ func TestPermutationPass(t *testing.T) { builder.RegisterCommit("B7", 8), builder.RegisterCommit("B8", 8), } + // each fragment has its own permutation, but the permutation is the same for the columns from the same fragment. builder.CompiledIOP.InsertFragmentedPermutation(0, "PERM1", [][]ifaces.Column{a[0:2], a[2:4]}, [][]ifaces.Column{b[0:2], b[2:4]}) builder.CompiledIOP.InsertFragmentedPermutation(0, "PERM2", [][]ifaces.Column{a[4:6], a[6:8]}, [][]ifaces.Column{b[4:6], b[6:8]}) }, @@ -244,6 +255,98 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("A7", smartvectors.ForTest(12, 13, 14, 15, 16, 17, 18, 19)) run.AssignColumn("A8", smartvectors.ForTest(13, 14, 15, 16, 17, 18, 19, 110)) + run.AssignColumn("B1", smartvectors.ForTest(1, 2, 3, 0)) + run.AssignColumn("B2", smartvectors.ForTest(2, 3, 4, 1)) + run.AssignColumn("B3", smartvectors.ForTest(2, 4, 3, 5)) + run.AssignColumn("B4", smartvectors.ForTest(3, 5, 4, 6)) + run.AssignColumn("B5", smartvectors.ForTest(11, 12, 13, 14, 15, 16, 17, 10)) + run.AssignColumn("B6", smartvectors.ForTest(12, 13, 14, 15, 16, 17, 18, 11)) + run.AssignColumn("B7", smartvectors.ForTest(13, 14, 15, 16, 17, 18, 19, 12)) + run.AssignColumn("B8", smartvectors.ForTest(14, 15, 16, 17, 18, 19, 110, 13)) + }, + + Title: "2 fragmented multi-column queries using different sizes", + ShouldPass: true, + }, + { + Define: func(builder *wizard.Builder) { + a := [][]ifaces.Column{ + {builder.RegisterCommit("A1", 4)}, + {builder.RegisterCommit("A2", 4)}, + {builder.RegisterCommit("A3", 4)}, + {builder.RegisterCommit("A4", 4)}, + } + b := [][]ifaces.Column{ + {builder.RegisterCommit("B1", 16)}, + } + builder.CompiledIOP.InsertFragmentedPermutation(0, "PERM1", a, b) + }, + + Prove: func(run *wizard.ProverRuntime) { + run.AssignColumn("A1", smartvectors.ForTest(0, 1, 2, 3)) + run.AssignColumn("A2", smartvectors.ForTest(4, 5, 6, 7)) + run.AssignColumn("A3", smartvectors.ForTest(8, 9, 10, 11)) + run.AssignColumn("A4", smartvectors.ForTest(12, 13, 14, 15)) + + run.AssignColumn("B1", smartvectors.ForTest(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)) + }, + + Title: "dissymetric fractional query", + ShouldPass: true, + }, + + // test cases that should Not Pass + { + Define: func(builder *wizard.Builder) { + a := builder.RegisterCommit("A", 16) + b := builder.RegisterCommit("B", 16) + builder.Permutation("PERM", []ifaces.Column{a}, []ifaces.Column{b}) + }, + + Prove: func(run *wizard.ProverRuntime) { + run.AssignColumn("A", smartvectors.ForTest(0, 2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)) + run.AssignColumn("B", smartvectors.ForTest(15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) + }, + + Title: "single-column, should not pass", + ShouldPass: false, + }, + { + Define: func(builder *wizard.Builder) { + a := []ifaces.Column{ + builder.RegisterCommit("A1", 4), + builder.RegisterCommit("A2", 4), + builder.RegisterCommit("A3", 4), + builder.RegisterCommit("A4", 4), + builder.RegisterCommit("A5", 8), + builder.RegisterCommit("A6", 8), + builder.RegisterCommit("A7", 8), + builder.RegisterCommit("A8", 8), + } + b := []ifaces.Column{ + builder.RegisterCommit("B1", 4), + builder.RegisterCommit("B2", 4), + builder.RegisterCommit("B3", 4), + builder.RegisterCommit("B4", 4), + builder.RegisterCommit("B5", 8), + builder.RegisterCommit("B6", 8), + builder.RegisterCommit("B7", 8), + builder.RegisterCommit("B8", 8), + } + builder.CompiledIOP.InsertFragmentedPermutation(0, "PERM1", [][]ifaces.Column{a[0:2], a[2:4]}, [][]ifaces.Column{b[0:2], b[2:4]}) + builder.CompiledIOP.InsertFragmentedPermutation(0, "PERM2", [][]ifaces.Column{a[4:6], a[6:8]}, [][]ifaces.Column{b[4:6], b[6:8]}) + }, + + Prove: func(run *wizard.ProverRuntime) { + run.AssignColumn("A1", smartvectors.ForTest(0, 1, 2, 3)) + run.AssignColumn("A2", smartvectors.ForTest(2, 2, 3, 4)) + run.AssignColumn("A3", smartvectors.ForTest(2, 3, 4, 5)) + run.AssignColumn("A4", smartvectors.ForTest(3, 4, 5, 6)) + run.AssignColumn("A5", smartvectors.ForTest(10, 11, 12, 13, 14, 15, 16, 17)) + run.AssignColumn("A6", smartvectors.ForTest(11, 12, 13, 14, 15, 16, 17, 18)) + run.AssignColumn("A7", smartvectors.ForTest(12, 13, 14, 15, 16, 17, 18, 19)) + run.AssignColumn("A8", smartvectors.ForTest(13, 14, 15, 16, 17, 18, 19, 110)) + run.AssignColumn("B1", smartvectors.ForTest(1, 2, 3, 0)) run.AssignColumn("B2", smartvectors.ForTest(2, 3, 4, 1)) run.AssignColumn("B3", smartvectors.ForTest(3, 4, 5, 2)) @@ -254,8 +357,10 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B8", smartvectors.ForTest(14, 15, 16, 17, 18, 19, 110, 13)) }, - Title: "2 fragmented multi-column queries using different sizes", + Title: "2 fragmented multi-column queries using different sizes, should not pass", + ShouldPass: false, }, + { Define: func(builder *wizard.Builder) { a := [][]ifaces.Column{ @@ -271,7 +376,7 @@ func TestPermutationPass(t *testing.T) { }, Prove: func(run *wizard.ProverRuntime) { - run.AssignColumn("A1", smartvectors.ForTest(0, 1, 2, 3)) + run.AssignColumn("A1", smartvectors.ForTest(1, 1, 2, 3)) run.AssignColumn("A2", smartvectors.ForTest(4, 5, 6, 7)) run.AssignColumn("A3", smartvectors.ForTest(8, 9, 10, 11)) run.AssignColumn("A4", smartvectors.ForTest(12, 13, 14, 15)) @@ -279,7 +384,8 @@ func TestPermutationPass(t *testing.T) { run.AssignColumn("B1", smartvectors.ForTest(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)) }, - Title: "dissymetric fractional query", + Title: "dissymetric fractional query, should not pass", + ShouldPass: false, }, } @@ -287,9 +393,12 @@ func TestPermutationPass(t *testing.T) { t.Run(testCase.Title, func(t *testing.T) { comp := wizard.Compile(testCase.Define, CompileGrandProduct, dummy.Compile) proof := wizard.Prove(comp, testCase.Prove) - if err := wizard.Verify(comp, proof); err != nil { + if err := wizard.Verify(comp, proof); err != nil && testCase.ShouldPass { t.Fatalf("verifier did not pass: %v", err.Error()) } + if err := wizard.Verify(comp, proof); err == nil && !testCase.ShouldPass { + t.Fatalf("verifier is passing for a false claim") + } }) } } From bb78efe353c88320f0057d6da6bfbbfd6baf6592 Mon Sep 17 00:00:00 2001 From: Victorien Gauch <85494462+VGau@users.noreply.github.com> Date: Tue, 15 Oct 2024 11:36:01 +0200 Subject: [PATCH 03/12] Fix: optimize postman docker build (#183) * fix: optimize postman docker build * fix: format readme * fix: add apt get clean * fix: refactor docker cache issue in the CI workflow --- .github/workflows/postman-build-and-publish.yml | 8 ++++++-- sdk/Dockerfile | 12 +++++++----- sdk/README.md | 2 -- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/.github/workflows/postman-build-and-publish.yml b/.github/workflows/postman-build-and-publish.yml index b72388022..ab2246112 100644 --- a/.github/workflows/postman-build-and-publish.yml +++ b/.github/workflows/postman-build-and-publish.yml @@ -71,7 +71,11 @@ jobs: push: true tags: | ${{ env.IMAGE_NAME }}:${{ env.COMMIT_TAG }}-${{ env.UNTESTED_TAG_SUFFIX }} - cache-from: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache - cache-to: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache,mode=max + cache-from: | + type=registry,ref=${{ env.IMAGE_NAME }}:buildcache-amd64,platform=linux/amd64 + type=registry,ref=${{ env.IMAGE_NAME }}:buildcache-arm64,platform=linux/arm64 + cache-to: | + type=registry,ref=${{ env.IMAGE_NAME }}:buildcache-amd64,mode=max,platform=linux/amd64 + type=registry,ref=${{ env.IMAGE_NAME }}:buildcache-arm64,mode=max,platform=linux/arm64 build-args: | NATIVE_LIBS_RELEASE_TAG=blob-libs-v1.0.1 diff --git a/sdk/Dockerfile b/sdk/Dockerfile index fc733355c..c77e6993b 100644 --- a/sdk/Dockerfile +++ b/sdk/Dockerfile @@ -5,6 +5,11 @@ ENV PATH="$PNPM_HOME:$PATH" RUN corepack enable +RUN apt-get update \ + && apt-get install -y --no-install-recommends python3 ca-certificates bash curl make g++ \ + && apt-get clean \ + && rm -rf /var/lib/apt/lists/* + FROM base AS builder WORKDIR /usr/src/app @@ -16,10 +21,7 @@ COPY package.json pnpm-lock.yaml pnpm-workspace.yaml tsconfig.json ./ COPY ./sdk/package.json ./sdk/package.json COPY ./ts-libs/linea-native-libs/package.json ./ts-libs/linea-native-libs/package.json -RUN --mount=type=cache,id=pnpm,target=/pnpm/store apt-get update && apt-get install -y --no-install-recommends python3 ca-certificates bash curl make g++ \ - && pnpm install --frozen-lockfile --prefer-offline --ignore-scripts \ - && apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false \ - && rm -rf /var/lib/apt/lists/* +RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile --prefer-offline --ignore-scripts COPY ./sdk ./sdk COPY ts-libs/linea-native-libs ./ts-libs/linea-native-libs @@ -27,7 +29,7 @@ COPY ts-libs/linea-native-libs ./ts-libs/linea-native-libs RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm run build \ && pnpm deploy --filter=./sdk --prod ./prod/sdk -FROM base AS production +FROM node:lts-slim AS production ENV NODE_ENV=production diff --git a/sdk/README.md b/sdk/README.md index 5a11cd9cb..702e8fbdc 100644 --- a/sdk/README.md +++ b/sdk/README.md @@ -40,5 +40,3 @@ This package exposes two main classes for usage: ## License This package is licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for more information. - - From 215b60c9f0f3b61c5541b8f040c0a49e49f402eb Mon Sep 17 00:00:00 2001 From: Victorien Gauch <85494462+VGau@users.noreply.github.com> Date: Tue, 15 Oct 2024 19:26:23 +0200 Subject: [PATCH 04/12] Feat(#133): run e2e tests in parallel (#164) * feat: run e2e tests in paralell + refactor test setup * fix: open handle issue * fix: sequencer finalized tag test issue + clean l2.spec tests * fix: refactor config structure * fix: genesis path issue * fix: pnpm lock file issue * fix: make each test run concurrently * fix: remove nested describes in tests * fix: refactor coordinator tests + add global L2 traffic generation * fix: change l2 genesis file for getting whale accounts + refactor utils function * fix: refactor coordinator restart util function * fix: remove conflation e2e tests * fix: add environment variable in e2e test ci workflowk * fix: coordinator restart test issue * fix: instanciate account manager only once per test file * fix: add restart option to zkbesu shomei and postman in docker compose file * fix: remove getAndIncreaseFeeData function and unsed utils functions * fix: increase messaging L2 to l1 timeout --- docker/compose.yml | 2 + e2e/env-setup/custom.d.ts | 33 - e2e/env-setup/global-setup.ts | 6 - e2e/env-setup/global-teardown.ts | 5 - e2e/env-setup/global-test-env.ts | 19 - e2e/env-setup/setup-dev.ts | 53 - e2e/env-setup/setup-local-deploy.ts | 81 - e2e/env-setup/setup-local.ts | 92 - e2e/env-setup/setup-shadow.ts | 62 - e2e/env-setup/setup-uat.ts | 59 - e2e/jest.config.ts | 13 +- e2e/jest.local.config.ts | 15 - e2e/jest.shadow.config.ts | 12 - ...t.dev.config.ts => jest.testnet.config.ts} | 7 +- e2e/jest.uat.config.ts | 12 - e2e/jest.vscode.config.ts | 14 - e2e/package.json | 23 +- e2e/src/{utils => common}/constants.ts | 4 +- e2e/src/{utils => common}/deployments.ts | 40 +- e2e/src/{utils => common}/types.ts | 10 +- e2e/src/{utils => common}/upgrades.ts | 17 +- e2e/src/common/utils.ts | 263 ++ e2e/src/config/jest/global-setup.ts | 39 + e2e/src/config/jest/global-teardown.ts | 3 + .../tests-config/accounts/account-manager.ts | 124 + .../config/tests-config/accounts/account.ts | 9 + .../environment-based-account-manager.ts | 11 + .../accounts/genesis-based-account-manager.ts | 41 + .../config/tests-config/environments/dev.ts | 49 + .../config/tests-config/environments/local.ts | 44 + .../tests-config/environments/sepolia.ts | 48 + e2e/src/config/tests-config/index.ts | 26 + e2e/src/config/tests-config/setup.ts | 97 + e2e/src/config/tests-config/types.ts | 24 + e2e/src/index.ordered-test.ts | 12 - e2e/src/l2.spec.ts | 444 +-- e2e/src/messaging.spec.ts | 334 +- e2e/src/restart.spec.ts | 168 +- e2e/src/submission-finalization.spec.ts | 307 +- e2e/src/utils/constants.dev.ts | 44 - e2e/src/utils/constants.local.ts | 60 - e2e/src/utils/constants.uat.ts | 43 - e2e/src/utils/helpers.ts | 9 - e2e/src/utils/utils.ts | 288 -- e2e/tsconfig.json | 1 - pnpm-lock.yaml | 3138 +++++++---------- 46 files changed, 2764 insertions(+), 3441 deletions(-) delete mode 100644 e2e/env-setup/custom.d.ts delete mode 100644 e2e/env-setup/global-setup.ts delete mode 100644 e2e/env-setup/global-teardown.ts delete mode 100644 e2e/env-setup/global-test-env.ts delete mode 100644 e2e/env-setup/setup-dev.ts delete mode 100644 e2e/env-setup/setup-local-deploy.ts delete mode 100644 e2e/env-setup/setup-local.ts delete mode 100644 e2e/env-setup/setup-shadow.ts delete mode 100644 e2e/env-setup/setup-uat.ts delete mode 100644 e2e/jest.local.config.ts delete mode 100644 e2e/jest.shadow.config.ts rename e2e/{jest.dev.config.ts => jest.testnet.config.ts} (60%) delete mode 100644 e2e/jest.uat.config.ts delete mode 100644 e2e/jest.vscode.config.ts rename e2e/src/{utils => common}/constants.ts (83%) rename e2e/src/{utils => common}/deployments.ts (53%) rename e2e/src/{utils => common}/types.ts (84%) rename e2e/src/{utils => common}/upgrades.ts (71%) create mode 100644 e2e/src/common/utils.ts create mode 100644 e2e/src/config/jest/global-setup.ts create mode 100644 e2e/src/config/jest/global-teardown.ts create mode 100644 e2e/src/config/tests-config/accounts/account-manager.ts create mode 100644 e2e/src/config/tests-config/accounts/account.ts create mode 100644 e2e/src/config/tests-config/accounts/environment-based-account-manager.ts create mode 100644 e2e/src/config/tests-config/accounts/genesis-based-account-manager.ts create mode 100644 e2e/src/config/tests-config/environments/dev.ts create mode 100644 e2e/src/config/tests-config/environments/local.ts create mode 100644 e2e/src/config/tests-config/environments/sepolia.ts create mode 100644 e2e/src/config/tests-config/index.ts create mode 100644 e2e/src/config/tests-config/setup.ts create mode 100644 e2e/src/config/tests-config/types.ts delete mode 100644 e2e/src/index.ordered-test.ts delete mode 100644 e2e/src/utils/constants.dev.ts delete mode 100644 e2e/src/utils/constants.local.ts delete mode 100644 e2e/src/utils/constants.uat.ts delete mode 100644 e2e/src/utils/helpers.ts delete mode 100644 e2e/src/utils/utils.ts diff --git a/docker/compose.yml b/docker/compose.yml index 7d981bfaf..4f4bcf2f9 100644 --- a/docker/compose.yml +++ b/docker/compose.yml @@ -182,6 +182,7 @@ services: image: consensys/linea-postman:${POSTMAN_TAG:-5a6fdf3} profiles: [ "l2", "debug" ] platform: linux/amd64 + restart: on-failure depends_on: sequencer: condition: service_healthy @@ -468,6 +469,7 @@ services: sequencer: condition: service_healthy privileged: true + restart: always user: root ports: - "8945:8545" # http diff --git a/e2e/env-setup/custom.d.ts b/e2e/env-setup/custom.d.ts deleted file mode 100644 index fbf4581e6..000000000 --- a/e2e/env-setup/custom.d.ts +++ /dev/null @@ -1,33 +0,0 @@ -/* eslint-disable no-var */ -import { JsonRpcProvider } from "@ethersproject/providers"; -import { TestEnvironment } from "./test-env"; -import { DummyContract, L2MessageService, L2TestContract, LineaRollup } from "src/typechain"; - -declare global { - var testingEnv: TestEnvironment; - var l1Provider: JsonRpcProvider; - var l2Provider: JsonRpcProvider; - var l2MessageService: L2MessageService; - var dummyContract: DummyContract; - var l1DummyContract: DummyContract; - var l2TestContract: L2TestContract; - var lineaRollup: LineaRollup; - var useLocalSetup: boolean; - var chainId: number; - var CHAIN_ID: number; - var L2_MESSAGE_SERVICE_ADDRESS: string; - var LINEA_ROLLUP_CONTRACT_ADDRESS: string; - var L1_ACCOUNT_0_PRIVATE_KEY: string; - var L2_ACCOUNT_0_PRIVATE_KEY: string; - var L2_ACCOUNT_1_PRIVATE_KEY: string; - var L1_DEPLOYER_ACCOUNT_PRIVATE_KEY: string; - var L2_DEPLOYER_ACCOUNT_PRIVATE_KEY: string; - var TRANSACTION_CALLDATA_LIMIT: number; - var OPERATOR_0_PRIVATE_KEY: string; - var SHOMEI_ENDPOINT: URL | null; - var SHOMEI_FRONTEND_ENDPOINT: URL | null; - var SEQUENCER_ENDPOINT: URL | null; - var OPERATOR_1_ADDRESS: string; - var SECURITY_COUNCIL_PRIVATE_KEY: string; - var CONTRACT_GAS_OPTIMIZATION_SWITCH_BLOCK: number; -} diff --git a/e2e/env-setup/global-setup.ts b/e2e/env-setup/global-setup.ts deleted file mode 100644 index fd382c93a..000000000 --- a/e2e/env-setup/global-setup.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { globalTestEnvironment } from "./global-test-env"; - -export default async (): Promise => { - await globalTestEnvironment.startEnv(); - global.testingEnv = globalTestEnvironment.testingEnv; -}; diff --git a/e2e/env-setup/global-teardown.ts b/e2e/env-setup/global-teardown.ts deleted file mode 100644 index fdd85c1f0..000000000 --- a/e2e/env-setup/global-teardown.ts +++ /dev/null @@ -1,5 +0,0 @@ -import { globalTestEnvironment } from "./global-test-env"; - -export default async (): Promise => { - await globalTestEnvironment.stopEnv(); -}; diff --git a/e2e/env-setup/global-test-env.ts b/e2e/env-setup/global-test-env.ts deleted file mode 100644 index d4b55e7da..000000000 --- a/e2e/env-setup/global-test-env.ts +++ /dev/null @@ -1,19 +0,0 @@ -import { TestEnvironment } from "./test-env"; - -export class GlobalTestEnvironment { - public readonly testingEnv = new TestEnvironment(); - - public async startEnv(): Promise { - await this.testingEnv.startEnv(); - } - - public async stopEnv(): Promise { - await this.testingEnv.stopEnv(); - } - - public async restartCoordinator(): Promise { - await this.testingEnv.restartCoordinator(global.useLocalSetup); - } -} - -export const globalTestEnvironment = new GlobalTestEnvironment(); diff --git a/e2e/env-setup/setup-dev.ts b/e2e/env-setup/setup-dev.ts deleted file mode 100644 index 002d2a86c..000000000 --- a/e2e/env-setup/setup-dev.ts +++ /dev/null @@ -1,53 +0,0 @@ -import { beforeAll, jest } from "@jest/globals"; -import { - DummyContract, - DummyContract__factory, - L2MessageService, - L2MessageService__factory, - LineaRollup, - LineaRollup__factory, -} from "../src/typechain"; -import { - getL1Provider, - getL2Provider, - CHAIN_ID, - DEPLOYER_ACCOUNT_PRIVATE_KEY, - MESSAGE_SERVICE_ADDRESS, - DUMMY_CONTRACT_ADDRESS, - ACCOUNT_0_PRIVATE_KEY, - TRANSACTION_CALLDATA_LIMIT, - OPERATOR_0_PRIVATE_KEY, - SHOMEI_ENDPOINT, - SHOMEI_FRONTEND_ENDPOINT, - LINEA_ROLLUP_CONTRACT_ADDRESS, -} from "../src/utils/constants.dev"; - -jest.setTimeout(5 * 60 * 1000); - -beforeAll(async () => { - /*********** PROVIDERS SETUP ***********/ - const l1Provider = getL1Provider(); - const l2Provider = getL2Provider(); - - const dummyContract: DummyContract = DummyContract__factory.connect(DUMMY_CONTRACT_ADDRESS, l2Provider); - // L2MessageService contract - const l2MessageService: L2MessageService = L2MessageService__factory.connect(MESSAGE_SERVICE_ADDRESS, l2Provider); - - /*********** L1 Contracts ***********/ - // LineaRollup deployment - const lineaRollup: LineaRollup = LineaRollup__factory.connect(LINEA_ROLLUP_CONTRACT_ADDRESS, l1Provider); - - global.l1Provider = l1Provider; - global.l2Provider = l2Provider; - global.dummyContract = dummyContract; - global.l2MessageService = l2MessageService; - global.lineaRollup = lineaRollup; - global.chainId = CHAIN_ID; - global.L1_ACCOUNT_0_PRIVATE_KEY = ACCOUNT_0_PRIVATE_KEY; - global.L1_DEPLOYER_ACCOUNT_PRIVATE_KEY = DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.L2_DEPLOYER_ACCOUNT_PRIVATE_KEY = DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.TRANSACTION_CALLDATA_LIMIT = TRANSACTION_CALLDATA_LIMIT; - global.OPERATOR_0_PRIVATE_KEY = OPERATOR_0_PRIVATE_KEY; - global.SHOMEI_ENDPOINT = SHOMEI_ENDPOINT; - global.SHOMEI_FRONTEND_ENDPOINT = SHOMEI_FRONTEND_ENDPOINT; -}); diff --git a/e2e/env-setup/setup-local-deploy.ts b/e2e/env-setup/setup-local-deploy.ts deleted file mode 100644 index 25c9a5636..000000000 --- a/e2e/env-setup/setup-local-deploy.ts +++ /dev/null @@ -1,81 +0,0 @@ -import { beforeAll, jest } from "@jest/globals"; -import { Wallet } from "ethers"; -import { - DummyContract, - DummyContract__factory, - L2MessageService, - L2MessageService__factory, - LineaRollup, - LineaRollup__factory, - TestPlonkVerifierForDataAggregation__factory, -} from "../src/typechain"; -import { - L2_ACCOUNT_0, - L2_ACCOUNT_0_PRIVATE_KEY, - L2_ACCOUNT_1_PRIVATE_KEY, - L1_DEPLOYER_ACCOUNT_PRIVATE_KEY, - L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, - INITIAL_WITHDRAW_LIMIT, - LINEA_ROLLUP_INITIAL_L2_BLOCK_NR, - LINEA_ROLLUP_INITIAL_STATE_ROOT_HASH, - LINEA_ROLLUP_OPERATORS, - LINEA_ROLLUP_RATE_LIMIT_AMOUNT, - LINEA_ROLLUP_RATE_LIMIT_PERIOD, - LINEA_ROLLUP_SECURITY_COUNCIL, - getL1Provider, - getL2Provider, - TRANSACTION_CALLDATA_LIMIT, - OPERATOR_0_PRIVATE_KEY, - SHOMEI_ENDPOINT, - SHOMEI_FRONTEND_ENDPOINT, -} from "../src/utils/constants.local"; -import { deployContract, deployUpgradableContractWithProxyAdmin } from "../src/utils/deployments"; - -jest.setTimeout(5 * 60 * 1000); - -beforeAll(async () => { - /*********** PROVIDERS SETUP ***********/ - const l1Provider = getL1Provider(); - const l2Provider = getL2Provider(); - - const l2Deployer = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); - const dummyContract = (await deployContract(new DummyContract__factory(), l2Deployer)) as DummyContract; - - // L2MessageService deployment - const l2MessageService = (await deployUpgradableContractWithProxyAdmin(new L2MessageService__factory(), l2Deployer, [ - L2_ACCOUNT_0, - 86400, - INITIAL_WITHDRAW_LIMIT, - ])) as L2MessageService; - - /*********** L1 DEPLOYMENTS ***********/ - const l1Deployer = new Wallet(L1_DEPLOYER_ACCOUNT_PRIVATE_KEY, l1Provider); - - // PlonkVerifier and LineaRollup deployment - const plonkVerifier = await deployContract(new TestPlonkVerifierForDataAggregation__factory(), l1Deployer); - - const lineaRollup = (await deployUpgradableContractWithProxyAdmin(new LineaRollup__factory(), l1Deployer, [ - LINEA_ROLLUP_INITIAL_STATE_ROOT_HASH, - LINEA_ROLLUP_INITIAL_L2_BLOCK_NR, - plonkVerifier.address, - LINEA_ROLLUP_SECURITY_COUNCIL, - LINEA_ROLLUP_OPERATORS, - LINEA_ROLLUP_RATE_LIMIT_PERIOD, - LINEA_ROLLUP_RATE_LIMIT_AMOUNT, - ])) as LineaRollup; - - global.l1Provider = l1Provider; - global.l2Provider = l2Provider; - global.dummyContract = dummyContract; - global.l2MessageService = l2MessageService; - global.lineaRollup = lineaRollup; - global.useLocalSetup = true; - global.L2_ACCOUNT_0_PRIVATE_KEY = L2_ACCOUNT_0_PRIVATE_KEY; - global.L2_ACCOUNT_1_PRIVATE_KEY = L2_ACCOUNT_1_PRIVATE_KEY; - global.L1_DEPLOYER_ACCOUNT_PRIVATE_KEY = L1_DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.L2_DEPLOYER_ACCOUNT_PRIVATE_KEY = L2_DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.TRANSACTION_CALLDATA_LIMIT = TRANSACTION_CALLDATA_LIMIT; - global.OPERATOR_0_PRIVATE_KEY = OPERATOR_0_PRIVATE_KEY; - global.SHOMEI_ENDPOINT = SHOMEI_ENDPOINT; - global.SHOMEI_FRONTEND_ENDPOINT = SHOMEI_FRONTEND_ENDPOINT; -}); diff --git a/e2e/env-setup/setup-local.ts b/e2e/env-setup/setup-local.ts deleted file mode 100644 index e133f7ebe..000000000 --- a/e2e/env-setup/setup-local.ts +++ /dev/null @@ -1,92 +0,0 @@ -import { beforeAll, jest } from "@jest/globals"; -import { Wallet, ethers } from "ethers"; -import { - DummyContract, - DummyContract__factory, - L2MessageService, - L2MessageService__factory, - LineaRollup, - LineaRollup__factory, -} from "../src/typechain"; -import { - getL1Provider, - getL2Provider, - CHAIN_ID, - L1_DEPLOYER_ACCOUNT_PRIVATE_KEY, - L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, - LINEA_ROLLUP_CONTRACT_ADDRESS, - MESSAGE_SERVICE_ADDRESS, - L1_ACCOUNT_0_PRIVATE_KEY, - L2_ACCOUNT_0_PRIVATE_KEY, - L2_ACCOUNT_1_PRIVATE_KEY, - TRANSACTION_CALLDATA_LIMIT, - OPERATOR_0_PRIVATE_KEY, - SHOMEI_ENDPOINT, - SHOMEI_FRONTEND_ENDPOINT, - SEQUENCER_ENDPOINT, - OPERATOR_1, - SECURITY_COUNCIL_PRIVATE_KEY, - CONTRACT_GAS_OPTIMIZATION_SWITCH_BLOCK, -} from "../src/utils/constants.local"; -import { deployContract } from "../src/utils/deployments"; -import { getAndIncreaseFeeData } from "../src/utils/helpers"; - -jest.setTimeout(3 * 60 * 1000); - -beforeAll(async () => { - /*********** PROVIDERS SETUP ***********/ - const l1JsonRpcProvider = getL1Provider(); - const l2JsonRpcProvider = getL2Provider(); - - const l1Deployer = new Wallet(L1_DEPLOYER_ACCOUNT_PRIVATE_KEY, l1JsonRpcProvider); - const l2Deployer = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2JsonRpcProvider); - - const [dummyContract, l1DummyContract] = await Promise.all([ - deployContract(new DummyContract__factory(), l2Deployer) as unknown as DummyContract, - deployContract(new DummyContract__factory(), l1Deployer) as unknown as DummyContract, - ]); - - // Old LineaRollup contract instanciation - // LineaRollup ABI contains both old and new functions - const lineaRollup: LineaRollup = LineaRollup__factory.connect(LINEA_ROLLUP_CONTRACT_ADDRESS, l1JsonRpcProvider); - // L2 MessageService contract instanciation - const l2MessageService: L2MessageService = L2MessageService__factory.connect( - MESSAGE_SERVICE_ADDRESS, - l2JsonRpcProvider, - ); - - // Send ETH to the LineaRollup contract - const value = ethers.utils.parseEther("500"); - const fee = ethers.utils.parseEther("3"); - const to = "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; - const calldata = "0x"; - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await l1JsonRpcProvider.getFeeData()); - const tx = await lineaRollup - .connect(l1Deployer) - .sendMessage(to, fee, calldata, { value, maxPriorityFeePerGas, maxFeePerGas }); - await tx.wait(); - - global.l1Provider = l1JsonRpcProvider; - global.l2Provider = l2JsonRpcProvider; - global.dummyContract = dummyContract; - global.l1DummyContract = l1DummyContract; - global.l2MessageService = l2MessageService; - global.L2_MESSAGE_SERVICE_ADDRESS = MESSAGE_SERVICE_ADDRESS; - global.LINEA_ROLLUP_CONTRACT_ADDRESS = LINEA_ROLLUP_CONTRACT_ADDRESS; - global.lineaRollup = lineaRollup; - global.useLocalSetup = true; - global.chainId = CHAIN_ID; - global.L1_ACCOUNT_0_PRIVATE_KEY = L1_ACCOUNT_0_PRIVATE_KEY; - global.L2_ACCOUNT_0_PRIVATE_KEY = L2_ACCOUNT_0_PRIVATE_KEY; - global.L2_ACCOUNT_1_PRIVATE_KEY = L2_ACCOUNT_1_PRIVATE_KEY; - global.L1_DEPLOYER_ACCOUNT_PRIVATE_KEY = L1_DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.L2_DEPLOYER_ACCOUNT_PRIVATE_KEY = L2_DEPLOYER_ACCOUNT_PRIVATE_KEY; - global.TRANSACTION_CALLDATA_LIMIT = TRANSACTION_CALLDATA_LIMIT; - global.OPERATOR_0_PRIVATE_KEY = OPERATOR_0_PRIVATE_KEY; - global.SHOMEI_ENDPOINT = SHOMEI_ENDPOINT; - global.SHOMEI_FRONTEND_ENDPOINT = SHOMEI_FRONTEND_ENDPOINT; - global.SEQUENCER_ENDPOINT = SEQUENCER_ENDPOINT; - global.OPERATOR_1_ADDRESS = OPERATOR_1; - global.SECURITY_COUNCIL_PRIVATE_KEY = SECURITY_COUNCIL_PRIVATE_KEY; - global.CONTRACT_GAS_OPTIMIZATION_SWITCH_BLOCK = CONTRACT_GAS_OPTIMIZATION_SWITCH_BLOCK; -}); diff --git a/e2e/env-setup/setup-shadow.ts b/e2e/env-setup/setup-shadow.ts deleted file mode 100644 index 37d3fcc97..000000000 --- a/e2e/env-setup/setup-shadow.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { beforeAll, jest } from "@jest/globals"; -import { - DummyContract, - DummyContract__factory, - L2MessageService, - L2MessageService__factory, - L2TestContract__factory, - L2TestContract, - LineaRollup, - LineaRollup__factory, -} from "../src/typechain"; -import { - getL1Provider, - getL2Provider, - CHAIN_ID, - SHADOW_ZKEVMV2_CONTRACT_ADDRESS, - SHADOW_MESSAGE_SERVICE_ADDRESS, - DUMMY_CONTRACT_ADDRESS, - ACCOUNT_0_PRIVATE_KEY, - TRANSACTION_CALLDATA_LIMIT, - L1_DUMMY_CONTRACT_ADDRESS, - SHOMEI_ENDPOINT, - SHOMEI_FRONTEND_ENDPOINT, -} from "../src/utils/constants.uat"; - -jest.setTimeout(5 * 60 * 1000); - -beforeAll(async () => { - /*********** PROVIDERS SETUP ***********/ - const l1Provider = getL1Provider(); - const l2Provider = getL2Provider(); - - const l1DummyContract: DummyContract = DummyContract__factory.connect(L1_DUMMY_CONTRACT_ADDRESS, l1Provider); - const dummyContract: DummyContract = DummyContract__factory.connect(DUMMY_CONTRACT_ADDRESS, l2Provider); - const l2TestContract: L2TestContract = L2TestContract__factory.connect( - "0xaD711a736ae454Be345078C0bc849997b78A30B9", - l2Provider, - ); - // L2MessageService contract - const l2MessageService: L2MessageService = L2MessageService__factory.connect( - SHADOW_MESSAGE_SERVICE_ADDRESS, - l2Provider, - ); - - /*********** L1 Contracts ***********/ - - // LineaRollup deployment - const lineaRollup: LineaRollup = LineaRollup__factory.connect(SHADOW_ZKEVMV2_CONTRACT_ADDRESS, l1Provider); - - global.l1Provider = l1Provider; - global.l2Provider = l2Provider; - global.l2TestContract = l2TestContract; - global.l1DummyContract = l1DummyContract; - global.dummyContract = dummyContract; - global.l2MessageService = l2MessageService; - global.lineaRollup = lineaRollup; - global.chainId = CHAIN_ID; - global.L2_ACCOUNT_0_PRIVATE_KEY = ACCOUNT_0_PRIVATE_KEY; - global.TRANSACTION_CALLDATA_LIMIT = TRANSACTION_CALLDATA_LIMIT; - global.SHOMEI_ENDPOINT = SHOMEI_ENDPOINT; - global.SHOMEI_FRONTEND_ENDPOINT = SHOMEI_FRONTEND_ENDPOINT; -}); diff --git a/e2e/env-setup/setup-uat.ts b/e2e/env-setup/setup-uat.ts deleted file mode 100644 index e3ebb2c3d..000000000 --- a/e2e/env-setup/setup-uat.ts +++ /dev/null @@ -1,59 +0,0 @@ -import { beforeAll, jest } from "@jest/globals"; -import { - DummyContract, - DummyContract__factory, - L2MessageService, - L2MessageService__factory, - L2TestContract__factory, - L2TestContract, - LineaRollup, - LineaRollup__factory, -} from "../src/typechain"; -import { - getL1Provider, - getL2Provider, - CHAIN_ID, - LINEA_ROLLUP_CONTRACT_ADDRESS, - MESSAGE_SERVICE_ADDRESS, - DUMMY_CONTRACT_ADDRESS, - ACCOUNT_0_PRIVATE_KEY, - TRANSACTION_CALLDATA_LIMIT, - L1_DUMMY_CONTRACT_ADDRESS, - SHOMEI_ENDPOINT, - SHOMEI_FRONTEND_ENDPOINT, -} from "../src/utils/constants.uat"; - -jest.setTimeout(5 * 60 * 1000); - -beforeAll(async () => { - /*********** PROVIDERS SETUP ***********/ - const l1Provider = getL1Provider(); - const l2Provider = getL2Provider(); - - const l1DummyContract: DummyContract = DummyContract__factory.connect(L1_DUMMY_CONTRACT_ADDRESS, l1Provider); - const dummyContract: DummyContract = DummyContract__factory.connect(DUMMY_CONTRACT_ADDRESS, l2Provider); - const l2TestContract: L2TestContract = L2TestContract__factory.connect( - "0xaD711a736ae454Be345078C0bc849997b78A30B9", - l2Provider, - ); - // L2MessageService contract - const l2MessageService: L2MessageService = L2MessageService__factory.connect(MESSAGE_SERVICE_ADDRESS, l2Provider); - - /*********** L1 Contracts ***********/ - - // LineaRollup deployment - const lineaRollup: LineaRollup = LineaRollup__factory.connect(LINEA_ROLLUP_CONTRACT_ADDRESS, l1Provider); - - global.l1Provider = l1Provider; - global.l2Provider = l2Provider; - global.l2TestContract = l2TestContract; - global.l1DummyContract = l1DummyContract; - global.dummyContract = dummyContract; - global.l2MessageService = l2MessageService; - global.lineaRollup = lineaRollup; - global.chainId = CHAIN_ID; - global.L1_ACCOUNT_0_PRIVATE_KEY = ACCOUNT_0_PRIVATE_KEY; - global.TRANSACTION_CALLDATA_LIMIT = TRANSACTION_CALLDATA_LIMIT; - global.SHOMEI_ENDPOINT = SHOMEI_ENDPOINT; - global.SHOMEI_FRONTEND_ENDPOINT = SHOMEI_FRONTEND_ENDPOINT; -}); diff --git a/e2e/jest.config.ts b/e2e/jest.config.ts index 534388c48..ce990bd11 100644 --- a/e2e/jest.config.ts +++ b/e2e/jest.config.ts @@ -3,12 +3,15 @@ import type { Config } from "jest"; const config: Config = { preset: "ts-jest", testEnvironment: "node", - rootDir: ".", - testRegex: "(spec|test).ts$", + rootDir: "src", + testRegex: ".spec.ts$", verbose: true, - globalSetup: "./env-setup/global-setup.ts", - setupFilesAfterEnv: ["./env-setup/setup.ts"], - globalTeardown: "./env-setup/global-teardown.ts", + globalSetup: "./config/jest/global-setup.ts", + globalTeardown: "./config/jest/global-teardown.ts", + maxWorkers: "50%", + maxConcurrency: 5, + testTimeout: 3 * 60 * 1000, + workerThreads: true, }; export default config; diff --git a/e2e/jest.local.config.ts b/e2e/jest.local.config.ts deleted file mode 100644 index 533d9dede..000000000 --- a/e2e/jest.local.config.ts +++ /dev/null @@ -1,15 +0,0 @@ -import type { Config } from "jest"; - -const config: Config = { - preset: "ts-jest", - testEnvironment: "node", - rootDir: ".", - testRegex: "ordered-test.ts$", - verbose: true, - setupFilesAfterEnv: ["./env-setup/setup-local.ts"], - bail: 1, - forceExit: true, - detectOpenHandles: true, -}; - -export default config; diff --git a/e2e/jest.shadow.config.ts b/e2e/jest.shadow.config.ts deleted file mode 100644 index f31e9e3f8..000000000 --- a/e2e/jest.shadow.config.ts +++ /dev/null @@ -1,12 +0,0 @@ -import type { Config } from "jest"; - -const config: Config = { - preset: "ts-jest", - testEnvironment: "node", - rootDir: ".", - testRegex: "(spec|test).ts$", - verbose: true, - setupFilesAfterEnv: ["./env-setup/setup-shadow.ts"], -}; - -export default config; diff --git a/e2e/jest.dev.config.ts b/e2e/jest.testnet.config.ts similarity index 60% rename from e2e/jest.dev.config.ts rename to e2e/jest.testnet.config.ts index 0cdaeed52..33efc4afd 100644 --- a/e2e/jest.dev.config.ts +++ b/e2e/jest.testnet.config.ts @@ -3,10 +3,11 @@ import type { Config } from "jest"; const config: Config = { preset: "ts-jest", testEnvironment: "node", - rootDir: ".", - testRegex: "(spec|test).ts$", + rootDir: "src", + testRegex: ".spec.ts$", verbose: true, - setupFilesAfterEnv: ["./env-setup/setup-dev.ts"], + maxWorkers: "50%", + testTimeout: 3 * 60 * 1000, }; export default config; diff --git a/e2e/jest.uat.config.ts b/e2e/jest.uat.config.ts deleted file mode 100644 index 7331a0864..000000000 --- a/e2e/jest.uat.config.ts +++ /dev/null @@ -1,12 +0,0 @@ -import type { Config } from "jest"; - -const config: Config = { - preset: "ts-jest", - testEnvironment: "node", - rootDir: ".", - testRegex: "(spec|test).ts$", - verbose: true, - setupFilesAfterEnv: ["./env-setup/setup-uat.ts"], -}; - -export default config; diff --git a/e2e/jest.vscode.config.ts b/e2e/jest.vscode.config.ts deleted file mode 100644 index fab1b7052..000000000 --- a/e2e/jest.vscode.config.ts +++ /dev/null @@ -1,14 +0,0 @@ -import type { Config } from "jest"; - -const config: Config = { - preset: "ts-jest", - testEnvironment: "node", - rootDir: ".", - testRegex: "(spec|test).ts$", - verbose: true, - globalSetup: "", - setupFilesAfterEnv: ["./env-setup/setup-local.ts"], - globalTeardown: "", -}; - -export default config; diff --git a/e2e/package.json b/e2e/package.json index 29e0d0e76..3787dffa0 100644 --- a/e2e/package.json +++ b/e2e/package.json @@ -8,30 +8,25 @@ "lint:ts:fix": "npx eslint --fix '**/*.{js,ts}'", "prettier": "prettier -c '**/*.{js,ts}'", "prettier:fix": "prettier -w '**/*.{js,ts}'", - "test:e2e:local": "npx jest --config ./jest.local.config.ts --runInBand", - "test:e2e:local:testenv": "npx jest --config ./jest.local.config.ts --runInBand --globalSetup ./env-setup/global-setup.ts --setupFilesAfterEnv ./env-setup/setup-local-deploy.ts --globalTeardown ./env-setup/global-teardown.ts", - "test:e2e:dev": "npx jest --config ./jest.dev.config.ts --bail --runInBand --testPathIgnorePatterns=restart.spec.ts", - "test:e2e:uat": "npx jest --config ./jest.uat.config.ts --bail --runInBand --testPathIgnorePatterns=restart.spec.ts", - "test:e2e:uat:shadow": "npx jest --config ./jest.uat.config.ts --bail --runInBand --testPathIgnorePatterns=restart.spec.ts", - "postinstall": "typechain --target ethers-v5 --out-dir ./src/typechain './src/abi/*.json'", - "test:e2e:vscode": "npx jest --config ./jest.vscode.config.ts --runInBand --detectOpenHandles --forceExit", + "test:e2e:local": "TEST_ENV=local npx jest", + "test:e2e:dev": "TEST_ENV=dev npx jest --config ./jest.testnet.config.ts --bail --runInBand --testPathIgnorePatterns=restart.spec.ts", + "test:e2e:sepolia": "TEST_ENV=sepolia npx jest --config ./jest.testnet.config.ts --bail --runInBand --testPathIgnorePatterns=restart.spec.ts", + "postinstall": "typechain --target ethers-v6 --out-dir ./src/typechain './src/abi/*.json'", "lint:fix": "pnpm run lint:ts:fix && pnpm run prettier:fix", - "clean": "rimraf node_modules" + "clean": "rimraf node_modules src/typechain" }, "author": "", "license": "ISC", "devDependencies": { - "@ethersproject/providers": "5.7.2", "@jest/globals": "29.7.0", "@openzeppelin/upgrades-core": "1.33.1", - "@typechain/ethers-v5": "11.1.2", - "@types/jest": "29.5.12", + "@typechain/ethers-v6": "0.5.1", + "@types/jest": "29.5.13", "child_process": "1.0.2", "dotenv": "16.4.5", - "ethers": "5.7.2", + "ethers": "6.13.3", "jest": "29.7.0", - "testcontainers": "10.9.0", - "ts-jest": "29.1.2", + "ts-jest": "29.2.5", "typechain": "8.3.2" } } diff --git a/e2e/src/utils/constants.ts b/e2e/src/common/constants.ts similarity index 83% rename from e2e/src/utils/constants.ts rename to e2e/src/common/constants.ts index fe397b4f4..c8e13676f 100644 --- a/e2e/src/utils/constants.ts +++ b/e2e/src/common/constants.ts @@ -6,4 +6,6 @@ export const OPERATOR_ROLE = "0x97667070c54ef182b0f5858b034beac1b6f3089aa2d3188b export const VERIFIER_SETTER_ROLE = "0x32937fd5162e282df7e9a14a5073a2425321c7966eaf70ed6c838a1006d84c4c"; export const MESSAGE_SENT_EVENT_SIGNATURE = "0xe856c2b8bd4eb0027ce32eeaf595c21b0b6b4644b326e5b7bd80a1cf8db72e6c"; -export const HASH_ZERO = ethers.constants.HashZero; +export const HASH_ZERO = ethers.ZeroHash; + +export const TRANSACTION_CALLDATA_LIMIT = 30_000; diff --git a/e2e/src/utils/deployments.ts b/e2e/src/common/deployments.ts similarity index 53% rename from e2e/src/utils/deployments.ts rename to e2e/src/common/deployments.ts index f4996bc74..2a46c010d 100644 --- a/e2e/src/utils/deployments.ts +++ b/e2e/src/common/deployments.ts @@ -1,14 +1,21 @@ -import { Contract, ContractFactory, Overrides, Wallet, ethers, utils } from "ethers"; +import { AbiCoder, BaseContract, ContractFactory, Wallet, ethers } from "ethers"; import { ProxyAdmin__factory, TransparentUpgradeableProxy__factory, ProxyAdmin } from "../typechain"; -function getInitializerData(contractInterface: ethers.utils.Interface, args: unknown[]) { +export const encodeData = (types: string[], values: unknown[], packed?: boolean) => { + if (packed) { + return ethers.solidityPacked(types, values); + } + return AbiCoder.defaultAbiCoder().encode(types, values); +}; + +function getInitializerData(contractInterface: ethers.Interface, args: unknown[]) { const initializer = "initialize"; const fragment = contractInterface.getFunction(initializer); - return contractInterface.encodeFunctionData(fragment, args); + return contractInterface.encodeFunctionData(fragment!, args); } export const encodeLibraryName = (libraryName: string) => { - const encodedLibraryName = utils.solidityKeccak256(["string"], [libraryName]).slice(2, 36); + const encodedLibraryName = ethers.keccak256(encodeData(["string"], [libraryName])).slice(2, 36); return `__$${encodedLibraryName}$__`; }; @@ -17,29 +24,28 @@ export const deployContract = async ( deployer: Wallet, // eslint-disable-next-line @typescript-eslint/no-explicit-any args?: any[], - overrides?: Overrides, -): Promise => { +): Promise => { const deploymentArgs = args || []; - const instance = await contractFactory.connect(deployer).deploy(...deploymentArgs, overrides); - await instance.deployed(); + const instance = await contractFactory.connect(deployer).deploy(...deploymentArgs); + await instance.waitForDeployment(); return instance; }; -export const deployUpgradableContract = async ( +const deployUpgradableContract = async ( contractFactory: T, deployer: Wallet, admin: ProxyAdmin, initializerData = "0x", -): Promise => { +): Promise => { const instance = await contractFactory.connect(deployer).deploy(); - await instance.deployed(); + await instance.waitForDeployment(); const proxy = await new TransparentUpgradeableProxy__factory() .connect(deployer) - .deploy(instance.address, admin.address, initializerData); - await proxy.deployed(); + .deploy(await instance.getAddress(), await admin.getAddress(), initializerData); + await proxy.waitForDeployment(); - return instance.attach(proxy.address); + return instance.attach(await proxy.getAddress()); }; export async function deployUpgradableContractWithProxyAdmin( @@ -49,8 +55,8 @@ export async function deployUpgradableContractWithProxyAdmin { +): Promise { const proxyAdminFactory = new ProxyAdmin__factory(deployer); - const proxyAdmin = proxyAdminFactory.connect(deployer).attach(proxyAdminContractAddress); + const proxyAdmin = proxyAdminFactory.connect(deployer).attach(proxyAdminContractAddress) as ProxyAdmin; const tx = await proxyAdmin.upgradeAndCall(proxyContractAddress, implementationContractAddress, initializerData); - return tx.wait(); } @@ -29,9 +28,9 @@ export async function upgradeContract( proxyAdminContractAddress: string, proxyContractAddress: string, implementationContractAddress: string, -): Promise { +): Promise { const proxyAdminFactory = new ProxyAdmin__factory(deployer); - const proxyAdmin = proxyAdminFactory.connect(deployer).attach(proxyAdminContractAddress); + const proxyAdmin = proxyAdminFactory.connect(deployer).attach(proxyAdminContractAddress) as ProxyAdmin; const tx = await proxyAdmin.upgrade(proxyContractAddress, implementationContractAddress); return tx.wait(); diff --git a/e2e/src/common/utils.ts b/e2e/src/common/utils.ts new file mode 100644 index 000000000..319aae072 --- /dev/null +++ b/e2e/src/common/utils.ts @@ -0,0 +1,263 @@ +import * as fs from "fs"; +import assert from "assert"; +import { BaseContract, BlockTag, TransactionReceipt, Wallet, ethers } from "ethers"; +import path from "path"; +import { exec } from "child_process"; +import { L2MessageService, LineaRollup } from "../typechain"; +import { PayableOverrides, TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog } from "../typechain/common"; +import { MessageEvent, SendMessageArgs } from "./types"; + +export function etherToWei(amount: string): bigint { + return ethers.parseEther(amount.toString()); +} + +export function readJsonFile(filePath: string): unknown { + const data = fs.readFileSync(filePath, "utf8"); + return JSON.parse(data); +} + +export const wait = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout)); + +export function increaseDate(currentDate: Date, seconds: number): Date { + const newDate = new Date(currentDate.getTime()); + newDate.setSeconds(newDate.getSeconds() + seconds); + return newDate; +} + +export const subtractSecondsToDate = (date: Date, seconds: number): Date => { + const dateCopy = new Date(date); + dateCopy.setSeconds(date.getSeconds() - seconds); + return dateCopy; +}; + +export function getWallet(privateKey: string, provider: ethers.JsonRpcProvider) { + return new ethers.Wallet(privateKey, provider); +} + +export function encodeFunctionCall(contractInterface: ethers.Interface, functionName: string, args: unknown[]) { + return contractInterface.encodeFunctionData(functionName, args); +} + +export const generateKeccak256 = (types: string[], values: unknown[], packed?: boolean) => + ethers.keccak256(encodeData(types, values, packed)); + +export const encodeData = (types: string[], values: unknown[], packed?: boolean) => { + if (packed) { + return ethers.solidityPacked(types, values); + } + return ethers.AbiCoder.defaultAbiCoder().encode(types, values); +}; + +export class RollupGetZkEVMBlockNumberClient { + private endpoint: URL; + private request = { + method: "post", + body: JSON.stringify({ + jsonrpc: "2.0", + method: "rollup_getZkEVMBlockNumber", + params: [], + id: 1, + }), + }; + + public constructor(endpoint: URL) { + this.endpoint = endpoint; + } + + public async rollupGetZkEVMBlockNumber(): Promise { + const response = await fetch(this.endpoint, this.request); + const data = await response.json(); + assert("result" in data); + return Number.parseInt(data.result); + } +} + +export async function getBlockByNumberOrBlockTag(rpcUrl: URL, blockTag: BlockTag): Promise { + const provider = new ethers.JsonRpcProvider(rpcUrl.href); + try { + const blockNumber = await provider.getBlock(blockTag); + return blockNumber; + } catch (error) { + return null; + } +} + +export async function getEvents( + contract: TContract, + eventFilter: TypedDeferredTopicFilter, + fromBlock?: BlockTag, + toBlock?: BlockTag, + criteria?: (events: TypedEventLog[]) => Promise[]>, +): Promise>> { + const events = await contract.queryFilter( + eventFilter, + fromBlock as string | number | undefined, + toBlock as string | number | undefined, + ); + + if (criteria) { + return await criteria(events); + } + + return events; +} + +export async function waitForEvents< + TContract extends LineaRollup | L2MessageService, + TEvent extends TypedContractEvent, +>( + contract: TContract, + eventFilter: TypedDeferredTopicFilter, + pollingInterval: number = 500, + fromBlock?: BlockTag, + toBlock?: BlockTag, + criteria?: (events: TypedEventLog[]) => Promise[]>, +): Promise[]> { + let events = await getEvents(contract, eventFilter, fromBlock, toBlock, criteria); + + while (events.length === 0) { + events = await getEvents(contract, eventFilter, fromBlock, toBlock, criteria); + await wait(pollingInterval); + } + + return events; +} + +export function getFiles(directory: string, fileRegex: RegExp[]): string[] { + const files = fs.readdirSync(directory, { withFileTypes: true }); + const filteredFiles = files.filter((file) => fileRegex.map((regex) => regex.test(file.name)).includes(true)); + return filteredFiles.map((file) => fs.readFileSync(path.join(directory, file.name), "utf-8")); +} + +export async function waitForFile( + directory: string, + regex: RegExp, + pollingInterval: number, + timeout: number, + criteria?: (fileName: string) => boolean, +): Promise { + const endTime = Date.now() + timeout; + + while (Date.now() < endTime) { + try { + const files = fs.readdirSync(directory); + + for (const file of files) { + if (regex.test(file) && (!criteria || criteria(file))) { + const filePath = path.join(directory, file); + const content = fs.readFileSync(filePath, "utf-8"); + return content; + } + } + } catch (err) { + throw new Error(`Error reading directory: ${(err as Error).message}`); + } + + await new Promise((resolve) => setTimeout(resolve, pollingInterval)); + } + + throw new Error("File check timed out"); +} + +export async function sendTransactionsToGenerateTrafficWithInterval(signer: Wallet, pollingInterval: number = 1_000) { + const { maxPriorityFeePerGas, maxFeePerGas } = await signer.provider!.getFeeData(); + const transactionRequest = { + to: signer.address, + value: etherToWei("0.000001"), + maxPriorityFeePerGas: maxPriorityFeePerGas, + maxFeePerGas: maxFeePerGas, + }; + + let timeoutId: NodeJS.Timeout | null = null; + let isRunning = true; + + const sendTransaction = async () => { + if (!isRunning) return; + + try { + const tx = await signer.sendTransaction(transactionRequest); + await tx.wait(); + } catch (error) { + console.error("Error sending transaction:", error); + } finally { + if (isRunning) { + timeoutId = setTimeout(sendTransaction, pollingInterval); + } + } + }; + + const stop = () => { + isRunning = false; + if (timeoutId) { + clearTimeout(timeoutId); + timeoutId = null; + } + console.log("Transaction loop stopped."); + }; + + sendTransaction(); + + return stop; +} + +export function getMessageSentEventFromLogs( + contract: T, + receipts: TransactionReceipt[], +): MessageEvent[] { + return receipts + .flatMap((receipt) => receipt.logs) + .filter((log) => log.topics[0] === "0xe856c2b8bd4eb0027ce32eeaf595c21b0b6b4644b326e5b7bd80a1cf8db72e6c") + .map((log) => { + const logDescription = contract.interface.parseLog(log); + if (!logDescription) { + throw new Error("Invalid log description"); + } + const { args } = logDescription; + return { + from: args._from, + to: args._to, + fee: args._fee, + value: args._value, + messageNumber: args._nonce, + calldata: args._calldata, + messageHash: args._messageHash, + blockNumber: log.blockNumber, + }; + }); +} + +export const sendMessage = async ( + signer: Wallet, + contract: T, + args: SendMessageArgs, + overrides?: PayableOverrides, +): Promise => { + const tx = await signer.sendTransaction({ + to: await contract.getAddress(), + value: overrides?.value || 0n, + data: contract.interface.encodeFunctionData("sendMessage", [args.to, args.fee, args.calldata]), + ...overrides, + }); + + const receipt = await tx.wait(); + + if (!receipt) { + throw new Error("Transaction receipt is undefined"); + } + return receipt; +}; + +export async function execDockerCommand(command: string, containerName: string): Promise { + const dockerCommand = `docker ${command} ${containerName}`; + console.log(`Executing: ${dockerCommand}...`); + return new Promise((resolve, reject) => { + exec(dockerCommand, (error, stdout, stderr) => { + if (error) { + console.error(`Error executing (${dockerCommand}): ${stderr}`); + reject(error); + } + console.log(`Execution success (${dockerCommand}): ${stdout}`); + resolve(stdout); + }); + }); +} diff --git a/e2e/src/config/jest/global-setup.ts b/e2e/src/config/jest/global-setup.ts new file mode 100644 index 000000000..2d610c040 --- /dev/null +++ b/e2e/src/config/jest/global-setup.ts @@ -0,0 +1,39 @@ +/* eslint-disable no-var */ +import { config } from "../tests-config"; +import { deployContract } from "../../common/deployments"; +import { DummyContract__factory } from "../../typechain"; +import { etherToWei, sendTransactionsToGenerateTrafficWithInterval } from "../../common/utils"; + +declare global { + var stopL2TrafficGeneration: () => void; +} + +export default async (): Promise => { + const account = config.getL1AccountManager().whaleAccount(0); + const l2Account = config.getL2AccountManager().whaleAccount(0); + + const [dummyContract, l2DummyContract] = await Promise.all([ + deployContract(new DummyContract__factory(), account), + deployContract(new DummyContract__factory(), l2Account), + ]); + + console.log(`L1 Dummy contract deployed at address: ${await dummyContract.getAddress()}`); + console.log(`L2 Dummy contract deployed at address: ${await l2DummyContract.getAddress()}`); + + // Send ETH to the LineaRollup contract + const lineaRollup = config.getLineaRollupContract(account); + const l1JsonRpcProvider = config.getL1Provider(); + + const value = etherToWei("500"); + const fee = etherToWei("3"); + const to = "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; + const calldata = "0x"; + const { maxPriorityFeePerGas, maxFeePerGas } = await l1JsonRpcProvider.getFeeData(); + const tx = await lineaRollup.sendMessage(to, fee, calldata, { value, maxPriorityFeePerGas, maxFeePerGas }); + await tx.wait(); + + console.log("Generating L2 traffic..."); + const stopPolling = await sendTransactionsToGenerateTrafficWithInterval(l2Account, 2_000); + + global.stopL2TrafficGeneration = stopPolling; +}; diff --git a/e2e/src/config/jest/global-teardown.ts b/e2e/src/config/jest/global-teardown.ts new file mode 100644 index 000000000..f1f0f307e --- /dev/null +++ b/e2e/src/config/jest/global-teardown.ts @@ -0,0 +1,3 @@ +export default async (): Promise => { + global.stopL2TrafficGeneration(); +}; diff --git a/e2e/src/config/tests-config/accounts/account-manager.ts b/e2e/src/config/tests-config/accounts/account-manager.ts new file mode 100644 index 000000000..42984b78a --- /dev/null +++ b/e2e/src/config/tests-config/accounts/account-manager.ts @@ -0,0 +1,124 @@ +import { ethers, Provider, Wallet } from "ethers"; +import Account from "./account"; +import { etherToWei } from "../../../common/utils"; + +interface IAccountManager { + whaleAccount(accIndex?: number): Wallet; + generateAccount(initialBalanceWei?: bigint): Promise; + generateAccounts(numberOfAccounts: number, initialBalanceWei?: bigint): Promise; + getWallet(account: Account): Wallet; +} + +function getWallet(provider: Provider, privateKey: string): Wallet { + if (!privateKey.startsWith("0x")) { + privateKey = "0x" + privateKey; + } + let keyWithoutPrefix = privateKey.slice(2); + + // Pad the private key to 64 hex characters (32 bytes) if it's shorter + if (keyWithoutPrefix.length < 64) { + keyWithoutPrefix = keyWithoutPrefix.padStart(64, "0"); + } + return new Wallet(`0x${keyWithoutPrefix}`, provider); +} + +abstract class AccountManager implements IAccountManager { + protected readonly chainId: number; + protected readonly whaleAccounts: Account[]; + protected provider: Provider; + protected accountWallets: Wallet[]; + + constructor(provider: Provider, whaleAccounts: Account[], chainId: number) { + this.provider = provider; + this.whaleAccounts = whaleAccounts; + this.chainId = chainId; + this.accountWallets = this.whaleAccounts.map((account) => getWallet(this.provider, account.privateKey)); + } + + selectWhaleAccount(accIndex?: number): { account: Account; accountWallet: Wallet } { + if (accIndex) { + return { account: this.whaleAccounts[accIndex], accountWallet: this.accountWallets[accIndex] }; + } + const workerIdEnv = process.env.JEST_WORKER_ID || "1"; + const workerId = parseInt(workerIdEnv, 10) - 1; + + const accountIndex = workerId; + const whaleAccount = this.whaleAccounts[accountIndex]; + const whaleTxManager = this.accountWallets[this.whaleAccounts.indexOf(whaleAccount)]; + return { account: whaleAccount, accountWallet: whaleTxManager }; + } + + whaleAccount(accIndex?: number): Wallet { + return this.selectWhaleAccount(accIndex).accountWallet; + } + + async generateAccount(initialBalanceWei = etherToWei("10")): Promise { + const accounts = await this.generateAccounts(1, initialBalanceWei); + return this.getWallet(accounts[0]); + } + + async generateAccounts( + numberOfAccounts: number, + initialBalanceWei = etherToWei("10"), + retryDelayMs = 1_000, + ): Promise { + const { account: whaleAccount, accountWallet: whaleAccountWallet } = this.selectWhaleAccount(); + + console.log( + `Generating accounts: chainId=${this.chainId} numberOfAccounts=${numberOfAccounts} whaleAccount=${whaleAccount.address}`, + ); + + const accounts: Account[] = []; + + for (let i = 0; i < numberOfAccounts; i++) { + const randomBytes = ethers.randomBytes(32); + const randomPrivKey = ethers.hexlify(randomBytes); + const newAccount = new Account(randomPrivKey, ethers.computeAddress(randomPrivKey)); + accounts.push(newAccount); + + let success = false; + while (!success) { + try { + const tx = { + to: newAccount.address, + value: initialBalanceWei, + gasPrice: ethers.parseUnits("300", "gwei"), + gasLimit: 21000n, + }; + const transactionResponse = await whaleAccountWallet.sendTransaction(tx); + console.log( + `Waiting for account funding: newAccount=${newAccount.address} txHash=${transactionResponse.hash} whaleAccount=${whaleAccount.address}`, + ); + const receipt = await transactionResponse.wait(); + + if (!receipt) { + throw new Error(`Transaction failed to be mined`); + } + + if (receipt.status !== 1) { + throw new Error(`Transaction failed with status ${receipt.status}`); + } + console.log( + `Account funded: newAccount=${newAccount.address} balance=${( + await this.provider.getBalance(newAccount.address) + ).toString()} wei`, + ); + success = true; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } catch (error: any) { + console.log( + `Failed to send funds from accAddress=${whaleAccount.address}. Retrying funding in ${retryDelayMs}ms...`, + ); + await new Promise((resolve) => setTimeout(resolve, retryDelayMs)); + } + } + } + return accounts.map((account) => getWallet(this.provider, account.privateKey)); + } + + getWallet(account: Account): Wallet { + return getWallet(this.provider, account.privateKey); + } +} + +export { AccountManager }; diff --git a/e2e/src/config/tests-config/accounts/account.ts b/e2e/src/config/tests-config/accounts/account.ts new file mode 100644 index 000000000..acd928bda --- /dev/null +++ b/e2e/src/config/tests-config/accounts/account.ts @@ -0,0 +1,9 @@ +export default class Account { + public readonly privateKey: string; + public readonly address: string; + + constructor(privateKey: string, address: string) { + this.privateKey = privateKey; + this.address = address; + } +} diff --git a/e2e/src/config/tests-config/accounts/environment-based-account-manager.ts b/e2e/src/config/tests-config/accounts/environment-based-account-manager.ts new file mode 100644 index 000000000..c98342ee5 --- /dev/null +++ b/e2e/src/config/tests-config/accounts/environment-based-account-manager.ts @@ -0,0 +1,11 @@ +import { Provider } from "ethers"; +import Account from "./account"; +import { AccountManager } from "./account-manager"; + +class EnvironmentBasedAccountManager extends AccountManager { + constructor(provider: Provider, whaleAccounts: Account[], chainId: number) { + super(provider, whaleAccounts, chainId); + } +} + +export { EnvironmentBasedAccountManager }; diff --git a/e2e/src/config/tests-config/accounts/genesis-based-account-manager.ts b/e2e/src/config/tests-config/accounts/genesis-based-account-manager.ts new file mode 100644 index 000000000..bc3a7801e --- /dev/null +++ b/e2e/src/config/tests-config/accounts/genesis-based-account-manager.ts @@ -0,0 +1,41 @@ +import { ethers, Provider } from "ethers"; +import Account from "./account"; +import { AccountManager } from "./account-manager"; +import { readJsonFile } from "../../../common/utils"; + +interface GenesisJson { + config: { + chainId: number; + }; + alloc: { + [address: string]: { + privateKey?: string; + }; + }; +} + +function readGenesisFileAccounts(genesisJson: GenesisJson): Account[] { + const alloc = genesisJson.alloc; + const accounts: Account[] = []; + for (const address in alloc) { + const accountData = alloc[address]; + if (accountData.privateKey) { + const addr = ethers.getAddress(address); + accounts.push(new Account(accountData.privateKey, addr)); + } + } + return accounts; +} + +class GenesisBasedAccountManager extends AccountManager { + constructor(provider: Provider, genesisFilePath: string) { + const genesisJson = readJsonFile(genesisFilePath); + const genesis = genesisJson as GenesisJson; + const chainId = genesis.config.chainId; + const whaleAccounts = readGenesisFileAccounts(genesis); + + super(provider, whaleAccounts, chainId); + } +} + +export { GenesisBasedAccountManager }; diff --git a/e2e/src/config/tests-config/environments/dev.ts b/e2e/src/config/tests-config/environments/dev.ts new file mode 100644 index 000000000..1ed0d35b9 --- /dev/null +++ b/e2e/src/config/tests-config/environments/dev.ts @@ -0,0 +1,49 @@ +import { ethers } from "ethers"; +import { EnvironmentBasedAccountManager } from "../accounts/environment-based-account-manager"; +import { Config } from "../types"; +import Account from "../accounts/account"; + +const L1_RPC_URL = new URL(`https://sepolia.infura.io/v3/${process.env.INFURA_PROJECT_ID}`); +const L2_RPC_URL = new URL("https://rpc.devnet.linea.build"); +const L1_CHAIN_ID = 11155111; +const L2_CHAIN_ID = 59139; + +const L1_WHALE_ACCOUNTS_PRIVATE_KEYS: string[] = process.env.L1_WHALE_ACCOUNTS_PRIVATE_KEYS?.split(",") ?? []; +const L2_WHALE_ACCOUNTS_PRIVATE_KEYS: string[] = process.env.L2_WHALE_ACCOUNTS_PRIVATE_KEYS?.split(",") ?? []; +const L1_WHALE_ACCOUNTS_ADDRESSES: string[] = process.env.L1_WHALE_ACCOUNTS_ADDRESSES?.split(",") ?? []; +const L2_WHALE_ACCOUNTS_ADDRESSES: string[] = process.env.L2_WHALE_ACCOUNTS_ADDRESSES?.split(",") ?? []; + +const L1_WHALE_ACCOUNTS: Account[] = L1_WHALE_ACCOUNTS_PRIVATE_KEYS.map((privateKey, index) => { + return new Account(privateKey, L1_WHALE_ACCOUNTS_ADDRESSES[index]); +}); + +const L2_WHALE_ACCOUNTS: Account[] = L2_WHALE_ACCOUNTS_PRIVATE_KEYS.map((privateKey, index) => { + return new Account(privateKey, L2_WHALE_ACCOUNTS_ADDRESSES[index]); +}); + +const config: Config = { + L1: { + rpcUrl: L1_RPC_URL, + chainId: L1_CHAIN_ID, + lineaRollupAddress: "0x2A5CDCfc38856e2590E9Bd32F54Fa348e5De5f48", + accountManager: new EnvironmentBasedAccountManager( + new ethers.JsonRpcProvider(L1_RPC_URL.toString()), + L1_WHALE_ACCOUNTS, + L1_CHAIN_ID, + ), + dummyContractAddress: "", + }, + L2: { + rpcUrl: L2_RPC_URL, + chainId: L2_CHAIN_ID, + l2MessageServiceAddress: "0x33bf916373159A8c1b54b025202517BfDbB7863D", + accountManager: new EnvironmentBasedAccountManager( + new ethers.JsonRpcProvider(L2_RPC_URL.toString()), + L2_WHALE_ACCOUNTS, + L2_CHAIN_ID, + ), + dummyContractAddress: "", + }, +}; + +export default config; diff --git a/e2e/src/config/tests-config/environments/local.ts b/e2e/src/config/tests-config/environments/local.ts new file mode 100644 index 000000000..c4607eed3 --- /dev/null +++ b/e2e/src/config/tests-config/environments/local.ts @@ -0,0 +1,44 @@ +import { ethers } from "ethers"; +import path from "path"; +import { GenesisBasedAccountManager } from "../accounts/genesis-based-account-manager"; +import { Config } from "../types"; + +const L1_RPC_URL = new URL("http://localhost:8445"); +const L2_RPC_URL = new URL("http://localhost:8845"); +const SHOMEI_ENDPOINT = new URL("http://localhost:8998"); +const SHOMEI_FRONTEND_ENDPOINT = new URL("http://localhost:8889"); +const SEQUENCER_ENDPOINT = new URL("http://localhost:8545"); + +const config: Config = { + L1: { + rpcUrl: L1_RPC_URL, + chainId: 31648428, + lineaRollupAddress: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9", + dummyContractAddress: "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", + accountManager: new GenesisBasedAccountManager( + new ethers.JsonRpcProvider(L1_RPC_URL.toString()), + path.resolve( + process.env.LOCAL_L1_GENESIS || + path.resolve(__dirname, "../../../../..", "docker/config/l1-node/el", "genesis.json"), + ), + ), + }, + L2: { + rpcUrl: L2_RPC_URL, + chainId: 1337, + l2MessageServiceAddress: "0xe537D669CA013d86EBeF1D64e40fC74CADC91987", + dummyContractAddress: "0x2f6dAaF8A81AB675fbD37Ca6Ed5b72cf86237453", + accountManager: new GenesisBasedAccountManager( + new ethers.JsonRpcProvider(L2_RPC_URL.toString()), + path.resolve( + process.env.LOCAL_L2_GENESIS || + path.resolve(__dirname, "../../../../..", "docker/config", "linea-local-dev-genesis-PoA.json"), + ), + ), + shomeiEndpoint: SHOMEI_ENDPOINT, + shomeiFrontendEndpoint: SHOMEI_FRONTEND_ENDPOINT, + sequencerEndpoint: SEQUENCER_ENDPOINT, + }, +}; + +export default config; diff --git a/e2e/src/config/tests-config/environments/sepolia.ts b/e2e/src/config/tests-config/environments/sepolia.ts new file mode 100644 index 000000000..c9fb33f3e --- /dev/null +++ b/e2e/src/config/tests-config/environments/sepolia.ts @@ -0,0 +1,48 @@ +import { ethers } from "ethers"; +import { EnvironmentBasedAccountManager } from "../accounts/environment-based-account-manager"; +import Account from "../accounts/account"; +import { Config } from "../types"; + +const L1_RPC_URL = new URL(`https://sepolia.infura.io/v3/${process.env.INFURA_PROJECT_ID}`); +const L2_RPC_URL = new URL(`https://linea-sepolia.infura.io/v3/${process.env.INFURA_PROJECT_ID}`); +const L1_CHAIN_ID = 11155111; +const L2_CHAIN_ID = 59141; +const L1_WHALE_ACCOUNTS_PRIVATE_KEYS: string[] = process.env.L1_WHALE_ACCOUNTS_PRIVATE_KEYS?.split(",") ?? []; +const L2_WHALE_ACCOUNTS_PRIVATE_KEYS: string[] = process.env.L2_WHALE_ACCOUNTS_PRIVATE_KEYS?.split(",") ?? []; +const L1_WHALE_ACCOUNTS_ADDRESSES: string[] = process.env.L1_WHALE_ACCOUNTS_ADDRESSES?.split(",") ?? []; +const L2_WHALE_ACCOUNTS_ADDRESSES: string[] = process.env.L2_WHALE_ACCOUNTS_ADDRESSES?.split(",") ?? []; + +const L1_WHALE_ACCOUNTS: Account[] = L1_WHALE_ACCOUNTS_PRIVATE_KEYS.map((privateKey, index) => { + return new Account(privateKey, L1_WHALE_ACCOUNTS_ADDRESSES[index]); +}); + +const L2_WHALE_ACCOUNTS: Account[] = L2_WHALE_ACCOUNTS_PRIVATE_KEYS.map((privateKey, index) => { + return new Account(privateKey, L2_WHALE_ACCOUNTS_ADDRESSES[index]); +}); + +const config: Config = { + L1: { + rpcUrl: L1_RPC_URL, + chainId: L1_CHAIN_ID, + lineaRollupAddress: "0xB218f8A4Bc926cF1cA7b3423c154a0D627Bdb7E5", + accountManager: new EnvironmentBasedAccountManager( + new ethers.JsonRpcProvider(L1_RPC_URL.toString()), + L1_WHALE_ACCOUNTS, + L1_CHAIN_ID, + ), + dummyContractAddress: "", + }, + L2: { + rpcUrl: L2_RPC_URL, + chainId: L2_CHAIN_ID, + l2MessageServiceAddress: "0x971e727e956690b9957be6d51Ec16E73AcAC83A7", + accountManager: new EnvironmentBasedAccountManager( + new ethers.JsonRpcProvider(L2_RPC_URL.toString()), + L2_WHALE_ACCOUNTS, + L2_CHAIN_ID, + ), + dummyContractAddress: "", + }, +}; + +export default config; diff --git a/e2e/src/config/tests-config/index.ts b/e2e/src/config/tests-config/index.ts new file mode 100644 index 000000000..639ed63bc --- /dev/null +++ b/e2e/src/config/tests-config/index.ts @@ -0,0 +1,26 @@ +import TestSetup from "./setup"; +import localConfig from "./environments/local"; +import devConfig from "./environments/dev"; +import sepoliaConfig from "./environments/sepolia"; + +import { Config } from "./types"; + +const testEnv = process.env.TEST_ENV || "local"; // Default to local environment + +let config: Config; + +switch (testEnv) { + case "dev": + config = devConfig; + break; + case "sepolia": + config = sepoliaConfig; + break; + case "local": + default: + config = localConfig; + break; +} +const setup = new TestSetup(config); + +export { setup as config }; diff --git a/e2e/src/config/tests-config/setup.ts b/e2e/src/config/tests-config/setup.ts new file mode 100644 index 000000000..d54879baa --- /dev/null +++ b/e2e/src/config/tests-config/setup.ts @@ -0,0 +1,97 @@ +import { JsonRpcProvider, Wallet } from "ethers"; +import { Config } from "./types"; +import { + DummyContract, + DummyContract__factory, + L2MessageService, + L2MessageService__factory, + LineaRollup, + LineaRollup__factory, +} from "../../typechain"; +import { AccountManager } from "./accounts/account-manager"; + +export default class TestSetup { + constructor(private readonly config: Config) {} + + public getL1Provider(): JsonRpcProvider { + return new JsonRpcProvider(this.config.L1.rpcUrl.toString()); + } + + public getL2Provider(): JsonRpcProvider { + return new JsonRpcProvider(this.config.L2.rpcUrl.toString()); + } + + public getL1ChainId(): number { + return this.config.L1.chainId; + } + + public getL2ChainId(): number { + return this.config.L2.chainId; + } + + public getShomeiEndpoint(): URL | undefined { + return this.config.L2.shomeiEndpoint; + } + + public getShomeiFrontendEndpoint(): URL | undefined { + return this.config.L2.shomeiFrontendEndpoint; + } + + public getSequencerEndpoint(): URL | undefined { + return this.config.L2.sequencerEndpoint; + } + + public getLineaRollupContract(signer?: Wallet): LineaRollup { + const lineaRollup: LineaRollup = LineaRollup__factory.connect( + this.config.L1.lineaRollupAddress, + this.getL1Provider(), + ); + + if (signer) { + return lineaRollup.connect(signer); + } + + return lineaRollup; + } + + public getL2MessageServiceContract(signer?: Wallet): L2MessageService { + const l2MessageService: L2MessageService = L2MessageService__factory.connect( + this.config.L2.l2MessageServiceAddress, + this.getL2Provider(), + ); + + if (signer) { + return l2MessageService.connect(signer); + } + + return l2MessageService; + } + + public getL1DummyContract(signer?: Wallet): DummyContract { + const dummyContract = DummyContract__factory.connect(this.config.L1.dummyContractAddress, this.getL1Provider()); + + if (signer) { + return dummyContract.connect(signer); + } + + return dummyContract; + } + + public getL2DummyContract(signer?: Wallet): DummyContract { + const dummyContract = DummyContract__factory.connect(this.config.L2.dummyContractAddress, this.getL2Provider()); + + if (signer) { + return dummyContract.connect(signer); + } + + return dummyContract; + } + + public getL1AccountManager(): AccountManager { + return this.config.L1.accountManager; + } + + public getL2AccountManager(): AccountManager { + return this.config.L2.accountManager; + } +} diff --git a/e2e/src/config/tests-config/types.ts b/e2e/src/config/tests-config/types.ts new file mode 100644 index 000000000..832ca0ad7 --- /dev/null +++ b/e2e/src/config/tests-config/types.ts @@ -0,0 +1,24 @@ +import { AccountManager } from "./accounts/account-manager"; + +export type BaseConfig = { + rpcUrl: URL; + chainId: number; + accountManager: AccountManager; + dummyContractAddress: string; +}; + +export type L1Config = BaseConfig & { + lineaRollupAddress: string; +}; + +export type L2Config = BaseConfig & { + l2MessageServiceAddress: string; + shomeiEndpoint?: URL; + shomeiFrontendEndpoint?: URL; + sequencerEndpoint?: URL; +}; + +export type Config = { + L1: L1Config; + L2: L2Config; +}; diff --git a/e2e/src/index.ordered-test.ts b/e2e/src/index.ordered-test.ts deleted file mode 100644 index ac1c6baa2..000000000 --- a/e2e/src/index.ordered-test.ts +++ /dev/null @@ -1,12 +0,0 @@ -// Here we want to guarantee the running order of test files -// to minimize timeout errors in ci pipeline -import submissionAndFinalizationTestSuite from "./submission-finalization.spec"; -import layer2TestSuite from "./l2.spec"; -import messagingTestSuite from "./messaging.spec"; -import coordinatorRestartTestSuite from "./restart.spec"; - -messagingTestSuite("Messaging test suite"); -// NOTES: The coordinator restart test must not be run first in the sequence of tests. -coordinatorRestartTestSuite("Coordinator restart test suite"); -layer2TestSuite("Layer 2 test suite"); -submissionAndFinalizationTestSuite("Submission and finalization test suite"); diff --git a/e2e/src/l2.spec.ts b/e2e/src/l2.spec.ts index 71b5edcea..c064e76fe 100644 --- a/e2e/src/l2.spec.ts +++ b/e2e/src/l2.spec.ts @@ -1,339 +1,157 @@ -import { Wallet, ethers } from "ethers"; -import { describe, expect, it } from "@jest/globals"; -import { TransactionRequest } from "@ethersproject/providers"; -import { getAndIncreaseFeeData } from "./utils/helpers"; -import { RollupGetZkEVMBlockNumberClient, getEvents, wait } from "./utils/utils"; +import { JsonRpcProvider, ethers } from "ethers"; +import { beforeAll, describe, expect, it } from "@jest/globals"; +import { config } from "./config/tests-config"; +import { RollupGetZkEVMBlockNumberClient, etherToWei } from "./common/utils"; +import { TRANSACTION_CALLDATA_LIMIT } from "./common/constants"; -const layer2TestSuite = (title: string) => { - describe(title, () => { - describe("Transaction data size", () => { - it("Should revert if transaction data size is above the limit", async () => { - const account = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); - await expect( - dummyContract.connect(account).setPayload(ethers.utils.randomBytes(TRANSACTION_CALLDATA_LIMIT)), - ).rejects.toThrow("err: tx data is too large (in bytes)"); - }); +const l2AccountManager = config.getL2AccountManager(); - it("Should succeed if transaction data size is below the limit", async () => { - const account = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); +describe("Layer 2 test suite", () => { + let l2Provider: JsonRpcProvider; - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - const tx = await dummyContract.connect(account).setPayload(ethers.utils.randomBytes(1000), { - nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - - const receipt = await tx.wait(); - expect(receipt.status).toEqual(1); - }); - }); - - describe("Block conflation", () => { - it("Should succeed in conflating multiple blocks and proving on L1", async () => { - const account = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - - const l2BlockNumbers: number[] = []; - for (let i = 0; i < 2; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - - const tx: TransactionRequest = { - type: 2, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - maxPriorityFeePerGas, - maxFeePerGas, - value: ethers.utils.parseEther("0.01"), - gasLimit: "21000", - chainId, - }; - - const signedTx = await account.signTransaction(tx); - - const receipt = await (await l2Provider.sendTransaction(signedTx)).wait(); - l2BlockNumbers.push(receipt.blockNumber); - } - - for (let i = 0; i < 2; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - - const tx = await dummyContract - .connect(account) - .setPayload(ethers.utils.randomBytes(TRANSACTION_CALLDATA_LIMIT / 2 - 1000), { - nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - const receipt = await tx.wait(); - l2BlockNumbers.push(receipt.blockNumber); - } - - // These is just to push the L1 verified block forward to the max number in - // l2BlockNumbers as it's always 2 blocks behind the current L2 block number - for (let i = 0; i < 4; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - - const tx = await dummyContract.connect(account).setPayload(ethers.utils.randomBytes(10), { - nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - await tx.wait(); - } - - const maxL2BlockNumber = Math.max(...l2BlockNumbers); - let currentL2BlockNumber = (await lineaRollup.currentL2BlockNumber()).toNumber(); - console.log(`maxL2BlockNumber: ${maxL2BlockNumber}`); - console.log(`l2BlockNumbers: ${l2BlockNumbers}`); - console.log(`initial currentL2BlockNumber: ${currentL2BlockNumber}`); - - while (maxL2BlockNumber > currentL2BlockNumber) { - await wait(2000); - currentL2BlockNumber = (await lineaRollup.currentL2BlockNumber()).toNumber(); - } - - const events = await getEvents(lineaRollup, lineaRollup.filters.BlocksVerificationDone()); - console.log(`Last blockVerification: ${JSON.stringify(events.at(-1))}`); - console.log(`currentL2BlockNumber: ${currentL2BlockNumber}`); - - expect(currentL2BlockNumber).toBeGreaterThanOrEqual(maxL2BlockNumber); - }, 300000); - - it("Should succeed in conflating transactions with large calldata with low gas into multiple L1 blocks", async () => { - const account = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - const l2BlockNumbers: number[] = []; - const txList = []; - for (let i = 0; i < 4; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address, "pending"), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - - const tx = await dummyContract - .connect(account) - .setPayload(ethers.utils.randomBytes(TRANSACTION_CALLDATA_LIMIT / 2 - 1000), { - nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - txList.push(tx); - } - - await Promise.all( - txList.map(async (tx) => { - const receipt = await tx.wait(); - l2BlockNumbers.push(receipt.blockNumber); - }), - ); - - // These is just to push the L1 verified block forward to the max number in - // l2BlockNumbers as it's always 2 blocks behind the current L2 block number - for (let i = 0; i < 4; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - - const tx = await dummyContract.connect(account).setPayload(ethers.utils.randomBytes(10), { - nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - await tx.wait(); - } - - const maxL2BlockNumber = Math.max(...l2BlockNumbers); - let currentL2BlockNumber = (await lineaRollup.currentL2BlockNumber()).toNumber(); - console.log(`l2BlockNumbers: ${l2BlockNumbers}`); - console.log(`initial currentL2BlockNumber: ${currentL2BlockNumber}`); - - while (maxL2BlockNumber > currentL2BlockNumber) { - await wait(2000); - currentL2BlockNumber = (await lineaRollup.currentL2BlockNumber()).toNumber(); - } - - const events = await getEvents(lineaRollup, lineaRollup.filters.BlocksVerificationDone()); - console.log(`Last blockVerification: ${JSON.stringify(events.at(-1))}`); - console.log(`currentL2BlockNumber: ${currentL2BlockNumber}`); - - expect(currentL2BlockNumber).toBeGreaterThanOrEqual(maxL2BlockNumber); - }, 600000); - }); - - describe("Different transaction types", () => { - it("Should successfully send a legacy transaction", async () => { - const account = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); + beforeAll(() => { + l2Provider = config.getL2Provider(); + }); - const [, , gasPrice] = getAndIncreaseFeeData(feeData); + it.concurrent("Should revert if transaction data size is above the limit", async () => { + const account = await l2AccountManager.generateAccount(); + const dummyContract = config.getL2DummyContract(account); - const receipt = await ( - await account.sendTransaction({ - type: 0, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - gasPrice, - value: ethers.utils.parseEther("0.01"), - gasLimit: "0x466124", - chainId, - }) - ).wait(); + await expect( + dummyContract.connect(account).setPayload(ethers.randomBytes(TRANSACTION_CALLDATA_LIMIT)), + ).rejects.toThrow("missing revert data"); + }); - expect(receipt).not.toBeNull(); - }); + it.concurrent("Should succeed if transaction data size is below the limit", async () => { + const account = await l2AccountManager.generateAccount(); + const dummyContract = config.getL2DummyContract(account); - it("Should successfully send an EIP1559 transaction", async () => { - const account = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); + const tx = await dummyContract.connect(account).setPayload(ethers.randomBytes(1000)); - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); - const receipt = await ( - await account.sendTransaction({ - type: 2, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - maxPriorityFeePerGas, - maxFeePerGas, - value: ethers.utils.parseEther("0.01"), - gasLimit: "21000", - chainId, - }) - ).wait(); + const receipt = await tx.wait(); + expect(receipt?.status).toEqual(1); + }); - expect(receipt).not.toBeNull(); - }); + it.concurrent("Should successfully send a legacy transaction", async () => { + const account = await l2AccountManager.generateAccount(); - it("Should successfully send an access list transaction with empty access list", async () => { - const account = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); + const { gasPrice } = await l2Provider.getFeeData(); - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); + const receipt = await ( + await account.sendTransaction({ + type: 0, + to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", + gasPrice, + value: etherToWei("0.01"), + gasLimit: "0x466124", + chainId: config.getL2ChainId(), + }) + ).wait(); - const [, , gasPrice] = getAndIncreaseFeeData(feeData); + expect(receipt).not.toBeNull(); + }); - const receipt = await ( - await account.sendTransaction({ - type: 1, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - gasPrice, - value: ethers.utils.parseEther("0.01"), - gasLimit: "21000", - chainId, - }) - ).wait(); + it.concurrent("Should successfully send an EIP1559 transaction", async () => { + const account = await l2AccountManager.generateAccount(); - expect(receipt).not.toBeNull(); - }); + const { maxPriorityFeePerGas, maxFeePerGas } = await l2Provider.getFeeData(); - it("Should successfully send an access list transaction with access list", async () => { - const account = new Wallet(L2_DEPLOYER_ACCOUNT_PRIVATE_KEY, l2Provider); + const receipt = await ( + await account.sendTransaction({ + type: 2, + to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", + maxPriorityFeePerGas, + maxFeePerGas, + value: etherToWei("0.01"), + gasLimit: "21000", + chainId: config.getL2ChainId(), + }) + ).wait(); - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); + expect(receipt).not.toBeNull(); + }); - const [, , gasPrice] = getAndIncreaseFeeData(feeData); - const accessList = { - "0x8D97689C9818892B700e27F316cc3E41e17fBeb9": [ - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000001", - ], - }; + it.concurrent("Should successfully send an access list transaction with empty access list", async () => { + const account = await l2AccountManager.generateAccount(); - const receipt = await ( - await account.sendTransaction({ - type: 1, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - gasPrice, - value: ethers.utils.parseEther("0.01"), - gasLimit: "200000", - chainId, - accessList: ethers.utils.accessListify(accessList), - }) - ).wait(); + const { gasPrice } = await l2Provider.getFeeData(); - expect(receipt).not.toBeNull(); - }); - }); + const receipt = await ( + await account.sendTransaction({ + type: 1, + to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", + gasPrice, + value: etherToWei("0.01"), + gasLimit: "21000", + chainId: config.getL2ChainId(), + }) + ).wait(); - describe("Block finalization notifications", () => { - // TODO: discuss new frontend - it.skip("Shomei frontend always behind while conflating multiple blocks and proving on L1", async () => { - if (SHOMEI_ENDPOINT == null || SHOMEI_FRONTEND_ENDPOINT == null) { - // Skip this test for dev and uat environments - return; - } - const account = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - const shomeiClient = new RollupGetZkEVMBlockNumberClient(SHOMEI_ENDPOINT); - const shomeiFrontendClient = new RollupGetZkEVMBlockNumberClient(SHOMEI_FRONTEND_ENDPOINT); + expect(receipt).not.toBeNull(); + }); - for (let i = 0; i < 5; i++) { - const [nonce, feeData] = await Promise.all([ - l2Provider.getTransactionCount(account.address), - l2Provider.getFeeData(), - ]); + it.concurrent("Should successfully send an access list transaction with access list", async () => { + const account = await l2AccountManager.generateAccount(); + + const { gasPrice } = await l2Provider.getFeeData(); + const accessList = { + "0x8D97689C9818892B700e27F316cc3E41e17fBeb9": [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000001", + ], + }; + + const receipt = await ( + await account.sendTransaction({ + type: 1, + to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", + gasPrice, + value: etherToWei("0.01"), + gasLimit: "200000", + chainId: config.getL2ChainId(), + accessList: ethers.accessListify(accessList), + }) + ).wait(); + + expect(receipt).not.toBeNull(); + }); - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(feeData); + // TODO: discuss new frontend + it.skip("Shomei frontend always behind while conflating multiple blocks and proving on L1", async () => { + const account = await l2AccountManager.generateAccount(); - await ( - await account.sendTransaction({ - type: 2, - nonce, - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - maxPriorityFeePerGas, - maxFeePerGas, - value: ethers.utils.parseEther("0.01"), - gasLimit: "21000", - chainId, - }) - ).wait(); + const shomeiEndpoint = config.getShomeiEndpoint(); + const shomeiFrontendEndpoint = config.getShomeiFrontendEndpoint(); - const [shomeiBlock, shomeiFrontendBlock] = await Promise.all([ - shomeiClient.rollupGetZkEVMBlockNumber(), - shomeiFrontendClient.rollupGetZkEVMBlockNumber(), - ]); - console.log(`shomeiBlock = ${shomeiBlock}, shomeiFrontendBlock = ${shomeiFrontendBlock}`); + if (!shomeiEndpoint || !shomeiFrontendEndpoint) { + // Skip this test for dev and uat environments + return; + } + const shomeiClient = new RollupGetZkEVMBlockNumberClient(shomeiEndpoint); + const shomeiFrontendClient = new RollupGetZkEVMBlockNumberClient(shomeiFrontendEndpoint); - expect(shomeiBlock).toBeGreaterThan(shomeiFrontendBlock); - } - }, 300000); - }); - }); -}; + for (let i = 0; i < 5; i++) { + const { maxPriorityFeePerGas, maxFeePerGas } = await l2Provider.getFeeData(); -export default layer2TestSuite; + await ( + await account.sendTransaction({ + type: 2, + to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", + maxPriorityFeePerGas, + maxFeePerGas, + value: etherToWei("0.01"), + gasLimit: "21000", + chainId: config.getL2ChainId(), + }) + ).wait(); + + const [shomeiBlock, shomeiFrontendBlock] = await Promise.all([ + shomeiClient.rollupGetZkEVMBlockNumber(), + shomeiFrontendClient.rollupGetZkEVMBlockNumber(), + ]); + console.log(`shomeiBlock = ${shomeiBlock}, shomeiFrontendBlock = ${shomeiFrontendBlock}`); + + expect(shomeiBlock).toBeGreaterThan(shomeiFrontendBlock); + } + }, 150_000); +}); diff --git a/e2e/src/messaging.spec.ts b/e2e/src/messaging.spec.ts index 035906bfb..722531d48 100644 --- a/e2e/src/messaging.spec.ts +++ b/e2e/src/messaging.spec.ts @@ -1,129 +1,211 @@ -import { Wallet, ethers } from "ethers"; -import { beforeAll, describe, expect, it } from "@jest/globals"; -import { - encodeFunctionCall, - sendTransactionsToGenerateTrafficWithInterval, - waitForEvents -} from "./utils/utils"; -import { getAndIncreaseFeeData } from "./utils/helpers"; -import { MESSAGE_SENT_EVENT_SIGNATURE } from "./utils/constants"; - -const messagingTestSuite = (title: string) => { - describe(title, () => { - let l1Account: Wallet; - let l2Account0: Wallet; - let l2AccountForLiveness: Wallet; - - beforeAll(() => { - l1Account = new Wallet(L1_ACCOUNT_0_PRIVATE_KEY, l1Provider); - l2Account0 = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - l2AccountForLiveness = new Wallet(L2_ACCOUNT_1_PRIVATE_KEY, l2Provider); - }); - - describe("Message Service L1 -> L2", () => { - it.each([ - { - subTitle: "with calldata", - withCalldata: true, - }, - { - subTitle: "without calldata", - withCalldata: false, - }, - ])( - "Should send a transaction $subTitle to L1 message service, be successfully claimed it on L2", - async ({ withCalldata }) => { - const valueAndFee = ethers.utils.parseEther("1.1"); - const calldata = withCalldata - ? encodeFunctionCall(dummyContract.interface, "setPayload", [ethers.utils.randomBytes(100)]) - : "0x"; - const destinationAddress = withCalldata - ? dummyContract.address - : "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await l1Provider.getFeeData()); - const nonce = await l1Provider.getTransactionCount(l1Account.address, "pending"); - const tx = await lineaRollup.connect(l1Account).sendMessage(destinationAddress, valueAndFee, calldata, { - value: valueAndFee, - nonce: nonce, - maxPriorityFeePerGas: maxPriorityFeePerGas, - maxFeePerGas: maxFeePerGas, - }); - - const receipt = await tx.wait(); - - console.log("Moving the L2 chain forward to trigger anchoring..."); - const intervalId = await sendTransactionsToGenerateTrafficWithInterval(l2AccountForLiveness); - - const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); - const messageHash = messageSentEvent.topics[3]; - console.log(`L1 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); - - console.log("Waiting for MessageClaimed event on L2."); - const [messageClaimedEvent] = await waitForEvents( - l2MessageService, - l2MessageService.filters.MessageClaimed(messageHash), - ); - clearInterval(intervalId); - console.log(`Message claimed on L2: ${JSON.stringify(messageClaimedEvent)}`); - expect(messageClaimedEvent).toBeDefined(); - }, - 300_000, +import { ethers, Wallet } from "ethers"; +import { describe, expect, it } from "@jest/globals"; +import { config } from "./config/tests-config"; +import { encodeFunctionCall, etherToWei, waitForEvents } from "./common/utils"; +import { MESSAGE_SENT_EVENT_SIGNATURE } from "./common/constants"; + +async function sendL1ToL2Message({ + l1Account, + l2Account, + withCalldata = false, +}: { + l1Account: Wallet; + l2Account: Wallet; + withCalldata: boolean; +}) { + const dummyContract = config.getL2DummyContract(l2Account); + const lineaRollup = config.getLineaRollupContract(l1Account); + + const valueAndFee = etherToWei("1.1"); + const calldata = withCalldata + ? encodeFunctionCall(dummyContract.interface, "setPayload", [ethers.randomBytes(100)]) + : "0x"; + const destinationAddress = withCalldata + ? await dummyContract.getAddress() + : "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; + + const l1Provider = config.getL1Provider(); + const { maxPriorityFeePerGas, maxFeePerGas } = await l1Provider.getFeeData(); + const nonce = await l1Provider.getTransactionCount(l1Account.address, "pending"); + const tx = await lineaRollup.sendMessage(destinationAddress, valueAndFee, calldata, { + value: valueAndFee, + nonce, + maxPriorityFeePerGas, + maxFeePerGas, + }); + + let receipt = await tx.wait(); + while (!receipt) { + console.log("Waiting for transaction to be mined..."); + receipt = await tx.wait(); + } + + return { tx, receipt }; +} + +async function sendL2ToL1Message({ + l1Account, + l2Account, + withCalldata = false, +}: { + l1Account: Wallet; + l2Account: Wallet; + withCalldata: boolean; +}) { + const l2Provider = config.getL2Provider(); + const dummyContract = config.getL1DummyContract(l1Account); + const l2MessageService = config.getL2MessageServiceContract(l2Account); + + const valueAndFee = etherToWei("0.001"); + const calldata = withCalldata + ? encodeFunctionCall(dummyContract.interface, "setPayload", [ethers.randomBytes(100)]) + : "0x"; + + const destinationAddress = withCalldata ? await dummyContract.getAddress() : l1Account.address; + const nonce = await l2Provider.getTransactionCount(l2Account.address, "pending"); + const { maxPriorityFeePerGas, maxFeePerGas } = await l2Provider.getFeeData(); + + const tx = await l2MessageService.sendMessage(destinationAddress, valueAndFee, calldata, { + value: valueAndFee, + nonce, + maxPriorityFeePerGas, + maxFeePerGas, + }); + + let receipt = await tx.wait(); + + while (!receipt) { + console.log("Waiting for transaction to be mined..."); + receipt = await tx.wait(); + } + + return { tx, receipt }; +} + +const l1AccountManager = config.getL1AccountManager(); +const l2AccountManager = config.getL2AccountManager(); + +describe("Messaging test suite", () => { + it.concurrent( + "Should send a transaction with calldata to L1 message service, be successfully claimed it on L2", + async () => { + const [l1Account, l2Account] = await Promise.all([ + l1AccountManager.generateAccount(), + l2AccountManager.generateAccount(), + ]); + + const { tx, receipt } = await sendL1ToL2Message({ l1Account, l2Account, withCalldata: true }); + + const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); + const messageHash = messageSentEvent.topics[3]; + console.log(`L1 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); + + console.log("Waiting for MessageClaimed event on L2."); + const l2MessageService = config.getL2MessageServiceContract(); + const [messageClaimedEvent] = await waitForEvents( + l2MessageService, + l2MessageService.filters.MessageClaimed(messageHash), ); - }); - - describe("Message Service L2 -> L1", () => { - it.each([ - { - subTitle: "with calldata", - withCalldata: true, - }, - { - subTitle: "without calldata", - withCalldata: false, - }, - ])( - "Should send a transaction $subTitle to L2 message service, be successfully claimed it on L1", - async ({ withCalldata }) => { - const valueAndFee = ethers.utils.parseEther("0.001"); - const calldata = withCalldata - ? encodeFunctionCall(l1DummyContract.interface, "setPayload", [ethers.utils.randomBytes(100)]) - : "0x"; - - const destinationAddress = withCalldata ? l1DummyContract.address : l1Account.address; - const nonce = await l2Provider.getTransactionCount(l2Account0.address, "pending"); - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await l2Provider.getFeeData()); - - const tx = await l2MessageService.connect(l2Account0).sendMessage(destinationAddress, valueAndFee, calldata, { - value: valueAndFee, - nonce: nonce, - maxPriorityFeePerGas, - maxFeePerGas, - }); - - const receipt = await tx.wait(); - - const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); - const messageHash = messageSentEvent.topics[3]; - console.log(`L2 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); - - console.log("Moving the L2 chain forward to trigger conflation..."); - const intervalId = await sendTransactionsToGenerateTrafficWithInterval(l2AccountForLiveness); - - console.log("Waiting for MessageClaimed event on L1."); - const [messageClaimedEvent] = await waitForEvents( - lineaRollup, - lineaRollup.filters.MessageClaimed(messageHash) - ); - clearInterval(intervalId); - - console.log(`Message claimed on L1: ${JSON.stringify(messageClaimedEvent)}`); - expect(messageClaimedEvent).toBeDefined(); - }, - 300_000, + + console.log(`Message claimed on L2: ${JSON.stringify(messageClaimedEvent)}`); + expect(messageClaimedEvent).toBeDefined(); + }, + 100_000, + ); + + it.concurrent( + "Should send a transaction without calldata to L1 message service, be successfully claimed it on L2", + async () => { + const [l1Account, l2Account] = await Promise.all([ + l1AccountManager.generateAccount(), + l2AccountManager.generateAccount(), + ]); + + const { tx, receipt } = await sendL1ToL2Message({ l1Account, l2Account, withCalldata: false }); + + const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); + const messageHash = messageSentEvent.topics[3]; + console.log(`L1 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); + + console.log("Waiting for MessageClaimed event on L2."); + const l2MessageService = config.getL2MessageServiceContract(); + const [messageClaimedEvent] = await waitForEvents( + l2MessageService, + l2MessageService.filters.MessageClaimed(messageHash), + ); + console.log(`Message claimed on L2: ${JSON.stringify(messageClaimedEvent)}`); + expect(messageClaimedEvent).toBeDefined(); + }, + 100_000, + ); + + it.concurrent( + "Should send a transaction with calldata to L2 message service, be successfully claimed it on L1", + async () => { + const [l1Account, l2Account] = await Promise.all([ + l1AccountManager.generateAccount(), + l2AccountManager.generateAccount(), + ]); + + const lineaRollup = config.getLineaRollupContract(); + const { tx, receipt } = await sendL2ToL1Message({ l1Account, l2Account, withCalldata: true }); + + const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); + const messageHash = messageSentEvent.topics[3]; + console.log(`L2 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); + + console.log(`Waiting for L2MessagingBlockAnchored... with blockNumber=${messageSentEvent.blockNumber}`); + await waitForEvents( + lineaRollup, + lineaRollup.filters.L2MessagingBlockAnchored(messageSentEvent.blockNumber), + 1_000, + ); + + console.log("Waiting for MessageClaimed event on L1."); + const [messageClaimedEvent] = await waitForEvents( + lineaRollup, + lineaRollup.filters.MessageClaimed(messageHash), + 1_000, + ); + + console.log(`Message claimed on L1: ${JSON.stringify(messageClaimedEvent)}`); + expect(messageClaimedEvent).toBeDefined(); + }, + 150_000, + ); + + it.concurrent( + "Should send a transaction without calldata to L2 message service, be successfully claimed it on L1", + async () => { + const [l1Account, l2Account] = await Promise.all([ + l1AccountManager.generateAccount(), + l2AccountManager.generateAccount(), + ]); + + const lineaRollup = config.getLineaRollupContract(); + const { tx, receipt } = await sendL2ToL1Message({ l1Account, l2Account, withCalldata: false }); + + const [messageSentEvent] = receipt.logs.filter((log) => log.topics[0] === MESSAGE_SENT_EVENT_SIGNATURE); + const messageHash = messageSentEvent.topics[3]; + console.log(`L2 message sent: messageHash=${messageHash} transaction=${JSON.stringify(tx)}`); + + console.log(`Waiting for L2MessagingBlockAnchored... with blockNumber=${messageSentEvent.blockNumber}`); + await waitForEvents( + lineaRollup, + lineaRollup.filters.L2MessagingBlockAnchored(messageSentEvent.blockNumber), + 1_000, + ); + + console.log("Waiting for MessageClaimed event on L1."); + const [messageClaimedEvent] = await waitForEvents( + lineaRollup, + lineaRollup.filters.MessageClaimed(messageHash), + 1_000, ); - }); - }); -}; -export default messagingTestSuite; + console.log(`Message claimed on L1: ${JSON.stringify(messageClaimedEvent)}`); + expect(messageClaimedEvent).toBeDefined(); + }, + 150_000, + ); +}); diff --git a/e2e/src/restart.spec.ts b/e2e/src/restart.spec.ts index 57ab3e1a0..9f828bf05 100644 --- a/e2e/src/restart.spec.ts +++ b/e2e/src/restart.spec.ts @@ -1,53 +1,73 @@ -import {describe, expect, it} from "@jest/globals"; +import { describe, expect, it } from "@jest/globals"; import { - getEvents, execDockerCommand, waitForEvents, getMessageSentEventFromLogs, sendMessage, - sendTransactionsToGenerateTrafficWithInterval, -} from "./utils/utils"; -import {getAndIncreaseFeeData} from "./utils/helpers"; -import {Wallet, ethers} from "ethers"; - -const coordinatorRestartTestSuite = (title: string) => { - describe(title, () => { - it("When the coordinator restarts it should resume blob submission and finalization", async () => { - const l2AccountForLiveness = new Wallet(L2_ACCOUNT_1_PRIVATE_KEY, l2Provider); - - console.log("Moving the L2 chain forward to trigger conflation..."); - const intervalId = await sendTransactionsToGenerateTrafficWithInterval(l2AccountForLiveness); - + etherToWei, + wait, +} from "./common/utils"; +import { config } from "./config/tests-config"; + +let testsWaitingForRestart = 0; +const TOTAL_TESTS_WAITING = 2; +let coordinatorHasRestarted = false; + +async function waitForCoordinatorRestart() { + testsWaitingForRestart += 1; + while (testsWaitingForRestart < TOTAL_TESTS_WAITING) { + console.log("Both tests have reached the restart point. Restarting coordinator..."); + await wait(1_000); + if (!coordinatorHasRestarted) { + coordinatorHasRestarted = true; + try { + await execDockerCommand("restart", "coordinator"); + console.log("Coordinator restarted."); + return; + } catch (error) { + console.error("Failed to restart coordinator:", error); + throw error; + } + } + } +} + +describe("Coordinator restart test suite", () => { + it.concurrent( + "When the coordinator restarts it should resume blob submission and finalization", + async () => { + if (process.env.TEST_ENV !== "local") { + console.log("Skipping test because it's not running on a local environment."); + return; + } + const lineaRollup = config.getLineaRollupContract(); + const l1Provider = config.getL1Provider(); // await for a finalization to happen on L1 - await Promise.all([ + const [dataSubmittedEventsBeforeRestart, dataFinalizedEventsBeforeRestart] = await Promise.all([ waitForEvents(lineaRollup, lineaRollup.filters.DataSubmittedV2(), 0, "latest"), waitForEvents(lineaRollup, lineaRollup.filters.DataFinalized(), 0, "latest"), ]); - await execDockerCommand("stop", "coordinator"); - - const currentBlockNumberBeforeRestart = await l1Provider.getBlockNumber(); - const [dataSubmittedEventsBeforeRestart, dataFinalizedEventsBeforeRestart] = await Promise.all([ - getEvents(lineaRollup, lineaRollup.filters.DataSubmittedV2(), 0, currentBlockNumberBeforeRestart), - getEvents(lineaRollup, lineaRollup.filters.DataFinalized(), 0, currentBlockNumberBeforeRestart), - ]); - const lastDataSubmittedEventBeforeRestart = dataSubmittedEventsBeforeRestart.slice(-1)[0]; const lastDataFinalizedEventsBeforeRestart = dataFinalizedEventsBeforeRestart.slice(-1)[0]; // Just some sanity checks // Check that the coordinator has submitted and finalized data before the restart - expect(lastDataSubmittedEventBeforeRestart.args.endBlock.toNumber()).toBeGreaterThan(0) - expect(lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized.toNumber()).toBeGreaterThan(0) + expect(lastDataSubmittedEventBeforeRestart.args.endBlock).toBeGreaterThan(0n); + expect(lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized).toBeGreaterThan(0n); + + await waitForCoordinatorRestart(); - await execDockerCommand("start", "coordinator"); const currentBlockNumberAfterRestart = await l1Provider.getBlockNumber(); console.log("Waiting for DataSubmittedV2 event after coordinator restart..."); const [dataSubmittedV2EventAfterRestart] = await waitForEvents( lineaRollup, - lineaRollup.filters.DataSubmittedV2(null, lastDataSubmittedEventBeforeRestart.args.endBlock.add(1)), + lineaRollup.filters.DataSubmittedV2(), 1_000, currentBlockNumberAfterRestart, + "latest", + async (events) => + events.filter((event) => event.args.startBlock > lastDataSubmittedEventBeforeRestart.args.endBlock), ); console.log(`New DataSubmittedV2 event found: event=${JSON.stringify(dataSubmittedV2EventAfterRestart)}`); @@ -58,37 +78,48 @@ const coordinatorRestartTestSuite = (title: string) => { 1_000, currentBlockNumberAfterRestart, "latest", - async (events) => { - return events.filter((event) => - event.args.lastBlockFinalized.gt(lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized), - ); - }, + async (events) => + events.filter( + (event) => event.args.lastBlockFinalized > lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized, + ), ); console.log(`New DataFinalized event found: event=${JSON.stringify(dataFinalizedEventAfterRestart)}`); - clearInterval(intervalId) - expect(dataFinalizedEventAfterRestart.args.lastBlockFinalized.toNumber()).toBeGreaterThan( - lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized.toNumber(), + expect(dataFinalizedEventAfterRestart.args.lastBlockFinalized).toBeGreaterThan( + lastDataFinalizedEventsBeforeRestart.args.lastBlockFinalized, ); - }, 300_000); + }, + 150_000, + ); + + it.concurrent( + "When the coordinator restarts it should resume anchoring", + async () => { + if (process.env.TEST_ENV !== "local") { + console.log("Skipping test because it's not running on a local environment."); + return; + } + + const l1Provider = config.getL1Provider(); + const l1MessageSender = await config.getL1AccountManager().generateAccount(); - it("When the coordinator restarts it should resume anchoring", async () => { - const l1MessageSender = new Wallet(L1_ACCOUNT_0_PRIVATE_KEY, l1Provider); - const l2AccountForLiveness = new Wallet(L2_ACCOUNT_1_PRIVATE_KEY, l2Provider); + const lineaRollup = config.getLineaRollupContract(); + const l2MessageService = config.getL2MessageServiceContract(); // Send Messages L1 -> L2 - const messageFee = ethers.utils.parseEther("0.0001"); - const messageValue = ethers.utils.parseEther("0.0051"); + const messageFee = etherToWei("0.0001"); + const messageValue = etherToWei("0.0051"); const destinationAddress = "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; const l1MessagesPromises = []; let l1MessageSenderNonce = await l1Provider.getTransactionCount(l1MessageSender.address); - const l1Fees = getAndIncreaseFeeData(await l1Provider.getFeeData()); + const { maxPriorityFeePerGas, maxFeePerGas } = await l1Provider.getFeeData(); for (let i = 0; i < 5; i++) { l1MessagesPromises.push( sendMessage( - lineaRollup.connect(l1MessageSender), + l1MessageSender, + lineaRollup, { to: destinationAddress, fee: messageFee, @@ -97,8 +128,8 @@ const coordinatorRestartTestSuite = (title: string) => { { value: messageValue, nonce: l1MessageSenderNonce, - maxPriorityFeePerGas: l1Fees[0], - maxFeePerGas: l1Fees[1], + maxPriorityFeePerGas, + maxFeePerGas, }, ), ); @@ -112,15 +143,26 @@ const coordinatorRestartTestSuite = (title: string) => { const lastNewL1MessageNumber = l1Messages.slice(-1)[0].messageNumber; console.log(`Waiting L1->L2 anchoring messageNumber=${lastNewL1MessageNumber}`); - await waitForEvents(l2MessageService, l2MessageService.filters.RollingHashUpdated(lastNewL1MessageNumber), 1_000); + await waitForEvents( + l2MessageService, + l2MessageService.filters.RollingHashUpdated(), + 1_000, + 0, + "latest", + async (events) => { + return events.filter((event) => event.args.messageNumber >= lastNewL1MessageNumber); + }, + ); // Restart Coordinator - await execDockerCommand("restart", "coordinator"); + await waitForCoordinatorRestart(); + const l1Fees = await l1Provider.getFeeData(); // Send more messages L1 -> L2 for (let i = 0; i < 5; i++) { l1MessagesPromises.push( sendMessage( + l1MessageSender, lineaRollup.connect(l1MessageSender), { to: destinationAddress, @@ -130,8 +172,8 @@ const coordinatorRestartTestSuite = (title: string) => { { value: messageValue, nonce: l1MessageSenderNonce, - maxPriorityFeePerGas: l1Fees[0], - maxFeePerGas: l1Fees[1], + maxPriorityFeePerGas: l1Fees.maxPriorityFeePerGas, + maxFeePerGas: l1Fees.maxFeePerGas, }, ), ); @@ -141,33 +183,31 @@ const coordinatorRestartTestSuite = (title: string) => { const l1ReceiptsAfterRestart = await Promise.all(l1MessagesPromises); const l1MessagesAfterRestart = getMessageSentEventFromLogs(lineaRollup, l1ReceiptsAfterRestart); - console.log("Moving the L2 chain forward to trigger anchoring..."); - // Using 5 messages to give the coordinator time to restart - const intervalId = await sendTransactionsToGenerateTrafficWithInterval(l2AccountForLiveness); - // Wait for messages to be anchored on L2 const lastNewL1MessageNumberAfterRestart = l1MessagesAfterRestart.slice(-1)[0].messageNumber; console.log( - `Waiting L1->L2 anchoring after coordinator restart messageNumber=${lastNewL1MessageNumberAfterRestart}` + `Waiting L1->L2 anchoring after coordinator restart messageNumber=${lastNewL1MessageNumberAfterRestart}`, ); const [rollingHashUpdatedEventAfterRestart] = await waitForEvents( l2MessageService, l2MessageService.filters.RollingHashUpdated(lastNewL1MessageNumberAfterRestart), 1_000, + 0, + "latest", + async (events) => { + return events.filter((event) => event.args.messageNumber >= lastNewL1MessageNumberAfterRestart); + }, ); const [lastNewMessageRollingHashAfterRestart, lastAnchoredL1MessageNumberAfterRestart] = await Promise.all([ - lineaRollup.rollingHashes(lastNewL1MessageNumberAfterRestart), + lineaRollup.rollingHashes(rollingHashUpdatedEventAfterRestart.args.messageNumber), l2MessageService.lastAnchoredL1MessageNumber(), ]); - clearInterval(intervalId) - expect(lastNewMessageRollingHashAfterRestart).toEqual(rollingHashUpdatedEventAfterRestart.args.rollingHash); - expect(lastAnchoredL1MessageNumberAfterRestart).toEqual(lastNewL1MessageNumberAfterRestart); - }, 300_000); - }); -}; - -export default coordinatorRestartTestSuite; + expect(lastAnchoredL1MessageNumberAfterRestart).toEqual(rollingHashUpdatedEventAfterRestart.args.messageNumber); + }, + 150_000, + ); +}); diff --git a/e2e/src/submission-finalization.spec.ts b/e2e/src/submission-finalization.spec.ts index bac7888cd..2b100b64d 100644 --- a/e2e/src/submission-finalization.spec.ts +++ b/e2e/src/submission-finalization.spec.ts @@ -1,146 +1,125 @@ -import { beforeAll, describe, expect, it } from "@jest/globals"; -import { Wallet, ethers } from "ethers"; -import { OPERATOR_ROLE, ROLLING_HASH_UPDATED_EVENT_SIGNATURE, VERIFIER_SETTER_ROLE } from "./utils/constants"; -import { getAndIncreaseFeeData } from "./utils/helpers"; -import { MessageEvent } from "./utils/types"; -import { getMessageSentEventFromLogs, sendMessage, sendTransactionsWithInterval, waitForEvents, wait, getBlockByNumberOrBlockTag } from "./utils/utils"; - -const submissionAndFinalizationTestSuite = (title: string) => { - describe(title, () => { - let securityCouncil: Wallet; - let l1Messages: MessageEvent[]; - let l2Messages: MessageEvent[]; - - beforeAll(async () => { - // Deploy new contracts implementation and grant roles - securityCouncil = new Wallet(SECURITY_COUNCIL_PRIVATE_KEY, l1Provider); - const securityCouncilNonce = await securityCouncil.getTransactionCount(); - - const rolesTransactions = await Promise.all([ - lineaRollup - .connect(securityCouncil) - .grantRole(OPERATOR_ROLE, OPERATOR_1_ADDRESS, { nonce: securityCouncilNonce }), - lineaRollup - .connect(securityCouncil) - .grantRole(VERIFIER_SETTER_ROLE, securityCouncil.address, { nonce: securityCouncilNonce + 1 }), - ]); +import { describe, expect, it } from "@jest/globals"; +import { JsonRpcProvider } from "ethers"; +import { + getMessageSentEventFromLogs, + sendMessage, + waitForEvents, + wait, + getBlockByNumberOrBlockTag, + etherToWei, +} from "./common/utils"; +import { config } from "./config/tests-config"; +import { LineaRollup } from "./typechain"; + +describe("Submission and finalization test suite", () => { + let l1Provider: JsonRpcProvider; + + beforeAll(() => { + l1Provider = config.getL1Provider(); + }); - await Promise.all(rolesTransactions.map((tx) => tx.wait())); - }); - - it("Send messages on L1 and L2", async () => { - const messageFee = ethers.utils.parseEther("0.0001"); - const messageValue = ethers.utils.parseEther("0.0051"); - const destinationAddress = "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; - - const l1MessageSender = new Wallet(L1_ACCOUNT_0_PRIVATE_KEY, l1Provider); - const l2MessageSender = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - - console.log("Sending messages on L1 and L2..."); - - // Send L1 messages - const l1MessagesPromises = []; - let l1MessageSenderNonce = await l1Provider.getTransactionCount(l1MessageSender.address); - const l1Fees = getAndIncreaseFeeData(await l1Provider.getFeeData()); - - const l2MessagesPromises = []; - let l2MessageSenderNonce = await l2Provider.getTransactionCount(l2MessageSender.address); - const l2Fees = getAndIncreaseFeeData(await l2Provider.getFeeData()); - - for (let i = 0; i < 5; i++) { - l1MessagesPromises.push( - sendMessage( - lineaRollup.connect(l1MessageSender), - { - to: destinationAddress, - fee: messageFee, - calldata: "0x", - }, - { - value: messageValue, - nonce: l1MessageSenderNonce, - maxPriorityFeePerGas: l1Fees[0], - maxFeePerGas: l1Fees[1], - }, - ), - ); - l1MessageSenderNonce++; - - l2MessagesPromises.push( - sendMessage( - l2MessageService.connect(l2MessageSender), - { - to: destinationAddress, - fee: messageFee, - calldata: "0x", - }, - { - value: messageValue, - nonce: l2MessageSenderNonce, - maxPriorityFeePerGas: l2Fees[0], - maxFeePerGas: l2Fees[1], - }, - ), - ); - l2MessageSenderNonce++; - } + const sendMessages = async () => { + const messageFee = etherToWei("0.0001"); + const messageValue = etherToWei("0.0051"); + const destinationAddress = "0x8D97689C9818892B700e27F316cc3E41e17fBeb9"; + + const l1MessageSender = await config.getL1AccountManager().generateAccount(); + const lineaRollup = config.getLineaRollupContract(); + + console.log("Sending messages on L1"); + + // Send L1 messages + const l1MessagesPromises = []; + // eslint-disable-next-line prefer-const + let [l1MessageSenderNonce, { maxPriorityFeePerGas, maxFeePerGas }] = await Promise.all([ + l1Provider.getTransactionCount(l1MessageSender.address), + l1Provider.getFeeData(), + ]); + + for (let i = 0; i < 5; i++) { + l1MessagesPromises.push( + sendMessage( + l1MessageSender, + lineaRollup, + { + to: destinationAddress, + fee: messageFee, + calldata: "0x", + }, + { + value: messageValue, + nonce: l1MessageSenderNonce, + maxPriorityFeePerGas, + maxFeePerGas, + }, + ), + ); + l1MessageSenderNonce++; + } - const l1Receipts = await Promise.all(l1MessagesPromises); - const l2Receipts = await Promise.all(l2MessagesPromises); + const l1Receipts = await Promise.all(l1MessagesPromises); - console.log("Messages sent on L1 and L2."); + console.log("Messages sent on L1."); - // Check that L1 messages emit RollingHashUpdated events - expect(l1Receipts.length).toBeGreaterThan(0); + // Extract message events + const l1Messages = getMessageSentEventFromLogs(lineaRollup, l1Receipts); - const newL1MessagesRollingHashUpdatedLogs = l1Receipts - .flatMap((receipt) => receipt.logs) - .filter((log) => log.topics[0] === ROLLING_HASH_UPDATED_EVENT_SIGNATURE); + return { l1Messages, l1Receipts }; + }; + + async function getFinalizedL2BlockNumber(lineaRollup: LineaRollup) { + let blockNumber = null; + + while (!blockNumber) { + try { + blockNumber = await lineaRollup.currentL2BlockNumber({ blockTag: "finalized" }); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } catch (error: any) { + console.log("No finalized block yet, retrying in 5 seconds..."); + await new Promise((resolve) => setTimeout(resolve, 5_000)); + } + } - expect(newL1MessagesRollingHashUpdatedLogs).toHaveLength(l1Receipts.length); + return blockNumber; + } - // Check that there are L2 messages - expect(l2Receipts.length).toBeGreaterThan(0); + it.concurrent( + "Check L2 anchoring", + async () => { + const lineaRollup = config.getLineaRollupContract(); + const l2MessageService = config.getL2MessageServiceContract(); - l1Messages = getMessageSentEventFromLogs(lineaRollup, l1Receipts); - l2Messages = getMessageSentEventFromLogs(l2MessageService, l2Receipts); - }, 300_000); + const { l1Messages } = await sendMessages(); - it("Check L2 anchoring", async () => { // Wait for the last L1->L2 message to be anchored on L2 const lastNewL1MessageNumber = l1Messages.slice(-1)[0].messageNumber; console.log("Waiting for the anchoring using rolling hash..."); const [rollingHashUpdatedEvent] = await waitForEvents( l2MessageService, - l2MessageService.filters.RollingHashUpdated(lastNewL1MessageNumber), + l2MessageService.filters.RollingHashUpdated(), 1_000, + 0, + "latest", + async (events) => events.filter((event) => event.args.messageNumber >= lastNewL1MessageNumber), ); const [lastNewMessageRollingHash, lastAnchoredL1MessageNumber] = await Promise.all([ - lineaRollup.rollingHashes(lastNewL1MessageNumber), + lineaRollup.rollingHashes(rollingHashUpdatedEvent.args.messageNumber), l2MessageService.lastAnchoredL1MessageNumber(), ]); expect(lastNewMessageRollingHash).toEqual(rollingHashUpdatedEvent.args.rollingHash); - expect(lastAnchoredL1MessageNumber).toEqual(lastNewL1MessageNumber); + expect(lastAnchoredL1MessageNumber).toEqual(rollingHashUpdatedEvent.args.messageNumber); console.log("New anchoring using rolling hash done."); - }, 300_000); - - it("Check L1 data submission and finalization", async () => { - // Send transactions on L2 in the background to make the L2 chain moving forward - const l2MessageSender = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await l2Provider.getFeeData()); - const sendTransactionsPromise = sendTransactionsWithInterval( - l2MessageSender, - { - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - value: ethers.utils.parseEther("0.0001"), - maxPriorityFeePerGas, - maxFeePerGas, - }, - 5_000, - ); + }, + 150_000, + ); + + it.concurrent( + "Check L1 data submission and finalization", + async () => { + const lineaRollup = config.getLineaRollupContract(); const [currentL2BlockNumber, startingRootHash] = await Promise.all([ lineaRollup.currentL2BlockNumber(), @@ -149,13 +128,17 @@ const submissionAndFinalizationTestSuite = (title: string) => { console.log("Waiting for data submission used to finalize with proof..."); // Waiting for data submission starting from migration block number - await waitForEvents(lineaRollup, lineaRollup.filters.DataSubmittedV2(null, currentL2BlockNumber.add(1)), 1_000); + await waitForEvents( + lineaRollup, + lineaRollup.filters.DataSubmittedV2(undefined, currentL2BlockNumber + 1n), + 1_000, + ); console.log("Waiting for the first DataFinalized event with proof..."); // Waiting for first DataFinalized event with proof const [dataFinalizedEvent] = await waitForEvents( lineaRollup, - lineaRollup.filters.DataFinalized(null, startingRootHash), + lineaRollup.filters.DataFinalized(undefined, startingRootHash), 1_000, ); @@ -164,69 +147,47 @@ const submissionAndFinalizationTestSuite = (title: string) => { lineaRollup.stateRootHashes(dataFinalizedEvent.args.lastBlockFinalized), ]); - expect(lastBlockFinalized.toBigInt()).toBeGreaterThanOrEqual(dataFinalizedEvent.args.lastBlockFinalized.toBigInt()); + expect(lastBlockFinalized).toBeGreaterThanOrEqual(dataFinalizedEvent.args.lastBlockFinalized); expect(newStateRootHash).toEqual(dataFinalizedEvent.args.finalRootHash); expect(dataFinalizedEvent.args.withProof).toBeTruthy(); console.log("Finalization with proof done."); - - clearInterval(sendTransactionsPromise); - }, 300_000); - - it( "Check L2 safe/finalized tag update on sequencer", async () => { - if (SEQUENCER_ENDPOINT == null) { - console.log("Skipped the \"Check L2 safe/finalized tag update on sequencer\" test"); + }, + 150_000, + ); + + it.concurrent( + "Check L2 safe/finalized tag update on sequencer", + async () => { + const lineaRollup = config.getLineaRollupContract(); + const sequencerEndpoint = config.getSequencerEndpoint(); + if (!sequencerEndpoint) { + console.log('Skipped the "Check L2 safe/finalized tag update on sequencer" test'); return; } - const lastFinalizedL2BlockNumberOnL1 = (await lineaRollup.currentL2BlockNumber({ blockTag: "finalized" })).toNumber(); - console.log(`lastFinalizedL2BlockNumberOnL1=${lastFinalizedL2BlockNumberOnL1}`) - let safeL2BlockNumber = -1, finalizedL2BlockNumber = -1 - while (safeL2BlockNumber < lastFinalizedL2BlockNumberOnL1 || finalizedL2BlockNumber < lastFinalizedL2BlockNumberOnL1) { - safeL2BlockNumber = (await getBlockByNumberOrBlockTag(SEQUENCER_ENDPOINT, "safe")).number; - finalizedL2BlockNumber = (await getBlockByNumberOrBlockTag(SEQUENCER_ENDPOINT, "finalized")).number; + const lastFinalizedL2BlockNumberOnL1 = (await getFinalizedL2BlockNumber(lineaRollup)).toString(); + console.log(`lastFinalizedL2BlockNumberOnL1=${lastFinalizedL2BlockNumberOnL1}`); + + let safeL2BlockNumber = -1, + finalizedL2BlockNumber = -1; + while ( + safeL2BlockNumber < parseInt(lastFinalizedL2BlockNumberOnL1) || + finalizedL2BlockNumber < parseInt(lastFinalizedL2BlockNumberOnL1) + ) { + safeL2BlockNumber = (await getBlockByNumberOrBlockTag(sequencerEndpoint, "safe"))?.number || safeL2BlockNumber; + finalizedL2BlockNumber = + (await getBlockByNumberOrBlockTag(sequencerEndpoint, "finalized"))?.number || finalizedL2BlockNumber; await wait(1_000); } console.log(`safeL2BlockNumber=${safeL2BlockNumber} finalizedL2BlockNumber=${finalizedL2BlockNumber}`); - expect(safeL2BlockNumber).toBeGreaterThanOrEqual(lastFinalizedL2BlockNumberOnL1); - expect(finalizedL2BlockNumber).toBeGreaterThanOrEqual(lastFinalizedL2BlockNumberOnL1); + expect(safeL2BlockNumber).toBeGreaterThanOrEqual(parseInt(lastFinalizedL2BlockNumberOnL1)); + expect(finalizedL2BlockNumber).toBeGreaterThanOrEqual(parseInt(lastFinalizedL2BlockNumberOnL1)); console.log("L2 safe/finalized tag update on sequencer done."); - }, 300_000) - - it("Check L1 claiming", async () => { - // Send transactions on L2 in the background to make the L2 chain moving forward - const l2MessageSender = new Wallet(L2_ACCOUNT_0_PRIVATE_KEY, l2Provider); - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await l2Provider.getFeeData()); - const sendTransactionsPromise = sendTransactionsWithInterval( - l2MessageSender, - { - to: "0x8D97689C9818892B700e27F316cc3E41e17fBeb9", - value: ethers.utils.parseEther("0.0001"), - maxPriorityFeePerGas, - maxFeePerGas, - }, - 1_000, - ); - - const { messageHash, messageNumber, blockNumber } = l2Messages[0]; - - console.log(`Waiting for L2MessagingBlockAnchored... with blockNumber=${blockNumber}`); - await waitForEvents(lineaRollup, lineaRollup.filters.L2MessagingBlockAnchored(blockNumber), 1_000); - - console.log("L2MessagingBlockAnchored event found."); - - await waitForEvents(lineaRollup, lineaRollup.filters.MessageClaimed(messageHash), 1_000); - - expect(await lineaRollup.isMessageClaimed(messageNumber)).toBeTruthy(); - - console.log("L1 claiming done."); - - clearInterval(sendTransactionsPromise); - }, 400_000); - }); -}; - -export default submissionAndFinalizationTestSuite; + }, + 150_000, + ); +}); diff --git a/e2e/src/utils/constants.dev.ts b/e2e/src/utils/constants.dev.ts deleted file mode 100644 index 88438d8a3..000000000 --- a/e2e/src/utils/constants.dev.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { ethers } from "ethers"; -import * as dotenv from "dotenv"; -dotenv.config(); - -export const TRANSACTION_CALLDATA_LIMIT = 30000; -export const L1_RPC_URL = "https://l1-rpc.dev.zkevm.consensys.net/"; -export const L2_RPC_URL = "https://archive.dev.zkevm.consensys.net/"; -export const CHAIN_ID = 59139; - -export function getL1Provider() { - return new ethers.providers.JsonRpcProvider(L1_RPC_URL); -} - -export function getL2Provider() { - return new ethers.providers.JsonRpcProvider(L2_RPC_URL); -} - -export const DEPLOYER_ACCOUNT_PRIVATE_KEY = process.env.LOCAL_DEPLOYER_ACCOUNT_PRIVATE_KEY ?? ""; - -export const INITIAL_WITHDRAW_LIMIT = ethers.utils.parseEther("5"); - -export const ACCOUNT_0 = "0xc8c92fe825d8930b9357c006e0af160dfa727a62"; -export const ACCOUNT_0_PRIVATE_KEY = process.env.LOCAL_ACCOUNT_0_PRIVATE_KEY ?? ""; -export const ACCOUNT_1 = ""; - -export const OPERATOR_0 = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"; -export const OPERATOR_0_PRIVATE_KEY = process.env.LOCAL_OPERATOR_0_PRIVATE_KEY ?? ""; - -export const LINEA_ROLLUP_CONTRACT_ADDRESS = "0xFE63fc3C8898F83B1c5F199133f89bDBA88B1C37"; -export const LINEA_ROLLUP_INITIAL_STATE_ROOT_HASH = - "0x0000000000000000000000000000000000000000000000000000000000000000"; -export const LINEA_ROLLUP_INITIAL_L2_BLOCK_NR = "123456"; -export const LINEA_ROLLUP_SECURITY_COUNCIL = OPERATOR_0; -export const LINEA_ROLLUP_OPERATORS = [OPERATOR_0]; -export const LINEA_ROLLUP_RATE_LIMIT_PERIOD = "86400"; //24Hours in seconds -export const LINEA_ROLLUP_RATE_LIMIT_AMOUNT = "1000000000000000000000"; //1000ETH - -export const TRANSACTION_DECODER_ADDRESS = ""; -export const PLONK_VERIFIER_ADDRESS = ""; -export const MESSAGE_SERVICE_ADDRESS = "0xa2d2C55e9B7054d9C4EA075Df35935BeA1693e27"; -export const DUMMY_CONTRACT_ADDRESS = ""; - -export const SHOMEI_ENDPOINT = null; -export const SHOMEI_FRONTEND_ENDPOINT = null; diff --git a/e2e/src/utils/constants.local.ts b/e2e/src/utils/constants.local.ts deleted file mode 100644 index 1f140e593..000000000 --- a/e2e/src/utils/constants.local.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { ethers } from "ethers"; -import * as dotenv from "dotenv"; -dotenv.config(); - -export const TRANSACTION_CALLDATA_LIMIT = 30000; -export const L1_RPC_URL = "http://localhost:8445"; -export const L2_RPC_URL = "http://localhost:8845"; -export const CHAIN_ID = 1337; - -export function getL1Provider() { - return new ethers.providers.JsonRpcProvider(L1_RPC_URL); -} - -export function getL2Provider() { - return new ethers.providers.JsonRpcProvider(L2_RPC_URL); -} - -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const L1_DEPLOYER_ACCOUNT_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"; -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const L2_DEPLOYER_ACCOUNT_PRIVATE_KEY = "0x1dd171cec7e2995408b5513004e8207fe88d6820aeff0d82463b3e41df251aae"; - -export const INITIAL_WITHDRAW_LIMIT = ethers.utils.parseEther("5"); - -export const L1_ACCOUNT_0 = "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65"; -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const L1_ACCOUNT_0_PRIVATE_KEY = "0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a"; - -export const L2_ACCOUNT_0 = "0xfe3b557e8fb62b89f4916b721be55ceb828dbd73"; -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const L2_ACCOUNT_0_PRIVATE_KEY = "0x8f2a55949038a9610f50fb23b5883af3b4ecb3c3bb792cbcefbd1542c692be63"; -export const L2_ACCOUNT_1_PRIVATE_KEY = "0xc87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3"; - -export const OPERATOR_0 = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"; -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const OPERATOR_0_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"; - -export const OPERATOR_1 = "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC"; -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const OPERATOR_1_PRIVATE_KEY = "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a"; - -// WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE -export const SECURITY_COUNCIL_PRIVATE_KEY = "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6"; - -export const LINEA_ROLLUP_INITIAL_STATE_ROOT_HASH = - "0x0000000000000000000000000000000000000000000000000000000000000000"; -export const LINEA_ROLLUP_INITIAL_L2_BLOCK_NR = "123456"; -export const LINEA_ROLLUP_SECURITY_COUNCIL = OPERATOR_0; -export const LINEA_ROLLUP_OPERATORS = [OPERATOR_0]; -export const LINEA_ROLLUP_RATE_LIMIT_PERIOD = "86400"; //24Hours in seconds -export const LINEA_ROLLUP_RATE_LIMIT_AMOUNT = "1000000000000000000000"; //1000ETH - -export const LINEA_ROLLUP_CONTRACT_ADDRESS = "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9"; -export const MESSAGE_SERVICE_ADDRESS = "0xe537D669CA013d86EBeF1D64e40fC74CADC91987"; - -export const SHOMEI_ENDPOINT = new URL("http://localhost:8998"); -export const SHOMEI_FRONTEND_ENDPOINT = new URL("http://localhost:8889"); -export const SEQUENCER_ENDPOINT = new URL("http://localhost:8545") - -export const CONTRACT_GAS_OPTIMIZATION_SWITCH_BLOCK = 12; diff --git a/e2e/src/utils/constants.uat.ts b/e2e/src/utils/constants.uat.ts deleted file mode 100644 index bf45cbd67..000000000 --- a/e2e/src/utils/constants.uat.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { ethers } from "ethers"; -import * as dotenv from "dotenv"; -dotenv.config(); - -export const TRANSACTION_CALLDATA_LIMIT = 59000; -export const L1_RPC_URL = "https://goerli.infura.io/v3/" + process.env.UAT_L1_RPC_KEY; -export const L2_RPC_URL = "https://linea-goerli.infura.io/v3/" + process.env.UAT_L2_RPC_KEY; -export const CHAIN_ID = 59140; - -export function getL1Provider() { - return new ethers.providers.JsonRpcProvider(L1_RPC_URL); -} - -export function getL2Provider() { - return new ethers.providers.JsonRpcProvider(L2_RPC_URL); -} - -export const DEPLOYER_ACCOUNT_PRIVATE_KEY = process.env.UAT_DEPLOYER_ACCOUNT_PRIVATE_KEY ?? ""; - -export const INITIAL_WITHDRAW_LIMIT = ethers.utils.parseEther("5"); - -export const ACCOUNT_0 = "0x174634fbF3d3e243543c6F22102837A113DF9005"; -export const ACCOUNT_0_PRIVATE_KEY = process.env.UAT_ACCOUNT_0_PRIVATE_KEY ?? ""; - -export const ACCOUNT_1 = ""; - -export const OPERATOR_0 = "0xA2689249FAeAf6D84b6087A2970a20432b86A53e"; - -export const LINEA_ROLLUP_INITIAL_STATE_ROOT_HASH = - "0x0000000000000000000000000000000000000000000000000000000000000000"; -export const LINEA_ROLLUP_INITIAL_L2_BLOCK_NR = "123456"; -export const LINEA_ROLLUP_SECURITY_COUNCIL = OPERATOR_0; -export const LINEA_ROLLUP_OPERATORS = [OPERATOR_0]; -export const LINEA_ROLLUP_RATE_LIMIT_PERIOD = "86400"; //24Hours in seconds -export const LINEA_ROLLUP_RATE_LIMIT_AMOUNT = "1000000000000000000000"; //1000ETH - -export const LINEA_ROLLUP_CONTRACT_ADDRESS = "0x70BaD09280FD342D02fe64119779BC1f0791BAC2"; -export const MESSAGE_SERVICE_ADDRESS = "0xC499a572640B64eA1C8c194c43Bc3E19940719dC"; -export const DUMMY_CONTRACT_ADDRESS = "0x91614d09f5A8c87E28ab79D5eC48164DA0988319"; -export const L1_DUMMY_CONTRACT_ADDRESS = "0x75b33806dCdb0fC7BB06fd1121a3358a88EdC5E9"; - -export const SHOMEI_ENDPOINT = null; -export const SHOMEI_FRONTEND_ENDPOINT = null; diff --git a/e2e/src/utils/helpers.ts b/e2e/src/utils/helpers.ts deleted file mode 100644 index ba78d6fa7..000000000 --- a/e2e/src/utils/helpers.ts +++ /dev/null @@ -1,9 +0,0 @@ -/* eslint-disable @typescript-eslint/no-non-null-assertion */ -import { BigNumber, ethers } from "ethers"; - -export function getAndIncreaseFeeData(feeData: ethers.providers.FeeData): [BigNumber, BigNumber, BigNumber] { - const maxPriorityFeePerGas = BigNumber.from((parseFloat(feeData.maxPriorityFeePerGas!.toString()) * 1.1).toFixed(0)); - const maxFeePerGas = BigNumber.from((parseFloat(feeData.maxFeePerGas!.toString()) * 1.1).toFixed(0)); - const gasPrice = BigNumber.from((parseFloat(feeData.gasPrice!.toString()) * 1.1).toFixed(0)); - return [maxPriorityFeePerGas, maxFeePerGas, gasPrice]; -} diff --git a/e2e/src/utils/utils.ts b/e2e/src/utils/utils.ts deleted file mode 100644 index 189547c6b..000000000 --- a/e2e/src/utils/utils.ts +++ /dev/null @@ -1,288 +0,0 @@ -import { BlockTag } from "@ethersproject/providers"; -import * as fs from "fs"; -import assert from "assert"; -import {Contract, ContractReceipt, PayableOverrides, Wallet, ethers} from "ethers"; -import path from "path"; -import { exec } from "child_process"; -import { L2MessageService, LineaRollup } from "../typechain"; -import { TypedEvent, TypedEventFilter } from "../typechain/common"; -import { MessageEvent, SendMessageArgs } from "./types"; -import { getAndIncreaseFeeData } from "./helpers"; - -export const wait = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout)); - -export function increaseDate(currentDate: Date, seconds: number): Date { - const newDate = new Date(currentDate.getTime()); - newDate.setSeconds(newDate.getSeconds() + seconds); - return newDate; -} - -export const subtractSecondsToDate = (date: Date, seconds: number): Date => { - const dateCopy = new Date(date); - dateCopy.setSeconds(date.getSeconds() - seconds); - return dateCopy; -}; - -export function getWallet(privateKey: string, provider: ethers.providers.JsonRpcProvider) { - return new ethers.Wallet(privateKey, provider); -} - -export function encodeFunctionCall(contractInterface: ethers.utils.Interface, functionName: string, args: unknown[]) { - return contractInterface.encodeFunctionData(functionName, args); -} - -export const generateKeccak256 = (types: string[], values: unknown[], packed?: boolean) => - ethers.utils.keccak256(encodeData(types, values, packed)); - -export const encodeData = (types: string[], values: unknown[], packed?: boolean) => { - if (packed) { - return ethers.utils.solidityPack(types, values); - } - return ethers.utils.defaultAbiCoder.encode(types, values); -}; - -export class RollupGetZkEVMBlockNumberClient { - private endpoint: URL; - private request = { - method: "post", - body: JSON.stringify({ - jsonrpc: "2.0", - method: "rollup_getZkEVMBlockNumber", - params: [], - id: 1, - }), - }; - - public constructor(endpoint: URL) { - this.endpoint = endpoint; - } - - public async rollupGetZkEVMBlockNumber(): Promise { - const response = await fetch(this.endpoint, this.request); - const data = await response.json(); - assert("result" in data); - return Number.parseInt(data.result); - } -} - -export async function getBlockByNumberOrBlockTag( - rpcUrl: URL, - blockTag: BlockTag -): Promise { - const provider = new ethers.providers.JsonRpcProvider(rpcUrl.href); - return provider.getBlock(blockTag) -} - -export async function getEvents( - contract: TContract, - eventFilter: TypedEventFilter, - fromBlock?: BlockTag, - toBlock?: BlockTag, - criteria?: (events: TEvent[]) => Promise, -): Promise> { - const events = await contract.queryFilter(eventFilter, fromBlock, toBlock); - - if (criteria) { - return await criteria(events); - } - - return events; -} - -export async function waitForEvents( - contract: TContract, - eventFilter: TypedEventFilter, - pollingInterval: number = 500, - fromBlock?: BlockTag, - toBlock?: BlockTag, - criteria?: (events: TEvent[]) => Promise, -): Promise { - let events = await getEvents(contract, eventFilter, fromBlock, toBlock, criteria); - - while (events.length === 0) { - events = await getEvents(contract, eventFilter, fromBlock, toBlock, criteria); - await wait(pollingInterval); - } - - return events; -} - -export function getFiles(directory: string, fileRegex: RegExp[]): string[] { - const files = fs.readdirSync(directory, { withFileTypes: true }); - const filteredFiles = files.filter((file) => fileRegex.map((regex) => regex.test(file.name)).includes(true)); - return filteredFiles.map((file) => fs.readFileSync(path.join(directory, file.name), "utf-8")); -} - -export async function waitForFile( - directory: string, - regex: RegExp, - pollingInterval: number, - timeout: number, - criteria?: (fileName: string) => boolean, -): Promise { - return new Promise((resolve, reject) => { - const interval = setInterval(() => { - fs.readdir(directory, (err, files) => { - if (err) { - clearInterval(interval); - clearTimeout(timeoutId); - reject(new Error(`Error reading directory: ${err}`)); - return; - } - - for (const file of files) { - if (regex.test(file) && (!criteria || criteria(file))) { - clearInterval(interval); - clearTimeout(timeoutId); - resolve(fs.readFileSync(path.join(directory, file), "utf-8")); - return; - } - } - }); - }, pollingInterval); - - const timeoutId = setTimeout(() => { - clearInterval(interval); - reject(new Error("File check timed out")); - }, timeout); - }); -} - -export function sendTransactionsWithInterval( - signer: Wallet, - transactionRequest: ethers.providers.TransactionRequest, - pollingInterval: number, -) { - return setInterval(async function () { - const tx = await signer.sendTransaction(transactionRequest); - await tx.wait(); - }, pollingInterval); -} - -export async function sendXTransactions( - signer: Wallet, - transactionRequest: ethers.providers.TransactionRequest, - numberOfTransactions: number, -) { - for (let i = 0; i < numberOfTransactions; i++) { - const tx = await signer.sendTransaction(transactionRequest); - await tx.wait(); - } -} - -export async function sendTransactionsToGenerateTrafficWithInterval( - signer: Wallet, - pollingInterval: number = 1000, -) { - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await signer.provider.getFeeData()); - const transactionRequest = { - to: signer.address, - value: ethers.utils.parseEther("0.000001"), - maxPriorityFeePerGas: maxPriorityFeePerGas, - maxFeePerGas: maxFeePerGas, - } - - return setInterval(async function () { - const tx = await signer.sendTransaction(transactionRequest); - await tx.wait(); - }, pollingInterval); -} - -export function getMessageSentEventFromLogs( - contract: T, - receipts: ContractReceipt[], -): MessageEvent[] { - return receipts - .flatMap((receipt) => receipt.logs) - .filter((log) => log.topics[0] === "0xe856c2b8bd4eb0027ce32eeaf595c21b0b6b4644b326e5b7bd80a1cf8db72e6c") - .map((log) => { - const { args } = contract.interface.parseLog(log); - - return { - from: args._from, - to: args._to, - fee: args._fee, - value: args._value, - messageNumber: args._nonce, - calldata: args._calldata, - messageHash: args._messageHash, - blockNumber: log.blockNumber, - }; - }); -} - -export async function waitForMessageAnchoring( - contract: L2MessageService, - messageHash: string, - pollingInterval: number, -) { - let messageStatus = await contract.inboxL1L2MessageStatus(messageHash); - while (messageStatus.toNumber() === 0) { - messageStatus = await contract.inboxL1L2MessageStatus(messageHash); - await wait(pollingInterval); - } -} - -export const sendMessage = async ( - contract: T, - args: SendMessageArgs, - overrides?: PayableOverrides, -): Promise => { - const tx = await contract.sendMessage(args.to, args.fee, args.calldata, overrides); - return await tx.wait(); -}; - -export const sendMessagesForNSeconds = async ( - provider: ethers.providers.JsonRpcProvider, - signer: Wallet, - contract: T, - duration: number, - args: SendMessageArgs, - overrides?: PayableOverrides, -): Promise => { - let nonce = await provider.getTransactionCount(signer.address); - - const currentDate = new Date(); - const endDate = increaseDate(currentDate, duration); - - const sendMessagePromises: Promise[] = []; - let currentTime = new Date().getTime(); - - const [maxPriorityFeePerGas, maxFeePerGas] = getAndIncreaseFeeData(await provider.getFeeData()); - while (currentTime < endDate.getTime()) { - sendMessagePromises.push( - sendMessage(contract.connect(signer), args, { - ...overrides, - maxPriorityFeePerGas, - maxFeePerGas, - nonce, - }).catch(() => { - return null; - }), - ); - nonce++; - - if (sendMessagePromises.length % 10 === 0) { - await wait(10_000); - } - currentTime = new Date().getTime(); - } - - const result = (await Promise.all(sendMessagePromises)).filter((receipt) => receipt !== null) as ContractReceipt[]; - return result; -}; - -export async function execDockerCommand(command: string, containerName: string): Promise { - const dockerCommand = `docker ${command} ${containerName}`; - console.log(`Executing: ${dockerCommand}...`); - return new Promise((resolve, reject) => { - exec(dockerCommand, (error, stdout, stderr) => { - if (error) { - console.error(`Error executing (${dockerCommand}): ${stderr}`); - reject(error); - } - console.log(`Execution success (${dockerCommand}): ${stdout}`); - resolve(stdout); - }); - }); -} diff --git a/e2e/tsconfig.json b/e2e/tsconfig.json index 2def2bf82..be4ae3d27 100644 --- a/e2e/tsconfig.json +++ b/e2e/tsconfig.json @@ -12,7 +12,6 @@ "isolatedModules": true, "noFallthroughCasesInSwitch": true, "strictPropertyInitialization": false, - "typeRoots": ["./env-setup/custom.d.ts"], }, "references": [ { diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 1480763e2..14547a864 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -52,13 +52,13 @@ importers: version: 5.59.3(react@18.3.1) '@wagmi/connectors': specifier: 5.1.15 - version: 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) + version: 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) '@wagmi/core': specifier: 2.13.8 version: 2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)) '@web3modal/wagmi': specifier: 5.1.11 - version: 5.1.11(@types/react@18.3.11)(@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4)) + version: 5.1.11(@types/react@18.3.11)(@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4)) clsx: specifier: ^2.1.1 version: 2.1.1 @@ -79,10 +79,10 @@ importers: version: 1.9.2 next: specifier: 14.2.15 - version: 14.2.15(@babel/core@7.25.2)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + version: 14.2.15(@babel/core@7.25.7)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) next-seo: specifier: 6.6.0 - version: 6.6.0(next@14.2.15(@babel/core@7.25.2)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + version: 6.6.0(next@14.2.15(@babel/core@7.25.7)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1) pino-pretty: specifier: 11.2.2 version: 11.2.2 @@ -118,7 +118,7 @@ importers: version: 2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4) wagmi: specifier: 2.12.17 - version: 2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) + version: 2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) zustand: specifier: 4.5.4 version: 4.5.4(@types/react@18.3.11)(react@18.3.1) @@ -179,7 +179,7 @@ importers: version: 1.0.10(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)) '@nomicfoundation/hardhat-toolbox': specifier: 4.0.0 - version: 4.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.8(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.10(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@1.1.1(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5)))(@types/chai@4.3.20)(@types/mocha@10.0.8)(@types/node@20.12.7)(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(solidity-coverage@0.8.13(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5) + version: 4.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.8(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.10(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@1.1.1(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5)))(@types/chai@4.3.20)(@types/mocha@10.0.9)(@types/node@20.12.7)(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(solidity-coverage@0.8.13(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5) '@nomicfoundation/hardhat-verify': specifier: 1.1.1 version: 1.1.1(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)) @@ -255,21 +255,18 @@ importers: e2e: devDependencies: - '@ethersproject/providers': - specifier: 5.7.2 - version: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@jest/globals': specifier: 29.7.0 version: 29.7.0 '@openzeppelin/upgrades-core': specifier: 1.33.1 version: 1.33.1 - '@typechain/ethers-v5': - specifier: 11.1.2 - version: 11.1.2(@ethersproject/abi@5.7.0)(@ethersproject/providers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5) + '@typechain/ethers-v6': + specifier: 0.5.1 + version: 0.5.1(ethers@6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5) '@types/jest': - specifier: 29.5.12 - version: 29.5.12 + specifier: 29.5.13 + version: 29.5.13 child_process: specifier: 1.0.2 version: 1.0.2 @@ -277,17 +274,14 @@ importers: specifier: 16.4.5 version: 16.4.5 ethers: - specifier: 5.7.2 - version: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + specifier: 6.13.3 + version: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) jest: specifier: 29.7.0 version: 29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)) - testcontainers: - specifier: 10.9.0 - version: 10.9.0(encoding@0.1.13) ts-jest: - specifier: 29.1.2 - version: 29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) + specifier: 29.2.5 + version: 29.2.5(@babel/core@7.25.7)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) typechain: specifier: 8.3.2 version: 8.3.2(typescript@5.4.5) @@ -330,7 +324,7 @@ importers: version: 0.3.4 ts-jest: specifier: 29.2.5 - version: 29.2.5(@babel/core@7.25.2)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) + version: 29.2.5(@babel/core@7.25.7)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) sdk: dependencies: @@ -385,7 +379,7 @@ importers: version: 3.0.5(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) ts-jest: specifier: 29.1.2 - version: 29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) + version: 29.1.2(@babel/core@7.25.7)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) typechain: specifier: 8.3.2 version: 8.3.2(typescript@5.4.5) @@ -425,7 +419,7 @@ importers: version: 16.4.5 ethers: specifier: ^6.13.1 - version: 6.13.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) jest: specifier: ^29.7.0 version: 29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)) @@ -437,7 +431,7 @@ importers: version: 3.3.2 ts-jest: specifier: ^29.1.5 - version: 29.2.5(@babel/core@7.25.2)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) + version: 29.2.5(@babel/core@7.25.7)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5) unzipper: specifier: ^0.12.1 version: 0.12.3 @@ -467,49 +461,49 @@ packages: '@aws-crypto/util@1.2.2': resolution: {integrity: sha512-H8PjG5WJ4wz0UXAFXeJjWCW1vkvIJ3qUUD+rGRwJ2/hj+xT58Qle2MTql/2MGzkU+1JLAFuR6aJpLAjHwhmwwg==} - '@aws-sdk/types@3.654.0': - resolution: {integrity: sha512-VWvbED3SV+10QJIcmU/PKjsKilsTV16d1I7/on4bvD/jo1qGeMXqLDBSen3ks/tuvXZF/mFc7ZW/W2DiLVtO7A==} + '@aws-sdk/types@3.664.0': + resolution: {integrity: sha512-+GtXktvVgpreM2b+NJL9OqZGsOzHwlCUrO8jgQUvH/yA6Kd8QO2YFhQCp0C9sSzTteZJVqGBu8E0CQurxJHPbw==} engines: {node: '>=16.0.0'} '@aws-sdk/util-utf8-browser@3.259.0': resolution: {integrity: sha512-UvFa/vR+e19XookZF8RzFZBrw2EUkQWxiBW0yYQAhvk3C+QVGl0H3ouca8LDBlBfQKXwmW3huo/59H8rwb1wJw==} - '@babel/code-frame@7.24.7': - resolution: {integrity: sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==} + '@babel/code-frame@7.25.7': + resolution: {integrity: sha512-0xZJFNE5XMpENsgfHYTw8FbX4kv53mFLn2i3XPoq69LyhYSCBJtitaHx9QnsVTrsogI4Z3+HtEfZ2/GFPOtf5g==} engines: {node: '>=6.9.0'} - '@babel/compat-data@7.25.4': - resolution: {integrity: sha512-+LGRog6RAsCJrrrg/IO6LGmpphNe5DiK30dGjCoxxeGv49B10/3XYGxPsAwrDlMFcFEvdAUavDT8r9k/hSyQqQ==} + '@babel/compat-data@7.25.7': + resolution: {integrity: sha512-9ickoLz+hcXCeh7jrcin+/SLWm+GkxE2kTvoYyp38p4WkdFXfQJxDFGWp/YHjiKLPx06z2A7W8XKuqbReXDzsw==} engines: {node: '>=6.9.0'} - '@babel/core@7.25.2': - resolution: {integrity: sha512-BBt3opiCOxUr9euZ5/ro/Xv8/V7yJ5bjYMqG/C1YAo8MIKAnumZalCN+msbci3Pigy4lIQfPUpfMM27HMGaYEA==} + '@babel/core@7.25.7': + resolution: {integrity: sha512-yJ474Zv3cwiSOO9nXJuqzvwEeM+chDuQ8GJirw+pZ91sCGCyOZ3dJkVE09fTV0VEVzXyLWhh3G/AolYTPX7Mow==} engines: {node: '>=6.9.0'} - '@babel/generator@7.25.6': - resolution: {integrity: sha512-VPC82gr1seXOpkjAAKoLhP50vx4vGNlF4msF64dSFq1P8RfB+QAuJWGHPXXPc8QyfVWwwB/TNNU4+ayZmHNbZw==} + '@babel/generator@7.25.7': + resolution: {integrity: sha512-5Dqpl5fyV9pIAD62yK9P7fcA768uVPUyrQmqpqstHWgMma4feF1x/oFysBCVZLY5wJ2GkMUCdsNDnGZrPoR6rA==} engines: {node: '>=6.9.0'} - '@babel/helper-annotate-as-pure@7.24.7': - resolution: {integrity: sha512-BaDeOonYvhdKw+JoMVkAixAAJzG2jVPIwWoKBPdYuY9b452e2rPuI9QPYh3KpofZ3pW2akOmwZLOiOsHMiqRAg==} + '@babel/helper-annotate-as-pure@7.25.7': + resolution: {integrity: sha512-4xwU8StnqnlIhhioZf1tqnVWeQ9pvH/ujS8hRfw/WOza+/a+1qv69BWNy+oY231maTCWgKWhfBU7kDpsds6zAA==} engines: {node: '>=6.9.0'} - '@babel/helper-builder-binary-assignment-operator-visitor@7.24.7': - resolution: {integrity: sha512-xZeCVVdwb4MsDBkkyZ64tReWYrLRHlMN72vP7Bdm3OUOuyFZExhsHUUnuWnm2/XOlAJzR0LfPpB56WXZn0X/lA==} + '@babel/helper-builder-binary-assignment-operator-visitor@7.25.7': + resolution: {integrity: sha512-12xfNeKNH7jubQNm7PAkzlLwEmCs1tfuX3UjIw6vP6QXi+leKh6+LyC/+Ed4EIQermwd58wsyh070yjDHFlNGg==} engines: {node: '>=6.9.0'} - '@babel/helper-compilation-targets@7.25.2': - resolution: {integrity: sha512-U2U5LsSaZ7TAt3cfaymQ8WHh0pxvdHoEk6HVpaexxixjyEquMh0L0YNJNM6CTGKMXV1iksi0iZkGw4AcFkPaaw==} + '@babel/helper-compilation-targets@7.25.7': + resolution: {integrity: sha512-DniTEax0sv6isaw6qSQSfV4gVRNtw2rte8HHM45t9ZR0xILaufBRNkpMifCRiAPyvL4ACD6v0gfCwCmtOQaV4A==} engines: {node: '>=6.9.0'} - '@babel/helper-create-class-features-plugin@7.25.4': - resolution: {integrity: sha512-ro/bFs3/84MDgDmMwbcHgDa8/E6J3QKNTk4xJJnVeFtGE+tL0K26E3pNxhYz2b67fJpt7Aphw5XcploKXuCvCQ==} + '@babel/helper-create-class-features-plugin@7.25.7': + resolution: {integrity: sha512-bD4WQhbkx80mAyj/WCm4ZHcF4rDxkoLFO6ph8/5/mQ3z4vAzltQXAmbc7GvVJx5H+lk5Mi5EmbTeox5nMGCsbw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/helper-create-regexp-features-plugin@7.25.2': - resolution: {integrity: sha512-+wqVGP+DFmqwFD3EH6TMTfUNeqDehV3E/dl+Sd54eaXqm17tEUNbEIn4sVivVowbvUpOtIGxdo3GoXyDH9N/9g==} + '@babel/helper-create-regexp-features-plugin@7.25.7': + resolution: {integrity: sha512-byHhumTj/X47wJ6C6eLpK7wW/WBEcnUeb7D0FNc/jFQnQVw7DOso3Zz5u9x/zLrFVkHa89ZGDbkAa1D54NdrCQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 @@ -519,103 +513,103 @@ packages: peerDependencies: '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0 - '@babel/helper-member-expression-to-functions@7.24.8': - resolution: {integrity: sha512-LABppdt+Lp/RlBxqrh4qgf1oEH/WxdzQNDJIu5gC/W1GyvPVrOBiItmmM8wan2fm4oYqFuFfkXmlGpLQhPY8CA==} + '@babel/helper-member-expression-to-functions@7.25.7': + resolution: {integrity: sha512-O31Ssjd5K6lPbTX9AAYpSKrZmLeagt9uwschJd+Ixo6QiRyfpvgtVQp8qrDR9UNFjZ8+DO34ZkdrN+BnPXemeA==} engines: {node: '>=6.9.0'} - '@babel/helper-module-imports@7.24.7': - resolution: {integrity: sha512-8AyH3C+74cgCVVXow/myrynrAGv+nTVg5vKu2nZph9x7RcRwzmh0VFallJuFTZ9mx6u4eSdXZfcOzSqTUm0HCA==} + '@babel/helper-module-imports@7.25.7': + resolution: {integrity: sha512-o0xCgpNmRohmnoWKQ0Ij8IdddjyBFE4T2kagL/x6M3+4zUgc+4qTOUBoNe4XxDskt1HPKO007ZPiMgLDq2s7Kw==} engines: {node: '>=6.9.0'} - '@babel/helper-module-transforms@7.25.2': - resolution: {integrity: sha512-BjyRAbix6j/wv83ftcVJmBt72QtHI56C7JXZoG2xATiLpmoC7dpd8WnkikExHDVPpi/3qCmO6WY1EaXOluiecQ==} + '@babel/helper-module-transforms@7.25.7': + resolution: {integrity: sha512-k/6f8dKG3yDz/qCwSM+RKovjMix563SLxQFo0UhRNo239SP6n9u5/eLtKD6EAjwta2JHJ49CsD8pms2HdNiMMQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/helper-optimise-call-expression@7.24.7': - resolution: {integrity: sha512-jKiTsW2xmWwxT1ixIdfXUZp+P5yURx2suzLZr5Hi64rURpDYdMW0pv+Uf17EYk2Rd428Lx4tLsnjGJzYKDM/6A==} + '@babel/helper-optimise-call-expression@7.25.7': + resolution: {integrity: sha512-VAwcwuYhv/AT+Vfr28c9y6SHzTan1ryqrydSTFGjU0uDJHw3uZ+PduI8plCLkRsDnqK2DMEDmwrOQRsK/Ykjng==} engines: {node: '>=6.9.0'} - '@babel/helper-plugin-utils@7.24.8': - resolution: {integrity: sha512-FFWx5142D8h2Mgr/iPVGH5G7w6jDn4jUSpZTyDnQO0Yn7Ks2Kuz6Pci8H6MPCoUJegd/UZQ3tAvfLCxQSnWWwg==} + '@babel/helper-plugin-utils@7.25.7': + resolution: {integrity: sha512-eaPZai0PiqCi09pPs3pAFfl/zYgGaE6IdXtYvmf0qlcDTd3WCtO7JWCcRd64e0EQrcYgiHibEZnOGsSY4QSgaw==} engines: {node: '>=6.9.0'} - '@babel/helper-remap-async-to-generator@7.25.0': - resolution: {integrity: sha512-NhavI2eWEIz/H9dbrG0TuOicDhNexze43i5z7lEqwYm0WEZVTwnPpA0EafUTP7+6/W79HWIP2cTe3Z5NiSTVpw==} + '@babel/helper-remap-async-to-generator@7.25.7': + resolution: {integrity: sha512-kRGE89hLnPfcz6fTrlNU+uhgcwv0mBE4Gv3P9Ke9kLVJYpi4AMVVEElXvB5CabrPZW4nCM8P8UyyjrzCM0O2sw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/helper-replace-supers@7.25.0': - resolution: {integrity: sha512-q688zIvQVYtZu+i2PsdIu/uWGRpfxzr5WESsfpShfZECkO+d2o+WROWezCi/Q6kJ0tfPa5+pUGUlfx2HhrA3Bg==} + '@babel/helper-replace-supers@7.25.7': + resolution: {integrity: sha512-iy8JhqlUW9PtZkd4pHM96v6BdJ66Ba9yWSE4z0W4TvSZwLBPkyDsiIU3ENe4SmrzRBs76F7rQXTy1lYC49n6Lw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/helper-simple-access@7.24.7': - resolution: {integrity: sha512-zBAIvbCMh5Ts+b86r/CjU+4XGYIs+R1j951gxI3KmmxBMhCg4oQMsv6ZXQ64XOm/cvzfU1FmoCyt6+owc5QMYg==} + '@babel/helper-simple-access@7.25.7': + resolution: {integrity: sha512-FPGAkJmyoChQeM+ruBGIDyrT2tKfZJO8NcxdC+CWNJi7N8/rZpSxK7yvBJ5O/nF1gfu5KzN7VKG3YVSLFfRSxQ==} engines: {node: '>=6.9.0'} - '@babel/helper-skip-transparent-expression-wrappers@7.24.7': - resolution: {integrity: sha512-IO+DLT3LQUElMbpzlatRASEyQtfhSE0+m465v++3jyyXeBTBUjtVZg28/gHeV5mrTJqvEKhKroBGAvhW+qPHiQ==} + '@babel/helper-skip-transparent-expression-wrappers@7.25.7': + resolution: {integrity: sha512-pPbNbchZBkPMD50K0p3JGcFMNLVUCuU/ABybm/PGNj4JiHrpmNyqqCphBk4i19xXtNV0JhldQJJtbSW5aUvbyA==} engines: {node: '>=6.9.0'} - '@babel/helper-string-parser@7.24.8': - resolution: {integrity: sha512-pO9KhhRcuUyGnJWwyEgnRJTSIZHiT+vMD0kPeD+so0l7mxkMT19g3pjY9GTnHySck/hDzq+dtW/4VgnMkippsQ==} + '@babel/helper-string-parser@7.25.7': + resolution: {integrity: sha512-CbkjYdsJNHFk8uqpEkpCvRs3YRp9tY6FmFY7wLMSYuGYkrdUi7r2lc4/wqsvlHoMznX3WJ9IP8giGPq68T/Y6g==} engines: {node: '>=6.9.0'} - '@babel/helper-validator-identifier@7.24.7': - resolution: {integrity: sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==} + '@babel/helper-validator-identifier@7.25.7': + resolution: {integrity: sha512-AM6TzwYqGChO45oiuPqwL2t20/HdMC1rTPAesnBCgPCSF1x3oN9MVUwQV2iyz4xqWrctwK5RNC8LV22kaQCNYg==} engines: {node: '>=6.9.0'} - '@babel/helper-validator-option@7.24.8': - resolution: {integrity: sha512-xb8t9tD1MHLungh/AIoWYN+gVHaB9kwlu8gffXGSt3FFEIT7RjS+xWbc2vUD1UTZdIpKj/ab3rdqJ7ufngyi2Q==} + '@babel/helper-validator-option@7.25.7': + resolution: {integrity: sha512-ytbPLsm+GjArDYXJ8Ydr1c/KJuutjF2besPNbIZnZ6MKUxi/uTA22t2ymmA4WFjZFpjiAMO0xuuJPqK2nvDVfQ==} engines: {node: '>=6.9.0'} - '@babel/helper-wrap-function@7.25.0': - resolution: {integrity: sha512-s6Q1ebqutSiZnEjaofc/UKDyC4SbzV5n5SrA2Gq8UawLycr3i04f1dX4OzoQVnexm6aOCh37SQNYlJ/8Ku+PMQ==} + '@babel/helper-wrap-function@7.25.7': + resolution: {integrity: sha512-MA0roW3JF2bD1ptAaJnvcabsVlNQShUaThyJbCDD4bCp8NEgiFvpoqRI2YS22hHlc2thjO/fTg2ShLMC3jygAg==} engines: {node: '>=6.9.0'} - '@babel/helpers@7.25.6': - resolution: {integrity: sha512-Xg0tn4HcfTijTwfDwYlvVCl43V6h4KyVVX2aEm4qdO/PC6L2YvzLHFdmxhoeSA3eslcE6+ZVXHgWwopXYLNq4Q==} + '@babel/helpers@7.25.7': + resolution: {integrity: sha512-Sv6pASx7Esm38KQpF/U/OXLwPPrdGHNKoeblRxgZRLXnAtnkEe4ptJPDtAZM7fBLadbc1Q07kQpSiGQ0Jg6tRA==} engines: {node: '>=6.9.0'} - '@babel/highlight@7.24.7': - resolution: {integrity: sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==} + '@babel/highlight@7.25.7': + resolution: {integrity: sha512-iYyACpW3iW8Fw+ZybQK+drQre+ns/tKpXbNESfrhNnPLIklLbXr7MYJ6gPEd0iETGLOK+SxMjVvKb/ffmk+FEw==} engines: {node: '>=6.9.0'} - '@babel/parser@7.25.6': - resolution: {integrity: sha512-trGdfBdbD0l1ZPmcJ83eNxB9rbEax4ALFTF7fN386TMYbeCQbyme5cOEXQhbGXKebwGaB/J52w1mrklMcbgy6Q==} + '@babel/parser@7.25.7': + resolution: {integrity: sha512-aZn7ETtQsjjGG5HruveUK06cU3Hljuhd9Iojm4M8WWv3wLE6OkE5PWbDUkItmMgegmccaITudyuW5RPYrYlgWw==} engines: {node: '>=6.0.0'} hasBin: true - '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.3': - resolution: {integrity: sha512-wUrcsxZg6rqBXG05HG1FPYgsP6EvwF4WpBbxIpWIIYnH8wG0gzx3yZY3dtEHas4sTAOGkbTsc9EGPxwff8lRoA==} + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.7': + resolution: {integrity: sha512-UV9Lg53zyebzD1DwQoT9mzkEKa922LNUp5YkTJ6Uta0RbyXaQNUgcvSt7qIu1PpPzVb6rd10OVNTzkyBGeVmxQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.0': - resolution: {integrity: sha512-Bm4bH2qsX880b/3ziJ8KD711LT7z4u8CFudmjqle65AZj/HNUFhEf90dqYv6O86buWvSBmeQDjv0Tn2aF/bIBA==} + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.7': + resolution: {integrity: sha512-GDDWeVLNxRIkQTnJn2pDOM1pkCgYdSqPeT1a9vh9yIqu2uzzgw1zcqEb+IJOhy+dTBMlNdThrDIksr2o09qrrQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.0': - resolution: {integrity: sha512-lXwdNZtTmeVOOFtwM/WDe7yg1PL8sYhRk/XH0FzbR2HDQ0xC+EnQ/JHeoMYSavtU115tnUk0q9CDyq8si+LMAA==} + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.7': + resolution: {integrity: sha512-wxyWg2RYaSUYgmd9MR0FyRGyeOMQE/Uzr1wzd/g5cf5bwi9A4v6HFdDm7y1MgDtod/fLOSTZY6jDgV0xU9d5bA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.24.7': - resolution: {integrity: sha512-+izXIbke1T33mY4MSNnrqhPXDz01WYhEf3yF5NbnUtkiNnm+XBZJl3kNfoK6NKmYlz/D07+l2GWVK/QfDkNCuQ==} + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.25.7': + resolution: {integrity: sha512-Xwg6tZpLxc4iQjorYsyGMyfJE7nP5MV8t/Ka58BgiA7Jw0fRqQNcANlLfdJ/yvBt9z9LD2We+BEkT7vLqZRWng==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.13.0 - '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.0': - resolution: {integrity: sha512-tggFrk1AIShG/RUQbEwt2Tr/E+ObkfwrPjR6BjbRvsx24+PSjK8zrq0GWPNCjo8qpRx4DuJzlcvWJqlm+0h3kw==} + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.7': + resolution: {integrity: sha512-UVATLMidXrnH+GMUIuxq55nejlj02HP7F5ETyBONzP6G87fPBogG4CH6kxrSrdIuAjdwNO9VzyaYsrZPscWUrw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 @@ -627,8 +621,8 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-proposal-export-default-from@7.24.7': - resolution: {integrity: sha512-CcmFwUJ3tKhLjPdt4NP+SHMshebytF8ZTYOv5ZDpkzq2sin80Wb5vJrGt8fhPrORQCfoSa0LAxC/DW+GAC5+Hw==} + '@babel/plugin-proposal-export-default-from@7.25.7': + resolution: {integrity: sha512-Egdiuy7pLTyaPkIr6rItNyFVbblTmx3VgqY+72KiS9BzcA+SMyrS9zSumQeSANo8uE3Kax0ZUMkpNh0Q+mbNwg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -679,8 +673,8 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-export-default-from@7.24.7': - resolution: {integrity: sha512-bTPz4/635WQ9WhwsyPdxUJDVpsi/X9BMmy/8Rf/UAlOO4jSql4CxUCjWI5PiM+jG+c4LVPTScoTw80geFj9+Bw==} + '@babel/plugin-syntax-export-default-from@7.25.7': + resolution: {integrity: sha512-LRUCsC0YucSjabsmxx6yly8+Q/5mxKdp9gemlpR9ro3bfpcOQOXx/CHivs7QCbjgygd6uQ2GcRfHu1FVax/hgg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -690,20 +684,20 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-flow@7.24.7': - resolution: {integrity: sha512-9G8GYT/dxn/D1IIKOUBmGX0mnmj46mGH9NnZyJLwtCpgh5f7D2VbuKodb+2s9m1Yavh1s7ASQN8lf0eqrb1LTw==} + '@babel/plugin-syntax-flow@7.25.7': + resolution: {integrity: sha512-fyoj6/YdVtlv2ROig/J0fP7hh/wNO1MJGm1NR70Pg7jbkF+jOUL9joorqaCOQh06Y+LfgTagHzC8KqZ3MF782w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-import-assertions@7.25.6': - resolution: {integrity: sha512-aABl0jHw9bZ2karQ/uUD6XP4u0SG22SJrOHFoL6XB1R7dTovOP4TzTlsxOYC5yQ1pdscVK2JTUnF6QL3ARoAiQ==} + '@babel/plugin-syntax-import-assertions@7.25.7': + resolution: {integrity: sha512-ZvZQRmME0zfJnDQnVBKYzHxXT7lYBB3Revz1GuS7oLXWMgqUPX4G+DDbT30ICClht9WKV34QVrZhSw6WdklwZQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-import-attributes@7.25.6': - resolution: {integrity: sha512-sXaDXaJN9SNLymBdlWFA+bjzBhFD617ZaFiY13dGt7TVslVvVgA6fkZOP7Ki3IGElC45lwHdOTrCtKZGVAWeLQ==} + '@babel/plugin-syntax-import-attributes@7.25.7': + resolution: {integrity: sha512-AqVo+dguCgmpi/3mYBdu9lkngOBlQ2w2vnNpa6gfiCxQZLzV4ZbhsXitJ2Yblkoe1VQwtHSaNmIaGll/26YWRw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -718,8 +712,8 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-jsx@7.24.7': - resolution: {integrity: sha512-6ddciUPe/mpMnOKv/U+RSd2vvVy+Yw/JfBB0ZHYjEZt9NLHmCUylNYlsbqCCS1Bffjlb0fCwC9Vqz+sBz6PsiQ==} + '@babel/plugin-syntax-jsx@7.25.7': + resolution: {integrity: sha512-ruZOnKO+ajVL/MVx+PwNBPOkrnXTXoWMtte1MBpegfCArhqOe3Bj52avVj1huLLxNKYKXYaSxZ2F+woK1ekXfw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -766,8 +760,8 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-syntax-typescript@7.25.4': - resolution: {integrity: sha512-uMOCoHVU52BsSWxPOMVv5qKRdeSlPuImUCB2dlPuBSU+W2/ROE7/Zg8F2Kepbk+8yBa68LlRKxO+xgEVWorsDg==} + '@babel/plugin-syntax-typescript@7.25.7': + resolution: {integrity: sha512-rR+5FDjpCHqqZN2bzZm18bVYGaejGq5ZkpVCJLXor/+zlSrSoc4KWcHI0URVWjl/68Dyr1uwZUz/1njycEAv9g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -778,368 +772,368 @@ packages: peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-transform-arrow-functions@7.24.7': - resolution: {integrity: sha512-Dt9LQs6iEY++gXUwY03DNFat5C2NbO48jj+j/bSAz6b3HgPs39qcPiYt77fDObIcFwj3/C2ICX9YMwGflUoSHQ==} + '@babel/plugin-transform-arrow-functions@7.25.7': + resolution: {integrity: sha512-EJN2mKxDwfOUCPxMO6MUI58RN3ganiRAG/MS/S3HfB6QFNjroAMelQo/gybyYq97WerCBAZoyrAoW8Tzdq2jWg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-async-generator-functions@7.25.4': - resolution: {integrity: sha512-jz8cV2XDDTqjKPwVPJBIjORVEmSGYhdRa8e5k5+vN+uwcjSrSxUaebBRa4ko1jqNF2uxyg8G6XYk30Jv285xzg==} + '@babel/plugin-transform-async-generator-functions@7.25.7': + resolution: {integrity: sha512-4B6OhTrwYKHYYgcwErvZjbmH9X5TxQBsaBHdzEIB4l71gR5jh/tuHGlb9in47udL2+wVUcOz5XXhhfhVJwEpEg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-async-to-generator@7.24.7': - resolution: {integrity: sha512-SQY01PcJfmQ+4Ash7NE+rpbLFbmqA2GPIgqzxfFTL4t1FKRq4zTms/7htKpoCUI9OcFYgzqfmCdH53s6/jn5fA==} + '@babel/plugin-transform-async-to-generator@7.25.7': + resolution: {integrity: sha512-ZUCjAavsh5CESCmi/xCpX1qcCaAglzs/7tmuvoFnJgA1dM7gQplsguljoTg+Ru8WENpX89cQyAtWoaE0I3X3Pg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-block-scoped-functions@7.24.7': - resolution: {integrity: sha512-yO7RAz6EsVQDaBH18IDJcMB1HnrUn2FJ/Jslc/WtPPWcjhpUJXU/rjbwmluzp7v/ZzWcEhTMXELnnsz8djWDwQ==} + '@babel/plugin-transform-block-scoped-functions@7.25.7': + resolution: {integrity: sha512-xHttvIM9fvqW+0a3tZlYcZYSBpSWzGBFIt/sYG3tcdSzBB8ZeVgz2gBP7Df+sM0N1850jrviYSSeUuc+135dmQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-block-scoping@7.25.0': - resolution: {integrity: sha512-yBQjYoOjXlFv9nlXb3f1casSHOZkWr29NX+zChVanLg5Nc157CrbEX9D7hxxtTpuFy7Q0YzmmWfJxzvps4kXrQ==} + '@babel/plugin-transform-block-scoping@7.25.7': + resolution: {integrity: sha512-ZEPJSkVZaeTFG/m2PARwLZQ+OG0vFIhPlKHK/JdIMy8DbRJ/htz6LRrTFtdzxi9EHmcwbNPAKDnadpNSIW+Aow==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-class-properties@7.25.4': - resolution: {integrity: sha512-nZeZHyCWPfjkdU5pA/uHiTaDAFUEqkpzf1YoQT2NeSynCGYq9rxfyI3XpQbfx/a0hSnFH6TGlEXvae5Vi7GD8g==} + '@babel/plugin-transform-class-properties@7.25.7': + resolution: {integrity: sha512-mhyfEW4gufjIqYFo9krXHJ3ElbFLIze5IDp+wQTxoPd+mwFb1NxatNAwmv8Q8Iuxv7Zc+q8EkiMQwc9IhyGf4g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-class-static-block@7.24.7': - resolution: {integrity: sha512-HMXK3WbBPpZQufbMG4B46A90PkuuhN9vBCb5T8+VAHqvAqvcLi+2cKoukcpmUYkszLhScU3l1iudhrks3DggRQ==} + '@babel/plugin-transform-class-static-block@7.25.7': + resolution: {integrity: sha512-rvUUtoVlkDWtDWxGAiiQj0aNktTPn3eFynBcMC2IhsXweehwgdI9ODe+XjWw515kEmv22sSOTp/rxIRuTiB7zg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.12.0 - '@babel/plugin-transform-classes@7.25.4': - resolution: {integrity: sha512-oexUfaQle2pF/b6E0dwsxQtAol9TLSO88kQvym6HHBWFliV2lGdrPieX+WgMRLSJDVzdYywk7jXbLPuO2KLTLg==} + '@babel/plugin-transform-classes@7.25.7': + resolution: {integrity: sha512-9j9rnl+YCQY0IGoeipXvnk3niWicIB6kCsWRGLwX241qSXpbA4MKxtp/EdvFxsc4zI5vqfLxzOd0twIJ7I99zg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-computed-properties@7.24.7': - resolution: {integrity: sha512-25cS7v+707Gu6Ds2oY6tCkUwsJ9YIDbggd9+cu9jzzDgiNq7hR/8dkzxWfKWnTic26vsI3EsCXNd4iEB6e8esQ==} + '@babel/plugin-transform-computed-properties@7.25.7': + resolution: {integrity: sha512-QIv+imtM+EtNxg/XBKL3hiWjgdLjMOmZ+XzQwSgmBfKbfxUjBzGgVPklUuE55eq5/uVoh8gg3dqlrwR/jw3ZeA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-destructuring@7.24.8': - resolution: {integrity: sha512-36e87mfY8TnRxc7yc6M9g9gOB7rKgSahqkIKwLpz4Ppk2+zC2Cy1is0uwtuSG6AE4zlTOUa+7JGz9jCJGLqQFQ==} + '@babel/plugin-transform-destructuring@7.25.7': + resolution: {integrity: sha512-xKcfLTlJYUczdaM1+epcdh1UGewJqr9zATgrNHcLBcV2QmfvPPEixo/sK/syql9cEmbr7ulu5HMFG5vbbt/sEA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-dotall-regex@7.24.7': - resolution: {integrity: sha512-ZOA3W+1RRTSWvyqcMJDLqbchh7U4NRGqwRfFSVbOLS/ePIP4vHB5e8T8eXcuqyN1QkgKyj5wuW0lcS85v4CrSw==} + '@babel/plugin-transform-dotall-regex@7.25.7': + resolution: {integrity: sha512-kXzXMMRzAtJdDEgQBLF4oaiT6ZCU3oWHgpARnTKDAqPkDJ+bs3NrZb310YYevR5QlRo3Kn7dzzIdHbZm1VzJdQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-duplicate-keys@7.24.7': - resolution: {integrity: sha512-JdYfXyCRihAe46jUIliuL2/s0x0wObgwwiGxw/UbgJBr20gQBThrokO4nYKgWkD7uBaqM7+9x5TU7NkExZJyzw==} + '@babel/plugin-transform-duplicate-keys@7.25.7': + resolution: {integrity: sha512-by+v2CjoL3aMnWDOyCIg+yxU9KXSRa9tN6MbqggH5xvymmr9p4AMjYkNlQy4brMceBnUyHZ9G8RnpvT8wP7Cfg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.0': - resolution: {integrity: sha512-YLpb4LlYSc3sCUa35un84poXoraOiQucUTTu8X1j18JV+gNa8E0nyUf/CjZ171IRGr4jEguF+vzJU66QZhn29g==} + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.7': + resolution: {integrity: sha512-HvS6JF66xSS5rNKXLqkk7L9c/jZ/cdIVIcoPVrnl8IsVpLggTjXs8OWekbLHs/VtYDDh5WXnQyeE3PPUGm22MA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-transform-dynamic-import@7.24.7': - resolution: {integrity: sha512-sc3X26PhZQDb3JhORmakcbvkeInvxz+A8oda99lj7J60QRuPZvNAk9wQlTBS1ZynelDrDmTU4pw1tyc5d5ZMUg==} + '@babel/plugin-transform-dynamic-import@7.25.7': + resolution: {integrity: sha512-UvcLuual4h7/GfylKm2IAA3aph9rwvAM2XBA0uPKU3lca+Maai4jBjjEVUS568ld6kJcgbouuumCBhMd/Yz17w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-exponentiation-operator@7.24.7': - resolution: {integrity: sha512-Rqe/vSc9OYgDajNIK35u7ot+KeCoetqQYFXM4Epf7M7ez3lWlOjrDjrwMei6caCVhfdw+mIKD4cgdGNy5JQotQ==} + '@babel/plugin-transform-exponentiation-operator@7.25.7': + resolution: {integrity: sha512-yjqtpstPfZ0h/y40fAXRv2snciYr0OAoMXY/0ClC7tm4C/nG5NJKmIItlaYlLbIVAWNfrYuy9dq1bE0SbX0PEg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-export-namespace-from@7.24.7': - resolution: {integrity: sha512-v0K9uNYsPL3oXZ/7F9NNIbAj2jv1whUEtyA6aujhekLs56R++JDQuzRcP2/z4WX5Vg/c5lE9uWZA0/iUoFhLTA==} + '@babel/plugin-transform-export-namespace-from@7.25.7': + resolution: {integrity: sha512-h3MDAP5l34NQkkNulsTNyjdaR+OiB0Im67VU//sFupouP8Q6m9Spy7l66DcaAQxtmCqGdanPByLsnwFttxKISQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-flow-strip-types@7.25.2': - resolution: {integrity: sha512-InBZ0O8tew5V0K6cHcQ+wgxlrjOw1W4wDXLkOTjLRD8GYhTSkxTVBtdy3MMtvYBrbAWa1Qm3hNoTc1620Yj+Mg==} + '@babel/plugin-transform-flow-strip-types@7.25.7': + resolution: {integrity: sha512-q8Td2PPc6/6I73g96SreSUCKEcwMXCwcXSIAVTyTTN6CpJe0dMj8coxu1fg1T9vfBLi6Rsi6a4ECcFBbKabS5w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-for-of@7.24.7': - resolution: {integrity: sha512-wo9ogrDG1ITTTBsy46oGiN1dS9A7MROBTcYsfS8DtsImMkHk9JXJ3EWQM6X2SUw4x80uGPlwj0o00Uoc6nEE3g==} + '@babel/plugin-transform-for-of@7.25.7': + resolution: {integrity: sha512-n/TaiBGJxYFWvpJDfsxSj9lEEE44BFM1EPGz4KEiTipTgkoFVVcCmzAL3qA7fdQU96dpo4gGf5HBx/KnDvqiHw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-function-name@7.25.1': - resolution: {integrity: sha512-TVVJVdW9RKMNgJJlLtHsKDTydjZAbwIsn6ySBPQaEAUU5+gVvlJt/9nRmqVbsV/IBanRjzWoaAQKLoamWVOUuA==} + '@babel/plugin-transform-function-name@7.25.7': + resolution: {integrity: sha512-5MCTNcjCMxQ63Tdu9rxyN6cAWurqfrDZ76qvVPrGYdBxIj+EawuuxTu/+dgJlhK5eRz3v1gLwp6XwS8XaX2NiQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-json-strings@7.24.7': - resolution: {integrity: sha512-2yFnBGDvRuxAaE/f0vfBKvtnvvqU8tGpMHqMNpTN2oWMKIR3NqFkjaAgGwawhqK/pIN2T3XdjGPdaG0vDhOBGw==} + '@babel/plugin-transform-json-strings@7.25.7': + resolution: {integrity: sha512-Ot43PrL9TEAiCe8C/2erAjXMeVSnE/BLEx6eyrKLNFCCw5jvhTHKyHxdI1pA0kz5njZRYAnMO2KObGqOCRDYSA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-literals@7.25.2': - resolution: {integrity: sha512-HQI+HcTbm9ur3Z2DkO+jgESMAMcYLuN/A7NRw9juzxAezN9AvqvUTnpKP/9kkYANz6u7dFlAyOu44ejuGySlfw==} + '@babel/plugin-transform-literals@7.25.7': + resolution: {integrity: sha512-fwzkLrSu2fESR/cm4t6vqd7ebNIopz2QHGtjoU+dswQo/P6lwAG04Q98lliE3jkz/XqnbGFLnUcE0q0CVUf92w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-logical-assignment-operators@7.24.7': - resolution: {integrity: sha512-4D2tpwlQ1odXmTEIFWy9ELJcZHqrStlzK/dAOWYyxX3zT0iXQB6banjgeOJQXzEc4S0E0a5A+hahxPaEFYftsw==} + '@babel/plugin-transform-logical-assignment-operators@7.25.7': + resolution: {integrity: sha512-iImzbA55BjiovLyG2bggWS+V+OLkaBorNvc/yJoeeDQGztknRnDdYfp2d/UPmunZYEnZi6Lg8QcTmNMHOB0lGA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-member-expression-literals@7.24.7': - resolution: {integrity: sha512-T/hRC1uqrzXMKLQ6UCwMT85S3EvqaBXDGf0FaMf4446Qx9vKwlghvee0+uuZcDUCZU5RuNi4781UQ7R308zzBw==} + '@babel/plugin-transform-member-expression-literals@7.25.7': + resolution: {integrity: sha512-Std3kXwpXfRV0QtQy5JJcRpkqP8/wG4XL7hSKZmGlxPlDqmpXtEPRmhF7ztnlTCtUN3eXRUJp+sBEZjaIBVYaw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-modules-amd@7.24.7': - resolution: {integrity: sha512-9+pB1qxV3vs/8Hdmz/CulFB8w2tuu6EB94JZFsjdqxQokwGa9Unap7Bo2gGBGIvPmDIVvQrom7r5m/TCDMURhg==} + '@babel/plugin-transform-modules-amd@7.25.7': + resolution: {integrity: sha512-CgselSGCGzjQvKzghCvDTxKHP3iooenLpJDO842ehn5D2G5fJB222ptnDwQho0WjEvg7zyoxb9P+wiYxiJX5yA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-modules-commonjs@7.24.8': - resolution: {integrity: sha512-WHsk9H8XxRs3JXKWFiqtQebdh9b/pTk4EgueygFzYlTKAg0Ud985mSevdNjdXdFBATSKVJGQXP1tv6aGbssLKA==} + '@babel/plugin-transform-modules-commonjs@7.25.7': + resolution: {integrity: sha512-L9Gcahi0kKFYXvweO6n0wc3ZG1ChpSFdgG+eV1WYZ3/dGbJK7vvk91FgGgak8YwRgrCuihF8tE/Xg07EkL5COg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-modules-systemjs@7.25.0': - resolution: {integrity: sha512-YPJfjQPDXxyQWg/0+jHKj1llnY5f/R6a0p/vP4lPymxLu7Lvl4k2WMitqi08yxwQcCVUUdG9LCUj4TNEgAp3Jw==} + '@babel/plugin-transform-modules-systemjs@7.25.7': + resolution: {integrity: sha512-t9jZIvBmOXJsiuyOwhrIGs8dVcD6jDyg2icw1VL4A/g+FnWyJKwUfSSU2nwJuMV2Zqui856El9u+ElB+j9fV1g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-modules-umd@7.24.7': - resolution: {integrity: sha512-3aytQvqJ/h9z4g8AsKPLvD4Zqi2qT+L3j7XoFFu1XBlZWEl2/1kWnhmAbxpLgPrHSY0M6UA02jyTiwUVtiKR6A==} + '@babel/plugin-transform-modules-umd@7.25.7': + resolution: {integrity: sha512-p88Jg6QqsaPh+EB7I9GJrIqi1Zt4ZBHUQtjw3z1bzEXcLh6GfPqzZJ6G+G1HBGKUNukT58MnKG7EN7zXQBCODw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-named-capturing-groups-regex@7.24.7': - resolution: {integrity: sha512-/jr7h/EWeJtk1U/uz2jlsCioHkZk1JJZVcc8oQsJ1dUlaJD83f4/6Zeh2aHt9BIFokHIsSeDfhUmju0+1GPd6g==} + '@babel/plugin-transform-named-capturing-groups-regex@7.25.7': + resolution: {integrity: sha512-BtAT9LzCISKG3Dsdw5uso4oV1+v2NlVXIIomKJgQybotJY3OwCwJmkongjHgwGKoZXd0qG5UZ12JUlDQ07W6Ow==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/plugin-transform-new-target@7.24.7': - resolution: {integrity: sha512-RNKwfRIXg4Ls/8mMTza5oPF5RkOW8Wy/WgMAp1/F1yZ8mMbtwXW+HDoJiOsagWrAhI5f57Vncrmr9XeT4CVapA==} + '@babel/plugin-transform-new-target@7.25.7': + resolution: {integrity: sha512-CfCS2jDsbcZaVYxRFo2qtavW8SpdzmBXC2LOI4oO0rP+JSRDxxF3inF4GcPsLgfb5FjkhXG5/yR/lxuRs2pySA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-nullish-coalescing-operator@7.24.7': - resolution: {integrity: sha512-Ts7xQVk1OEocqzm8rHMXHlxvsfZ0cEF2yomUqpKENHWMF4zKk175Y4q8H5knJes6PgYad50uuRmt3UJuhBw8pQ==} + '@babel/plugin-transform-nullish-coalescing-operator@7.25.7': + resolution: {integrity: sha512-FbuJ63/4LEL32mIxrxwYaqjJxpbzxPVQj5a+Ebrc8JICV6YX8nE53jY+K0RZT3um56GoNWgkS2BQ/uLGTjtwfw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-numeric-separator@7.24.7': - resolution: {integrity: sha512-e6q1TiVUzvH9KRvicuxdBTUj4AdKSRwzIyFFnfnezpCfP2/7Qmbb8qbU2j7GODbl4JMkblitCQjKYUaX/qkkwA==} + '@babel/plugin-transform-numeric-separator@7.25.7': + resolution: {integrity: sha512-8CbutzSSh4hmD+jJHIA8vdTNk15kAzOnFLVVgBSMGr28rt85ouT01/rezMecks9pkU939wDInImwCKv4ahU4IA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-object-rest-spread@7.24.7': - resolution: {integrity: sha512-4QrHAr0aXQCEFni2q4DqKLD31n2DL+RxcwnNjDFkSG0eNQ/xCavnRkfCUjsyqGC2OviNJvZOF/mQqZBw7i2C5Q==} + '@babel/plugin-transform-object-rest-spread@7.25.7': + resolution: {integrity: sha512-1JdVKPhD7Y5PvgfFy0Mv2brdrolzpzSoUq2pr6xsR+m+3viGGeHEokFKsCgOkbeFOQxfB1Vt2F0cPJLRpFI4Zg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-object-super@7.24.7': - resolution: {integrity: sha512-A/vVLwN6lBrMFmMDmPPz0jnE6ZGx7Jq7d6sT/Ev4H65RER6pZ+kczlf1DthF5N0qaPHBsI7UXiE8Zy66nmAovg==} + '@babel/plugin-transform-object-super@7.25.7': + resolution: {integrity: sha512-pWT6UXCEW3u1t2tcAGtE15ornCBvopHj9Bps9D2DsH15APgNVOTwwczGckX+WkAvBmuoYKRCFa4DK+jM8vh5AA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-optional-catch-binding@7.24.7': - resolution: {integrity: sha512-uLEndKqP5BfBbC/5jTwPxLh9kqPWWgzN/f8w6UwAIirAEqiIVJWWY312X72Eub09g5KF9+Zn7+hT7sDxmhRuKA==} + '@babel/plugin-transform-optional-catch-binding@7.25.7': + resolution: {integrity: sha512-m9obYBA39mDPN7lJzD5WkGGb0GO54PPLXsbcnj1Hyeu8mSRz7Gb4b1A6zxNX32ZuUySDK4G6it8SDFWD1nCnqg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-optional-chaining@7.24.8': - resolution: {integrity: sha512-5cTOLSMs9eypEy8JUVvIKOu6NgvbJMnpG62VpIHrTmROdQ+L5mDAaI40g25k5vXti55JWNX5jCkq3HZxXBQANw==} + '@babel/plugin-transform-optional-chaining@7.25.7': + resolution: {integrity: sha512-h39agClImgPWg4H8mYVAbD1qP9vClFbEjqoJmt87Zen8pjqK8FTPUwrOXAvqu5soytwxrLMd2fx2KSCp2CHcNg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-parameters@7.24.7': - resolution: {integrity: sha512-yGWW5Rr+sQOhK0Ot8hjDJuxU3XLRQGflvT4lhlSY0DFvdb3TwKaY26CJzHtYllU0vT9j58hc37ndFPsqT1SrzA==} + '@babel/plugin-transform-parameters@7.25.7': + resolution: {integrity: sha512-FYiTvku63me9+1Nz7TOx4YMtW3tWXzfANZtrzHhUZrz4d47EEtMQhzFoZWESfXuAMMT5mwzD4+y1N8ONAX6lMQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-private-methods@7.25.4': - resolution: {integrity: sha512-ao8BG7E2b/URaUQGqN3Tlsg+M3KlHY6rJ1O1gXAEUnZoyNQnvKyH87Kfg+FoxSeyWUB8ISZZsC91C44ZuBFytw==} + '@babel/plugin-transform-private-methods@7.25.7': + resolution: {integrity: sha512-KY0hh2FluNxMLwOCHbxVOKfdB5sjWG4M183885FmaqWWiGMhRZq4DQRKH6mHdEucbJnyDyYiZNwNG424RymJjA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-private-property-in-object@7.24.7': - resolution: {integrity: sha512-9z76mxwnwFxMyxZWEgdgECQglF2Q7cFLm0kMf8pGwt+GSJsY0cONKj/UuO4bOH0w/uAel3ekS4ra5CEAyJRmDA==} + '@babel/plugin-transform-private-property-in-object@7.25.7': + resolution: {integrity: sha512-LzA5ESzBy7tqj00Yjey9yWfs3FKy4EmJyKOSWld144OxkTji81WWnUT8nkLUn+imN/zHL8ZQlOu/MTUAhHaX3g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-property-literals@7.24.7': - resolution: {integrity: sha512-EMi4MLQSHfd2nrCqQEWxFdha2gBCqU4ZcCng4WBGZ5CJL4bBRW0ptdqqDdeirGZcpALazVVNJqRmsO8/+oNCBA==} + '@babel/plugin-transform-property-literals@7.25.7': + resolution: {integrity: sha512-lQEeetGKfFi0wHbt8ClQrUSUMfEeI3MMm74Z73T9/kuz990yYVtfofjf3NuA42Jy3auFOpbjDyCSiIkTs1VIYw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-constant-elements@7.25.1': - resolution: {integrity: sha512-SLV/giH/V4SmloZ6Dt40HjTGTAIkxn33TVIHxNGNvo8ezMhrxBkzisj4op1KZYPIOHFLqhv60OHvX+YRu4xbmQ==} + '@babel/plugin-transform-react-constant-elements@7.25.7': + resolution: {integrity: sha512-/qXt69Em8HgsjCLu7G3zdIQn7A2QwmYND7Wa0LTp09Na+Zn8L5d0A7wSXrKi18TJRc/Q5S1i1De/SU1LzVkSvA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-display-name@7.24.7': - resolution: {integrity: sha512-H/Snz9PFxKsS1JLI4dJLtnJgCJRoo0AUm3chP6NYr+9En1JMKloheEiLIhlp5MDVznWo+H3AAC1Mc8lmUEpsgg==} + '@babel/plugin-transform-react-display-name@7.25.7': + resolution: {integrity: sha512-r0QY7NVU8OnrwE+w2IWiRom0wwsTbjx4+xH2RTd7AVdof3uurXOF+/mXHQDRk+2jIvWgSaCHKMgggfvM4dyUGA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-jsx-development@7.24.7': - resolution: {integrity: sha512-QG9EnzoGn+Qar7rxuW+ZOsbWOt56FvvI93xInqsZDC5fsekx1AlIO4KIJ5M+D0p0SqSH156EpmZyXq630B8OlQ==} + '@babel/plugin-transform-react-jsx-development@7.25.7': + resolution: {integrity: sha512-5yd3lH1PWxzW6IZj+p+Y4OLQzz0/LzlOG8vGqonHfVR3euf1vyzyMUJk9Ac+m97BH46mFc/98t9PmYLyvgL3qg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-jsx-self@7.24.7': - resolution: {integrity: sha512-fOPQYbGSgH0HUp4UJO4sMBFjY6DuWq+2i8rixyUMb3CdGixs/gccURvYOAhajBdKDoGajFr3mUq5rH3phtkGzw==} + '@babel/plugin-transform-react-jsx-self@7.25.7': + resolution: {integrity: sha512-JD9MUnLbPL0WdVK8AWC7F7tTG2OS6u/AKKnsK+NdRhUiVdnzyR1S3kKQCaRLOiaULvUiqK6Z4JQE635VgtCFeg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-jsx-source@7.24.7': - resolution: {integrity: sha512-J2z+MWzZHVOemyLweMqngXrgGC42jQ//R0KdxqkIz/OrbVIIlhFI3WigZ5fO+nwFvBlncr4MGapd8vTyc7RPNQ==} + '@babel/plugin-transform-react-jsx-source@7.25.7': + resolution: {integrity: sha512-S/JXG/KrbIY06iyJPKfxr0qRxnhNOdkNXYBl/rmwgDd72cQLH9tEGkDm/yJPGvcSIUoikzfjMios9i+xT/uv9w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-jsx@7.25.2': - resolution: {integrity: sha512-KQsqEAVBpU82NM/B/N9j9WOdphom1SZH3R+2V7INrQUH+V9EBFwZsEJl8eBIVeQE62FxJCc70jzEZwqU7RcVqA==} + '@babel/plugin-transform-react-jsx@7.25.7': + resolution: {integrity: sha512-vILAg5nwGlR9EXE8JIOX4NHXd49lrYbN8hnjffDtoULwpL9hUx/N55nqh2qd0q6FyNDfjl9V79ecKGvFbcSA0Q==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-react-pure-annotations@7.24.7': - resolution: {integrity: sha512-PLgBVk3fzbmEjBJ/u8kFzOqS9tUeDjiaWud/rRym/yjCo/M9cASPlnrd2ZmmZpQT40fOOrvR8jh+n8jikrOhNA==} + '@babel/plugin-transform-react-pure-annotations@7.25.7': + resolution: {integrity: sha512-6YTHJ7yjjgYqGc8S+CbEXhLICODk0Tn92j+vNJo07HFk9t3bjFgAKxPLFhHwF2NjmQVSI1zBRfBWUeVBa2osfA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-regenerator@7.24.7': - resolution: {integrity: sha512-lq3fvXPdimDrlg6LWBoqj+r/DEWgONuwjuOuQCSYgRroXDH/IdM1C0IZf59fL5cHLpjEH/O6opIRBbqv7ELnuA==} + '@babel/plugin-transform-regenerator@7.25.7': + resolution: {integrity: sha512-mgDoQCRjrY3XK95UuV60tZlFCQGXEtMg8H+IsW72ldw1ih1jZhzYXbJvghmAEpg5UVhhnCeia1CkGttUvCkiMQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-reserved-words@7.24.7': - resolution: {integrity: sha512-0DUq0pHcPKbjFZCfTss/pGkYMfy3vFWydkUBd9r0GHpIyfs2eCDENvqadMycRS9wZCXR41wucAfJHJmwA0UmoQ==} + '@babel/plugin-transform-reserved-words@7.25.7': + resolution: {integrity: sha512-3OfyfRRqiGeOvIWSagcwUTVk2hXBsr/ww7bLn6TRTuXnexA+Udov2icFOxFX9abaj4l96ooYkcNN1qi2Zvqwng==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-runtime@7.25.4': - resolution: {integrity: sha512-8hsyG+KUYGY0coX6KUCDancA0Vw225KJ2HJO0yCNr1vq5r+lJTleDaJf0K7iOhjw4SWhu03TMBzYTJ9krmzULQ==} + '@babel/plugin-transform-runtime@7.25.7': + resolution: {integrity: sha512-Y9p487tyTzB0yDYQOtWnC+9HGOuogtP3/wNpun1xJXEEvI6vip59BSBTsHnekZLqxmPcgsrAKt46HAAb//xGhg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-shorthand-properties@7.24.7': - resolution: {integrity: sha512-KsDsevZMDsigzbA09+vacnLpmPH4aWjcZjXdyFKGzpplxhbeB4wYtury3vglQkg6KM/xEPKt73eCjPPf1PgXBA==} + '@babel/plugin-transform-shorthand-properties@7.25.7': + resolution: {integrity: sha512-uBbxNwimHi5Bv3hUccmOFlUy3ATO6WagTApenHz9KzoIdn0XeACdB12ZJ4cjhuB2WSi80Ez2FWzJnarccriJeA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-spread@7.24.7': - resolution: {integrity: sha512-x96oO0I09dgMDxJaANcRyD4ellXFLLiWhuwDxKZX5g2rWP1bTPkBSwCYv96VDXVT1bD9aPj8tppr5ITIh8hBng==} + '@babel/plugin-transform-spread@7.25.7': + resolution: {integrity: sha512-Mm6aeymI0PBh44xNIv/qvo8nmbkpZze1KvR8MkEqbIREDxoiWTi18Zr2jryfRMwDfVZF9foKh060fWgni44luw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-sticky-regex@7.24.7': - resolution: {integrity: sha512-kHPSIJc9v24zEml5geKg9Mjx5ULpfncj0wRpYtxbvKyTtHCYDkVE3aHQ03FrpEo4gEe2vrJJS1Y9CJTaThA52g==} + '@babel/plugin-transform-sticky-regex@7.25.7': + resolution: {integrity: sha512-ZFAeNkpGuLnAQ/NCsXJ6xik7Id+tHuS+NT+ue/2+rn/31zcdnupCdmunOizEaP0JsUmTFSTOPoQY7PkK2pttXw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-template-literals@7.24.7': - resolution: {integrity: sha512-AfDTQmClklHCOLxtGoP7HkeMw56k1/bTQjwsfhL6pppo/M4TOBSq+jjBUBLmV/4oeFg4GWMavIl44ZeCtmmZTw==} + '@babel/plugin-transform-template-literals@7.25.7': + resolution: {integrity: sha512-SI274k0nUsFFmyQupiO7+wKATAmMFf8iFgq2O+vVFXZ0SV9lNfT1NGzBEhjquFmD8I9sqHLguH+gZVN3vww2AA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-typeof-symbol@7.24.8': - resolution: {integrity: sha512-adNTUpDCVnmAE58VEqKlAA6ZBlNkMnWD0ZcW76lyNFN3MJniyGFZfNwERVk8Ap56MCnXztmDr19T4mPTztcuaw==} + '@babel/plugin-transform-typeof-symbol@7.25.7': + resolution: {integrity: sha512-OmWmQtTHnO8RSUbL0NTdtpbZHeNTnm68Gj5pA4Y2blFNh+V4iZR68V1qL9cI37J21ZN7AaCnkfdHtLExQPf2uA==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-typescript@7.25.2': - resolution: {integrity: sha512-lBwRvjSmqiMYe/pS0+1gggjJleUJi7NzjvQ1Fkqtt69hBa/0t1YuW/MLQMAPixfwaQOHUXsd6jeU3Z+vdGv3+A==} + '@babel/plugin-transform-typescript@7.25.7': + resolution: {integrity: sha512-VKlgy2vBzj8AmEzunocMun2fF06bsSWV+FvVXohtL6FGve/+L217qhHxRTVGHEDO/YR8IANcjzgJsd04J8ge5Q==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-unicode-escapes@7.24.7': - resolution: {integrity: sha512-U3ap1gm5+4edc2Q/P+9VrBNhGkfnf+8ZqppY71Bo/pzZmXhhLdqgaUl6cuB07O1+AQJtCLfaOmswiNbSQ9ivhw==} + '@babel/plugin-transform-unicode-escapes@7.25.7': + resolution: {integrity: sha512-BN87D7KpbdiABA+t3HbVqHzKWUDN3dymLaTnPFAMyc8lV+KN3+YzNhVRNdinaCPA4AUqx7ubXbQ9shRjYBl3SQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-unicode-property-regex@7.24.7': - resolution: {integrity: sha512-uH2O4OV5M9FZYQrwc7NdVmMxQJOCCzFeYudlZSzUAHRFeOujQefa92E74TQDVskNHCzOXoigEuoyzHDhaEaK5w==} + '@babel/plugin-transform-unicode-property-regex@7.25.7': + resolution: {integrity: sha512-IWfR89zcEPQGB/iB408uGtSPlQd3Jpq11Im86vUgcmSTcoWAiQMCTOa2K2yNNqFJEBVICKhayctee65Ka8OB0w==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-unicode-regex@7.24.7': - resolution: {integrity: sha512-hlQ96MBZSAXUq7ltkjtu3FJCCSMx/j629ns3hA3pXnBXjanNP0LHi+JpPeA81zaWgVK1VGH95Xuy7u0RyQ8kMg==} + '@babel/plugin-transform-unicode-regex@7.25.7': + resolution: {integrity: sha512-8JKfg/hiuA3qXnlLx8qtv5HWRbgyFx2hMMtpDDuU2rTckpKkGu4ycK5yYHwuEa16/quXfoxHBIApEsNyMWnt0g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/plugin-transform-unicode-sets-regex@7.25.4': - resolution: {integrity: sha512-qesBxiWkgN1Q+31xUE9RcMk79eOXXDCv6tfyGMRSs4RGlioSg2WVyQAm07k726cSE56pa+Kb0y9epX2qaXzTvA==} + '@babel/plugin-transform-unicode-sets-regex@7.25.7': + resolution: {integrity: sha512-YRW8o9vzImwmh4Q3Rffd09bH5/hvY0pxg+1H1i0f7APoUeg12G7+HhLj9ZFNIrYkgBXhIijPJ+IXypN0hLTIbw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - '@babel/preset-env@7.25.4': - resolution: {integrity: sha512-W9Gyo+KmcxjGahtt3t9fb14vFRWvPpu5pT6GBlovAK6BTBcxgjfVMSQCfJl4oi35ODrxP6xx2Wr8LNST57Mraw==} + '@babel/preset-env@7.25.7': + resolution: {integrity: sha512-Gibz4OUdyNqqLj+7OAvBZxOD7CklCtMA5/j0JgUEwOnaRULsPDXmic2iKxL2DX2vQduPR5wH2hjZas/Vr/Oc0g==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/preset-flow@7.24.7': - resolution: {integrity: sha512-NL3Lo0NorCU607zU3NwRyJbpaB6E3t0xtd3LfAQKDfkeX4/ggcDXvkmkW42QWT5owUeW/jAe4hn+2qvkV1IbfQ==} + '@babel/preset-flow@7.25.7': + resolution: {integrity: sha512-q2x3g0YHzo/Ohsr51KOYS/BtZMsvkzVd8qEyhZAyTatYdobfgXCuyppTqTuIhdq5kR/P3nyyVvZ6H5dMc4PnCQ==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 @@ -1149,46 +1143,40 @@ packages: peerDependencies: '@babel/core': ^7.0.0-0 || ^8.0.0-0 <8.0.0 - '@babel/preset-react@7.24.7': - resolution: {integrity: sha512-AAH4lEkpmzFWrGVlHaxJB7RLH21uPQ9+He+eFLWHmF9IuFQVugz8eAsamaW0DXRrTfco5zj1wWtpdcXJUOfsag==} + '@babel/preset-react@7.25.7': + resolution: {integrity: sha512-GjV0/mUEEXpi1U5ZgDprMRRgajGMRW3G5FjMr5KLKD8nT2fTG8+h/klV3+6Dm5739QE+K5+2e91qFKAYI3pmRg==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/preset-typescript@7.24.7': - resolution: {integrity: sha512-SyXRe3OdWwIwalxDg5UtJnJQO+YPcTfwiIY2B0Xlddh9o7jpWLvv8X1RthIeDOxQ+O1ML5BLPCONToObyVQVuQ==} + '@babel/preset-typescript@7.25.7': + resolution: {integrity: sha512-rkkpaXJZOFN45Fb+Gki0c+KMIglk4+zZXOoMJuyEK8y8Kkc8Jd3BDmP7qPsz0zQMJj+UD7EprF+AqAXcILnexw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/register@7.24.6': - resolution: {integrity: sha512-WSuFCc2wCqMeXkz/i3yfAAsxwWflEgbVkZzivgAmXl/MxrXeoYFZOOPllbC8R8WTF7u61wSRQtDVZ1879cdu6w==} + '@babel/register@7.25.7': + resolution: {integrity: sha512-qHTd2Rhn/rKhSUwdY6+n98FmwXN+N+zxSVx3zWqRe9INyvTpv+aQ5gDV2+43ACd3VtMBzPPljbb0gZb8u5ma6Q==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0-0 - '@babel/regjsgen@0.8.0': - resolution: {integrity: sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==} - - '@babel/runtime@7.25.6': - resolution: {integrity: sha512-VBj9MYyDb9tuLq7yzqjgzt6Q+IBQLrGZfdjOekyEirZPHxXWoTSGUTMrpsfi58Up73d13NfYLv8HT9vmznjzhQ==} + '@babel/runtime@7.25.7': + resolution: {integrity: sha512-FjoyLe754PMiYsFaN5C94ttGiOmBNYTf6pLr4xXHAT5uctHb092PBszndLDR5XA/jghQvn4n7JMHl7dmTgbm9w==} engines: {node: '>=6.9.0'} - '@babel/template@7.25.0': - resolution: {integrity: sha512-aOOgh1/5XzKvg1jvVz7AVrx2piJ2XBi227DHmbY6y+bM9H2FlN+IfecYu4Xl0cNiiVejlsCri89LUsbj8vJD9Q==} + '@babel/template@7.25.7': + resolution: {integrity: sha512-wRwtAgI3bAS+JGU2upWNL9lSlDcRCqD05BZ1n3X2ONLH1WilFP6O1otQjeMK/1g0pvYcXC7b/qVUB1keofjtZA==} engines: {node: '>=6.9.0'} - '@babel/traverse@7.25.6': - resolution: {integrity: sha512-9Vrcx5ZW6UwK5tvqsj0nGpp/XzqthkT0dqIc9g1AdtygFToNtTF67XzYS//dm+SAK9cp3B9R4ZO/46p63SCjlQ==} + '@babel/traverse@7.25.7': + resolution: {integrity: sha512-jatJPT1Zjqvh/1FyJs6qAHL+Dzb7sTb+xr7Q+gM1b+1oBsMsQQ4FkVKb6dFlJvLlVssqkRzV05Jzervt9yhnzg==} engines: {node: '>=6.9.0'} - '@babel/types@7.25.6': - resolution: {integrity: sha512-/l42B1qxpG6RdfYf343Uw1vmDjeNhneUXtzhojE7pDgfpEypmRhI6j1kr17XCVv4Cgl9HdAiQY2x0GwKm7rWCw==} + '@babel/types@7.25.7': + resolution: {integrity: sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==} engines: {node: '>=6.9.0'} - '@balena/dockerignore@1.0.2': - resolution: {integrity: sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==} - '@bcoe/v8-coverage@0.2.3': resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} @@ -1212,19 +1200,19 @@ packages: '@dabh/diagnostics@2.0.3': resolution: {integrity: sha512-hrlQOIi7hAfzsMqlGSFyVucrx38O+j6wiGOf//H2ecvIEqYN4ADBSS2iLMh5UFyDunCNniUIPk/q3riFv45xRA==} - '@depay/solana-web3.js@1.26.0': - resolution: {integrity: sha512-aAhDxfNGraE8VBwM5g/BhHnNCENlLSKDJ3yIh2EZd4mfmKM/4utv0cNUhTEytUAvvFoaMcOXXQ5U5sE1IMXFrQ==} + '@depay/solana-web3.js@1.27.0': + resolution: {integrity: sha512-BRRGu4LkWFkvrYRRnenxj+/omvuJidYHK9gUys0VXJQS2QGE/d7iME2Hlc2rzlVeCwz5DVjQc5Mgf8lFBvaZgg==} - '@depay/web3-blockchains@9.6.1': - resolution: {integrity: sha512-IK8D+zQ8UufqY8+fIGJ2Yuzw4Yms7VLYtkEPbAfurUffNTMOweMxBWRJVQfkcmKTamZbA7juTHFJ7Uv/z0m17g==} + '@depay/web3-blockchains@9.6.7': + resolution: {integrity: sha512-RqVsm/aURJ2npRm0/0qr/GiMdBsGSbRA2GpzG75Vy7qODYScbYjA/CitMjhw9ktzGjiFN9oh/ooq9GBjPIhEdA==} engines: {node: '>=10'} '@depay/web3-mock@14.17.0': resolution: {integrity: sha512-0WCIpHqGUTPmOb5l3iN+4wCY+P3nHnGWd3uyWB+Wrt5DygS6MWI2b50gwtSCgYUCfgmEv9KlRuCnHDC4TDKCeA==} engines: {node: '>=16'} - '@emnapi/runtime@1.2.0': - resolution: {integrity: sha512-bV21/9LQmcQeCPEg3BDFtvwL6cwiTMksYNWQQ4KOxCZikEGalWtenoZ0wCiukJINlGCIi2KXx01g4FoH/LxpzQ==} + '@emnapi/runtime@1.3.0': + resolution: {integrity: sha512-XMBySMuNZs3DM96xcJmLW4EfGnf+uGmFNjzpehMjuX5PLB5j87ar2Zc4e3PVeZ3I5g3tYtAqskB28manlF69Zw==} '@esbuild/aix-ppc64@0.19.12': resolution: {integrity: sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==} @@ -2009,8 +1997,8 @@ packages: resolution: {integrity: sha512-I6bkduevXb72TIM9q2LRO63JSsF9EXduh3sBr9oybNX2hNNpr/j1tEjXrsG0Uabm4MJ1xkGAQEMwifvKZIkyxQ==} engines: {node: '>=16.0.0'} - '@metamask/utils@9.2.1': - resolution: {integrity: sha512-/u663aUaB6+Xe75i3Mt/1cCljm41HDYIsna5oBrwGvgkY2zH7/9k9Zjd706cxoAbxN7QgLSVAReUiGnuxCuXrQ==} + '@metamask/utils@9.3.0': + resolution: {integrity: sha512-w8CVbdkDrVXFJbfBSlDfafDR6BAkpDmv1bC1UJVCoVny5tW2RKAdn9i68Xf7asYT4TnUhl/hN4zfUiKQq9II4g==} engines: {node: '>=16.0.0'} '@motionone/animation@10.18.0': @@ -2317,11 +2305,11 @@ packages: resolution: {integrity: sha512-PTef+rMxkM5VQ7sLwLKSjp2DBakYQd661ZJiSRywx+q/nIpm3B/HYGcz5wPZCA5O/QcEP6TatXXDoeMwimbcnw==} deprecated: This package has been deprecated and will no longer be maintained, please use @openzeppelin/defender-sdk package instead. - '@openzeppelin/defender-sdk-base-client@1.14.4': - resolution: {integrity: sha512-tOePVQLKpqfGQ1GMzHvSBNd2psPYd86LDNpvdl5gjD0Y2kW/zNh5qBXy29RraGtk/qc8zs9hzS5pAOh0vhGkGQ==} + '@openzeppelin/defender-sdk-base-client@1.15.0': + resolution: {integrity: sha512-nuf/xegMIuKCO0hMrxI1KQKTzQw1iCl/9kew2nJM9MrFIohhfEXItc5rbJRoV/jehmK/Jhi9ATF9OHH09StEsQ==} - '@openzeppelin/defender-sdk-deploy-client@1.14.4': - resolution: {integrity: sha512-+diSoz1zid37LMsY2RDxI+uAsYx9Eryg8Vz+yfvuyd56fXrzjQEln7BBtYQw+2zp9yvyAByOL5XSQdrQga9OBQ==} + '@openzeppelin/defender-sdk-deploy-client@1.15.0': + resolution: {integrity: sha512-2ODMN4j5pPYWyIOvA/zRQmJ0tJyqi6NV3S/PyvufBXa3oj/MDnVO5bMGSQFH0M2VE3bg+i/rcUb0hdbX9Rtm5Q==} '@openzeppelin/hardhat-upgrades@2.5.1': resolution: {integrity: sha512-wRwq9f2PqlfIdNGFApsqRpqptqy98exSFp8SESb6Brgw4L07sExySInNJhscM/tWVSnR1Qnuws9Ck6Fs5zIxvg==} @@ -2446,24 +2434,24 @@ packages: resolution: {integrity: sha512-c83qWb22rNRuB0UaVCI0uRPNRr8Z0FWnEIvT47jiHAmOIUHbBOg5XvV7pM5x+rKn9HRpjxquDbXYSXr3fAKFcw==} engines: {node: '>=12'} - '@react-aria/focus@3.18.2': - resolution: {integrity: sha512-Jc/IY+StjA3uqN73o6txKQ527RFU7gnG5crEl5Xy3V+gbYp2O5L3ezAo/E0Ipi2cyMbG6T5Iit1IDs7hcGu8aw==} + '@react-aria/focus@3.18.3': + resolution: {integrity: sha512-WKUElg+5zS0D3xlVn8MntNnkzJql2J6MuzAMP8Sv5WTgFDse/XGR842dsxPTIyKKdrWVCRegCuwa4m3n/GzgJw==} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 - '@react-aria/interactions@3.22.2': - resolution: {integrity: sha512-xE/77fRVSlqHp2sfkrMeNLrqf2amF/RyuAS6T5oDJemRSgYM3UoxTbWjucPhfnoW7r32pFPHHgz4lbdX8xqD/g==} + '@react-aria/interactions@3.22.3': + resolution: {integrity: sha512-RRUb/aG+P0IKTIWikY/SylB6bIbLZeztnZY2vbe7RAG5MgVaCgn5HQ45SI15GlTmhsFG8CnF6slJsUFJiNHpbQ==} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 - '@react-aria/ssr@3.9.5': - resolution: {integrity: sha512-xEwGKoysu+oXulibNUSkXf8itW0npHHTa6c4AyYeZIJyRoegeteYuFpZUBPtIDE8RfHdNsSmE1ssOkxRnwbkuQ==} + '@react-aria/ssr@3.9.6': + resolution: {integrity: sha512-iLo82l82ilMiVGy342SELjshuWottlb5+VefO3jOQqQRNYnJBFpUSadswDPbRimSgJUZuFwIEYs6AabkP038fA==} engines: {node: '>= 12'} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 - '@react-aria/utils@3.25.2': - resolution: {integrity: sha512-GdIvG8GBJJZygB4L2QJP1Gabyn2mjFsha73I2wSe+o4DYeGWoJiMZRM06PyTIxLH4S7Sn7eVDtsSBfkc2VY/NA==} + '@react-aria/utils@3.25.3': + resolution: {integrity: sha512-PR5H/2vaD8fSq0H/UB9inNbc8KDcVmW6fYAfSWkkn+OAdhTTMVKqXXrZuZBWyFfSD5Ze7VN6acr4hrOQm2bmrA==} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 @@ -2502,57 +2490,57 @@ packages: engines: {node: '>=18'} hasBin: true - '@react-native/assets-registry@0.75.3': - resolution: {integrity: sha512-i7MaRbYR06WdpJWv3a0PQ2ScFBUeevwcJ0tVopnFwTg0tBWp3NFEMDIcU8lyXVy9Y59WmrP1V2ROaRDaPiESgg==} + '@react-native/assets-registry@0.75.4': + resolution: {integrity: sha512-WX6/LNHwyjislSFM+h3qQjBiPaXXPJW5ZV4TdgNKb6QOPO0g1KGYRQj44cI2xSpZ3fcWrvQFZfQgSMbVK9Sg7A==} engines: {node: '>=18'} - '@react-native/babel-plugin-codegen@0.75.3': - resolution: {integrity: sha512-8JmXEKq+Efb9AffsV48l8gmKe/ZQ2PbBygZjHdIf8DNZZhO/z5mt27J4B43MWNdp5Ww1l59T0mEaf8l/uywQUg==} + '@react-native/babel-plugin-codegen@0.75.4': + resolution: {integrity: sha512-gu5ZRIdr7+ufi09DJROhfDtbF4biTnCDJqtqcmtsku4cXOXPHE36QbC/vAmKEZ0PMPURBI8lwF2wfaeHLn7gig==} engines: {node: '>=18'} - '@react-native/babel-preset@0.75.3': - resolution: {integrity: sha512-VZQkQEj36DKEGApXFYdVcFtqdglbnoVr7aOZpjffURSgPcIA9vWTm1b+OL4ayOaRZXTZKiDBNQCXvBX5E5AgQg==} + '@react-native/babel-preset@0.75.4': + resolution: {integrity: sha512-UtyYCDJ3rZIeggyFEfh/q5t/FZ5a1h9F8EI37Nbrwyk/OKPH+1XS4PbHROHJzBARlJwOAfmT75+ovYUO0eakJA==} engines: {node: '>=18'} peerDependencies: '@babel/core': '*' - '@react-native/codegen@0.75.3': - resolution: {integrity: sha512-I0bz5jwOkiR7vnhYLGoV22RGmesErUg03tjsCiQgmsMpbyCYumudEtLNN5+DplHGK56bu8KyzBqKkWXGSKSCZQ==} + '@react-native/codegen@0.75.4': + resolution: {integrity: sha512-0FplNAD/S5FUvm8YIn6uyarOcP4jdJPqWz17K4a/Gp2KSsG/JJKEskX3aj5wpePzVfNQl3WyvBJ0whODdCocIA==} engines: {node: '>=18'} peerDependencies: '@babel/preset-env': ^7.1.6 - '@react-native/community-cli-plugin@0.75.3': - resolution: {integrity: sha512-njsYm+jBWzfLcJcxavAY5QFzYTrmPtjbxq/64GSqwcQYzy9qAkI7LNTK/Wprq1I/4HOuHJO7Km+EddCXB+ByRQ==} + '@react-native/community-cli-plugin@0.75.4': + resolution: {integrity: sha512-k/hevYPjEpW0MNVVyb3v9PJosOP+FzenS7+oqYNLXdEmgTnGHrAtYX9ABrJJgzeJt7I6g8g+RDvm8PSE+tnM5w==} engines: {node: '>=18'} - '@react-native/debugger-frontend@0.75.3': - resolution: {integrity: sha512-99bLQsUwsxUMNR7Wa9eV2uyR38yfd6mOEqfN+JIm8/L9sKA926oh+CZkjDy1M8RmCB6spB5N9fVFVkrVdf2yFA==} + '@react-native/debugger-frontend@0.75.4': + resolution: {integrity: sha512-QfGurR5hV6bhMPn/6VxS2RomYrPRFGwA03jJr+zKyWHnxDAu5jOqYVyKAktIIbhYe5sPp78QVl1ZYuhcnsRbEw==} engines: {node: '>=18'} - '@react-native/dev-middleware@0.75.3': - resolution: {integrity: sha512-h2/6+UGmeMWjnT43axy27jNqoDRsE1C1qpjRC3sYpD4g0bI0jSTkY1kAgj8uqGGXLnHXiHOtjLDGdbAgZrsPaA==} + '@react-native/dev-middleware@0.75.4': + resolution: {integrity: sha512-UhyBeQOG2wNcvrUGw3+IBrHBk/lIu7hHGmWt4j8W9Aqv9BwktHKkPyko+5A1yoUeO1O/VDnHWYqWeOejcA9wpQ==} engines: {node: '>=18'} - '@react-native/gradle-plugin@0.75.3': - resolution: {integrity: sha512-mSfa/Mq/AsALuG/kvXz5ECrc6HdY5waMHal2sSfa8KA0Gt3JqYQVXF9Pdwd4yR5ClPZDI2HRa1tdE8GVlhMvPA==} + '@react-native/gradle-plugin@0.75.4': + resolution: {integrity: sha512-kKTmw7cF7p1raT30DC0L6N+xiVXN7dlRy0J+hYPiCRRVHplwgvyS7pszjxfzwXmHFqOxwpxQVI3du8opsma1Mg==} engines: {node: '>=18'} - '@react-native/js-polyfills@0.75.3': - resolution: {integrity: sha512-+JVFJ351GSJT3V7LuXscMqfnpR/UxzsAjbBjfAHBR3kqTbVqrAmBccqPCA3NLzgb/RY8khLJklwMUVlWrn8iFg==} + '@react-native/js-polyfills@0.75.4': + resolution: {integrity: sha512-NF5ID5FjcVHBYk1LQ4JMRjPmxBWEo4yoqW1m6vGOQZPT8D5Qs9afgx3f7gQatxbn3ivMh0FVbLW0zBx6LyxEzA==} engines: {node: '>=18'} - '@react-native/metro-babel-transformer@0.75.3': - resolution: {integrity: sha512-gDlEl6C2mwQPLxFOR+yla5MpJpDPNOFD6J5Hd9JM9+lOdUq6MNujh1Xn4ZMvglW7rfViq3nMjg4xPQeGUhDG+w==} + '@react-native/metro-babel-transformer@0.75.4': + resolution: {integrity: sha512-O0WMW/K8Ny/MAAeRebqGEQhrbzcioxcPHZtos+EH2hWeBTEKHQV8fMYYxfYDabpr392qdhSBwg3LlXUD4U3PXQ==} engines: {node: '>=18'} peerDependencies: '@babel/core': '*' - '@react-native/normalize-colors@0.75.3': - resolution: {integrity: sha512-3mhF8AJFfIN0E5bEs/DQ4U2LzMJYm+FPSwY5bJ1DZhrxW1PFAh24bAPrSd8PwS0iarQ7biLdr1lWf/8LFv8pDA==} + '@react-native/normalize-colors@0.75.4': + resolution: {integrity: sha512-90QrQDLg0/k9xqYesaKuIkayOSjD+FKa0hsHollbwT5h3kuGMY+lU7UZxnb8tU55Y1PKdvjYxqQsYWI/ql79zA==} - '@react-native/virtualized-lists@0.75.3': - resolution: {integrity: sha512-cTLm7k7Y//SvV8UK8esrDHEw5OrwwSJ4Fqc3x52Imi6ROuhshfGIPFwhtn4pmAg9nWHzHwwqiJ+9hCSVnXXX+g==} + '@react-native/virtualized-lists@0.75.4': + resolution: {integrity: sha512-iEauRiXjvWG/iOH8bV+9MfepCS+72cuL5rhkrenYZS0NUnDcNjF+wtaoS9+Gx5z1UJOfEXxSmyXRtQJZne8SnA==} engines: {node: '>=18'} peerDependencies: '@types/react': ^18.2.6 @@ -2562,93 +2550,93 @@ packages: '@types/react': optional: true - '@react-stately/utils@3.10.3': - resolution: {integrity: sha512-moClv7MlVSHpbYtQIkm0Cx+on8Pgt1XqtPx6fy9rQFb2DNc9u1G3AUVnqA17buOkH1vLxAtX4MedlxMWyRCYYA==} + '@react-stately/utils@3.10.4': + resolution: {integrity: sha512-gBEQEIMRh5f60KCm7QKQ2WfvhB2gLUr9b72sqUdIZ2EG+xuPgaIlCBeSicvjmjBvYZwOjoOEnmIkcx2GHp/HWw==} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 - '@react-types/shared@3.24.1': - resolution: {integrity: sha512-AUQeGYEm/zDTN6zLzdXolDxz3Jk5dDL7f506F07U8tBwxNNI3WRdhU84G0/AaFikOZzDXhOZDr3MhQMzyE7Ydw==} + '@react-types/shared@3.25.0': + resolution: {integrity: sha512-OZSyhzU6vTdW3eV/mz5i6hQwQUhkRs7xwY2d1aqPvTdMe0+2cY7Fwp45PAiwYLEj73i9ro2FxF9qC4DvHGSCgQ==} peerDependencies: react: ^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0 - '@rollup/rollup-android-arm-eabi@4.22.5': - resolution: {integrity: sha512-SU5cvamg0Eyu/F+kLeMXS7GoahL+OoizlclVFX3l5Ql6yNlywJJ0OuqTzUx0v+aHhPHEB/56CT06GQrRrGNYww==} + '@rollup/rollup-android-arm-eabi@4.24.0': + resolution: {integrity: sha512-Q6HJd7Y6xdB48x8ZNVDOqsbh2uByBhgK8PiQgPhwkIw/HC/YX5Ghq2mQY5sRMZWHb3VsFkWooUVOZHKr7DmDIA==} cpu: [arm] os: [android] - '@rollup/rollup-android-arm64@4.22.5': - resolution: {integrity: sha512-S4pit5BP6E5R5C8S6tgU/drvgjtYW76FBuG6+ibG3tMvlD1h9LHVF9KmlmaUBQ8Obou7hEyS+0w+IR/VtxwNMQ==} + '@rollup/rollup-android-arm64@4.24.0': + resolution: {integrity: sha512-ijLnS1qFId8xhKjT81uBHuuJp2lU4x2yxa4ctFPtG+MqEE6+C5f/+X/bStmxapgmwLwiL3ih122xv8kVARNAZA==} cpu: [arm64] os: [android] - '@rollup/rollup-darwin-arm64@4.22.5': - resolution: {integrity: sha512-250ZGg4ipTL0TGvLlfACkIxS9+KLtIbn7BCZjsZj88zSg2Lvu3Xdw6dhAhfe/FjjXPVNCtcSp+WZjVsD3a/Zlw==} + '@rollup/rollup-darwin-arm64@4.24.0': + resolution: {integrity: sha512-bIv+X9xeSs1XCk6DVvkO+S/z8/2AMt/2lMqdQbMrmVpgFvXlmde9mLcbQpztXm1tajC3raFDqegsH18HQPMYtA==} cpu: [arm64] os: [darwin] - '@rollup/rollup-darwin-x64@4.22.5': - resolution: {integrity: sha512-D8brJEFg5D+QxFcW6jYANu+Rr9SlKtTenmsX5hOSzNYVrK5oLAEMTUgKWYJP+wdKyCdeSwnapLsn+OVRFycuQg==} + '@rollup/rollup-darwin-x64@4.24.0': + resolution: {integrity: sha512-X6/nOwoFN7RT2svEQWUsW/5C/fYMBe4fnLK9DQk4SX4mgVBiTA9h64kjUYPvGQ0F/9xwJ5U5UfTbl6BEjaQdBQ==} cpu: [x64] os: [darwin] - '@rollup/rollup-linux-arm-gnueabihf@4.22.5': - resolution: {integrity: sha512-PNqXYmdNFyWNg0ma5LdY8wP+eQfdvyaBAojAXgO7/gs0Q/6TQJVXAXe8gwW9URjbS0YAammur0fynYGiWsKlXw==} + '@rollup/rollup-linux-arm-gnueabihf@4.24.0': + resolution: {integrity: sha512-0KXvIJQMOImLCVCz9uvvdPgfyWo93aHHp8ui3FrtOP57svqrF/roSSR5pjqL2hcMp0ljeGlU4q9o/rQaAQ3AYA==} cpu: [arm] os: [linux] - '@rollup/rollup-linux-arm-musleabihf@4.22.5': - resolution: {integrity: sha512-kSSCZOKz3HqlrEuwKd9TYv7vxPYD77vHSUvM2y0YaTGnFc8AdI5TTQRrM1yIp3tXCKrSL9A7JLoILjtad5t8pQ==} + '@rollup/rollup-linux-arm-musleabihf@4.24.0': + resolution: {integrity: sha512-it2BW6kKFVh8xk/BnHfakEeoLPv8STIISekpoF+nBgWM4d55CZKc7T4Dx1pEbTnYm/xEKMgy1MNtYuoA8RFIWw==} cpu: [arm] os: [linux] - '@rollup/rollup-linux-arm64-gnu@4.22.5': - resolution: {integrity: sha512-oTXQeJHRbOnwRnRffb6bmqmUugz0glXaPyspp4gbQOPVApdpRrY/j7KP3lr7M8kTfQTyrBUzFjj5EuHAhqH4/w==} + '@rollup/rollup-linux-arm64-gnu@4.24.0': + resolution: {integrity: sha512-i0xTLXjqap2eRfulFVlSnM5dEbTVque/3Pi4g2y7cxrs7+a9De42z4XxKLYJ7+OhE3IgxvfQM7vQc43bwTgPwA==} cpu: [arm64] os: [linux] - '@rollup/rollup-linux-arm64-musl@4.22.5': - resolution: {integrity: sha512-qnOTIIs6tIGFKCHdhYitgC2XQ2X25InIbZFor5wh+mALH84qnFHvc+vmWUpyX97B0hNvwNUL4B+MB8vJvH65Fw==} + '@rollup/rollup-linux-arm64-musl@4.24.0': + resolution: {integrity: sha512-9E6MKUJhDuDh604Qco5yP/3qn3y7SLXYuiC0Rpr89aMScS2UAmK1wHP2b7KAa1nSjWJc/f/Lc0Wl1L47qjiyQw==} cpu: [arm64] os: [linux] - '@rollup/rollup-linux-powerpc64le-gnu@4.22.5': - resolution: {integrity: sha512-TMYu+DUdNlgBXING13rHSfUc3Ky5nLPbWs4bFnT+R6Vu3OvXkTkixvvBKk8uO4MT5Ab6lC3U7x8S8El2q5o56w==} + '@rollup/rollup-linux-powerpc64le-gnu@4.24.0': + resolution: {integrity: sha512-2XFFPJ2XMEiF5Zi2EBf4h73oR1V/lycirxZxHZNc93SqDN/IWhYYSYj8I9381ikUFXZrz2v7r2tOVk2NBwxrWw==} cpu: [ppc64] os: [linux] - '@rollup/rollup-linux-riscv64-gnu@4.22.5': - resolution: {integrity: sha512-PTQq1Kz22ZRvuhr3uURH+U/Q/a0pbxJoICGSprNLAoBEkyD3Sh9qP5I0Asn0y0wejXQBbsVMRZRxlbGFD9OK4A==} + '@rollup/rollup-linux-riscv64-gnu@4.24.0': + resolution: {integrity: sha512-M3Dg4hlwuntUCdzU7KjYqbbd+BLq3JMAOhCKdBE3TcMGMZbKkDdJ5ivNdehOssMCIokNHFOsv7DO4rlEOfyKpg==} cpu: [riscv64] os: [linux] - '@rollup/rollup-linux-s390x-gnu@4.22.5': - resolution: {integrity: sha512-bR5nCojtpuMss6TDEmf/jnBnzlo+6n1UhgwqUvRoe4VIotC7FG1IKkyJbwsT7JDsF2jxR+NTnuOwiGv0hLyDoQ==} + '@rollup/rollup-linux-s390x-gnu@4.24.0': + resolution: {integrity: sha512-mjBaoo4ocxJppTorZVKWFpy1bfFj9FeCMJqzlMQGjpNPY9JwQi7OuS1axzNIk0nMX6jSgy6ZURDZ2w0QW6D56g==} cpu: [s390x] os: [linux] - '@rollup/rollup-linux-x64-gnu@4.22.5': - resolution: {integrity: sha512-N0jPPhHjGShcB9/XXZQWuWBKZQnC1F36Ce3sDqWpujsGjDz/CQtOL9LgTrJ+rJC8MJeesMWrMWVLKKNR/tMOCA==} + '@rollup/rollup-linux-x64-gnu@4.24.0': + resolution: {integrity: sha512-ZXFk7M72R0YYFN5q13niV0B7G8/5dcQ9JDp8keJSfr3GoZeXEoMHP/HlvqROA3OMbMdfr19IjCeNAnPUG93b6A==} cpu: [x64] os: [linux] - '@rollup/rollup-linux-x64-musl@4.22.5': - resolution: {integrity: sha512-uBa2e28ohzNNwjr6Uxm4XyaA1M/8aTgfF2T7UIlElLaeXkgpmIJ2EitVNQxjO9xLLLy60YqAgKn/AqSpCUkE9g==} + '@rollup/rollup-linux-x64-musl@4.24.0': + resolution: {integrity: sha512-w1i+L7kAXZNdYl+vFvzSZy8Y1arS7vMgIy8wusXJzRrPyof5LAb02KGr1PD2EkRcl73kHulIID0M501lN+vobQ==} cpu: [x64] os: [linux] - '@rollup/rollup-win32-arm64-msvc@4.22.5': - resolution: {integrity: sha512-RXT8S1HP8AFN/Kr3tg4fuYrNxZ/pZf1HemC5Tsddc6HzgGnJm0+Lh5rAHJkDuW3StI0ynNXukidROMXYl6ew8w==} + '@rollup/rollup-win32-arm64-msvc@4.24.0': + resolution: {integrity: sha512-VXBrnPWgBpVDCVY6XF3LEW0pOU51KbaHhccHw6AS6vBWIC60eqsH19DAeeObl+g8nKAz04QFdl/Cefta0xQtUQ==} cpu: [arm64] os: [win32] - '@rollup/rollup-win32-ia32-msvc@4.22.5': - resolution: {integrity: sha512-ElTYOh50InL8kzyUD6XsnPit7jYCKrphmddKAe1/Ytt74apOxDq5YEcbsiKs0fR3vff3jEneMM+3I7jbqaMyBg==} + '@rollup/rollup-win32-ia32-msvc@4.24.0': + resolution: {integrity: sha512-xrNcGDU0OxVcPTH/8n/ShH4UevZxKIO6HJFK0e15XItZP2UcaiLFd5kiX7hJnqCbSztUF8Qot+JWBC/QXRPYWQ==} cpu: [ia32] os: [win32] - '@rollup/rollup-win32-x64-msvc@4.22.5': - resolution: {integrity: sha512-+lvL/4mQxSV8MukpkKyyvfwhH266COcWlXE/1qxwN08ajovta3459zrjLghYMgDerlzNwLAcFpvU+WWE5y6nAQ==} + '@rollup/rollup-win32-x64-msvc@4.24.0': + resolution: {integrity: sha512-fbMkAF7fufku0N2dE5TBXcNlg0pt0cJue4xBRE2Qc5Vqikxr4VCgKj/ht6SMdFcOacVA9rqF70APJ8RN/4vMJw==} cpu: [x64] os: [win32] @@ -2758,8 +2746,8 @@ packages: '@sinonjs/fake-timers@10.3.0': resolution: {integrity: sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==} - '@smithy/types@3.4.2': - resolution: {integrity: sha512-tHiFcfcVedVBHpmHUEUHOCCih8iZbIAYn9NvPsNzaPm/237I3imdDdZoOC8c87H5HBAVEa06tTgb+OcSWV9g5w==} + '@smithy/types@3.5.0': + resolution: {integrity: sha512-QN0twHNfe8mNJdH9unwsCK13GURU7oEAZqkBI+rsvpv1jrmserO+WnLE7jidR9W/1dxwZ0u/CB01mV2Gms/K2Q==} engines: {node: '>=16.0.0'} '@socket.io/component-emitter@3.1.2': @@ -3002,15 +2990,6 @@ packages: '@tsconfig/node16@1.0.4': resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} - '@typechain/ethers-v5@11.1.2': - resolution: {integrity: sha512-ID6pqWkao54EuUQa0P5RgjvfA3MYqxUQKpbGKERbsjBW5Ra7EIXvbMlPp2pcP5IAdUkyMCFYsP2SN5q7mPdLDQ==} - peerDependencies: - '@ethersproject/abi': ^5.0.0 - '@ethersproject/providers': ^5.0.0 - ethers: ^5.1.3 - typechain: ^8.3.2 - typescript: '>=4.3.0' - '@typechain/ethers-v6@0.5.1': resolution: {integrity: sha512-F+GklO8jBWlsaVV+9oHaPh5NJdd6rAKN4tklGfInX1Q7h0xPgVLP39Jl3eCulPB5qexI71ZFHwbljx4ZXNfouA==} peerDependencies: @@ -3062,12 +3041,6 @@ packages: '@types/diff@5.2.0': resolution: {integrity: sha512-pjJH+02ukgJRW0mViDUA1cdC+wzSgRu0e4cPuogPLAw0i66y62iMP0ZlXoJAmoXrKRZnF3pMDwyKZsgNVlMX4A==} - '@types/docker-modem@3.0.6': - resolution: {integrity: sha512-yKpAGEuKRSS8wwx0joknWxsmLha78wNMe9R2S3UNsVOkZded8UqOrV8KoeDXoXsjndxwyF3eIhyClGbO1SEhEg==} - - '@types/dockerode@3.3.31': - resolution: {integrity: sha512-42R9eoVqJDSvVspV89g7RwRqfNExgievLNWoHkg7NoWIqAmavIbgQBb4oc0qRtHkxE+I3Xxvqv7qVXFABKPBTg==} - '@types/dom-screen-wake-lock@1.0.3': resolution: {integrity: sha512-3Iten7X3Zgwvk6kh6/NRdwN7WbZ760YgFCsF5AxDifltUQzW1RaW+WRmcVtgwFzLjaNu64H+0MPJ13yRa8g3Dw==} @@ -3125,8 +3098,8 @@ packages: '@types/minimatch@5.1.2': resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==} - '@types/mocha@10.0.8': - resolution: {integrity: sha512-HfMcUmy9hTMJh66VNcmeC9iVErIZJli2bszuXc6julh5YGuRb/W5OnkHjwLNYdFlMis0sY3If5SEAp+PktdJjw==} + '@types/mocha@10.0.9': + resolution: {integrity: sha512-sicdRoWtYevwxjOHNMPTl3vSfJM6oyW8o1wXeI7uww6b6xHg8eBznQDNSGBCDJmsE8UMxP05JgZRtsKbTqt//Q==} '@types/ms@0.7.34': resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} @@ -3143,9 +3116,6 @@ packages: '@types/node@18.15.13': resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} - '@types/node@18.19.54': - resolution: {integrity: sha512-+BRgt0G5gYjTvdLac9sIeE0iZcJxi4Jc4PV5EUzqi+88jmQLr+fRZdv2tCTV7IHKSGxM6SaLoOXQWWUiLUItMw==} - '@types/node@20.12.7': resolution: {integrity: sha512-wq0cICSkRLVaf3UGLMGItu/PtdY7oaXaI/RVU+xliKVOtRna3PRY57ZDfztpDL0n11vfymMUnXv8QwYCO7L1wg==} @@ -3185,15 +3155,6 @@ packages: '@types/semver@7.5.8': resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} - '@types/ssh2-streams@0.1.12': - resolution: {integrity: sha512-Sy8tpEmCce4Tq0oSOYdfqaBpA3hDM8SoxoFh5vzFsu2oL+znzGz8oVWW7xb4K920yYMUY+PIG31qZnFMfPWNCg==} - - '@types/ssh2@0.5.52': - resolution: {integrity: sha512-lbLLlXxdCZOSJMCInKH2+9V/77ET2J6NPQHpFI0kda61Dd1KglJs+fPQBchizmzYSOJBgdTajhPqBO1xxLywvg==} - - '@types/ssh2@1.15.1': - resolution: {integrity: sha512-ZIbEqKAsi5gj35y4P4vkJYly642wIbY6PqoN0xiyQGshKUGXR9WQjF/iF9mXBQ8uBKy3ezfsCkcoHKhd0BzuDA==} - '@types/stack-utils@2.0.3': resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} @@ -3627,18 +3588,6 @@ packages: appdirsjs@1.2.7: resolution: {integrity: sha512-Quji6+8kLBC3NnBeo14nPDq0+2jUs5s3/xEye+udFHumHhRk4M7aAMXp/PBJqkKYGuuyR9M/6Dq7d2AViiGmhw==} - archiver-utils@2.1.0: - resolution: {integrity: sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==} - engines: {node: '>= 6'} - - archiver-utils@3.0.4: - resolution: {integrity: sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==} - engines: {node: '>= 10'} - - archiver@5.3.2: - resolution: {integrity: sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==} - engines: {node: '>= 10'} - arg@4.1.3: resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} @@ -3739,9 +3688,6 @@ packages: async-limiter@1.0.1: resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==} - async-lock@1.4.1: - resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==} - async-mutex@0.2.6: resolution: {integrity: sha512-Hs4R+4SPgamu6rSGW8C7cV9gaWUKEHykfzCCvIRuaVv636Ju10ZdeUbvb4TBEW0INuq2DHZqXbK4Nd3yG4RaRw==} @@ -3799,9 +3745,6 @@ packages: resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==} engines: {node: '>= 0.4'} - b4a@1.6.7: - resolution: {integrity: sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==} - babel-core@7.0.0-bridge.0: resolution: {integrity: sha512-poPX9mZH/5CSanm50Q+1toVci6pv5KSRv/5TWCwtzQS5XEwn40BcCrgIeMFWP9CKKIniKXNxoIOnOq4VVlGXhg==} peerDependencies: @@ -3853,21 +3796,6 @@ packages: balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} - bare-events@2.5.0: - resolution: {integrity: sha512-/E8dDe9dsbLyh2qrZ64PEPadOQ0F4gbl1sUJOrmph7xOiIxfY8vwab/4bFLh4Y88/Hk/ujKcrQKc+ps0mv873A==} - - bare-fs@2.3.5: - resolution: {integrity: sha512-SlE9eTxifPDJrT6YgemQ1WGFleevzwY+XAP1Xqgl56HtcrisC2CHCZ2tq6dBpcH2TnNxwUEUGhweo+lrQtYuiw==} - - bare-os@2.4.4: - resolution: {integrity: sha512-z3UiI2yi1mK0sXeRdc4O1Kk8aOa/e+FNWZcTiPB/dfTWyLypuE99LibgRaQki914Jq//yAWylcAt+mknKdixRQ==} - - bare-path@2.1.3: - resolution: {integrity: sha512-lh/eITfU8hrj9Ru5quUp0Io1kJWIk1bTjzo7JH1P5dWmQ2EL4hFUlfI8FonAhSlgIfhn63p84CDY/x+PisgcXA==} - - bare-stream@2.3.0: - resolution: {integrity: sha512-pVRWciewGUeCyKEuRxwv06M079r+fRjAQjBEK2P6OYGrO43O+Z0LrPZZEjlc4mB6C2RpZ9AxJ1s7NLEtOHO6eA==} - base-x@3.0.10: resolution: {integrity: sha512-7d0s06rR9rYaIWHkpfLIFICM/tkSVdoPC9qYAQRpxn9DdKNWNsKC0uk++akckyLq16Tx2WIinnZ6WRriAt6njQ==} @@ -3981,9 +3909,6 @@ packages: bser@2.1.1: resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==} - buffer-crc32@0.2.13: - resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==} - buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} @@ -4018,10 +3943,6 @@ packages: resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==} engines: {node: '>=6.14.2'} - buildcheck@0.0.6: - resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==} - engines: {node: '>=10.0.0'} - bundle-require@4.2.1: resolution: {integrity: sha512-7Q/6vkyYAwOmQNRw75x+4yRtZCZJXUDmHHlFdkiV0wgv/reNjtJwpu1jPJ0w2kbEpIM0uoKI3S4/f39dU7AjSA==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -4032,10 +3953,6 @@ packages: resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==} engines: {node: '>=10.16.0'} - byline@5.0.0: - resolution: {integrity: sha512-s6webAy+R4SR8XVuJWt2V2rGvhnrhxN+9S15GNuTK3wKPOXFF6RNc+8ug2XhH+2s4f+uudG4kUVYmYOQWL2g0Q==} - engines: {node: '>=0.10.0'} - bytes@3.0.0: resolution: {integrity: sha512-pMhOfFDPiv9t5jjIXkHosWmkSyQbvsgEVNkz0ERHbuLh2T/7j4Mqqpz523Fe8MVY89KC6Sh/QfS2sM+SjgFDcw==} engines: {node: '>= 0.8'} @@ -4107,8 +4024,8 @@ packages: resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} engines: {node: '>=10'} - caniuse-lite@1.0.30001664: - resolution: {integrity: sha512-AmE7k4dXiNKQipgn7a2xg558IRqPN3jMQY/rOsbxDhrd0tyChwbITBfiwtnqz8bi2M5mIWbxAYBvk7W7QBUS2g==} + caniuse-lite@1.0.30001667: + resolution: {integrity: sha512-7LTwJjcRkzKFmtqGsibMeuXmvFDfZq/nzIjnmgCGzKKRVzjD72selLDK1oPF/Oxzmt4fNcPvTDvGqSDG4tCALw==} caseless@0.12.0: resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} @@ -4364,10 +4281,6 @@ packages: compare-versions@6.1.1: resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==} - compress-commons@4.1.2: - resolution: {integrity: sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==} - engines: {node: '>= 10'} - compressible@2.0.18: resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==} engines: {node: '>= 0.6'} @@ -4383,8 +4296,8 @@ packages: resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} engines: {'0': node >= 0.8} - confbox@0.1.7: - resolution: {integrity: sha512-uJcB/FKZtBMCJpK8MQji6bJHgu1tixKPxRLeGkNzBoOZzpnZUJm0jm2/sBDWcuBx1dYgxV4JU+g5hmNxCyAmdA==} + confbox@0.1.8: + resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} config-chain@1.1.13: resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==} @@ -4424,8 +4337,8 @@ packages: resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} engines: {node: '>= 0.6'} - cookie@0.6.0: - resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==} + cookie@0.7.1: + resolution: {integrity: sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==} engines: {node: '>= 0.6'} core-js-compat@3.38.1: @@ -4463,19 +4376,11 @@ packages: typescript: optional: true - cpu-features@0.0.10: - resolution: {integrity: sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA==} - engines: {node: '>=10.0.0'} - crc-32@1.2.2: resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} engines: {node: '>=0.8'} hasBin: true - crc32-stream@4.0.3: - resolution: {integrity: sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==} - engines: {node: '>= 10'} - create-hash@1.2.0: resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} @@ -4500,13 +4405,8 @@ packages: resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} engines: {node: '>= 8'} - crossws@0.2.4: - resolution: {integrity: sha512-DAxroI2uSOgUKLz00NX6A8U/8EE3SZHmIND+10jkVSaypvyt57J5JEOxAQOL6lQxyzi/wZbTIwssU1uy69h5Vg==} - peerDependencies: - uWebSockets.js: '*' - peerDependenciesMeta: - uWebSockets.js: - optional: true + crossws@0.3.1: + resolution: {integrity: sha512-HsZgeVYaG+b5zA+9PbIPGq4+J/CJynJuearykPsXx4V/eMhyQ5EDVg3Ak2FBZtVXCiOLu/U7IiwDHTr9MA+IKw==} crypt@0.0.2: resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} @@ -4760,18 +4660,6 @@ packages: dlv@1.1.3: resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==} - docker-compose@0.24.8: - resolution: {integrity: sha512-plizRs/Vf15H+GCVxq2EUvyPK7ei9b/cVesHvjnX4xaXjM9spHe2Ytq0BitndFgvTJ3E3NljPNUEl7BAN43iZw==} - engines: {node: '>= 6.0.0'} - - docker-modem@3.0.8: - resolution: {integrity: sha512-f0ReSURdM3pcKPNS30mxOHSbaFLcknGmQjwSfmbcdOw1XWKXVhukM3NJHhr7NpY9BIyyWQb0EBo3KQvvuU5egQ==} - engines: {node: '>= 8.0'} - - dockerode@3.3.5: - resolution: {integrity: sha512-/0YNa3ZDNeLr/tSckmD69+Gq+qVNhvKfAHNeZJBnp7EOP6RGKV8ORrJHkUn20So5wU+xxT7+1n5u8PjHbfjbSA==} - engines: {node: '>= 8.0'} - doctrine@2.1.0: resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} engines: {node: '>=0.10.0'} @@ -4829,8 +4717,8 @@ packages: engines: {node: '>=0.10.0'} hasBin: true - electron-to-chromium@1.5.29: - resolution: {integrity: sha512-PF8n2AlIhCKXQ+gTpiJi0VhcHDb69kYX4MtCiivctc2QD3XuNZ/XIOlbGzt7WAjjEev0TtaH6Cu3arZExm5DOw==} + electron-to-chromium@1.5.34: + resolution: {integrity: sha512-/TZAiChbAflBNjCg+VvstbcwAtIL/VdMFO3NgRFIzBjpvPzWOTIbbO8kNb6RwU4bt9TP7K+3KqBKw/lOU+Y+GA==} elliptic@6.5.4: resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==} @@ -4924,8 +4812,8 @@ packages: es-get-iterator@1.1.3: resolution: {integrity: sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==} - es-iterator-helpers@1.0.19: - resolution: {integrity: sha512-zoMwbCcH5hwUkKJkT8kDIBZSz9I6mVG//+lDCinLCGov4+r7NIy0ld8o03M0cJxl2spVf6ESYVS6/gpIfq1FFw==} + es-iterator-helpers@1.1.0: + resolution: {integrity: sha512-/SurEfycdyssORP/E+bj4sEu1CWw4EmLDsHynHwSXQ7utgbrMRWW195pTrCjFgFCddf/UkYm3oqKPRq5i8bJbw==} engines: {node: '>= 0.4'} es-object-atoms@1.0.0: @@ -5043,12 +4931,12 @@ packages: eslint-import-resolver-webpack: optional: true - eslint-plugin-import@2.30.0: - resolution: {integrity: sha512-/mHNE9jINJfiD2EKkg1BKyPyUk4zdnT54YgbOgfjSakWT5oyX/qQLVNTkehyfpcMxZXMy1zyonZ2v7hZTX43Yw==} + eslint-plugin-import@2.31.0: + resolution: {integrity: sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==} engines: {node: '>=4'} peerDependencies: '@typescript-eslint/parser': '*' - eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 + eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9 peerDependenciesMeta: '@typescript-eslint/parser': optional: true @@ -5079,8 +4967,8 @@ packages: peerDependencies: eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 - eslint-plugin-react@7.37.0: - resolution: {integrity: sha512-IHBePmfWH5lKhJnJ7WB1V+v/GolbB0rjS8XYVCSQCZKaQCAUhMoVoOEn1Ef8Z8Wf0a7l8KTJvuZg5/e4qrZ6nA==} + eslint-plugin-react@7.37.1: + resolution: {integrity: sha512-xwTnwDqzbDRA8uJ7BMxPs/EXRB3i8ZfnOIp8BsxEQkT0nHPp+WWceqGgo6rKb9ctNi8GJLDT4Go5HAWELa/WMg==} engines: {node: '>=4'} peerDependencies: eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7 @@ -5210,6 +5098,10 @@ packages: resolution: {integrity: sha512-9VkriTTed+/27BGuY1s0hf441kqwHJ1wtN2edksEtiRvXx+soxRX3iSXTfFqq2+YwrOqbDoTHjIhQnjJRlzKmg==} engines: {node: '>=14.0.0'} + ethers@6.13.3: + resolution: {integrity: sha512-/DzbZOLVtoO4fKvvQwpEucHAQgIwBGWuRvBdwE/lMXgXvvHHTSkn7XqAQ2b+gjJzZDJjWA9OD05bVceVOsBHbg==} + engines: {node: '>=14.0.0'} + ethjs-unit@0.1.6: resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==} engines: {node: '>=6.5.0', npm: '>=3'} @@ -5271,8 +5163,8 @@ packages: exponential-backoff@3.1.1: resolution: {integrity: sha512-dX7e/LHVJ6W3DE1MHWi9S1EYzDESENfLrYohG2G++ovZrYOkm4Knwa0mc1cn84xJOR4KEU0WSchhLbd0UklbHw==} - express@4.21.0: - resolution: {integrity: sha512-VqcNGcj/Id5ZT1LZ/cfihi3ttTn+NJmkli2eZADigjq29qTlWi/hAQ43t/VLPq8+UX06FCEx3ByOYet6ZFblng==} + express@4.21.1: + resolution: {integrity: sha512-YSFlK1Ee0/GC8QaO91tHcDxJiE/X4FbpAyQWkxAvG6AXCuR65YzK8ua6D9hvi/TzUfZMpc+BwuM1IPw8fmQBiQ==} engines: {node: '>= 0.10.0'} ext@1.7.0: @@ -5301,9 +5193,6 @@ packages: fast-diff@1.3.0: resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} - fast-fifo@1.3.2: - resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==} - fast-glob@3.3.2: resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} engines: {node: '>=8.6.0'} @@ -5589,10 +5478,6 @@ packages: resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} engines: {node: '>=4'} - get-port@5.1.1: - resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} - engines: {node: '>=8'} - get-port@6.1.2: resolution: {integrity: sha512-BrGGraKm2uPqurfGVj/z97/zv8dPleC6x9JBNRTrDNtCkkRF4rPwrQXFgL7+I+q8QSdU4ntLQX2D7KIxSy8nGw==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -5723,8 +5608,8 @@ packages: graphemer@1.4.0: resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} - h3@1.12.0: - resolution: {integrity: sha512-Zi/CcNeWBXDrFNlV0hUBJQR9F7a96RjMeAZweW/ZWkR9fuXrMcvKnSA63f/zZ9l0GgQOZDVHGvXivNN9PWOwhA==} + h3@1.13.0: + resolution: {integrity: sha512-vFEAu/yf8UMUcB4s43OaDaigcqpQd14yanmOsn+NcRX3/guSKncyE2rOYhq8RIchgJrPSs/QiIddnTTR1ddiAg==} handlebars@4.7.8: resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} @@ -6273,8 +6158,9 @@ packages: iterate-object@1.3.4: resolution: {integrity: sha512-4dG1D1x/7g8PwHS9aK6QV5V94+ZvyP4+d19qDv43EzImmrndysIl4prmJ1hWWIGCqrZHyaHBm6BSEWHOLnpoNw==} - iterator.prototype@1.1.2: - resolution: {integrity: sha512-DR33HMMr8EzwuRL8Y9D3u2BMj8+RqSE850jfGu59kS7tbmPLzGkZmVSfyCFSDxuZiEY6Rzt3T2NA/qU+NwVj1w==} + iterator.prototype@1.1.3: + resolution: {integrity: sha512-FW5iMbeQ6rBGm/oKgzq2aW4KvAGpxPzYES8N4g4xNXUKpL1mclMvOe+76AcLDTvD+Ze+sOpVhgdAQEKF4L9iGQ==} + engines: {node: '>= 0.4'} jackspeak@2.3.6: resolution: {integrity: sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==} @@ -6432,8 +6318,8 @@ packages: resolution: {integrity: sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==} hasBin: true - jiti@2.0.0: - resolution: {integrity: sha512-CJ7e7Abb779OTRv3lomfp7Mns/Sy1+U4pcAx5VbjxCZD5ZM/VJaXPpPjNKjtSvWQy/H86E49REXR34dl1JEz9w==} + jiti@2.3.3: + resolution: {integrity: sha512-EX4oNDwcXSivPrw2qKH2LB5PoFxEvgtv2JgwW0bU858HoLQ+kutSvjLMUqBd0PeJYEinLWhoI9Ol0eYMqj/wNQ==} hasBin: true joi@17.13.3: @@ -6481,13 +6367,9 @@ packages: peerDependencies: '@babel/preset-env': ^7.1.6 - jsesc@0.5.0: - resolution: {integrity: sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==} - hasBin: true - - jsesc@2.5.2: - resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} - engines: {node: '>=4'} + jsesc@3.0.2: + resolution: {integrity: sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==} + engines: {node: '>=6'} hasBin: true json-buffer@3.0.1: @@ -6582,10 +6464,6 @@ packages: resolution: {integrity: sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg==} engines: {node: '>=14.16'} - lazystream@1.0.1: - resolution: {integrity: sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==} - engines: {node: '>= 0.6.3'} - leven@3.1.0: resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} engines: {node: '>=6'} @@ -6598,8 +6476,8 @@ packages: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} - libphonenumber-js@1.11.9: - resolution: {integrity: sha512-Zs5wf5HaWzW2/inlupe2tstl0I/Tbqo7lH20ZLr6Is58u7Dz2n+gRFGNlj9/gWxFvNfp9+YyDsiegjNhdixB9A==} + libphonenumber-js@1.11.11: + resolution: {integrity: sha512-mF3KaORjJQR6JBNcOkluDcJKhtoQT4VTLRMrX1v/wlBayL4M8ybwEDeryyPcrSEJmD0rVwHUbBarpZwN5NfPFQ==} lighthouse-logger@1.4.2: resolution: {integrity: sha512-gPWxznF6TKmUHrOQjlVo2UbaL2EJ71mb2CCeRs/2qBpi4L/g4LUVc9+3lKQ6DTUZwJswfM7ainGrLO1+fOqa2g==} @@ -6618,21 +6496,21 @@ packages: listenercount@1.0.1: resolution: {integrity: sha512-3mk/Zag0+IJxeDrxSgaDPy4zZ3w05PRZeJNnlWhzFz5OkX49J4krc+A8X2d2M69vGMBEX0uyl8M+W+8gH+kBqQ==} - listhen@1.8.0: - resolution: {integrity: sha512-Wj5hk++HPDqnG/0nc9++oXf8M3GlzObC6AJJJ9VYAVhVTdeW+t3HyeiKhK6Ro0GPhVd8lOYM75zsckrtzLB2Gw==} + listhen@1.9.0: + resolution: {integrity: sha512-I8oW2+QL5KJo8zXNWX046M134WchxsXC7SawLPvRQpogCbkyQIaFxPE89A2HiwR7vAK2Dm2ERBAmyjTYGYEpBg==} hasBin: true lit-element@3.3.3: resolution: {integrity: sha512-XbeRxmTHubXENkV4h8RIPyr8lXc+Ff28rkcQzw3G6up2xg5E8Zu1IgOWIwBLEQsu3cOVFqdYwiVi0hv0SlpqUA==} - lit-element@4.1.0: - resolution: {integrity: sha512-gSejRUQJuMQjV2Z59KAS/D4iElUhwKpIyJvZ9w+DIagIQjfJnhR20h2Q5ddpzXGS+fF0tMZ/xEYGMnKmaI/iww==} + lit-element@4.1.1: + resolution: {integrity: sha512-HO9Tkkh34QkTeUmEdNYhMT8hzLid7YlMlATSi1q4q17HE5d9mrrEHJ/o8O2D0cMi182zK1F3v7x0PWFjrhXFew==} lit-html@2.8.0: resolution: {integrity: sha512-o9t+MQM3P4y7M7yNzqAyjp7z+mQGa4NS4CxiyLqFPyFWyc4O+nodLrkrxSaCTrla6M5YOLaT3RpbbqjszB5g3Q==} - lit-html@3.2.0: - resolution: {integrity: sha512-pwT/HwoxqI9FggTrYVarkBKFN9MlTUpLrDHubTmW4SrkL3kkqW5gxwbxMMUnbbRHBC0WTZnYHcjDSCM559VyfA==} + lit-html@3.2.1: + resolution: {integrity: sha512-qI/3lziaPMSKsrwlxH/xMgikhQ0EGOX2ICU73Bi/YHFvz2j/yMCIrw4+puF2IpQ4+upd3EWbvnHM9+PnJn48YA==} lit@2.8.0: resolution: {integrity: sha512-4Sc3OFX9QHOJaHbmTMk28SYgVxLN3ePDjg7hofEft2zWlehFL3LiAuapWc4U/kYwMYJSh2hTCPZ6/LIC7ii0MA==} @@ -6669,21 +6547,9 @@ packages: lodash.debounce@4.0.8: resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} - lodash.defaults@4.2.0: - resolution: {integrity: sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==} - - lodash.difference@4.5.0: - resolution: {integrity: sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==} - - lodash.flatten@4.4.0: - resolution: {integrity: sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==} - lodash.isequal@4.5.0: resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} - lodash.isplainobject@4.0.6: - resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==} - lodash.memoize@4.1.2: resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} @@ -6699,9 +6565,6 @@ packages: lodash.truncate@4.4.2: resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==} - lodash.union@4.6.0: - resolution: {integrity: sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==} - lodash@4.17.21: resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} @@ -7022,8 +6885,8 @@ packages: engines: {node: '>=10'} hasBin: true - mlly@1.7.1: - resolution: {integrity: sha512-rrVRZRELyQzrIUAVMHxP97kv+G786pHmOKzuFII8zDYahFBS7qnHh2AlYSl1GAHhaMPCz6/oHjVMcfFYgFYHgA==} + mlly@1.7.2: + resolution: {integrity: sha512-tN3dvVHYVz4DhSXinXIk7u9syPYaJvio118uomkovAtWBT+RdbP6Lfh/5Lvo519YMmwBafwlh20IPTXIStscpA==} mnemonist@0.38.5: resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} @@ -7077,9 +6940,6 @@ packages: mz@2.7.0: resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} - nan@2.20.0: - resolution: {integrity: sha512-bk3gXBZDGILuuo/6sKtr0DQmSThYHLtNCdSdXk9YkxD/jK6X2vmCyyXBBxyqZ4XcnzTyYEAThfX3DCEnLf6igw==} - nano-json-stream-parser@0.1.2: resolution: {integrity: sha512-9MqxMH/BSJC7dnLsEMPyfN5Dvoo49IsPFYMcHw3Bcfc2kN0lpHRBSzlMSVx4HGyJ7s9B31CyBTVehWJoQ8Ctew==} @@ -7243,8 +7103,8 @@ packages: resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} - npm@10.8.3: - resolution: {integrity: sha512-0IQlyAYvVtQ7uOhDFYZCGK8kkut2nh8cpAdA9E6FvRSJaTgtZRZgNjlC5ZCct//L73ygrpY93CxXpRJDtNqPVg==} + npm@10.9.0: + resolution: {integrity: sha512-ZanDioFylI9helNhl2LNd+ErmVD+H5I53ry41ixlLyCBgkuYb+58CvbAp99hW+zr5L9W4X7CchSoeqKdngOLSw==} engines: {node: ^18.17.0 || >=20.5.0} hasBin: true bundledDependencies: @@ -7387,8 +7247,8 @@ packages: oboe@2.1.5: resolution: {integrity: sha512-zRFWiF+FoicxEs3jNI/WYUrVEgA7DeET/InK0XQuudGHRg8iIob3cNPrJTKaz4004uaA9Pbe+Dwa8iluhjLZWA==} - ofetch@1.4.0: - resolution: {integrity: sha512-MuHgsEhU6zGeX+EMh+8mSMrYTnsqJQQrpM00Q6QHMKNqQ0bKy0B43tk8tL1wg+CnsSTy1kg4Ir2T5Ig6rD+dfQ==} + ofetch@1.4.1: + resolution: {integrity: sha512-QZj2DfGplQAr2oj9KzceK9Hwz6Whxazmn85yYeVuS3u9XTMOGMRx0kO95MQ+vLsj/S/NwBDMMLU5hpxvI6Tklw==} ohash@1.1.4: resolution: {integrity: sha512-FlDryZAahJmEF3VR3w1KogSEdWX3WhA5GPakFx4J81kEAiHyLMpdLLElS8n8dfNadMgAne/MywcvmogzscVt4g==} @@ -7679,8 +7539,8 @@ packages: resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} engines: {node: '>=8'} - pkg-types@1.2.0: - resolution: {integrity: sha512-+ifYuSSqOQ8CqP4MbZA5hDpb97n3E8SVWdJe+Wms9kj745lmd3b7EZJiqvmLwAlmRfjrI7Hi5z3kdBJ93lFNPA==} + pkg-types@1.2.1: + resolution: {integrity: sha512-sQoqa8alT3nHjGuTjuKgOnvjo4cljkufdtLMnO2LBP/wRwuDlo1tkaEdMxCRhyGRPacv/ztlZgDPm2b7FAmEvw==} playwright-core@1.45.3: resolution: {integrity: sha512-+ym0jNbcjikaOwwSZycFbwkWgfruWvYlJfThKYAlImbxUgdWFO2oW70ojPm4OpE4t6TAo2FY/smM+hpVTtkhDA==} @@ -7769,8 +7629,8 @@ packages: resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==} engines: {node: '>=0.10.0'} - preact@10.24.1: - resolution: {integrity: sha512-PnBAwFI3Yjxxcxw75n6VId/5TFxNW/81zexzWD9jn1+eSrOP84NdsS38H5IkF/UH3frqRPT+MvuCoVHjTDTnDw==} + preact@10.24.2: + resolution: {integrity: sha512-1cSoF0aCC8uaARATfrlz4VCBqE8LwZwRfLgkxJOQwAlQt6ayTmi0D9OF7nXid1POI5SZidFuG9CnlXbDfLqY/Q==} prebuild-install@7.1.2: resolution: {integrity: sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==} @@ -7852,10 +7712,6 @@ packages: proper-lockfile@4.1.2: resolution: {integrity: sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==} - properties-reader@2.3.0: - resolution: {integrity: sha512-z597WicA7nDZxK12kZqHr2TcvwNU1GCfA5UwfDY/HDp3hXPoPlb5rlEx9bwGTiJnc0OqbBTkU975jDToth8Gxw==} - engines: {node: '>=14'} - proto-list@1.2.4: resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==} @@ -7920,9 +7776,6 @@ packages: queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - queue-tick@1.0.1: - resolution: {integrity: sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==} - queue@6.0.2: resolution: {integrity: sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==} @@ -7994,8 +7847,8 @@ packages: react: '*' react-native: '*' - react-native@0.75.3: - resolution: {integrity: sha512-+Ne6u5H+tPo36sme19SCd1u2UID2uo0J/XzAJarxmrDj4Nsdi44eyUDKtQHmhgxjRGsuVJqAYrMK0abLSq8AHw==} + react-native@0.75.4: + resolution: {integrity: sha512-Jehg4AMNIAXu9cn0/1jbTCoNg3tc+t6EekwucCalN8YoRmxGd/PY6osQTI/5fSAM40JQ4O8uv8Qg09Ycpb5sxQ==} engines: {node: '>=18'} hasBin: true peerDependencies: @@ -8033,9 +7886,6 @@ packages: resolution: {integrity: sha512-yjavECdqeZ3GLXNgRXgeQEdz9fvDDkNKyHnbHRFtOr7/LcfgBcmct7t/ET+HaCTqfh06OzoAxrkN/IfjJBVe+g==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - readdir-glob@1.1.3: - resolution: {integrity: sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==} - readdirp@3.6.0: resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} engines: {node: '>=8.10.0'} @@ -8086,12 +7936,12 @@ packages: regenerator-transform@0.15.2: resolution: {integrity: sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==} - regexp.prototype.flags@1.5.2: - resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} + regexp.prototype.flags@1.5.3: + resolution: {integrity: sha512-vqlC04+RQoFalODCbCumG2xIOvapzVMHwsyIGM/SIE8fRhFFsXeH8/QQ+s0T0kDAhKc4k30s73/0ydkHQz6HlQ==} engines: {node: '>= 0.4'} - regexpu-core@5.3.2: - resolution: {integrity: sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==} + regexpu-core@6.1.1: + resolution: {integrity: sha512-k67Nb9jvwJcJmVpw0jPttR1/zVfnKf8Km0IPatrU/zJ5XeG3+Slx0xLXs9HByJSzXzrlz5EDvN6yLNMDc2qdnw==} engines: {node: '>=4'} registry-auth-token@5.0.2: @@ -8102,8 +7952,11 @@ packages: resolution: {integrity: sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q==} engines: {node: '>=12'} - regjsparser@0.9.1: - resolution: {integrity: sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==} + regjsgen@0.8.0: + resolution: {integrity: sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==} + + regjsparser@0.11.1: + resolution: {integrity: sha512-1DHODs4B8p/mQHU9kr+jv8+wIC9mtG4eBHxWxIq5mhjE3D5oORhCc6deRKzTjs9DcfRFmj9BHSDguZklqCGFWQ==} hasBin: true req-cwd@2.0.0: @@ -8233,8 +8086,8 @@ packages: rollup: optional: true - rollup@4.22.5: - resolution: {integrity: sha512-WoinX7GeQOFMGznEcWA1WrTQCd/tpEbMkc3nuMs9BT0CPjMdSjPMTVClwWd4pgSQwJdP65SK9mTCNvItlr5o7w==} + rollup@4.24.0: + resolution: {integrity: sha512-DOmrlGSXNk1DM0ljiQA+i+o0rSLhtii1je5wgk60j49d1jHT5YYttBv1iWOnYSTG+fZZESUOSNiAl89SIet+Cg==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true @@ -8500,9 +8353,6 @@ packages: resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} engines: {node: '>= 8'} - split-ca@1.0.1: - resolution: {integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==} - split-on-first@1.1.0: resolution: {integrity: sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==} engines: {node: '>=6'} @@ -8517,13 +8367,6 @@ packages: sprintf-js@1.1.3: resolution: {integrity: sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==} - ssh-remote-port-forward@1.0.4: - resolution: {integrity: sha512-x0LV1eVDwjf1gmG7TTnfqIzf+3VPRz7vrNIjX6oYLbeCrf/PeVY6hkT68Mg+q02qXxQhrLjB0jfgvhevoCRmLQ==} - - ssh2@1.16.0: - resolution: {integrity: sha512-r1X4KsBGedJqo7h8F5c4Ybpcr5RjyP+aWIG007uBPRjmdQWfEiVLzSK71Zji1B9sKxwaCvD8y8cwSkYrlLiRRg==} - engines: {node: '>=10.16.0'} - sshpk@1.18.0: resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} engines: {node: '>=0.10.0'} @@ -8569,9 +8412,6 @@ packages: resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==} engines: {node: '>=10.0.0'} - streamx@2.20.1: - resolution: {integrity: sha512-uTa0mU6WUC65iUvzKH4X9hEdvSW7rbPxPtwfWiLMSj3qTdQbAiUboZTxauKfpFuGIGa1C2BYijZ7wgdUXICJhA==} - strict-uri-encode@1.1.0: resolution: {integrity: sha512-R3f198pcvnB+5IpnBlRkphuE9n46WyVl8I39W/ZUTZLz4nqSP/oLYUrcnJrw462Ds8he4YKMov2efsTIw1BDGQ==} engines: {node: '>=0.10.0'} @@ -8777,22 +8617,13 @@ packages: resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==} engines: {node: '>=6'} - tar-fs@2.0.1: - resolution: {integrity: sha512-6tzWDMeroL87uF/+lin46k+Q+46rAJ0SyPGz7OW7wTgblI273hsBqk2C1j0/xNadNLKDTUL9BukSjB7cwgmlPA==} - tar-fs@2.1.1: resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} - tar-fs@3.0.6: - resolution: {integrity: sha512-iokBDQQkUyeXhgPYaZxmczGPhnhXZ0CmrqI+MOb/WFGS9DW5wnfrLgtjUJBvz50vQ3qfRwJ62QVoCFu8mPVu5w==} - tar-stream@2.2.0: resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} engines: {node: '>=6'} - tar-stream@3.1.7: - resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==} - tar@4.4.19: resolution: {integrity: sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==} engines: {node: '>=4.5'} @@ -8814,12 +8645,6 @@ packages: resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} engines: {node: '>=8'} - testcontainers@10.9.0: - resolution: {integrity: sha512-LN+cKAOd61Up9SVMJW+3VFVGeVQG8JBqZhEQo2U0HBfIsAynyAXcsLBSo+KZrOfy9SBz7pGHctWN/KabLDbNFA==} - - text-decoder@1.2.0: - resolution: {integrity: sha512-n1yg1mOj9DNpk3NeZOx7T6jchTbyJS3i3cucbNN6FcdPriMZx7NsgrGpWWdWZZGxD7ES1XB+3uoqHMgOKaN+fg==} - text-encoding-utf-8@1.0.2: resolution: {integrity: sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg==} @@ -8863,10 +8688,6 @@ packages: resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} engines: {node: '>=0.6.0'} - tmp@0.2.3: - resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==} - engines: {node: '>=14.14'} - tmpl@1.0.5: resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==} @@ -9789,10 +9610,6 @@ packages: resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} engines: {node: '>=10'} - zip-stream@4.1.1: - resolution: {integrity: sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==} - engines: {node: '>= 10'} - zksync-ethers@5.9.2: resolution: {integrity: sha512-Y2Mx6ovvxO6UdC2dePLguVzvNToOY8iLWeq5ne+jgGSJxAi/f4He/NF6FNsf6x1aWX0o8dy4Df8RcOQXAkj5qw==} engines: {node: '>=16.0.0'} @@ -9850,43 +9667,43 @@ snapshots: '@aws-crypto/sha256-js@1.2.2': dependencies: '@aws-crypto/util': 1.2.2 - '@aws-sdk/types': 3.654.0 + '@aws-sdk/types': 3.664.0 tslib: 1.14.1 '@aws-crypto/util@1.2.2': dependencies: - '@aws-sdk/types': 3.654.0 + '@aws-sdk/types': 3.664.0 '@aws-sdk/util-utf8-browser': 3.259.0 tslib: 1.14.1 - '@aws-sdk/types@3.654.0': + '@aws-sdk/types@3.664.0': dependencies: - '@smithy/types': 3.4.2 + '@smithy/types': 3.5.0 tslib: 2.7.0 '@aws-sdk/util-utf8-browser@3.259.0': dependencies: tslib: 2.7.0 - '@babel/code-frame@7.24.7': + '@babel/code-frame@7.25.7': dependencies: - '@babel/highlight': 7.24.7 + '@babel/highlight': 7.25.7 picocolors: 1.1.0 - '@babel/compat-data@7.25.4': {} + '@babel/compat-data@7.25.7': {} - '@babel/core@7.25.2': + '@babel/core@7.25.7': dependencies: '@ampproject/remapping': 2.3.0 - '@babel/code-frame': 7.24.7 - '@babel/generator': 7.25.6 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-module-transforms': 7.25.2(@babel/core@7.25.2) - '@babel/helpers': 7.25.6 - '@babel/parser': 7.25.6 - '@babel/template': 7.25.0 - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/code-frame': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-module-transforms': 7.25.7(@babel/core@7.25.7) + '@babel/helpers': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/template': 7.25.7 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 convert-source-map: 2.0.0 debug: 4.3.7(supports-color@8.1.1) gensync: 1.0.0-beta.2 @@ -9895,908 +9712,904 @@ snapshots: transitivePeerDependencies: - supports-color - '@babel/generator@7.25.6': + '@babel/generator@7.25.7': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 '@jridgewell/gen-mapping': 0.3.5 '@jridgewell/trace-mapping': 0.3.25 - jsesc: 2.5.2 + jsesc: 3.0.2 - '@babel/helper-annotate-as-pure@7.24.7': + '@babel/helper-annotate-as-pure@7.25.7': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 - '@babel/helper-builder-binary-assignment-operator-visitor@7.24.7': + '@babel/helper-builder-binary-assignment-operator-visitor@7.25.7': dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-compilation-targets@7.25.2': + '@babel/helper-compilation-targets@7.25.7': dependencies: - '@babel/compat-data': 7.25.4 - '@babel/helper-validator-option': 7.24.8 + '@babel/compat-data': 7.25.7 + '@babel/helper-validator-option': 7.25.7 browserslist: 4.24.0 lru-cache: 5.1.1 semver: 6.3.1 - '@babel/helper-create-class-features-plugin@7.25.4(@babel/core@7.25.2)': + '@babel/helper-create-class-features-plugin@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-member-expression-to-functions': 7.24.8 - '@babel/helper-optimise-call-expression': 7.24.7 - '@babel/helper-replace-supers': 7.25.0(@babel/core@7.25.2) - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-member-expression-to-functions': 7.25.7 + '@babel/helper-optimise-call-expression': 7.25.7 + '@babel/helper-replace-supers': 7.25.7(@babel/core@7.25.7) + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 + '@babel/traverse': 7.25.7 semver: 6.3.1 transitivePeerDependencies: - supports-color - '@babel/helper-create-regexp-features-plugin@7.25.2(@babel/core@7.25.2)': + '@babel/helper-create-regexp-features-plugin@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - regexpu-core: 5.3.2 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + regexpu-core: 6.1.1 semver: 6.3.1 - '@babel/helper-define-polyfill-provider@0.6.2(@babel/core@7.25.2)': + '@babel/helper-define-polyfill-provider@0.6.2(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 debug: 4.3.7(supports-color@8.1.1) lodash.debounce: 4.0.8 resolve: 1.22.8 transitivePeerDependencies: - supports-color - '@babel/helper-member-expression-to-functions@7.24.8': + '@babel/helper-member-expression-to-functions@7.25.7': dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-module-imports@7.24.7': + '@babel/helper-module-imports@7.25.7': dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-module-transforms@7.25.2(@babel/core@7.25.2)': + '@babel/helper-module-transforms@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-imports': 7.24.7 - '@babel/helper-simple-access': 7.24.7 - '@babel/helper-validator-identifier': 7.24.7 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-module-imports': 7.25.7 + '@babel/helper-simple-access': 7.25.7 + '@babel/helper-validator-identifier': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-optimise-call-expression@7.24.7': + '@babel/helper-optimise-call-expression@7.25.7': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 - '@babel/helper-plugin-utils@7.24.8': {} + '@babel/helper-plugin-utils@7.25.7': {} - '@babel/helper-remap-async-to-generator@7.25.0(@babel/core@7.25.2)': + '@babel/helper-remap-async-to-generator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-wrap-function': 7.25.0 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-wrap-function': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-replace-supers@7.25.0(@babel/core@7.25.2)': + '@babel/helper-replace-supers@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-member-expression-to-functions': 7.24.8 - '@babel/helper-optimise-call-expression': 7.24.7 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-member-expression-to-functions': 7.25.7 + '@babel/helper-optimise-call-expression': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-simple-access@7.24.7': + '@babel/helper-simple-access@7.25.7': dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-skip-transparent-expression-wrappers@7.24.7': + '@babel/helper-skip-transparent-expression-wrappers@7.25.7': dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helper-string-parser@7.24.8': {} + '@babel/helper-string-parser@7.25.7': {} - '@babel/helper-validator-identifier@7.24.7': {} + '@babel/helper-validator-identifier@7.25.7': {} - '@babel/helper-validator-option@7.24.8': {} + '@babel/helper-validator-option@7.25.7': {} - '@babel/helper-wrap-function@7.25.0': + '@babel/helper-wrap-function@7.25.7': dependencies: - '@babel/template': 7.25.0 - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/template': 7.25.7 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/helpers@7.25.6': + '@babel/helpers@7.25.7': dependencies: - '@babel/template': 7.25.0 - '@babel/types': 7.25.6 + '@babel/template': 7.25.7 + '@babel/types': 7.25.7 - '@babel/highlight@7.24.7': + '@babel/highlight@7.25.7': dependencies: - '@babel/helper-validator-identifier': 7.24.7 + '@babel/helper-validator-identifier': 7.25.7 chalk: 2.4.2 js-tokens: 4.0.0 picocolors: 1.1.0 - '@babel/parser@7.25.6': + '@babel/parser@7.25.7': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 - '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.3(@babel/core@7.25.2)': + '@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-bugfix-safari-class-field-initializer-scope@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 - '@babel/plugin-transform-optional-chaining': 7.24.8(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 + '@babel/plugin-transform-optional-chaining': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-proposal-class-properties@7.18.6(@babel/core@7.25.2)': + '@babel/plugin-proposal-class-properties@7.18.6(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-proposal-export-default-from@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-proposal-export-default-from@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-export-default-from': 7.24.7(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-export-default-from': 7.25.7(@babel/core@7.25.7) - '@babel/plugin-proposal-nullish-coalescing-operator@7.18.6(@babel/core@7.25.2)': + '@babel/plugin-proposal-nullish-coalescing-operator@7.18.6(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-proposal-optional-chaining@7.21.0(@babel/core@7.25.2)': + '@babel/plugin-proposal-optional-chaining@7.21.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.25.2)': + '@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.25.2)': + '@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.25.2)': + '@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.25.2)': + '@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-export-default-from@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-syntax-export-default-from@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-export-namespace-from@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-export-namespace-from@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-flow@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-syntax-flow@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-import-assertions@7.25.6(@babel/core@7.25.2)': + '@babel/plugin-syntax-import-assertions@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-import-attributes@7.25.6(@babel/core@7.25.2)': + '@babel/plugin-syntax-import-attributes@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.25.2)': + '@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-jsx@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-syntax-jsx@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.25.2)': + '@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.25.2)': + '@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.25.2)': + '@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.25.2)': + '@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.25.2)': + '@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-typescript@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-syntax-typescript@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.25.2)': + '@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-arrow-functions@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-arrow-functions@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-async-generator-functions@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-transform-async-generator-functions@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-remap-async-to-generator': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.2) - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-remap-async-to-generator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.7) + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-async-to-generator@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-async-to-generator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-imports': 7.24.7 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-remap-async-to-generator': 7.25.0(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-module-imports': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-remap-async-to-generator': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-block-scoped-functions@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-block-scoped-functions@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-block-scoping@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-transform-block-scoping@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-class-properties@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-transform-class-properties@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-class-static-block@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-class-static-block@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-classes@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-transform-classes@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-replace-supers': 7.25.0(@babel/core@7.25.2) - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-replace-supers': 7.25.7(@babel/core@7.25.7) + '@babel/traverse': 7.25.7 globals: 11.12.0 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-computed-properties@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-computed-properties@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/template': 7.25.0 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/template': 7.25.7 - '@babel/plugin-transform-destructuring@7.24.8(@babel/core@7.25.2)': + '@babel/plugin-transform-destructuring@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-dotall-regex@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-dotall-regex@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-duplicate-keys@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-duplicate-keys@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-dynamic-import@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-dynamic-import@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-transform-exponentiation-operator@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-exponentiation-operator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-builder-binary-assignment-operator-visitor': 7.24.7 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-builder-binary-assignment-operator-visitor': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-export-namespace-from@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-export-namespace-from@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-transform-flow-strip-types@7.25.2(@babel/core@7.25.2)': + '@babel/plugin-transform-flow-strip-types@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-flow': 7.25.7(@babel/core@7.25.7) - '@babel/plugin-transform-for-of@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-for-of@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-function-name@7.25.1(@babel/core@7.25.2)': + '@babel/plugin-transform-function-name@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-json-strings@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-json-strings@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-transform-literals@7.25.2(@babel/core@7.25.2)': + '@babel/plugin-transform-literals@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-logical-assignment-operators@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-logical-assignment-operators@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.7) - '@babel/plugin-transform-member-expression-literals@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-member-expression-literals@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-modules-amd@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-modules-amd@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-transforms': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-module-transforms': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-modules-commonjs@7.24.8(@babel/core@7.25.2)': + '@babel/plugin-transform-modules-commonjs@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-transforms': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-simple-access': 7.24.7 + '@babel/core': 7.25.7 + '@babel/helper-module-transforms': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-simple-access': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-modules-systemjs@7.25.0(@babel/core@7.25.2)': + '@babel/plugin-transform-modules-systemjs@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-transforms': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-validator-identifier': 7.24.7 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-module-transforms': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-validator-identifier': 7.25.7 + '@babel/traverse': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-modules-umd@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-modules-umd@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-transforms': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-module-transforms': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-named-capturing-groups-regex@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-named-capturing-groups-regex@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-new-target@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-new-target@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-nullish-coalescing-operator@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-nullish-coalescing-operator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-transform-numeric-separator@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-numeric-separator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.7) - '@babel/plugin-transform-object-rest-spread@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-object-rest-spread@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-transform-parameters': 7.24.7(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-transform-parameters': 7.25.7(@babel/core@7.25.7) - '@babel/plugin-transform-object-super@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-object-super@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-replace-supers': 7.25.0(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-replace-supers': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-optional-catch-binding@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-optional-catch-binding@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.7) - '@babel/plugin-transform-optional-chaining@7.24.8(@babel/core@7.25.2)': + '@babel/plugin-transform-optional-chaining@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-parameters@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-parameters@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-private-methods@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-transform-private-methods@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-private-property-in-object@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-private-property-in-object@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-property-literals@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-property-literals@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-react-constant-elements@7.25.1(@babel/core@7.25.2)': + '@babel/plugin-transform-react-constant-elements@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-react-display-name@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-react-display-name@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-react-jsx-development@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-react-jsx-development@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/plugin-transform-react-jsx': 7.25.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/plugin-transform-react-jsx': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-react-jsx-self@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-react-jsx-self@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-react-jsx-source@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-react-jsx-source@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-react-jsx@7.25.2(@babel/core@7.25.2)': + '@babel/plugin-transform-react-jsx@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-module-imports': 7.24.7 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.25.2) - '@babel/types': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-module-imports': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/plugin-syntax-jsx': 7.25.7(@babel/core@7.25.7) + '@babel/types': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-react-pure-annotations@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-react-pure-annotations@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-regenerator@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-regenerator@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 regenerator-transform: 0.15.2 - '@babel/plugin-transform-reserved-words@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-reserved-words@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-runtime@7.25.4(@babel/core@7.25.2)': + '@babel/plugin-transform-runtime@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-module-imports': 7.24.7 - '@babel/helper-plugin-utils': 7.24.8 - babel-plugin-polyfill-corejs2: 0.4.11(@babel/core@7.25.2) - babel-plugin-polyfill-corejs3: 0.10.6(@babel/core@7.25.2) - babel-plugin-polyfill-regenerator: 0.6.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-module-imports': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + babel-plugin-polyfill-corejs2: 0.4.11(@babel/core@7.25.7) + babel-plugin-polyfill-corejs3: 0.10.6(@babel/core@7.25.7) + babel-plugin-polyfill-regenerator: 0.6.2(@babel/core@7.25.7) semver: 6.3.1 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-shorthand-properties@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-shorthand-properties@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-spread@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-spread@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 transitivePeerDependencies: - supports-color - '@babel/plugin-transform-sticky-regex@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-sticky-regex@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-template-literals@7.24.7(@babel/core@7.25.2)': + '@babel/plugin-transform-template-literals@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-typeof-symbol@7.24.8(@babel/core@7.25.2)': + '@babel/plugin-transform-typeof-symbol@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 - '@babel/plugin-transform-typescript@7.25.2(@babel/core@7.25.2)': + '@babel/plugin-transform-typescript@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-annotate-as-pure': 7.24.7 - '@babel/helper-create-class-features-plugin': 7.25.4(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-skip-transparent-expression-wrappers': 7.24.7 - '@babel/plugin-syntax-typescript': 7.25.4(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-annotate-as-pure': 7.25.7 + '@babel/helper-create-class-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-skip-transparent-expression-wrappers': 7.25.7 + '@babel/plugin-syntax-typescript': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/plugin-transform-unicode-escapes@7.24.7(@babel/core@7.25.2)': - dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - - '@babel/plugin-transform-unicode-property-regex@7.24.7(@babel/core@7.25.2)': - dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - - '@babel/plugin-transform-unicode-regex@7.24.7(@babel/core@7.25.2)': - dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - - '@babel/plugin-transform-unicode-sets-regex@7.25.4(@babel/core@7.25.2)': - dependencies: - '@babel/core': 7.25.2 - '@babel/helper-create-regexp-features-plugin': 7.25.2(@babel/core@7.25.2) - '@babel/helper-plugin-utils': 7.24.8 - - '@babel/preset-env@7.25.4(@babel/core@7.25.2)': - dependencies: - '@babel/compat-data': 7.25.4 - '@babel/core': 7.25.2 - '@babel/helper-compilation-targets': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-bugfix-firefox-class-in-computed-class-key': 7.25.3(@babel/core@7.25.2) - '@babel/plugin-bugfix-safari-class-field-initializer-scope': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.25.2) - '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.2) - '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.25.2) - '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.2) - '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-import-assertions': 7.25.6(@babel/core@7.25.2) - '@babel/plugin-syntax-import-attributes': 7.25.6(@babel/core@7.25.2) - '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.2) - '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.25.2) - '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.25.2) - '@babel/plugin-transform-arrow-functions': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-async-generator-functions': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-async-to-generator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-block-scoped-functions': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-block-scoping': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-transform-class-properties': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-class-static-block': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-classes': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-computed-properties': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-destructuring': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-dotall-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-duplicate-keys': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-duplicate-named-capturing-groups-regex': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-transform-dynamic-import': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-exponentiation-operator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-export-namespace-from': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-for-of': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-function-name': 7.25.1(@babel/core@7.25.2) - '@babel/plugin-transform-json-strings': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-literals': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-logical-assignment-operators': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-member-expression-literals': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-modules-amd': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-modules-commonjs': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-modules-systemjs': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-transform-modules-umd': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-named-capturing-groups-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-new-target': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-nullish-coalescing-operator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-numeric-separator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-object-rest-spread': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-object-super': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-optional-catch-binding': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-optional-chaining': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-parameters': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-private-methods': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-private-property-in-object': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-property-literals': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-regenerator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-reserved-words': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-shorthand-properties': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-spread': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-sticky-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-template-literals': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-typeof-symbol': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-unicode-escapes': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-unicode-property-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-unicode-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-unicode-sets-regex': 7.25.4(@babel/core@7.25.2) - '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.25.2) - babel-plugin-polyfill-corejs2: 0.4.11(@babel/core@7.25.2) - babel-plugin-polyfill-corejs3: 0.10.6(@babel/core@7.25.2) - babel-plugin-polyfill-regenerator: 0.6.2(@babel/core@7.25.2) + '@babel/plugin-transform-unicode-escapes@7.25.7(@babel/core@7.25.7)': + dependencies: + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + + '@babel/plugin-transform-unicode-property-regex@7.25.7(@babel/core@7.25.7)': + dependencies: + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + + '@babel/plugin-transform-unicode-regex@7.25.7(@babel/core@7.25.7)': + dependencies: + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + + '@babel/plugin-transform-unicode-sets-regex@7.25.7(@babel/core@7.25.7)': + dependencies: + '@babel/core': 7.25.7 + '@babel/helper-create-regexp-features-plugin': 7.25.7(@babel/core@7.25.7) + '@babel/helper-plugin-utils': 7.25.7 + + '@babel/preset-env@7.25.7(@babel/core@7.25.7)': + dependencies: + '@babel/compat-data': 7.25.7 + '@babel/core': 7.25.7 + '@babel/helper-compilation-targets': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-validator-option': 7.25.7 + '@babel/plugin-bugfix-firefox-class-in-computed-class-key': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-bugfix-safari-class-field-initializer-scope': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.25.7) + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.7) + '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.25.7) + '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.7) + '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-import-assertions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-import-attributes': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.7) + '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.25.7) + '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.25.7) + '@babel/plugin-transform-arrow-functions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-async-generator-functions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-async-to-generator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-block-scoped-functions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-block-scoping': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-class-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-class-static-block': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-classes': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-computed-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-destructuring': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-dotall-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-duplicate-keys': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-duplicate-named-capturing-groups-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-dynamic-import': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-exponentiation-operator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-export-namespace-from': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-for-of': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-function-name': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-json-strings': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-literals': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-logical-assignment-operators': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-member-expression-literals': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-amd': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-commonjs': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-systemjs': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-umd': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-named-capturing-groups-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-new-target': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-nullish-coalescing-operator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-numeric-separator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-object-rest-spread': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-object-super': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-optional-catch-binding': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-optional-chaining': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-parameters': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-private-methods': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-private-property-in-object': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-property-literals': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-regenerator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-reserved-words': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-shorthand-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-spread': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-sticky-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-template-literals': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-typeof-symbol': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-unicode-escapes': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-unicode-property-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-unicode-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-unicode-sets-regex': 7.25.7(@babel/core@7.25.7) + '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.25.7) + babel-plugin-polyfill-corejs2: 0.4.11(@babel/core@7.25.7) + babel-plugin-polyfill-corejs3: 0.10.6(@babel/core@7.25.7) + babel-plugin-polyfill-regenerator: 0.6.2(@babel/core@7.25.7) core-js-compat: 3.38.1 semver: 6.3.1 transitivePeerDependencies: - supports-color - '@babel/preset-flow@7.24.7(@babel/core@7.25.2)': + '@babel/preset-flow@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-validator-option': 7.25.7 + '@babel/plugin-transform-flow-strip-types': 7.25.7(@babel/core@7.25.7) - '@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.25.2)': + '@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/types': 7.25.6 + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/types': 7.25.7 esutils: 2.0.3 - '@babel/preset-react@7.24.7(@babel/core@7.25.2)': + '@babel/preset-react@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-transform-react-display-name': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-react-jsx': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-react-jsx-development': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-react-pure-annotations': 7.24.7(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-validator-option': 7.25.7 + '@babel/plugin-transform-react-display-name': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-jsx': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-jsx-development': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-pure-annotations': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/preset-typescript@7.24.7(@babel/core@7.25.2)': + '@babel/preset-typescript@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@babel/helper-plugin-utils': 7.24.8 - '@babel/helper-validator-option': 7.24.8 - '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-modules-commonjs': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-typescript': 7.25.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-plugin-utils': 7.25.7 + '@babel/helper-validator-option': 7.25.7 + '@babel/plugin-syntax-jsx': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-commonjs': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-typescript': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - '@babel/register@7.24.6(@babel/core@7.25.2)': + '@babel/register@7.25.7(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 clone-deep: 4.0.1 find-cache-dir: 2.1.0 make-dir: 2.1.0 pirates: 4.0.6 source-map-support: 0.5.21 - '@babel/regjsgen@0.8.0': {} - - '@babel/runtime@7.25.6': + '@babel/runtime@7.25.7': dependencies: regenerator-runtime: 0.14.1 - '@babel/template@7.25.0': + '@babel/template@7.25.7': dependencies: - '@babel/code-frame': 7.24.7 - '@babel/parser': 7.25.6 - '@babel/types': 7.25.6 + '@babel/code-frame': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/types': 7.25.7 - '@babel/traverse@7.25.6': + '@babel/traverse@7.25.7': dependencies: - '@babel/code-frame': 7.24.7 - '@babel/generator': 7.25.6 - '@babel/parser': 7.25.6 - '@babel/template': 7.25.0 - '@babel/types': 7.25.6 + '@babel/code-frame': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/template': 7.25.7 + '@babel/types': 7.25.7 debug: 4.3.7(supports-color@8.1.1) globals: 11.12.0 transitivePeerDependencies: - supports-color - '@babel/types@7.25.6': + '@babel/types@7.25.7': dependencies: - '@babel/helper-string-parser': 7.24.8 - '@babel/helper-validator-identifier': 7.24.7 + '@babel/helper-string-parser': 7.25.7 + '@babel/helper-validator-identifier': 7.25.7 to-fast-properties: 2.0.0 - '@balena/dockerignore@1.0.2': {} - '@bcoe/v8-coverage@0.2.3': {} '@coinbase/wallet-sdk@3.9.3': @@ -10808,7 +10621,7 @@ snapshots: eth-json-rpc-filters: 6.0.1 eventemitter3: 5.0.1 keccak: 3.0.4 - preact: 10.24.1 + preact: 10.24.2 sha.js: 2.4.11 transitivePeerDependencies: - supports-color @@ -10819,7 +10632,7 @@ snapshots: clsx: 1.2.1 eventemitter3: 5.0.1 keccak: 3.0.4 - preact: 10.24.1 + preact: 10.24.2 sha.js: 2.4.11 '@colors/colors@1.6.0': {} @@ -10829,7 +10642,7 @@ snapshots: better-sqlite3: 9.6.0 class-validator: 0.14.1 dotenv: 16.4.5 - ethers: 6.13.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) lru-cache: 10.2.2 pg: 8.11.3 typeorm: 0.3.20(better-sqlite3@9.6.0)(pg@8.11.3)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)) @@ -10865,22 +10678,22 @@ snapshots: enabled: 2.0.0 kuler: 2.0.0 - '@depay/solana-web3.js@1.26.0': + '@depay/solana-web3.js@1.27.0': dependencies: bs58: 5.0.0 - '@depay/web3-blockchains@9.6.1': {} + '@depay/web3-blockchains@9.6.7': {} '@depay/web3-mock@14.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: - '@depay/solana-web3.js': 1.26.0 - '@depay/web3-blockchains': 9.6.1 + '@depay/solana-web3.js': 1.27.0 + '@depay/web3-blockchains': 9.6.7 ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate - '@emnapi/runtime@1.2.0': + '@emnapi/runtime@1.3.0': dependencies: tslib: 2.7.0 optional: true @@ -11374,8 +11187,8 @@ snapshots: '@headlessui/react@2.1.9(react-dom@18.3.1(react@18.3.1))(react@18.3.1)': dependencies: '@floating-ui/react': 0.26.24(react-dom@18.3.1(react@18.3.1))(react@18.3.1) - '@react-aria/focus': 3.18.2(react@18.3.1) - '@react-aria/interactions': 3.22.2(react@18.3.1) + '@react-aria/focus': 3.18.3(react@18.3.1) + '@react-aria/interactions': 3.22.3(react@18.3.1) '@tanstack/react-virtual': 3.10.8(react-dom@18.3.1(react@18.3.1))(react@18.3.1) react: 18.3.1 react-dom: 18.3.1(react@18.3.1) @@ -11458,7 +11271,7 @@ snapshots: '@img/sharp-wasm32@0.33.5': dependencies: - '@emnapi/runtime': 1.2.0 + '@emnapi/runtime': 1.3.0 optional: true '@img/sharp-win32-ia32@0.33.5': @@ -11627,7 +11440,7 @@ snapshots: '@jest/transform@29.7.0': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 '@jest/types': 29.6.3 '@jridgewell/trace-mapping': 0.3.25 babel-plugin-istanbul: 6.1.1 @@ -11768,7 +11581,7 @@ snapshots: '@metamask/rpc-errors@6.4.0': dependencies: - '@metamask/utils': 9.2.1 + '@metamask/utils': 9.3.0 fast-safe-stringify: 2.1.1 transitivePeerDependencies: - supports-color @@ -11792,21 +11605,21 @@ snapshots: transitivePeerDependencies: - supports-color - '@metamask/sdk-install-modal-web@0.28.1(i18next@23.11.5)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)': + '@metamask/sdk-install-modal-web@0.28.1(i18next@23.11.5)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)': dependencies: i18next: 23.11.5 qr-code-styling: 1.6.0-rc.1 optionalDependencies: react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - react-native: 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) + react-native: 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) - '@metamask/sdk@0.28.4(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(utf-8-validate@5.0.10)': + '@metamask/sdk@0.28.4(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(utf-8-validate@5.0.10)': dependencies: '@metamask/onboarding': 1.0.1 '@metamask/providers': 16.1.0 '@metamask/sdk-communication-layer': 0.28.2(cross-fetch@4.0.0(encoding@0.1.13))(eciesjs@0.3.20)(eventemitter2@6.4.9)(readable-stream@3.6.2)(socket.io-client@4.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) - '@metamask/sdk-install-modal-web': 0.28.1(i18next@23.11.5)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) + '@metamask/sdk-install-modal-web': 0.28.1(i18next@23.11.5)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) '@types/dom-screen-wake-lock': 1.0.3 '@types/uuid': 10.0.0 bowser: 2.11.0 @@ -11820,9 +11633,9 @@ snapshots: obj-multiplex: 1.0.0 pump: 3.0.2 qrcode-terminal-nooctal: 0.12.1 - react-native-webview: 11.26.1(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) + react-native-webview: 11.26.1(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) readable-stream: 3.6.2 - rollup-plugin-visualizer: 5.12.0(rollup@4.22.5) + rollup-plugin-visualizer: 5.12.0(rollup@4.24.0) socket.io-client: 4.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) util: 0.12.5 uuid: 8.3.2 @@ -11863,7 +11676,7 @@ snapshots: transitivePeerDependencies: - supports-color - '@metamask/utils@9.2.1': + '@metamask/utils@9.3.0': dependencies: '@ethereumjs/tx': 4.2.0 '@metamask/superstruct': 3.1.0 @@ -12064,7 +11877,7 @@ snapshots: ethereumjs-util: 7.1.5 hardhat: 2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10) - ? '@nomicfoundation/hardhat-toolbox@4.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.8(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.10(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@1.1.1(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5)))(@types/chai@4.3.20)(@types/mocha@10.0.8)(@types/node@20.12.7)(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(solidity-coverage@0.8.13(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)' + ? '@nomicfoundation/hardhat-toolbox@4.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.8(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.10(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@1.1.1(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5)))(@types/chai@4.3.20)(@types/mocha@10.0.9)(@types/node@20.12.7)(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(solidity-coverage@0.8.13(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)' : dependencies: '@nomicfoundation/hardhat-chai-matchers': 2.0.8(@nomicfoundation/hardhat-ethers@3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)))(chai@4.1.1)(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)) '@nomicfoundation/hardhat-ethers': 3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)) @@ -12073,7 +11886,7 @@ snapshots: '@typechain/ethers-v6': 0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5) '@typechain/hardhat': 9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5))(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5)) '@types/chai': 4.3.20 - '@types/mocha': 10.0.8 + '@types/mocha': 10.0.9 '@types/node': 20.12.7 chai: 4.1.1 ethers: 6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) @@ -12174,7 +11987,7 @@ snapshots: '@oclif/core': 4.0.23 ansis: 3.3.2 debug: 4.3.7(supports-color@8.1.1) - npm: 10.8.3 + npm: 10.9.0 npm-package-arg: 11.0.3 npm-run-path: 5.3.0 object-treeify: 4.0.1 @@ -12221,16 +12034,16 @@ snapshots: - debug - encoding - '@openzeppelin/defender-sdk-base-client@1.14.4(encoding@0.1.13)': + '@openzeppelin/defender-sdk-base-client@1.15.0(encoding@0.1.13)': dependencies: amazon-cognito-identity-js: 6.3.12(encoding@0.1.13) async-retry: 1.3.3 transitivePeerDependencies: - encoding - '@openzeppelin/defender-sdk-deploy-client@1.14.4(debug@4.3.7)(encoding@0.1.13)': + '@openzeppelin/defender-sdk-deploy-client@1.15.0(debug@4.3.7)(encoding@0.1.13)': dependencies: - '@openzeppelin/defender-sdk-base-client': 1.14.4(encoding@0.1.13) + '@openzeppelin/defender-sdk-base-client': 1.15.0(encoding@0.1.13) axios: 1.7.7(debug@4.3.7) lodash: 4.17.21 transitivePeerDependencies: @@ -12242,8 +12055,8 @@ snapshots: '@nomicfoundation/hardhat-ethers': 3.0.5(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.10(bufferutil@4.0.8)(c-kzg@2.1.2)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5))(typescript@5.4.5)(utf-8-validate@5.0.10)) '@openzeppelin/defender-admin-client': 1.54.6(bufferutil@4.0.8)(debug@4.3.7)(encoding@0.1.13)(utf-8-validate@5.0.10) '@openzeppelin/defender-base-client': 1.54.6(debug@4.3.7)(encoding@0.1.13) - '@openzeppelin/defender-sdk-base-client': 1.14.4(encoding@0.1.13) - '@openzeppelin/defender-sdk-deploy-client': 1.14.4(debug@4.3.7)(encoding@0.1.13) + '@openzeppelin/defender-sdk-base-client': 1.15.0(encoding@0.1.13) + '@openzeppelin/defender-sdk-deploy-client': 1.15.0(debug@4.3.7)(encoding@0.1.13) '@openzeppelin/upgrades-core': 1.33.1 chalk: 4.1.2 debug: 4.3.7(supports-color@8.1.1) @@ -12355,33 +12168,33 @@ snapshots: '@pnpm/network.ca-file': 1.0.2 config-chain: 1.1.13 - '@react-aria/focus@3.18.2(react@18.3.1)': + '@react-aria/focus@3.18.3(react@18.3.1)': dependencies: - '@react-aria/interactions': 3.22.2(react@18.3.1) - '@react-aria/utils': 3.25.2(react@18.3.1) - '@react-types/shared': 3.24.1(react@18.3.1) + '@react-aria/interactions': 3.22.3(react@18.3.1) + '@react-aria/utils': 3.25.3(react@18.3.1) + '@react-types/shared': 3.25.0(react@18.3.1) '@swc/helpers': 0.5.13 clsx: 2.1.1 react: 18.3.1 - '@react-aria/interactions@3.22.2(react@18.3.1)': + '@react-aria/interactions@3.22.3(react@18.3.1)': dependencies: - '@react-aria/ssr': 3.9.5(react@18.3.1) - '@react-aria/utils': 3.25.2(react@18.3.1) - '@react-types/shared': 3.24.1(react@18.3.1) + '@react-aria/ssr': 3.9.6(react@18.3.1) + '@react-aria/utils': 3.25.3(react@18.3.1) + '@react-types/shared': 3.25.0(react@18.3.1) '@swc/helpers': 0.5.13 react: 18.3.1 - '@react-aria/ssr@3.9.5(react@18.3.1)': + '@react-aria/ssr@3.9.6(react@18.3.1)': dependencies: '@swc/helpers': 0.5.13 react: 18.3.1 - '@react-aria/utils@3.25.2(react@18.3.1)': + '@react-aria/utils@3.25.3(react@18.3.1)': dependencies: - '@react-aria/ssr': 3.9.5(react@18.3.1) - '@react-stately/utils': 3.10.3(react@18.3.1) - '@react-types/shared': 3.24.1(react@18.3.1) + '@react-aria/ssr': 3.9.6(react@18.3.1) + '@react-stately/utils': 3.10.4(react@18.3.1) + '@react-types/shared': 3.25.0(react@18.3.1) '@swc/helpers': 0.5.13 clsx: 2.1.1 react: 18.3.1 @@ -12510,86 +12323,86 @@ snapshots: - typescript - utf-8-validate - '@react-native/assets-registry@0.75.3': {} + '@react-native/assets-registry@0.75.4': {} - '@react-native/babel-plugin-codegen@0.75.3(@babel/preset-env@7.25.4(@babel/core@7.25.2))': + '@react-native/babel-plugin-codegen@0.75.4(@babel/preset-env@7.25.7(@babel/core@7.25.7))': dependencies: - '@react-native/codegen': 0.75.3(@babel/preset-env@7.25.4(@babel/core@7.25.2)) + '@react-native/codegen': 0.75.4(@babel/preset-env@7.25.7(@babel/core@7.25.7)) transitivePeerDependencies: - '@babel/preset-env' - supports-color - '@react-native/babel-preset@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))': - dependencies: - '@babel/core': 7.25.2 - '@babel/plugin-proposal-export-default-from': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-export-default-from': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-transform-arrow-functions': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-async-generator-functions': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-async-to-generator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-block-scoping': 7.25.0(@babel/core@7.25.2) - '@babel/plugin-transform-class-properties': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-classes': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-computed-properties': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-destructuring': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-flow-strip-types': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-for-of': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-function-name': 7.25.1(@babel/core@7.25.2) - '@babel/plugin-transform-literals': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-logical-assignment-operators': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-modules-commonjs': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-named-capturing-groups-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-nullish-coalescing-operator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-numeric-separator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-object-rest-spread': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-optional-catch-binding': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-optional-chaining': 7.24.8(@babel/core@7.25.2) - '@babel/plugin-transform-parameters': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-private-methods': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-private-property-in-object': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-react-display-name': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-react-jsx': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-react-jsx-self': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-react-jsx-source': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-regenerator': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-runtime': 7.25.4(@babel/core@7.25.2) - '@babel/plugin-transform-shorthand-properties': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-spread': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-sticky-regex': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-transform-typescript': 7.25.2(@babel/core@7.25.2) - '@babel/plugin-transform-unicode-regex': 7.24.7(@babel/core@7.25.2) - '@babel/template': 7.25.0 - '@react-native/babel-plugin-codegen': 0.75.3(@babel/preset-env@7.25.4(@babel/core@7.25.2)) - babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.25.2) + '@react-native/babel-preset@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))': + dependencies: + '@babel/core': 7.25.7 + '@babel/plugin-proposal-export-default-from': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-export-default-from': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-flow': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-transform-arrow-functions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-async-generator-functions': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-async-to-generator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-block-scoping': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-class-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-classes': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-computed-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-destructuring': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-flow-strip-types': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-for-of': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-function-name': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-literals': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-logical-assignment-operators': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-modules-commonjs': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-named-capturing-groups-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-nullish-coalescing-operator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-numeric-separator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-object-rest-spread': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-optional-catch-binding': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-optional-chaining': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-parameters': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-private-methods': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-private-property-in-object': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-display-name': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-jsx': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-jsx-self': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-react-jsx-source': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-regenerator': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-runtime': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-shorthand-properties': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-spread': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-sticky-regex': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-typescript': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-transform-unicode-regex': 7.25.7(@babel/core@7.25.7) + '@babel/template': 7.25.7 + '@react-native/babel-plugin-codegen': 0.75.4(@babel/preset-env@7.25.7(@babel/core@7.25.7)) + babel-plugin-transform-flow-enums: 0.0.2(@babel/core@7.25.7) react-refresh: 0.14.2 transitivePeerDependencies: - '@babel/preset-env' - supports-color - '@react-native/codegen@0.75.3(@babel/preset-env@7.25.4(@babel/core@7.25.2))': + '@react-native/codegen@0.75.4(@babel/preset-env@7.25.7(@babel/core@7.25.7))': dependencies: - '@babel/parser': 7.25.6 - '@babel/preset-env': 7.25.4(@babel/core@7.25.2) + '@babel/parser': 7.25.7 + '@babel/preset-env': 7.25.7(@babel/core@7.25.7) glob: 7.2.3 hermes-parser: 0.22.0 invariant: 2.2.4 - jscodeshift: 0.14.0(@babel/preset-env@7.25.4(@babel/core@7.25.2)) + jscodeshift: 0.14.0(@babel/preset-env@7.25.7(@babel/core@7.25.7)) mkdirp: 0.5.6 nullthrows: 1.1.1 yargs: 17.7.2 transitivePeerDependencies: - supports-color - '@react-native/community-cli-plugin@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': + '@react-native/community-cli-plugin@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': dependencies: '@react-native-community/cli-server-api': 14.1.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@react-native-community/cli-tools': 14.1.0 - '@react-native/dev-middleware': 0.75.3(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10) - '@react-native/metro-babel-transformer': 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2)) + '@react-native/dev-middleware': 0.75.4(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10) + '@react-native/metro-babel-transformer': 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7)) chalk: 4.1.2 execa: 5.1.1 metro: 0.80.12(bufferutil@4.0.8)(utf-8-validate@5.0.10) @@ -12605,12 +12418,12 @@ snapshots: - supports-color - utf-8-validate - '@react-native/debugger-frontend@0.75.3': {} + '@react-native/debugger-frontend@0.75.4': {} - '@react-native/dev-middleware@0.75.3(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': + '@react-native/dev-middleware@0.75.4(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': dependencies: '@isaacs/ttlcache': 1.4.1 - '@react-native/debugger-frontend': 0.75.3 + '@react-native/debugger-frontend': 0.75.4 chrome-launcher: 0.15.2 chromium-edge-launcher: 0.2.0 connect: 3.7.0 @@ -12627,86 +12440,86 @@ snapshots: - supports-color - utf-8-validate - '@react-native/gradle-plugin@0.75.3': {} + '@react-native/gradle-plugin@0.75.4': {} - '@react-native/js-polyfills@0.75.3': {} + '@react-native/js-polyfills@0.75.4': {} - '@react-native/metro-babel-transformer@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))': + '@react-native/metro-babel-transformer@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))': dependencies: - '@babel/core': 7.25.2 - '@react-native/babel-preset': 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2)) + '@babel/core': 7.25.7 + '@react-native/babel-preset': 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7)) hermes-parser: 0.22.0 nullthrows: 1.1.1 transitivePeerDependencies: - '@babel/preset-env' - supports-color - '@react-native/normalize-colors@0.75.3': {} + '@react-native/normalize-colors@0.75.4': {} - '@react-native/virtualized-lists@0.75.3(@types/react@18.3.11)(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)': + '@react-native/virtualized-lists@0.75.4(@types/react@18.3.11)(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)': dependencies: invariant: 2.2.4 nullthrows: 1.1.1 react: 18.3.1 - react-native: 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) + react-native: 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) optionalDependencies: '@types/react': 18.3.11 - '@react-stately/utils@3.10.3(react@18.3.1)': + '@react-stately/utils@3.10.4(react@18.3.1)': dependencies: '@swc/helpers': 0.5.13 react: 18.3.1 - '@react-types/shared@3.24.1(react@18.3.1)': + '@react-types/shared@3.25.0(react@18.3.1)': dependencies: react: 18.3.1 - '@rollup/rollup-android-arm-eabi@4.22.5': + '@rollup/rollup-android-arm-eabi@4.24.0': optional: true - '@rollup/rollup-android-arm64@4.22.5': + '@rollup/rollup-android-arm64@4.24.0': optional: true - '@rollup/rollup-darwin-arm64@4.22.5': + '@rollup/rollup-darwin-arm64@4.24.0': optional: true - '@rollup/rollup-darwin-x64@4.22.5': + '@rollup/rollup-darwin-x64@4.24.0': optional: true - '@rollup/rollup-linux-arm-gnueabihf@4.22.5': + '@rollup/rollup-linux-arm-gnueabihf@4.24.0': optional: true - '@rollup/rollup-linux-arm-musleabihf@4.22.5': + '@rollup/rollup-linux-arm-musleabihf@4.24.0': optional: true - '@rollup/rollup-linux-arm64-gnu@4.22.5': + '@rollup/rollup-linux-arm64-gnu@4.24.0': optional: true - '@rollup/rollup-linux-arm64-musl@4.22.5': + '@rollup/rollup-linux-arm64-musl@4.24.0': optional: true - '@rollup/rollup-linux-powerpc64le-gnu@4.22.5': + '@rollup/rollup-linux-powerpc64le-gnu@4.24.0': optional: true - '@rollup/rollup-linux-riscv64-gnu@4.22.5': + '@rollup/rollup-linux-riscv64-gnu@4.24.0': optional: true - '@rollup/rollup-linux-s390x-gnu@4.22.5': + '@rollup/rollup-linux-s390x-gnu@4.24.0': optional: true - '@rollup/rollup-linux-x64-gnu@4.22.5': + '@rollup/rollup-linux-x64-gnu@4.24.0': optional: true - '@rollup/rollup-linux-x64-musl@4.22.5': + '@rollup/rollup-linux-x64-musl@4.24.0': optional: true - '@rollup/rollup-win32-arm64-msvc@4.22.5': + '@rollup/rollup-win32-arm64-msvc@4.24.0': optional: true - '@rollup/rollup-win32-ia32-msvc@4.22.5': + '@rollup/rollup-win32-ia32-msvc@4.24.0': optional: true - '@rollup/rollup-win32-x64-msvc@4.22.5': + '@rollup/rollup-win32-x64-msvc@4.24.0': optional: true '@rtsao/scc@1.1.0': {} @@ -12718,7 +12531,7 @@ snapshots: '@noble/hashes': 1.5.0 '@safe-global/safe-deployments': 1.37.10 ethereumjs-util: 7.1.5 - ethers: 6.13.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) semver: 7.6.3 web3: 1.10.4(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10) web3-core: 1.10.4(encoding@0.1.13) @@ -12752,7 +12565,7 @@ snapshots: '@safe-global/safe-core-sdk-types@4.0.2(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': dependencies: '@safe-global/safe-deployments': 1.37.10 - ethers: 6.13.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-core: 1.10.4(encoding@0.1.13) web3-utils: 1.10.4 transitivePeerDependencies: @@ -12884,7 +12697,7 @@ snapshots: dependencies: '@sinonjs/commons': 3.0.1 - '@smithy/types@3.4.2': + '@smithy/types@3.5.0': dependencies: tslib: 2.7.0 @@ -12980,54 +12793,54 @@ snapshots: '@stablelib/random': 1.0.2 '@stablelib/wipe': 1.0.1 - '@svgr/babel-plugin-add-jsx-attribute@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-add-jsx-attribute@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-remove-jsx-attribute@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-remove-jsx-attribute@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-remove-jsx-empty-expression@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-remove-jsx-empty-expression@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-replace-jsx-attribute-value@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-replace-jsx-attribute-value@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-svg-dynamic-title@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-svg-dynamic-title@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-svg-em-dimensions@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-svg-em-dimensions@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-transform-react-native-svg@8.1.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-transform-react-native-svg@8.1.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-plugin-transform-svg-component@8.0.0(@babel/core@7.25.2)': + '@svgr/babel-plugin-transform-svg-component@8.0.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - '@svgr/babel-preset@8.1.0(@babel/core@7.25.2)': + '@svgr/babel-preset@8.1.0(@babel/core@7.25.7)': dependencies: - '@babel/core': 7.25.2 - '@svgr/babel-plugin-add-jsx-attribute': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-remove-jsx-attribute': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-remove-jsx-empty-expression': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-replace-jsx-attribute-value': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-svg-dynamic-title': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-svg-em-dimensions': 8.0.0(@babel/core@7.25.2) - '@svgr/babel-plugin-transform-react-native-svg': 8.1.0(@babel/core@7.25.2) - '@svgr/babel-plugin-transform-svg-component': 8.0.0(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@svgr/babel-plugin-add-jsx-attribute': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-remove-jsx-attribute': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-remove-jsx-empty-expression': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-replace-jsx-attribute-value': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-svg-dynamic-title': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-svg-em-dimensions': 8.0.0(@babel/core@7.25.7) + '@svgr/babel-plugin-transform-react-native-svg': 8.1.0(@babel/core@7.25.7) + '@svgr/babel-plugin-transform-svg-component': 8.0.0(@babel/core@7.25.7) '@svgr/core@8.1.0(typescript@5.4.5)': dependencies: - '@babel/core': 7.25.2 - '@svgr/babel-preset': 8.1.0(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@svgr/babel-preset': 8.1.0(@babel/core@7.25.7) camelcase: 6.3.0 cosmiconfig: 8.3.6(typescript@5.4.5) snake-case: 3.0.4 @@ -13037,13 +12850,13 @@ snapshots: '@svgr/hast-util-to-babel-ast@8.0.0': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 entities: 4.5.0 '@svgr/plugin-jsx@8.1.0(@svgr/core@8.1.0(typescript@5.4.5))': dependencies: - '@babel/core': 7.25.2 - '@svgr/babel-preset': 8.1.0(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@svgr/babel-preset': 8.1.0(@babel/core@7.25.7) '@svgr/core': 8.1.0(typescript@5.4.5) '@svgr/hast-util-to-babel-ast': 8.0.0 svg-parser: 2.0.4 @@ -13061,11 +12874,11 @@ snapshots: '@svgr/webpack@8.1.0(typescript@5.4.5)': dependencies: - '@babel/core': 7.25.2 - '@babel/plugin-transform-react-constant-elements': 7.25.1(@babel/core@7.25.2) - '@babel/preset-env': 7.25.4(@babel/core@7.25.2) - '@babel/preset-react': 7.24.7(@babel/core@7.25.2) - '@babel/preset-typescript': 7.24.7(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/plugin-transform-react-constant-elements': 7.25.7(@babel/core@7.25.7) + '@babel/preset-env': 7.25.7(@babel/core@7.25.7) + '@babel/preset-react': 7.25.7(@babel/core@7.25.7) + '@babel/preset-typescript': 7.25.7(@babel/core@7.25.7) '@svgr/core': 8.1.0(typescript@5.4.5) '@svgr/plugin-jsx': 8.1.0(@svgr/core@8.1.0(typescript@5.4.5)) '@svgr/plugin-svgo': 8.1.0(@svgr/core@8.1.0(typescript@5.4.5))(typescript@5.4.5) @@ -13207,19 +13020,17 @@ snapshots: '@tsconfig/node16@1.0.4': {} - '@typechain/ethers-v5@11.1.2(@ethersproject/abi@5.7.0)(@ethersproject/providers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)': + '@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)': dependencies: - '@ethersproject/abi': 5.7.0 - '@ethersproject/providers': 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) lodash: 4.17.21 ts-essentials: 7.0.3(typescript@5.4.5) typechain: 8.3.2(typescript@5.4.5) typescript: 5.4.5 - '@typechain/ethers-v6@0.5.1(ethers@6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)': + '@typechain/ethers-v6@0.5.1(ethers@6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.4.5))(typescript@5.4.5)': dependencies: - ethers: 6.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) lodash: 4.17.21 ts-essentials: 7.0.3(typescript@5.4.5) typechain: 8.3.2(typescript@5.4.5) @@ -13235,24 +13046,24 @@ snapshots: '@types/babel__core@7.20.5': dependencies: - '@babel/parser': 7.25.6 - '@babel/types': 7.25.6 + '@babel/parser': 7.25.7 + '@babel/types': 7.25.7 '@types/babel__generator': 7.6.8 '@types/babel__template': 7.4.4 '@types/babel__traverse': 7.20.6 '@types/babel__generator@7.6.8': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 '@types/babel__template@7.4.4': dependencies: - '@babel/parser': 7.25.6 - '@babel/types': 7.25.6 + '@babel/parser': 7.25.7 + '@babel/types': 7.25.7 '@types/babel__traverse@7.20.6': dependencies: - '@babel/types': 7.25.6 + '@babel/types': 7.25.7 '@types/bn.js@4.11.6': dependencies: @@ -13285,17 +13096,6 @@ snapshots: '@types/diff@5.2.0': {} - '@types/docker-modem@3.0.6': - dependencies: - '@types/node': 20.12.7 - '@types/ssh2': 1.15.1 - - '@types/dockerode@3.3.31': - dependencies: - '@types/docker-modem': 3.0.6 - '@types/node': 20.12.7 - '@types/ssh2': 1.15.1 - '@types/dom-screen-wake-lock@1.0.3': {} '@types/estree@1.0.6': {} @@ -13362,7 +13162,7 @@ snapshots: '@types/minimatch@5.1.2': {} - '@types/mocha@10.0.8': {} + '@types/mocha@10.0.9': {} '@types/ms@0.7.34': {} @@ -13376,10 +13176,6 @@ snapshots: '@types/node@18.15.13': {} - '@types/node@18.19.54': - dependencies: - undici-types: 5.26.5 - '@types/node@20.12.7': dependencies: undici-types: 5.26.5 @@ -13423,19 +13219,6 @@ snapshots: '@types/semver@7.5.8': {} - '@types/ssh2-streams@0.1.12': - dependencies: - '@types/node': 20.12.7 - - '@types/ssh2@0.5.52': - dependencies: - '@types/node': 20.12.7 - '@types/ssh2-streams': 0.1.12 - - '@types/ssh2@1.15.1': - dependencies: - '@types/node': 18.19.54 - '@types/stack-utils@2.0.3': {} '@types/tinycolor2@1.4.6': {} @@ -13561,10 +13344,10 @@ snapshots: - debug - utf-8-validate - '@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4)': + '@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4)': dependencies: '@coinbase/wallet-sdk': 4.0.4 - '@metamask/sdk': 0.28.4(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(utf-8-validate@5.0.10) + '@metamask/sdk': 0.28.4(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(utf-8-validate@5.0.10) '@safe-global/safe-apps-provider': 0.18.3(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4) '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4) '@wagmi/core': 2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)) @@ -13596,7 +13379,6 @@ snapshots: - react-native - rollup - supports-color - - uWebSockets.js - utf-8-validate - zod @@ -13647,7 +13429,6 @@ snapshots: - '@vercel/kv' - bufferutil - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/core@2.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)': @@ -13683,7 +13464,6 @@ snapshots: - '@vercel/kv' - bufferutil - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/environment@1.0.1': @@ -13720,7 +13500,6 @@ snapshots: - encoding - ioredis - react - - uWebSockets.js - utf-8-validate '@walletconnect/ethereum-provider@2.17.0(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(utf-8-validate@5.0.10)': @@ -13753,7 +13532,6 @@ snapshots: - encoding - ioredis - react - - uWebSockets.js - utf-8-validate '@walletconnect/events@1.0.1': @@ -13821,7 +13599,6 @@ snapshots: - '@upstash/redis' - '@vercel/kv' - ioredis - - uWebSockets.js '@walletconnect/logger@2.1.2': dependencies: @@ -13921,7 +13698,6 @@ snapshots: - '@vercel/kv' - bufferutil - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/sign-client@2.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)': @@ -13950,7 +13726,6 @@ snapshots: - '@vercel/kv' - bufferutil - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/time@1.0.2': @@ -13979,7 +13754,6 @@ snapshots: - '@upstash/redis' - '@vercel/kv' - ioredis - - uWebSockets.js '@walletconnect/types@2.17.0': dependencies: @@ -14003,7 +13777,6 @@ snapshots: - '@upstash/redis' - '@vercel/kv' - ioredis - - uWebSockets.js '@walletconnect/universal-provider@2.16.1(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': dependencies: @@ -14032,7 +13805,6 @@ snapshots: - bufferutil - encoding - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/universal-provider@2.17.0(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10)': @@ -14062,7 +13834,6 @@ snapshots: - bufferutil - encoding - ioredis - - uWebSockets.js - utf-8-validate '@walletconnect/utils@2.16.1': @@ -14097,7 +13868,6 @@ snapshots: - '@upstash/redis' - '@vercel/kv' - ioredis - - uWebSockets.js '@walletconnect/utils@2.17.0': dependencies: @@ -14131,7 +13901,6 @@ snapshots: - '@upstash/redis' - '@vercel/kv' - ioredis - - uWebSockets.js '@walletconnect/window-getters@1.0.1': dependencies: @@ -14172,7 +13941,6 @@ snapshots: - '@vercel/kv' - ioredis - react - - uWebSockets.js '@web3modal/common@5.1.11': dependencies: @@ -14217,7 +13985,6 @@ snapshots: - '@vercel/kv' - ioredis - react - - uWebSockets.js '@web3modal/scaffold-utils@5.1.11(@types/react@18.3.11)(react@18.3.1)': dependencies: @@ -14256,16 +14023,15 @@ snapshots: - '@vercel/kv' - ioredis - react - - uWebSockets.js '@web3modal/ui@5.1.11': dependencies: lit: 3.1.0 qrcode: 1.5.3 - ? '@web3modal/wagmi@5.1.11(@types/react@18.3.11)(@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))' + ? '@web3modal/wagmi@5.1.11(@types/react@18.3.11)(@wagmi/connectors@5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4))' : dependencies: - '@wagmi/connectors': 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) + '@wagmi/connectors': 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) '@wagmi/core': 2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)) '@walletconnect/ethereum-provider': 2.16.1(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(utf-8-validate@5.0.10) '@walletconnect/utils': 2.16.1 @@ -14276,7 +14042,7 @@ snapshots: '@web3modal/siwe': 5.1.11(@types/react@18.3.11)(react@18.3.1) '@web3modal/wallet': 5.1.11 viem: 2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4) - wagmi: 2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) + wagmi: 2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) optionalDependencies: react: 18.3.1 react-dom: 18.3.1(react@18.3.1) @@ -14297,7 +14063,6 @@ snapshots: - bufferutil - encoding - ioredis - - uWebSockets.js - utf-8-validate '@web3modal/wallet@5.1.11': @@ -14447,42 +14212,6 @@ snapshots: appdirsjs@1.2.7: {} - archiver-utils@2.1.0: - dependencies: - glob: 7.2.3 - graceful-fs: 4.2.11 - lazystream: 1.0.1 - lodash.defaults: 4.2.0 - lodash.difference: 4.5.0 - lodash.flatten: 4.4.0 - lodash.isplainobject: 4.0.6 - lodash.union: 4.6.0 - normalize-path: 3.0.0 - readable-stream: 2.3.8 - - archiver-utils@3.0.4: - dependencies: - glob: 7.2.3 - graceful-fs: 4.2.11 - lazystream: 1.0.1 - lodash.defaults: 4.2.0 - lodash.difference: 4.5.0 - lodash.flatten: 4.4.0 - lodash.isplainobject: 4.0.6 - lodash.union: 4.6.0 - normalize-path: 3.0.0 - readable-stream: 3.6.2 - - archiver@5.3.2: - dependencies: - archiver-utils: 2.1.0 - async: 3.2.6 - buffer-crc32: 0.2.13 - readable-stream: 3.6.2 - readdir-glob: 1.1.3 - tar-stream: 2.2.0 - zip-stream: 4.1.1 - arg@4.1.3: {} arg@5.0.2: {} @@ -14596,8 +14325,6 @@ snapshots: async-limiter@1.0.1: {} - async-lock@1.4.1: {} - async-mutex@0.2.6: dependencies: tslib: 2.7.0 @@ -14619,7 +14346,7 @@ snapshots: autoprefixer@10.4.20(postcss@8.4.47): dependencies: browserslist: 4.24.0 - caniuse-lite: 1.0.30001664 + caniuse-lite: 1.0.30001667 fraction.js: 4.3.7 normalize-range: 0.1.2 picocolors: 1.1.0 @@ -14660,19 +14387,17 @@ snapshots: axobject-query@4.1.0: {} - b4a@1.6.7: {} - - babel-core@7.0.0-bridge.0(@babel/core@7.25.2): + babel-core@7.0.0-bridge.0(@babel/core@7.25.7): dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 - babel-jest@29.7.0(@babel/core@7.25.2): + babel-jest@29.7.0(@babel/core@7.25.7): dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 '@jest/transform': 29.7.0 '@types/babel__core': 7.20.5 babel-plugin-istanbul: 6.1.1 - babel-preset-jest: 29.6.3(@babel/core@7.25.2) + babel-preset-jest: 29.6.3(@babel/core@7.25.7) chalk: 4.1.2 graceful-fs: 4.2.11 slash: 3.0.0 @@ -14681,7 +14406,7 @@ snapshots: babel-plugin-istanbul@6.1.1: dependencies: - '@babel/helper-plugin-utils': 7.24.8 + '@babel/helper-plugin-utils': 7.25.7 '@istanbuljs/load-nyc-config': 1.1.0 '@istanbuljs/schema': 0.1.3 istanbul-lib-instrument: 5.2.1 @@ -14691,92 +14416,68 @@ snapshots: babel-plugin-jest-hoist@29.6.3: dependencies: - '@babel/template': 7.25.0 - '@babel/types': 7.25.6 + '@babel/template': 7.25.7 + '@babel/types': 7.25.7 '@types/babel__core': 7.20.5 '@types/babel__traverse': 7.20.6 - babel-plugin-polyfill-corejs2@0.4.11(@babel/core@7.25.2): + babel-plugin-polyfill-corejs2@0.4.11(@babel/core@7.25.7): dependencies: - '@babel/compat-data': 7.25.4 - '@babel/core': 7.25.2 - '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.2) + '@babel/compat-data': 7.25.7 + '@babel/core': 7.25.7 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.7) semver: 6.3.1 transitivePeerDependencies: - supports-color - babel-plugin-polyfill-corejs3@0.10.6(@babel/core@7.25.2): + babel-plugin-polyfill-corejs3@0.10.6(@babel/core@7.25.7): dependencies: - '@babel/core': 7.25.2 - '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.7) core-js-compat: 3.38.1 transitivePeerDependencies: - supports-color - babel-plugin-polyfill-regenerator@0.6.2(@babel/core@7.25.2): + babel-plugin-polyfill-regenerator@0.6.2(@babel/core@7.25.7): dependencies: - '@babel/core': 7.25.2 - '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.2) + '@babel/core': 7.25.7 + '@babel/helper-define-polyfill-provider': 0.6.2(@babel/core@7.25.7) transitivePeerDependencies: - supports-color - babel-plugin-transform-flow-enums@0.0.2(@babel/core@7.25.2): + babel-plugin-transform-flow-enums@0.0.2(@babel/core@7.25.7): dependencies: - '@babel/plugin-syntax-flow': 7.24.7(@babel/core@7.25.2) + '@babel/plugin-syntax-flow': 7.25.7(@babel/core@7.25.7) transitivePeerDependencies: - '@babel/core' - babel-preset-current-node-syntax@1.1.0(@babel/core@7.25.2): - dependencies: - '@babel/core': 7.25.2 - '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.2) - '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.25.2) - '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.2) - '@babel/plugin-syntax-import-attributes': 7.25.6(@babel/core@7.25.2) - '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.2) - '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.2) - '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.2) - '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.25.2) - - babel-preset-jest@29.6.3(@babel/core@7.25.2): - dependencies: - '@babel/core': 7.25.2 + babel-preset-current-node-syntax@1.1.0(@babel/core@7.25.7): + dependencies: + '@babel/core': 7.25.7 + '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.25.7) + '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.25.7) + '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.25.7) + '@babel/plugin-syntax-import-attributes': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.25.7) + '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.25.7) + '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.25.7) + '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.25.7) + + babel-preset-jest@29.6.3(@babel/core@7.25.7): + dependencies: + '@babel/core': 7.25.7 babel-plugin-jest-hoist: 29.6.3 - babel-preset-current-node-syntax: 1.1.0(@babel/core@7.25.2) + babel-preset-current-node-syntax: 1.1.0(@babel/core@7.25.7) balanced-match@1.0.2: {} - bare-events@2.5.0: - optional: true - - bare-fs@2.3.5: - dependencies: - bare-events: 2.5.0 - bare-path: 2.1.3 - bare-stream: 2.3.0 - optional: true - - bare-os@2.4.4: - optional: true - - bare-path@2.1.3: - dependencies: - bare-os: 2.4.4 - optional: true - - bare-stream@2.3.0: - dependencies: - b4a: 1.6.7 - streamx: 2.20.1 - optional: true - base-x@3.0.10: dependencies: safe-buffer: 5.2.1 @@ -14896,8 +14597,8 @@ snapshots: browserslist@4.24.0: dependencies: - caniuse-lite: 1.0.30001664 - electron-to-chromium: 1.5.29 + caniuse-lite: 1.0.30001667 + electron-to-chromium: 1.5.34 node-releases: 2.0.18 update-browserslist-db: 1.1.1(browserslist@4.24.0) @@ -14923,8 +14624,6 @@ snapshots: dependencies: node-int64: 0.4.0 - buffer-crc32@0.2.13: {} - buffer-from@1.1.2: {} buffer-indexof-polyfill@1.0.2: {} @@ -14957,9 +14656,6 @@ snapshots: dependencies: node-gyp-build: 4.8.2 - buildcheck@0.0.6: - optional: true - bundle-require@4.2.1(esbuild@0.19.12): dependencies: esbuild: 0.19.12 @@ -14969,8 +14665,6 @@ snapshots: dependencies: streamsearch: 1.1.0 - byline@5.0.0: {} - bytes@3.0.0: {} bytes@3.1.2: {} @@ -15049,7 +14743,7 @@ snapshots: camelcase@6.3.0: {} - caniuse-lite@1.0.30001664: {} + caniuse-lite@1.0.30001667: {} caseless@0.12.0: {} @@ -15166,7 +14860,7 @@ snapshots: class-validator@0.14.1: dependencies: '@types/validator': 13.12.2 - libphonenumber-js: 1.11.9 + libphonenumber-js: 1.11.11 validator: 13.12.0 clean-stack@2.2.0: {} @@ -15323,13 +15017,6 @@ snapshots: compare-versions@6.1.1: {} - compress-commons@4.1.2: - dependencies: - buffer-crc32: 0.2.13 - crc32-stream: 4.0.3 - normalize-path: 3.0.0 - readable-stream: 3.6.2 - compressible@2.0.18: dependencies: mime-db: 1.53.0 @@ -15355,7 +15042,7 @@ snapshots: readable-stream: 2.3.8 typedarray: 0.0.6 - confbox@0.1.7: {} + confbox@0.1.8: {} config-chain@1.1.13: dependencies: @@ -15397,7 +15084,7 @@ snapshots: cookie@0.4.2: {} - cookie@0.6.0: {} + cookie@0.7.1: {} core-js-compat@3.38.1: dependencies: @@ -15437,19 +15124,8 @@ snapshots: optionalDependencies: typescript: 5.4.5 - cpu-features@0.0.10: - dependencies: - buildcheck: 0.0.6 - nan: 2.20.0 - optional: true - crc-32@1.2.2: {} - crc32-stream@4.0.3: - dependencies: - crc-32: 1.2.2 - readable-stream: 3.6.2 - create-hash@1.2.0: dependencies: cipher-base: 1.0.4 @@ -15502,7 +15178,9 @@ snapshots: shebang-command: 2.0.0 which: 2.0.2 - crossws@0.2.4: {} + crossws@0.3.1: + dependencies: + uncrypto: 0.1.3 crypt@0.0.2: {} @@ -15587,7 +15265,7 @@ snapshots: date-fns@2.30.0: dependencies: - '@babel/runtime': 7.25.6 + '@babel/runtime': 7.25.7 date-fns@4.1.0: {} @@ -15652,7 +15330,7 @@ snapshots: object-is: 1.1.6 object-keys: 1.1.1 object.assign: 4.1.5 - regexp.prototype.flags: 1.5.2 + regexp.prototype.flags: 1.5.3 side-channel: 1.0.6 which-boxed-primitive: 1.0.2 which-collection: 1.0.2 @@ -15724,27 +15402,6 @@ snapshots: dlv@1.1.3: {} - docker-compose@0.24.8: - dependencies: - yaml: 2.5.1 - - docker-modem@3.0.8: - dependencies: - debug: 4.3.7(supports-color@8.1.1) - readable-stream: 3.6.2 - split-ca: 1.0.1 - ssh2: 1.16.0 - transitivePeerDependencies: - - supports-color - - dockerode@3.3.5: - dependencies: - '@balena/dockerignore': 1.0.2 - docker-modem: 3.0.8 - tar-fs: 2.0.1 - transitivePeerDependencies: - - supports-color - doctrine@2.1.0: dependencies: esutils: 2.0.3 @@ -15818,7 +15475,7 @@ snapshots: dependencies: jake: 10.9.2 - electron-to-chromium@1.5.29: {} + electron-to-chromium@1.5.34: {} elliptic@6.5.4: dependencies: @@ -15944,7 +15601,7 @@ snapshots: object-inspect: 1.13.2 object-keys: 1.1.1 object.assign: 4.1.5 - regexp.prototype.flags: 1.5.2 + regexp.prototype.flags: 1.5.3 safe-array-concat: 1.1.2 safe-regex-test: 1.0.3 string.prototype.trim: 1.2.9 @@ -15975,7 +15632,7 @@ snapshots: isarray: 2.0.5 stop-iteration-iterator: 1.0.0 - es-iterator-helpers@1.0.19: + es-iterator-helpers@1.1.0: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 @@ -15989,7 +15646,7 @@ snapshots: has-proto: 1.0.3 has-symbols: 1.0.3 internal-slot: 1.0.7 - iterator.prototype: 1.1.2 + iterator.prototype: 1.1.3 safe-array-concat: 1.1.2 es-object-atoms@1.0.0: @@ -16111,10 +15768,10 @@ snapshots: '@typescript-eslint/parser': 7.6.0(eslint@8.57.0)(typescript@5.4.5) eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0) - eslint-plugin-import: 2.30.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0) + eslint-import-resolver-typescript: 3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0) + eslint-plugin-import: 2.31.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0) eslint-plugin-jsx-a11y: 6.10.0(eslint@8.57.0) - eslint-plugin-react: 7.37.0(eslint@8.57.0) + eslint-plugin-react: 7.37.1(eslint@8.57.0) eslint-plugin-react-hooks: 4.6.2(eslint@8.57.0) optionalDependencies: typescript: 5.4.5 @@ -16135,37 +15792,37 @@ snapshots: transitivePeerDependencies: - supports-color - eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0): + eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0): dependencies: '@nolyfill/is-core-module': 1.0.39 debug: 4.3.7(supports-color@8.1.1) enhanced-resolve: 5.17.1 eslint: 8.57.0 - eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0))(eslint@8.57.0) + eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0))(eslint@8.57.0) fast-glob: 3.3.2 get-tsconfig: 4.8.1 is-bun-module: 1.2.1 is-glob: 4.0.3 optionalDependencies: - eslint-plugin-import: 2.30.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0) + eslint-plugin-import: 2.31.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0) transitivePeerDependencies: - '@typescript-eslint/parser' - eslint-import-resolver-node - eslint-import-resolver-webpack - supports-color - eslint-module-utils@2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0))(eslint@8.57.0): + eslint-module-utils@2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0))(eslint@8.57.0): dependencies: debug: 3.2.7 optionalDependencies: '@typescript-eslint/parser': 7.6.0(eslint@8.57.0)(typescript@5.4.5) eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0) + eslint-import-resolver-typescript: 3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0) transitivePeerDependencies: - supports-color - eslint-plugin-import@2.30.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0): + eslint-plugin-import@2.31.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-typescript@3.6.3)(eslint@8.57.0): dependencies: '@rtsao/scc': 1.1.0 array-includes: 3.1.8 @@ -16176,7 +15833,7 @@ snapshots: doctrine: 2.1.0 eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.30.0)(eslint@8.57.0))(eslint@8.57.0) + eslint-module-utils: 2.12.0(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.3(@typescript-eslint/parser@7.6.0(eslint@8.57.0)(typescript@5.4.5))(eslint-import-resolver-node@0.3.9)(eslint-plugin-import@2.31.0)(eslint@8.57.0))(eslint@8.57.0) hasown: 2.0.2 is-core-module: 2.15.1 is-glob: 4.0.3 @@ -16185,6 +15842,7 @@ snapshots: object.groupby: 1.0.3 object.values: 1.2.0 semver: 6.3.1 + string.prototype.trimend: 1.0.8 tsconfig-paths: 3.15.0 optionalDependencies: '@typescript-eslint/parser': 7.6.0(eslint@8.57.0)(typescript@5.4.5) @@ -16203,7 +15861,7 @@ snapshots: axobject-query: 4.1.0 damerau-levenshtein: 1.0.8 emoji-regex: 9.2.2 - es-iterator-helpers: 1.0.19 + es-iterator-helpers: 1.1.0 eslint: 8.57.0 hasown: 2.0.2 jsx-ast-utils: 3.3.5 @@ -16226,14 +15884,14 @@ snapshots: dependencies: eslint: 8.57.0 - eslint-plugin-react@7.37.0(eslint@8.57.0): + eslint-plugin-react@7.37.1(eslint@8.57.0): dependencies: array-includes: 3.1.8 array.prototype.findlast: 1.2.5 array.prototype.flatmap: 1.3.2 array.prototype.tosorted: 1.1.4 doctrine: 2.1.0 - es-iterator-helpers: 1.0.19 + es-iterator-helpers: 1.1.0 eslint: 8.57.0 estraverse: 5.3.0 hasown: 2.0.2 @@ -16529,6 +16187,19 @@ snapshots: - bufferutil - utf-8-validate + ethers@6.13.3(bufferutil@4.0.8)(utf-8-validate@5.0.10): + dependencies: + '@adraffy/ens-normalize': 1.10.1 + '@noble/curves': 1.2.0 + '@noble/hashes': 1.3.2 + '@types/node': 18.15.13 + aes-js: 4.0.0-beta.5 + tslib: 2.4.0 + ws: 8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + transitivePeerDependencies: + - bufferutil + - utf-8-validate + ethjs-unit@0.1.6: dependencies: bn.js: 4.11.6 @@ -16611,14 +16282,14 @@ snapshots: exponential-backoff@3.1.1: {} - express@4.21.0: + express@4.21.1: dependencies: accepts: 1.3.8 array-flatten: 1.1.1 body-parser: 1.20.3 content-disposition: 0.5.4 content-type: 1.0.5 - cookie: 0.6.0 + cookie: 0.7.1 cookie-signature: 1.0.6 debug: 2.6.9 depd: 2.0.0 @@ -16668,8 +16339,6 @@ snapshots: fast-diff@1.3.0: {} - fast-fifo@1.3.2: {} - fast-glob@3.3.2: dependencies: '@nodelib/fs.stat': 2.0.5 @@ -16956,8 +16625,6 @@ snapshots: get-port@3.2.0: {} - get-port@5.1.1: {} - get-port@6.1.2: {} get-stream@5.2.0: @@ -17162,10 +16829,10 @@ snapshots: graphemer@1.4.0: {} - h3@1.12.0: + h3@1.13.0: dependencies: cookie-es: 1.2.2 - crossws: 0.2.4 + crossws: 0.3.1 defu: 6.1.4 destr: 2.0.3 iron-webcrypto: 1.2.1 @@ -17174,8 +16841,6 @@ snapshots: ufo: 1.5.4 uncrypto: 0.1.3 unenv: 1.10.0 - transitivePeerDependencies: - - uWebSockets.js handlebars@4.7.8: dependencies: @@ -17454,11 +17119,11 @@ snapshots: i18next-browser-languagedetector@7.1.0: dependencies: - '@babel/runtime': 7.25.6 + '@babel/runtime': 7.25.7 i18next@23.11.5: dependencies: - '@babel/runtime': 7.25.6 + '@babel/runtime': 7.25.7 iconv-lite@0.4.24: dependencies: @@ -17734,8 +17399,8 @@ snapshots: istanbul-lib-instrument@5.2.1: dependencies: - '@babel/core': 7.25.2 - '@babel/parser': 7.25.6 + '@babel/core': 7.25.7 + '@babel/parser': 7.25.7 '@istanbuljs/schema': 0.1.3 istanbul-lib-coverage: 3.2.2 semver: 6.3.1 @@ -17744,8 +17409,8 @@ snapshots: istanbul-lib-instrument@6.0.3: dependencies: - '@babel/core': 7.25.2 - '@babel/parser': 7.25.6 + '@babel/core': 7.25.7 + '@babel/parser': 7.25.7 '@istanbuljs/schema': 0.1.3 istanbul-lib-coverage: 3.2.2 semver: 7.6.3 @@ -17773,7 +17438,7 @@ snapshots: iterate-object@1.3.4: {} - iterator.prototype@1.1.2: + iterator.prototype@1.1.3: dependencies: define-properties: 1.2.1 get-intrinsic: 1.2.4 @@ -17853,10 +17518,10 @@ snapshots: jest-config@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)): dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 '@jest/test-sequencer': 29.7.0 '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.25.2) + babel-jest: 29.7.0(@babel/core@7.25.7) chalk: 4.1.2 ci-info: 3.9.0 deepmerge: 4.3.1 @@ -17948,7 +17613,7 @@ snapshots: jest-message-util@29.7.0: dependencies: - '@babel/code-frame': 7.24.7 + '@babel/code-frame': 7.25.7 '@jest/types': 29.6.3 '@types/stack-utils': 2.0.3 chalk: 4.1.2 @@ -18050,15 +17715,15 @@ snapshots: jest-snapshot@29.7.0: dependencies: - '@babel/core': 7.25.2 - '@babel/generator': 7.25.6 - '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.25.2) - '@babel/plugin-syntax-typescript': 7.25.4(@babel/core@7.25.2) - '@babel/types': 7.25.6 + '@babel/core': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/plugin-syntax-jsx': 7.25.7(@babel/core@7.25.7) + '@babel/plugin-syntax-typescript': 7.25.7(@babel/core@7.25.7) + '@babel/types': 7.25.7 '@jest/expect-utils': 29.7.0 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - babel-preset-current-node-syntax: 1.1.0(@babel/core@7.25.2) + babel-preset-current-node-syntax: 1.1.0(@babel/core@7.25.7) chalk: 4.1.2 expect: 29.7.0 graceful-fs: 4.2.11 @@ -18123,7 +17788,7 @@ snapshots: jiti@1.21.6: {} - jiti@2.0.0: {} + jiti@2.3.3: {} joi@17.13.3: dependencies: @@ -18160,19 +17825,19 @@ snapshots: jsc-safe-url@0.2.4: {} - jscodeshift@0.14.0(@babel/preset-env@7.25.4(@babel/core@7.25.2)): - dependencies: - '@babel/core': 7.25.2 - '@babel/parser': 7.25.6 - '@babel/plugin-proposal-class-properties': 7.18.6(@babel/core@7.25.2) - '@babel/plugin-proposal-nullish-coalescing-operator': 7.18.6(@babel/core@7.25.2) - '@babel/plugin-proposal-optional-chaining': 7.21.0(@babel/core@7.25.2) - '@babel/plugin-transform-modules-commonjs': 7.24.8(@babel/core@7.25.2) - '@babel/preset-env': 7.25.4(@babel/core@7.25.2) - '@babel/preset-flow': 7.24.7(@babel/core@7.25.2) - '@babel/preset-typescript': 7.24.7(@babel/core@7.25.2) - '@babel/register': 7.24.6(@babel/core@7.25.2) - babel-core: 7.0.0-bridge.0(@babel/core@7.25.2) + jscodeshift@0.14.0(@babel/preset-env@7.25.7(@babel/core@7.25.7)): + dependencies: + '@babel/core': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/plugin-proposal-class-properties': 7.18.6(@babel/core@7.25.7) + '@babel/plugin-proposal-nullish-coalescing-operator': 7.18.6(@babel/core@7.25.7) + '@babel/plugin-proposal-optional-chaining': 7.21.0(@babel/core@7.25.7) + '@babel/plugin-transform-modules-commonjs': 7.25.7(@babel/core@7.25.7) + '@babel/preset-env': 7.25.7(@babel/core@7.25.7) + '@babel/preset-flow': 7.25.7(@babel/core@7.25.7) + '@babel/preset-typescript': 7.25.7(@babel/core@7.25.7) + '@babel/register': 7.25.7(@babel/core@7.25.7) + babel-core: 7.0.0-bridge.0(@babel/core@7.25.7) chalk: 4.1.2 flow-parser: 0.247.1 graceful-fs: 4.2.11 @@ -18185,9 +17850,7 @@ snapshots: transitivePeerDependencies: - supports-color - jsesc@0.5.0: {} - - jsesc@2.5.2: {} + jsesc@3.0.2: {} json-buffer@3.0.1: {} @@ -18274,10 +17937,6 @@ snapshots: dependencies: package-json: 8.1.1 - lazystream@1.0.1: - dependencies: - readable-stream: 2.3.8 - leven@3.1.0: {} levn@0.3.0: @@ -18290,7 +17949,7 @@ snapshots: prelude-ls: 1.2.1 type-check: 0.4.0 - libphonenumber-js@1.11.9: {} + libphonenumber-js@1.11.11: {} lighthouse-logger@1.4.2: dependencies: @@ -18307,28 +17966,26 @@ snapshots: listenercount@1.0.1: {} - listhen@1.8.0: + listhen@1.9.0: dependencies: '@parcel/watcher': 2.4.1 '@parcel/watcher-wasm': 2.4.1 citty: 0.1.6 clipboardy: 4.0.0 consola: 3.2.3 - crossws: 0.2.4 + crossws: 0.3.1 defu: 6.1.4 get-port-please: 3.1.2 - h3: 1.12.0 + h3: 1.13.0 http-shutdown: 1.2.2 - jiti: 2.0.0 - mlly: 1.7.1 + jiti: 2.3.3 + mlly: 1.7.2 node-forge: 1.3.1 pathe: 1.1.2 std-env: 3.7.0 ufo: 1.5.4 untun: 0.1.3 uqr: 0.1.2 - transitivePeerDependencies: - - uWebSockets.js lit-element@3.3.3: dependencies: @@ -18336,17 +17993,17 @@ snapshots: '@lit/reactive-element': 1.6.3 lit-html: 2.8.0 - lit-element@4.1.0: + lit-element@4.1.1: dependencies: '@lit-labs/ssr-dom-shim': 1.2.1 '@lit/reactive-element': 2.0.4 - lit-html: 3.2.0 + lit-html: 3.2.1 lit-html@2.8.0: dependencies: '@types/trusted-types': 2.0.7 - lit-html@3.2.0: + lit-html@3.2.1: dependencies: '@types/trusted-types': 2.0.7 @@ -18359,8 +18016,8 @@ snapshots: lit@3.1.0: dependencies: '@lit/reactive-element': 2.0.4 - lit-element: 4.1.0 - lit-html: 3.2.0 + lit-element: 4.1.1 + lit-html: 3.2.1 load-tsconfig@0.2.5: {} @@ -18388,16 +18045,8 @@ snapshots: lodash.debounce@4.0.8: {} - lodash.defaults@4.2.0: {} - - lodash.difference@4.5.0: {} - - lodash.flatten@4.4.0: {} - lodash.isequal@4.5.0: {} - lodash.isplainobject@4.0.6: {} - lodash.memoize@4.1.2: {} lodash.merge@4.6.2: {} @@ -18408,8 +18057,6 @@ snapshots: lodash.truncate@4.4.2: {} - lodash.union@4.6.0: {} - lodash@4.17.21: {} log-symbols@4.1.0: @@ -18520,7 +18167,7 @@ snapshots: metro-babel-transformer@0.80.12: dependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 flow-enums-runtime: 0.0.6 hermes-parser: 0.23.1 nullthrows: 1.1.1 @@ -18587,13 +18234,13 @@ snapshots: metro-runtime@0.80.12: dependencies: - '@babel/runtime': 7.25.6 + '@babel/runtime': 7.25.7 flow-enums-runtime: 0.0.6 metro-source-map@0.80.12: dependencies: - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 flow-enums-runtime: 0.0.6 invariant: 2.2.4 metro-symbolicate: 0.80.12 @@ -18618,10 +18265,10 @@ snapshots: metro-transform-plugins@0.80.12: dependencies: - '@babel/core': 7.25.2 - '@babel/generator': 7.25.6 - '@babel/template': 7.25.0 - '@babel/traverse': 7.25.6 + '@babel/core': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/template': 7.25.7 + '@babel/traverse': 7.25.7 flow-enums-runtime: 0.0.6 nullthrows: 1.1.1 transitivePeerDependencies: @@ -18629,10 +18276,10 @@ snapshots: metro-transform-worker@0.80.12(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - '@babel/core': 7.25.2 - '@babel/generator': 7.25.6 - '@babel/parser': 7.25.6 - '@babel/types': 7.25.6 + '@babel/core': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/types': 7.25.7 flow-enums-runtime: 0.0.6 metro: 0.80.12(bufferutil@4.0.8)(utf-8-validate@5.0.10) metro-babel-transformer: 0.80.12 @@ -18649,13 +18296,13 @@ snapshots: metro@0.80.12(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - '@babel/code-frame': 7.24.7 - '@babel/core': 7.25.2 - '@babel/generator': 7.25.6 - '@babel/parser': 7.25.6 - '@babel/template': 7.25.0 - '@babel/traverse': 7.25.6 - '@babel/types': 7.25.6 + '@babel/code-frame': 7.25.7 + '@babel/core': 7.25.7 + '@babel/generator': 7.25.7 + '@babel/parser': 7.25.7 + '@babel/template': 7.25.7 + '@babel/traverse': 7.25.7 + '@babel/types': 7.25.7 accepts: 1.3.8 chalk: 4.1.2 ci-info: 2.0.0 @@ -18815,11 +18462,11 @@ snapshots: mkdirp@3.0.1: {} - mlly@1.7.1: + mlly@1.7.2: dependencies: acorn: 8.12.1 pathe: 1.1.2 - pkg-types: 1.2.0 + pkg-types: 1.2.1 ufo: 1.5.4 mnemonist@0.38.5: @@ -18905,9 +18552,6 @@ snapshots: object-assign: 4.1.1 thenify-all: 1.6.0 - nan@2.20.0: - optional: true - nano-json-stream-parser@0.1.2: {} nanoid@3.3.7: {} @@ -18920,25 +18564,25 @@ snapshots: neo-async@2.6.2: {} - next-seo@6.6.0(next@14.2.15(@babel/core@7.25.2)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1): + next-seo@6.6.0(next@14.2.15(@babel/core@7.25.7)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1))(react-dom@18.3.1(react@18.3.1))(react@18.3.1): dependencies: - next: 14.2.15(@babel/core@7.25.2)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + next: 14.2.15(@babel/core@7.25.7)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) react: 18.3.1 react-dom: 18.3.1(react@18.3.1) next-tick@1.1.0: {} - next@14.2.15(@babel/core@7.25.2)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1): + next@14.2.15(@babel/core@7.25.7)(@playwright/test@1.45.3)(react-dom@18.3.1(react@18.3.1))(react@18.3.1): dependencies: '@next/env': 14.2.15 '@swc/helpers': 0.5.5 busboy: 1.6.0 - caniuse-lite: 1.0.30001664 + caniuse-lite: 1.0.30001667 graceful-fs: 4.2.11 postcss: 8.4.31 react: 18.3.1 react-dom: 18.3.1(react@18.3.1) - styled-jsx: 5.1.1(@babel/core@7.25.2)(react@18.3.1) + styled-jsx: 5.1.1(@babel/core@7.25.7)(react@18.3.1) optionalDependencies: '@next/swc-darwin-arm64': 14.2.15 '@next/swc-darwin-x64': 14.2.15 @@ -19055,7 +18699,7 @@ snapshots: dependencies: path-key: 4.0.0 - npm@10.8.3: {} + npm@10.9.0: {} nth-check@2.1.1: dependencies: @@ -19133,7 +18777,7 @@ snapshots: dependencies: http-https: 1.0.0 - ofetch@1.4.0: + ofetch@1.4.1: dependencies: destr: 2.0.3 node-fetch-native: 1.6.4 @@ -19286,7 +18930,7 @@ snapshots: parse-json@5.2.0: dependencies: - '@babel/code-frame': 7.24.7 + '@babel/code-frame': 7.25.7 error-ex: 1.3.2 json-parse-even-better-errors: 2.3.1 lines-and-columns: 1.2.4 @@ -19438,10 +19082,10 @@ snapshots: dependencies: find-up: 4.1.0 - pkg-types@1.2.0: + pkg-types@1.2.1: dependencies: - confbox: 0.1.7 - mlly: 1.7.1 + confbox: 0.1.8 + mlly: 1.7.2 pathe: 1.1.2 playwright-core@1.45.3: {} @@ -19514,7 +19158,7 @@ snapshots: dependencies: xtend: 4.0.2 - preact@10.24.1: {} + preact@10.24.2: {} prebuild-install@7.1.2: dependencies: @@ -19601,10 +19245,6 @@ snapshots: retry: 0.12.0 signal-exit: 3.0.7 - properties-reader@2.3.0: - dependencies: - mkdirp: 1.0.4 - proto-list@1.2.4: {} proxy-addr@2.0.7: @@ -19665,8 +19305,6 @@ snapshots: queue-microtask@1.2.3: {} - queue-tick@1.0.1: {} - queue@6.0.2: dependencies: inherits: 2.0.4 @@ -19735,26 +19373,26 @@ snapshots: react-is@18.3.1: {} - react-native-webview@11.26.1(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1): + react-native-webview@11.26.1(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1): dependencies: escape-string-regexp: 2.0.0 invariant: 2.2.4 react: 18.3.1 - react-native: 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) + react-native: 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10) - react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10): + react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10): dependencies: '@jest/create-cache-key-function': 29.7.0 '@react-native-community/cli': 14.1.0(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10) '@react-native-community/cli-platform-android': 14.1.0 '@react-native-community/cli-platform-ios': 14.1.0 - '@react-native/assets-registry': 0.75.3 - '@react-native/codegen': 0.75.3(@babel/preset-env@7.25.4(@babel/core@7.25.2)) - '@react-native/community-cli-plugin': 0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10) - '@react-native/gradle-plugin': 0.75.3 - '@react-native/js-polyfills': 0.75.3 - '@react-native/normalize-colors': 0.75.3 - '@react-native/virtualized-lists': 0.75.3(@types/react@18.3.11)(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) + '@react-native/assets-registry': 0.75.4 + '@react-native/codegen': 0.75.4(@babel/preset-env@7.25.7(@babel/core@7.25.7)) + '@react-native/community-cli-plugin': 0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(bufferutil@4.0.8)(encoding@0.1.13)(utf-8-validate@5.0.10) + '@react-native/gradle-plugin': 0.75.4 + '@react-native/js-polyfills': 0.75.4 + '@react-native/normalize-colors': 0.75.4 + '@react-native/virtualized-lists': 0.75.4(@types/react@18.3.11)(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1) abort-controller: 3.0.0 anser: 1.4.10 ansi-regex: 5.0.1 @@ -19835,10 +19473,6 @@ snapshots: process: 0.11.10 string_decoder: 1.3.0 - readdir-glob@1.1.3: - dependencies: - minimatch: 5.1.6 - readdirp@3.6.0: dependencies: picomatch: 2.3.1 @@ -19888,21 +19522,21 @@ snapshots: regenerator-transform@0.15.2: dependencies: - '@babel/runtime': 7.25.6 + '@babel/runtime': 7.25.7 - regexp.prototype.flags@1.5.2: + regexp.prototype.flags@1.5.3: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-errors: 1.3.0 set-function-name: 2.0.2 - regexpu-core@5.3.2: + regexpu-core@6.1.1: dependencies: - '@babel/regjsgen': 0.8.0 regenerate: 1.4.2 regenerate-unicode-properties: 10.2.0 - regjsparser: 0.9.1 + regjsgen: 0.8.0 + regjsparser: 0.11.1 unicode-match-property-ecmascript: 2.0.0 unicode-match-property-value-ecmascript: 2.2.0 @@ -19914,9 +19548,11 @@ snapshots: dependencies: rc: 1.2.8 - regjsparser@0.9.1: + regjsgen@0.8.0: {} + + regjsparser@0.11.1: dependencies: - jsesc: 0.5.0 + jsesc: 3.0.2 req-cwd@2.0.0: dependencies: @@ -20035,35 +19671,35 @@ snapshots: dependencies: bn.js: 5.2.1 - rollup-plugin-visualizer@5.12.0(rollup@4.22.5): + rollup-plugin-visualizer@5.12.0(rollup@4.24.0): dependencies: open: 8.4.2 picomatch: 2.3.1 source-map: 0.7.4 yargs: 17.7.2 optionalDependencies: - rollup: 4.22.5 + rollup: 4.24.0 - rollup@4.22.5: + rollup@4.24.0: dependencies: '@types/estree': 1.0.6 optionalDependencies: - '@rollup/rollup-android-arm-eabi': 4.22.5 - '@rollup/rollup-android-arm64': 4.22.5 - '@rollup/rollup-darwin-arm64': 4.22.5 - '@rollup/rollup-darwin-x64': 4.22.5 - '@rollup/rollup-linux-arm-gnueabihf': 4.22.5 - '@rollup/rollup-linux-arm-musleabihf': 4.22.5 - '@rollup/rollup-linux-arm64-gnu': 4.22.5 - '@rollup/rollup-linux-arm64-musl': 4.22.5 - '@rollup/rollup-linux-powerpc64le-gnu': 4.22.5 - '@rollup/rollup-linux-riscv64-gnu': 4.22.5 - '@rollup/rollup-linux-s390x-gnu': 4.22.5 - '@rollup/rollup-linux-x64-gnu': 4.22.5 - '@rollup/rollup-linux-x64-musl': 4.22.5 - '@rollup/rollup-win32-arm64-msvc': 4.22.5 - '@rollup/rollup-win32-ia32-msvc': 4.22.5 - '@rollup/rollup-win32-x64-msvc': 4.22.5 + '@rollup/rollup-android-arm-eabi': 4.24.0 + '@rollup/rollup-android-arm64': 4.24.0 + '@rollup/rollup-darwin-arm64': 4.24.0 + '@rollup/rollup-darwin-x64': 4.24.0 + '@rollup/rollup-linux-arm-gnueabihf': 4.24.0 + '@rollup/rollup-linux-arm-musleabihf': 4.24.0 + '@rollup/rollup-linux-arm64-gnu': 4.24.0 + '@rollup/rollup-linux-arm64-musl': 4.24.0 + '@rollup/rollup-linux-powerpc64le-gnu': 4.24.0 + '@rollup/rollup-linux-riscv64-gnu': 4.24.0 + '@rollup/rollup-linux-s390x-gnu': 4.24.0 + '@rollup/rollup-linux-x64-gnu': 4.24.0 + '@rollup/rollup-linux-x64-musl': 4.24.0 + '@rollup/rollup-win32-arm64-msvc': 4.24.0 + '@rollup/rollup-win32-ia32-msvc': 4.24.0 + '@rollup/rollup-win32-x64-msvc': 4.24.0 fsevents: 2.3.3 run-parallel@1.2.0: @@ -20180,7 +19816,7 @@ snapshots: dependencies: body-parser: 1.20.3 cors: 2.8.5 - express: 4.21.0 + express: 4.21.1 request: 2.88.2 xhr: 2.6.0 transitivePeerDependencies: @@ -20456,8 +20092,6 @@ snapshots: dependencies: whatwg-url: 7.1.0 - split-ca@1.0.1: {} - split-on-first@1.1.0: {} split2@4.2.0: {} @@ -20466,19 +20100,6 @@ snapshots: sprintf-js@1.1.3: {} - ssh-remote-port-forward@1.0.4: - dependencies: - '@types/ssh2': 0.5.52 - ssh2: 1.16.0 - - ssh2@1.16.0: - dependencies: - asn1: 0.2.6 - bcrypt-pbkdf: 1.0.2 - optionalDependencies: - cpu-features: 0.0.10 - nan: 2.20.0 - sshpk@1.18.0: dependencies: asn1: 0.2.6 @@ -20521,14 +20142,6 @@ snapshots: streamsearch@1.1.0: {} - streamx@2.20.1: - dependencies: - fast-fifo: 1.3.2 - queue-tick: 1.0.1 - text-decoder: 1.2.0 - optionalDependencies: - bare-events: 2.5.0 - strict-uri-encode@1.1.0: {} strict-uri-encode@2.0.0: {} @@ -20573,7 +20186,7 @@ snapshots: gopd: 1.0.1 has-symbols: 1.0.3 internal-slot: 1.0.7 - regexp.prototype.flags: 1.5.2 + regexp.prototype.flags: 1.5.3 set-function-name: 2.0.2 side-channel: 1.0.6 @@ -20643,12 +20256,12 @@ snapshots: strnum@1.0.5: {} - styled-jsx@5.1.1(@babel/core@7.25.2)(react@18.3.1): + styled-jsx@5.1.1(@babel/core@7.25.7)(react@18.3.1): dependencies: client-only: 0.0.1 react: 18.3.1 optionalDependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 sucrase@3.35.0: dependencies: @@ -20783,13 +20396,6 @@ snapshots: tapable@2.2.1: {} - tar-fs@2.0.1: - dependencies: - chownr: 1.1.4 - mkdirp-classic: 0.5.3 - pump: 3.0.2 - tar-stream: 2.2.0 - tar-fs@2.1.1: dependencies: chownr: 1.1.4 @@ -20797,14 +20403,6 @@ snapshots: pump: 3.0.2 tar-stream: 2.2.0 - tar-fs@3.0.6: - dependencies: - pump: 3.0.2 - tar-stream: 3.1.7 - optionalDependencies: - bare-fs: 2.3.5 - bare-path: 2.1.3 - tar-stream@2.2.0: dependencies: bl: 4.1.0 @@ -20813,12 +20411,6 @@ snapshots: inherits: 2.0.4 readable-stream: 3.6.2 - tar-stream@3.1.7: - dependencies: - b4a: 1.6.7 - fast-fifo: 1.3.2 - streamx: 2.20.1 - tar@4.4.19: dependencies: chownr: 1.1.4 @@ -20855,31 +20447,6 @@ snapshots: glob: 7.2.3 minimatch: 3.1.2 - testcontainers@10.9.0(encoding@0.1.13): - dependencies: - '@balena/dockerignore': 1.0.2 - '@types/dockerode': 3.3.31 - archiver: 5.3.2 - async-lock: 1.4.1 - byline: 5.0.0 - debug: 4.3.7(supports-color@8.1.1) - docker-compose: 0.24.8 - dockerode: 3.3.5 - get-port: 5.1.1 - node-fetch: 2.7.0(encoding@0.1.13) - proper-lockfile: 4.1.2 - properties-reader: 2.3.0 - ssh-remote-port-forward: 1.0.4 - tar-fs: 3.0.6 - tmp: 0.2.3 - transitivePeerDependencies: - - encoding - - supports-color - - text-decoder@1.2.0: - dependencies: - b4a: 1.6.7 - text-encoding-utf-8@1.0.2: optional: true @@ -20933,8 +20500,6 @@ snapshots: dependencies: os-tmpdir: 1.0.2 - tmp@0.2.3: {} - tmpl@1.0.5: {} to-fast-properties@2.0.0: {} @@ -20979,7 +20544,7 @@ snapshots: ts-interface-checker@0.1.13: {} - ts-jest@29.1.2(@babel/core@7.25.2)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5): + ts-jest@29.1.2(@babel/core@7.25.7)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5): dependencies: bs-logger: 0.2.6 fast-json-stable-stringify: 2.1.0 @@ -20992,11 +20557,11 @@ snapshots: typescript: 5.4.5 yargs-parser: 21.1.1 optionalDependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.25.2) + babel-jest: 29.7.0(@babel/core@7.25.7) - ts-jest@29.2.5(@babel/core@7.25.2)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.2))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5): + ts-jest@29.2.5(@babel/core@7.25.7)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.25.7))(jest@29.7.0(@types/node@20.12.7)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)))(typescript@5.4.5): dependencies: bs-logger: 0.2.6 ejs: 3.1.10 @@ -21010,10 +20575,10 @@ snapshots: typescript: 5.4.5 yargs-parser: 21.1.1 optionalDependencies: - '@babel/core': 7.25.2 + '@babel/core': 7.25.7 '@jest/transform': 29.7.0 '@jest/types': 29.6.3 - babel-jest: 29.7.0(@babel/core@7.25.2) + babel-jest: 29.7.0(@babel/core@7.25.7) ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5): dependencies: @@ -21060,7 +20625,7 @@ snapshots: joycon: 3.1.1 postcss-load-config: 4.0.2(postcss@8.4.47)(ts-node@10.9.2(@types/node@20.12.7)(typescript@5.4.5)) resolve-from: 5.0.0 - rollup: 4.22.5 + rollup: 4.24.0 source-map: 0.8.0-beta.0 sucrase: 3.35.0 tree-kill: 1.2.2 @@ -21264,17 +20829,15 @@ snapshots: anymatch: 3.1.3 chokidar: 3.6.0 destr: 2.0.3 - h3: 1.12.0 - listhen: 1.8.0 + h3: 1.13.0 + listhen: 1.9.0 lru-cache: 10.4.3 mri: 1.2.0 node-fetch-native: 1.6.4 - ofetch: 1.4.0 + ofetch: 1.4.1 ufo: 1.5.4 optionalDependencies: idb-keyval: 6.2.1 - transitivePeerDependencies: - - uWebSockets.js untun@0.1.3: dependencies: @@ -21414,10 +20977,10 @@ snapshots: w-json@1.3.10: {} - wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4): + wagmi@2.12.17(@tanstack/query-core@5.59.0)(@tanstack/react-query@5.59.3(react@18.3.1))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4): dependencies: '@tanstack/react-query': 5.59.3(react@18.3.1) - '@wagmi/connectors': 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.3(@babel/core@7.25.2)(@babel/preset-env@7.25.4(@babel/core@7.25.2))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.22.5)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) + '@wagmi/connectors': 5.1.15(@types/react@18.3.11)(@wagmi/core@2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)))(bufferutil@4.0.8)(encoding@0.1.13)(react-dom@18.3.1(react@18.3.1))(react-native@0.75.4(@babel/core@7.25.7)(@babel/preset-env@7.25.7(@babel/core@7.25.7))(@types/react@18.3.11)(bufferutil@4.0.8)(encoding@0.1.13)(react@18.3.1)(typescript@5.4.5)(utf-8-validate@5.0.10))(react@18.3.1)(rollup@4.24.0)(typescript@5.4.5)(utf-8-validate@5.0.10)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4))(zod@3.22.4) '@wagmi/core': 2.13.8(@tanstack/query-core@5.59.0)(@types/react@18.3.11)(react@18.3.1)(typescript@5.4.5)(viem@2.21.19(bufferutil@4.0.8)(typescript@5.4.5)(utf-8-validate@5.0.10)(zod@3.22.4)) react: 18.3.1 use-sync-external-store: 1.2.0(react@18.3.1) @@ -21447,7 +21010,6 @@ snapshots: - react-native - rollup - supports-color - - uWebSockets.js - utf-8-validate - zod @@ -21960,12 +21522,6 @@ snapshots: yocto-queue@0.1.0: {} - zip-stream@4.1.1: - dependencies: - archiver-utils: 3.0.4 - compress-commons: 4.1.2 - readable-stream: 3.6.2 - zksync-ethers@5.9.2(ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)): dependencies: ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) From 9763bf23b13fa19acf788e9797802b1191de05e0 Mon Sep 17 00:00:00 2001 From: Ivo Kubjas Date: Wed, 16 Oct 2024 10:29:46 +0200 Subject: [PATCH 05/12] fix: ensure IsActive column does not re-activate (#172) * chore: use common constraints for binary * chore: use common constraint for zero when inactive * fix: enforce IsActive activation * chore: use common constraint for binary * chore: use common cs for zero when inactive * fix: enforce activation constraints for ecdata antichamber --- prover/zkevm/prover/ecdsa/adress.go | 13 ++-- prover/zkevm/prover/ecdsa/antichamber.go | 2 +- .../prover/ecdsa/antichamber_constraints.go | 37 ++++------- prover/zkevm/prover/ecdsa/ecdata.go | 3 +- prover/zkevm/prover/ecdsa/utils.go | 27 -------- prover/zkevm/prover/ecpair/ecpair.go | 2 + .../zkevm/prover/ecpair/ecpair_constraints.go | 61 ++++++++----------- 7 files changed, 50 insertions(+), 95 deletions(-) delete mode 100644 prover/zkevm/prover/ecdsa/utils.go diff --git a/prover/zkevm/prover/ecdsa/adress.go b/prover/zkevm/prover/ecdsa/adress.go index b75c93787..ea5462b40 100644 --- a/prover/zkevm/prover/ecdsa/adress.go +++ b/prover/zkevm/prover/ecdsa/adress.go @@ -13,6 +13,7 @@ import ( "github.com/consensys/linea-monorepo/prover/protocol/wizard" sym "github.com/consensys/linea-monorepo/prover/symbolic" "github.com/consensys/linea-monorepo/prover/zkevm/prover/common" + commoncs "github.com/consensys/linea-monorepo/prover/zkevm/prover/common/common_constraints" "github.com/consensys/linea-monorepo/prover/zkevm/prover/hash/generic" ) @@ -82,11 +83,13 @@ func newAddress(comp *wizard.CompiledIOP, size int, ecRec *EcRecover, ac *antich comp.InsertGlobal(0, ifaces.QueryIDf("Format_IsAddress"), sym.Sub(addr.isAddress, sym.Add(addr.isAddressFromEcRec, addr.isAddressFromTxnData))) - mustBeBinary(comp, addr.isAddress) - mustBeBinary(comp, addr.isAddressFromEcRec) - mustBeBinary(comp, addr.isAddressFromTxnData) - isZeroWhenInactive(comp, addr.isAddress, ac.IsActive) - isZeroWhenInactive(comp, addr.hashNum, ac.IsActive) + commoncs.MustBeBinary(comp, addr.isAddress) + commoncs.MustBeBinary(comp, addr.isAddressFromEcRec) + commoncs.MustBeBinary(comp, addr.isAddressFromTxnData) + commoncs.MustZeroWhenInactive(comp, ac.IsActive, + addr.isAddress, + addr.hashNum, + ) // check the trimming of hashHi to the addressHi addr.csAddressTrimming(comp) diff --git a/prover/zkevm/prover/ecdsa/antichamber.go b/prover/zkevm/prover/ecdsa/antichamber.go index c5fff035c..5fb8aeb9e 100644 --- a/prover/zkevm/prover/ecdsa/antichamber.go +++ b/prover/zkevm/prover/ecdsa/antichamber.go @@ -126,7 +126,7 @@ func newAntichamber(comp *wizard.CompiledIOP, inputs *antichamberInput) *anticha res.AlignedGnarkData = plonk.DefineAlignment(comp, toAlign) // root module constraints - res.csIsActive(comp) + res.csIsActiveActivation(comp) res.csZeroWhenInactive(comp) res.csConsistentPushingFetching(comp) res.csIDSequential(comp) diff --git a/prover/zkevm/prover/ecdsa/antichamber_constraints.go b/prover/zkevm/prover/ecdsa/antichamber_constraints.go index 890dbb8c9..08df3a448 100644 --- a/prover/zkevm/prover/ecdsa/antichamber_constraints.go +++ b/prover/zkevm/prover/ecdsa/antichamber_constraints.go @@ -5,38 +5,27 @@ import ( "github.com/consensys/linea-monorepo/prover/protocol/ifaces" "github.com/consensys/linea-monorepo/prover/protocol/wizard" sym "github.com/consensys/linea-monorepo/prover/symbolic" + commoncs "github.com/consensys/linea-monorepo/prover/zkevm/prover/common/common_constraints" ) -// csIsActive constraints that IsActive module to be only one for antichamber rounds. -func (ac *antichamber) csIsActive(comp *wizard.CompiledIOP) { - // column must be binary - mustBeBinary(comp, ac.IsActive) - // allow becoming inactive from active but now vice versa - isZeroWhenInactive(comp, ac.IsActive, column.Shift(ac.IsActive, -1)) +// csIsActiveActivation constraints that IsActive module to be only one for antichamber rounds. +func (ac *antichamber) csIsActiveActivation(comp *wizard.CompiledIOP) { + // IsActive must be binary and cannot transition from 0 to 1 + commoncs.MustBeActivationColumns(comp, ac.IsActive) } func (ac *antichamber) csZeroWhenInactive(comp *wizard.CompiledIOP) { - for _, c := range ac.cols(false) { - isZeroWhenInactive(comp, c, ac.IsActive) - } - for _, c := range ac.EcRecover.cols() { - isZeroWhenInactive(comp, c, ac.IsActive) - } - for _, c := range ac.Addresses.cols() { - isZeroWhenInactive(comp, c, ac.IsActive) - } - for _, c := range ac.txSignature.cols() { - isZeroWhenInactive(comp, c, ac.IsActive) - } - for _, c := range ac.UnalignedGnarkData.cols() { - isZeroWhenInactive(comp, c, ac.IsActive) - } + commoncs.MustZeroWhenInactive(comp, ac.IsActive, ac.cols(false)...) + commoncs.MustZeroWhenInactive(comp, ac.IsActive, ac.EcRecover.cols()...) + commoncs.MustZeroWhenInactive(comp, ac.IsActive, ac.Addresses.cols()...) + commoncs.MustZeroWhenInactive(comp, ac.IsActive, ac.txSignature.cols()...) + commoncs.MustZeroWhenInactive(comp, ac.IsActive, ac.UnalignedGnarkData.cols()...) } func (ac *antichamber) csConsistentPushingFetching(comp *wizard.CompiledIOP) { // pushing and fetching must be binary - mustBeBinary(comp, ac.IsPushing) - mustBeBinary(comp, ac.IsFetching) + commoncs.MustBeBinary(comp, ac.IsPushing) + commoncs.MustBeBinary(comp, ac.IsFetching) // pushing and fetching cannot be active at the same time comp.InsertGlobal( ROUND_NR, @@ -58,7 +47,7 @@ func (ac *antichamber) csIDSequential(comp *wizard.CompiledIOP) { func (ac *antichamber) csSource(comp *wizard.CompiledIOP) { // source must be binary // Source=0 <> ECRecover, Source=1 <> TxSignature - mustBeBinary(comp, ac.Source) + commoncs.MustBeBinary(comp, ac.Source) } func (ac *antichamber) csTransitions(comp *wizard.CompiledIOP) { diff --git a/prover/zkevm/prover/ecdsa/ecdata.go b/prover/zkevm/prover/ecdsa/ecdata.go index 303ac3079..b54965f88 100644 --- a/prover/zkevm/prover/ecdsa/ecdata.go +++ b/prover/zkevm/prover/ecdsa/ecdata.go @@ -7,6 +7,7 @@ import ( "github.com/consensys/linea-monorepo/prover/protocol/ifaces" "github.com/consensys/linea-monorepo/prover/protocol/wizard" sym "github.com/consensys/linea-monorepo/prover/symbolic" + commoncs "github.com/consensys/linea-monorepo/prover/zkevm/prover/common/common_constraints" ) var ( @@ -173,7 +174,7 @@ func (ec *EcRecover) csEcDataProjection(comp *wizard.CompiledIOP, src *ecDataSou } func (ec *EcRecover) csConstraintAuxProjectionMask(comp *wizard.CompiledIOP) { - mustBeBinary(comp, ec.AuxProjectionMask) + commoncs.MustBeBinary(comp, ec.AuxProjectionMask) } // TODO: must be called from the antichamber to ensure that the mask is consistent with the column in the root antichamber diff --git a/prover/zkevm/prover/ecdsa/utils.go b/prover/zkevm/prover/ecdsa/utils.go deleted file mode 100644 index 3461df1a5..000000000 --- a/prover/zkevm/prover/ecdsa/utils.go +++ /dev/null @@ -1,27 +0,0 @@ -package ecdsa - -import ( - "github.com/consensys/linea-monorepo/prover/protocol/ifaces" - "github.com/consensys/linea-monorepo/prover/protocol/wizard" - sym "github.com/consensys/linea-monorepo/prover/symbolic" -) - -// -- utils. Copied from prover/zkevm/prover/statemanager/statesummary/state_summary.go - -// isZeroWhenInactive constraints the column to cancel when inactive. -func isZeroWhenInactive(comp *wizard.CompiledIOP, c, isActive ifaces.Column) { - comp.InsertGlobal( - ROUND_NR, - ifaces.QueryIDf("%v_IS_ZERO_WHEN_INACTIVE", c.GetColID()), - sym.Sub(c, sym.Mul(c, isActive)), - ) -} - -// mustBeBinary constrains the current column to be binary. -func mustBeBinary(comp *wizard.CompiledIOP, c ifaces.Column) { - comp.InsertGlobal( - ROUND_NR, - ifaces.QueryIDf("%v_MUST_BE_BINARY", c.GetColID()), - sym.Mul(c, sym.Sub(c, 1)), - ) -} diff --git a/prover/zkevm/prover/ecpair/ecpair.go b/prover/zkevm/prover/ecpair/ecpair.go index 255e8c3e2..5f9b2043b 100644 --- a/prover/zkevm/prover/ecpair/ecpair.go +++ b/prover/zkevm/prover/ecpair/ecpair.go @@ -89,6 +89,8 @@ func newECPair(comp *wizard.CompiledIOP, limits *Limits, ecSource *ECPairSource) UnalignedG2MembershipData: newUnalignedG2MembershipData(comp, limits), } + // IsActive activation - can only go from 1 to {0, 1} and from 0 to 0. + res.csIsActiveActivation(comp) // masks and flags are binary res.csBinaryConstraints(comp) // IsActive is only active when we are either pulling or computing in the unaligned submodules diff --git a/prover/zkevm/prover/ecpair/ecpair_constraints.go b/prover/zkevm/prover/ecpair/ecpair_constraints.go index e36d00ea6..40e5c5be4 100644 --- a/prover/zkevm/prover/ecpair/ecpair_constraints.go +++ b/prover/zkevm/prover/ecpair/ecpair_constraints.go @@ -9,21 +9,26 @@ import ( "github.com/consensys/linea-monorepo/prover/protocol/ifaces" "github.com/consensys/linea-monorepo/prover/protocol/wizard" sym "github.com/consensys/linea-monorepo/prover/symbolic" + common "github.com/consensys/linea-monorepo/prover/zkevm/prover/common/common_constraints" ) +func (ec *ECPair) csIsActiveActivation(comp *wizard.CompiledIOP) { + // IsActive is binary and cannot transition from 0 to 1 + common.MustBeActivationColumns(comp, ec.IsActive) +} + func (ec *ECPair) csBinaryConstraints(comp *wizard.CompiledIOP) { - mustBeBinary(comp, ec.IsActive) - mustBeBinary(comp, ec.UnalignedPairingData.IsPulling) - mustBeBinary(comp, ec.UnalignedPairingData.IsComputed) - mustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfInstance) - mustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorInit) - mustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorCurr) - mustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorPrev) - mustBeBinary(comp, ec.UnalignedPairingData.ToMillerLoopCircuitMask) - mustBeBinary(comp, ec.UnalignedPairingData.ToFinalExpCircuitMask) - mustBeBinary(comp, ec.UnalignedG2MembershipData.IsPulling) - mustBeBinary(comp, ec.UnalignedG2MembershipData.IsComputed) - mustBeBinary(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsPulling) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsComputed) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfInstance) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorInit) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorCurr) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorPrev) + common.MustBeBinary(comp, ec.UnalignedPairingData.ToMillerLoopCircuitMask) + common.MustBeBinary(comp, ec.UnalignedPairingData.ToFinalExpCircuitMask) + common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsPulling) + common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsComputed) + common.MustBeBinary(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask) } func (ec *ECPair) csFlagConsistency(comp *wizard.CompiledIOP) { @@ -41,11 +46,13 @@ func (ec *ECPair) csFlagConsistency(comp *wizard.CompiledIOP) { func (ec *ECPair) csOffWhenInactive(comp *wizard.CompiledIOP) { // nothing is set when inactive - isZeroWhenInactive(comp, ec.UnalignedPairingData.Limb, ec.IsActive) - isZeroWhenInactive(comp, ec.UnalignedPairingData.ToMillerLoopCircuitMask, ec.IsActive) - isZeroWhenInactive(comp, ec.UnalignedPairingData.ToFinalExpCircuitMask, ec.IsActive) - isZeroWhenInactive(comp, ec.UnalignedG2MembershipData.Limb, ec.IsActive) - isZeroWhenInactive(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask, ec.IsActive) + common.MustZeroWhenInactive(comp, ec.IsActive, + ec.UnalignedPairingData.Limb, + ec.UnalignedPairingData.ToMillerLoopCircuitMask, + ec.UnalignedPairingData.ToFinalExpCircuitMask, + ec.UnalignedG2MembershipData.Limb, + ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask, + ) } func (ec *ECPair) csProjections(comp *wizard.CompiledIOP) { @@ -277,23 +284,3 @@ func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { ), ) } - -// -- utils. Copied from prover/zkevm/prover/statemanager/statesummary/state_summary.go - -// isZeroWhenInactive constraints the column to cancel when inactive. -func isZeroWhenInactive(comp *wizard.CompiledIOP, c, isActive ifaces.Column) { - comp.InsertGlobal( - roundNr, - ifaces.QueryIDf("%v_IS_ZERO_WHEN_INACTIVE", c.GetColID()), - sym.Sub(c, sym.Mul(c, isActive)), - ) -} - -// mustBeBinary constrains the current column to be binary. -func mustBeBinary(comp *wizard.CompiledIOP, c ifaces.Column) { - comp.InsertGlobal( - roundNr, - ifaces.QueryIDf("%v_MUST_BE_BINARY", c.GetColID()), - sym.Mul(c, sym.Sub(c, 1)), - ) -} From 3c6219d407165f1db0af4c5d0f6f3ab2c8a9f301 Mon Sep 17 00:00:00 2001 From: Ivo Kubjas Date: Wed, 16 Oct 2024 11:08:38 +0200 Subject: [PATCH 06/12] fix: add binary constraints for accumulators first lines (#173) --- prover/zkevm/prover/ecpair/ecpair_constraints.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/prover/zkevm/prover/ecpair/ecpair_constraints.go b/prover/zkevm/prover/ecpair/ecpair_constraints.go index 40e5c5be4..979f51769 100644 --- a/prover/zkevm/prover/ecpair/ecpair_constraints.go +++ b/prover/zkevm/prover/ecpair/ecpair_constraints.go @@ -29,6 +29,8 @@ func (ec *ECPair) csBinaryConstraints(comp *wizard.CompiledIOP) { common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsPulling) common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsComputed) common.MustBeBinary(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfPrevAccumulator) + common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfCurrAccumulator) } func (ec *ECPair) csFlagConsistency(comp *wizard.CompiledIOP) { From 5a2ab959162125e1464889c66221f377cdca3f48 Mon Sep 17 00:00:00 2001 From: Ivo Kubjas Date: Wed, 16 Oct 2024 11:34:19 +0200 Subject: [PATCH 07/12] fix: add exclusive constraint for Miller loop and Final exp masks (#174) * feat: add IsActive to Unaligned pairing data submodule * feat: only unaligned g2 data or pairing data active at a time * chore: use common constraint for pairwise exclusive columns * fix: exclusive Miller loop and final exp masks * fix: remove double constraints * test: unaligned pairing data IsActive unit test * chore: use common cs for accumulator masks * chore: remove duplicate constraint * chore: use unaligned pairing data IsActive * fix: add constraints when zero-ness cannot be deduced from projection or other constraints --- prover/zkevm/prover/ecpair/ecpair.go | 6 + .../zkevm/prover/ecpair/ecpair_assignment.go | 3 + .../zkevm/prover/ecpair/ecpair_constraints.go | 92 ++-- prover/zkevm/prover/ecpair/ecpair_test.go | 1 + .../testdata/ecpair_double_pair_module.csv | 258 ++++----- .../ecpair_failing_double_pair_module.csv | 258 ++++----- .../testdata/ecpair_triple_pair_module.csv | 514 +++++++++--------- .../testdata/ecpair_two_pairings_module.csv | 514 +++++++++--------- 8 files changed, 830 insertions(+), 816 deletions(-) diff --git a/prover/zkevm/prover/ecpair/ecpair.go b/prover/zkevm/prover/ecpair/ecpair.go index 5f9b2043b..ab2fdcb20 100644 --- a/prover/zkevm/prover/ecpair/ecpair.go +++ b/prover/zkevm/prover/ecpair/ecpair.go @@ -111,6 +111,10 @@ func newECPair(comp *wizard.CompiledIOP, limits *Limits, ecSource *ECPairSource) res.csLastPairToFinalExp(comp) res.csIndexConsistency(comp) res.csAccumulatorMask(comp) + // only Unaligned Pairing data or G2 membership data is active at a time + res.csExclusiveUnalignedDatas(comp) + // only to Miller loop or to FinalExp + res.csExclusivePairingCircuitMasks(comp) return res } @@ -221,6 +225,7 @@ func newUnalignedG2MembershipData(comp *wizard.CompiledIOP, limits *Limits) *Una // // Use [newUnalignedPairingData] to create a new instance of UnalignedPairingData. type UnalignedPairingData struct { + IsActive ifaces.Column IsPulling ifaces.Column IsComputed ifaces.Column IsAccumulatorInit ifaces.Column @@ -246,6 +251,7 @@ func newUnalignedPairingData(comp *wizard.CompiledIOP, limits *Limits) *Unaligne createCol := createColFn(comp, namePairingData, size) return &UnalignedPairingData{ + IsActive: createCol("IS_ACTIVE"), IsPulling: createCol("IS_PULLING"), IsComputed: createCol("IS_COMPUTED"), Limb: createCol("LIMB"), diff --git a/prover/zkevm/prover/ecpair/ecpair_assignment.go b/prover/zkevm/prover/ecpair/ecpair_assignment.go index 55ffa0210..ba1e28b6a 100644 --- a/prover/zkevm/prover/ecpair/ecpair_assignment.go +++ b/prover/zkevm/prover/ecpair/ecpair_assignment.go @@ -72,6 +72,7 @@ func (ec *ECPair) assignPairingData(run *wizard.ProverRuntime) { ) var ( + dstIsActive = common.NewVectorBuilder(ec.UnalignedPairingData.IsActive) dstLimb = common.NewVectorBuilder(ec.UnalignedPairingData.Limb) dstToMillerLoop = common.NewVectorBuilder(ec.UnalignedPairingData.ToMillerLoopCircuitMask) dstToFinalExp = common.NewVectorBuilder(ec.UnalignedPairingData.ToFinalExpCircuitMask) @@ -130,6 +131,7 @@ func (ec *ECPair) assignPairingData(run *wizard.ProverRuntime) { } dstInstanceId.PushField(instanceId) dstIndex.PushInt(i) + dstIsActive.PushOne() } for i := 0; i < nbInputs-1; i++ { for j := 0; j < nbGtLimbs; j++ { @@ -221,6 +223,7 @@ func (ec *ECPair) assignPairingData(run *wizard.ProverRuntime) { } currPos += nbInputs*(nbG1Limbs+nbG2Limbs) + 2 } + dstIsActive.PadAndAssign(run, field.Zero()) dstLimb.PadAndAssign(run, field.Zero()) dstPairId.PadAndAssign(run, field.Zero()) dstTotalPairs.PadAndAssign(run, field.Zero()) diff --git a/prover/zkevm/prover/ecpair/ecpair_constraints.go b/prover/zkevm/prover/ecpair/ecpair_constraints.go index 979f51769..932cca482 100644 --- a/prover/zkevm/prover/ecpair/ecpair_constraints.go +++ b/prover/zkevm/prover/ecpair/ecpair_constraints.go @@ -18,42 +18,36 @@ func (ec *ECPair) csIsActiveActivation(comp *wizard.CompiledIOP) { } func (ec *ECPair) csBinaryConstraints(comp *wizard.CompiledIOP) { - common.MustBeBinary(comp, ec.UnalignedPairingData.IsPulling) - common.MustBeBinary(comp, ec.UnalignedPairingData.IsComputed) common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfInstance) - common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorInit) - common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorCurr) - common.MustBeBinary(comp, ec.UnalignedPairingData.IsAccumulatorPrev) - common.MustBeBinary(comp, ec.UnalignedPairingData.ToMillerLoopCircuitMask) - common.MustBeBinary(comp, ec.UnalignedPairingData.ToFinalExpCircuitMask) - common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsPulling) - common.MustBeBinary(comp, ec.UnalignedG2MembershipData.IsComputed) - common.MustBeBinary(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask) common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfPrevAccumulator) common.MustBeBinary(comp, ec.UnalignedPairingData.IsFirstLineOfCurrAccumulator) } func (ec *ECPair) csFlagConsistency(comp *wizard.CompiledIOP) { // flag consistency. That the assigned data is pulled from input or computed. - comp.InsertGlobal( - roundNr, - ifaces.QueryIDf("%v_FLAG_CONSISTENCY", nameECPair), - sym.Sub(ec.IsActive, - ec.UnalignedPairingData.IsPulling, - ec.UnalignedPairingData.IsComputed, - ec.UnalignedG2MembershipData.IsPulling, - ec.UnalignedG2MembershipData.IsComputed), - ) + common.MustBeMutuallyExclusiveBinaryFlags(comp, ec.UnalignedPairingData.IsActive, []ifaces.Column{ + ec.UnalignedPairingData.IsPulling, + ec.UnalignedPairingData.IsComputed, + }) + common.MustBeMutuallyExclusiveBinaryFlags(comp, ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask, []ifaces.Column{ + ec.UnalignedG2MembershipData.IsPulling, + ec.UnalignedG2MembershipData.IsComputed, + }) } func (ec *ECPair) csOffWhenInactive(comp *wizard.CompiledIOP) { // nothing is set when inactive common.MustZeroWhenInactive(comp, ec.IsActive, + ec.UnalignedPairingData.InstanceID, + ec.UnalignedPairingData.PairID, + ec.UnalignedPairingData.TotalPairs, ec.UnalignedPairingData.Limb, - ec.UnalignedPairingData.ToMillerLoopCircuitMask, - ec.UnalignedPairingData.ToFinalExpCircuitMask, + ec.UnalignedPairingData.Index, + ec.UnalignedPairingData.IsFirstLineOfInstance, + ec.UnalignedPairingData.IsFirstLineOfPrevAccumulator, + ec.UnalignedPairingData.IsFirstLineOfCurrAccumulator, ec.UnalignedG2MembershipData.Limb, - ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask, + ec.UnalignedG2MembershipData.SuccessBit, ) } @@ -94,7 +88,7 @@ func (ec *ECPair) csConstantWhenIsComputing(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_COUNTERS_CONSISTENCY", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsComputed, sym.Sub(1, ec.UnalignedPairingData.IsFirstLineOfInstance), sym.Sub(ec.UnalignedPairingData.PairID, column.Shift(ec.UnalignedPairingData.PairID, -1)), @@ -122,8 +116,8 @@ func (ec *ECPair) csInstanceIDChangeWhenNewInstance(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_INSTANCE_ID_CHANGE", nameECPair), sym.Mul( - column.Shift(verifiercol.NewConstantCol(field.One(), ec.IsActive.Size()), -1), // this "useless" line helps cancelling the constraint on the first row - ec.IsActive, + column.Shift(verifiercol.NewConstantCol(field.One(), ec.UnalignedPairingData.IsActive.Size()), -1), // this "useless" line helps cancelling the constraint on the first row + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfInstance, ec.UnalignedPairingData.InstanceID, prevEqualCurrID, @@ -148,7 +142,7 @@ func (ec *ECPair) csAccumulatorInit(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_ACCUMULATOR_INIT", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfInstance, accLimbSum, ), @@ -173,7 +167,7 @@ func (ec *ECPair) csLastPairToFinalExp(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_LAST_PAIR_TO_FINAL_EXP", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, sym.Sub(ec.UnalignedPairingData.PairID, ec.UnalignedPairingData.TotalPairs), ec.UnalignedPairingData.PairID, ec.UnalignedPairingData.ToFinalExpCircuitMask, @@ -187,7 +181,7 @@ func (ec *ECPair) csIndexConsistency(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_INDEX_START", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfInstance, ec.UnalignedPairingData.Index, ), @@ -196,7 +190,7 @@ func (ec *ECPair) csIndexConsistency(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_INDEX_INCREMENT", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, sym.Sub(1, ec.UnalignedG2MembershipData.IsPulling, ec.UnalignedG2MembershipData.IsComputed), // we dont use index in the G2 membership check sym.Sub(1, ec.UnalignedPairingData.IsFirstLineOfInstance), sym.Sub(ec.UnalignedPairingData.Index, column.Shift(ec.UnalignedPairingData.Index, -1), 1), @@ -206,23 +200,18 @@ func (ec *ECPair) csIndexConsistency(comp *wizard.CompiledIOP) { func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { // accumulator sum is IS_COMPUTED - comp.InsertGlobal( - roundNr, - ifaces.QueryIDf("%v_ACCUMULATOR_MASK", nameECPair), - sym.Sub( - ec.UnalignedPairingData.IsComputed, - ec.UnalignedPairingData.IsAccumulatorCurr, - ec.UnalignedPairingData.IsAccumulatorPrev, - ec.UnalignedPairingData.IsAccumulatorInit, - ), - ) + common.MustBeMutuallyExclusiveBinaryFlags(comp, ec.UnalignedPairingData.IsComputed, []ifaces.Column{ + ec.UnalignedPairingData.IsAccumulatorCurr, + ec.UnalignedPairingData.IsAccumulatorPrev, + ec.UnalignedPairingData.IsAccumulatorInit, + }) // first prev accumulator is 1 when pairID*60 == index comp.InsertGlobal( roundNr, ifaces.QueryIDf("%v_FIRST_ACC_PREV", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfPrevAccumulator, sym.Sub( sym.Mul(nbG1Limbs+nbG2Limbs+2*nbGtLimbs, sym.Sub(ec.UnalignedPairingData.PairID, 1)), @@ -236,7 +225,7 @@ func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_FIRST_ACC_CURR", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfCurrAccumulator, sym.Sub( sym.Mul(nbG1Limbs+nbG2Limbs+2*nbGtLimbs, ec.UnalignedPairingData.PairID), @@ -258,7 +247,7 @@ func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_INIT_ACC_MASK", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfInstance, sym.Sub(nbGtLimbs, sumMask(ec.UnalignedPairingData.IsAccumulatorInit)), ), @@ -269,7 +258,7 @@ func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_CURR_ACC_MASK", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfCurrAccumulator, sym.Sub(nbGtLimbs, sumMask(ec.UnalignedPairingData.IsAccumulatorCurr)), ), @@ -280,9 +269,24 @@ func (ec *ECPair) csAccumulatorMask(comp *wizard.CompiledIOP) { roundNr, ifaces.QueryIDf("%v_PREV_ACC_MASK", nameECPair), sym.Mul( - ec.IsActive, + ec.UnalignedPairingData.IsActive, ec.UnalignedPairingData.IsFirstLineOfPrevAccumulator, sym.Sub(nbGtLimbs, sumMask(ec.UnalignedPairingData.IsAccumulatorPrev)), ), ) } + +func (ec *ECPair) csExclusiveUnalignedDatas(comp *wizard.CompiledIOP) { + common.MustBeMutuallyExclusiveBinaryFlags(comp, ec.IsActive, []ifaces.Column{ + ec.UnalignedG2MembershipData.ToG2MembershipCircuitMask, + ec.UnalignedPairingData.IsActive, + }) +} + +func (ec *ECPair) csExclusivePairingCircuitMasks(comp *wizard.CompiledIOP) { + // the pairing circuit masks are mutually exclusive + common.MustBeMutuallyExclusiveBinaryFlags(comp, ec.UnalignedPairingData.IsActive, []ifaces.Column{ + ec.UnalignedPairingData.ToMillerLoopCircuitMask, + ec.UnalignedPairingData.ToFinalExpCircuitMask, + }) +} diff --git a/prover/zkevm/prover/ecpair/ecpair_test.go b/prover/zkevm/prover/ecpair/ecpair_test.go index 34a69d57e..50fa06f29 100644 --- a/prover/zkevm/prover/ecpair/ecpair_test.go +++ b/prover/zkevm/prover/ecpair/ecpair_test.go @@ -136,6 +136,7 @@ func testModule(t *testing.T, tc pairingDataTestCase, withPairingCircuit, withG2 if checkPairingModule { modCt.CheckAssignment(run, "ECPAIR_IS_ACTIVE", + "ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACTIVE", "ECPAIR_UNALIGNED_PAIRING_DATA_INDEX", "ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID", "ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID", diff --git a/prover/zkevm/prover/ecpair/testdata/ecpair_double_pair_module.csv b/prover/zkevm/prover/ecpair/testdata/ecpair_double_pair_module.csv index ccbcdcd43..bcef32bda 100644 --- a/prover/zkevm/prover/ecpair/testdata/ecpair_double_pair_module.csv +++ b/prover/zkevm/prover/ecpair/testdata/ecpair_double_pair_module.csv @@ -1,129 +1,129 @@ -ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT -0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 -0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13364879816394e38a2d72bde23bda93,0x1,0x0 -0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xcd39885c6bfdedbc45e6bafcfc8fa685,0x1,0x0 -0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xe0e4c9d03746d287b341d52461946a1,0x1,0x0 -0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xc865002c35ba9bd6b789fc26a526d121,0x1,0x0 -0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 -0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 -0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 -0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 -0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 -0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 -0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 -0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 -0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x1,0x0 -0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4c95627608bdbb0235762c7048400f93,0x1,0x0 -0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x1,0x0 -0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x1,0x0 -0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x1,0x0 -0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x1,0x0 -0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b45ce688738a571621b63dba9880856,0x1,0x0 -0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x1,0x0 -0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x653b8af047158278411df902874a82a,0x1,0x0 -0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x1,0x0 -0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1373a842ceca78f2ae076804f168559c,0x1,0x0 -0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x1,0x0 -0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x1,0x0 -0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f12833bfd8a1711d7947461776699df,0x1,0x0 -0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x1,0x0 -0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x1,0x0 -0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x1,0x0 -0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x1,0x0 -0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x22af99c52785193aa8920826c0d96380,0x1,0x0 -0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x1,0x0 -0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x1,0x0 -0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x217f227c48e2682613693d3afb8231e,0x1,0x0 -0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5641ef4d251e87484afef7cae876258,0x1,0x0 -0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x1,0x0 -0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x0,0x1 -0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4c95627608bdbb0235762c7048400f93,0x0,0x1 -0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x0,0x1 -0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x0,0x1 -0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x0,0x1 -0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x0,0x1 -0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b45ce688738a571621b63dba9880856,0x0,0x1 -0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x0,0x1 -0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x653b8af047158278411df902874a82a,0x0,0x1 -0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x0,0x1 -0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1373a842ceca78f2ae076804f168559c,0x0,0x1 -0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x0,0x1 -0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x0,0x1 -0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f12833bfd8a1711d7947461776699df,0x0,0x1 -0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x0,0x1 -0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x0,0x1 -0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x0,0x1 -0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x0,0x1 -0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x22af99c52785193aa8920826c0d96380,0x0,0x1 -0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x0,0x1 -0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x0,0x1 -0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x217f227c48e2682613693d3afb8231e,0x0,0x1 -0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5641ef4d251e87484afef7cae876258,0x0,0x1 -0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x0,0x1 -0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xb9624a62e115247146d4643e8d4daf0,0x0,0x1 -0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 -0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 -0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 -0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2977858b214a3cb43fa4024976dd1675,0x0,0x1 -0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9b1bf5367e6318da3545e697b9931671,0x0,0x1 -0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x06fcfd4b9ca03fb145ff273e480efda3,0x0,0x1 -0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc8a7aef64882efcbd8920b4458e1ef3d,0x0,0x1 -0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x281508326108309778f9cdf9c39a4c4d,0x0,0x1 -0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc90a405c0cfbfd5d20fec4e47acce66f,0x0,0x1 -0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10d24b6f0b87c1e3f78b80b967bac765,0x0,0x1 -0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x763f38c53a4377e9a97e2761758a92f1,0x0,0x1 -0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 -0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT +0x1,0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 +0x1,0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13364879816394e38a2d72bde23bda93,0x1,0x0 +0x1,0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xcd39885c6bfdedbc45e6bafcfc8fa685,0x1,0x0 +0x1,0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xe0e4c9d03746d287b341d52461946a1,0x1,0x0 +0x1,0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xc865002c35ba9bd6b789fc26a526d121,0x1,0x0 +0x1,0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 +0x1,0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 +0x1,0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 +0x1,0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 +0x1,0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 +0x1,0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 +0x1,0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 +0x1,0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 +0x1,0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x1,0x0 +0x1,0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4c95627608bdbb0235762c7048400f93,0x1,0x0 +0x1,0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x1,0x0 +0x1,0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x1,0x0 +0x1,0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x1,0x0 +0x1,0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x1,0x0 +0x1,0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b45ce688738a571621b63dba9880856,0x1,0x0 +0x1,0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x1,0x0 +0x1,0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x653b8af047158278411df902874a82a,0x1,0x0 +0x1,0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x1,0x0 +0x1,0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1373a842ceca78f2ae076804f168559c,0x1,0x0 +0x1,0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x1,0x0 +0x1,0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x1,0x0 +0x1,0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f12833bfd8a1711d7947461776699df,0x1,0x0 +0x1,0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x1,0x0 +0x1,0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x1,0x0 +0x1,0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x1,0x0 +0x1,0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x1,0x0 +0x1,0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x22af99c52785193aa8920826c0d96380,0x1,0x0 +0x1,0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x1,0x0 +0x1,0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x1,0x0 +0x1,0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x217f227c48e2682613693d3afb8231e,0x1,0x0 +0x1,0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5641ef4d251e87484afef7cae876258,0x1,0x0 +0x1,0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x1,0x0 +0x1,0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x0,0x1 +0x1,0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4c95627608bdbb0235762c7048400f93,0x0,0x1 +0x1,0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x0,0x1 +0x1,0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x0,0x1 +0x1,0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x0,0x1 +0x1,0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x0,0x1 +0x1,0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b45ce688738a571621b63dba9880856,0x0,0x1 +0x1,0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x0,0x1 +0x1,0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x653b8af047158278411df902874a82a,0x0,0x1 +0x1,0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x0,0x1 +0x1,0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1373a842ceca78f2ae076804f168559c,0x0,0x1 +0x1,0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x0,0x1 +0x1,0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x0,0x1 +0x1,0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f12833bfd8a1711d7947461776699df,0x0,0x1 +0x1,0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x0,0x1 +0x1,0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x0,0x1 +0x1,0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x0,0x1 +0x1,0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x0,0x1 +0x1,0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x22af99c52785193aa8920826c0d96380,0x0,0x1 +0x1,0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x0,0x1 +0x1,0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x0,0x1 +0x1,0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x217f227c48e2682613693d3afb8231e,0x0,0x1 +0x1,0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5641ef4d251e87484afef7cae876258,0x0,0x1 +0x1,0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x0,0x1 +0x1,0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xb9624a62e115247146d4643e8d4daf0,0x0,0x1 +0x1,0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 +0x1,0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 +0x1,0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 +0x1,0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2977858b214a3cb43fa4024976dd1675,0x0,0x1 +0x1,0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9b1bf5367e6318da3545e697b9931671,0x0,0x1 +0x1,0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x06fcfd4b9ca03fb145ff273e480efda3,0x0,0x1 +0x1,0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc8a7aef64882efcbd8920b4458e1ef3d,0x0,0x1 +0x1,0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x281508326108309778f9cdf9c39a4c4d,0x0,0x1 +0x1,0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc90a405c0cfbfd5d20fec4e47acce66f,0x0,0x1 +0x1,0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10d24b6f0b87c1e3f78b80b967bac765,0x0,0x1 +0x1,0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x763f38c53a4377e9a97e2761758a92f1,0x0,0x1 +0x1,0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 +0x1,0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 diff --git a/prover/zkevm/prover/ecpair/testdata/ecpair_failing_double_pair_module.csv b/prover/zkevm/prover/ecpair/testdata/ecpair_failing_double_pair_module.csv index 3bd58f543..0d7099470 100644 --- a/prover/zkevm/prover/ecpair/testdata/ecpair_failing_double_pair_module.csv +++ b/prover/zkevm/prover/ecpair/testdata/ecpair_failing_double_pair_module.csv @@ -1,129 +1,129 @@ -ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT -0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 -0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x219db76fd15c77e92376ec7ccdf3795a,0x1,0x0 -0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x96b20b521116027d63df9d7a4d76bcef,0x1,0x0 -0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0692f74fd48f12f945546eb1daaa688b,0x1,0x0 -0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xe31ef7b9f6338c8c452d69a386f0a098,0x1,0x0 -0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f679eca6f21e702c5613627661a31b7,0x1,0x0 -0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa5b99a766175a8ceebadf12135d8c0a0,0x1,0x0 -0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0a23a4431ea9ca09eb5787a8a0a7bb52,0x1,0x0 -0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x30a7cf5dc4fbf71edbda6ae0faca4000,0x1,0x0 -0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0715261e3e5eb7991d5dbe83f4cd963c,0x1,0x0 -0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xd8eb1975c583801573dc432c2c677165,0x1,0x0 -0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x142ed84e025468f2aa7a6fe50839c23a,0x1,0x0 -0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa3e99559088d53289092e02ffd59e84d,0x1,0x0 -0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x2519fb9fc917e5401ef8ae1dc4e0fcf6,0x1,0x0 -0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe73ec610c73dedfaecdc78b4cfed5fae,0x1,0x0 -0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x532dd87a224b3c74c0972336084d8cf,0x1,0x0 -0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd63ea1761e1b3eb06330f9a70a334bb3,0x1,0x0 -0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1be66119d8e9cb15799f97c5765a4f8f,0x1,0x0 -0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x7945a28f14dda8ff8d91e8e7472250dc,0x1,0x0 -0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1445016cdd9b1f1521bc8554163ed0d8,0x1,0x0 -0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1d69bb89e43261ea0cd55460902d1502,0x1,0x0 -0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x27c2852669c9bb985bb057af1b521490,0x1,0x0 -0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9e44217a7c12ccc32c1a38dfddb3e4f9,0x1,0x0 -0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x213cd09f21a19a3ba7bf07cfb2af15db,0x1,0x0 -0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x484f312ecb72e9937bb9d118dc40bb98,0x1,0x0 -0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x278d3989a6a313a5ae46832637fb035d,0x1,0x0 -0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x27160f6e52a0177a893c3b8cfc3a16dd,0x1,0x0 -0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xf2867d79c66c1b03b24b76190f1cddb,0x1,0x0 -0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x507f66b1e126b7d5f6b8fb575b98f4e3,0x1,0x0 -0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x190f41a349878e7007fa72a919920ebe,0x1,0x0 -0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4afaca4694c9b0a0848e46598d1f80fd,0x1,0x0 -0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x274ebf234ca143dd8a07c1ffff2ed891,0x1,0x0 -0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xb7638a696e66fe108cb6a122e36c2c9d,0x1,0x0 -0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x26f9711c5e431d68483d1c20ad498818,0x1,0x0 -0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f3ae73e50cb72160c69a85e3b6cf774,0x1,0x0 -0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x967d0cd5a60dd7aedeb12ef807e2ce8,0x1,0x0 -0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x43aad3aff198259e8706389ab5add7c1,0x1,0x0 -0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2519fb9fc917e5401ef8ae1dc4e0fcf6,0x0,0x1 -0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe73ec610c73dedfaecdc78b4cfed5fae,0x0,0x1 -0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x532dd87a224b3c74c0972336084d8cf,0x0,0x1 -0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd63ea1761e1b3eb06330f9a70a334bb3,0x0,0x1 -0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1be66119d8e9cb15799f97c5765a4f8f,0x0,0x1 -0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x7945a28f14dda8ff8d91e8e7472250dc,0x0,0x1 -0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1445016cdd9b1f1521bc8554163ed0d8,0x0,0x1 -0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d69bb89e43261ea0cd55460902d1502,0x0,0x1 -0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x27c2852669c9bb985bb057af1b521490,0x0,0x1 -0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9e44217a7c12ccc32c1a38dfddb3e4f9,0x0,0x1 -0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x213cd09f21a19a3ba7bf07cfb2af15db,0x0,0x1 -0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x484f312ecb72e9937bb9d118dc40bb98,0x0,0x1 -0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x278d3989a6a313a5ae46832637fb035d,0x0,0x1 -0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x27160f6e52a0177a893c3b8cfc3a16dd,0x0,0x1 -0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xf2867d79c66c1b03b24b76190f1cddb,0x0,0x1 -0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x507f66b1e126b7d5f6b8fb575b98f4e3,0x0,0x1 -0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x190f41a349878e7007fa72a919920ebe,0x0,0x1 -0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4afaca4694c9b0a0848e46598d1f80fd,0x0,0x1 -0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x274ebf234ca143dd8a07c1ffff2ed891,0x0,0x1 -0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xb7638a696e66fe108cb6a122e36c2c9d,0x0,0x1 -0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x26f9711c5e431d68483d1c20ad498818,0x0,0x1 -0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f3ae73e50cb72160c69a85e3b6cf774,0x0,0x1 -0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x967d0cd5a60dd7aedeb12ef807e2ce8,0x0,0x1 -0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x43aad3aff198259e8706389ab5add7c1,0x0,0x1 -0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1ae800da67a6c22f94d05578d1361f25,0x0,0x1 -0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x422a9f478669101d5b117f57fcb741e1,0x0,0x1 -0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x15ded9e40e5489c82b473115f1d4b409,0x0,0x1 -0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9e93aa996ad2346e8b46a2aa0db7832c,0x0,0x1 -0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2e1b4d36165dbb3f03664c4e77181c95,0x0,0x1 -0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x285a1f1bb08fac1599d9c06095085cf0,0x0,0x1 -0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x286dcf3fe302f14b9df2d19119a97c81,0x0,0x1 -0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x70a68443dafe5001dcc450abf66cb1b9,0x0,0x1 -0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x23e5cf5e441d3d12e4b63d4d16eea2dd,0x0,0x1 -0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xdc6005a79a59c812fbd4050870691a91,0x0,0x1 -0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x11cfc60ff4ceb85b8af413347b760f13,0x0,0x1 -0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x4325aead086b2761e0a16039ab1f12aa,0x0,0x1 -0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 -0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT +0x1,0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 +0x1,0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x219db76fd15c77e92376ec7ccdf3795a,0x1,0x0 +0x1,0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x96b20b521116027d63df9d7a4d76bcef,0x1,0x0 +0x1,0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0692f74fd48f12f945546eb1daaa688b,0x1,0x0 +0x1,0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xe31ef7b9f6338c8c452d69a386f0a098,0x1,0x0 +0x1,0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f679eca6f21e702c5613627661a31b7,0x1,0x0 +0x1,0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa5b99a766175a8ceebadf12135d8c0a0,0x1,0x0 +0x1,0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0a23a4431ea9ca09eb5787a8a0a7bb52,0x1,0x0 +0x1,0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x30a7cf5dc4fbf71edbda6ae0faca4000,0x1,0x0 +0x1,0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0715261e3e5eb7991d5dbe83f4cd963c,0x1,0x0 +0x1,0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xd8eb1975c583801573dc432c2c677165,0x1,0x0 +0x1,0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x142ed84e025468f2aa7a6fe50839c23a,0x1,0x0 +0x1,0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa3e99559088d53289092e02ffd59e84d,0x1,0x0 +0x1,0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x2519fb9fc917e5401ef8ae1dc4e0fcf6,0x1,0x0 +0x1,0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe73ec610c73dedfaecdc78b4cfed5fae,0x1,0x0 +0x1,0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x532dd87a224b3c74c0972336084d8cf,0x1,0x0 +0x1,0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd63ea1761e1b3eb06330f9a70a334bb3,0x1,0x0 +0x1,0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1be66119d8e9cb15799f97c5765a4f8f,0x1,0x0 +0x1,0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x7945a28f14dda8ff8d91e8e7472250dc,0x1,0x0 +0x1,0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1445016cdd9b1f1521bc8554163ed0d8,0x1,0x0 +0x1,0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1d69bb89e43261ea0cd55460902d1502,0x1,0x0 +0x1,0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x27c2852669c9bb985bb057af1b521490,0x1,0x0 +0x1,0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9e44217a7c12ccc32c1a38dfddb3e4f9,0x1,0x0 +0x1,0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x213cd09f21a19a3ba7bf07cfb2af15db,0x1,0x0 +0x1,0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x484f312ecb72e9937bb9d118dc40bb98,0x1,0x0 +0x1,0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x278d3989a6a313a5ae46832637fb035d,0x1,0x0 +0x1,0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x27160f6e52a0177a893c3b8cfc3a16dd,0x1,0x0 +0x1,0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xf2867d79c66c1b03b24b76190f1cddb,0x1,0x0 +0x1,0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x507f66b1e126b7d5f6b8fb575b98f4e3,0x1,0x0 +0x1,0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x190f41a349878e7007fa72a919920ebe,0x1,0x0 +0x1,0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4afaca4694c9b0a0848e46598d1f80fd,0x1,0x0 +0x1,0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x274ebf234ca143dd8a07c1ffff2ed891,0x1,0x0 +0x1,0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xb7638a696e66fe108cb6a122e36c2c9d,0x1,0x0 +0x1,0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x26f9711c5e431d68483d1c20ad498818,0x1,0x0 +0x1,0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f3ae73e50cb72160c69a85e3b6cf774,0x1,0x0 +0x1,0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x967d0cd5a60dd7aedeb12ef807e2ce8,0x1,0x0 +0x1,0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x43aad3aff198259e8706389ab5add7c1,0x1,0x0 +0x1,0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2519fb9fc917e5401ef8ae1dc4e0fcf6,0x0,0x1 +0x1,0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe73ec610c73dedfaecdc78b4cfed5fae,0x0,0x1 +0x1,0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x532dd87a224b3c74c0972336084d8cf,0x0,0x1 +0x1,0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd63ea1761e1b3eb06330f9a70a334bb3,0x0,0x1 +0x1,0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1be66119d8e9cb15799f97c5765a4f8f,0x0,0x1 +0x1,0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x7945a28f14dda8ff8d91e8e7472250dc,0x0,0x1 +0x1,0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1445016cdd9b1f1521bc8554163ed0d8,0x0,0x1 +0x1,0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d69bb89e43261ea0cd55460902d1502,0x0,0x1 +0x1,0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x27c2852669c9bb985bb057af1b521490,0x0,0x1 +0x1,0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9e44217a7c12ccc32c1a38dfddb3e4f9,0x0,0x1 +0x1,0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x213cd09f21a19a3ba7bf07cfb2af15db,0x0,0x1 +0x1,0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x484f312ecb72e9937bb9d118dc40bb98,0x0,0x1 +0x1,0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x278d3989a6a313a5ae46832637fb035d,0x0,0x1 +0x1,0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x27160f6e52a0177a893c3b8cfc3a16dd,0x0,0x1 +0x1,0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xf2867d79c66c1b03b24b76190f1cddb,0x0,0x1 +0x1,0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x507f66b1e126b7d5f6b8fb575b98f4e3,0x0,0x1 +0x1,0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x190f41a349878e7007fa72a919920ebe,0x0,0x1 +0x1,0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4afaca4694c9b0a0848e46598d1f80fd,0x0,0x1 +0x1,0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x274ebf234ca143dd8a07c1ffff2ed891,0x0,0x1 +0x1,0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xb7638a696e66fe108cb6a122e36c2c9d,0x0,0x1 +0x1,0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x26f9711c5e431d68483d1c20ad498818,0x0,0x1 +0x1,0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f3ae73e50cb72160c69a85e3b6cf774,0x0,0x1 +0x1,0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x967d0cd5a60dd7aedeb12ef807e2ce8,0x0,0x1 +0x1,0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x43aad3aff198259e8706389ab5add7c1,0x0,0x1 +0x1,0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1ae800da67a6c22f94d05578d1361f25,0x0,0x1 +0x1,0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x422a9f478669101d5b117f57fcb741e1,0x0,0x1 +0x1,0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x15ded9e40e5489c82b473115f1d4b409,0x0,0x1 +0x1,0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9e93aa996ad2346e8b46a2aa0db7832c,0x0,0x1 +0x1,0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2e1b4d36165dbb3f03664c4e77181c95,0x0,0x1 +0x1,0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x285a1f1bb08fac1599d9c06095085cf0,0x0,0x1 +0x1,0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x286dcf3fe302f14b9df2d19119a97c81,0x0,0x1 +0x1,0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x70a68443dafe5001dcc450abf66cb1b9,0x0,0x1 +0x1,0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x23e5cf5e441d3d12e4b63d4d16eea2dd,0x0,0x1 +0x1,0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xdc6005a79a59c812fbd4050870691a91,0x0,0x1 +0x1,0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x11cfc60ff4ceb85b8af413347b760f13,0x0,0x1 +0x1,0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x4325aead086b2761e0a16039ab1f12aa,0x0,0x1 +0x1,0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 +0x1,0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 diff --git a/prover/zkevm/prover/ecpair/testdata/ecpair_triple_pair_module.csv b/prover/zkevm/prover/ecpair/testdata/ecpair_triple_pair_module.csv index ddf137454..1ef3848fe 100644 --- a/prover/zkevm/prover/ecpair/testdata/ecpair_triple_pair_module.csv +++ b/prover/zkevm/prover/ecpair/testdata/ecpair_triple_pair_module.csv @@ -1,257 +1,257 @@ -ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT -0x1,0x0,0x0,0x1,0x3,0x1,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x1,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0 -0x1,0x2,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x3,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x4,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x5,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x6,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x7,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x8,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x9,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xa,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xb,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xc,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xd,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xe,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0xf,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x10,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x11,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x12,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x13,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x14,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x15,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x16,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x17,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 -0x1,0x18,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x100fb2006c3a4409ce06f6c2d535564c,0x1,0x0 -0x1,0x19,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x92e592aeb426d6c035bb8c0a50202e6d,0x1,0x0 -0x1,0x1a,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1275964141a90f3170592ade82174d09,0x1,0x0 -0x1,0x1b,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xde3cc7f5b79f260f51c143e3268ba06d,0x1,0x0 -0x1,0x1c,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2e607689d1161c5cb3d6ed870a5b6f47,0x1,0x0 -0x1,0x1d,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xb19627c2c51d3d2eb72f81c540ff9f9d,0x1,0x0 -0x1,0x1e,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x09d2b2eb399326d9cc552e9753afaeab,0x1,0x0 -0x1,0x1f,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xbb29985def8b5800f32145223ff61d48,0x1,0x0 -0x1,0x20,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x03a5907084b1f9ee93a1fa011b31b383,0x1,0x0 -0x1,0x21,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x60b7d50b789fbe32d3733176ffd9d46a,0x1,0x0 -0x1,0x22,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2e8b82b3506125e8b67bb867604a8892,0x1,0x0 -0x1,0x23,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x7b9695a8d131627503a0f63bfe5d0cca,0x1,0x0 -0x1,0x24,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x3b453509cb62c429d8a86ea1cf46897,0x1,0x0 -0x1,0x25,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xfc8f75a5184afbfee72be2a8ac39ab6,0x1,0x0 -0x1,0x26,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x258732ffd31c5ae816e163e3458108dd,0x1,0x0 -0x1,0x27,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x99caaa2e258abab37bb4b1e675e792b4,0x1,0x0 -0x1,0x28,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x8dc4617a012a931507f27b285f48a99,0x1,0x0 -0x1,0x29,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2c0cc58a0906a3a6ef6e5378a04addf2,0x1,0x0 -0x1,0x2a,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x185514250c1eaff2fdc813fd31c55772,0x1,0x0 -0x1,0x2b,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x81316979a26c9fdb191f6abac2a0bcf2,0x1,0x0 -0x1,0x2c,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x26a52e43327b03b40c3b36854698ed02,0x1,0x0 -0x1,0x2d,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x572116a2bc8995a07550a2c11b3f1bb3,0x1,0x0 -0x1,0x2e,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x22a813b81101fa27e07888a4c1ee151b,0x1,0x0 -0x1,0x2f,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xd5c7de0e174ce72545ed2796a057e0f5,0x1,0x0 -0x1,0x30,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1755fc232224e41b6b375a49c842eed,0x1,0x0 -0x1,0x31,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe4e0cf3cce99d1664c5e8489205e9461,0x1,0x0 -0x1,0x32,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2b80c453b72e713a9ee7304f7c598ebe,0x1,0x0 -0x1,0x33,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe28aeb3c386d4c2dfe575197636a578b,0x1,0x0 -0x1,0x34,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x225235e07cb0c897a4d26f2f76019f3,0x1,0x0 -0x1,0x35,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xec0c5349a3d4d57e9ab9e9b48f3ba9b3,0x1,0x0 -0x1,0x36,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2864b7882cf2e11ed3bffbff7cb788ca,0x1,0x0 -0x1,0x37,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x30f1e0743e45d9900320f9e6890f6817,0x1,0x0 -0x1,0x38,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x29293f07fccd8ac29bf0501e823696f,0x1,0x0 -0x1,0x39,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x71ba1b75f369441cf66cb0c6d8127ad0,0x1,0x0 -0x1,0x3a,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x15d7ace2db3651ba26cc0852ffa53be9,0x1,0x0 -0x1,0x3b,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x40a41876d29c7d3d9efea184a2f58712,0x1,0x0 -0x1,0x3c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x3b453509cb62c429d8a86ea1cf46897,0x1,0x0 -0x1,0x3d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xfc8f75a5184afbfee72be2a8ac39ab6,0x1,0x0 -0x1,0x3e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x258732ffd31c5ae816e163e3458108dd,0x1,0x0 -0x1,0x3f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x99caaa2e258abab37bb4b1e675e792b4,0x1,0x0 -0x1,0x40,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x8dc4617a012a931507f27b285f48a99,0x1,0x0 -0x1,0x41,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2c0cc58a0906a3a6ef6e5378a04addf2,0x1,0x0 -0x1,0x42,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x185514250c1eaff2fdc813fd31c55772,0x1,0x0 -0x1,0x43,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x81316979a26c9fdb191f6abac2a0bcf2,0x1,0x0 -0x1,0x44,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x26a52e43327b03b40c3b36854698ed02,0x1,0x0 -0x1,0x45,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x572116a2bc8995a07550a2c11b3f1bb3,0x1,0x0 -0x1,0x46,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x22a813b81101fa27e07888a4c1ee151b,0x1,0x0 -0x1,0x47,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xd5c7de0e174ce72545ed2796a057e0f5,0x1,0x0 -0x1,0x48,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1755fc232224e41b6b375a49c842eed,0x1,0x0 -0x1,0x49,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe4e0cf3cce99d1664c5e8489205e9461,0x1,0x0 -0x1,0x4a,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2b80c453b72e713a9ee7304f7c598ebe,0x1,0x0 -0x1,0x4b,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe28aeb3c386d4c2dfe575197636a578b,0x1,0x0 -0x1,0x4c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x225235e07cb0c897a4d26f2f76019f3,0x1,0x0 -0x1,0x4d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xec0c5349a3d4d57e9ab9e9b48f3ba9b3,0x1,0x0 -0x1,0x4e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2864b7882cf2e11ed3bffbff7cb788ca,0x1,0x0 -0x1,0x4f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x30f1e0743e45d9900320f9e6890f6817,0x1,0x0 -0x1,0x50,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x29293f07fccd8ac29bf0501e823696f,0x1,0x0 -0x1,0x51,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x71ba1b75f369441cf66cb0c6d8127ad0,0x1,0x0 -0x1,0x52,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x15d7ace2db3651ba26cc0852ffa53be9,0x1,0x0 -0x1,0x53,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x40a41876d29c7d3d9efea184a2f58712,0x1,0x0 -0x1,0x54,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1f5ca3dcd416ce988b93b505e473fbc8,0x1,0x0 -0x1,0x55,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xa510b9a25ba4af91a01cbf2d66496ba7,0x1,0x0 -0x1,0x56,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2ab07af451260653f5d92e48135636fe,0x1,0x0 -0x1,0x57,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x6e69bfad773e8c1806b4e4bb128048f9,0x1,0x0 -0x1,0x58,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1e311797d9d7b0c3b1658f72e16632e3,0x1,0x0 -0x1,0x59,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x927ad04f742ded7fe801e8df6e137325,0x1,0x0 -0x1,0x5a,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1d0510803ef7512c7915a6879d460c72,0x1,0x0 -0x1,0x5b,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x27480a98574d5d306828694e1640ec2b,0x1,0x0 -0x1,0x5c,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0bb8fd9936c7a8c8f4a3d9ce97735df5,0x1,0x0 -0x1,0x5d,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x41af0c73696dff5f92c6eb248f949a18,0x1,0x0 -0x1,0x5e,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x15f8308390c00f0a0e1ebcd08626f1ec,0x1,0x0 -0x1,0x5f,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x57a14cac88cd49f9d0e3caaa20ce36e9,0x1,0x0 -0x1,0x60,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x152e268cc785bd6c948a88b3091ef9a3,0x1,0x0 -0x1,0x61,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x708426323c268b89b2a5e02478ccdda6,0x1,0x0 -0x1,0x62,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2f6d0a4127a8a6f986490f9f8322397c,0x1,0x0 -0x1,0x63,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x82c9cdc9f0d6ec378eda15ec3dc78b6f,0x1,0x0 -0x1,0x64,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x21da9702fb1d05b6c0a1007d0b9c160e,0x1,0x0 -0x1,0x65,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x9d8d0a02fedddd4bce9598f5787c284,0x1,0x0 -0x1,0x66,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2b46be639fc122126b7e0efbc5398fe8,0x1,0x0 -0x1,0x67,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x67d9dd3ecc9160db686aaed5bbbd2cbc,0x1,0x0 -0x1,0x68,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x20d3e1ac646cf95fbf02ad4589eb173d,0x1,0x0 -0x1,0x69,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x8501b392226c7a7e7818b5781887ef0e,0x1,0x0 -0x1,0x6a,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xcb19e117479b79a6b64d592612adf5d,0x1,0x0 -0x1,0x6b,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xaacf84e0e323906338a778d53c6d57d2,0x1,0x0 -0x1,0x6c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1dd39eb06e7c88b5e3fea51f0bcefc0d,0x1,0x0 -0x1,0x6d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xb11c23cd9f2f7108861555162026536d,0x1,0x0 -0x1,0x6e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x290860069e0d24d4363147d4f3d6760a,0x1,0x0 -0x1,0x6f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x4fb8917396a450547f84fb7e70c9999f,0x1,0x0 -0x1,0x70,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2ca828fba83798a17db205631e9903d,0x1,0x0 -0x1,0x71,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe19924a9209f0fe7c06025b0851fbfe9,0x1,0x0 -0x1,0x72,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x6f263094fe06ea7acc71974bc64d7dd,0x1,0x0 -0x1,0x73,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf167b0ea71dc77d57f39fd46d42db5e4,0x1,0x0 -0x1,0x74,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x12809c90c9533ba0d7159a9631812b01,0x1,0x0 -0x1,0x75,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xef3180f718d6e3693eeaf24f05ff6804,0x1,0x0 -0x1,0x76,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1821399d4a5711ca9d4e6b605b0c6ff2,0x1,0x0 -0x1,0x77,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x89ca237ebf99d460e8d0a9301e74a664,0x1,0x0 -0x1,0x78,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x152e268cc785bd6c948a88b3091ef9a3,0x0,0x1 -0x1,0x79,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x708426323c268b89b2a5e02478ccdda6,0x0,0x1 -0x1,0x7a,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2f6d0a4127a8a6f986490f9f8322397c,0x0,0x1 -0x1,0x7b,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x82c9cdc9f0d6ec378eda15ec3dc78b6f,0x0,0x1 -0x1,0x7c,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x21da9702fb1d05b6c0a1007d0b9c160e,0x0,0x1 -0x1,0x7d,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x9d8d0a02fedddd4bce9598f5787c284,0x0,0x1 -0x1,0x7e,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2b46be639fc122126b7e0efbc5398fe8,0x0,0x1 -0x1,0x7f,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x67d9dd3ecc9160db686aaed5bbbd2cbc,0x0,0x1 -0x1,0x80,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x20d3e1ac646cf95fbf02ad4589eb173d,0x0,0x1 -0x1,0x81,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x8501b392226c7a7e7818b5781887ef0e,0x0,0x1 -0x1,0x82,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xcb19e117479b79a6b64d592612adf5d,0x0,0x1 -0x1,0x83,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xaacf84e0e323906338a778d53c6d57d2,0x0,0x1 -0x1,0x84,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1dd39eb06e7c88b5e3fea51f0bcefc0d,0x0,0x1 -0x1,0x85,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xb11c23cd9f2f7108861555162026536d,0x0,0x1 -0x1,0x86,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x290860069e0d24d4363147d4f3d6760a,0x0,0x1 -0x1,0x87,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x4fb8917396a450547f84fb7e70c9999f,0x0,0x1 -0x1,0x88,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2ca828fba83798a17db205631e9903d,0x0,0x1 -0x1,0x89,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe19924a9209f0fe7c06025b0851fbfe9,0x0,0x1 -0x1,0x8a,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x6f263094fe06ea7acc71974bc64d7dd,0x0,0x1 -0x1,0x8b,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xf167b0ea71dc77d57f39fd46d42db5e4,0x0,0x1 -0x1,0x8c,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x12809c90c9533ba0d7159a9631812b01,0x0,0x1 -0x1,0x8d,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xef3180f718d6e3693eeaf24f05ff6804,0x0,0x1 -0x1,0x8e,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1821399d4a5711ca9d4e6b605b0c6ff2,0x0,0x1 -0x1,0x8f,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x89ca237ebf99d460e8d0a9301e74a664,0x0,0x1 -0x1,0x90,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0c8671a7e8f372087c46b7b82c53c183,0x0,0x1 -0x1,0x91,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xd09453270e38045cb7372662d4716f8d,0x0,0x1 -0x1,0x92,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x20dd05e87836797d4507cc8917ed1079,0x0,0x1 -0x1,0x93,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xa10fe34dc7536969843e4cbe868a64ac,0x0,0x1 -0x1,0x94,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x24e48d89873ad5ebcf0f7022c01020b5,0x0,0x1 -0x1,0x95,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x10458a3dfc798231e6b5d5f17c8c9e1c,0x0,0x1 -0x1,0x96,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2f3ba4b3c58fd37398ceef826e29c853,0x0,0x1 -0x1,0x97,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x7048f7fec19180f89f4961bf0b00e9c1,0x0,0x1 -0x1,0x98,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2ed87dc23279bee95b8caada387b5f5e,0x0,0x1 -0x1,0x99,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x04fdd666fda2df2aac57457ecfb62014,0x0,0x1 -0x1,0x9a,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1b77c09a4389d4d50e5b78a8dca80583,0x0,0x1 -0x1,0x9b,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1056618bfe329ac4dcc8ee73ec818284,0x0,0x1 -0x1,0x9c,0x0,0x0,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1 -0x1,0x9d,0x0,0x0,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x1 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT +0x1,0x1,0x0,0x0,0x1,0x3,0x1,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x1,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0 +0x1,0x1,0x2,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x3,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x4,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x5,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x6,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x7,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x8,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x9,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xa,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xb,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xc,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xd,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xe,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0xf,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x10,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x11,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x12,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x13,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x14,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x15,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x16,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x17,0x0,0x1,0x3,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x0 +0x1,0x1,0x18,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x100fb2006c3a4409ce06f6c2d535564c,0x1,0x0 +0x1,0x1,0x19,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x92e592aeb426d6c035bb8c0a50202e6d,0x1,0x0 +0x1,0x1,0x1a,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1275964141a90f3170592ade82174d09,0x1,0x0 +0x1,0x1,0x1b,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xde3cc7f5b79f260f51c143e3268ba06d,0x1,0x0 +0x1,0x1,0x1c,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2e607689d1161c5cb3d6ed870a5b6f47,0x1,0x0 +0x1,0x1,0x1d,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xb19627c2c51d3d2eb72f81c540ff9f9d,0x1,0x0 +0x1,0x1,0x1e,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x09d2b2eb399326d9cc552e9753afaeab,0x1,0x0 +0x1,0x1,0x1f,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xbb29985def8b5800f32145223ff61d48,0x1,0x0 +0x1,0x1,0x20,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x03a5907084b1f9ee93a1fa011b31b383,0x1,0x0 +0x1,0x1,0x21,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x60b7d50b789fbe32d3733176ffd9d46a,0x1,0x0 +0x1,0x1,0x22,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2e8b82b3506125e8b67bb867604a8892,0x1,0x0 +0x1,0x1,0x23,0x0,0x1,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x7b9695a8d131627503a0f63bfe5d0cca,0x1,0x0 +0x1,0x1,0x24,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x3b453509cb62c429d8a86ea1cf46897,0x1,0x0 +0x1,0x1,0x25,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xfc8f75a5184afbfee72be2a8ac39ab6,0x1,0x0 +0x1,0x1,0x26,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x258732ffd31c5ae816e163e3458108dd,0x1,0x0 +0x1,0x1,0x27,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x99caaa2e258abab37bb4b1e675e792b4,0x1,0x0 +0x1,0x1,0x28,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x8dc4617a012a931507f27b285f48a99,0x1,0x0 +0x1,0x1,0x29,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2c0cc58a0906a3a6ef6e5378a04addf2,0x1,0x0 +0x1,0x1,0x2a,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x185514250c1eaff2fdc813fd31c55772,0x1,0x0 +0x1,0x1,0x2b,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x81316979a26c9fdb191f6abac2a0bcf2,0x1,0x0 +0x1,0x1,0x2c,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x26a52e43327b03b40c3b36854698ed02,0x1,0x0 +0x1,0x1,0x2d,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x572116a2bc8995a07550a2c11b3f1bb3,0x1,0x0 +0x1,0x1,0x2e,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x22a813b81101fa27e07888a4c1ee151b,0x1,0x0 +0x1,0x1,0x2f,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xd5c7de0e174ce72545ed2796a057e0f5,0x1,0x0 +0x1,0x1,0x30,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1755fc232224e41b6b375a49c842eed,0x1,0x0 +0x1,0x1,0x31,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe4e0cf3cce99d1664c5e8489205e9461,0x1,0x0 +0x1,0x1,0x32,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2b80c453b72e713a9ee7304f7c598ebe,0x1,0x0 +0x1,0x1,0x33,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe28aeb3c386d4c2dfe575197636a578b,0x1,0x0 +0x1,0x1,0x34,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x225235e07cb0c897a4d26f2f76019f3,0x1,0x0 +0x1,0x1,0x35,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xec0c5349a3d4d57e9ab9e9b48f3ba9b3,0x1,0x0 +0x1,0x1,0x36,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2864b7882cf2e11ed3bffbff7cb788ca,0x1,0x0 +0x1,0x1,0x37,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x30f1e0743e45d9900320f9e6890f6817,0x1,0x0 +0x1,0x1,0x38,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x29293f07fccd8ac29bf0501e823696f,0x1,0x0 +0x1,0x1,0x39,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x71ba1b75f369441cf66cb0c6d8127ad0,0x1,0x0 +0x1,0x1,0x3a,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x15d7ace2db3651ba26cc0852ffa53be9,0x1,0x0 +0x1,0x1,0x3b,0x0,0x1,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x40a41876d29c7d3d9efea184a2f58712,0x1,0x0 +0x1,0x1,0x3c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x3b453509cb62c429d8a86ea1cf46897,0x1,0x0 +0x1,0x1,0x3d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xfc8f75a5184afbfee72be2a8ac39ab6,0x1,0x0 +0x1,0x1,0x3e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x258732ffd31c5ae816e163e3458108dd,0x1,0x0 +0x1,0x1,0x3f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x99caaa2e258abab37bb4b1e675e792b4,0x1,0x0 +0x1,0x1,0x40,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x8dc4617a012a931507f27b285f48a99,0x1,0x0 +0x1,0x1,0x41,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2c0cc58a0906a3a6ef6e5378a04addf2,0x1,0x0 +0x1,0x1,0x42,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x185514250c1eaff2fdc813fd31c55772,0x1,0x0 +0x1,0x1,0x43,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x81316979a26c9fdb191f6abac2a0bcf2,0x1,0x0 +0x1,0x1,0x44,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x26a52e43327b03b40c3b36854698ed02,0x1,0x0 +0x1,0x1,0x45,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x572116a2bc8995a07550a2c11b3f1bb3,0x1,0x0 +0x1,0x1,0x46,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x22a813b81101fa27e07888a4c1ee151b,0x1,0x0 +0x1,0x1,0x47,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xd5c7de0e174ce72545ed2796a057e0f5,0x1,0x0 +0x1,0x1,0x48,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1755fc232224e41b6b375a49c842eed,0x1,0x0 +0x1,0x1,0x49,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe4e0cf3cce99d1664c5e8489205e9461,0x1,0x0 +0x1,0x1,0x4a,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2b80c453b72e713a9ee7304f7c598ebe,0x1,0x0 +0x1,0x1,0x4b,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe28aeb3c386d4c2dfe575197636a578b,0x1,0x0 +0x1,0x1,0x4c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x225235e07cb0c897a4d26f2f76019f3,0x1,0x0 +0x1,0x1,0x4d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xec0c5349a3d4d57e9ab9e9b48f3ba9b3,0x1,0x0 +0x1,0x1,0x4e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2864b7882cf2e11ed3bffbff7cb788ca,0x1,0x0 +0x1,0x1,0x4f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x30f1e0743e45d9900320f9e6890f6817,0x1,0x0 +0x1,0x1,0x50,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x29293f07fccd8ac29bf0501e823696f,0x1,0x0 +0x1,0x1,0x51,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x71ba1b75f369441cf66cb0c6d8127ad0,0x1,0x0 +0x1,0x1,0x52,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x15d7ace2db3651ba26cc0852ffa53be9,0x1,0x0 +0x1,0x1,0x53,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x40a41876d29c7d3d9efea184a2f58712,0x1,0x0 +0x1,0x1,0x54,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1f5ca3dcd416ce988b93b505e473fbc8,0x1,0x0 +0x1,0x1,0x55,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xa510b9a25ba4af91a01cbf2d66496ba7,0x1,0x0 +0x1,0x1,0x56,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2ab07af451260653f5d92e48135636fe,0x1,0x0 +0x1,0x1,0x57,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x6e69bfad773e8c1806b4e4bb128048f9,0x1,0x0 +0x1,0x1,0x58,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1e311797d9d7b0c3b1658f72e16632e3,0x1,0x0 +0x1,0x1,0x59,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x927ad04f742ded7fe801e8df6e137325,0x1,0x0 +0x1,0x1,0x5a,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1d0510803ef7512c7915a6879d460c72,0x1,0x0 +0x1,0x1,0x5b,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x27480a98574d5d306828694e1640ec2b,0x1,0x0 +0x1,0x1,0x5c,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0bb8fd9936c7a8c8f4a3d9ce97735df5,0x1,0x0 +0x1,0x1,0x5d,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x41af0c73696dff5f92c6eb248f949a18,0x1,0x0 +0x1,0x1,0x5e,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x15f8308390c00f0a0e1ebcd08626f1ec,0x1,0x0 +0x1,0x1,0x5f,0x0,0x2,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x57a14cac88cd49f9d0e3caaa20ce36e9,0x1,0x0 +0x1,0x1,0x60,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x152e268cc785bd6c948a88b3091ef9a3,0x1,0x0 +0x1,0x1,0x61,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x708426323c268b89b2a5e02478ccdda6,0x1,0x0 +0x1,0x1,0x62,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2f6d0a4127a8a6f986490f9f8322397c,0x1,0x0 +0x1,0x1,0x63,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x82c9cdc9f0d6ec378eda15ec3dc78b6f,0x1,0x0 +0x1,0x1,0x64,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x21da9702fb1d05b6c0a1007d0b9c160e,0x1,0x0 +0x1,0x1,0x65,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x9d8d0a02fedddd4bce9598f5787c284,0x1,0x0 +0x1,0x1,0x66,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2b46be639fc122126b7e0efbc5398fe8,0x1,0x0 +0x1,0x1,0x67,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x67d9dd3ecc9160db686aaed5bbbd2cbc,0x1,0x0 +0x1,0x1,0x68,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x20d3e1ac646cf95fbf02ad4589eb173d,0x1,0x0 +0x1,0x1,0x69,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x8501b392226c7a7e7818b5781887ef0e,0x1,0x0 +0x1,0x1,0x6a,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xcb19e117479b79a6b64d592612adf5d,0x1,0x0 +0x1,0x1,0x6b,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xaacf84e0e323906338a778d53c6d57d2,0x1,0x0 +0x1,0x1,0x6c,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1dd39eb06e7c88b5e3fea51f0bcefc0d,0x1,0x0 +0x1,0x1,0x6d,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xb11c23cd9f2f7108861555162026536d,0x1,0x0 +0x1,0x1,0x6e,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x290860069e0d24d4363147d4f3d6760a,0x1,0x0 +0x1,0x1,0x6f,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x4fb8917396a450547f84fb7e70c9999f,0x1,0x0 +0x1,0x1,0x70,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2ca828fba83798a17db205631e9903d,0x1,0x0 +0x1,0x1,0x71,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xe19924a9209f0fe7c06025b0851fbfe9,0x1,0x0 +0x1,0x1,0x72,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x6f263094fe06ea7acc71974bc64d7dd,0x1,0x0 +0x1,0x1,0x73,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf167b0ea71dc77d57f39fd46d42db5e4,0x1,0x0 +0x1,0x1,0x74,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x12809c90c9533ba0d7159a9631812b01,0x1,0x0 +0x1,0x1,0x75,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xef3180f718d6e3693eeaf24f05ff6804,0x1,0x0 +0x1,0x1,0x76,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1821399d4a5711ca9d4e6b605b0c6ff2,0x1,0x0 +0x1,0x1,0x77,0x0,0x2,0x3,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x89ca237ebf99d460e8d0a9301e74a664,0x1,0x0 +0x1,0x1,0x78,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x152e268cc785bd6c948a88b3091ef9a3,0x0,0x1 +0x1,0x1,0x79,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x708426323c268b89b2a5e02478ccdda6,0x0,0x1 +0x1,0x1,0x7a,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2f6d0a4127a8a6f986490f9f8322397c,0x0,0x1 +0x1,0x1,0x7b,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x82c9cdc9f0d6ec378eda15ec3dc78b6f,0x0,0x1 +0x1,0x1,0x7c,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x21da9702fb1d05b6c0a1007d0b9c160e,0x0,0x1 +0x1,0x1,0x7d,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x9d8d0a02fedddd4bce9598f5787c284,0x0,0x1 +0x1,0x1,0x7e,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2b46be639fc122126b7e0efbc5398fe8,0x0,0x1 +0x1,0x1,0x7f,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x67d9dd3ecc9160db686aaed5bbbd2cbc,0x0,0x1 +0x1,0x1,0x80,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x20d3e1ac646cf95fbf02ad4589eb173d,0x0,0x1 +0x1,0x1,0x81,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x8501b392226c7a7e7818b5781887ef0e,0x0,0x1 +0x1,0x1,0x82,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xcb19e117479b79a6b64d592612adf5d,0x0,0x1 +0x1,0x1,0x83,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xaacf84e0e323906338a778d53c6d57d2,0x0,0x1 +0x1,0x1,0x84,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1dd39eb06e7c88b5e3fea51f0bcefc0d,0x0,0x1 +0x1,0x1,0x85,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xb11c23cd9f2f7108861555162026536d,0x0,0x1 +0x1,0x1,0x86,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x290860069e0d24d4363147d4f3d6760a,0x0,0x1 +0x1,0x1,0x87,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x4fb8917396a450547f84fb7e70c9999f,0x0,0x1 +0x1,0x1,0x88,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2ca828fba83798a17db205631e9903d,0x0,0x1 +0x1,0x1,0x89,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xe19924a9209f0fe7c06025b0851fbfe9,0x0,0x1 +0x1,0x1,0x8a,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x6f263094fe06ea7acc71974bc64d7dd,0x0,0x1 +0x1,0x1,0x8b,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xf167b0ea71dc77d57f39fd46d42db5e4,0x0,0x1 +0x1,0x1,0x8c,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x12809c90c9533ba0d7159a9631812b01,0x0,0x1 +0x1,0x1,0x8d,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xef3180f718d6e3693eeaf24f05ff6804,0x0,0x1 +0x1,0x1,0x8e,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1821399d4a5711ca9d4e6b605b0c6ff2,0x0,0x1 +0x1,0x1,0x8f,0x0,0x3,0x3,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x89ca237ebf99d460e8d0a9301e74a664,0x0,0x1 +0x1,0x1,0x90,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0c8671a7e8f372087c46b7b82c53c183,0x0,0x1 +0x1,0x1,0x91,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xd09453270e38045cb7372662d4716f8d,0x0,0x1 +0x1,0x1,0x92,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x20dd05e87836797d4507cc8917ed1079,0x0,0x1 +0x1,0x1,0x93,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xa10fe34dc7536969843e4cbe868a64ac,0x0,0x1 +0x1,0x1,0x94,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x24e48d89873ad5ebcf0f7022c01020b5,0x0,0x1 +0x1,0x1,0x95,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x10458a3dfc798231e6b5d5f17c8c9e1c,0x0,0x1 +0x1,0x1,0x96,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2f3ba4b3c58fd37398ceef826e29c853,0x0,0x1 +0x1,0x1,0x97,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x7048f7fec19180f89f4961bf0b00e9c1,0x0,0x1 +0x1,0x1,0x98,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x2ed87dc23279bee95b8caada387b5f5e,0x0,0x1 +0x1,0x1,0x99,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x04fdd666fda2df2aac57457ecfb62014,0x0,0x1 +0x1,0x1,0x9a,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1b77c09a4389d4d50e5b78a8dca80583,0x0,0x1 +0x1,0x1,0x9b,0x0,0x3,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1056618bfe329ac4dcc8ee73ec818284,0x0,0x1 +0x1,0x1,0x9c,0x0,0x0,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1 +0x1,0x1,0x9d,0x0,0x0,0x3,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x1 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 diff --git a/prover/zkevm/prover/ecpair/testdata/ecpair_two_pairings_module.csv b/prover/zkevm/prover/ecpair/testdata/ecpair_two_pairings_module.csv index a9ecdcbbb..9a5b8368f 100644 --- a/prover/zkevm/prover/ecpair/testdata/ecpair_two_pairings_module.csv +++ b/prover/zkevm/prover/ecpair/testdata/ecpair_two_pairings_module.csv @@ -1,257 +1,257 @@ -ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT -0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 -0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13364879816394e38a2d72bde23bda93,0x1,0x0 -0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xcd39885c6bfdedbc45e6bafcfc8fa685,0x1,0x0 -0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e0e4c9d03746d287b341d52461946a1,0x1,0x0 -0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xc865002c35ba9bd6b789fc26a526d121,0x1,0x0 -0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 -0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 -0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 -0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 -0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 -0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 -0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 -0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 -0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x1,0x0 -0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4c95627608bdbb0235762c7048400f93,0x1,0x0 -0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x1,0x0 -0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x1,0x0 -0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x1,0x0 -0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x1,0x0 -0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b45ce688738a571621b63dba9880856,0x1,0x0 -0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x1,0x0 -0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x653b8af047158278411df902874a82a,0x1,0x0 -0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x1,0x0 -0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1373a842ceca78f2ae076804f168559c,0x1,0x0 -0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x1,0x0 -0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x1,0x0 -0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f12833bfd8a1711d7947461776699df,0x1,0x0 -0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x1,0x0 -0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x1,0x0 -0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x1,0x0 -0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x1,0x0 -0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x22af99c52785193aa8920826c0d96380,0x1,0x0 -0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x1,0x0 -0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x1,0x0 -0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x217f227c48e2682613693d3afb8231e,0x1,0x0 -0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5641ef4d251e87484afef7cae876258,0x1,0x0 -0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x1,0x0 -0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x0,0x1 -0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4c95627608bdbb0235762c7048400f93,0x0,0x1 -0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x0,0x1 -0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x0,0x1 -0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x0,0x1 -0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x0,0x1 -0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b45ce688738a571621b63dba9880856,0x0,0x1 -0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x0,0x1 -0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x653b8af047158278411df902874a82a,0x0,0x1 -0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x0,0x1 -0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1373a842ceca78f2ae076804f168559c,0x0,0x1 -0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x0,0x1 -0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x0,0x1 -0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f12833bfd8a1711d7947461776699df,0x0,0x1 -0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x0,0x1 -0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x0,0x1 -0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x0,0x1 -0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x0,0x1 -0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x22af99c52785193aa8920826c0d96380,0x0,0x1 -0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x0,0x1 -0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x0,0x1 -0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x217f227c48e2682613693d3afb8231e,0x0,0x1 -0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5641ef4d251e87484afef7cae876258,0x0,0x1 -0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x0,0x1 -0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x0,0x1 -0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 -0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 -0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 -0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2977858b214a3cb43fa4024976dd1675,0x0,0x1 -0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9b1bf5367e6318da3545e697b9931671,0x0,0x1 -0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x06fcfd4b9ca03fb145ff273e480efda3,0x0,0x1 -0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc8a7aef64882efcbd8920b4458e1ef3d,0x0,0x1 -0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x281508326108309778f9cdf9c39a4c4d,0x0,0x1 -0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc90a405c0cfbfd5d20fec4e47acce66f,0x0,0x1 -0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10d24b6f0b87c1e3f78b80b967bac765,0x0,0x1 -0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x763f38c53a4377e9a97e2761758a92f1,0x0,0x1 -0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 -0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 -0x1,0x0,0x1,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x1,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 -0x1,0x2,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x3,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x4,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x5,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x6,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x7,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x8,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x9,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xa,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xb,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xc,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xd,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xe,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0xf,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x10,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x11,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x12,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x13,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x14,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x15,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x16,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x17,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 -0x1,0x18,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x1,0x0 -0x1,0x19,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x1,0x0 -0x1,0x1a,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13aabde6da726f8fc6fcc33f7156267a,0x1,0x0 -0x1,0x1b,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x7a7f3ccb21010e7a2e2f3e67e154cc63,0x1,0x0 -0x1,0x1c,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 -0x1,0x1d,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 -0x1,0x1e,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 -0x1,0x1f,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 -0x1,0x20,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 -0x1,0x21,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 -0x1,0x22,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 -0x1,0x23,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 -0x1,0x24,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1d986c0862b80ece8d231a383cb73943,0x1,0x0 -0x1,0x25,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x3dbbc8770d85f0584f6dc86875624cea,0x1,0x0 -0x1,0x26,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x3c51f8072e2a8a07f6a06f5088e9ab2,0x1,0x0 -0x1,0x27,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdbc106c833cd19dffcb9e1073ec1805c,0x1,0x0 -0x1,0x28,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x24ef30331e45aacaa2c0db503198129d,0x1,0x0 -0x1,0x29,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x698da943542b3b26946e11a08dc6144,0x1,0x0 -0x1,0x2a,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x229bffeec7cae24f754f3353492e06b7,0x1,0x0 -0x1,0x2b,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x38b7714ed0c32e48e7afaf62a4efa110,0x1,0x0 -0x1,0x2c,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x10bc1cc6e37e745faa3ed918cc36edc9,0x1,0x0 -0x1,0x2d,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x21edc644688a0705476f795d39af8b66,0x1,0x0 -0x1,0x2e,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2adcf726eec4f68995c3207f92aea375,0x1,0x0 -0x1,0x2f,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfcd13ed4fe7b43ad615735680a4485e7,0x1,0x0 -0x1,0x30,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1f0e7e775eefc2a5672928b4efc2c508,0x1,0x0 -0x1,0x31,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd1b9522023a1105027220223481cad5e,0x1,0x0 -0x1,0x32,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x241401f805f060cf5e55b76d0a1d9703,0x1,0x0 -0x1,0x33,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x623d8250a84288f9a9d6b32e4a79ab25,0x1,0x0 -0x1,0x34,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2aefa1de34a54b19496ac527550823fc,0x1,0x0 -0x1,0x35,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4b742adbe4a5e836b5a4c3c601d721be,0x1,0x0 -0x1,0x36,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2feeac4095267db703b602ff985fc423,0x1,0x0 -0x1,0x37,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x235e6c11ea98a28c6a34a72c6ee2ddc,0x1,0x0 -0x1,0x38,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1d75dcc79d6ddd435182ca5de99635c0,0x1,0x0 -0x1,0x39,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x212f3e7e80bdfa698ac725005f8dae63,0x1,0x0 -0x1,0x3a,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5aeef8c0490c8356ffdd4913155eb21,0x1,0x0 -0x1,0x3b,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd66a1367a4c8c3f6c041b4227c1bf352,0x1,0x0 -0x1,0x3c,0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d986c0862b80ece8d231a383cb73943,0x0,0x1 -0x1,0x3d,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x3dbbc8770d85f0584f6dc86875624cea,0x0,0x1 -0x1,0x3e,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x3c51f8072e2a8a07f6a06f5088e9ab2,0x0,0x1 -0x1,0x3f,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdbc106c833cd19dffcb9e1073ec1805c,0x0,0x1 -0x1,0x40,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x24ef30331e45aacaa2c0db503198129d,0x0,0x1 -0x1,0x41,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x698da943542b3b26946e11a08dc6144,0x0,0x1 -0x1,0x42,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x229bffeec7cae24f754f3353492e06b7,0x0,0x1 -0x1,0x43,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x38b7714ed0c32e48e7afaf62a4efa110,0x0,0x1 -0x1,0x44,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x10bc1cc6e37e745faa3ed918cc36edc9,0x0,0x1 -0x1,0x45,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x21edc644688a0705476f795d39af8b66,0x0,0x1 -0x1,0x46,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2adcf726eec4f68995c3207f92aea375,0x0,0x1 -0x1,0x47,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfcd13ed4fe7b43ad615735680a4485e7,0x0,0x1 -0x1,0x48,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1f0e7e775eefc2a5672928b4efc2c508,0x0,0x1 -0x1,0x49,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd1b9522023a1105027220223481cad5e,0x0,0x1 -0x1,0x4a,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x241401f805f060cf5e55b76d0a1d9703,0x0,0x1 -0x1,0x4b,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x623d8250a84288f9a9d6b32e4a79ab25,0x0,0x1 -0x1,0x4c,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2aefa1de34a54b19496ac527550823fc,0x0,0x1 -0x1,0x4d,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4b742adbe4a5e836b5a4c3c601d721be,0x0,0x1 -0x1,0x4e,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2feeac4095267db703b602ff985fc423,0x0,0x1 -0x1,0x4f,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x235e6c11ea98a28c6a34a72c6ee2ddc,0x0,0x1 -0x1,0x50,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d75dcc79d6ddd435182ca5de99635c0,0x0,0x1 -0x1,0x51,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x212f3e7e80bdfa698ac725005f8dae63,0x0,0x1 -0x1,0x52,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5aeef8c0490c8356ffdd4913155eb21,0x0,0x1 -0x1,0x53,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd66a1367a4c8c3f6c041b4227c1bf352,0x0,0x1 -0x1,0x54,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x0,0x1 -0x1,0x55,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 -0x1,0x56,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 -0x1,0x57,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 -0x1,0x58,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0e82be8514331e947408a3a27a54d580,0x0,0x1 -0x1,0x59,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x0,0x1 -0x1,0x5a,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x0,0x1 -0x1,0x5b,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x0,0x1 -0x1,0x5c,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x0,0x1 -0x1,0x5d,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x0,0x1 -0x1,0x5e,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x11497987c563ade267b3bdfcc9c04022,0x0,0x1 -0x1,0x5f,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x0,0x1 -0x1,0x60,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 -0x1,0x61,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 -0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +ECPAIR_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACTIVE,ECPAIR_UNALIGNED_PAIRING_DATA_INDEX,ECPAIR_UNALIGNED_PAIRING_DATA_INSTANCE_ID,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_INSTANCE,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_INIT,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_PREV_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_PREV,ECPAIR_UNALIGNED_PAIRING_DATA_IS_FIRST_LINE_OF_CURR_ACC,ECPAIR_UNALIGNED_PAIRING_DATA_IS_ACCUMULATOR_CURR,ECPAIR_UNALIGNED_PAIRING_DATA_IS_COMPUTED,ECPAIR_UNALIGNED_PAIRING_DATA_IS_PULLING,ECPAIR_UNALIGNED_PAIRING_DATA_PAIR_ID,ECPAIR_UNALIGNED_PAIRING_DATA_TOTAL_PAIRS,ECPAIR_UNALIGNED_PAIRING_DATA_LIMB,ECPAIR_UNALIGNED_PAIRING_DATA_TO_MILLER_LOOP_CIRCUIT,ECPAIR_UNALIGNED_PAIRING_DATA_TO_FINAL_EXP_CIRCUIT +0x1,0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 +0x1,0x1,0x2,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x3,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x4,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x5,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x6,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x7,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x8,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x9,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xa,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xb,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xc,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xd,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xe,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xf,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x10,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x11,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x12,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x14,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x15,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x16,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x17,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13364879816394e38a2d72bde23bda93,0x1,0x0 +0x1,0x1,0x19,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xcd39885c6bfdedbc45e6bafcfc8fa685,0x1,0x0 +0x1,0x1,0x1a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e0e4c9d03746d287b341d52461946a1,0x1,0x0 +0x1,0x1,0x1b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xc865002c35ba9bd6b789fc26a526d121,0x1,0x0 +0x1,0x1,0x1c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 +0x1,0x1,0x1d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 +0x1,0x1,0x1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 +0x1,0x1,0x1f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 +0x1,0x1,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 +0x1,0x1,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 +0x1,0x1,0x22,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 +0x1,0x1,0x23,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 +0x1,0x1,0x24,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x1,0x0 +0x1,0x1,0x25,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4c95627608bdbb0235762c7048400f93,0x1,0x0 +0x1,0x1,0x26,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x1,0x0 +0x1,0x1,0x27,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x1,0x0 +0x1,0x1,0x28,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x1,0x0 +0x1,0x1,0x29,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x1,0x0 +0x1,0x1,0x2a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2b45ce688738a571621b63dba9880856,0x1,0x0 +0x1,0x1,0x2b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x1,0x0 +0x1,0x1,0x2c,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x653b8af047158278411df902874a82a,0x1,0x0 +0x1,0x1,0x2d,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x1,0x0 +0x1,0x1,0x2e,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1373a842ceca78f2ae076804f168559c,0x1,0x0 +0x1,0x1,0x2f,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x1,0x0 +0x1,0x1,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x1,0x0 +0x1,0x1,0x31,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2f12833bfd8a1711d7947461776699df,0x1,0x0 +0x1,0x1,0x32,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x1,0x0 +0x1,0x1,0x33,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x1,0x0 +0x1,0x1,0x34,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x1,0x0 +0x1,0x1,0x35,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x1,0x0 +0x1,0x1,0x36,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x22af99c52785193aa8920826c0d96380,0x1,0x0 +0x1,0x1,0x37,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x1,0x0 +0x1,0x1,0x38,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x1,0x0 +0x1,0x1,0x39,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x217f227c48e2682613693d3afb8231e,0x1,0x0 +0x1,0x1,0x3a,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5641ef4d251e87484afef7cae876258,0x1,0x0 +0x1,0x1,0x3b,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x1,0x0 +0x1,0x1,0x3c,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1fc57e97fc7f579bbc2ba220d9b10d46,0x0,0x1 +0x1,0x1,0x3d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4c95627608bdbb0235762c7048400f93,0x0,0x1 +0x1,0x1,0x3e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b4305dcdfcf51d41a169cbe7b4e89d4,0x0,0x1 +0x1,0x1,0x3f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x59f4578a51cdbe050925fc0b9312aa86,0x0,0x1 +0x1,0x1,0x40,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1133d6c9d0cacf4e7cd03b8ae8654f3b,0x0,0x1 +0x1,0x1,0x41,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfbfc80323c91c70825d4aa8accfd77b8,0x0,0x1 +0x1,0x1,0x42,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2b45ce688738a571621b63dba9880856,0x0,0x1 +0x1,0x1,0x43,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x9dd4ff917cefc257d7cfe3ea571e206a,0x0,0x1 +0x1,0x1,0x44,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x653b8af047158278411df902874a82a,0x0,0x1 +0x1,0x1,0x45,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x401206aafb12aa7c2d704f51f115d8c2,0x0,0x1 +0x1,0x1,0x46,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1373a842ceca78f2ae076804f168559c,0x0,0x1 +0x1,0x1,0x47,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1781cbb3451085c1166bdadbc7c92688,0x0,0x1 +0x1,0x1,0x48,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2c8c1f272129cf6b0866ad1d8f3ac818,0x0,0x1 +0x1,0x1,0x49,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2f12833bfd8a1711d7947461776699df,0x0,0x1 +0x1,0x1,0x4a,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x16e10599cfcd3537d808d197ce64c2c5,0x0,0x1 +0x1,0x1,0x4b,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdaf005b2c0be94b08c52e30acfb098e,0x0,0x1 +0x1,0x1,0x4c,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd5d04cfad426760d9019d3d15b98aee,0x0,0x1 +0x1,0x1,0x4d,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x8c37f28a10bb3cfa2f3971505c77db23,0x0,0x1 +0x1,0x1,0x4e,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x22af99c52785193aa8920826c0d96380,0x0,0x1 +0x1,0x1,0x4f,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xe8213976bbbab27922a2cd8c8fe4adeb,0x0,0x1 +0x1,0x1,0x50,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xa6356a8a0caaec7d1a28661b990a20b,0x0,0x1 +0x1,0x1,0x51,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x217f227c48e2682613693d3afb8231e,0x0,0x1 +0x1,0x1,0x52,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5641ef4d251e87484afef7cae876258,0x0,0x1 +0x1,0x1,0x53,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xc199d8553a68a9408d2603bd9ff29c36,0x0,0x1 +0x1,0x1,0x54,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x0,0x1 +0x1,0x1,0x55,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 +0x1,0x1,0x56,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 +0x1,0x1,0x57,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 +0x1,0x1,0x58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x2977858b214a3cb43fa4024976dd1675,0x0,0x1 +0x1,0x1,0x59,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9b1bf5367e6318da3545e697b9931671,0x0,0x1 +0x1,0x1,0x5a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x06fcfd4b9ca03fb145ff273e480efda3,0x0,0x1 +0x1,0x1,0x5b,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc8a7aef64882efcbd8920b4458e1ef3d,0x0,0x1 +0x1,0x1,0x5c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x281508326108309778f9cdf9c39a4c4d,0x0,0x1 +0x1,0x1,0x5d,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xc90a405c0cfbfd5d20fec4e47acce66f,0x0,0x1 +0x1,0x1,0x5e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10d24b6f0b87c1e3f78b80b967bac765,0x0,0x1 +0x1,0x1,0x5f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x763f38c53a4377e9a97e2761758a92f1,0x0,0x1 +0x1,0x1,0x60,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 +0x1,0x1,0x61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 +0x1,0x1,0x0,0x1,0x1,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x1,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x1,0x1,0x0 +0x1,0x1,0x2,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x3,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x4,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x5,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x6,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x7,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x8,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x9,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xa,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xb,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xc,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xd,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xe,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0xf,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x10,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x11,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x12,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x13,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x14,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x15,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x16,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x17,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x2,0x0,0x1,0x0 +0x1,0x1,0x18,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x1,0x0 +0x1,0x1,0x19,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x1,0x0 +0x1,0x1,0x1a,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x13aabde6da726f8fc6fcc33f7156267a,0x1,0x0 +0x1,0x1,0x1b,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x7a7f3ccb21010e7a2e2f3e67e154cc63,0x1,0x0 +0x1,0x1,0x1c,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0e82be8514331e947408a3a27a54d580,0x1,0x0 +0x1,0x1,0x1d,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x1,0x0 +0x1,0x1,0x1e,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x1,0x0 +0x1,0x1,0x1f,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x1,0x0 +0x1,0x1,0x20,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x1,0x0 +0x1,0x1,0x21,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x1,0x0 +0x1,0x1,0x22,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x11497987c563ade267b3bdfcc9c04022,0x1,0x0 +0x1,0x1,0x23,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x1,0x0 +0x1,0x1,0x24,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x1,0x0,0x1,0x2,0x1d986c0862b80ece8d231a383cb73943,0x1,0x0 +0x1,0x1,0x25,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x3dbbc8770d85f0584f6dc86875624cea,0x1,0x0 +0x1,0x1,0x26,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x3c51f8072e2a8a07f6a06f5088e9ab2,0x1,0x0 +0x1,0x1,0x27,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xdbc106c833cd19dffcb9e1073ec1805c,0x1,0x0 +0x1,0x1,0x28,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x24ef30331e45aacaa2c0db503198129d,0x1,0x0 +0x1,0x1,0x29,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x698da943542b3b26946e11a08dc6144,0x1,0x0 +0x1,0x1,0x2a,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x229bffeec7cae24f754f3353492e06b7,0x1,0x0 +0x1,0x1,0x2b,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x38b7714ed0c32e48e7afaf62a4efa110,0x1,0x0 +0x1,0x1,0x2c,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x10bc1cc6e37e745faa3ed918cc36edc9,0x1,0x0 +0x1,0x1,0x2d,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x21edc644688a0705476f795d39af8b66,0x1,0x0 +0x1,0x1,0x2e,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2adcf726eec4f68995c3207f92aea375,0x1,0x0 +0x1,0x1,0x2f,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xfcd13ed4fe7b43ad615735680a4485e7,0x1,0x0 +0x1,0x1,0x30,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1f0e7e775eefc2a5672928b4efc2c508,0x1,0x0 +0x1,0x1,0x31,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd1b9522023a1105027220223481cad5e,0x1,0x0 +0x1,0x1,0x32,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x241401f805f060cf5e55b76d0a1d9703,0x1,0x0 +0x1,0x1,0x33,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x623d8250a84288f9a9d6b32e4a79ab25,0x1,0x0 +0x1,0x1,0x34,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2aefa1de34a54b19496ac527550823fc,0x1,0x0 +0x1,0x1,0x35,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x4b742adbe4a5e836b5a4c3c601d721be,0x1,0x0 +0x1,0x1,0x36,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x2feeac4095267db703b602ff985fc423,0x1,0x0 +0x1,0x1,0x37,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x235e6c11ea98a28c6a34a72c6ee2ddc,0x1,0x0 +0x1,0x1,0x38,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x1d75dcc79d6ddd435182ca5de99635c0,0x1,0x0 +0x1,0x1,0x39,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x212f3e7e80bdfa698ac725005f8dae63,0x1,0x0 +0x1,0x1,0x3a,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0x5aeef8c0490c8356ffdd4913155eb21,0x1,0x0 +0x1,0x1,0x3b,0x1,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x1,0x2,0xd66a1367a4c8c3f6c041b4227c1bf352,0x1,0x0 +0x1,0x1,0x3c,0x1,0x0,0x0,0x1,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d986c0862b80ece8d231a383cb73943,0x0,0x1 +0x1,0x1,0x3d,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x3dbbc8770d85f0584f6dc86875624cea,0x0,0x1 +0x1,0x1,0x3e,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x3c51f8072e2a8a07f6a06f5088e9ab2,0x0,0x1 +0x1,0x1,0x3f,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xdbc106c833cd19dffcb9e1073ec1805c,0x0,0x1 +0x1,0x1,0x40,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x24ef30331e45aacaa2c0db503198129d,0x0,0x1 +0x1,0x1,0x41,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x698da943542b3b26946e11a08dc6144,0x0,0x1 +0x1,0x1,0x42,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x229bffeec7cae24f754f3353492e06b7,0x0,0x1 +0x1,0x1,0x43,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x38b7714ed0c32e48e7afaf62a4efa110,0x0,0x1 +0x1,0x1,0x44,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x10bc1cc6e37e745faa3ed918cc36edc9,0x0,0x1 +0x1,0x1,0x45,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x21edc644688a0705476f795d39af8b66,0x0,0x1 +0x1,0x1,0x46,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2adcf726eec4f68995c3207f92aea375,0x0,0x1 +0x1,0x1,0x47,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xfcd13ed4fe7b43ad615735680a4485e7,0x0,0x1 +0x1,0x1,0x48,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1f0e7e775eefc2a5672928b4efc2c508,0x0,0x1 +0x1,0x1,0x49,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd1b9522023a1105027220223481cad5e,0x0,0x1 +0x1,0x1,0x4a,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x241401f805f060cf5e55b76d0a1d9703,0x0,0x1 +0x1,0x1,0x4b,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x623d8250a84288f9a9d6b32e4a79ab25,0x0,0x1 +0x1,0x1,0x4c,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2aefa1de34a54b19496ac527550823fc,0x0,0x1 +0x1,0x1,0x4d,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x4b742adbe4a5e836b5a4c3c601d721be,0x0,0x1 +0x1,0x1,0x4e,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x2feeac4095267db703b602ff985fc423,0x0,0x1 +0x1,0x1,0x4f,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x235e6c11ea98a28c6a34a72c6ee2ddc,0x0,0x1 +0x1,0x1,0x50,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x1d75dcc79d6ddd435182ca5de99635c0,0x0,0x1 +0x1,0x1,0x51,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x212f3e7e80bdfa698ac725005f8dae63,0x0,0x1 +0x1,0x1,0x52,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0x5aeef8c0490c8356ffdd4913155eb21,0x0,0x1 +0x1,0x1,0x53,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x2,0x2,0xd66a1367a4c8c3f6c041b4227c1bf352,0x0,0x1 +0x1,0x1,0x54,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0b9624a62e115247146d4643e8d4daf0,0x0,0x1 +0x1,0x1,0x55,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x7ff180000fcf9f02c84cc5692b2c0526,0x0,0x1 +0x1,0x1,0x56,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1cb9908c06bf3099f1538277102b31e3,0x0,0x1 +0x1,0x1,0x57,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x1d022dc64770bc130df14daef72830e4,0x0,0x1 +0x1,0x1,0x58,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0e82be8514331e947408a3a27a54d580,0x0,0x1 +0x1,0x1,0x59,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x9866db37d74db5abc7de8f0d3d0f7ee3,0x0,0x1 +0x1,0x1,0x5a,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x0f89c9a7bb2eb9418d2d89310306196d,0x0,0x1 +0x1,0x1,0x5b,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xf1ae8d9de0173f3e1151487bb5157cd7,0x0,0x1 +0x1,0x1,0x5c,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x10b30b9925aace81dcec2ccce77c3eea,0x0,0x1 +0x1,0x1,0x5d,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0xa949c366d7cd71a6a6748bcdd996b762,0x0,0x1 +0x1,0x1,0x5e,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x11497987c563ade267b3bdfcc9c04022,0x0,0x1 +0x1,0x1,0x5f,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x2,0x3e25664c3bcdd28858b1daa7ac249034,0x0,0x1 +0x1,0x1,0x60,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x0,0x0,0x1 +0x1,0x1,0x61,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x2,0x1,0x0,0x1 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 +0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 From b3857464ad9e19d16614d67da5ac022f524024c7 Mon Sep 17 00:00:00 2001 From: The Dark Jester Date: Wed, 16 Oct 2024 05:51:32 -0700 Subject: [PATCH 08/12] Feat/3907 state reconstruction events (#43) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Remove lastFinalizedShnarf from finalization input * Emit events state-reconstruction friendly * Index shnarf on data submitted event * reinstate public input variable name * updated V6 ABI * Coordinator - Allowing endless retries and setting them throughout th… (#89) * Coordinator - Allowing endless retries and setting them throughout the app * feat/1731 code coverage in Codecov (#13) * feat/1731 code coverage in Codecov * Cancel in progress workflows on new commits (#53) * Cancel in progress workflows on new commits * Test - Trigger workflow * Test - Trigger workflow 2 * Group by only github.ref for branch name * Add concurrency to more workflows * Revert "Add concurrency to more workflows" This reverts commit 86a00aa7b5c8e29d870acdc3d4d25d660b3a59e8. * Print group * Remove print steps and amend group * Test adding concurrency group to testing.yml * Test concurrency * Specifying specific groups for child workflows * Testing concurrency * Add child groups to build and publish workflows * Test concurrency * Remove main workflow concurrency group * Remove concurrency on pull request merge * Feat/94 emit version updated event (#98) * Emit LineaRollupVersionChanged on upgrade * make padded hex bytes generic * Use L2MessageService versioned API (#96) * Stricter path filters for shared jvm-libs module (#52) * Stricter path filters for shared jvm-libs module * Update .github/workflows/main.yml Co-authored-by: Roman Vaseev <4833306+Filter94@users.noreply.github.com> Signed-off-by: Bradley Bown --------- Signed-off-by: Bradley Bown Co-authored-by: Roman Vaseev <4833306+Filter94@users.noreply.github.com> * adding TokenBridge version for completeness (#99) * Coordinator: DRY refactor test helpers and data for future reuse (#100) * coordinator: adds slice ByteArrayExtensions.kt * coordinator: adds testing file system helper * coordinator: adds testing l1-blob-proof-submission submitter * coordinator: rename findFile function * coordinator: move prover responses to common test data for code reuse * coordinator: fix ByteArray.sliceOf off-by-one bug * coordinator: remove unnecessary!! * coordinator: fix gradle deps * coordinator: fix test * coordinator: reduce transitive dependencies * rebuild LineaRollup ABI * Use finalStateRootHash on DataSubmittedV3 * fix flaky test * fix regression * use latest LineaRollup ABI for V6.0 * Add explicit comment for lastFinalizedShnarf * NatSpec tweak and variable name correction * Use finalizeBlocks not finalizeBlocksWithoutProof * Use PAUSE_FINALIZATION_ROLE without WITHPROOF * remove WithProof from finalize function * use most up to date ABIs * use V5 for the current end to end tests * reinstate format from main * reset pragma version * rename file and env var function --------- Signed-off-by: Bradley Bown Co-authored-by: count-sum Co-authored-by: Pedro Novais <1478752+jpnovais@users.noreply.github.com> Co-authored-by: Roman Vaseev <4833306+Filter94@users.noreply.github.com> Co-authored-by: Bradley Bown --- Makefile | 2 +- contracts/abi/L2MessageServiceV1.0.abi | 232 ++++-------- contracts/abi/LineaRollupV6.0.abi | 349 ++++++++---------- contracts/common/constants/pauseTypes.ts | 8 +- contracts/common/constants/roles.ts | 8 +- contracts/contracts/LineaRollup.sol | 115 +++--- contracts/contracts/ZkEvmV2.sol | 18 +- .../contracts/interfaces/l1/ILineaRollup.sol | 51 +-- .../contracts/interfaces/l1/IZkEvmV2.sol | 8 - .../contracts/lib/LineaRollupPauseManager.sol | 4 +- ...aRollupFlattened.sol => LineaRollupV5.sol} | 10 +- ...pAlphaV3.ts => 03_deploy_LineaRollupV5.ts} | 28 +- .../SixInOne/aggregatedProof-1-206.json | 30 +- .../testEIP4844/SixInOne/blocks-1-46.json | 27 +- .../testEIP4844/SixInOne/blocks-115-155.json | 27 +- .../testEIP4844/SixInOne/blocks-156-175.json | 27 +- .../testEIP4844/SixInOne/blocks-176-206.json | 27 +- .../testEIP4844/SixInOne/blocks-47-81.json | 27 +- .../testEIP4844/SixInOne/blocks-82-114.json | 27 +- .../SixInOne/sendBlobTransaction.ts | 5 +- contracts/test/L1MessageService.ts | 2 +- contracts/test/LineaRollup.ts | 314 +++++----------- contracts/test/PauseManager.ts | 12 +- contracts/test/common/constants/pauseTypes.ts | 8 +- contracts/test/common/constants/roles.ts | 4 +- .../test/common/helpers/dataGeneration.ts | 1 - contracts/test/common/helpers/expectations.ts | 21 +- contracts/test/common/types.ts | 1 - 28 files changed, 629 insertions(+), 764 deletions(-) rename contracts/contracts/test-contracts/{LineaRollupFlattened.sol => LineaRollupV5.sol} (99%) rename contracts/deploy/{03_deploy_LineaRollupAlphaV3.ts => 03_deploy_LineaRollupV5.ts} (87%) diff --git a/Makefile b/Makefile index c017b7d38..d26be8c1f 100644 --- a/Makefile +++ b/Makefile @@ -81,7 +81,7 @@ deploy-linea-rollup: LINEA_ROLLUP_RATE_LIMIT_PERIOD=86400 \ LINEA_ROLLUP_RATE_LIMIT_AMOUNT=1000000000000000000000 \ LINEA_ROLLUP_GENESIS_TIMESTAMP=1683325137 \ - npx hardhat deploy --no-compile --network zkevm_dev --tags PlonkVerifier,LineaRollup + npx hardhat deploy --no-compile --network zkevm_dev --tags PlonkVerifier,LineaRollupV5 deploy-l2messageservice: # WARNING: FOR LOCAL DEV ONLY - DO NOT REUSE THESE KEYS ELSEWHERE diff --git a/contracts/abi/L2MessageServiceV1.0.abi b/contracts/abi/L2MessageServiceV1.0.abi index 7439ad369..a03019024 100644 --- a/contracts/abi/L2MessageServiceV1.0.abi +++ b/contracts/abi/L2MessageServiceV1.0.abi @@ -33,9 +33,9 @@ { "inputs": [ { - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "IsNotPaused", @@ -44,9 +44,9 @@ { "inputs": [ { - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "IsPaused", @@ -147,6 +147,11 @@ "name": "ZeroAddressNotAllowed", "type": "error" }, + { + "inputs": [], + "name": "ZeroHashNotAllowed", + "type": "error" + }, { "anonymous": false, "inputs": [ @@ -304,6 +309,25 @@ "name": "MinimumFeeChanged", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "enum IPauseManager.PauseType", + "name": "pauseType", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "PauseTypeRoleSet", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -315,9 +339,9 @@ }, { "indexed": true, - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "Paused", @@ -460,58 +484,38 @@ "inputs": [ { "indexed": false, - "internalType": "address", - "name": "messageSender", - "type": "address" + "internalType": "enum IPauseManager.PauseType", + "name": "unPauseType", + "type": "uint8" }, { - "indexed": true, - "internalType": "uint256", - "name": "pauseType", - "type": "uint256" + "indexed": false, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" } ], - "name": "UnPaused", + "name": "UnPauseTypeRoleSet", "type": "event" }, { - "inputs": [], - "name": "BLOB_SUBMISSION_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "CALLDATA_SUBMISSION_PAUSE_TYPE", - "outputs": [ + "anonymous": false, + "inputs": [ { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "COMPLETE_TOKEN_BRIDGING_PAUSE_TYPE", - "outputs": [ + "indexed": false, + "internalType": "address", + "name": "messageSender", + "type": "address" + }, { - "internalType": "uint8", - "name": "", + "indexed": true, + "internalType": "enum IPauseManager.PauseType", + "name": "pauseType", "type": "uint8" } ], - "stateMutability": "view", - "type": "function" + "name": "UnPaused", + "type": "event" }, { "inputs": [], @@ -539,32 +543,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "FINALIZATION_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "GENERAL_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "INBOX_STATUS_CLAIMED", @@ -604,19 +582,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "INITIATE_TOKEN_BRIDGING_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "L1_L2_MESSAGE_SETTER_ROLE", @@ -630,32 +595,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "L1_L2_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "L2_L1_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "MINIMUM_FEE_SETTER_ROLE", @@ -682,19 +621,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "PAUSE_FINALIZE_WITHPROOF_ROLE", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "PAUSE_L1_L2_ROLE", @@ -708,19 +634,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "PAUSE_L2_BLOB_SUBMISSION_ROLE", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "PAUSE_L2_L1_ROLE", @@ -760,19 +673,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "UNPAUSE_FINALIZE_WITHPROOF_ROLE", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "UNPAUSE_L1_L2_ROLE", @@ -786,19 +686,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "UNPAUSE_L2_BLOB_SUBMISSION_ROLE", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "UNPAUSE_L2_L1_ROLE", @@ -1014,6 +901,11 @@ "name": "_rateLimitAmount", "type": "uint256" }, + { + "internalType": "address", + "name": "_defaultAdmin", + "type": "address" + }, { "components": [ { @@ -1034,7 +926,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1051,7 +943,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1074,7 +966,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } @@ -1164,7 +1056,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } @@ -1228,7 +1120,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1245,7 +1137,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1392,7 +1284,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } diff --git a/contracts/abi/LineaRollupV6.0.abi b/contracts/abi/LineaRollupV6.0.abi index 4be652856..5f8cd5442 100644 --- a/contracts/abi/LineaRollupV6.0.abi +++ b/contracts/abi/LineaRollupV6.0.abi @@ -105,22 +105,6 @@ "name": "FeeTooLow", "type": "error" }, - { - "inputs": [ - { - "internalType": "uint256", - "name": "expected", - "type": "uint256" - }, - { - "internalType": "uint256", - "name": "actual", - "type": "uint256" - } - ], - "name": "FinalBlockDoesNotMatchShnarfFinalBlock", - "type": "error" - }, { "inputs": [ { @@ -256,9 +240,9 @@ { "inputs": [ { - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "IsNotPaused", @@ -267,9 +251,9 @@ { "inputs": [ { - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "IsPaused", @@ -513,6 +497,11 @@ "name": "ZeroAddressNotAllowed", "type": "error" }, + { + "inputs": [], + "name": "ZeroHashNotAllowed", + "type": "error" + }, { "anonymous": false, "inputs": [ @@ -532,23 +521,35 @@ { "indexed": true, "internalType": "uint256", - "name": "lastBlockFinalized", + "name": "startBlockNumber", "type": "uint256" }, + { + "indexed": true, + "internalType": "uint256", + "name": "endBlockNumber", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "shnarf", + "type": "bytes32" + }, { "indexed": false, "internalType": "bytes32", - "name": "startingRootHash", + "name": "parentStateRootHash", "type": "bytes32" }, { "indexed": false, "internalType": "bytes32", - "name": "finalRootHash", + "name": "finalStateRootHash", "type": "bytes32" } ], - "name": "BlocksVerificationDone", + "name": "DataFinalizedV3", "type": "event" }, { @@ -557,29 +558,35 @@ { "indexed": true, "internalType": "uint256", - "name": "lastBlockFinalized", + "name": "startBlock", "type": "uint256" }, { "indexed": true, + "internalType": "uint256", + "name": "endBlock", + "type": "uint256" + }, + { + "indexed": false, "internalType": "bytes32", - "name": "startingRootHash", + "name": "parentShnarf", "type": "bytes32" }, { "indexed": true, "internalType": "bytes32", - "name": "finalRootHash", + "name": "shnarf", "type": "bytes32" }, { "indexed": false, - "internalType": "bool", - "name": "withProof", - "type": "bool" + "internalType": "bytes32", + "name": "finalStateRootHash", + "type": "bytes32" } ], - "name": "DataFinalized", + "name": "DataSubmittedV3", "type": "event" }, { @@ -587,24 +594,18 @@ "inputs": [ { "indexed": true, - "internalType": "bytes32", - "name": "shnarf", - "type": "bytes32" - }, - { - "indexed": true, - "internalType": "uint256", - "name": "startBlock", - "type": "uint256" + "internalType": "address", + "name": "caller", + "type": "address" }, { "indexed": true, - "internalType": "uint256", - "name": "endBlock", - "type": "uint256" + "internalType": "address", + "name": "fallbackOperator", + "type": "address" } ], - "name": "DataSubmittedV2", + "name": "FallbackOperatorAddressSet", "type": "event" }, { @@ -619,11 +620,11 @@ { "indexed": true, "internalType": "address", - "name": "gatewayOperatorAddress", + "name": "fallbackOperator", "type": "address" } ], - "name": "GatewayOperatorRoleGranted", + "name": "FallbackOperatorRoleGranted", "type": "event" }, { @@ -702,6 +703,25 @@ "name": "LimitAmountChanged", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes8", + "name": "previousVersion", + "type": "bytes8" + }, + { + "indexed": true, + "internalType": "bytes8", + "name": "newVersion", + "type": "bytes8" + } + ], + "name": "LineaRollupVersionChanged", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -764,6 +784,25 @@ "name": "MessageSent", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "enum IPauseManager.PauseType", + "name": "pauseType", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "PauseTypeRoleSet", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -775,9 +814,9 @@ }, { "indexed": true, - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "Paused", @@ -908,6 +947,25 @@ "name": "RollingHashUpdated", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "enum IPauseManager.PauseType", + "name": "unPauseType", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "UnPauseTypeRoleSet", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -919,9 +977,9 @@ }, { "indexed": true, - "internalType": "uint256", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", - "type": "uint256" + "type": "uint8" } ], "name": "UnPaused", @@ -958,45 +1016,6 @@ "name": "VerifierAddressChanged", "type": "event" }, - { - "inputs": [], - "name": "BLOB_SUBMISSION_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "CALLDATA_SUBMISSION_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "COMPLETE_TOKEN_BRIDGING_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "CONTRACT_VERSION", @@ -1023,45 +1042,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "FINALIZATION_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "FINALIZE_WITHOUT_PROOF_ROLE", - "outputs": [ - { - "internalType": "bytes32", - "name": "", - "type": "bytes32" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "GENERAL_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "GENESIS_SHNARF", @@ -1101,45 +1081,6 @@ "stateMutability": "view", "type": "function" }, - { - "inputs": [], - "name": "INITIATE_TOKEN_BRIDGING_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "L1_L2_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [], - "name": "L2_L1_PAUSE_TYPE", - "outputs": [ - { - "internalType": "uint8", - "name": "", - "type": "uint8" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [], "name": "OPERATOR_ROLE", @@ -1207,7 +1148,7 @@ }, { "inputs": [], - "name": "PAUSE_FINALIZE_WITHPROOF_ROLE", + "name": "PAUSE_BLOB_SUBMISSION_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1220,7 +1161,7 @@ }, { "inputs": [], - "name": "PAUSE_L1_L2_ROLE", + "name": "PAUSE_FINALIZATION_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1233,7 +1174,7 @@ }, { "inputs": [], - "name": "PAUSE_L2_BLOB_SUBMISSION_ROLE", + "name": "PAUSE_L1_L2_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1285,7 +1226,7 @@ }, { "inputs": [], - "name": "UNPAUSE_FINALIZE_WITHPROOF_ROLE", + "name": "UNPAUSE_BLOB_SUBMISSION_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1298,7 +1239,7 @@ }, { "inputs": [], - "name": "UNPAUSE_L1_L2_ROLE", + "name": "UNPAUSE_FINALIZATION_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1311,7 +1252,7 @@ }, { "inputs": [], - "name": "UNPAUSE_L2_BLOB_SUBMISSION_ROLE", + "name": "UNPAUSE_L1_L2_ROLE", "outputs": [ { "internalType": "bytes32", @@ -1681,6 +1622,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [], + "name": "fallbackOperator", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, { "inputs": [ { @@ -1700,11 +1654,6 @@ "name": "parentStateRootHash", "type": "bytes32" }, - { - "internalType": "bytes32", - "name": "lastFinalizedShnarf", - "type": "bytes32" - }, { "internalType": "uint256", "name": "finalBlockInData", @@ -1788,29 +1737,16 @@ "type": "bytes" } ], - "internalType": "struct ILineaRollup.FinalizationDataV2", + "internalType": "struct ILineaRollup.FinalizationDataV3", "name": "_finalizationData", "type": "tuple" } ], - "name": "finalizeBlocksWithProof", + "name": "finalizeBlocks", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, - { - "inputs": [], - "name": "gatewayOperator", - "outputs": [ - { - "internalType": "address", - "name": "", - "type": "address" - } - ], - "stateMutability": "view", - "type": "function" - }, { "inputs": [ { @@ -1945,7 +1881,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1962,7 +1898,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -1978,7 +1914,12 @@ }, { "internalType": "address", - "name": "gatewayOperator", + "name": "fallbackOperator", + "type": "address" + }, + { + "internalType": "address", + "name": "defaultAdmin", "type": "address" } ], @@ -2014,7 +1955,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } @@ -2097,7 +2038,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } @@ -2161,7 +2102,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -2178,7 +2119,7 @@ { "components": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "pauseType", "type": "uint8" }, @@ -2194,11 +2135,11 @@ }, { "internalType": "address", - "name": "_gatewayOperator", + "name": "_fallbackOperator", "type": "address" } ], - "name": "reinitializePauseTypesAndPermissions", + "name": "reinitializeLineaRollupV6", "outputs": [], "stateMutability": "nonpayable", "type": "function" @@ -2332,7 +2273,7 @@ "type": "uint256" } ], - "name": "setGatewayOperator", + "name": "setFallbackOperator", "outputs": [], "stateMutability": "nonpayable", "type": "function" @@ -2545,7 +2486,7 @@ { "inputs": [ { - "internalType": "uint8", + "internalType": "enum IPauseManager.PauseType", "name": "_pauseType", "type": "uint8" } diff --git a/contracts/common/constants/pauseTypes.ts b/contracts/common/constants/pauseTypes.ts index 560cf44ca..9471f6294 100644 --- a/contracts/common/constants/pauseTypes.ts +++ b/contracts/common/constants/pauseTypes.ts @@ -1,14 +1,14 @@ import { PAUSE_ALL_ROLE, PAUSE_COMPLETE_TOKEN_BRIDGING_ROLE, - PAUSE_FINALIZE_WITHPROOF_ROLE, + PAUSE_FINALIZATION_ROLE, PAUSE_INITIATE_TOKEN_BRIDGING_ROLE, PAUSE_L1_L2_ROLE, PAUSE_BLOB_SUBMISSION_ROLE, PAUSE_L2_L1_ROLE, UNPAUSE_ALL_ROLE, UNPAUSE_COMPLETE_TOKEN_BRIDGING_ROLE, - UNPAUSE_FINALIZE_WITHPROOF_ROLE, + UNPAUSE_FINALIZATION_ROLE, UNPAUSE_INITIATE_TOKEN_BRIDGING_ROLE, UNPAUSE_L1_L2_ROLE, UNPAUSE_BLOB_SUBMISSION_ROLE, @@ -34,7 +34,7 @@ export const LINEA_ROLLUP_PAUSE_TYPES_ROLES = [ { pauseType: L2_L1_PAUSE_TYPE, role: PAUSE_L2_L1_ROLE }, { pauseType: BLOB_SUBMISSION_PAUSE_TYPE, role: PAUSE_BLOB_SUBMISSION_ROLE }, { pauseType: CALLDATA_SUBMISSION_PAUSE_TYPE, role: PAUSE_BLOB_SUBMISSION_ROLE }, - { pauseType: FINALIZATION_PAUSE_TYPE, role: PAUSE_FINALIZE_WITHPROOF_ROLE }, + { pauseType: FINALIZATION_PAUSE_TYPE, role: PAUSE_FINALIZATION_ROLE }, ]; export const LINEA_ROLLUP_UNPAUSE_TYPES_ROLES = [ @@ -43,7 +43,7 @@ export const LINEA_ROLLUP_UNPAUSE_TYPES_ROLES = [ { pauseType: L2_L1_PAUSE_TYPE, role: UNPAUSE_L2_L1_ROLE }, { pauseType: BLOB_SUBMISSION_PAUSE_TYPE, role: UNPAUSE_BLOB_SUBMISSION_ROLE }, { pauseType: CALLDATA_SUBMISSION_PAUSE_TYPE, role: UNPAUSE_BLOB_SUBMISSION_ROLE }, - { pauseType: FINALIZATION_PAUSE_TYPE, role: UNPAUSE_FINALIZE_WITHPROOF_ROLE }, + { pauseType: FINALIZATION_PAUSE_TYPE, role: UNPAUSE_FINALIZATION_ROLE }, ]; // L2MessageService diff --git a/contracts/common/constants/roles.ts b/contracts/common/constants/roles.ts index 7cf223ae8..3b9867dc9 100644 --- a/contracts/common/constants/roles.ts +++ b/contracts/common/constants/roles.ts @@ -23,10 +23,10 @@ export const PAUSE_BLOB_SUBMISSION_ROLE = generateKeccak256(["string"], ["PAUSE_ export const UNPAUSE_BLOB_SUBMISSION_ROLE = generateKeccak256(["string"], ["UNPAUSE_BLOB_SUBMISSION_ROLE"], { encodePacked: true, }); -export const PAUSE_FINALIZE_WITHPROOF_ROLE = generateKeccak256(["string"], ["PAUSE_FINALIZE_WITHPROOF_ROLE"], { +export const PAUSE_FINALIZATION_ROLE = generateKeccak256(["string"], ["PAUSE_FINALIZATION_ROLE"], { encodePacked: true, }); -export const UNPAUSE_FINALIZE_WITHPROOF_ROLE = generateKeccak256(["string"], ["UNPAUSE_FINALIZE_WITHPROOF_ROLE"], { +export const UNPAUSE_FINALIZATION_ROLE = generateKeccak256(["string"], ["UNPAUSE_FINALIZATION_ROLE"], { encodePacked: true, }); export const MINIMUM_FEE_SETTER_ROLE = generateKeccak256(["string"], ["MINIMUM_FEE_SETTER_ROLE"], { @@ -91,8 +91,8 @@ export const LINEA_ROLLUP_ROLES = [ UNPAUSE_L2_L1_ROLE, PAUSE_BLOB_SUBMISSION_ROLE, UNPAUSE_BLOB_SUBMISSION_ROLE, - PAUSE_FINALIZE_WITHPROOF_ROLE, - UNPAUSE_FINALIZE_WITHPROOF_ROLE, + PAUSE_FINALIZATION_ROLE, + UNPAUSE_FINALIZATION_ROLE, ]; export const L2_MESSAGE_SERVICE_ROLES = [ diff --git a/contracts/contracts/LineaRollup.sol b/contracts/contracts/LineaRollup.sol index 2cfa40b33..4fdaae747 100644 --- a/contracts/contracts/LineaRollup.sol +++ b/contracts/contracts/LineaRollup.sol @@ -281,7 +281,13 @@ contract LineaRollup is /// @dev use the last shnarf as the submission to store as technically it becomes the next parent shnarf. shnarfFinalBlockNumbers[computedShnarf] = blobFinalBlockNumber; - emit DataSubmittedV2(computedShnarf, _blobSubmissionData[0].submissionData.firstBlockInData, blobFinalBlockNumber); + emit DataSubmittedV3( + _blobSubmissionData[0].submissionData.firstBlockInData, + blobFinalBlockNumber, + _parentShnarf, + computedShnarf, + blobSubmissionData.submissionData.finalStateRootHash + ); } /** @@ -330,7 +336,13 @@ contract LineaRollup is shnarfFinalBlockNumbers[computedShnarf] = _submissionData.finalBlockInData; - emit DataSubmittedV2(computedShnarf, _submissionData.firstBlockInData, _submissionData.finalBlockInData); + emit DataSubmittedV3( + _submissionData.firstBlockInData, + _submissionData.finalBlockInData, + _parentShnarf, + computedShnarf, + _submissionData.finalStateRootHash + ); } /** @@ -466,10 +478,10 @@ contract LineaRollup is * @param _proofType The proof type. * @param _finalizationData The full finalization data. */ - function finalizeBlocksWithProof( + function finalizeBlocks( bytes calldata _aggregatedProof, uint256 _proofType, - FinalizationDataV2 calldata _finalizationData + FinalizationDataV3 calldata _finalizationData ) external whenTypeAndGeneralNotPaused(PauseType.FINALIZATION) onlyRole(OPERATOR_ROLE) { if (_aggregatedProof.length == 0) { revert ProofIsEmpty(); @@ -481,42 +493,30 @@ contract LineaRollup is revert StartingRootHashDoesNotMatch(); } + /// @dev currentFinalizedShnarf is updated in _finalizeBlocks and lastFinalizedShnarf MUST be set beforehand for the transition. bytes32 lastFinalizedShnarf = currentFinalizedShnarf; - - if (_finalizationData.lastFinalizedShnarf != lastFinalizedShnarf) { - revert LastFinalizedShnarfWrong(lastFinalizedShnarf, _finalizationData.lastFinalizedShnarf); - } - - bytes32 finalShnarf = _finalizeBlocks(_finalizationData, lastFinalizedBlockNumber, true); + bytes32 finalShnarf = _finalizeBlocks(_finalizationData, lastFinalizedBlockNumber); uint256 publicInput = _computePublicInput( _finalizationData, lastFinalizedShnarf, finalShnarf, - lastFinalizedBlockNumber + lastFinalizedBlockNumber, + shnarfFinalBlockNumbers[finalShnarf] ); - _verifyProof( - publicInput, - _proofType, - _aggregatedProof, - _finalizationData.parentStateRootHash, - _finalizationData.finalBlockInData, - _finalizationData.shnarfData.finalStateRootHash - ); + _verifyProof(publicInput, _proofType, _aggregatedProof); } /** * @notice Internal function to finalize compressed blocks. * @param _finalizationData The full finalization data. * @param _lastFinalizedBlock The last finalized block. - * @param _withProof If we are finalizing with a proof. * @return finalShnarf The final computed shnarf in finalizing. */ function _finalizeBlocks( - FinalizationDataV2 calldata _finalizationData, - uint256 _lastFinalizedBlock, - bool _withProof + FinalizationDataV3 calldata _finalizationData, + uint256 _lastFinalizedBlock ) internal returns (bytes32 finalShnarf) { if (_finalizationData.finalBlockInData <= _lastFinalizedBlock) { revert FinalBlockNumberLessThanOrEqualToLastFinalizedBlock( @@ -560,13 +560,6 @@ contract LineaRollup is _finalizationData.shnarfData.dataEvaluationClaim ); - if (shnarfFinalBlockNumbers[finalShnarf] != _finalizationData.finalBlockInData) { - revert FinalBlockDoesNotMatchShnarfFinalBlock( - _finalizationData.finalBlockInData, - shnarfFinalBlockNumbers[finalShnarf] - ); - } - _addL2MerkleRoots(_finalizationData.l2MerkleRoots, _finalizationData.l2MerkleTreesDepth); _anchorL2MessagingBlocks(_finalizationData.l2MessagingBlocksOffsets, _lastFinalizedBlock); @@ -582,11 +575,13 @@ contract LineaRollup is _finalizationData.finalTimestamp ); - emit DataFinalized( + emit DataFinalizedV3( + /// @dev incremented to cover the starting block of data being finalized + ++_lastFinalizedBlock, _finalizationData.finalBlockInData, + finalShnarf, _finalizationData.parentStateRootHash, - _finalizationData.shnarfData.finalStateRootHash, - _withProof + _finalizationData.shnarfData.finalStateRootHash ); } @@ -675,36 +670,36 @@ contract LineaRollup is * ) * Data is found at the following offsets: * 0x00 parentStateRootHash - * 0x20 lastFinalizedShnarf - * 0x40 finalBlockInData - * 0x60 shnarfData.parentShnarf - * 0x80 shnarfData.snarkHash - * 0xa0 shnarfData.finalStateRootHash - * 0xc0 shnarfData.dataEvaluationPoint - * 0xe0 shnarfData.dataEvaluationClaim - * 0x100 lastFinalizedTimestamp - * 0x120 finalTimestamp - * 0x140 lastFinalizedL1RollingHash - * 0x160 l1RollingHash - * 0x180 lastFinalizedL1RollingHashMessageNumber - * 0x1a0 l1RollingHashMessageNumber - * 0x1c0 l2MerkleTreesDepth - * 0x1e0 l2MerkleRootsLengthLocation - * 0x200 l2MessagingBlocksOffsetsLengthLocation - * 0x220 l2MerkleRootsLength - * 0x240 l2MerkleRoots + * 0x20 finalBlockInData + * 0x40 shnarfData.parentShnarf + * 0x60 shnarfData.snarkHash + * 0x80 shnarfData.finalStateRootHash + * 0xa0 shnarfData.dataEvaluationPoint + * 0xc0 shnarfData.dataEvaluationClaim + * 0xe0 lastFinalizedTimestamp + * 0x100 finalTimestamp + * 0x120 lastFinalizedL1RollingHash + * 0x140 l1RollingHash + * 0x160 lastFinalizedL1RollingHashMessageNumber + * 0x180 l1RollingHashMessageNumber + * 0x1a0 l2MerkleTreesDepth + * 0x1c0 l2MerkleRootsLengthLocation + * 0x1e0 l2MessagingBlocksOffsetsLengthLocation + * 0x200 l2MerkleRootsLength + * 0x220 l2MerkleRoots * Dynamic l2MessagingBlocksOffsetsLength (location depends on where l2MerkleRoots ends) * Dynamic l2MessagingBlocksOffsets (location depends on where l2MerkleRoots ends) * @param _finalizationData The full finalization data. - * @param _lastFinalizedShnarf The last finalized shnarf. * @param _finalShnarf The final shnarf in the finalization. * @param _lastFinalizedBlockNumber The last finalized block number. + * @param _finalBlockNumber Final block number being finalized. */ function _computePublicInput( - FinalizationDataV2 calldata _finalizationData, + FinalizationDataV3 calldata _finalizationData, bytes32 _lastFinalizedShnarf, bytes32 _finalShnarf, - uint256 _lastFinalizedBlockNumber + uint256 _lastFinalizedBlockNumber, + uint256 _finalBlockNumber ) private pure returns (uint256 publicInput) { assembly { let mPtr := mload(0x40) @@ -715,12 +710,12 @@ contract LineaRollup is * _finalizationData.lastFinalizedTimestamp * _finalizationData.finalTimestamp */ - calldatacopy(add(mPtr, 0x40), add(_finalizationData, 0x100), 0x40) + calldatacopy(add(mPtr, 0x40), add(_finalizationData, 0xe0), 0x40) mstore(add(mPtr, 0x80), _lastFinalizedBlockNumber) - // _finalizationData.finalBlockInData - calldatacopy(add(mPtr, 0xA0), add(_finalizationData, 0x40), 0x20) + // shnarfFinalBlockNumbers[finalShnarf] + mstore(add(mPtr, 0xA0), _finalBlockNumber) /** * _finalizationData.lastFinalizedL1RollingHash @@ -729,7 +724,7 @@ contract LineaRollup is * _finalizationData.l1RollingHashMessageNumber * _finalizationData.l2MerkleTreesDepth */ - calldatacopy(add(mPtr, 0xC0), add(_finalizationData, 0x140), 0xA0) + calldatacopy(add(mPtr, 0xC0), add(_finalizationData, 0x120), 0xA0) /** * @dev Note the following in hashing the _finalizationData.l2MerkleRoots array: @@ -737,8 +732,8 @@ contract LineaRollup is * as we need the space left for the array hash to be stored at 0x160. */ let mPtrMerkleRoot := add(mPtr, 0x180) - let merkleRootsLen := calldataload(add(_finalizationData, 0x220)) - calldatacopy(mPtrMerkleRoot, add(_finalizationData, 0x240), mul(merkleRootsLen, 0x20)) + let merkleRootsLen := calldataload(add(_finalizationData, 0x200)) + calldatacopy(mPtrMerkleRoot, add(_finalizationData, 0x220), mul(merkleRootsLen, 0x20)) let l2MerkleRootsHash := keccak256(mPtrMerkleRoot, mul(merkleRootsLen, 0x20)) mstore(add(mPtr, 0x160), l2MerkleRootsHash) diff --git a/contracts/contracts/ZkEvmV2.sol b/contracts/contracts/ZkEvmV2.sol index ab745600b..e1ea16de3 100644 --- a/contracts/contracts/ZkEvmV2.sol +++ b/contracts/contracts/ZkEvmV2.sol @@ -30,23 +30,13 @@ abstract contract ZkEvmV2 is Initializable, AccessControlUpgradeable, L1MessageS /** * @notice Verifies the proof with locally computed public inputs. * @dev If the verifier based on proof type is not found, it reverts with InvalidProofType. - * @param _publicInputHash The full BlockData collection - block, transaction and log data. + * @param _publicInput The computed public input hash cast as uint256. * @param _proofType The proof type to determine which verifier contract to use. * @param _proof The proof to be verified with the proof type verifier contract. - * @param _parentStateRootHash The beginning roothash to start with. - * @param _finalizedL2BlockNumber The final L2 block number being finalized. - * @param _finalStateRootHash The state root finalized up until. */ - function _verifyProof( - uint256 _publicInputHash, - uint256 _proofType, - bytes calldata _proof, - bytes32 _parentStateRootHash, - uint256 _finalizedL2BlockNumber, - bytes32 _finalStateRootHash - ) internal { + function _verifyProof(uint256 _publicInput, uint256 _proofType, bytes calldata _proof) internal { uint256[] memory publicInput = new uint256[](1); - publicInput[0] = _publicInputHash; + publicInput[0] = _publicInput; address verifierToUse = verifiers[_proofType]; @@ -85,7 +75,5 @@ abstract contract ZkEvmV2 is Initializable, AccessControlUpgradeable, L1MessageS if (!proofSucceeded) { revert InvalidProof(); } - - emit BlocksVerificationDone(_finalizedL2BlockNumber, _parentStateRootHash, _finalStateRootHash); } } diff --git a/contracts/contracts/interfaces/l1/ILineaRollup.sol b/contracts/contracts/interfaces/l1/ILineaRollup.sol index 51d71cc42..2d434eb96 100644 --- a/contracts/contracts/interfaces/l1/ILineaRollup.sol +++ b/contracts/contracts/interfaces/l1/ILineaRollup.sol @@ -102,7 +102,6 @@ interface ILineaRollup { * @notice Supporting data for finalization with proof. * @dev NB: the dynamic sized fields are placed last on purpose for efficient keccaking on public input. * @dev parentStateRootHash is the expected last state root hash finalized. - * @dev lastFinalizedShnarf is the last finalized shnarf for proof continuity checks. * @dev finalBlockInData is the final block finalizing until. * @dev shnarfData contains data about the last data submission's shnarf used in finalization. * @dev lastFinalizedTimestamp is the expected last finalized block's timestamp. @@ -117,9 +116,8 @@ interface ILineaRollup { * @dev l2MerkleRoots is an array of L2 message Merkle roots of depth l2MerkleTreesDepth between last finalized block and finalSubmissionData.finalBlockInData. * @dev l2MessagingBlocksOffsets indicates by offset from currentL2BlockNumber which L2 blocks contain MessageSent events. */ - struct FinalizationDataV2 { + struct FinalizationDataV3 { bytes32 parentStateRootHash; - bytes32 lastFinalizedShnarf; uint256 finalBlockInData; ShnarfData shnarfData; uint256 lastFinalizedTimestamp; @@ -173,25 +171,35 @@ interface ILineaRollup { /** * @notice Emitted when compressed data is being submitted and verified succesfully on L1. - * @param shnarf The indexed shnarf for the data being submitted. + * @dev The block range is indexed and parent shnarf included for state reconstruction simplicity. * @param startBlock The indexed L2 block number indicating which block the data starts from. * @param endBlock The indexed L2 block number indicating which block the data ends on. - * @dev Please note, shnarf was previously dataHash and points to the shnarfFinalBlockNumbers mapping. - */ - event DataSubmittedV2(bytes32 indexed shnarf, uint256 indexed startBlock, uint256 indexed endBlock); + * @param parentShnarf The parent shnarf for the data being submitted. + * @param shnarf The indexed shnarf for the data being submitted. + * @param finalStateRootHash The L2 state root hash that the current blob submission ends on. NB: The last blob in the collection. + */ + event DataSubmittedV3( + uint256 indexed startBlock, + uint256 indexed endBlock, + bytes32 parentShnarf, + bytes32 indexed shnarf, + bytes32 finalStateRootHash + ); /** * @notice Emitted when L2 blocks have been finalized on L1. - * @param lastBlockFinalized The indexed last L2 block that is finalized in the finalization. - * @param startingRootHash The indexed initial (also last finalized) L2 state root hash that the finalization is from. - * @param finalRootHash The indexed L2 state root hash that the current finalization is up until. - * @param withProof Indicates if the finalization is proven or not. - */ - event DataFinalized( - uint256 indexed lastBlockFinalized, - bytes32 indexed startingRootHash, - bytes32 indexed finalRootHash, - bool withProof + * @param startBlockNumber The indexed L2 block number indicating which block the finalization the data starts from. + * @param endBlockNumber The indexed L2 block number indicating which block the finalization the data ends on. + * @param shnarf The shnarf being set as currentFinalizedShnarf in the current finalization. + * @param parentStateRootHash The indexed parent L2 state root hash that the current finalization starts from. + * @param finalStateRootHash The indexed L2 state root hash that the current finalization ends on. + */ + event DataFinalizedV3( + uint256 indexed startBlockNumber, + uint256 indexed endBlockNumber, + bytes32 indexed shnarf, + bytes32 parentStateRootHash, + bytes32 finalStateRootHash ); /** @@ -315,11 +323,6 @@ interface ILineaRollup { */ error SnarkHashIsZeroHash(); - /** - * @dev Thrown when the block being finalized until does not match that of the shnarf data. - */ - error FinalBlockDoesNotMatchShnarfFinalBlock(uint256 expected, uint256 actual); - /** * @dev Thrown when the computed shnarf does not match what is expected. */ @@ -383,9 +386,9 @@ interface ILineaRollup { * @param _proofType The proof type. * @param _finalizationData The full finalization data. */ - function finalizeBlocksWithProof( + function finalizeBlocks( bytes calldata _aggregatedProof, uint256 _proofType, - FinalizationDataV2 calldata _finalizationData + FinalizationDataV3 calldata _finalizationData ) external; } diff --git a/contracts/contracts/interfaces/l1/IZkEvmV2.sol b/contracts/contracts/interfaces/l1/IZkEvmV2.sol index b0c5351d6..a61bdb9bf 100644 --- a/contracts/contracts/interfaces/l1/IZkEvmV2.sol +++ b/contracts/contracts/interfaces/l1/IZkEvmV2.sol @@ -7,14 +7,6 @@ pragma solidity 0.8.26; * @custom:security-contact security-report@linea.build */ interface IZkEvmV2 { - /** - * @notice Emitted when a L2 blocks have been finalized on L1. - * @param lastBlockFinalized The indexed L2 block number the finalization is up until. - * @param startingRootHash The state root hash the finalization started from. This is the last finalized block's state root. - * @param finalRootHash The L2 block state root hash the finalization ended on. - */ - event BlocksVerificationDone(uint256 indexed lastBlockFinalized, bytes32 startingRootHash, bytes32 finalRootHash); - /** * @dev Thrown when the starting rootHash does not match the existing state. */ diff --git a/contracts/contracts/lib/LineaRollupPauseManager.sol b/contracts/contracts/lib/LineaRollupPauseManager.sol index 5dc8f7af3..484a3c46c 100644 --- a/contracts/contracts/lib/LineaRollupPauseManager.sol +++ b/contracts/contracts/lib/LineaRollupPauseManager.sol @@ -15,6 +15,6 @@ abstract contract LineaRollupPauseManager is PauseManager { bytes32 public constant UNPAUSE_L2_L1_ROLE = keccak256("UNPAUSE_L2_L1_ROLE"); bytes32 public constant PAUSE_BLOB_SUBMISSION_ROLE = keccak256("PAUSE_BLOB_SUBMISSION_ROLE"); bytes32 public constant UNPAUSE_BLOB_SUBMISSION_ROLE = keccak256("UNPAUSE_BLOB_SUBMISSION_ROLE"); - bytes32 public constant PAUSE_FINALIZE_WITHPROOF_ROLE = keccak256("PAUSE_FINALIZE_WITHPROOF_ROLE"); - bytes32 public constant UNPAUSE_FINALIZE_WITHPROOF_ROLE = keccak256("UNPAUSE_FINALIZE_WITHPROOF_ROLE"); + bytes32 public constant PAUSE_FINALIZATION_ROLE = keccak256("PAUSE_FINALIZATION_ROLE"); + bytes32 public constant UNPAUSE_FINALIZATION_ROLE = keccak256("UNPAUSE_FINALIZATION_ROLE"); } diff --git a/contracts/contracts/test-contracts/LineaRollupFlattened.sol b/contracts/contracts/test-contracts/LineaRollupV5.sol similarity index 99% rename from contracts/contracts/test-contracts/LineaRollupFlattened.sol rename to contracts/contracts/test-contracts/LineaRollupV5.sol index 49ad01103..9608d4184 100644 --- a/contracts/contracts/test-contracts/LineaRollupFlattened.sol +++ b/contracts/contracts/test-contracts/LineaRollupV5.sol @@ -1346,7 +1346,7 @@ abstract contract AccessControlUpgradeable is uint256[49] private __gap; } -// File contracts/interfaces/l1/ILineaRollupFlattened.sol +// File contracts/interfaces/l1/ILineaRollupV5.sol // Original license: SPDX_License_Identifier: Apache-2.0 pragma solidity 0.8.24; @@ -1356,7 +1356,7 @@ pragma solidity 0.8.24; * @author ConsenSys Software Inc. * @custom:security-contact security-report@linea.build */ -interface ILineaRollupFlattened { +interface ILineaRollupV5 { /** * @notice Supporting data for compressed calldata submission including compressed data. * @dev finalStateRootHash is used to set state root at the end of the data. @@ -3094,7 +3094,7 @@ abstract contract ZkEvmV2 is Initializable, AccessControlUpgradeable, L1MessageS } } -// File contracts/LineaRollupFlattened.sol +// File contracts/LineaRollupV5.sol // Original license: SPDX_License_Identifier: AGPL-3.0 pragma solidity 0.8.24; @@ -3104,7 +3104,7 @@ pragma solidity 0.8.24; * @author ConsenSys Software Inc. * @custom:security-contact security-report@linea.build */ -contract LineaRollupFlattened is AccessControlUpgradeable, ZkEvmV2, L1MessageService, ILineaRollupFlattened { +contract LineaRollupV5 is AccessControlUpgradeable, ZkEvmV2, L1MessageService, ILineaRollupV5 { using Utils for *; bytes32 public constant VERIFIER_SETTER_ROLE = keccak256("VERIFIER_SETTER_ROLE"); @@ -3699,7 +3699,7 @@ contract LineaRollupFlattened is AccessControlUpgradeable, ZkEvmV2, L1MessageSer revert BytesLengthNotMultipleOf32(); } - bytes4 errorSelector = ILineaRollupFlattened.FirstByteIsNotZero.selector; + bytes4 errorSelector = ILineaRollupV5.FirstByteIsNotZero.selector; assembly { for { let i := _data.length diff --git a/contracts/deploy/03_deploy_LineaRollupAlphaV3.ts b/contracts/deploy/03_deploy_LineaRollupV5.ts similarity index 87% rename from contracts/deploy/03_deploy_LineaRollupAlphaV3.ts rename to contracts/deploy/03_deploy_LineaRollupV5.ts index b8208369b..9073be38f 100644 --- a/contracts/deploy/03_deploy_LineaRollupAlphaV3.ts +++ b/contracts/deploy/03_deploy_LineaRollupV5.ts @@ -1,20 +1,19 @@ import { DeployFunction } from "hardhat-deploy/types"; import { HardhatRuntimeEnvironment } from "hardhat/types"; -import { LineaRollupAlphaV3__factory } from "../typechain-types"; +import { deployUpgradableFromFactory } from "../scripts/hardhat/utils"; import { - tryVerifyContract, - deployUpgradableContractWithProxyAdmin, getDeployedContractAddress, + getRequiredEnvVar, tryStoreAddress, + tryVerifyContract, validateDeployBranchAndTags, - getRequiredEnvVar, -} from "../common/helpers"; +} from "contracts/common/helpers"; const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { const { deployments } = hre; validateDeployBranchAndTags(hre.network.name); - const contractName = "LineaRollupAlphaV3"; + const contractName = "LineaRollupV5"; const verifierName = "PlonkVerifier"; const existingContractAddress = await getDeployedContractAddress(contractName, deployments); let verifierAddress = await getDeployedContractAddress(verifierName, deployments); @@ -45,12 +44,9 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { } else { console.log(`Deploying new version, NB: ${existingContractAddress} will be overwritten if env SAVE_ADDRESS=true.`); } - - const [deployer] = await hre.ethers.getSigners(); - - const contract = await deployUpgradableContractWithProxyAdmin(new LineaRollupAlphaV3__factory(), deployer, { - functionName: "initialize", - args: [ + const contract = await deployUpgradableFromFactory( + "LineaRollupV5", + [ LineaRollup_initialStateRootHash, LineaRollup_initialL2BlockNumber, verifierAddress, @@ -60,7 +56,11 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { LineaRollup_rateLimitAmountInWei, LineaRollup_genesisTimestamp, ], - }); + { + initializer: "initialize(bytes32,uint256,address,address,address[],uint256,uint256,uint256)", + unsafeAllow: ["constructor"], + }, + ); const contractAddress = await contract.getAddress(); const txReceipt = await contract.deploymentTransaction()?.wait(); @@ -76,4 +76,4 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { }; export default func; -func.tags = ["LineaRollupAlphaV3"]; +func.tags = ["LineaRollupV5"]; diff --git a/contracts/scripts/testEIP4844/SixInOne/aggregatedProof-1-206.json b/contracts/scripts/testEIP4844/SixInOne/aggregatedProof-1-206.json index a398f448d..400892e28 100644 --- a/contracts/scripts/testEIP4844/SixInOne/aggregatedProof-1-206.json +++ b/contracts/scripts/testEIP4844/SixInOne/aggregatedProof-1-206.json @@ -1 +1,29 @@ -{"aggregatedProof":"0x2fc9952c350bddaa650bb15052d8f95f7772c815930e7386a0a03deb0644d3b1079a2f36d960ea7cc807305bb81c629c2834deb1f178e750f2bab76feccd0ff01060cc6fe67165db076b4586f4f53712dc098652f69366fc4755740114a9965f1effe8d37bb54b3271bd2ddff55da7b79ed8544edb4b582ec6359fb3b445cf630a3e9022ec821960c8dd967001d05692823dc0e8940b22b3ff4f15be6cee8ebb1a96cd29a3200f9c22b38078fd5ab989b07fe1daaf6b061df62eb971f98bd0df254f1d5e9e9c219c02cda2f6af61358d690ec580e882147ca31a239a7a91a5022296ebd064299e3d1832a97780233d1d4e8741fbefec13db11498baf1975078a0f7f07fdec3c8bf59a02d0063fc1004f91c9ee9ebfc3fc398f7ce15e1bd93bd315985a58ec46e1f796f29c02bbbc5c0beff74746d3994811cee16b3ef530c3661017386f414e6bb7b72bca872691f7f9aa8d58beea238d5ca417b5c3e22f28c821b8a45ec2baf6876df001c6f89e86fc50a90c8c0218faaeb71750724506231f08cdce918b401871e6df2cdcdf88d3de0b28774b115ff5afb94f048815a5942108fe606ffa02373f3db7db56fac81fa1a81e78e16061c8fe7aa696d2bb3bb7d22921cfa38752132a8ae10823d6bbad8d8d8f3fb866a5aa14b9a9c6872cc3cdfb08fae4e751f73655fe3dfb365350925f888b45c0e6b687072295708d14fe14260fc439cc106f4abad7aee7a4f48f4d7902389d88f48baf8014482268848597180a8c0f9e65c1b7e89a68e0875f6f67bc887f2164e9a865cc2f8376cc0c879ef71f445304064673b569b968e9e101ce6836b53fc143535a4d5f0eab76dcc9fb741f681a34f38027207c478f8e69119d2ae44206218472601cfa8fddb2a7ea7afe1d2673be71e76d61653d47e9c7654995f823a8417477ee797dba72a4373360a325807176d33bb83675547ddff69399945259258658d6bcf75d4afef0387947c80b8d250cf17d3d938468ee61a4527a9bfd0a970f01134e198668a208629f150c294781fca3234d8a85370c1ce2bf16d2e129a9d8222afe7a4c80653c962885180ed12192c999f2abe229fef1600942ba39442702f3a87e212e81d22d434d6e97097d6a6bc09b2cd4f9562ffb1ca398d50dc881369634c2c3a4326e1768e79ca0156e74c9d0cd535050fbeaf4a029fc7b6faf8c00c59acd114295d2cf2fef4068","aggregatedProverVersion":"test","aggregatedVerifierIndex":0,"aggregatedProofPublicInput":"0x2c35ea1b78b59a5fac9a23a9071d617072de788f3e217828b89af03b4d890046","dataHashes":["0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95","0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618","0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487","0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088","0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1","0x017207990658280f269f538918209b2ab0f4e70c4b222aa8067ed327caf3c762"],"dataParentHash":"0x0000000000000000000000000000000000000000000000000000000000000000","parentStateRootHash":"0x072ead6777750dc20232d1cee8dc9a395c2d350df4bbaa5096c6f59b214dcecd","parentAggregationLastBlockTimestamp":1683325137,"lastFinalizedBlockNumber":0,"finalTimestamp":1683335137,"finalBlockNumber":206,"l1RollingHash":"0xdc8e70637c1048e1e0406c4ed6fab51a7489ccb52f37ddd2c135cb1aa18ec697","l1RollingHashMessageNumber":1,"l2MerkleRoots":["0xff0e2ae07c9c972f7ac6ab579a49376381d56f8101b37142cc52a4abef5cfb86"],"l2MerkleTreesDepth":5,"l2MessagingBlocksOffsets":"0x00000000000000000000000fffff"} +{ + "finalShnarf": "0x96ed18f2706ace8f30f5535d286087d34d1cc04a1e03b4100e24c209de5dcd6f", + "parentAggregationFinalShnarf": "0x47452a1b9ebadfe02bdd02f580fa1eba17680d57eec968a591644d05d78ee84f", + "aggregatedProof": "0x051bed77f58484470b119a8b017de47539026b71e9d5093b207264daa840556c0f2eb7584efe5084afa69e275af231e73354d204138d4dd05982a2edd42352aa2bd18d16c2dcb695ef4173fbcf52949a940f859b571740f1b3a569c8f4d28f9b0cd796d579aa427a4e606aa4c8251c335beb0ee3211c406d4661a0e2bfc5981c1ba391882dca92b4804cb8077e2e960758760ab0d51c0b350eea3f968ddc71fe22c1d477aa22ff16cead741b7717237b37e3d635226c331a9f28ff1def6ed5692a8556af2536b8be72ec1524d252527639b3f572bf55e1032247ca4ba45fc47201f12306560cbd848fa7c53d017268241483bd13488ce122c9b62d9577245e401ac5aa15d193ff32e07684314f9077df50be46d724639289d362c84e0a330bd0286f2eace37392c4472ba884eebc909c9227bdf7e3779c7198a1bef376a21d42023ef79eb682b7e235949451bef1a08073407ab40c83a9a9509a15b44e6ca0de096de86c2eb9d4af577ca0c33b7c1380df9a69ff910841d6069ef7ffbf77b0f515afe5c15ad24ed86a5bdae413038979cf9568aa73925b03369ac03ba6522f5f2d7d6ff97710e76cf174fbaaaf078142f157d6db3223ac61ecb429073050b5f316d182360128f596809533576ee686595968eff44165e9d7925095db5c91b61f1ff1ca8f5f1c58244d03873dbe8e42e66924d26b1cd9a3d121dd1f1d7f30df8c0e96cc051ccf6b5beb32894d4a6ade8658b26a25fe1c4ecf28149818ff92a9d70c3a34125dc3b177b9e3a16d9294bc4596ff26a28dfc838c5f85955a468c704026508167c976af9d0cc153733b3e068525abcef8aaf2fc9fc043766e122aec6c070a6bef078a1150755de8544b69d8c1b47bf67023dcc0b9cf0d9e51ae85773d1ab5ff6ffd5c36c0589ea1aa5916977c0fc3620921e440919c7523e4e8fe042e2a2a8389fad3f6a6d0f56e3861d3c6a6944c3f6450fa641307c71d89854d773721c9bb944424e819aff3502826ea9959b9d1bcb4447f0bd5ebddf517eb60a2c72055b32988d292cae0dcceb228a7b6148fcf3a172d9fb5a9ac6400f7c51138682b00069832b273928d0d171a0cf165a01565a12cb03039dfc65eb5b330402a212d2c86751d05ad8ca23ff22659f417d62bb2a5eac28d677b36b8d7197fe51d691e8e8febe9243b14274cf645a2ae19c77d141adb91acb63cc1b4761b3016a3be", + "aggregatedProverVersion": "test", + "aggregatedVerifierIndex": 1, + "aggregatedProofPublicInput": "0x1d2b9051238709f6f992a6bce6b5102a7182a6b9db4100ce46a9fe26f92dde78", + "dataHashes": [ + "0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95", + "0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618", + "0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487", + "0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088", + "0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1", + "0x017207990658280f269f538918209b2ab0f4e70c4b222aa8067ed327caf3c762" + ], + "dataParentHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "parentStateRootHash": "0x072ead6777750dc20232d1cee8dc9a395c2d350df4bbaa5096c6f59b214dcecd", + "parentAggregationLastBlockTimestamp": 1683325137, + "lastFinalizedBlockNumber": 0, + "finalTimestamp": 1683335137, + "finalBlockNumber": 206, + "l1RollingHash": "0xdc8e70637c1048e1e0406c4ed6fab51a7489ccb52f37ddd2c135cb1aa18ec697", + "l1RollingHashMessageNumber": 1, + "l2MerkleRoots": [ + "0xff0e2ae07c9c972f7ac6ab579a49376381d56f8101b37142cc52a4abef5cfb86" + ], + "l2MerkleTreesDepth": 5, + "l2MessagingBlocksOffsets": "0x00000000000000000000000fffff" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-1-46.json b/contracts/scripts/testEIP4844/SixInOne/blocks-1-46.json index 2c4b2f34e..7af4e0c7e 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-1-46.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-1-46.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95","compressedData":"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","commitment":"0xb47a63ea0b1ca02698cf24a2880d2ec8258919a455f0dabf0441e2fb5b0309198615462ff913ea0e5604ac936fbd6be9","kzgProofContract":"0x976762978c83e8961c073273188fb1fa09a3df2807ea1470512657c4b3975548d0c4594596e7aa532401b0db202e3c2f","kzgProofSidecar":"0xab1b3b551d211307161b24b32564e95d39d8ca5251d6e5fdf8b1f5d2bd0e4603c9220609a29fd08ee6c58bdf6bc801d3","expectedX":"0x82694df01c377652b4d9b8950df372a64984525aadad26eb99039b159a1da598","expectedY":"0x6463a429317dbce6c608a2fab6e847bf1848ed55a8ec444a132df5b48ac2759e","snarkHash":"0x0ee930c261bcc88a1640443180b686ca58f2fdcf283a4c38c0dfcfa115a2dd2c","conflationOrder":{"startingBlockNumber":1,"upperBoundaries":[12,23,29,37,46]},"parentStateRootHash":"0x072ead6777750dc20232d1cee8dc9a395c2d350df4bbaa5096c6f59b214dcecd","finalStateRootHash":"0xea09456033a79b5f8b369a95cce74d3dbe34fdd6415bff1a417ff8a8fa0cffd3","parentDataHash":"0x0000000000000000000000000000000000000000000000000000000000000000","expectedShnarf":"0x3c5b711ffc8d48fd2db968d678f48c3892bb0bd8fb0ad74e14c98a119688a18d","prevShnarf":"0x47452a1b9ebadfe02bdd02f580fa1eba17680d57eec968a591644d05d78ee84f"} +{ + "eip4844Enabled": true, + "dataHash": "0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95", + "compressedData": "AJT9wvov/MBB0/8SBFtzyG5P+V/2YqXu6Cq99EotC3UAGA2vSKee4LENOUZRhQ/UoXiJLuKF7OFRFFV4CHXWTgDT0NDea/j5tEzoX/BExrH4O46IO7+FequZxbJSx0KcAPOorree+Fb2WcGPDc7Md8deeoG/3idfZ8/iQs88w1QA7eLWvsxOo65eiFJqn0pXi8ue8tSmUxR2jW0pl2HqngBapq7D/HjGquCBrIEgxyDvzWzqhLaSXmB74GNxb5bdANAddQRcPwAPinlrzmxRLDgBqsru361bUGZk6MDkp3EA4Li3wZZdkYElG3ycnKUgWvwWojai783S0S0qedB0qAAK6UOesNauyggjrgLWfYZqwsT+SnJQU9oRm51PUVFAANcjnEC0WsOVDZQfxP4cDLlq0yLWIoIpX7/hHiakMwcAtcFETDo00ypcSn/76NGB9+07jP6QT5P48G0pvNnthAAYLgRkEPRLxLDz8DoNBoIKMPJX+BFBMGeKwEWGwePJACyLgFXEZtiGRB0lmQbWms2JS5aK6fDrnZZc5qRpPE4AiBUBt9mEa2brArV+XNp7bLpokdYWvWhsN7g0YTrIugAsAI/+aINSc0rk4/Ehes1fgycIFDAYZ7XQZxGyOAAcAFeydxnOPzGI3+V97r9vgllaEPe7ViygTVw9J5QpWMYAMmJnBknzvJfZojFnNe3mgqXf5vGgEfvJitD755AAPADo6ZZ3A69mXp9yQH9LA9T9tHSq/ooNPgUV3UZQz1EXAIEki8t/lp5AC2xbEndoscQS+umM9XYxzzcDO0tKun0A0xm6FHJJyQiscNHEBtreDoKOtroNyqiChVQ+ECE8ZADIYDtYYCNmcLq8rQvX9MQZDjI2I6ho0erhdp9AomYxABs71SFWBdIIb+rUmaxjpGU9Eig9VgGcN5WpihJtCc8A42zcyTeIpUCfi25Cwt2DqkZhGFKtC1Aod1x3FpC2hQAFs3ckHnOog913r/AwLG2oZlxCNB3aStrqWVqxiV+WAEid0s60nCR0MDy7RMK5QwPbZiycZrh4KQUZDx4WNbYANIeNPyRvrfzjROdO+BMJD4AwvNUlrBBlP/GC4AEg9wD3lvoPwWunu5C+KjPofD1gq2KEcaQgg0ODZhgBuwv9AGwUAHHbHrL3oYGU8aBFqUwHiDXHXf8vPoNhgLqtnpUAqEDcdMTcJJj4wgGuwlSg42R2su6xJP3Gr8G32AnF4ABeDoRar5tsOVfpWrSqjhB824c/LaxSfxbE1ayHYHaKAF5GacuEDCUxf5o2h3TlBjQa+0ZQPijpLlG9f31LU7kAPVb5ueyZGsKp2bxF/2S7K/FNQFGnYEsoutRNmL/jDgDrwH+kX2KqvjlcyU+goPJGtdKLLj9t6ymQGHBY5L/SAGQGU/w4owsPgyMalltBOw8mkn4NAy6DC3Mr3rMJTLEA+m3snwY3XqJf5XwoU+oJMgrIgDl26sqglcAvhp/X3AAHJHWUDDdR1WKDxJ4v79Qd9na9y1hVoEcO/S2renLMAF85/37qD0M6n+e2pnW8KsUM0hjACeIfkQ+d2wmg0FkAzX0splojSd96hn2+3YHp1IkWGcg8Qolc4bZxy3pLygCRMKsd1MwtgUehWVBWtV+So1XbdlrcjT34jrk9Un9/AMhpp1cDuobUs2EQ6aBEWTyWaBXRU2ZTh9w45QfnRY0A5rDwQDXvlBmIPgPAji11OwjJCQqr8XX9tj6M+aXweAAEx0HBlRV2JkAdlJ6qbb0E163ldJ6rVHC/XpwYzHndAOEu/lZOy4pAGeHEHy2CF8DDpDcSriJvzndmMa4ZsyYAEaKEdBvgH7Tzrvxd75aOtszrhgSGS0ua03PLrBDqfgBbKUqKeQaRqlJG5v+P0Lf7m5pqlY6/KOxej6pjSnUqAHHAvAxjcATO4mLO8S589tnNd3JRPb1GYXagerfE9GUACXR3ecMUleaJtl9VewpK9lNYgLglU9Em/3ITVCkFWgB0lZkzPpZVtDqjZyi7Y70oZCdEG6qfMF1cJeBSKbszAH6DdbfEXh6gRh0zPDxyX3RntEG30PXoAkK3pKGO2ugA8mKhDTP8DX2aCkY08HvqXFoAIS+8WRvd/ruUM09KLQCGc9Jirauqgpg7lJZfVcuSjGg/R0LBIJm3Mr0DY5wZAHUtg3UYJDt01nMBJF7+VmHqoEKJF/VaWMwz2yhNHywABfH9e2YCmA8G0QcjC/MQtIz2KUIBfdZoDrOrEzEOygCBr7PFthnlzgaC0N/B+t45KBeancKM0XC1tVROf5tjAD2jdK+ijhR43Fwpl6mDR+wecVFOsmgiFi3Hw5kv1B8ALMwm5V572PP6NyFfd0tSFrW4crbCOI3ZUBYOP/o78AA8Q4ZVu1yMdoqzOuLuOSGGdACGZeIKOs34Sr7zXKvMAJFYwIU/1b+pVCJhOfxExPUGblHbcrcz6f+xfL+eZUkAB9eJZzfNkHgct3JlAshBcspZaP/JvdBIDnzm4l99CwC+h0KTGMhQOGeboGW8n9/64/qEhvzv3YLOCa+epaZIAOBrp2dAPQt4irCuniPB94kfjAAHDU71QWvx1ZisXrUA8ROX8Gfr0eSR1fz2GrXuKrgvt3etU4z8EXw8UNKz+QA9VXcMhXM3jyujQ4TME9wcKzyTo0u7cNtoKfLFi+0cAPj3orpBCnDQrUkGA1W53rlwEjRWA9nQ0dyw3p/M0iAAa2OjMWIG5og5gCunwwyj+N1qW4/DuhYOkYOAV6haRwBTMPiC5k27EoAMU+9tvi6FLOYLuwnELlxYqfYsWQTWALywo1jW4TLnfdm3uYk+hk5trBqsuIe9AwHoo5E6rHQA0tmm9u4rVJOssDmsKEXrDvou3Qo8+WupetcdrgBVYACiogB6D6BIY8tpRp+Uo26JHjmty8ybXjTKKBPR10NaAPysdqiWVDx9zW7QRgEfMwvM6EgNNCaOZyQCceNN2RMA/eFkoeAUyRfei9RxuOcLd3cLBWgCMms4P246EV7JXAABx3kyHTkaFDDaUo0s8Dtwb50SVJaQm6jueATBmEwsALaJtTPdxodWWvVp/Gc3nqyyRjnsencqF04gWY9nvLUAZm7vzeDKhyet+rJXQoqPMqjLhGz/5Tot4TW0/i8NaQArxucHwK9pF4gQynn0LnhAIUx4Rgarm18h806droNaAKgB8HvpjJInPsZEf1fniRhyXy9Y/Z0EBxRMzipefWsArhucUGeJDgV0b1P1Z9RWbEHbwToJMoj10OYAHXCQbQB4nms69mWpErj7v3j2hh1ttDhnlyPz8cVzHv5ozhlDAL2L4wis1EQw9n37av31InuP8Q2Hz37rDrwDHfkcvEUAxmd6lzERK2rpheDFRtCjjeE9fnCeMSiJicdsvZDSaAA18NJB929AS1R9xF49YOShXABuTkuGJmpglSmI9rFPABGSnuWbIFPPVgTfCWhmNPI2rBQWJmQL4J1M+ae2yTAAlWrv71tinsy6dZeyb+KOwK6j9DLVJgI6sWKJANZZ4ABFFka6+7xtFHOEkQj5o9Q6iw+3Jl9vDdRYf1iQG7SjADxcyFgfuCsboUqvEapMOEOzbKkTp7hoN5ftpbaQFH4A5X1vjwW9JS7C4c8oHU+Jddz/Ia/kEZmXeWqIP7EeWQAwXEk4ImjovWHkGfJtFW7elZg+ZPN5Klgmov46chUiALE2DXl3CZidLJOYIHuxdfAei+oyqPzjwfBin+YI+egAT8OSGHIMS7GIgqTciJULmWGJqSb71nCBNL+W/gzOEgBoSY+/nzJCqooxfOO09f1ED2wQjeOVhKujNMeF+I0WADYfBG0x363nTUGT0Ufux5DSWzIkCctB2w1WZMcFsVcAOCUpJaAjqtXnKzpMeSsKp1l02KbEamrReCLVFJTrWQBj1ib7LvpiDqQ90TRYIm0iLiK0RZ/vf/8361C2z+SnANW+pv7G5fQCEPOdw5hNSWDO6CrQCmM94HVtE3f9KqQA918kv2L1Nz6RXEolYBIQkQJ9BiO1yyUdPSwBlcCxiwDbENu4F8jjb7DeWrGOrQ7VlyFzuE1gonXuPm9cDCpkAOd6ZmDO9YQRBR39xa+JwaAUawWaCJy+DKPDc4NfaIUACvbCkKwe9EEC4oxesHNTCM9ffO7bscpqaS40xYi1lgCRQX784TokXpLTcL/nXwu4XVqFu0aVeL6DRBQBUhgVAKLwsAvjnclKIGtVAASXUm+u1GN0t4plWOUk6BAPHlQA/ql2QVXtdwZ+YNbC72jGuT7Raw85KJw2oy08w7neDQC/XZItAtlpx0/crYIMmTKcNkvstmtJ1uxaK2r/ktQ/AFZQqeEDZ7Sx9mSFIVhxVHXR5Xd+7JF14cp1mV4hEvcAF6z66x5vNEXxyjbYwD7weJDUswn+9wGv0Vk3eIkO5AC5j3tA20ChfvSDVMlEtbE7H2XiRop8UODyudwuOfKIALX4tiixozSU1s0xqV8m28Ox0o4B8M55WNX/Wekqc0IAtKeSdWjRNGduIEirCYYqEZFqtbEAlZNmPxfcAwbBsQBuHffad9p0pSWqOmIngZc3QjtNPRzrivqsz/VmDDsrALDqhbTzN0ylkygIc0cG+L4N/R8YhxLdtw0F4XezdLQAIGthjUSkLepQ17eNy1UyYFdW8cNH/ZVZOyKPigw7zQDWmfcuMW/S1pCh52NsYfxKmb0+xzNdco5DayGVSm/VAFfRw1FIc8bUdHgq9WLiN9pU7hqxhBSx0kWVUj2dAHUAdX9U1RTg39UY5XGOtBVTDJTXv9MudkWsbpmx+SjGgwDv7mozMnnAwQNY9ALCCDSbozuvsFgxw6bmOI+pRTg9AO/TkEI0/8RPyVKrr04FSMkdohVVgJzQyBp5uypyZpwAFl6kr18vvPLn9jjP3NhxylJFAFlwMDaayTCjCM4ZWQAiSIO/AGCUBnKFljXJDV5Ke0tzLONv7SgfJBDdsZq/AEpeM/Vfmh221G0aMlCvUmC+VEIruRs8CCaoihj4jHkAy+3xQH0Lv6xIBDj5DG+S+iEkmzarblnANQzdt/OlDQCX0Z3gVPwSrPNjRNA85Vd1pcQ1C5psnz9pdW38lrT0APvG8f+eIuLJbY/SNXJnh0wVWRCA0nS15ZAIeEg3+tsA9zAf0JhKiEeZ1hqDuL16PPHJdPKVj4GlTqgOvgUubgBS8b/IPm0lTz9ANNTo8QRZsV8RG7MXyFLtRUhupfc+ADk6MT+eRwxn0E0gvM8rKYZB0nFvvRgSTuRgOo9rfD8AL5CM52TkCJ6NTxVMkkCld31Gf4RyN3UQEi9Bzp7A+QC1Nxx0vp4mnvthhTvXi8JTwJfjgV3tZ/b2dNL8HnpNAAiH6xKP/2SKPgmlqppnJj8NrVaTeCFYaXuZBPRBIHIAb9H/UY/UweGDaYia/vw8FNNHEJRHQXwXTTITIldABwAtRoFB4bR5JFPxOId2KQebE1IC9zyGHkQsM/bJzLPDAClIWVj7bUmGk17lqekSIYJZz31hKi158x42JpFO4uwAlRYsgB49W0WAysldLu0PSDpY0WxOfR3g8bon1gT2dQDC39FnAzKrcDU1WXUn7x4+fweSpw5nErvaWOBwnDvYAC6kyXf6IfueRN3nt+L6udjZvfRtQpqhr2+Dy6PFtyMAPIZXVY7qpXA61GVf3JzSzx7fuyRXlmmgwQAVb/gQtgDC17I6gP1P9e3wzzSNIUwDRGPyJozPFfbjw0y6a/4fAHuRZ7fXzd4jWGvmhdjDjI73Z/AQ0DK9Sk6P+BVBrf0AZay29+EkObmiILWK8WYdL07Q/7JfqkPNkVkdzSR1YQCqHgFJ8Ly3C8QyNhXImBmIlIvV97CkvVzbPa9amEGpACfc7Kl3Q0Kv4NvzuQOioBpkmNmALbRDpDVLtaYVh6kAlGo/sZ4Q3w12fxppIAg35RfSIXmTTVun3LP6rjHXqAD+6Xm5/IBGfVpqZe28yFkuaPu1ICogU7q6qM7evgOmAM/nLBZpCnC9FtbaJK99MPEmC0NUGYJ41QzHE/iiUiYAC6VGj6aM3bpcXwb4/CS82sFI4vR/hH1Mg/t7QAmoSACv7VJ4n70MDQalYuttniPrd0n+RHB9S8HX4IYjHDsPAA5gBZuGRUk1d9kF/rB6eMdUMHbWmj9Tr7KbGoYS6pQAZxRGQuiPS3bNq/p6nIKHZQgfnJfDwiB/GtJNIx/CQgBKBfUilMq4EQX5zIRQQRWPDjXzpnZcbGzYOXkGCAEhAAbjBF+jl2rs6m1asBAT2lcYcE4aqyHyazzqyuklGfEACoTBBoTLCOTiAzfykset1AzzOzRiPMUuJcIhBzmLnQDJVYbmXDIy9u61bMqGJb2e/lFW83Wn1HIg7FbIVrGWAJ8yRIhtE5SmWOeYs8nM6EtbeaRMASdJUFCqSSvvKWwAbEW41D2BDws566Ct919IqvEMF882pALhVPkU6Q7VVwBFfaUp53P8DDE21FWqjcngbdYKDvXItzn+bl8CPVUmAGNYgEVZIFWTAjkCQYblSEdY9O2ca0Z4KKI/+jcXjkMAZbkPNay89KbiQzXdCHse2WOWPkvD+DOq3L4l85Eb+AAf+jz979CyG8y5GWayT4E+Zua4g0D0N2zJaxNGGqOEAKDaPV968cyBE2z2StDb5u2dXt25GQ9LoUgLLX/tqN4AVryaa7gVwhJiV1UITjEj4Vc53pfTrKxHgLKDb3pIzQDQVATPrQPMZmkF7AJrnmqUqVPy1PgWcpnSp6LdrYq2ACbmvi7KOuzrNA/XO/wJeGhoa3cnHw9i+zjjVVVeUyUAWHhEg1pn/+cdc5du7/k102u/JDqZu25Vujpu3k0upAB0pkUOR/Xw1i5RLR44hxFY8hnBSqxJNTfcB/CHwWNNAJ7cCrMl/wPiYVIGLL8hNEqLXTTOmVfFoR1ZMog6uVEA/LVy98VkXpcIzgRFR0DXuoiINQiML4NykriW1PqNGABG/aIB+7Cg2pDTlMrN90A94pYDh4pI+sNMoukwSJP2AIxrBSl1e2SkGUTUe/24xcAp6gGbyyYSh3n2e7vNbQoAL8vOIxyGUsx520N/opaUwiJPL+R0ujQgw/FIZHl73ABMmkejqeohTG1XBZ0kAeV3cIonPMHKb40bjdhozFjcAP1q9gulJ63iGhaPRN41Da5M73ThHy/Y7MnAxkMjGPoAEVd0gvynHIIb/ZVgvZ87W7OeJ+hEbUEvXsWsXRUt+QCAYurpH9nMgpLI3Uwlr9DMxwJMuzpQMyK/VYHzkJqhAPlxlrwyjo+0gL4GYIsLr9LSSsxWPsdk9f0cP7w34o8AuSXwxP7zUO0TVjxDR5kSwiCOMQ7OahJ94lDkIrr1sABxfEHFyMLIGHe3eWI7bpdcNkbo0THiRWgLlQl2wFplAHnrzOKj8jbbpuwCZhFvdG/peokOf2jR8wKG3l2GCr4AN1KwofieTGoFxP2nQuS8OP8ab//HcrJJ7JRhhNSv5gA5iuPFa03hCQI/GGp0c3RqvuNQfUfQZcjEjh6qJJe8ABhteDav4TB2UN7FI7DKx06U6aei8MM19rZjADoYIh0A0hpc22DBdhj9aK4dwJZ9e21TWG5d0jn9z6dUzHXVwABKzoacOtN/77qJYxolxZI6nGxuqggehVUrZZU4ViBgAEMN2dmPQrDSgXSnFpBfhMFl1G0XTQS+KmCdUw4BTaYAdmGg6/m2rlA+3KbXRlKbN6tQdarP/GE7a7Ir4HpYSwC9zt4uJvXUm7xrG9RGhKwII0cqOiqO+WbMt7JwqrkSANC492PCiNsMZf3X/F9UDwX58cEogKIpSAkCFehZIcIAw+u/k2QDdtSnaSW1wIwFbYcNAnnpRqnh4SFlvBqNoABxiwzfrs1G0UtweIcvaXPM3eCvyo1+/tKcbMJCxRqkANirLGtG6Dns5n6qEr8a9kwKuqmWbvED04k89QOEZHAA4WT3J5Tmlxo0LwWZjy5/b0hA6RraNmBNUa0NCJnYnwDlM7+XiH7mZWi3r6884Xy5DEbg2vK9/xmqlZuBwwTjANVvXST1D7t6VfJhsJJb/lgDH9wM1UnAYV+92N7CmhoAdB5/jyYMjf5N19qfWJCXJaMniIG1FGwLTNk+jZniPQCtdSyaVCAGwXlcAXdm3Hiroe7sgh44sDkkiP48tRNnABVOU4Ngdni5t9hoxyCen0wGmq10VskThQ04wTVS5a0ATPAPizr2kBZp27BXnXbutkKAYM6pYsd3EaNOF+634ADUYQqKGGe4Mo6qVkNHw0lwwF42qE7x63SmpAxP2WOXAPoRKRtIWaLThBtMY9YIBr9qYD8zc4m4giiv74TfesMA8WLU92ly6CyKcMWTAEamYiv6fQMULi7LMWysk+4ZEgC7b5XzP92UN4SyYgw0gRfyS0DeGJlRF27lP9pvxij8AO5zxlaRDdmSHQZnOW9NaGSnDVALtALuasr7YUJpte8AZpdC2MHAI54gjyWu+RMvmbf7ltVo45FzD0yTo3c0qQD9EZ72dIJzUwqwTwcrj7MmUkm13LGmWi+TzrhphH9dADmmjvUcxZSUlGGNxk1FcGv73SC2I/3BZW1DPB00dA8A3NNmzGu9+fRTrtzIkbFyEWOfQnqLlh/DwlBaBF/tIQC8QHdCENzSg8B1UHXlTfNCGcaRVkxttmsTB2L/d2ZuAO012AMIpbeQoOVzrZPpP05DCf8Wqy3nk1f8y53DKDwAAlVwBn/unKbLTt78rpv2ROmbQ3hRqokA8VuQg5iZ3AAgeX8DmVcZnmebcvvIa1ISZ1o8vP9Qi29BMCWLnyqcAIXiwNqMzoaQsG9mI2j4FthJ7Nx0tp89ZcNpCHRH8nAAKnW410YFvJULrpORlMLLKck1Uwe2+8Q00DQC+YKZfwC64DnZGiVzVb6Xzjfi3aSo4SavV84GRQ2yvCbZTYoMAPpQr4lF39F45liFaL5sQ0JwvUntkTqgrxh2YCCKu98AG5cq88pFoBSIpsBEK9JfQAfR7CvOdCmKKmyRYQsuHQCgvduKUw+xEWTsS3M4Vmsm+OjJqRK3SMwLtjUsYkwDAIRWvkpEhqc8lUqd2ZTDrsipWs1AFjoUtZchx0qij8cAE4zh54SGP5iIdffXDloO6J7DP4vDrh9QIdFn38AOfgCF1NtJAvEg9KZnJzUnDZLLpcSoo6NaB4Ekg3XAq8g+AIBpz2Hk35FymWjI0DWqEFbfhf5FOfra+RrXx4Bu4coAcvZS/ULNLZB8kQR9wFMA6ekaXSD+XVROxOlMHJPRIwAzruM6x4fjMsnO1BrGVqtrPhxINspn5n/K74oTcw5TAM04IBb85X3WSQ3AXXNVdWM7fPdcjpdFehz2uWfgdvEAEMMBiBqxhOGvQ8WD7hZSnfxeQe0UrWxdmJXR2Q1i4wACtqDcY5rt/bIi1FVwMA5NiSRGWGJaMbFJcvy0vqMUAPyQXTsF6T+IokM6quSoNqIE1rwBP0mkEoqpFsrRj3YAtVKG2hEfqVAZCGO+U4w91JOjKl9VHsCd9dsmJNZA/gCpfPYHRLpo7D1d+2Lvvi63c2JTHaeKbOazaP+bdpOeAFJ4uM7tHeOWDC+9f2yxdvn1s6YeJNpe1kak4sKEGbEA3lNyQFosEGyv/cyfij+DANK+0Yzy2a7wqz4CzqmEQQCVlvluJkWKgBsqucftJFlAqhWVze2clYmV0RyA4MSqAIU/Iznmm1tbxAwDkuclTWw2tYGSdAa+ddhb/WII63cADpt9umXr5HQ/PFNKB0rLHNJPIYmwWEIGTvXf4ml5oQAK4C6xDYFAGwsbGrc+D9SJwOohxV8qWJDoJ/6winHvAByZM/zKljHeAiqxw4KqinbbwgBM4+G3zneSta7/M4sAoFyunJkWWXP93+Ix38kHSKjJR6IGwLbF0j9vPwQeBQC998IRMYbF/P8mo53xfpCny6yj/B0fHoe7jD82IDm0ALRRQr/xgAgcFsBZax89PdhyOYnwCVFFd8IG8qGAT9EAdfQMyAUVqlOQQOU+8Z7bYXYs+W0OCKQw2fpxZjkAeQCECTWrSzWprlzhUfvZY7/GPfADXA9FdPycMcYqIQy3AFy6pwSUDARGJccH0wrAcgdE8vP0UFY/WzER1BfqJ7wA/YTr8T/doUgXCkHs0ynMSQAqzM++6/uMIDtEzEjowADw0TptcJzAxn3/FL7Pheq+y9RPMiRmhPT1R/eGHSisABnNwMrBq0L9C7BSmkHaFeuXAN72s7LyoflQ1X9roogAgTkAT8XiPaMOg6fvFOlNSGo55VvQ/sBxNP+Zh4IYQABVbKv+EXheVaeBkBtSQWRiEe6SOUQftp0pzf25twx8ANNonke4e2b1PFvmvmldpXuQWFN7tgw4mdMXZShUvkcAPpot6oFoT7/nVmcE+C32kvSqUW3KPZTmcIJeA6NbsQBGkWyh9yfhMO1Dok1SLEniGDHcdhPN6Vt4HFqwG2xlAECuarMduFU+VUzSHaJcBE3i2zwTDrbQHrrm+yQpzBkAfs7rOt7NdJAJB73vi+DpIXYogVQDEpKBi9X1LC5GlQCqlqZ1sFmSfhAzIPMWcErgL2WyZg2xOC5vgGx4z7vaAPjTNSmQx2ZhaVdYSHaj0Uzm9wLTd8zaM5rJ7VkB7ZgAja8Nc8Ln1PWHRtb3PyUmiOFkNST7NVMnNviHRmCDzAAJSnue1YUaNOkOprluW6h9SDNJkstaOyOT6lT+Vs21AIRcK2Vu3DFeD1M5jNSt8ax3Kqu/4UT6QHALUiv2LzkApR7mb6xgHsrMdSe64pnsxojfH2YAGLqvZAG7NzdRfADy7xliRgEuO5sncsPjgQQoSlv35yGdvWiZewwIIuFAAGqLowrd7rBvufCShKRrmvAB3con6WgJMBIOMpuxhnQA15XhIAJ2jlSAv9WFnevjQ7qQ8yipfSb7/MSDzMT5GwBQ8FtJzaky8LdbXxjWiaVaUOyeB/eaXOj9e46tgZcxAKRim/SIP/BpYRCil4RLWDLyV7c7sg4jtIdLX63Tsp0AGWS3nr7JAN46pIK/dgmVZ7UOPXwo685veg3Ic9QCKACR03CzKbIjj12IJMI6onAP5QWcl6G0n0AyvDueBnZIAIbgt4bM5pQCeTQIJvT+64uHaFAqPtxMoJeQFMUV9WIANG8nd1tcJIQhnEkJ+EnwO0R5OoV+cLGpVQxZPFzwwAC70D+vqiEwKQ7Mrh3aBOkw51O5nzxzh2M8muPZDLvCAFWp4uxeZz1hR34ePdX1+mm3pvajmdiQ2oeeqkhll8gA7SLalVPZP6N0HTVGGMyakgv/BmQ9okRE5ruJ8KyniAAMrc8uyy6uOSpbm7t14gWr0OaLtJmUZTtLg7I+CQeOAGVUEzgtpPmV7yDYqMbJNNlf7DeUrNxzSa0zaa68k2IA0ev8ekij7VXESm+mC5VnjX9QiHqvwKq4q5+F0RxVegBQcFiXaJYP/1X9J865pLf1ibgya1cxdlusWahGKME1AGRJm/SBC9uJRd54ZjJRVNbSO105Fni/xFNRz7fvF1gAVaEgH4xj4qfrUMSn9VY+bhDHrMDUMuNJp3D1ksBPIgD6wfJSv4suL87hezQw3BlnXRHgXPs0Gi07vTS+P6S9AMf3Q/qwa5ADiTU8zFo+1erbgfNwbYY5uZGwz7CcqKIAMg6t6X69Zc+0ZZYGAznSmaZ0ptQGIb2rUufuSIDHgAAihJQtBY7wYZ9q7IVOhwWiz/i7JglIKcmvfk43WDEwAHXOdZiVfvQCcHaPNz9Ld2WYn2H1BOfIgeNhXUhos9UAxntWxlGxY2LisVB0NO+NF5n/t61XNnnISEpPDcrLwgBEosbA0UfuxYFQVWb/qUHrbqXlwDFy3w8GaxvxBxKhAB/FVj/axaRQCwaRgT681ohikaFZffm2MUEIax8QKHkAMLDxSMdisNa2WV1jxxd/igEOxNhLCZPzb6tgJKFxyQAGt1inIqEUN/lSS56Ok+0OoCF34KpNL5nYJpGLz5y6ADkpYFFzvMfBdLtTlTwaul4cN7YnWM1nTAcmDFanFmQArrul7D8HoXzuhdj5asHEPix3zh9s7WMVA2NN/I6lbQBoNE6QayYXvAxFKr5Zo4q2SVSUi3ytUarl/UuTR8oKADvutUAHIYe+lBT1LuhTnv7d4DHkG+7DBMrVmNpxaYwAkc/YjIAJ5hoGKoDgdho3JGekDaS8WDPZ+V4oNno2PQDRmwsjAmK7yO74YyzoWILJe/k+Brc8Gn6VQjMimUssACjPSwGM/7u38+d4LYr+aRDHxs4bMZJDkkgelaNKX2UAvma2/ZSb+Lg9v+eNEVwVmZYo7pb4ji/pBoVtqOz4MAAtfA6UFyK748t5/j3CKz2Ub35jDuFp7OnYA1HPZd7hAJAayW6s9RRGV6qf1baw5ekriFWiETloVyTUglhFI64AyhdBtgUEUiAysA1+59XUNDuoIlpzY0LjJxuKdQkgZAAOwRCI7X+hAYAPu0JZt0Iq4vlwjhcCP1jEtmU3j08RAJeIvExbdV+EkXsKy5vxwPc9zqlw1pIdw1erpA/Iz1IAIkeQ98qag6p2hMtC1j2InpuPv2uIs+/VHzFhvixvEgB4WsneqAYHFauM5ERNACwgpFjjt+Cxf3XJ7QE3Dv/2AKGXpp+KQP+EL9aLVN3JoyvVILrTWATE8wV4XUUGFsQArlowqKTJAsbq9bm/hsezMsK9wsSjjl37S2k4P8DcTADLjpkTBY1VX5dygVNK+a4qaLp4ZowlcvZQDWUJTuznAPy/8UZ3Oux8eE6A2+6zbGne8AxEC1XjXR3+ubvu4soAZcIFpC0sfXfnMUtF4N+gDOxjSElbYwJQAL1Vhfpa/QADrBjooSECTUlF2GsH+wpr/Ft/ZGqRZMxCH6qiZYbOAN54h0eqyiphJRt+Asdy6QY6JH7VsdgI4DwnWxglgk0AC+fC/o2BnqN8JLiWlNKt1HdcIOIX6QzWMCbH5+zfJAAxtqOOb5B7K/P8BETbt8aKmTwAAI8fnfFG2y9ffR4BAGRJ1Ru/P7t5OHNZ9ocCAABPB7oyQtlT5A1lJquvGIMA4mPcjUb7kOqXas6MIBHqXMn3sgykGy9oB97HYPuKHQCdJbcUGI3E7J2xgXyw/6AhylgNMT+vmd9lb7NzjdKuAGFah44NRsBaYsC2yEkiBACRsugfl70CSRUm4DoehNYAvCbWBUnWUqmzyQ2j10Pra+4+qmC95Foml024MWF79QAnoyIdeWgUxq625SPJmPXM5ySmq5krnkXldTP1eGsxAEL0FTjHFnIKZUcsT+8CX/VgfZCLaI9rBeIpfYU6rgwAR6kuirB8JgyhhTpuLwezIiwb1YpffWOYp5DD5uwn8gB4sJ+JWUt65ZKiN5dHjWX7tne6TcG7ArbXYNm7HddkAIxP8L8/4XSu5e1uE6Mzvgt1/lJk9h5Q6hCy2fnZUN0AzDqCdehDmMmV7BprpqadJgyNztnhda4SuR81jT2X8wAwB4L7PmXnVVkmFfkTRi+nXXDP5lNM0UT2DH+VHp83AOHtB/3Sh5tlI5UcYtmwMoUe/BmW9WKevYePSus0RsYAkGk+IRtUgqtbRzbRgT1hfuBRr8kGrDACbFEYIdq3dQCiWPE/OwA+ZHXk14rPeXaSCY1LFH7h5iUMnbqLfR2BAJpw3aOuKG0EIl1wHrc/XpeqvlqxdiaiF4785riAGZQAFp/7WfqClkLSPaRafYbzFW64+TTOg7bVELTNKbFWNQDK/PS0pEHBfnlcx8T0PHiopS+zS0hcLpJvkGKLAZKBAD+YmdZsYEYwUpiShlqvEjjYztBj1H3aVLjv46ZcoBkA1uwegZO7MKtLDf7qFpsN+UCXKG7d2vG58hsf27noLwBxBJcmOaMhv53ONPliD54S+8PhVx58uEUU55k3LhL9AFJmUx0NfJyoXPjy4oTCOpmoD1PJ4jtOaXv3jHG+Na8AHvTBV/g9loUP89ru8x1CZCKtgAzaWXIUgkn6PI55cQAqsj5/OLg7MBteZdU0ionaJNqy1FQkuHbzVmQW/xpnABX9GJVdiFfqLah59JBYFmu/tPfJhx7zUT0Pk1K6c7QA4+GtXJCtu3grVM4kPZdMldu/jiGSi/jpalnpAWTw7wB/m8NVihN7jKqXWJIKgxDMMEQK00c1D3GmQQxPYgSGAIhGfKpFAHqPqEW6ImPrX+zfYn5VEid4kG3mjw2zgpQA+SpokP8f3xbgobIn1+CoFE1cjLzktPgxHXEBbFpcHwBfQDQqUJdTQgofxUvCtF/PQRCIsjWPk5edMtkMwQTfAPpPrY/AXLKL4nq7lj0U75nNcE/Ksk0sNQ1E/Cm1awcAQvFZqJwhAdlN+rZWTST2L92mCZZphj2A98gVQk5tswD3ILXdpu+GZerOXHXqMLqPawxNl5U5nPtRd7hZyT2oAKT4HLG3n/S0owi0ubW2gsx3rE81sxhDzAR3K4g9PKUA6g3TLTrnghjmDcUnfkmTrRAkjanlEK53LIIc23hbPADnVkwiJYLRa0tAFv5U5ZSdW2HA0ZU8brkmGzKtleLmABASLQpSnDzB35dNByU2U0wzvhLO77E3u7yfPe+Q5lsA/r5S8CmDqm+5Pt212vRPoxJmcu/F9whIsmknlRniAQBZsmQa6LWIqZSbXGnZHx8Ph3b/2CsWN1hKVv7iq9rNACZZGzTH1lRJByrN5ZfWuxKipJCmle5QlBJd4j5UKqEAZhUrFPTL5xVst/6JmUkTDRTAV0GB356Y0R6v40k/TwCR7KHfL5EjiuHdyfbH3Sy1klTzACvthaY50NVnSb6oANsflbEzkR1ZknTg2TXn7E+fuSbAHxDV/Oc2Z2T83JgAMYH22SxLQ6d+zRv31Gjj4X6Hf7R5n674CYGKah/+sAAJe8/GqP3nb2dNKT6K6kctUhW5svp0oLSp/ByPMNzNAN1oo4vLq0DX85O+WW8yvwpTTUjQNiH4HTUO7yUaTgUAhleLpzNHirALXtZqv9B6bZWma8KHRHYAdyFL7we8sgDxaoYeOzFBNJZt7VjvUwUwFP7MYCkfaHoCvwL8UcIeAHm97W9GMShMGzOVHOt/HYlc7oHEhBE4N+uMiCjWiJMADG6GEOhsR9ExxEFFtS4exEPrZ0M540rvEH8xL+AYNADd/Uywvn+s4Sx3WgsR1ZOJi/YSNSPNBqDRTxyBSEM/AMLJsdgsk+kD2C02rCFrfnJeEa4FsToPTdeCIFyY8OMAjMbuQ0cg5Di3t3hKrYHVqj9/46Kf0el8/Xdnd82viwDeMFEXmThq67pKJV6xZND//RBIULqRsj1lh9xwqRLCAM+bBah7Wo43MLdZoCLR+rKHT40LY6t/EMGL41BlYxMAjQ9S43GIMjnQfv7c9XZWvjIu4Pe9Ba97TCaDH9xnOAC5F6haRRK1x3hRtIsaFSSFJfiXRWk3g3//kSfZezjiADaJHeEpKBYOrj6/051oCpW3Q0AjM9jo+ovfl8F9aToAArvARZYwfgLT+6QYNe+36PQ+eqKNJHK8k0TrHS0VQgBwAiO+6aVUoYSoydbBo7H9oAKf7F0FPGk4kxOCUez/AG9ZHSug8X7froXf5dVxAyzs4TfuTqN5lnSQ3oi6gmsAhuRMenwJmgbPJUYtDDm5TFWKZ+0snqtu3ywJJVXJAQAFEr2VPZLApbqDXTgdqOcJoIxt/zjoStqQC5hC8QuQAG4Tqpsd3mNQeSYQmxkSjokifWzkrvfEcxgzwPDa5rUADzNq3hb2K2FG7lKx2at81qjpQjWT34fj1B+iZFpUowD//C0Khcn1s26m1WX7XDHhAlQwvTd6dwPkBgoBhOKmAA6qTgTBLntLPFtguMGPa2Ydc80xNSql859IV3FH6LcAgkYegqH0/EEGbYs9cxdLmjK9N8GnXewAOyHCWZo/yABFRRrvfHrkBL8kh6YX07SX0g27t17npcw5Rizr34UmAEMWlTNOEE3ZYGRSiFiUCcdPA8bXCpVoSHJV3oaLUEUA4VfGjGUHhLEIXzI18WQe8bgIpaK/R+x3dcCVbE9pvgDl/E96SifVUwPEkKW5m4KK8+8XfaLaA5MXTo4/KZONAMYJpnv+hLFn3jLH0dmxinHrwgeP9uHg9RB/z4UHoGMAhYsdVFsD2+SekaVDvz64PG/SB9bcnsG7UXAOJzscMQB04ZGMaQFz867BPP816jeeHkZhckqvpS+VhzlVnh1eANuAUdcydQf1nooWKY2vyMYqVjntkWOX8Yj0LTCsJgoAnw2y1c5puT8F4CzQVi6i6+dn8p6wNohjaIFksrSDZgBRTwvLNLjNy7eUsH2AKcfCt5iDidjh0AvRoiDo/hu2AMx7lQBpgZOATBmWHRCmr/MSdpGxnnC6jLWj3b4gn4cAaw0+UCfipjJEoJiImtL+7FyP5gsTJuuqTzxFHxPOHwCYAW6KyYCs54ppNz7iuF3Olv446Uk0+c58RQ0n3uKpADOOCveFHRutN50k2iJwBjlgJu3KPdFHX54s4ptIc3QAYpPfhqLmz7ydgumkgVt9i3kMS8AUI8OeSBYVGtk9pgCy5ZQKDyfGCB5tZUdNYfQZUmHagucr1DGKaIW50SSUAJgxUPBw7PRkD0i2Jibq65n3kM5IITVcFSZSvyuhRLgAvi813y7R4DPygHhJx6r4jQ1wTcOdw6QdH925QbI5VgB1kzaNQofVxau/4YSxN1x1sYZcKnda/7ASDn61s6NBANQXqoetmo5QcmNbrr4ZRQ0mwsnuIJu/QTnucLemq/wApCtc3wacEznoEyU13jYOahGZ/G4hNY7C3WiZdw6vngCj5ucLvlcZMkvMK3AUEghO3C4ZGkE7MrtraGAADFytAKTJYuwxyZ62oTYea+1oqJSnOMOYRRRVBT2uUX8OYEAAW/7Ua2HLJdcQwTxgKtdYiKOd4Pi1GLa/56IAgYTaPgBy0ZIfd9JbBp9Ylpyd2Z2Wu54VUy5VzCwEKV6Hzr/jAELeFFFy+K59VyAcP83cYGqydgvweq5EeA44gk0fsLwAo7RHVvJZd0X97JUdpVpUoMvJDuIJ+UhJQR4OIv0ZDgCW2kjEi58yw+4/Ih62HXrR091MGrQDPYsJfnqqM6VXAJaiBE0EDfHqs5yGIh2P7DL76Ug5LYSANF23OcV3K3sAyCKUU1qC9GY8RSsiMR/AcS575uiZ8cSxfLm7CNUUDQBCSLqdxxRmxeQPoNjWC4otoKVToW2NlUicFfa5KBTVAFmbxxIL7O67C+63dUtMySyKHfyI6OBRJPDyCzjGmIEAuoe/1RVuS+mqM8N0UAsfC9hAlBnv69Yz5dTt3HqiRwCtflte5C/uZO6ZddHBjMf2eyhPOAcp3FuktzXIviLnANZ/RCJtOtekW/a42zbeRBEAF+NKFPEAYidsp6Lj2CUA0IttZKAiLfbsF1TblLPf0QJuzHxGGavfQJZC/8M4IQCvC/DaXnwc4CxSsrEi+OoixWXZf+mXBqB95y2SbBIfAFhAqsSYvrSUOLd1HOIpjxQe9ZA1PwzCJ1qqbIqGZHYAruFwUFK5KWwvzlMpnvP5LVOM93Lbwixqg7bOLHoIlwBEpLJMt8xHk4jObu33s4OVsnKnsua/8EJ59Cae2ErtAGqObjYerBxK/SHm+/HihBolYU9nFGNTxkLAOUi+uo0AhbYACcRa3v1JhHrvCqO8eMs4Vexu22pBq/trZGzs6ADzSJHpzv5KUDQ/rPHsco00ZR/klT/OPDAXGg17I1QqAOlC8Usp2BXpx/dZRcaL+igtBlnkgyuYl88pMv1g61kAdQ1forC9/t19wYPRtQVqwXwxTWaK/BBrNeLmccTq9ABlK4gxRUcaNTWv9Mc1b5aYYNXP0Ug8OQyq1kOHfZCZAH9ImYb94goKGQkForE2TdsJeZOYhayOuYZ6sryJvjgANvLDbqTgvJw+p76MIeANkLjLPXELg40eJGbB+w9KYgAK8koCozXhOpEublfNew4vey5e6ODOXmdWS104vC0wACKKTZymzMD016+hlubJZHfJcMXOOKCL5IlRYF+fKvgAQfzC1MRumdoopirixoP1+5sP8a9th28e7O3VKlxapQDI+4bPIZnTdDfalIBfr8x6djud22EIHtRYLOyweWxfAIdf9ZC0XOMuDBrnvzGRmLPooj8guvrvl+rjAjlW9XsAqteoFgRVPRaCpbvWDoEB/e9g0PnYyRdYpt/czYmLQAAu1Lzo6r1HKCsIj/hT042A4LdzUsq8eoDOIvbmvAxWADu7J/5W24lOnRA9kq6lJZioid7bHcS2BvkLdb2VtqEAc4GHZQBaoEwUGFZNs+DnmBOo3LeZqWXDeNxktXGZfQBswFu1G7iotobyevk+G5JBAlZqvCFnAlt6GZNaQoDYALr3KkPjtV/LnTXsrZAxGBI/qH6s8QXQanQaQpM6dHwA6QOM8/I5Tp8mFrG0ofdVHn/fV1T7trMQAICxgh4SMQCcbthiGJV2cxqnG6cwADA8liyoNQohn0DamN9m+O76ALGbzTAAEcJabsIzivnS2dYhIaY186qCr2GkBe1OLnsAwFdQb2flY6IP38Y9HJ5QfqDSk6qB4yozdFthDSZj1QBnDMpxMhddocOP2cK8G3wjJL9l8Hp64+pH1zGiEyD4AF66zt71ZSmyTaHL9uFvFa5wFmA3/+DPhqmBnTAfmiQACt62GDVAP2/SVt2W0QOUpVQcjGHH4AL4IXTwRY657gCs1GkDd1ivCKMqaf27SUvE70AzZn5ZP/nc7vzpiR+CAHe02g4secXLdwNGn5TWoCLUk59fmZcLTlgTMFX4xoUAOo+QDffrDexng1GZVh8ha8p52JS+hNInCMjxCr4WoQA+ZEeOzJ4GowRyyIJBjvArybc1tk0X6MHbvKOLngzpAN9E1PXJeIwIQnnWRBxUuFPpwjRUlADnnJyARD0abUkAqv3PxiHu77uER4mjsVM6u0EnSJBTWmqlfrUz+ApdZAB12MMcJ43VSSFlBB+/WEvg3bS3ocmVsiXYgqclpnT4AIK3fFkHTsbFIaRB+B4JG6HiufwhL5KXxyBs1pKmD54AMc+S8G4gvjcYwL5nh7m9mAAmzLI2gPqPQWFFkZyuTAA2+zNozJrA74fmD7YFtqc4ej7ZBrLR94tfgPfy5zPJAJ0PTTvj/t8mOCy58BuwYfeWtTgg2ta69dcWzDbOs7sA5pve4wzSPkD1a7+3WZqAvZpB0fwki/A7CMf2gKjwGQBrPcznCN6yEgU9fCYkBl1DEOoGzMQbhEoNTOCe2slQAMfQkpakFIecVNN7bK89IiAUfVRhN3mSJYv2T+Q/wmEAGEeSTlXFqW8wpyx85gTpf4AndPVnH0g3wv6qubETtQAO/q24bIXUz0SH0jpwAD8iPnG02YVeadlkLeklfkP4ALWXx7QtndEf4WjI+F+dYWtAwQ9x60Ed3EsUBPuhkjcA8Y74vF2yN7bVuMeGe4o9wve4cGeBm8qLvmkLllPvwQAD4ambxLQxyZdW6lbDqQf14lCj7ZqdOXKZhlUJH+cgAN+5DQLVw3lQiQa0WwZj9MZ9ljS55+rxoFyZvEV3hMEAlPIVmD3ZYgVjt/FcwiuEj4eJGYqLzG5FQWe4TfYqAQDFMRGQDG7vFUJvxzQQF+V7kvzzLeLlaAjfLv9CjCmjAMyhgIJkIbyExG0T4FjUWBUuLRzcQXqvL/2pUHIXUu8AL1nKqhNRykTmpZ2Ru0zQbwr5F2hnx+r2DJ5/dXH2cgCIyyylMMfE7DovYfyuJ9SU/2ATERY5JkmNR63OQXnPAHphDaTe06+a6SzN8rOZWf9jsnnS5+MAQYRIHJIYkOkAw2u6Ci2C9jctdHxtQelaXWVbwgqw+slByFSJTMDthACvVXN0tJ7XIz2clJPlwA+d6VI5wI5B3/UYpGKhZCc8ADjD+vspB8Zf5iRanKM28boDRNW85eZ3r81ntE2y7VIAozZWUEod5fEHmu2V410tbctPQ8Bh1ja3pTLMtyS5AQArAKvZTjhHu5W2JvMtcCa7ZyVbglRtTwtfoeVNnFuDABxg6z6feUXYhPxBjKNXYfalvgE+vj/uVgYVSG9q4QsAg/YxUq2v5NVYbx8r+N+CxoLTo6WQ1ILp4ZxaivqBegDnVPu82gHfRSC41nNp1lMnbFMg9SVmi6ZDVY1qzkHMAIwxPAjh2f+5/qrI1DTpArF5YGPwZyLcbJ4RG/FkMJoARVqHV6rhrh6FiKqBqVrz4rYnBKrbebRPB5CoIe900wCuZTDKKGgotcL2+7G9ASggYr/kSulD0evvSv6N8v2eAKHu4CL100hMFeBagwTErQaBfFNfzgUZQlOF+8vxxbMACov7gusBmDhE7woboqZZhnb5zqYpScsG2e5GcFsOAQDFYH80+S/ic+LjkaB9uutIbxWmLHTjKs92KnOfwjmbAJPmf3ssFbk2LibteK25pgwh7IxfJoJK3waejjmS8C0AAFEBArpDd6Qb3SoyQ60u+WKpMneuXk6jwXyDmQ4OhgDV7CTocuOXXhDdb2CD2AYFRGa5RphPZ9OCVxd2k2nyAB8J5A8I72ERnhfk8VKFWSoGCly8uSjEDzegPWf6ZIYAfR51hd1kLlsaRP21V6Y/5AoLOUuAvyTNqw0nrUAHuwCKoN41GotL8agygs3KpRjPLGPSxFtnDDpk5vo6ex5gAE59LR/qhwfu0lMeh1sZt1JeBfhY8c3wyFYi1PHEg0cA8dYJpJ3sfA3qLOhZjpxp3hbIWRK0FsfBishWcc4vlQDZwLyVGEOv/nu3PTIAtGMZEgdm7js2mW8PBfyji0jOAPJpCQixNm08E2rRMPnZ0/+rRg2yN+qIshhKL7Iyzd8AGy576YwJA5IaO8lHrxb+hyk8OJL1FWJQjuh7Cfzv1gArMrC3ZT/D1wCpOwUKoixklZDSqfelQUWfCXQ0zfgDACGn+LWPyXYPqHy9OVWK/CZYpxoW5SUFrAZbjvjhyfkATeFr+5d473mR36OIwha8f5ByDgJjlp+vsWVyanjn+wDg6yUv3CWz7OraY+oYXUaJFCyMew7XyunJhkioawdtAIms261e9OtFpssti/Dr5uQjBX92B/Zror2G+ITGjcoA7XR823Hu5qpnS+3BBl4LXVbs7L0kUwuiucws81zz0QCSrL5hNLES3KdaL/UccA+6k8Xm/j0lb6AGP+EYJBNYAEJQnqtG11EiFAA6ns0tjOXq1cMyHHZGCdwmclJr32AANowcselpF1hIeEP/zlGbmwpl1mxCqcIXdfDnw9IrEgAxOCMCd1f9qIyI8OVGbJeHXdwWk0TXK3n83yDpDgJeAKkAI/IOvsq7nT/sBpdENqPtwGCQCXfRypr+IKGHK8oA08q/Zro6fVgD+xEraYEezTsKPn4He/HzG1fBNnwdmQDTDnGTP8rXRY7en5BMe6FjoHerQHFDtYKT0/L3ghHSAC1F6/G5s68apDeoxL0eFxSEKEQkbs2YUSPecG/ysOoAksX+EQz8Sq2NZQMhjJ/PI6jTQGLOq5ksvEZjRQ93PQCnCoxKlr73KE/qXgFWWoPEg+JGaM6S8UqIwp4hPUNAAKkAHaavMnSXUM8v6kn2rsU4ENnS+n2WVxPWBgRUDEgAmR/M2UEWLQrtG7b8VwUlqqm35no12AZ89xTAkicm9wCXGBU465idmC+SD1d0t9JL+GyzfaAYYFy4MjgzeCpOAIC8tKtVG5MZQCwP8lNd0Nup44Rc8+QgdJ+k7bJNPcUA053qIGxabiWzvL8sGuYd6bwHAHh1Ic7O7lFzJTIOFgAhG7fJSRyCyCZ1nszxYOnOBzIP6fCLzPi6B3g2ofCdAMYqLuw8VwpMG3OnmOvc1DAm5Wt4FwBzdvttzqac3OQAnMoG/S12L0ntnkuhDNqaWfAzrt9DYQcZN03GHluiOQDG1xqd0JVQ4FycQXf9GRDtkFGm4vWs5hvmGAQ5aAbYADOAjRAb4pQHhMcJb8v1vRwg1Z3CejVzp/vEOPOyoDcAORSgEahNaKesg90STWn8ePbAOTGu4m6LXRWpAgVZqwCJLvdbMqLH4T0AfYGpTJiEMaVFZAY0R/91pgNDTkPRAO4+xD2h1n/bZMq3INQ71VVnOYuEq598PX1JJkjQ6CIAZCn65gWm/43CebB4lqwWicZWetjGSfg58nMj7PSR/AAsZLf5u2bXD4dtOi2mfSuizUdZoUN8K3NLM2j5K8urAHYxTb4bpnYiR249G/2WW9Hb2tqcC8G4w7li3GNBOzEACa3ZcXP2WfWSD/k1EAwrabOlxzAiE+VA5+rUZabzvQBjU30mcZs/+O4ggWP8wwwyZcyr+7qBwNALgzcVYfIhAPJ4spUeCzbAJytZRA53m4P5LqCWRZ3IBDiPItcJpNIAxO7QnJcZd6po6Mx56erch5XCOjGlK3mryhegEH7evwDVfKcK9u3T97xKWYuvACunZkAK/Z5KXtfxneERE4S3AFalaM+mBc0LkrHr/gC56v8iILYS7l76UEn6Ga0JFrsAUI/MAcga1nPk6vgkb3zL+jcJZXY4EI5riwbYI6SohgCNN7Rq0FCSv63+HzVmBSMVYc3wnNwHmluKXRAymLyqAALh5Dn0/s9DVb3c05IcrNJBTJjIaNrjZkd0MMIAV84A7XZLFB9QouM9VhycxPyXJhVpwnzOmbujNJ9xIVjRnwD901//8/iBwPPrvjRIlZ+Mns6I3GPJ6Jpq0uIpnotYAG63FFcHuM7zMTfOtDyQcNucJG/e2s0rnUke+a4usysAc10eMH0QcqNZ/5Mks+HTh8QF2Sg6Swkq+vjsvLuCNwBdOPfoI1k/IjETxs8sa920/HpGrgZ0Za5lImuvcRBhAKU/k6SchBILqvMEIqeGz+jNl+Hnf9vm38BUHrMToyQAqxYJWRyl0j8mWcMl0rPnKhM2Y2dGx7VGXDq8uAX44QDNPNRALzxTjiB+bQj9GbtNXlh0sBUW39otLfqHc51mAIvbESOLaJno4geIdbpRCOP5MvHHuOx+59PXgf5l5N4AgYYo/Ihk16e6Mo6RqGKUwt6qBbWwaa37X/Vz4Ec4gQDTW3jXs5u4Ize8tGTMrewtN1gM1mi29kDUkxv4yb+NAPcQRAU2fCLxLCEikqitpz1Au04o9/J7nADNxYcpxxkA2DVtzcIhDpkfV0AR9WPZbTWBV62RQSYBUY0Xi9udqgCesZsdz7bCJpElUFPa5/yQUH3xSUvaVeXDccOc1L66AOemVcoGrwXimqrLmIDWiEdlTebrISD13gZ0Mgsjm7kAd+V6dJhbwZvifnMDftsk3o6ZMQh4Uy1mukJMGUxzWAC1h7Z6o228zn8xJ5EiCEt6Rqef9qw6Nts3/VBCIDw7ALoFcKXLwHI5enLRG4DIgFR6Rsw/SANRRh1lLH5VLGoAJJE/CVvEEyRlZZhO+uV7JoBLMi7tN1aFcCXFxOFzlQCGucaNc+Jp/1FP20QMzEGwdKkWtGrH8hVIXuEX+rtWALHy6ElSMpbuP3vrtPdN6D9nOM8lUXdF58zrQzH/7FwA6byRx7httd1NGHv2LiRcQB/55CqjhQsZeFwhn5RXzQB3opHX6WdpIrxER0xI1mxXpGwOLQN9besd5p+p9o56AAa/uV5Ds2AyNPqkZd5McRzuTtAjxoZTHd6eZb+KjXcAQMRxqPTxJrtjti7qIURCRLG2RL1ScWuKlABe94XWSgA1WJtHUtY9icGCDi7V3Cd2Xc0F+j20/OcmZqfNpnO7AHRxeGKu65S2UDpuuVGoEfr6yn5XkNm9ldyjEN/5y7QAp08ZtRHNLKMYvw6CyXwSZYjRp9VkaDKtZs3ZH24B/gCecosCQ6YIX9kG9BTRA0MUOMfI68/nw+k+UcbKprV5AGcXDiY9inZ7QUBIfcmbhxV+78N9EofYKUv7IeI41DMASa87phPMcmGi5gfmVg+40l26QvHaLud0VOQUxy/YnwArs6iiyFREiA+/6E37Tiz4lmvU58ZD0Kq2V7IVacrSAO4utzgXVi8WakZ62Im6uCU564iFCy2Aa1e4CTc/LmMAMKFWeE1gVcDlfwpNWIsxjLHXX1EKd5Ij/XVOIrHqYgCJhRcHDyW82QDGRybn7AE8056h7sVeGNo8uRSIlYwsAEJKkWWd38VoTG//orOgeLIW4ZwzckBUlIJ9dQ5HLRsAdiS+i48efYOOB5zbDfomesMhNy0TRjoSTNWPOwgFfQA0HzY79e7pSOtTUDTC4T/jZayO2Td0cFVeHLcfjcUwAM3SgS0gjfclBqkbWdWb7oKPNYp/39jGy/dI2zo5Y4sAbg3O5dz/WNK1cI7VWM2vvtgcps8+NXpGdcGnADW3CADkcCPP97rSm9djBX3tk9i9/5mqkTYrgbVq2sCmWoGkAHtKw1TakHpxqVu4SmbxzzpnqpWZxm5XHix+sQiFW8IAasOkUnkvL5FWgnPjwKCwQpseMov3McVMnVUsYKNHzACIqfpOs2YMsrxwXM5BpaC4PwwBWhGWxdSKy3RicGGlAGoO4ZN4/qoQAWd6sOvAvuOGFLBVLNZ1InV/VXxDMiAAjB+MI64Yza4TI/TiNgOMRLJFg0mWxarS5KFZAmnozwC8Acky70nYa2CHi07EmlngS4L4gTvcklLwORZl86ZoABPZhdhalK6yGWk5Y0FG0i9v/sp3DsjyXNt8noL/BtwAP9Ic16Q1kuH3XJHDayfMiTtDWMskoyHKdejITldGMAClUu1k5bJbi+BZxw8vYfNFw6lacVxIOcPng7lODkO9AF7FAQ1NYYeDE1Tb5MdqlbHtO+Q4LhkP0qN3gcAxPfMANjFiyfxGGRWdXuZaM78XouCsfHIqjM8e4WPBT39MygBhds+7e2bM5YlGPYx+5Vv7vj/cV3PKrgynHdPq8j6eAD1egYqdv4lWcrCAS2mNILzZLyPqQq2FFZ+XbSqwG78AhCFNZVeMxbfiTq75jLAkXT0rB87C/hI30r9RiDspvQC6iTLbfBGsT8CKJBNAxvY51aMQvj1pEwyGd81UvjmRAIEwhtPzWv9hQvSDojh/r7LTftryOznqSPKBmY/PAxEACtqMN3UrmJl0pTdIgXmtqOIjOKijKE7EjqX5yA3wcQC09e0tjJ6fno/oVU1uG/dU6c6bo1L+z8Sw6BqempT4AIZzKn1zb3xJQXsZDMh+BIDmyUhWYO3tDfAqzixSd6cApqWieFeeiQkwQBMCU6OOJkDOuhQXFxy/bfPxCZG/mQDwIew58mG4Il4QZn1TdGbZFySRVtlOXG882ogYSNthAE0QJAPFgPKBoAHazvsNg7Im2N0t9refFkvr0f2S1sQAhFiSxsEsWx0bB1ZWJ0qkqSjqZgz0TglNzCZC7QNTcwBXrHTK/JgBzepQpx7czHVQGHhN8YXScRfgG3DJKUPSAOA/UQiDfRCiLOFIk+z8GOedq/rAcWasep2DuilJsRMA86xSn6abxGw1xxnAmZ0qXHtAASKK+r22YZes6UaAEAC2mnx5hvw2ubXZC9cgj9X3bsLb/OkmChCpwHj+3E2HACrFEU/l7aMI0Noa8qwNKLPNmqLIhUIavjVhv4NfAa8AknS2Av83+c9lCfmFJpPi16RASPyFMysm+RsOCuwCQQCuvP65Q9CKZMXXJax2VxcLS8Eqlnayc/k+bwXhVXEpANy3SM+g1a1mdrVNUnXQCVDYJCkPFbYqW/WJLa5grRIAL8UNN/B8xZZ3/WuTf+RAP+QdoCMNFbSq1R4TAQlw1gD7qML5EvVw00N0He9/5rlFW6U5L0m1mmGyPB8CbN/jAPDrUFdJ8h25dFI/QRUbRZIadmCwBYhIQ7QGptRjonUAN3KuRrBZx5BKq2jbQ5WIlq/qKmdkvIpPDvzUKsRmsABQrBnMifTUOYpWHbHkEVXsTFfSyF0q043jHgv8ipuhACeUEnx6PlWiZi7/LE46iu5QHMlTuVwuw+Hg9zvnCPgAsa0uVWmA6i1Ss6pAlySLiWcYSt0/h8U5jNEYb2VVAACHHzQX5+NWzi+NrTltHF8TZboGQCyy0LIPrqnRZo8eAO/NmInuZfpSgD4796O5yva6ultyjB/UhPkkrjjp4fIAT6kcHJwJ+sUFBhcv5TGbwjsoPSORX5il/pEo62kjZgDoYilzCLAE0mVx1jX0G0lsiWEmeiiIlYyTj0tom9MVAFi1Qk2t9PT0UxSJf83rbEVy5xaiAwuSMoKRsdgBL6oAx8wBBjaVyQrhSseuLSSzWBCVl8M9Raa7wRhmx1sb7gDdKHLSkn8cnbEPBXf/fKdLM1PbzSD87i8zAwONIa9BACsX7NN1258Tmqu6Yp0Z/ejddMXzBjBKB51nMj/sFisAreDV5wNufj8jBttcwSN7VpYwQkLzwkzmHH3ZTEqlSwAU3kG5XNGwoaXfsyj6dwAGE1GS/SZIFf2J5+b5H4++AD7ENAfOh8nhCNaEeHUUX+RqMec0eL7VF/ktEB3UI5gAIxtQJ0CxrDG67jfo4B5f3ZYsEV+K0vsKsMTQQz7RkQBRA4nEltsOlfP9I//VxcAYqED+5NPOPMWZ4mrHDZVVAB57gcW/wsdlTx0W3tZ3EZn9qECzYjDmM6l3H0YW5YkAj7LJFcWGFq7+t/gkjXdJAiJVfT/jRGeDOmXoeiBUUgA/2AWLdcRSjx0yYdRge3DbaMbtB/ekrT6XcVHDDqGOAFvqfReKkQ9darFf/rtia01nP5SP1Ya240dHOGvM23cATEKnO4UXZqkGWzKSvEEIuHdNwgCKQyH/RCOwcclbNwD+t3+vo0ZBcQnlxSQylahpvnDsubiNkJ8TFNre7ivXAIXDswSRC/Ke7x1FxtcD8Wbp4Xkae6/vxq8QNnqrn6kAk6LVkmt97GQCkKUCaJa8u8qDJ6cJdEVEwllbFGy8BAC7TfUwk6YPmzW19gyXw14t8jWXQUV39o2H9Iz9kvHIAARE01bXFqf+MfN13QGc9Vf3reilRNG0yPtNU5whPU8APhEjraZHh9HBH0xXws7DbiDHXsToU5ZSdc0Zc83G7ADIX8lT0Ak6Xdk8ZE8UzU98v5C5MZghqAM/tKLpkeraAKwIj4pRC18oeFDM1xbnZSoC6E82KqNKXla5aJkKh2IAPZga38dJYslZB3La6RigffN84NlXwt6mAVz47VvkZwA0GbPHu+V/G6agVXw+Yf6JZdKrVux3sVD3LOPm3kRwAJKITaBHKIrywk5aVTDB78zHJkWdKBnMf9jF18HbQRQA9OGSmxEWgOoIkdv9dRxIC0DcJF5KhFHtt4aEsYycoQBktCvlXUtL6FMEKULDbpvu/7BiztXkLVXRmCVimXIcAOwKd9fBCWm/h9yl4Zav6gPUOfNpcGudhD7ihbHxbjAAeCaHQrFr/7CIJlWv6MIDAthg9Gz/F2smHKNZZoc4QABr8Eg+Enbh3CiZX3NCIy517ME8ZmPQ6FM+o6VUidNyAHinwAdaEh3D/iocUpZ2oWuPKDIoUmDgIekTkIV4Ag4AmslsNEkPOhJcLbMudio3RTZN9gnQWUOfwc6lgw7axQDTEbKLZwMUcPwA8utIV22NkASihFjsCLsuTasO+M/3ANTgPnr2rMzja2tE4Rvg9didf6fTPHm84oi/twI8s3sArLsPi+h4np9AWH1B68j5AU31jUbjI4bsXidCLK9H7ACPAtFLLkS+5UeSY4wvfqcfdHezQ5f93zGws6tqy67rAF1XDEUArsx+Tnr7pVHzQTcqRNNVuvX6d9uQtxvcKuAAG3jMCsRiYhUkIU6im8de6jBvU7cHaj8SoFBj7Ei+yACeKPcD7fyFLq1XrVMmI7k0FHuMa8dWs0kiUGd8eq7oABFhPDY7KTBSeqt1T1njknZeHTH7z/DgL+MI+A7rdsMAKZ3EZGWhQIS7QufO6xQOher7T+C2tDaJh3131gp1wwBFOi7VAoZcQ+EAl00DlCrFXFe0/qh4Yp5btFsAo4E9ANk3tG1gFauq3V+MHWJn/F1UxayAxnTIFWpFGFkx43cAh0Hr8uE40xbE+lAqkQJUKpzkeGlXGruIVkFoVpnO0gCEdL/tCL/iS0pwvyRYrzsia0MWfV4FmekV58uM+Jn1ANLXPAaZ17P4QQkJkD+5CJQ4sSFAE8IESnQNp2cHoNUAFYs3EpLjkI8/axw8RhmF82xXBAawSjJpY09JENJSfwBLCpdve4aHFrxin9sorAnN2pDnLZXNHGNz1QZVQH63AHT7UJUFcFX7OYrcBVMHYo/ltwtx36oh2qUQGNW1uZUAQcFQW7jTW5Dw4W+l3RyFuYVadTky18zJrq9wXgmQIwBXW0Wcgn5B88tOmAsyaPtt4FOh3QA8S5CDTiuo8RGyABIzLNRPjSe6Av5+jmSsDJ2gEKdGzBNuj6Mc/sSwzkgAn5oSEkrEJiDGx4vTmmUdOpkeSb0V3+F7Io0pqCRSSgD5drB4NgjOIN6WzjZTDdnsSAX1d1hdJF9LcLRxJ3j7AFAwQBQJt1ku0cXO/wo1N0ePXV1SuGm+EinTlPwkh7IAvlQ0nEYyEDYBGHUhb0UUc7HZw4MIE42sUt8t8DxzcwDN05IwQjHHTOUZdo8ZF3rF9AUMI0gkGtH6ZcbCpimPAMxbdRHCxw92CLrKANDpmtj/22XjaGaktcWn960shS4A7vk2badVFEQLNlaCJ1GSfXj8wushzBfGVav5MKyNNgAZkWiCrfHOHSQFJS49RvZAi6tdDrRdBNryFaglzKiQADjAO4JQOfNeFE76D+H66HjShWwdJ3SDVYf5Fnqa/4YAPPTPT7ZbBrjS136LbZ2uPbVmlCGjF7f390oIAE3fvgCoJM4/jpyvDMEQT3ipgHBZBFQaOTocOtbpioUR+G7KANJLiO1s19DaBRZw+HmV4fJM9bCvs//eZ/m8jlk4he4A6HUHjbz7LB94p4/Zrm0GElzgwHywbvHN5Lie1kVJ/QB7lqZte37hNy8gl1hQjVC3TaE8bKgKZJYe6o6EAm1OAKQEqpylgey1qy3cF7SCUi8JSBokZrhLXnkKLLBWePIAKLFasjrfpReAi6VWEkQOAQvuqGpP5z67M61V1uRpWQAiiWRuE7v+I2d+MAX9Kf3vZ9vs0lk3obN6B3+GUDtIABxoLbK8HWU+WbVceeRQ+puNZ6T3/IMY5nR7CK7PaOAApjigeCxBUAqV5Heyarj6f0y0ZmSFUd2cc+9HB4wL/QAPr+zbcZ//xAYNAdzPUMSiiskfMEAjVymS9bkbafnEANMbQgOvsyPUljj847O5YLUyVlFshW4Jxsmt+j52qVwAjWaMYafmBOlpsE9aZueFmECOEC4bwl924L9zFe81YwCgKNtgf8qtALSdcP1K4xB+nm7fTCNd7s8E6VwsU0R1AKcGSeYxxkMRWNfngKkte6z4XOBSbVB7TopJBOTfmlAARvY81k8OZNt9InKIy9UdgO83uHyb/bpweZyArFshaABYD8ylRSiqBJsfEu1MW/a5ofLKbBE3qAINcsliGeqkAFJP5PWwxlo6wiBtDb2DsL83ku3nB/bWt/aKxLRtxFsAm42XCkyNCqjc3LOs0ajZTfZkbu+oJQ777BIDDLBNKQCeBjYcs6WLd2MX7NoSgzImKffNpbEKsUw3uj36rSd9ANjblv80YXku4Oah/ooRoiZkH/G8nMuMEOUIDn+CeR8AHdwgZPApOKyiGcXfR+rTgcdPpWUbp9mXBuNoEl7NewBgO/xIrlYVll5dLkzJu8eJUOBcLWch/PQl1yVfL5kXAChbG3fn1rnJYhg7ygeS3vCfE3vwyan4IKfV5aJ7HcoA+Sdtdb/7q7iOOz/nt8MtDBsHLwKq6Dp/Y6IJG9faBgCHt0lfSqnoJisl8AwSQZsLqnE3Ka4ktmmeq/b3RF6tACWRNefjrOUTHVkW/0TV+K435M2ojr31qMNUFDOZHz4ATFtYBBzZncbig6KJl0r/4m5Rr2JzeVr3zLdL4Fu93ABrFeTQ+IZCnIAVgwmgJ4m46RoVMdSnq4ENpHh94RR+AMXztZvzjv9n5jHC/PEWTGrJ+l85qWhuP5TofgxjFKMAnlyKLnWdNgaIXbNl8wkOGe3RAcDiSkuWwxxPDFaNnwCSSG68Oi4tQUc9o4p3/+zzmUhkJC+b2qBLxyPw+39KAB0BUXiuN34+OObfPdPNeE6TQs6wFexqUUZ6mckMF50AaH6oZXnkwgvZFFuTeLLC1Em3qwTELyqwO11qumds/gBBdq8jYd4iALtliRpHdvdahpAMJbFU8CyFyEbJ4LvIAOZbLd1BBtKDJB/Ysnc2VG7jp1Tyj9NWhLLf40k7vakA02cL1SqgMAKfwrXS4U3akq0+aedAx2R6sTbWCdMqZAA5pbC35iRc4ATIrh8i2OxDGtxkQ/0/vkGm4YgojhUFADZWqSDzwddRY/SkKmI8eBzM35KkxNHU5qQiKmaujeUAxvoix/nV73+tPByb7WSilk8bTow19YE4rWQGZU9ZiQAVNKzp7l2EdPmUqyXqjCor0zxkZNG8uKNlFeMv0SYRAEUVZJ/zekOwwGvAosw74BhSv3YEzmqpJRwpUWPDcNYAUcPaEU29t7ygUpl6BP413FYH7Qb5gkhDZEMPViQ62AAnonMGqcjSj6BTqGXTW+coHp5MSiIwzY8+94/LsjAKAFjJGmPMSFov6/bjI4BCs4cZLd/U9JNspvG4Qhi3hOoAzV4wyru9chwK2ISKPW2iTZg7kmvhTp9cwKFJB778QQD8E4Bg9IpGiDnJUc11wIvBmZX6OUfF+OXgBYvzneGZAChs7qhU0KrcDPU/e0102HXVyL3PVzDcOUjXzuJQz/8AK7Ag9yhNOIraWwN7LS23m71gide8dVz/EuxBJfeYkQBYyEtFak4Rb3rhq7pQYqefDZmb4xtDtqyJHPY7xxkcACDdnsopYBEG6r5qXWpH3f+LOp8555D0ALxfIm7H66AASSzVdDQZSBzRb5XzDNgzwqN0k/ZP3dK+izTRyM6PTQC06T2pYwA27a4dYr9pGK5UvYCYaWX/+MMrmMB9gVbHAJK5T7JTExQFrnXKBVtE5ZrqdBiVUNynkMMU3Jc6k7MAuqECuNgAcMrAYS8D0/4S/1nLc/acvLPgqYbclNBt6ACGq1Yz1xNjH2GHY0lGpMu3HChaUxPWU91yK6w+QZVyAHOA2tvAu2fV09SlQ2OO3M+3oG2lgwvtdbRgMrmk+TEAPiZdQkM/i6CvkIbElJ0IcGkvkmsRlT7IEfv2Y/PNVQDVijc2zBzUbYMCTvxZig0ePKFB2rJ8D3nc6T5P8zYvALK/5wanX8/pkLfeUQr5B/vyVemf4Nx0ZWisB/4qp40APvVAu+8jDr+2bEbMJsytIqX9iXqNH226if0EnNOfiACnxnUVFO89RZP+Vto/R+udNVswC3DTzKjBg5Uv0ePPAOmzbJeEYdkGOgxV7S4oHZMeQZZXh1oHzO/3eA1TdREAYAQs7q4bLaFy2/IQH/dVLfxS3OsdYQnxeN3fKcWRkQCw4QO5aJRM1TfsVtNxyFKpOZ2A15cSLFUz+ki/TXaqAGdmbtEzN0FeNGd7OIGpiEyYD89hdH3IyVOCRk1bIFYALQyFEXFcO5Xc+YYYO/cXYnA3t9ykQBAaNxYcQRBopACsgrinapQU82RT66MU4TpAQAtYaaqtDhxStdHwNEwhAIOMBpKKZ7jsegmyA8NEmEUuGFx4OkckxVqPRcXKPnAAN/fwpa+eOReqIR/hw2m8R3RBLDpE5rMCtjuFjrubzgDTBuLmf6nUJYxbWH1G6Igqm7iskeQu9zlPKmbYJiyEAApiVYrvVNF7wtrNq+gxTl86js7BEfc6ozLlFuozst0ApaNu72ZThK3TghUyZGOBcvL1pqAOZV9K7KItgdDjlQCoUUgSkj6iUcfv4bogKxWrpB5FuQvRSJX2Jg+jmNaQAHSZj66keimgqBOmSB6cSnl4N+fiJ3JGh5Jo7Tvi2bYANgw0hji6mewglvFg8MGgw6MdFI1gVHmDL3mFGxCucgBfNfMnuLfdHEhhnVN5m8VZWObf8jbv3p2l+NPyf7YLAMIS7XCrqjc4mAA5mfP9/wuITptUvnvHWX7VzoCU2C8AvbyCViFPYlVJ2SCQWoa5wir8OcBq/W82Flk3A8zLKABJpslJaxNFiNRk0cJpOx8zxe2+fmu7jWrt5wK+JRAKAHuV/K4QeOskOJn9mrBf3yHOp2HtQC0ecwk/33Hv924AfxT8Xciq+djoog5cWjzI7BYSin0TkuDpl4v7d2zaHAALLQTC4FQBmuJ+guRg3zmNWmDEFxQ403pLW0/tYS+OAKdY/GhmP2wQ7uO2t7HvxVQUfRTN4NhuiCfJXz0TNUoAmKmYF8HpboZUlkE+eBAGGoZRYg9G06z/MZWh8eRtPgDO9mdE01dNsimvdnAlQKy/qjsb9c92zVxjNJ9jW4laAMof5An6KkTgTYwYe3euNlT0J0dz/iysI3Pdx8/dLtIAIpKn3BDX5V+4mETtk9WmvH778JE3iCEVHXdzzRmuGQB6hZlFKvFOptbftPtOtfVS6DrXPCnqjcnicenov5INAMz3segj4y0oKFJvQKmztop2BgHvETbIZwOPckj0DR0AXORYaecPteIo+W3L8I9nd+VKWqkpwWjhaazNXdvTiAAOZarDVq/CXbeE641fw/ThGZm9FfMXPwo7Gdh3i05IAEO5ejcdjRvivo1Bzx0Dcu592H2vAC7WQ1dVbghuFBcAPdPjRIrZu6/hrewTZlRThrvAc9AFCZyjOO27e73qSQAv4yG5UOFyJg4AopEuR+9jb0gl2agkC04HYvb0zY1pADp+Us2yks/hMbnEOypD/GMv23YepIgXQ3mdXXhAeCoAtXghPKMKVJ0LMQ6GZI2Tfbauz6rsP4FNEaWYecBt9gCytrD91WJgYuekHyKeCMb3zkCvEseRcdhjDdUepzSdANz4Lot+O4tnzpJVJqCqy9J3+/7T73614qsO0nCtsYkA+6N3k0Y5RjkfIsYoX/KjSulER9UKemlGZCQQdp814ABFNEw/PBPu1j48xMUpuLvQO//SKo2Y4oUM0I88uVUmAEjpOyyvIjuANGPGCtEM9gR9jwZpxF8hxLdTuQ3FEc8AFZikIFDMUvhyfC8rq5qjRGT4abS/UBI1jw7QFf0bngBlBJOGil1TVeOClxg5nemBllGaV7QYyB657nR+1MEyAGbfJHIu/N6Gum/ZlhjFkvlzcWVik+INxfEEq/o3aMkAu/D1gU6+LY4UMOuIItzVfITSxnX/fQd4HSwcBBYvAQBokiXzAXeKkpdHL9UL3Ahn8uka4A1IIRVkfqslG9kgANqHDbAACPR86DFGC3RzNygJfpb8OcsbF7h9TjWSODgA2lH1KNMIjv+XsxuQyxb1DWQdtq6zbYA4eGe9NlnV0QD2z9ueBENnbIPLUm/6vRbJLpaMKgZleeg6PfMgZP4CAO0XtRebAyNFb7O0c/u7V2+pRL4uaBtnMqTm1XBPg0UAwg+fgieNpTbq8ROB2KKva2S00caeOK93e2dGKGWbjgChHQJR5plpywWDZbTfr3hiIUj6+CzSR1b+lOyB6BaLALirBvKR6C4UOnXsBNtQCCazN0yWk1aT9w3c74xt0N8ADA1jXxx1ZlYpyLtJPXpVcpxG2ujGGY3+Ft50wgZFWACeJ0SXzly5cFL2N4w/qvcttAKAqesLDkatXlB/qXCUACDwsyKzNH/zwtjomYhLe01JSKBwhipJM8ovGoBFJHcAicjNnS1HKXLDyhwz1VGKFkVrcZo1Xb2qvUzBAy9mUQCSjWd2xlM3wZSuMbeCv8MOU6KePEcB8DFbMxE+z0pwAM6atKnUMKf8IsQwxwoKM4UPe9Mx/M3+9f20tkC5Ey8AZ4BWA9IAKgeNbzKZkExkq9eqrOt0PUA9DrfWZEr2GACOR7yu7Mi6uhS2ZeUM/3+OTUPfQULZBg2YxPLJ/VuFAP8gPMczT/sZr3arKDgHCDuI/Ft+HQOoEvs+IdrvfC4AlfUOnoW62QjwfPzEp9UE52yDRsNWQsX4+qJTe6aWmQAMHZv9m+wOV9cZ9uDPQTQVdmtMdh7P0rFiaEfkr3dmAIhZz0/g21lx+xdnafUgJ3fhkb0Pkn1NKbLVQbFwREwAKFjeCfYil6d+RjoBk8iD9ShFFKVkydhe53b8njBbJQCJ7LuJAqqFVH4JQ24xFy/fYSTQYjxdI/eO02Udl/odAFaXHTnUsVyo3VB9Rmps6XRgPyuRARe5xsq9ASWw+94AlyebjmqMMA8aLBaqyRtpWvFKNrNI+4UBptDgtRZ8ewCfY7OcarB7LTYkjqcaGQZn8LuDIF0wKUCfbhtY135sAPjxsA1gi6Uwz1ltbwXvADe/CQDb16kHNrCmr6LV1OYA4SmAXnNibdtteSZ7goa+b/i0euddMHwvVYQGYo5YrQCntJKftoJIU1z6H5/y66ytHgftoNbdUzNZN9Nyurc8AB9nWW0U9PnokOs2QquAo8w+18Zn666MAGkG0sCnBsQAcPd2YLoaWYUQYYIRBC2DDuF+2J4Hq55NXdudv0SaGACAFfsIdXTGXvg70/drjgyXxrirHoxRvL95aAdRGLO2ADhouYpWUJnYBej1+udvZOJr7WojXTITC4InW8vrB9YAj8y9Np5tRX0rQwiFIdbuYbewDfh7f4g70/H6xcV/ZwB8UU4PkjF30+7JbBQm3VErozZre+buV9WcHjh15v7fAL1kGeFk3EvLl8nILAB4qqryWXhufr+lx80YxvVctvYA4GcRt7WsPRCuF+W3id1ssHFw83SI693rwar6gMwt2wCJF8nXkaRFVeAQy3qcWMwo+MLcqTYawaQqDBhTG96vAKi9xLLLlaTYH5+WAAmuq37y8TLNULOXXX1sMwPtHToAath2dPS50+YGlGWXPzJuO1trn9+stDoqXvWqX7n0mACY4CB1mhKnMNRbg+Ck6B7Dqn8jzp5JlC1QhDHVi8OqAIzMGOirgTcFpeXh3XnPgGGtzLg6WyUYmL9O41m9FiYAqZzEe1VQ6vmn6e4X245lmMX9Fh6S+QfLHN87Z8eetAC6Mh7BPcEoBbvGdOFmKcad4mKFQD9oFzVaCvjviHNQAFYKYLugA+ZswKLh3KLZnquRf7q9cDYZAR2ruMsFZqkAMzDsXZ0k+pUKkjsXqW/XQGTE6J+H9pJqnUVR7bkO6wAsyGkTcMaK8+azemEH6C9JFMWKjlr4v2wFGT5Tqc6HAAWl5gnehHGw/qamztOHTgiipcKrDsVfuo+8HyHZ8BAA3Mz6B1Pel13m1+/2xThvxP2ghMtpzJZObD+VcUViUACsRKvzJjdOQ8rsKE2KJvXg+fzXNqDHcbZ5sgiv2304AE8jmViPxR/2ZMf+ALZ+ZHWSg09m11nCzPdJl76BO3QA+nCen1ebD5Wfb71nMEv3CcY/T6YQcqJ8g6olQ9gfXgBdrl3d7326/EzKGfaTG8GejDjBsE90iePJtkLHmtUQALmAS5C33RMTB6hFJ6hjB2J3cBykqc50qBWdJHwgKuUANuOBdfHnH+LzfrnYIvgDWs3TyrNoeRiEtJialBcKsAACpknMQVMbO+FBfDz7Vf9mx1z0BDaCXiVrp0GT8zMHAP9GIFQVliwGSPCD2ZD1a2PVxrE9j7DSk2lpFAZoRocA4xVdbZeVW7BiM68firud/U1k/nsoAe8I2zHjFIvI8gCJH3bsAt2LpGqHKLbYqmkEhTebI86IjAYKt7qcuBm1ALAg1LtPCvhgZf+q9wY8YMyl9sFbWMVWBmkTg5823MUAbiNuAhqpSv0gWbjNLh1kiH1ifq/4De8Ffo5xqtwDdgBTCOpmb4AZtb5kl7lM5USOLueChZOIN9mcTiawK1VbADIBcf2Nfp4A2ByNRvDMa6iq0/3YARlho3jbhADmzwUAN0Cvo8hsRLiLmVYHYBAMz+tvFT0fDZqgoq4GEBiSDADN8TGwkPgWCCk6aW9Muq+ft6RXOgjVmlFX7rxLuglqAJO5O6nbeUeWiNgKzV5kcmIoe1LYq9MWx+TV2NCtmPgAQ3d1fc0Rp9zQnaYx3XNJUE7rSo8BPX2HYMhLCGFjoQACE/D7SmbHw95JFHtefUuAzJnm7nvaY0GmHCY+0h1xAOnlmYZ28rLdYh/T97pktMZ/VaJQALGSHbeodIAUWtEAeHu1/RwirnxeLKg9HltpvwOR61eoG6R0dZVaqW4GLgCz2N7YJPwr6t7WsNgSB8n1obTCuMa48Pj/2sQmOyi8AGeJ7TCxTqkwcb4O03RrY5e/WHfV7ymUk7YmZ0iq9boA+gcquHUKWfjyiscUMrI+KvOyvHF+CJl8yzTV9h3zfgDLO48HSgF79e82eNls0YD6j9HfGFEuFRDvsL1UkZuHAExqkFzXqEWbPGzH9gdGu/aZl0ZEB83tAFp/b8CpftcATD+O0MexH7AggrQyDJht6vAePBjZab6OtOdeDcDjBwBAP0EQeq27BN6cosuww4L0wwW2P4F8E5F2lI9/lGVoAOUlCuTBWJ0vnGkXuObDVbHrqvbluPWzsbAueySFA2kAguaDEjNvLkmD0v31e6yI76MP28gEYEqt1eQpcWBDcAA2x1BkNUHtqS3w6rHFIo81J9IYgUA1ktWSgzkehb1xAAUWh1fgkI+P5nqQKueyKKuZbUkxwc2M7ypxw0XV6roAS+h2Xc7eOQ7g/hl9Xik7jwbAswzzXwg8/nUrBWJeVADTA9BgGgLedCMqLrBTwLNCtA+kc4/urz5BpOQq5TO8AHDezc21Lxks9ke5W2rMnB2bdFBcOiBOCmcOD0Vo8MoAAep+b17M6M0a7lO1oAkNk0aVFUk1IJrREvHCx/K+bADEPTih3ZoE+CvtT++bOtXdNi1TzuJfX04PhpiXwXFNAMfwcVPrWsHMJzx8GYS6sr8fi4wUJNr9EMcyHltpFDsAY7cyYdjIaACwbT1H0FwMyuluDpZW2HQ1NdGU9j04dwC51gs5uNN5zCmSnmBY4VLG8Vxwv1MQ+KftADSKCQ7XADDKQAJb4hMqdfzCG7n80zWvk0Q8NpXVQG5gEyey3eYAZ7wdWRqyNv4R99+dAiaoZKeNt72na+mRq1sNoWJ0egDdRdNeniuOHOancWg92iCDWYAu+Nx7C8peaWxaCQJtAL0t5z5D1qq9lqTA3QmrHa58jsU0xyOsOU0lnQw+ebQAoTzsnA5wC0D9pQdL4fy4m7tNSAzNwprSJnwbF0PoLwBfSQ6t9Ywiu5jbsp3L+xWtOG+LAj/wnmG2xWMchLZfALwtf+sbv4stmrh51ihQddw0GKsupyuaARiVQ7w+yHcABGDBO+Ev9Qm2IY3kYxgz5m9VEBHzpXH5pgDOgkr18wAodZy7OZCStAlR62JUBYvdDs6OoGxriHe+l7mtfCOCAMQiXGEr8mZ7HM6F/ER8jHSmgi1T9mCk7nOA1klEwzsADyhyDd5WbanK2W17dkwhmZjdRNDey+B1P8YYCQEOhAAJV2O5GoMmLPIVw0XqopKvzh14uUR73yJJwTn0k8lDADepzVuKoYzCd11ZoN4jaQjk2YDMub7SOhE5FeT+jnQAiZcqgdeDNBB3jlV53C89Y2bOz7TalhRwUFTNcUdhvwCzlXdYirZfgyYpXlP1d4nTjSdpDY9ggMkjv/CTK54kAL8pPkAtGEdX2BKkUClQ8PtIXsTZWCk4P6OucIqVpUAAytMX4gjLPmTQcO4iS1HmZJ/PwoiPf5pcbibQ8hysQgAIxDooeIrPzYe1ipS4Kml1T1Ss4NFTFi61L7CnzdzDAC97M6RKuEPB2IeYzUPLdR0nDAncrjZr5rp2nU+NqNUA/CeQw9MfI93CUnPLudZ7irKesCTTPz4bryoIIpUW7gDFEe+Ygk8dwuntSCpFhUham6A61/WkIWuYpIWThwBKAGHhfzhjxFTMEKrGm3DWBMvE4hnQKNb0iCZG91MEdtQAgKtL5wKp+YuTYyMlP4NV8TJNDDhdccenTPaGiJV75gBQbozVWTmvklJHArGDz7Z2tnRcPMf1JPgRGYcfIudqAFpv1h7ULKIjMMffxMNEHuP5h7C/jUCOkEFMldXwGQ0AXwdlOnN7CAQov9qv7BaxYLwNct/ZjQvVemxe6S8sEgChNNU/Q5M7bhlzACcUla2MvF4KZwAhJRm0mtmu21b3AJZauEXxuhjLGZl4Zu37ffcy93dRL0cF8AsqZUl+f5MAW9dx+ftGsQTvdIIp8AA/o5nmo/0Q5yemTtLQW0ZztABqUK9GdlqU7K6AbigytsdymCRJhneQujnv4iD6zU4QAF1ifPLJv4+a2Nv0FdtJHqgdvrgOVFHhtpWxu5TgZ4oAO3dbcOyBi+9Q/Id2ve8zVNLI/0oM5G5qQCc6U8SjjgAUeWc4+arigW0+RQdZPeI48l6d59AY9nseoOCvN+/hAEObRpJemu+ZN20hJ/IJyIMpjGLcw9P3oOTpIRo690oAe4jAJEw2EujTRBiWKz4puvF/rXUKTSz3GucosjS6EgDXdKBaQBMtSyIO6dd/h5HYO87wUoMqOYo+7l+Mdx35ADrxcX6GEGvuciEZW+bdWFWuPN6Ct5/14CVSdvycJRgABXXEMpnp+hm+wor/EG0GFqv3FjPUTqeMKeufwvkN/QCCM50kpqpyb+TPM8OvbrsPY4pi4pMQ9Mne37rCMe/wAPYRNH4q3n47Jt5P09sftpkugFCklorCnhz+5lhOXZ8ArNyg5GU6y/mVaOeuhGjUllkS/ScT8xuClvRwyBx8tgDPI1RCMnSQRfkmsTBtsEkSD1Q1Cz65sQVkUzVE1TONABPyVQyEnDSp2g0nioBIrH5FIDcedI/fLAeRl5p8h/QAEYGEC0lX74WrMOPjaixf2PnG+8jttm6UEkv4P4PJswDFjAlYWaPWZU5k6xekFI72KNuArZ+dmE1C+O78m0cSAP5ePjcbx9Kh/jguIq37SHuU0z5VpPIQbQppWNVhILgA/5xkUqPhXShHRZZvZvhZ0P4Wiw4ZmoV45Rtib9aODQCcOn/MU04KuRMaXTcrxv72zAfnUZvBlbcCAbSc96FyANaagzkzUG8CdCR8RSC6FioWtmF4JM3/hFZxKuiGyUwAF22pMCCDq/t+hA3DjrLIPBfOVzW0v6J7yBJz1MMUNwAm1KPZo2fY1j19NRL8MA5B+7SFy+XWzJMFKXXi4XUpAEaWrUxmCFsS0Gp5u8a5wXLHwdnBbKOp1vIuCdXQy/YAElTySi4W4A7mZkQ/9puSkW054VHrwb6zb9xtfWH66QCAV3gOCvG8CYJAuWnXdljOovoIWvbChcgSbPX5xueIALgLUqJY3MeSogRfusk5FnVUvKO4b3TylaCfXxHvmwIA4RaNiaOV3sHiXpHVkCD8WySN9ww/suU7ocFpqzgyPwBfE7q4baovwUOYOVT5lKvMMFbkgnV8CRkFBOBS0YcgAP0QyLVxNX/jmd+2whZFErdkeY56UgqG088A/IxyPDEAamALASMX1Bz0HREpCnEDNMeSqvR4MH7o4nK5DtdLzQCZK9CKeuMSVQhIagD8bOQtPkJB4HIhxUm5z0kXkADzALfX0R7i4DQvIpJ/FdcXGnVtq+ukp+RF7TcdelZ5ak0AEY8Urk7ga6/IP7oD6gaVU24I4INOaqIL4GhUrMkT1wCwYeQ5n8hYXmeaeyM/YgwkYWf9XH0T6VaM81ve00apAPuX9/+L7O+wozugE5nKCCDX/3SFXWTkBz909d2/6xsAFwJjSGauvOLEKZ6K0ixQc6XN7ISZoG2rfzYF1JYY3gCDMeQF/Kh1vGS0R1OVAyuPJEuSgFWQB+KiCNjXSI7XAAz432u+pvNj9wxTd47WXjuM0o+k5Q5hIqIX0/5oybsAymo14F6dUlnKcFAeN3MQYMeYQEwapBUHLjTj1B79QABgBY9qr1T4dyiA66Ie0HJEmV9+XdiYcEDD+8TejtErAPu7INMjp42s6R0PeoEBH53AdbhfGxNXe7lq/45kzTQACj3V47smiJkUBNreprgfR/zIr7CwWS3wHUXimuGZjgDxML8QHhU2jYxwbr9iPVPF8I54mivSn+R2dRAdQUJFALC1mv7CW/SQh5/Tpl+pGGVsbhvSAS+Jxu9J6DDxSAQAduZkE3Lo4wmbDoyh/v8e3VQ2eBkiZlt3h+hPARYangCubrR3iY0AETZKi2f/h3TCDE1vyV1pONidvlUoIbzLAHGcjPxHXIlV9YqSBEjEkF9u6vKc9lj1gE1QSsFVlbQASfQKQUzO1AOyLXb6oveOgTFSGnh3LlHe+cn0NcFtOgAyttfAr4pLPrZjkd9Lkq09a4OZx6KJw5b1r/WYx9XyAFuGl7Dfm/p4N6wSGrJR1RFMOm7FHbzP3F5NKO0Ah7kAHguVggJ8Al1Jo35LrrzaVPLVOlsMS3q8X88AlAbTbgD99kEqPdI3B1GsR+kZqlZ2kEc+goEWlDwUCVAsm+ZwAP+mrDtRoSORCxKSBYAro+fqIWAcye/pL5j0pMdbxSEAPEPE1YNen97L/imQPhdb5FME9ch+09mK5vatz62jTAAuCUXpZvaoJLC3p2bV0axMQ+UUzUYkSfKdbv/0oTw1APezIEclwssYS1s/sQ4t2tV55Vkh75j7CQPyBoxjtIUAxH+VzvQqMD1uH6ySyGb6kgQeOBOGz9zHMH/cBw+QvgBtqBADrIgbIvfPZBY/txK8ZfaNF76+NUuVcngPfFaMAJ4zLWLd5CD4lFq0tIdEWCNfv1N2bxsErKnIA1wBUggA4ULM0d3hfDiSNXzLpJjcZ9PtBv8+uoUT0uJ2YrgxEQAWebptzXDhb2WtSmAwQTCCTb4/HzvKNkgkqboy0/9gAM/byFWrJZBNB8zT3t87r1Udwa0euzMLwsFgFdOLaXMArIYdZL4G3CDRofDOj30voOHJD+PEZ2sl1EME9LI1YACcK99INKhxYSKbiFXkX0i07kzvzGAnrJPh8tYJjhXRALDrExtWUqoebVzZmgqYaFagm8xCpibZs88PSOWOoa0AOn1dKj/fOFX1P/lZswNQ3bMg/Mt4k7hLOpvL3rKE5gCjiEc878EjM9i2kdLQSfzgauI2nWDRCJmDzyzk7VpsAB5mJQDU7HBv22q7eFBEVa81QLPf7LIxFix+s+R5svcA1ZGnVpSuebJZjaPw8lBbnpO1Xx6KHU9nONMHKCBkVgCyJ0JpR90HZ+Qvtl7DXEP3Y29by4MIW6buNiR0qsCOABkwFVhcse8t5hcBi4/4IHojUgCQ8JLMs1OgK4aO4I8Abi+fCEFljMV10u7EMKsyaYjaMTGCHnhWljdYj+En2wDWE2Qc0NPNrFGDbzw12gZTXBB2uEgYjQYM3yv6iDeGALKREaj+hCmvJLxVD7OttZOXoVE3JK3rxmg1LB0TP5AAkUjjFSRmFFqTob+vEsZZaVFhUwZo6vmKH3h7x6XwDgBhDHBc4rwTjWP9Dx5NkVsx/WyLDfLuynS5kT8FLkIhAO7shkS1lGDZYW08J3ek9UFC9SOH0ONpWqiWUxTf66YARW6M8z5KnWq+NeIWc4eRRr/aSluP8zuipLYMA/LSJQDS6NCBzV4H2dbSwbD+tMScoVZK/rGKleJOUCtlAAD7ACylf4kpY+TFVRkdfAcIWfHCgdZDFQawgTg96lssh3UAGpabmH8noYkwgLAGmE5P39lXqpzl5GsfledQGeWl6ABZBrCiYuu0RAXUtjBmzdCCsNWqLX2Ks+eLsF9WBKZ4AC5YBNs0IPASQqVbU5IlsVZvr/H2CcksgxLcMMicVgAARKdeyZNM9iEAYaeNEb9kAvokJtV6/uNRxPCJv+7ZKwC9F5Z/tHYpDLkM6+EaLuS24GqPIZH3teYVBXs3teuOAO49kXoRKXwdskVtMS25TpGYX+uzwj3Cnaz0EpHGjxAAjgKUn/Nwx4ckt2W2h9VkNVUg0p966UoaMbTAl2KlywCQLN/Aqd1+b4DXNDLuhyGegKuHpn4+UnwWk/EAPcnkANWm+Y4ef4jlcx5MMiPXAeUQ6z0wkMLy8clXa7Nzq8UAuU2V0WcLeoKJQ4y/dIW10HITjkYMd9JwYxzKCLTaBgD4ioKwn/DFqywy/645nrN3Xv7+7g2zE78kEl0j8a7cAJZdsnnjyjjwn6+qXSTHaUqu8OoI6uFxeU/601jELAgAb1ZtAb57F8S5yy5EUFsBlBoF2kQ4XMMZY2YgI9uLzQDj/vU8WIjQ6VahbFjc7bbWoDHD/bcJ6Wu3LcfcUCXyAOXNA4N8zkJmNZxXduUkPdFJh2H5CaEUiTNoXu0FnXMAuYQFY1c3Jc54hvLi0S55DCYwRVpdsxo+xC/ucgZEmwDCJ1GvgIm4X9qYQAmd+kGrRNZNdJM5fmDms2+OBw5lAIF2obyGsfs/FUS0iYHwEFJWFKNM9KBGhqulvixrCIkAnEZm8M56LGS128BqAFAnfD5K4y1CqSkrh5BULsRWRABOBpFyhRNOpvLE8u3hpWBdzdfPUZkeV2h95BBcSGtHABU7Z9HwuteVU++MbuE52hi5DhX9ZPXhV+Cc1C15c/QA0AEbItKjAa+Izzs9blHKG1apzf/093MsbCLIUHYOVgBwHi2ghCMh/VhiCTpo9bzrqkXu1TiD+CcgVNXNlKxkAGz9OP4JcUa/NAwvcu7c1ufw1TEl0w1/TbWV3bLqPusAOAGewRvX2ShsJ61mopEMXSm+YSlBUF2VWBwzp+YawwBInF7fJXfotLEWVxUn4EOGUAGELl0uEuzBaUIbuyeBAKd4rLkszjmPbUwdJFHS/FgaqSrC771rtkbHbjMNGNoA6gyfY9WYLE4AlwY9YxgBpgNCW156eEbnInn9myZargCjjoVS3Y46JB9VFOuVkFmQghsV4+w1OIuv9vntSPAFAGer9WTvoAxi56Y0qb4Ozf2u3rJkoz3FfbdRsIFnHhwA0BgDKJMDpWeybnO3eSHo+dAYKUqPre90XUaK/g0ZNgC2/QqnjrmOwy2u15Enh+KFAvcsaWm7S/PA1LDtXF0hAMabVmuO9+x1/m7qV5BWmyBsY18Vc55avjeJ+N+/ytAAekZexBOgYOB4m0urJtDriuUhT4TtkOlp4VQR2QOHewBgckBDTSOZZH6tqov0J71+5D67ukU25XsMKp6Ie+abAIcxx9FyxHgMlSg+Z1JAheIUT02dqBkpCMbMd8KGut4A4SPwIQfZtW0mHO0GnJWGA7rtQCR0vZLheZqa1gnzpQDg26SUMO/rolnz5Y1zEOKp4shjScjTo12I4PdUPauuAN3a3eWXTZvokuGd2CiTDCqSJxvx5TNzBuGL+hsiqlAAjFTeSOkFuMPoT10DlN48CiIaESm8pk1Xu4RB5VLpOgARG9EeY3vTMyPf7v1Sxse+BSlYo/J9DxIl0BnmTQjYAJlblGrQZ4CGNv1yZxTdFdiOygI8EUCfcMpM3/GqJtkAY8lWJ0tza1fnNu/NQxpcPyq+alCF7a1x/NtwxGtFgQB4S6hXKwKKatehaxFMf9MfDoY0ljdmnJ6v2SxF6yxuAB7Dh1PCrdvo9Wfj4P3OWPF64IkUNTX0hOO+C78XnBkADAoEep/As7jrwK6SY+EhLyTyJKnY6qd3lMfnOqkm3ABCJDb0bjtkwNNp6mwJZgpKd3nadOMBpwQidm5gwsmoAP0NwFL12H7stmlUSO/4C1F2xf0A0hm5QOYBxmrNTd8AsNO30hUf47GYWaY63dynxmNJdLU5Rh6/X6FwrBd74gAz3h2dDDAOFdAX2PXnNDT6C57gCKq+bSv2towx8TLBAIYa/o8fNQ/R3rzu+vnM1Hi53yBojmsZZsY1Y/mqfYAAnQhdqREgZQbSYyj6b6edmydkuUZxWdRppL/zQc3J8gCIXrG3A/ZTm7MPn+wVnu0zhXrMWJPM2Waxe/ity58JAKgDkCHW50lfE+pbbTNjVyJvGwA0OV7xoXBAeKBY3RkAPJiLB9s0s28JccQg+U3cAC8ReGGF7wDsSKvTPS0ADwDsYBrVBxkhMMFd1vE511go/H8saJXlu3xnm70czFmEAO+pZbyrTn8kLhblbcs6c54ScbS/m97UJ7jPjoXc+wQAzxmElK6DT4dedOfxz/51nFfx7BPsX08dREwKjYNTDwC6lfQWS/DayhA7fl8AoC97R0ZMKbIvRT4iV/7JvSTYAGQ/ivDf2HhUWhISBlgzrHHHKEqLE+3jE3/WifGlJ5oAbiIosak1vTKsWNnDZyO/ish2a1uihQlyYrUXJx5NLgDudPPwzOHvtutVJZO9hzYzPYlBpGhypSt9hg7SRJa9ABRAI8boYMUqv1SBbKvAkwamD6hXGTGINfhU28fKIAAAnM1rYJJAIrC+VFXLonrcho+lvdUyeo1csEJcVVuPRgAGgUoC3WgetQHpM44fyNkxhxEsJrOrSqVvYJ5la66RAItmV97pu0HicfoH+EgAV175duT70+W/G8enkUl9SyMAYEDErl/kfQGfF8CxB7+pEOHHKPk/SCSF/vBBLunHxgBd32LRa4zK34OBbXoHQDOEJwRMNQlo3YjEvhso1+GIAISalg7upfme4WYLEHCSj2KlratiqGGByxSTMKZClUkA5Ir4oqdizLqOIhpLzHZidInUcQywZ0iwn4FNBEJpjQBaRvTPDRpwuM79BJnBLFmqikI/Ux6zbKTJTrRil4w+AGi+d4H+lBCt57cQ0TMMO+Wx1ll4yP8H4llDnEG1ShQAzqJozKAhTjEv8PqZ1OfmYup2lAV0VF8vpQ2qAbnwbACd69zpsESJaW7ayw8+nStaqY/vw/m1pRyhKlcgqObNAHOU8xo3OQJYyFyuj2z6X//7YxZ7f1XI4tRL+QSEi9YAmMJNS+k/xueiDBw2dYfhbQbhoA8ZbGq5NmMDc9TmdQCmJnDhOThH1me7rXSLaSGlZ99qdYvGz2sAIhT/vwUxAE02yjpa6Miu4kVG/fo8STFu0JhgAlDLJfUe/CAdhUAAbmNvXwrxtVS/N+rlYZifeSb1zSNnM61QoHKJEp3xOwCG1Utze/F9yTPz3pArlhpjH7IdshaAIFSQxuSqc0U/ALDQBhuO061k20VTSXdX1Om12TFZxsVd8WAYMppZc+QAs9QcJRThYGhgMnmDcsY28vWXUXKbyDCidZcAkCREFAB//Vd5Hsdcrnm1aOJ3cViePLg/Trs7TTlR0Sna+8CiAGE3uljd0lTUA3BnFO7xbnrfloI0VnuvKzFVme31uwkAVs/4IafjdEMzz9Qs9QR6nglqxGBxPNeVqG9uOiU3lQDGH1Xh4y2M5VTyNj2yYFZkdSKED9NKl344XRsQCNlXAKqEvsz1O7smzYsp7RrpyS8d+yZp9q2jk7Ka+8yYuDoAR6p4AyyacAxiMl7v/aNLB4E8EBs4bq2/5ZxUQNeg0gA32BQ0Gyy90o66sNm60SsconkkTsSccUXbeJbTpggLAGOZXQZhYgHabdevNb4aDr8zU4k/9mRjqDgPIHNvYw4A0WrEzJh20C5UtRwfUtWCvmgsFuEXng9yENURxJntYAAHogJ3pRn5Elf0AaoHZpfW294hQDJAmwfUtnAdYpzKAOYS2Hv5ufDep/h08fsyV6jJu9uEqF8Ept5ZgDNzhIcASDXINUptjAS/D/ql8AR9OM/KQwMW4OqU4kqAIgdVigBHv4/OBmM3BIa3g/XmldU5GrzNXYF9CxaRuAEy1ZYhALXK18D/5x9oFD4sIbRU2mWx7jeX1x88J+Sg16HXd8kArXSmbzvmrNJSrZKPj5QQA2GKH/Ijl3TkTBp7lQJeiwD8gJz/seCpAKa4f0DtxcPjV389jazEDnxajFRMxCR2APLTIrP6C7IG6ic+Vf3Qbxlkl9p30nGVWPJP5XUCACAApVKOJuOEzrJ5fxOvQ0OwsAWPNZ2qkDnGhBoTbbwfAgDioCrJwGq2lKqJ9Qz2hkB2rhOwQj6ZRNMoxyCoKDAQADspy6W8YGo8CG6/qgdC+o3j1KGfv6DqVRmyreIjS/MAryZ6VjQOkf/Ptorzsssty7jPEZQygswxWsZiwISM5gD+tLTKyoHc6NombHHBqOkplowU7MB0XY3qhEoE2Bi7AG40jUW4cpvQVhpcc7d1mnf7H8hnyLQwfWADIUz7BFoAUrqk9eahWsfZD8o4B3Fnfvd/L07uN5dkW3I3MxHoHgBItmsz9khh0l0uedjKJdj7AFVXcJhWLko07ls6wuXiAI4E/5Zf4SIjEkDm5ub/ZC/zY9nMQoE45aqvhjZmCHMAcvGVHI618z0f7pqTZw1YW6tznh0HRqG5PeIcov4CQABVRhWUx/xgBjDlJuLR8/rSfr2wzTrQsUQeazgwOLtZAN7lyl7iEzDMm4ZeG4PXJPyA+GsjjfzkKUv73D6CQusAW71UJFwl4H+HGAbFz0OEqGudCtEl81SQM5P6z8cxfQBIMSKRaZLMYeKfRZrLGCE3j8qQQgLC6rmrppqQVRfQAFnBGn7Dh2OfnU3yeH0sbKeInEkTD+0infta46OKXpUAvsvszCy8PN5mlSIzDrwfVG2VnkLTmlhfI8dbJX3fNgB+p5MqpuelKyAOMqXIgOTSwJFg0E03ek+vAeeKl7PMAHcHCVSQV/5aJaMMi6s1T2RjcHizBZPCoJ80gMKepdkAk1ROqZiANMBHja+4ovVDHQDanMs4nopoiS6UqBoaqgCQc5/5+eJ+lyMASq77vdHaojhliQOKB0txLXknFGgWAEXqvOkFfbvDCbVtSopE5YdvDMHSC4j22k5GF881kR8AyLQuI5wPzh0moZtVZfUklMtDpdExqLLlRsmCcziEZQAIfyBheCmEmCfUWciQL0nM7UalTL7dGGpE1e0qygwHALtlnGEfVmPpBgzHdPwLPlP7yf7ulKo/Kw+FkKeYfmEAgjvjowVsf7Af4SczCn7vfPav9YYV1WSWQ7kxfHFfGgCuqWAOjArduXq0AOTczMPntjScwz1zama7LfJN2BG2AKZZe7g8jDj/yUAMSp4IM1SunSipRauQ5qZ2QHGMfIYAxuRtXM5cvpZbwJqRf0gy6repYxXl2a7tgvQZT6LuRQDbABzH70VKgW2dllxuRXO+STugUqguO5Mz+BpeAtxbAPNuDYCw3PMA36jPM29zut8H6jeCmneeBaPmjy6ngU4A+3u4CJ7ZGH8WtAHU7hiUCdz1mpV9bHYBLDo9mg2vAgBows6jQ8wxHIj+LWkO/JcE8VgZpI8we44WSmrPFt0LAJDno/W8OZp2c/vOEv65bO8l65HgrxQpyS2UcSCrd5QAtVCz8WPuakNoV4dKmHQ1VY/iPqNMmIkSsvd/TNwIkQBk/I/uo8Oo+G7JGqRSiwENSuwH+f+ys1t4TSHn22RDAKGzYyMrxszM5sZQKoNFbYgzhbXj4dp5EVp8o+0a+wcAH17b0Npzk7c3D78KY3SCY+YVTwWvEhGmv7SImAHbIgDdrdUy9zJkzOFkmrGbSmrkc9jvSMUfrHlmh1HwZ30lAFL/CeYeZF9ShnnLkXFcHaoFEiaYvPVn/TFenZtrxn0AVZwrz8nMMnWGZoNS52+OYhA2BrCCAmGXYdl1D5FxOgB6A0iRTKI4g+dy0ugfmz3b4BVfNN2hKHxtl0dtk1dCALXTIKuJwnHXd7IETmzcL7OUSC1LdCHRl+jxyw1wf+cAF+2hvvhZyfd8Yl3Z+MBkaInK54/3h9hENxHHs5jEuQA38iUEMc0j8oixYUmCWbAjQY32xclWImdfsuNfg/TEABuURu2gpxiTDuEyVWm93kQUvv9S3/pPM62PflldWA4Av3Pcn2KeZXO0clFcRcF3Gem9NPmPWUjOhcQ3US9KYQC28AjhpKa/draeFK2Pz9r7dn52KPwyUngaocvreBOvAHSAjodBph3T0ceauatbnJsGs/pflYoVOjte0S8d7doAmJOLVBoxLL4NWqKZZ7dg+iWHqDWO2HirK864II8UCgCIKWCttP1KG4ZKfgn3zvj1tloDlXoRof43IC6yEYJjADeKzf4jq7l1/s0VRNn24bZvBiff8RW0NkBGQzozV98A9TFjBl8Dr3l+bPW66gMTV1u9aVcazIiQhZ+9CwrIjQBYtoXI0JcmA1pgihVu3bD94fettsqOTCskJoKKLHXyAJ5ntu4fOU4qGalcd7GdxDXC/ReE4M9xjyPdcLE+fb8ApE2VfXNecqnj/BEr3U+JxKJgv9uCA3o7lWDQIYUJqABmDMUh00OL5NcjBk99AA4F5W1UneeX2Qu+SN8siKSLADuFg72OQlpu2uLcxfV0qtzI9/WsRF7HEXYSbXPktkMAbMebvgb/3zdyD8hVvEfyy2cwK+AQdnznL9UAUKLF1wDh62eaLGV1ZNxmSw7tT8y3Ia1o98tcrrVAa09Z69d9ANzva1TmlvmnHSt5VqDyhgQ8p99EG9uYJtY1n48++oAADoH7YGcBgwLoT0bUUimE8NBZNCtTDxC9/RTWX86LLQDX9aP8w6OOr7mzhJn3vktvrkMhJsw23OnqbjRCskfLAJLe/xstkB49ZSS61IPXi1E9XNkdOTzStX/hASpzgKAAGHKa53Ts2YXNwHLl5m9vH0QaEjUNTvgaioXjzalv7ACOHt80YGNLfobkBOq+7Dra+KdKYhfJRqR6Q0PDGSqJAN2JIY8Hwf7dpcpe9R2aOKz24SCr8rZsc1hrkD0N6b4Ahcin8cj31JKfm7FNTQoDtTBvvAnI3jwZ6eV5VA10cgAO8nMW0P7L7N88kufaG9sdWD2O077m5gkiXwmgJHBGAKRklJGLWVew4r0L/jt+G5Ark2AEke5KDmMdTlWGZgIA+i+8pXSqmzBWs2xU40nTZuribnbFxrozQPe3tx5o3wBSTf6++pZnBcFqu3v0JQKxTLLK0pFj7YQRqzqGqGC7ACm4DmllmAxjok3s8EWt/e5YZR96lyieCbIy/zkLeMwAAZmmbRysO3jHnPhA5DrEppnbW8FNn9qYCq/lR9u1ZwBjLeooHLUVzNSyXBPrpmD4/VUVl/wi3ZRlLJmUpsYaAIEVWGwpv21QW088Z5AVGwttCHOkROOhlqKFKMEmDUYAG1kwgSM0MYJtLQ3W1mmfwjcmclzR4MNXvPbz/A7xngBlGdy3TijtHNGKjriH/zxdc+NmCHg45fhMgZ84ryldAA3kLBdHm+M2kIY5Oin5BjzTL5zL6sQ1Ad9sbB/U9m0AdqUfhtZB7FjLFqzCsr+dfbJ3ZybZweWpvasD/lweVwC4NW+qUDS8xGeJeygz4DUZpQ3v+6K/pCG8/w08cSr/AHVAtHSx7u15VjhM5vzZ3PVKOUWk8eHlcD8sMVxiw/YAjVK/uT0UjdeUG5cuqYT//wlpdP7uMrPnetA0MPyZtwCF8iE3aiaplA0JljKTUrBilE3MOrkeQp5S0D89828ZACGXjNQBJogvxAqMdbPp6Xywhl4lsFLhQ1xpvgP8nuUAsgbw+HjpSMsor2Y2PfIBXR/4sdRYxQsvOP4W6bPu2QC60kcFxzOPVNDDJ/e527+PlpYNzFODCZhcAxfuQzz1ANy/WT31SPKb0a0jEgMks4Dd8eyEKlJo0J0WX15+lH4AH61727VlTQ/L0jDlDehLc5aKjxqPnnT1I1hfe00ltgANoM0yZWwMJjzPYyCQwII05GMJ1hmJ9QJe+eDKsfsZANiQkUVl9LZfEjQCx98z6l5j98lknhpJgMCnsgOVxM0A2C/q04ZfRE+UrQYyLBLgAGL1aZw032dtb569x2DgnwCFjN317WcCZ/VwlXxEZ+5lZ64bIWqPQqDQXouwUOVmAMbfTXwZbY9VZtgm/D3b+HLSk3epQVI4jdMXMe7eShsAq+FcqnqNiDtUBsyWI53/lQv/ImX6Njf+l/4QzHRSLgD8xvwrT2kwCXbQb2sOVuGBv4Oc84thyc+zUZget5iuAH08gKjYKhBquPJsIn/ig/+nIHMpzUwp3RLvEP45fBgAOX5f5OAtJHkc9RRXairXR+qA7dyi7H7dLHIAY5L2DAAVWQbwFQ1fUF9/7YL13vPz4wEzxNKAm5iDEGdpZjy7AC7NeqXqPHLfQ62p6BsaqXwDDfwJK+np5t62NSCrHDEASPVM72fXYmeU/yZn/jR9IfQ8tyK7t0adXKjREFGYZwB0cQDgTESaiiZA/AWaaMSRHEZe1IUrInxDforsk91jAJKHz9lWN/PHzFRPwFba/8V6kMyLp77JoDcmWY9ot50AAT9ABNDU+hgtjT2i6oCmuNzbRslq/IiBTgmPKXDLVABr8GucpHyaowGAmjtj0s6nYoPh0PgGM6keoTOVdiatAJkBU21WoHFtaIqUHk5u5hk0R6gRu6X4/RxFXtofZAgAHzkUVpKrJSSj5s/p0RDOjaaRlMuLFrfKGdeDDHNgmADQQ52Kaa/jXeFgn5A4xsx50HD5IhVojuCCK3MekM4XADEJlHdr2jgyDaTvhE0P8OB6clp0DYOLZqH+6A1MY/cAsmr2FUfN9IWGpJmkU/gA87CNbIgZjj5f/fhvAkkzWwAyIRYTBG59mMgJdhohumqi2WQVFfU3Da1EcyWUjPOtAKN9/4ZrbSCQq46+XIs//A+yQ1xHVp5VJgSxPCk9CWIAG9gAMAEOlKTu1yezLIvgUMWyKgbpqgiZMvQrQPcw9AC1SU1YwxKVgXHUq5iys17RdiL9tYeP59o4PcRqrMkbAHKQapAu8MvcYDY2/oGID0QxAXgjKDPc49BFTnp5AHwAYe1wMJkAHHdKdbW0XEAB81ExOrejAftKFHj172ifxQCMZoH2g4DLG19KNTkKddTu6lTEiDSweU+yArvmu3g1AJFWe15WIk4hljJlg6yCTcNLvkQOkT9aDw/89cBXvQoA48vFI1zgvdWqCneTqtJi3wAypTuzzDvrjL5pJYYcSACqft3BfMG8m0tyYZC9H/IXAffIWRKjCXILMnQ7eN3VABDOSNcvOWSSC1Vnn+prcW201+xZComMZkem5SXOeD4AdhNffBaf2ZqJUSZ6eAZroaeI+slYxo8R5uumPKe6SQDA5stVrkgT+kqiYtxRFFiYLhrfBoii42S6N/NBxDlpAPdIjzSxRiNpeHuXXYqWUvAm3aIJVEfjI8/9gNLyOugAmuC8lqQtOlLZRYiWje5/7S0c3MniW+OcxLCfJDDk9AASWZ/bC42vemazji2qXkKKtVOYK+4i0z4KKTEKOKT3AN216R5EQBKOuPyJFPees/NyZPR9BiFjUL6OBKFzzkwAellGwvv+54cXhsWjY+R47YtYro2n5UKW+LtLmDQWWgBBUfbUwcsi1XVdngLq/OkM8+vqpJJNAC5r21AbKF4TAMKRtb9zASYBzXrAXkvMi24z3w2HmNcuHPtxb0xrmxgAG4CSD2uHu8RHIGX9XZJTfB6cWPYJt1wcaKszoQai6wA9DimHtJFFXbUrXbBVERyGj4egI/a95bT1CuoBmL5DAE2SqcXt6rQbSXf51LVKzcCuWcZfxJBHdyyZQT9fNoQAo+JoIpDBdwn1v1goF60KoAfXl8ArapqDno97qtv4UABl1pL+VaQ7rgYbJjLAhyWf8h2vuTPXkIMNOw1TiC67AOTm8IUiEZKtfiG49CXgL+dYUYhHtW4XK9trqu7Z7eIAaRVElhSmBDK0VTFzf4P4pkwNr7vTwtZY+4vdyH4hKwCKXW8S8+8ooa4f2InMF3sYs/n+EerhO/S9K8z7Za24AG8UYZVqyOS8WTJY/rD2dTz6VqMe+0U8MdONumOHpMsA5gLdDjNV80zvYkahKa5d7ihkAX5qUtwSRcFk9SmjZgBQVTj9GD2KDIzmetINk1lTZGiuqF0QVpSy/CodIuTCAAqqFHaypxojNUb5SFJ9x212ZUq+/biKcLJNvjyr7LgAPqluj2vm/26YZ2LI//Vos7Xf34LQHRP4VpQoAEM3SQBHtSAu5hdw7Kh3rlc7SeTziX0fDxIYGGGX4RoXuk8sABG8WtrLu3CrWN3iYCAcFA2u3G40zx3pCwHP3kNIKt8AewK9mw2FNET0Ms3D6JgrHShi5JAtXCKmxaLCG1jreQBCrw/AoI/TGj95aV5UL4uxk0qBPgy8T1nwoW4X2VsuAA8Gski+fpn+KHxOu5RqkojQCgUZJdS876HVnNDjEJcAcs4yAGHJnwIyGLfYsYPiRvVa1jDIQH+iOYz+UTk54gCtyrWy85DwA7h2a7jLyJ22WASSDSGX3w4uEO34Hl1GAF8i1RHZst9Hyor2/uqWtzr3YQV8T2VJpc9h2o+z1KYACCvVOJ2LNrFZzQytkm0AMT9d/OCiPnxflXBKPBGa5wAx3Qn0H5Fbq8sb+wZbez5bxxTe5I2BaHAp3e+4Zok4AG9K/IeJ9DCjbhripts7F9tiohtYci9Jwl+ilDd2jrgAytVLkOeJ2vCGknG7CUOGjtleEowhZL0b4sTgfYzMGADulQyqq0Z25BdoNzEz+ndmN9/nOQvnWuOhiCf4i4iTAIuU9tiqFC/x7GBwcpnnuitZVdMnp+IJQEUbSn2PQ88A3htjMZ/TUyjU6Kah2hOIbJ0P6CKepYJ2B4kr+bBkvAAvDGQdEv5x030pdMgHsW3npqoimLgsA0lbKU9LS/7pAGcknRz+hUnH9LI+x6wnWkkd8U2dagna/jTySOOPn/MA/vCnCn8bKieRZcDjYIxI7Y54h5EJ8+H6OcfEuqBo5wDWV8Y0+kPaTjAWfelAB1byawzhrSwGMdgeq9py/uINANa8Xe02bgruThbHRxFxz3K5jIeDFaBSXTQ0c91Uq/UAjhxKurQVLJe7TbOifiP57A4yEAD6+9a532cYXYU4fAD/sO9kprzA9oy9xpObsBWVol/Ps8C6LZxtuy8lRLU5AKYcHXzX9BXMS5lq1EmILpfTdCSKMx+hKyilPTah4V0AXUPloCLMRxOBurYc92bfQqCxoOSAQ3xkV1LbHKFHTACjB+i/EGXuBcaIBVQL23gMPiUWEBvzY8IY+HP7yNz1AJxeTmezQmx8f6RgFXyLGVVaYFttStN09eaXyarwH0wAcYBrpCKEOB4WoA3PcR86dwrKfuwgdkc6tDVx3z5YDADBrSngxM0WXMj7KkQ9vL9VGeVIFYyvIMXb3DRBoBfCAFugwSXxl1ocKNAfRuYaRrAqo7CO+cnEQORSLwv0sggAKq0s+BxSreJcMBgPQ8WOmfFdnpTMX9UyhaL07uFeTgBJMv81BUZBBYUN7I0/at2Z1CVDItmsCK2L5JN2gRh/ALkdcVRxL99u3Fg5h2e5hPnBuxHBbQ/po0cmBLqrpTkATC1nYI5tz4Hkzv/QTG9s5Q/d4TStNbhzTpnjJT/EdQBCsptnTs2uT71NUxxAcNeKR/L3givO+0pKs1B7Jn/uACTuNA7Mzxz84YWbhwUkZjFjVXM7HY67p5Xht6LNXnwAnYV03SfLnN92ufmyHhvm3PEWtQR2pam46pw0WWEfOgDlFQMPfDfZeBCyF0ecmctTAPr/ry4F83E6/8c4Ggg5AMsdPv8YAT2P02PYgLGImZkeAMaZZLe2JbHT/KQmG0EAJPhBE8AW/UMkAX1TJiWb+yXimnjqZhebi2TpOZwtKwBgcDbzrb9PjxQFjTDYcT0z4x4QfVr4NgH7F14R9NdmAJYdqAigSb4f01lkV9xdNXD8uPIg7PlQ/gb0IHEsXv0Au4ZjozJZ5A/TS9AJO9WyeObfanMeKK7xqJQNb5MOfQAtDZqfGSyOyKrz6Fd57QqTubap9a8BZ2s5QtTJCOMlAP/jdIG0IdEjYdZ1tNct3wq6KMf1WHkEbU/lKbLtBsEAsN5MwFsqi1COcIu+aSNmaktvdaXHmOkA6JoiV0mWMwAGgv/7J8dcfLCNBVIpgzHlFuZ7+H+YI2oZHMw4IvlEAF+YglEbCW9B5PL07HQWtNR9LZVKyKAap7XNlO5ESgcAjj/gOlhJ8Mh4Ie7/Y6B6L72ps3MV0CSBp5VOT1BMXABjz78dZ9jNgVMHVCGe9ipy8RnXmA7mESQSi7FVheGAANvVOwFZuhB7EegMLYcT1NpOgqquj29RIbVFEfwVXqAAZ3VTkAOrko7b02cLr7VeNrZR4HqIj5zmiaF/UQWirwAdDoIGW3jIdg6AE2cC5JId+ApnXo6JnRG+x3vGDVZRANBxqKp5J6ajwDaL1pTjYbdVlV0OMJQfNVjWdBTBMcIAkpaXOVh8fthe7Bet4A+VzUFcqoBLnuIqOIiEjdedjQClpUo//WGHIhlDLPwWSEK2RlaBSXpi3FuU77NJ/UQgALDe4rXgNCk1MZvGRahT+hkxNafKZ+WQb+i6mFTk+g0AQOxriKN6iGEQ+F+L/c7JsTS9YLngc6sPHL7FwC5TBAB5GW6/4KZdZx3fFxoaHnPuFRQDnDjQK31oI2gmvuohADPZheRkoolRg6L7i4xJV5lX4Ju0jN0nhVQS9P93i8gAF0WGC/SkMdBvCxYxIqTmoaKLHZGMz2dJTRteorzklgCoBAunncc9XeQJ8YCO3SdSFVoOcgdLjfChrSfKemtCAOKjy9uXCDKwjbvmmfB6b+5T8O6CsIe5NormUxvumdwAlm8Q1YlxyiVRPPZM1rnOY6t0TlclhSgO0hBZR/3vxgDxMPtMcG/sV/EaGmh9nfjKOnnGvqMJVHegFXWop7WzAEgibvF9fS8xAgNvOmu5En5qAv18pT30jD+0Fbk1yMEAaBIo7upyXBBmQzk75cOF2yKh1mH6CIbzsdALJBIUOAD42OXYnnQg98bJM5PzsO7xZ6nvElpUqf6tOiu1aS5wAKfHiXhPPzo0v3hftm3B3bRaJhFTDVa8ZdriHMqifUwABJ0zzKcpKkaZzxA/CmYky3EpqX25uyCfAICZPhcy7QB0xhwHPvEaZZKQXPWnQTIPhq1kaoeVA8Yhtb34noHXAN9JMFdkSruYu8BlYSrsgQTEUDeDyik6yUPB0Jv+i98ADMfzVSmDaLZTXcVmCK/9xzUgqr0oewflOpr8agCz+AA/zEzKKCHrNt/xon/lSRZVcKLIwLiP1kKfe8vMS5kXAPR9ey8aTn4JuGd1cx3DXoe5nE3PgMLv9zCEyCunVU4AGGusZok7VoeMmKj8yjLJ6MyHYm9ouH0VOhYkAvfqvAD0nHdu56rZqAdCkGoBWw5nWIdJYuedD0EEWO9FixD7AAcPitQeFCXdgOMzeNUtgj6KpeamjTcJ8w6EythYH28AAZKRhJ5LEUL5ZIP2dwxNopdi0f/GZXlV/eXhdR+QtAAlSLxx7GPat393OLwgwHaSoP7KXV5bO4zdao0EoW9aADwDF3WRXzM8wWvnHnZs5ik30dY1dqccqBwiS0ZbkYsArMXWgOrYIPiQc/fDYHXTKOjYBDg8Ed/MRsiUkI9HVgAMW0Gh4kGngmAxqCpXYnvVKJ7DAX2aekbzogi16gM0AABgRd8Ec/7B2os4T0ALu2pFDpUska4ixJGrgG9IYYAAEB30HWMdHpkkcnj47L22j9+uNNI1K5e+6JOhbQ9pkgDEWVrXcZupPbshDz5YXvlP9gv62KhqCMuKSi2wbrvlAK3W5ev2J6s74Rrx5sYAV69nffyIPgPqH1fp4KIsEEkACsbB3kG5WY7JJg2TnxSH3RKEzk9WRtjZqmJeJLL3iQB0RzlSEyqA8CwzlnmMw7FaumGzoHpUBmik1n73h3ApACB/xdOdO48el5SPLI6XwX/rshtbHG+K5VFbxZf3lx8AD1y87K2qs5raoaHIaQAcb4nTpRd++cB6+kcrUTWp3AB0gIxm0dvOUUc3X5DPw2TSgfAeUynQMSCD5cVxDyyyAONfx2O/HmKGTS4HzONuz2miRzg1ks2ZsG/5511HJrkAlsslnC/Dvw+iXMV5wV8yFzobTJhT3t/fKJ2mjtF+JABmgKl9EsIL7qrUXnGXZkfTNJ+EtahehXlDn/43bMF4ACidB6BfyQMx/dW+/l60rciK1kMB9PLpSgQO33o4838AJmI9sjk0S9gw6Uset2Re45pQnr/5WRXu2SJIkI1rJADWui1sg51jzoemQcPQfojxyeEPnhSsK2QiDkO1i6Y+AMG54FAZ0l/reZYKXtrLjT+zf9CZOdF1O1NzHFSOaB0AM4r3FaroChbDFetE2iQeF8uKOIQ7d9pXgOhdpNWWXACLE9VxFpEr5BHBCseAUI85d1sKZNqv9fFp2im2XMKNAPIsYVJ3VipnW8yFAQ9GNhShZeRR8omGacwGITLgT30A23uY+TE+uOLvHLd6bwSP/roRINA3uh6PVLV3GlyP1gCY1y+goDcemgdvp9oHUBZC2wa+NCMdEPTyKcsBepQ2AFfniIPGkb0Y+j0YVi+L/DbAYu+xcG0vzHW/UMW6uUAATez0nyHo8lqzpqY/vBE0xH3znJcQreiCE2HpmPf1fAAEUMfeN40lGNnNKbpPx2sUZ+CwF+mt9yTRDrec//LBAA5TN6pPvklSG4CfjClPVy4dR/H/MMMZxHZxkdOnRusAQoQyySMnsgpt/zFZ3rXAAaVdS0YNtFJulqLpLPwpYgDc/isVitVEU/nXyrMhxfBNdj4U7wYG2yMn5n82e408AINYn+ijkfpAmqulWMljxL63HC6KmRjMPR5kXkyCwscAZnNgFlVJoSe/lFJ16aZvFgjH9+rHfQJcsfgZuvTeFQAanbgoXgskY6wO54hT9tdN2GGytJL4xxmcaJFFfVTrADDWePe/ssutLYwoD5qn1zs7L0y0c4YM/LiOgeewLx8AVY8oeG0fZJRM0V3upzZyG6xTi1hwgMGNdOUfuvgrUACVBUKf3s+kxkOvZVYsv7d3jHj5nGlQiaU19A6AEDXCABUt+TaBpHhzv1weABF/kbv5on0VBUWSOItJPo2YzKEAhhiIhuPAUOiw0x3V8bEwfw6DTzP0dy/GqOgYJ2lZZgBnL6DfwdbSjgGP9OZd0mKruWDiCYJWF41FxzVad0sdAHdx6CpMQZZB7Y6gd4K60lRAX9vIpvBNKl9InalkpdEADOOr4gIxbi76UHCaVgAhfDdZFCsxAuDAeiYnMNeo5ADOOKHz2oXkaNYsDmBBl6f9yY91rgxJYc4RCerAj+ZBABicxU0qxf9vdn4KUKuv9G+bSSXYm3S/2btdZzM3uBAAVz/Ez46Erng1/bDr5OyeGYiF4D4vJbF1qp4v2ZF8GQAkDyjVxQ94RRnOlTvKf+E6mRM4I2CPN5nE08cQfIXVALF1VZHr0gWQoe+aVPcnZNA3I/RCG0rOIyQM1dr4fiEA8Ldcnbiru1KILrOCUDtiyfvmj7wCEtfasE/u4go1nQD75+gkJG11YFA8IAkPfcGEkyZBRvfu2NIpFNW+US0kABkN1kVLqszVPsRMDGimRxXX2vVuebLpvAmj4Ai/lA4AjGpxYmTVwedlo9Rc2hvlPLFsy9GVdFxALQIKGwBOugDcS1ju4lu945uNzogTbhj+xwK6A3cAzkUMgaycR9TVAM3xR6S+j5cdpJvreNKX2ZlVgpgpqQFZz37+/z35Gl4AgPqsAfhPRP2NICNzOQSexQqvuL7vo5H4g4tzlrBWHQBgO+ZHEhZL2VV9oJgSp2CycyJhdJlazT1/wuQ6fGQgAFQe68samdCdkNdMoNEBEEnlXw3BbAisRJC9IuQVIkMAQwDarZPpBOGUEEzX7EwzIyIl0dUuBe/T9fJwpEbmLQCGhJ3OHvf/g6RxxMsuPZ0m/rTnTSxTb4G/zIMu1MVsAP1y8T6M1m0VV3rxDnYVr17dunrHNkjfLzChilCTz8AAY6xyxcfhDCrroQnMfp4putWCS7xgmI68di5AH2Q7gQB6atTXmCgVg0XAuDSMA81cDceQn8CTlB58xD9GEifNAG+flOEksvLUhy46CLU9P/wweVZIiqrP8n02o7/q+aoAu8FOV3S9v58T/JlBjS4ykG1k8mnXCaaz7UnMt3pEDgDiAfhjDw5DKc8CX3l7HYVvAp4lNUBF5+eJdrwOZx1TADcEazsRFuaDaVxBb5OwRfobqkw4GueZSAJjaF+lp40AFecSz2SSy/aJl3RRgwntMVYBEKSgCN18aSStvSuRxwASltDJGQOTfJrTNrv2KS9IZg91TzlyfMYa1IED0laCAP8IT/4xiqnf4zNoJj31BrLMgitUCNWunQJNczeSBKMAF/rzD4cgxc2vJ6Upbn+8tKKjP/x0GTBDxxdudlsfwwBbamIzZYtuQs5QsGJ2pA0nTYaAsmna69xd9d8BWaEcAGgMVgJgyTBZmcIFPwdDElSkIMFG42rM+XwjEUvHsSAAaZZ7qMfIluMcwwjLliuE1EZgQ36MbIdoTYpXeeZNbQBe8PWPp8Veyd2ty7BhOxNl4P841OZS38pEnruFUlzKAH034mBYEHH4OaRBc3vGtqDRBQkimbe6pOH7WI2w9n0AShSQiKdDiAmOBSXbYfR/e/rawkRbeWNcoTeaXHzAAwBrGr5KCcb2LYyS57hef3UaWN6fhB7+tKS3BlFPLqrtAMxLvCVISHmga+Zgw6WqBTKqTDZnGMSdYPzjzlawIs0AtZa3ITmoa8nncTQe5EgNek5wNcuhxRY0+IqvaD6FmgC5wn2Hmn9YqSSwT7SQrKeecpoHZ8Pf/g0Gg1gBknBQAJvQ5t8fmRorjA6/T+GQLrc1NUwCZOU5KUCUdPhPvlgAkmrpOjqaouTfkuSW5CQr9d1DPJ9BTSnXZUbygTVOaADfIGeOHwFYsdIULlmcFWixFN7rzaHMqP6IIgCgNu80AChO/DmKc9Bgu/02O58SGe3L/A4VkR0LnYvzmfNjqXkAOd9Kj0p1GQHCSnPoSBhZGfZbbYuayvGgJVpNzS877ABRAwsgX1kHap+vksGx3FPHXFCkboMYVKaL0rXFx8JeAEOdYxsYPKGd/MPXs48IeX5s3KlOMMJyzIWtvZI8ZIoAFIOY9ZibfQHtXlMiblaR/AQxv/uvJ3I+DBQMn+2zhQBPDolOmLiD08XA9MripFqJggU24xgBdIR7eVzrJZgfAM9c2nxrl5700TjyKEZEknK824b4wRFGMT5Xt1c1ftoA+xPeeT3GJQuPrpuA72/8UUl/DrTML3BYwsma/rJsHgC3QW0beA5pXBsGBrwKUcnQnmrTr+ad7b0Jhf2moHZ4ACS1CuGqYFiDby6Emcj6QhHWmEtK++FHnz4sNJNIuSgAIybZwSYhn6FgFuuNF2cTaB7LjfGDPANcRNwgoB7keQBRC4rQSf5yc13Yli1xsn+zAx2qZo6HAVxN2Wf2pXltABs9FCfYr614Yi/SgwNn9O+PfP8OQRNavFG/lRUoBN4A8TBIDI5OeOHDhxFjoa2HxeMmrhmcfLGSmP0lQXPXHwC/OKH8yPJMP/HffNTDp83j5bcUHqRV75JCJkQbRJKfACXJ8/nWCqkENjfMrjpCOvK0d89slqoFrPeHaVhCBQoA936rZ2YIre2NCVy7bYg/rFVoDJMLVAoolVC+DpctuQDfglfpkMzOH8steff73iUvyB30maJmPKtZ7qxLPb4IAApRBYgM/NdxRPKuIunNwoKytsUw3vOOUTsLe4WCiTcAklSNSu2VkustkljGTKhhlc3c/WuXKerV2S8zu8A8sgD1hoEvlwudRL8yWMC8dp42ipFW3jWSH3UxKR3p4mZIAABeV//QkmbGuxbycg3Ov82Beb7oDZbn1/2fpcqFBzIAeMLT8RklLVxgL8HZ00Dl+7/kHqJ4L8fE/Y9KGaB78ABccA8yi5Dw90nudEAKwChgulGy+9ba32D/cp9t2WAIAGap1AqOZrTKQOxNgqhcrcEdk6F0RS9OQsUsD2FWNXoA0XO52xH3rFye5VFgIAdu0IRGuX9JXv29unu7u6bN3AAUf/UmKqKUKPSCoqFvJHEMPw1H1rr7haeUe+uV6ck3AOZlT5SiXl0ZkTzF+vtjH+b+dPhy3QvDrA8iQUaLohwA2AX3oGGNkKuG/AY9P8QlvnHy1ZiinoDpOZnaTuRgXQDv3oBz+RXNkbTuwNe5rrm3kMhaDJUEmdFSwb0sT3jEAAMIWOqx87fIcK49rJ2Rn6l7aGFhQRxXovvf2n00qJ8AcqYVNY8qD2JIEJ+KWB7WqxDIqKRWlWopK/2MmCE/fgBNEKQo2IJWWcQDALfrWQznCzJW2gbcDOtik9AlQG5lADQxqsKCniYNsiIbe3qzjx2uw5E97L1ohr+8UV/FnOkAwNmS0+YjnZETJcYdiJ9bryn7ipoBHNZihTM+LsyJ9QCXFQclinPgzBiSwnqqlAbo2lU/LQ1qRMPt4m+HI96EANLiKZB9LPzVhbVA/QaDOYQYK2YIeGhIF+u65zXTiqcA0wvP7diUc+gAtr5dFTT6art/03n0tuY7Cj3qwBb/9QDQHnjFPrIgk6KzQJb1jicCuPEWHkvfxaeIjLoKi5FJACUB0ujQMq0ea77xeb0pRic1UfoVrxOfK3n2Hv41D98AMFm67OSfUUsZTY/oXLMJqq+mmpcOsRQvPfwAQ9rqUgBI+EiMXI/VJmmXXunCoKOqFb2OAFtqaCS83wEtHSR1AMHT/++l7TtOudLlflEh3gUpihRjoCzX7BHyGJXpL0AAMDAS6WoXHtgF1PTXi6emo+3wfvssxiHyCt2QDVm8/wCKiRi8kDf3Y9aqb+MvpUEhubydzsGCCvitjsp+VNEAAGpHGOB07Pvi15v20JVnLdmPErJd0e6RL5DnjQJQ3xsAMF2R4/LZdwAr+ZjC6LAFtw+f+iNLatapxnqeEfH3fQDYPPseodhZFm9NOcxJVJXbChkYfaMT9CTRSp/XNxgEAGsNgZetE6+yhxnOLM2zl4xkFaO29qs0ZBqDt1GdtfcAoImuyqNZAsmezSNzExWgVn1m/bAmxpDNc/chOUr9FADvxBXlMYpxLaLQNrhRpjC+87hrM9LptzG1B6gUgl1cAFzA6rOC12BIl6kgZBUZAByINvg9+x4bpW/Mi764GWkAQeZGSRL25+AE+hUxr9kDvt+2fscGX2j3jGoQ4EbhBgCKeCxWQ9aPKweIXSM28bWW05cXwzp8BSMdyYCJ6VviAGnB9E3VXJQlIl8F3MUa+3Yqwfm417dK6eO3gX6HcDwAMw+qHJhNhQnbetk28qfiGk9BFL/04jA6042kjp27xgBJdCYJpZRcKSrmFfixNDmdQUGVM95f0S0fqzl6cIzGAEx6cfDOhhUvhUIOXr3ik0hf/0J8bsfqdxqXECCGmQwAzsWx1Qvy9TTyoxw+1mfaT2ZJaxbxlFkoR3FU4d+ZagCj93+pqAfGm7v+UW8c/0Rh/KoClRPnabI6cIHDxeOKAO1jbjWMpbB8V8l2RL6F8ZFbPsrioAC7YmZrDhBItzwAaQp910TnsLfbWD22JQ4QsD+eKPXS40xx0Rp8G0a1FABKbWNTpb3HeL8tQikw0p9MTbAN8xOU5B+F2JukonJ5ABUf6u6YSELRrio/TxWcnLfNQHgC1pm+xvl7VWD/PB8A5aBQdSJ0a9SaYUPoXAQMpsR7mNQRzc4I5h8ZvlSzlgDQlieoHhzptBxw/mSZx2JaWYWIzCbxR/QUQf0UFbC2ACad/aS1KdkDr7uXRcfuj8PQ+vYztkZLdJAGF0VmhdQA35hWrm5bBvZHmYoQMWRKrBSfDJLnVok3KpR9tcCikADeNqVVb4A1/U1u/4Rd5xcfc9bJ6AYG30jq4JvYzNsgAPwLQAq+E49eihUsC4BbS2qQVqGLbrSiYt2aewZyuHMAAWUjIsXtM6wKQHFU1jwtuhd0Ezs4CBJuaL1aQRQdWwDuWUNc91nYITR18cYLPdMnMejeAh5DFHhGnzqtIcQJABPjRA4udUAftXZqS3c0bEax/+9RujrMfoE6Oe+g7zcA7mwvJ66WCxo7T3+AzqMcH2fyR5QJAHg8LHx4Yex+fQDBbPF6Ij3odLbPL8QlJ0xhtZjQu6z73PsHjNEGqkk8ANHTHeEcQkLLuapyVN8oyQd8W4INB4QWLnQDT++Lc38AIlb5hd5uN1KfzPX6BXqVxBw0zufyc0Yg3aTVhGzwBwCILJ2iHuJA/OFxjT/+TFhCcMCsJlcAQIYdCtjT2g/+AAqI8BKIEUoeyywRjwp4/zIwTJQ5JjdcVAScnSRA4qkA5HNG7DSL5CQKG7OIKRuZ8vOpLFIQWgzhTcSzydTAawA9xb/uz3zsSpP7O4DYLCmEl7OLzJNEbmJvM/78p/CbAGnrStiB4ZJxxzQnIoXu3djDzLAFPq3TtJBXSrkN0e0AcFuFeJmuX4Sj1r6muWDdyc1off7Hcm4kr3Wl66ZFQQAVNNVcNRIGKmi6ws7Fpt4Bz1Bm8xr9SHyR76dGjxLWAE/6kI/lALj14HnW9+PgOo1Fq8nneveCvEfqsYrubA4Ak3/sSBYIeFyC9K6VEnFEx3d0Sie1jf4zAUu1UhoCSAAX7nLNEhlDsSjzKUZU9idVCWB7CYQw8Da55Jnk/TvpAAMJqmG5S6W27ITr1qgs/ZjHdjqaIi3EmuYMzlrEEVAAb8aZXcQ2PQKuzzsgtIUuzNFlmCLu9fCQAQeMgZuwUgDXcavWg6tpwUdpj+Q3jUmCh2UVaJ8tW2kMvxlS03mfAD0/O5J4/XveExvCIybZ+BJtIEVqAhdjj0yNpndVW6MAUYwY+ZVYZuMc6AMyXhEaeSfs4L7o4iweprALhGVZigAy+gdc9GLnLK6NMxsHPu1CVEtMZ548dxnRePojkgGTAIvxp4gT0bRVwFvNYWx1zyCLY2ivXXmsAq2rb6xxx1YAlTycku8GXx5rJuQm9HHXRA36izO9LCeoG15kTkNvUQAK+HdbgOvUeG/Hsu2oc+ieWBomU7cVwOtLTp+lAcLlAPpZy5u+AwT6Zf8bsIuopiJUqwmbmyOgqEiAYy4mX7sARmBNsIjxkR9QC53o+QGG2GAOzevZ7iDyFml9mk/ZPgAGycSoEXg9GrsRBdubyLlfZmtaeXRU3cLMzdC5V9GLAB5Ctt0yVaT21Y088FmWGlLJSBIKzjB7VEHU+brlnPUAIs2sqb9xUPe7cXIEII7hJrkK5rrzEY1XdtX2zfE5/AB/xIyX/H3G+vk/bSY8/pgYIC8vJz910ntZ2zv+2x6qALWBDCCq8XNBiNxlWjBO7N83JRaWzIcZBnbf2rK73GcA8ZhzdiB5O8eK1H3F78rzY6wODFn6+B3o9pi2PTnvswCo/QNTGHslV4KofXpB+Zs/h04KyGexJYgmeRtaNA75AHVMTTYAQIDwxCWAMmMril0kDcU0GpiSUIXlAd6lkpkAlimaNVHWuB/o34NYK0Oycr8uzxPck0YbOj8ee4bt/wAuzdyVK4IoPjw6onTpIirAHpXKqLxKWJlJBxxL4s2pAJ1ynpF+xskBPKFr3flgt4kEdx0h5MsHDd6rPZWYjp8A4nrtBCQWbCzF2muhjccVUydS2tRNp76wV3mRpE85DwD6IVpacq9cHXNBtR2mGMpDxB5DwnzAT93eZB5Xr/lwACxmJM5NjB9VkwUFjL7bOATrB4P4X3voDpi26KbXDJMAzp1f6eG4+x6zrkBdp/KhXFyOFuqg8aY06ecXki0E6AAncR/QMkLFBSiFJy3l3CzDfG7TtRNdV3dY107NwKMzAIjU3iSUdpSvMPxW/eyKLsqfC/VDf6MCh0XhIAOJlh8A/kKTMxZ2y5Q7MGlAG0shbdam8QUbbOrWyTvwt2PBuwDcn48mhrymLnPrNO4DcjX8J6OeHUrxxhMQhIafTy8yAL+oMfOdinKOR6mL4xYk6pZdKvQHnd7hUByx3lrwJ78AgwByPo4XRG37N5kc6WH99Q5XLlPQ/DBG8JejmxdNvADMAZbBKLPguF+kOFPj3stqs0jbM1rmWrDkyZ/u2BUHAAtFlW7oZzZpZRdpIbIkPVJIbAUnuZXyhRPl45rpEIEAstZ4K00X81HyzBWUKjDcnRT5PlcA3ANrkczpIGaOQQARX+w4nTZ40YRUU1YScYwMQeku+utfGYOQSN+O2OmWAPMc/eBM/vLgpVgCD26lGNlGmv66wnGrr8jNrATUw+QAWn2MnXeHbHscatka72fAoMT6ua1AR3xOQnK8rqSQ+AB5jGq+osRO2QCDp+k1om14nZ5Mrwwznip0ab9zdOLJAOkj166n7kJGFU4SVstpckWqzku31AI9zFYj+iqBTj4AOfb2kSfvVhrRtt4dvaH7x/R5mY75QImrfVrrJqJupQA35vaRBfxngFAYWTzRgA4AFZRjfERfV5fb+cw7myneAL5Qu88P3BY49RMmdRtmQtyogYnKuQUxUs2+8qvNU0UAa/1ilYwOS0UrSXCECnZTouaa1YgVqiZHidXG4JMSvABZ0Vnv07dMXN28RVriVcVvdp/zE0Y/3HssJC+VA2AgACg9YKWNCFsZsQQwpghtSyo5whGhj27dI99XdarQlY0AsDp9Bd+7MYDfEpEYFQlaNxkEVYZy4VI6typabcwy6QDQ8Q6ZD5R5DrLGFxqGd8b5LPdg9xZsj72Ib+QnYqEkABQRBHLqeuTPIt9dq/KZRsip2sFBOUcMgZE8I0KKT44AavK+3S0lzZWyOsSbwnbiT3FbMSqDRCITv7Elt9fZlwByep5Rb8aYAb2xVxb8762PSOTn5q7rHZAwQCERX+LWAADXT/5C4teK1RY+XBp1VXggGJ6czc8PBDwWSQ8IULwAD4XBG0TfNoYc6S2XUs3yk/XxIIwXoe8XT7sCrfYpEQAGyy50rRj0kwXUS6L4OpLfi8DGQu9ObYeBAhrv/Ap/AJFCKIuq5ymNnU9wEVy6Un4VVD4KeI7R6M6pLaSPCuUAWS3VPfqlxBB5U5cTvWkG9hTkF9vYiaM+MPmCDtQsSwBcI+WwM/Zo4riEvqfuzLiUS+wisLL0SMmj4Zpv0QH0AOwz0HoOrD/EXs0EJV4RQ0lG/2NWY7PjAP0HhiovUAwAbRHF5PRHLmxk2qO0nD9HWwcGErAXcFz1+GP+WiXR/wDU7c1lWckCkSVfMDJKjLNqdzLiI3xcDSMxaZpaSG6pAMTctSUBwUCVWh9SN0to8NWeEIEILZSRDhS/JrgwFAwA1HFXgDRoDgxYTZq9YYc7B7ODCQQJlQrh86JULxPQyQBWHO6TSLcKxxFr0KvAZr0W566ikYg2b/bLGhXQ5gurADqNUZ/Q9PGSTw2I9rAF9og4AGUCp+CcWtYiSpvgct8AWUgkDTQDR+luk3WuEwsRNQJHj+DeDLxpY5qwgazUwgB5Ya1fBDrrteAZQ5yoDkO7TtNTxbxT0z23nQ+VAExhAKCMlMQ1jJYpmvJAtFfhlMwgodWOsDl63YCc8EYGMLEA7J885uTkEs3HDK17FTU+AzVi7ug51848PvAdVN3unQAjEx1qTbvfPRbmN9a3OBsTE501S9uFeesFKAvONY+KAPdkngDpsOJ8C8TsTR93gyfhYqHFzJRlTsqzWV38H4YA1t3UR4MuNQ7Q6n56Y2YhZatCxl46lZOA95Ucy1NPEQBto8DtKNpm1Dvfvy3UJiDKi4s1E40xrvsQy1woe86YALYwc/s3inY6VVEXFQc2UMd7jTbRMt+vWpKTDw8G81UAiwNB5Yjdidjw5C/shGpjOYIG8DJ/h82bU2Wd8x4oiADr8yJDO9jcRe2gGRUOdRraxHWXtm2O1xKm+/4qZW1WAG4aSfElpY7x3KZeJ5OuCg+xLXR4CbcVtpp2fnhj7boAne1zLXeR9Uu3h8FbWl8ETTuyHRRt6MJHFXb5LbC0gQAKxorgg/RdXfoakA9WfB2RokZXwaYaYvPTmkakaFhzAH5ENmPidbcw9NBmcHKZLJLQZHF2uNlp/PfOZvuYO74A7TV7Rr4sJk9MfdZt0TLZosXdN9hMxRAYk51vvlUPYgDLtZmvQLJfekT0o0flWbUfaqF+IPt1EZPhNaeF61N1AG6Eb7zbYR4LX/d2I/kUdyJuK3gIFsPqZr6/502m6VgAsPFWzsQb1mDW8v+zrzYZoJB8XzZv4jmiPC1lQZ01sgAptdNkdt93voj+QVA6RJTEoCiUmbqHqyII9ezFUV0HAJinP/9xLpMSCjvqdZkz7l1ecTKSFx6JGEaE6rOhzFEAzKsbmWxfhqK1SzubB1ZHiBORiEwCHdYGv08p7S6qpQDQQHp0xYl2hhiDW670ZShtBovJweYNUNvNJx3dAvE+ACPAlEt08WpDtgoBDqRd8a0F3eKKwzzlc8dUBxVmcYIAfiISAcpyjrSsGpAvz4oDoScCqnxWpSUc5b9WmKURRQDDOsL4ScCjzkaMDsns89kxdpF83zyL1L6ru3y2RgPGAA1hjoYHGjyfS63EOq2j0yapjOm6phNshM/chab3uFkAGnG43zGTXTwwvmWCWgI1gsczgqVPDGDoL8YeupbTkgCkY0x8obQbuP/q0lQKphq7c2Zpdyf4vYlpbavjhddBAC3YbuvwhqbdRxBA0RKWmQcKtOWI6LgktkjkOM6uoGUAf52t+FypUKyFo2yjkvkWxjAEpB3f3gsJoYzCSwEcKwAd8iM25J8h4T+rYOkQQEkhFVOG+iLhCgcM7aVi4yRqAIak36RdaX93WPJzLqR9mYD/YQx82GZptpHoXWI771IAsnDED8zVucQWQuQ4hXdtXRcsezBPsb3iTayk6Q1gzwBjrONL0xxSoVwsZor6pIncYEzdhMIQh/DQYSfURIYcAHkZ3iiNqDZfZR9P7MV3SFxGF/QB2CcdHAlgUxw8LHcA3AB9wn3B4u/ww0/z+WBjyEPO3iPtLCp0yyqhrxgAzgAhNLeqtwCn966yvVgeS3oMNKDJP7d7noWTBEQ15bvMAD1QWzFe9BDiHsoLTzkPsp7rEVcHzrWxMTOvD/7+GcsAePXGGNQQhXrjNIhYJpUOdE3hd6MyQnBmXCi0hY1YTgDxN/7+k5vXUO5ZXbFVzRCFTHYGWEEAppJpA50NsgMhAKDrpFrcZyl+Iw5MkQPxCkkKsBpSWVPvOnZqaU3xvSUAjujhi00YvQqWsMQ8xPM6co3A2NpCMYcNQ3ijjGu+9QB+83LDLewHPaeglT9hYqHV4LVC3rxqdiljTt9NzomNAFcd2TTDdppJJw/yRjofFXZcqBom8zCz473U/BcUZt4AC3PFAcb36w0T/mr7RvisfXcfMy06l5yRyYPyvzu7dQCG8nc/2AmUVIqsYke/L13/SAcxeKArApdcIJRqivamAMtazBja7j+DcvchVpw29YMKXlAFZdFYxmLouEGE668A7NxS6hK6goW18YYN1aVemi+Tsw1vdz7bXQ0NBMdi7wDKkzuDS8ND1Wzb4fvgVN0KOkSDesA/0yGpBsJPPJkNAEy+f1s/sGUtc7HgQXfY7q3yF4Ur47HXev/RSTqwgiQAsiEp6XSGUWBOqDF6FRHz0ltgqU8yvb/P4+YVVhgu0AAwyedfIY/ReKY5JMYvgdG1TwMtLEMIcUecvtRRCDcdAO84mk/YToYZJ5U+QrUBRBGAzMlp/S30dp/YxzlWXOEA+VgrB4u+j3NMw68HwhYwxOJ/lV7AoI8M3LzSiPCwJwB5a4HJDIIOlFFJFsPwFiOppcbWwM+VuEGGdpLyO2PSAJMIB3ssFv3qcTah/U8+CfG6LkQCG7agEMYoVFJJK04AGFRo09saMHyLhV+LohFlCtHIMmK/VWjWZhDqQT3pNQC9b3i2YcOQfHO/xVYeYWoSO/J0vI8X00JL2sttlxB1AAlqZz5F9NWQQtXCUwf0WhaoZ6W4RroEV7IulSQWz/oAsUDbJJobrQF6vyxzReKgv+60HUn5AiMj2ZHSSiYgQQA+Tbdbl2zW58VHb+ml45fDfl1ZtBU2HQz+0Yn1emWmAD3Ur5NhbflJJW1COwYOIu/+X3kELVnCiKCl0S+9lK4AfXSwPFfD8RI7srXq3AzpEaWuqyeoqm0Rbo3F0jN57ABq26x139Rz8GYDs1iEQV50TLpD23oxnDhOtDS+DRiPAO5UCOJFSc2/ZHAWM4h/SxMw60ykZRUXrEIkQhO+Gg8A4F/zOV4FRubPCwoEfQ54elFktQXa/9R7DVRtFSN93AA7QiKDvDI70FKth9dYY4kP/11zMCGzbP6IiumqV4lTAAI/CDF8pL2j4j8xrugzi4LKyPOf11NTdDlE7jI/QiQAmxxxcEAMZn+ft6m5IfDIFwCE/+yCTJw785EJ1TWhfACix+RJlc5f8kFpHAaxxQeXjAAy8e7xBcEfIGPRexKdAGimkCKTQpz6r/vdHh+14/Xfijd9P468PC+xbLIjbkkAZtV2HIMqJjTFijSyUsReeAVGu1Yr1+ytpNxsm+3ztQD+rPdZrnuivL9+rYfZStYAuOxUdNzYdAh3aF3q0auSAP0U/qW0M9C9p8XBBEAIOW/oN3SSX1AQgMwGN2a1OSAA05bJnpRFGJX9wju1dG6RP6AcasW706AiyS7s3EROgQASD27Jf6mRQeaLGoapzr8I3sLjT6K4i79LebRTvZ72AG/m6qsCIJZWytAiPBaie36rM5xFj1mDlu9RKJC2lGQA7GWzyuakSDefs+F4fdXF3NWtwQBk2EXluhnFw48AsAAeklvXLI7FJgH1p4dzhBEp5wMvz/dWjdcFRsg116SKAFWlhp4OiiYY0Zj9cZf9bCNGt4FyhqkxV4w62yI9ufcAQhEpREagHi7jUZUUJ6Q3OqRqwSdlixbGJp1BcjM2+AB6FiBnakj757GCzMzIQ+1af5Oy+b4wPh/rExABiWbBAAX7TRGDLaye9QK68mMk6ZnQYPChb16WKJnHgtaSOKYAWxgMNeUz7xPi4aFsO/Kj/sXMd4DEAG4r2LORvTbERwBTmZ1pucn8afUo7UjkzrfJo3JP/UD/LcF7NoQLbVQaAARH4yoeFR9FzHAJsdvTNfVkrB8TEo4FFJQtLH7JXXwAriqn2jSYrVGRprIUQXqAwhakn5ixOGo9X+OlO+psjgAKuzSO/kX+JdkopvYLmh2wiOUio1LIrC1MnbjNHNJfAE58C7UKgyo0dAQes2HhAKB9gtXK60duKSVLa/s6znIApahE/tYQJ+iNqJT8/+/UqJmg9j6xwxW9/gWx0aRF9wDXJcR84dboKqatTP21WK7Knf3bdMm5UJVT2sa3w/EmAA/nb1mbP5nJpdCaGynmduHFO8dZRgJ3IxzxdfCjB1EAl3c+igMsOFAwZjjSqRxeNrs8oPYGp/X2o7LpMgY0WgBLGTg7AjHPAqk5E9n6J+J3lRC8XBhKqWHgBZqseGmhACV3ce2kLTlz2nBwq9wweWDXq/OK+TcJEGYFllzmdmYAc3/vUF5QU3KYfi/icKkXzbHmkDkDV2tB9bXtSjS9bQBH+YiHi5VXVQ2g5qiBufF92w1w1XMwE/lFN9HtGpeeAPh+Om79tRAgDn+qbNP7IvrCH4KFuRpwqg2GwQUDIwUAw88BsXglmDd41c0mSg1FPnnQNmyzPvuw0oH/BdplaADHWOnu6fnmSWwVr29Tdo+aSY2lVZ44xFxscVxyKVIxAMerNTxE7ifWGs2aNIdJIdEaTheRrP6lla7t0OKGpXEAGSpULRXslsoSIUdIWECjNf62cU5Z33P//ySZphdVVADyhwx39ssFvVJX1/vBdgVmuXAauKrzd5lz6pOvrzeAAOB2m411J+fotFsPISufQ9dXjV/z9LbeooC4HsPYOAwA3hBUSQcbI4/4ecc4Ul8CdTO7jei/Sexq/tG8ZKYL3AAnf7GYSkxnCaj1clrZQt7YbtbcRqVLT8T+RaVEreJHANAi2UMgKyV41u2jsYBk+QATLatDXiTYtoI8DuloKnQAN5xb5/spBKLYXdy6LhPemtljJ8GNcFoIVXV5QlVrxAD1srK/cpqsNQx49FnNzGIysj+qJ8CvQfJ3t0E2QmspADEwWtAUwC4BF5q/Ri4c2lZpJTR9vr8xkAToOTBWYDwA4CaOO4YOOZ48UtG7h3nVFDnjFAvanUB27lJdhCRehwB+Tw+gBdwroqUTxxiRhvHCBV4nzxewSasP9CAyPVrRAPEb//pbJmdFPEAI8UE6tntU812F8eQEGmVTROtjHXwA3GAM8rw4MS6qziDSQR57ueCx4GVa+MYGdzEEiYftTwDJ9dWBLziy//3vxCQcKyPZsEkdltCedXzY12w7rwx+AERTxGdYj2iBKHH5e623fFXm3MEtU7A7PRV95N+MGvcAVYFqAL1XpBeQ3DyBl6EdcpF7fmArwJdLsOKoIKG9oQBVeJHi/CyJHULmF8BBVodt7YoevcdMaqHJ2bjjRUVXANZ/BV8KVwZV9+2cLqGzQtC+xWQ34FmbiI/b++kZ8OMASgKKgz67NEQtPmGXn/Dy6JUOYW8vSRX79cbgWIgaxwDNi9LTeuqQcfFOpjbCNK3t6diwfRKdsE6Ntl6P4aZiAAFID1KwGiqRPwTF85ux1w0sUzLXg6tl/KRBf39OnPkAP1M6TR5FzPcswXvmtOWfP3aUfGAdfIBP1waitBJulgAULKwbVRveUrBYv5IMdcLx8mS3kCZjPTlcZAUr+gC2AFLPt0YmOuDof5iQh8XJoIvt5fRYiuCJ1LPfbS6AVJIAz2jRgTPWi5St+wQ+Vjgu8VRqHamnCwRIco+UgRYwGAAZ7LH7FyZPRrl6NjNjhG7lf+EOVuR4aQLf3B5KChdtANBWDRlm1Q5+M2vSuXfP0EZnH5zZnGwERVY1TfUxZ0AATATYcycUgPBZnf0DVcnPhJ8dlFxZrT6uHrm77E6UWgB1dFNLg2geyAfldPj1DlYqAVd0z0GwFjKb5z6B1uSxAMLuie9gpFydoB4s4h9Fc56nOM04PjA9EbixqdTJ9igAHYS/2roPfvvO81aQ2ZOOQTdDvTePltPdoVCi0ojWvwBnHBtP+ekLySFXu2u5UxQz0sCEgi0+sMBVdwdiktT3AHuiHoOk4X0r88JlsxXN059E7gPFziBNNPNpKykKTiEA7NWntSLpIDXpimaRYlBcQwxteTWUh9PD4Fppu492JgBY4pJWStU9HMYYspChxZYatfJD2/LTIgyDDr8fiuMRAA45Ik54MrfGRq/ixKReHGk9LrjBYpppd7yqLoWlMegAMOw8aiPlU1nUomMFnhJ6H2iPd+ldrDikljG1AdZIVQADeHLy/nSPCGnaEb21x2yZxr/K82/elmYN80HPd0/yAGw5UVcrQUpmgQ3+u7y+iDo27O2Z4XIo23vfdLmbVrgAjOplPrk+cPQxPbSbXEml1vfTBUNF/lvQLqtqqy2ExQBbvbH4L3LE4sw0AK9jvaa4r2NmJlngpI2FOQWlcOd2AEinkn059w7rOrQXBxUEt3DZKNKRYwuOsW16Ty4lFbgA034Tmhk2rdDbKK44eHfi7WksNLQ8q28O3DpWLfdz+wB0pNClKhIpqL+Kr14Tm6k9fpmBZoLKJIbY7fCo9aI5AM4DzGvii3GCPcJZaU+sLvYgABgQAuUIIkYlH2v7j8cA1qblp+ryW0I2cP0iryIWyd+dClFoJvTIySHEeYu8UgB38nPhB+/iYYjogIqg+fJctUtrjJC1f7BV12qkMmvmAH5ipwUp5vkyoj9samhpnzbeTDHiU16jGsWygkXNAkoAs/PzdhPOvRDDZGopzCuA6WtvkYyTnZUv53RuOKWtRQAOI/C1DF0Bt51s8Sjvv3eNfAPlKDPE6sHNmQ5vpA+pAI8iGms2sSVa/2eC2psxq8cTfuWQzaKSnivXMUMrqX4AeEINlJH3aama/mc4OQ0VLcsvtvDn+ySdeQTnHco7YgDbyCQ2w+nN3JjP7aCWq362DFn8oVbP1MrwQS4fof78APeILjffbcb/GPoVw/nvHbbgY4QDVGl2soQSEfObx2MAwuXscbe7KqOUlhbm4S5+2im1nzvS0+vJcAeqnZYhyABUk8IR6cAI366X1x2taZ5rU7atcS9E1z0Q/qi/rlrgAE3x+OHEDu6cUfgWNvmsNeJEbcF/2UtZiQ4PEgesn1EAdBjUDkjy4Uz23/ic+aHEPgbP4l8MYOogUARgotkX3QBR3y25+Omcfg9tiSDeE2nMWYw4SAzI11mD2Z+QasmKAIWaH1qeK3c0CYv3FXbNjWx3OlAyifajW+mBBYTXh1EA/o5YmBG2y5e+ewI/aFy4JNvhilAjAztYKIwUpMRiZgADXZ8uGphf0DZLvE4RVnh/8zQ8coKBuwv+uH+YXcuIADxPzIuIVBehrnRGe7EBhIu/KrB+m+8qSCja7ea/gPgA8R8rxo2m8sw7jUrMxcTRZ4hOTQNuF+Z6/GMID1wz3wC6iJy9e2NQ3DP0ciB8nnW7KPPwUcxVIKALPfADd/iUAI8A3ubu86WcCQyQO6maxwkt30qQ/rh+VEHUANpSkUoAvEHaff+jEiHAbdiBcjIvcpGCoqiHAPBsGI/A71wq9wBn5R0cwFyTFQju9Z7TLh+iKwxh4xpC2/8FfATMauYBAJFu+et0+KHjMWgdiP/oC6NtzTSalSEhrXjLi+E/l5IANPCFk8gOJOuB/xwxpQ4soIOQMzRchgtJkIeVzPT/sgCOqk0Z3xdYFNJ0sI9TfO1/Wn1a8d9ezD/v8DFaJfvgAJH2Sp/rC0lleKr79zxGGgvmre4AKy6q/des3WGTDZYATETgja9+quv66hV0SiBaZmx68/A6QUHvhWNqEcT/FwD5WtXgZ+fM6ruqVql5uK1f5a+zUpnpqTq2QlvLUpZtAK6gHEL33beHsqLilY74p4umRy5saMX54mrCHZaMZ44AJmSQiehXkabx2ghG5op8Y8Zm9Z3UtaYzbZ1VwS5PFQD0Kr6sUc5lmgiV3Pp5pDhmaoJnOAWTlkuoi1GClt5eAEIn2wP7AQAcxa0+EdE7tJFyWAqtWm5I8cBV3QrUDjMAwdOOwUaPH4uRa81/TnrMTY1DQUFcS+Z9gb+wzdSiKwDUWyhJQYKTSHPgEMWqH8bLkbyc7qopfPBT2eXrnXVUANkxz32tuGIJXmwbByYmO3hjKIYQ7DX+TCaHC56gC6gA7u6XlCcXGGVCb3eip2MBr4GhhlyoRq44NF49fgRT2QC5DTs+79cC5jcT8c+yb/YbNOkREFbO+yK86A8NmgF4ABE3wOmP0Ay/m0NctwzN3CQmCu1UpppG7J/Aus0lZOIAFSzTlHrj8ph7nXVxdAF2ZgY0Wt1pbt36kKtTQy3aBADugvYSjDD8r6Xx1XnXKaNu6foG3Z9dlPiHhoTnnhoAAP8jA46SwV2KyEGgci3U2g5302vEWXxDH0drfC6PrAYAh2869sYfw6gOT4udr1lkv8mBFaPmo3vDDmyf6zv64gBhAH5Umvg7ZmFFl3QS1ocDvqSRwCbvo/g2R1/ZWr5gAJufoeWbkf8RSwgrs+zMKIv09K6VY8DHkhTJRCFOw+8AhJllnOeVNZJZZZ80TxqYpqdUAR771dVh1cyP1A6m5ABYNSvmxlkVc4BzN0uHqcN4muDzZB8es7xnXdBbPRWYAKoq+4S2eYPcsYIiKNViahB2KfuTQ5z4klzlidJ8gaIA1Iv+pItiUS5ceJUNjAAdo+MJYGGm440HPQ/L+hGV3wAq7UJXsHMnngTpiZ77yrbwHy2tT7ZEI/uujCklp5abAJ9JyFe3oKqbogR7pnXkqFjjfDna7/WZv/0qvyvHmaIAYsh1tEUCnrOip9SqUJ25rd33JRhbE1ESAFNS8a7tDQDA4ci/y+mnPjobWCXkcGbibk8j5WQVtUjtjJlNxAaYAN1QaUSW4J2/++z3VKJJjujd/UOEARDj34JofcFv7JgA4JbbjfeNCoNV0As5njMkgR+k7xu3BHx/U00VoeIE7wC0n2YNdsioeHtmqljNJ9ohdfg2erysc8XRNEUeQaS5AKZZcDEKaDbgv16Slfx8onM7b06I5jODcMV7QKpYQBMAI140VZYBo00iFD50KK+cmHeF3mMmH1m+1jZ7oS6s0gC+dOlHTfwB3RGHrD0hT13Fm5WFYj0nHoRkyhjZ5R/+AH4Z5/wzCEH3AND8Vlnl+rotltNYepn0aILjvOiYEHUALqXocCdW0RgN84jcuFMZ2qGQgMIiCDmY80Z30Y13pwB9fU3crmfLRooLqfp6O4T1+TPTHkgrIQAGuhSXr3jcAIFS9oLvSAWeVQ+lNq5F01Byzr6BVgdLqidiXf55wDAAujT67meWi+btPMAv4ySIagteis09+xBz/dwbwCfoWwCjkNzQOPViQuC61fTETpoTf8iIadM4Hj87OP2RiFLoAI6Dz0O5Hkslp8yU/HGJ9biuN4nz3lVoA4piOReWeDMAFjnQNn+sKjhT/KdpbqtGq1tzWKVen+jSImdH7C0UfAD90PIrwKVaRJOgDBj2OVYHCFW84nAwh+/xqE3/1DBIAOLGRca85vnNvQOXBmM148Ix/AasyOxog2LybAXNrdAANQzpmyDi/hJPcJzCdVsoBzBDZBn4WtT6sx0q9fXtEgCquf9O1tld9rRzPqfEmz1+KYFzQBgWdpVzTHtid6dmAGIMX+b1GbH8NmXxKEmaiDzQjT0wq74Ij4jYVSsdAGIAJcUNA1OgETzERwwsc/yuVRj0zwWVpifOj9zjn8TRFgC+GsaQKKpG2k5O7KtgiZLtFv9zEAV1oxNTKhXTuXV5ALHQPhzEmAaV6tgXrJn2I5avUSGPVW6LXv+mFB1r1hoAr3ZDhg8aBtyBCNP4zSaglrU57y9eoXB2rETXXpY14QAzSvelUnhvyN3VEnjAbM8Tdn6dDp0tHDT7o7FM0fh3AJ7sKP7+OeRt9U18d2T0AXlvQcGGOLtpGNU6rf3/jQwAVvCcX+D6Tf8vEz41cSx9c4ckANIjg2kLvTM1uu1TCABEo4a0cB/XhimsjmxMJkcBNJS2YCqbXOlYKQAmL6jNAA45dLxzwjEPV9+guhWXnuo14d/sPcN4XWz/9HCRt04A4LLy4t0LowrjeVR7iumkIZ8m9fKG3WXOapGbr63xZQBgjR0DEZBLQ9kSyqt73lZwvfmBWDE2e//oQOX9fyx5AL0qKOaQjVxfSxCoBfeU3YvE0RgRha3k0rV9EgN9IaEAHyuwT3v/m6WK9lPeC8VjADKjUrYFtU2TABHp4MjQOQCsKGUgozeNn7vTwRbLf37qoQPcJAG7efkoEvjU+jJfAPRnDey1bYF1SDiO0ININpwJStPvf78lfkinOeS67tkAwTBB5VThr41LDT9S0u3tK/gY/5TinmBqJ+8KvBTi1gB1acrAAAWgiOWxCQs3AxoqQlvw6zyFhQI7D8kDVa5TAF807WX0aQKsrefcgn2k1uFbkYAgFz5hpgNxAITlBs4Aw72h9aunAgo+TSszqZvqS0DWeU0S7mYAMZy9pRdttQAk1XRB3YrFbPea85J7VpSU9k9UU0MElx4eA4OsmUpoALfmBkOWjdRQMXmDN7XtPBAa21B5U+BPCZNf5B/TP7YA46Nt8itNsYZEVG4Hj0SiWXYzCuOLlJ5IVGDlnGmPcgCC6SKH2vTeb1d1UtLqCWGu4TphF7ip7p31xDBgeNWjAKInfxqACEXGWjhQlly+/Gd5g1XhQer9F8rJxIHnLCUAcI48Z6ovy1v374Hcw2z4Ze5BZj6DL2H1chtlfROI9ACxLSKEKn6VCf5K82rZ1cD8Xv5f94Wcr5goPjmfcBKbAOUBy9PlbasXzfKyzWlenOlrysFGlh+O5p/EsHndTr8A4rGxfPK3oLyvrtDH887flcW4lnHFaGZqKdNzmCK56AAfgEj4++SMZLTnjoDD7vBOjfsYo6OHL0+nzINnQ43CAEGeYfL49jmarBsOdxIUvrznVAb857VjBVt/SYuHGzcA0LMOqdURd0bX+3+o0M5zSqm0aB/ab1JYcNPVBPn4vQBdJ1FPVx+l2xYjPKVPz7jNkg+8A98B7Tzg9l0tdPs+ACVtmQSMauF7YpwggX2P335qDvoGpzXq23Q7HO30P+kAupYi7Eg5WukkwONfDba6cFUfsAqQ/b48h3XoUNxTLgC3ZInoQGNpjcmJcoCN4gV9WMUiHm4g5HElyRCJTf7GAPQTd3uZLEQjF+Vs9BkKMA00F4nbEISJN6X/7Jq0AUkACdURUfS4VLsXjLTYuhGzogtwPJEULlQjUoKq6sBF4wDgtl93sWrWv2wj5DKkQHcv3AAsSUuuKDZ13INjvP+2AFcr/zR3tc2lbSw/p4bAIjpkG5DMxJyhGJbIg/1IxO0AkFRD4SR/d36DE/5PbNvyiScG0BwcjgNT8ZconWvbFACvBSHprrwanEB4T4K+XFPx1AvdWIiu7PXRgjBI27XlADOxz9h88WxM48NlEGbHWOxqXJ6ONqMGTnqs5ASncFgATj+kcO2bUPDqVjtT3hjsV5Jr1i/5IJr0f7MRTjzQjABWBPXKKy/rRH3Vl1AJzXIQ4mPX/JAILwCq5aVds7lIACaaenF1l4KRmU/fWgLFINyt25GWwelc1Rj3QyDxA/IAsd6SVJG83eojhpzzV5fuE0gzU9iAnNvnKwfMDNe77ACCezF43zZZKte8pfperRo4qLopiPKGtj4gThlPVzrhAJkerhRRtA5ByaUZ/xsipjKkEmCgcgfbJThkE0bZdfoAHnyfHQcvp3UwxbAmzQe5QHtqO7mgse6eEDqyVh3uLwBAkoXhzOZFVnffi8FgtYfZffXxGDNsqqdLT2WBn09zACtrTmDWdBYJ6XN0muI9fkpu4Aw54Lo8y94IKIrkAxgAAwffxeksySfHx/v1vHMNZ1TYalVtARiMEg28dV+GJwAUqZcoVDgm+efw+EoifOtz3JPDPVS+DOS50rsrEUmaANX91oNGq4Ab0U+zqEnY4SDJRgrYR6sQCXE8cNADVnkAYil3bGcDauOtjpFMOcpES0LDy6LNFw62Kn8WJuMTgwCVPlWq1bJQrSu0tXZzzO1NeXuqP9x1mKcAoYNu3ylAAOZjO2PkRn/YtLYPLxPBYweA8j7SUkEorN4xQ7JfOAoAW9d2jWI9C+ezPULK7DcGQs6Xb0UcOLNiKtPN6XN3LABEGtBy1LX1C2/dbEzKskDjWledzdRdwl3304rGv9sOAA2ws/j4m9d5yrvJLCWLWaxeLhkOqVe3Xu/bBh8M88cAyknuzGX+AUfq8AWttimzmP4pxOM8Ek2GY5w3DlIxzQCQIhxerEEQLMhTrg/GCzlH8970fe8ExAPQtg44eQ6EADqglBmBxI+irtbawPobFH9XafTVek1UlknC6LYfL8IAO3U4OpEI/1RwzXyPg8PUT1+cERl6rmB99qqZRe+ClgDm1dwqlps/9mcIfi66r9GQ0pjBPzEdReNoNyHv7/DKAAQa5FUd8Djnzj2KHeOc3L/8epcN/bDk/w0sgfplhLAAbT2d8wYZpTLrE1AJFDeuT9JgkR+XMxTDZv/2fbNofgBVKWu0XoAOScGBkOCLROV9xnkqFsaXFHFoT4WY+PT4ALs5igM4NZazl+xFOmXPLEHK5bK/1u/33QPqawxCgngAeW11n6yeEb3c1VUL4bk34UMfwr7kASPEj9/o/QED/wC2XkKSxDieO9SrDdFxTdPUClYFKskPq4XGfHlSn0UgAO9WnM6yivViPWvHMh8UF426IgEm4U/t/9z9QHThYLMAk6XWIvtcrWeFlyPHNCffWZr379rX5Qn+3Nk4d0bVkQAgt/bDHHiMZkHi8+MahlkSM0jZWtU4ddExX8vjJnlfALadPQ1oFLByFi18twcyRiABvb1af0TsS2fGf3Q7TrkAQUjdyQNk+YWFds8y0elgy0r0PRpmrdrGIslPWZ2xPgBJyIY5QoKG+n/LzMfVqAV2Z/GPaVIYG8bW8MKTmBxEALgTzjnz5zfUEHRVU7DjJ798/jxlniukTJTeRHczi14A7tmn7xacTcRhOHjCbALwW+TlfwVUdawcTWZhCFFTEgBnLyDGIllZyLfcoZAHBTYEfn8QoVnEX5ZIwcsyS1C0AFW2KygOua6PlnlsRDIcX7P/71zDQy2ueMz88gk0n3oA8HcTH39L9D09N8LVJJ0B07QmcGppxQjN+N7ItHLeEwCWEkDDi9PgEK3ymVpSdp3lMUnvOMX/NJkW5/+dJAUjAE1YhFFd0JaYJYHtos0YWqXJyf3r+I9XckzO1aMbQFQA07NE4fT3Tfrk0wu4yfYWlMjdSJ9pNAhEe1Z0rxFeGAA2dWn2BmYLi57ih7nQCx80h8kmBt+Px5csWX4zh4ouAAeFQhru72VZShzE8BBuRWwEoGoOqeTdw8VCcj1XjMgAE0hy78Yc3N/DfB+0aZGY09BLRQAbfOO1U5U83HI74wDTiWvZYjtv52GFHZZ4apDouwnKrZ6GellZWk3O16GBAAXKIWm9N3WUtOurmwj97gS6/83i5okNPuS8SfJTbiQAgzJLsmQCQ1FAD2YI3LodarY/xxaPSm3rUXez56iNMwDJLYBYFZ9XD3OCatSfwfKGKsvKybxtIzubjS9KFzNKADYpFlqKWSOjdGSJDm7vbguGxHhGwn8+GCJlEyQ9VeoA3KgNTMeLrAmxImOaqhmrz2apprleAsTq0Uq7zySwHAAUA+xaYlT3JBKwYa9hQL0LR5JI/sub4x+IS9fBdYWlAC3g1CrP2iz64hqYrHI0YSHwQHOa7eb7XVjqgsM2AnQAlRJF1hjZyEbon7maPkBYUM/Qcczjg9yISU5mSf791gCIJqIb4x6T3a+t6tEK0XwjFbfB+X270zAsuEKy87x9ABJ3uneQ1alaN8S11qz35pHrP+ZY0YeECKZUGORoB08A0pmSyJL/VgQr9iYJ46ntN4PIXSapOiqROTYVglGVfwARyx80zsfySnLjjOKLVmSvfcHzLvkSJTj6vVpzBPl8AHMKAjxBMBYOyoeJPYCmqw6lbIsrWPd9ToGjlPAp4rEA4QOVfooZLG16TQNk5fNww9JYubj+G6hdW3w6ZiWyZAB9pp+UaiJqRiOhfqarFaMlqbTJUqWD2AnS23Hz6xyKALVAoJk5M7I13086U6qDxLzveWdQ3Uw9Eg4u9DKieXwAmOf7gkrb33C+R80vMj6o85ng1RvcOlNyILYRRNNAwABP/1/+4WlSQGHQ3POksRT2r+4b5w7wsn3tBkp8mtWaABiaclNtLdxni/qAZmv6Q+sge6Op0TegtkVKRwK0Xe8AoWGp7y+Oo+V6seKbRTI7CM0OPKfArCvjdFpty4vQuAAN6Dn2whPampjVIpPNUIvZVqKQakqFKAsjeE0ZzMZ8ABF5g2zceRUk0SxmjQrzDwIE1xYOKb87n8F+D7KDgMgAY576NxqDS/0wTtGm2weCrMy5oB6y7s22Svrwyexr+wCkm/L2JjwQlkGhNXrWZ/cK5bt+YzpJJOOsl2UOa0wFAI7tw6H9xZEvKXgna5B1HiaEXV2doz2k+uVUvdBHAMMATo05MR/mlNCrqaARmw/GDV+ZjmDV8u8tLjZAsUBIOwA3Ckd/BYyBnfzJ48uRT6x8INe79MoihdWW7wJLVPWgAC+Llb0ZMS9aFLTKiLvkWFL3FOakVksCFXIc59JuFU8AHQIpf80Cv3ALq7RqwJmVrUOTZbQhhKJXkvPQCAqMDQArj2AIJ2mS9+8UUrPB6HxQkmD9On09DOCVcm3i4yR2AJjbs9HIevu787SjLrr0hQ1ga+kkzK1VyClt5kz7NU8A6AZ9s4AMfvnk8XkQa8cfWAS68Q4aZrsFKUoDlbI3ggBsuwJP6PGaDLmWDnDG5gsJTwJ/8N8RReJAEpbOoD4KAB1kzKMWj7rbXu4JTmycwWrC7nA0xnHyF6m5jIeL7p0Aa9KeKPmClTLtg+c4MLeEQVXBp0yBEFwXL5ZfkIqnjADua2t637S1WgPNnbvqgt55qh7MC7Hx3mAAiOb5wHHcAIBq2LiRoQ6XjhbVhRq4OCxrvDJjFjmoVQEsd9ZcXlEAOffVqDMg2McZQFcgJ/IYzwKB4Ox/FAyJ6oHtLreN9QC549wzrlMpDSWFiR49cxBRIaj/P+EmOTfxh9QqYVZYADDZ2nHnInsg7boUk9FoDovZXbWPgU3awYFXZfJkzqMAoxIPeMCaFifh87rrreuw92JL8G4IzLCGn3eerdS+HQC+XEEOD0kwM101bS0po+Cady1vyToWQgL1Roiy2cs8AGF8pl272yj3oCqnVJAFFVOTtMBcwyog+vM4L1pCo4EAlFosJVAo9CI0wGcVFrW85WjAT5wAr52CzBuJKnvfBgAeuCsnsswO4p3xTqU+CnhZLVvAChgkt81a/CcupdgcAAfLBfTdpqmTqtNZ81TxwArZ0p5QIXM4uk+OmkKAvR0AC7oL6ZX5wW6K7WuHPDA1ridPALHOqYdksTavhQiWFACnTdCoodOcB4dFo0FIeWdGZ2/Yb3vaQZlxAYTqjYlMADwzKcNb6CtMErPjOzpBerASQBrl1y9OZnFF3D+aTP4ApW0Q6XlUUOVe70YV/OTXtn42Q/5QEXh0BHe2v7g5wwDc0aNFOqcw+/KXxVmWgxmyzIhmgAqi1V0hcMuUbR+vAACW8MCIq9lG8ZBX+o3YEynmSzM0xamSvlAiWPMHaAAARhm0xVcXalMRpUtJskaQcTs1tGdPpSHkCyF2fra+GwD9fNSm8SfP1mqOX7rxu3Z8tWovv7TQ37Oz5N5606coAMTGtZfE1YMgObvleuiIqMfNvuQAPtTETD0CDB3e3YcAM1fIcfsNKaZpDXGBRY3xXykqLCRhlUPXB4ght7WGigCHErAk6ir56slYqTFGzUx67H5EcGv29UDv7kJTDwmRALt/xNGEEOyCigwRhQnffj88mk9PYcMrc6ZmV9QIkk0A8mfs92EcGwfoTkrua2J1eROFg6wfnk2trCwKoyDEyAATaaO3vGLWqTXCxp0bXfi5xHS94l2WW9scl9KH+HWZAHSRTRIIJQjUKRA+13RKw2m/hAEccnk91+qq5lFoN7sAuxPwuD2bDo0gI6gPa4Qpsh23WKkRGa2XBkQWt5QCtwCMqCHL9JsiFRcLoDW7NSkCjmDm1NhhNexUOi//mgAuANCAqWGC6mEaWW+WFtOBHLmDMSfAAYNvRNXEMs7OQpcAc5QTLVFgvaO5wJSvexfLIVROLwnQ7yjLuc/+z0YjcgA2pgPQR0xP6eu+MdZ+brQmlCsiWyEPOqBXVxTxYQfvAIrvIcUGTCtR71TVTv6zB0eHeIhnYuxPOB3n/ZfzSE4AZhTTjta0Dsw46085ZB5zR2YwE8J/vrGtlxKpH4Y9DQAJ4cGMrUCQDRywO+T5VmCNrbXNWDqR9wboa6WyWdPYAM2zIaBhwGesPEVXMH8KpVXtQCKipr+ibWF3yl3TPHIADfT7lXdXlh+yyfBqgcCwxxy1RgIPXILQrQLmf0PlAgCgPJFbHlh+XVe55o+E6qBgKINGeJGfmFzgIbyJKBLzAOw9JQ8nb/yVuxgncZog1rDyO72tSfXVo37WHOsLJWQA569/82qD15AVoA0FGJATv4GV5W497Fu0HXBIecs/VwDnVaIrvnP0HP9yBw6isnkkNOLGwCGDznNG/cCKgglVACtQduYoFIyoRvpfmVAcFPtq1CkAp/Ad17sh8OPfa9sAwy/MUr8lg3lfQCrWQfqnCpKGf+8ttUw4XxmVBFabeQC5AbSIESKsaV9xBr/6QnqsQ9HxgiZ2MkdPKrj2FR3LAIdK8N160c0m+Ptu9FUO1ym8bMvE5jyyaKKdA6cJPRIA1PmAsiZVEv0bcL5JiDtn/pESy3hqbcpWbkPL02TOUwCQOh+CKUbrCUWb2oYWPTl3m5+bdrE9VvRJZCM88caOAOzSsO4ls0J7BvMOVQiHTeq0hI4G5IRxGh9SYhm4wrIA8z7TGq8Ibe/zBDpCu5JT6xKHknBpREmSHoNLah00FQAfuY3UtmPm10WmaQpmQHGw6lalk+lwVKOzcqcer0DsABRo49/33ILXTjKpgJYsqNJKj1N4SJ4BNNhs4u6+EcIA9oPVACAs1beF+bxzgSbRNIS6XSVN4qaPbZW+qfxuOQC6ziLNooqUDC9OYKFSfvYw5IL+ZUPdLbyG7MEO/FqJAPhHXVM1Yh9qJcgILkiTHaEckbgUcwKkZeBPGUh0NAcAPE66n/SXcmRvE5CzGmRB78jp/02s/hUdDhLmub0jtAD/dTle3NTngHNFbtAVjXxwWpnprzFNhoVrNk368tryAN9661/u5Lp6o5Hf9TVIT+CrBpoUhaZlyRMW0i4hz60AMkO2hMY7eqrslSF6Bi4MBHA7+cV9Ww9nRiHLhw6iOwAMPzV2DdkQCEP6WhvL5ZMvsaYIU5UnaE0ODTaccIfCAESBLfhdIh9KyO4puIolhFNh2Nbwbz3F3mXKk0fja6cAjdCrpFFnf9MLFS2OSTzSa2E+mbIxcfcGEW+BvnqfhgD0ZIPmeJrtt4Ug5BtGTGIYFPkGfOc7uKee7GEpymLPAA+8dhMDW6hWLw/32Xb8Ew0QMakYimJ/0y2rpgqkHnMAWyhw2ppip+ShqTOJ7FM0+4peaide+UEzgT5dJcCQEABoN63Ov0kbZfNBA63JBk7/Pf+pd3w7BrTcb7A8zFDTAGhAR4bfgVfHqy4KLI22Nxr/ZZPoPIMA5JP12/v9+m0AzG+ivRrEuMZScGFHngLIxyN93xdwfQvJupzlhdaScAAcIWprbc3SfW89YapbXjqoqLKFp7WwEo3e6neLTv2sADYWMv1R3wXUlxu0YPf0V7aWJi7MaUESo7o51QMh7b4AOjHR3+HhcMJsrsoZvUbag3p4BoL+EkXm7fVwoJlz4AA4OZZEty6D4PO+NNwH9N+ngovK3OZujtR1lRb6BFbVAP8hRwMBhxYSGpIvFvEnvhOSavmO9Zaaj4dGiSoSQzMAkBpeFvEvyjvOVxrDfwKyBc34R/FMNLVpxwse2g0uEACaEw/FCOsJPL83DI3zu0fSfnqVJ847A9POD5k3E8LnAKlLQ7hvNGDk0Ox9mW9/g7YoRXe7O+42b2QVA16qbdUA1hVThgK6U1v2P3noHnUl6XbE6zk0KYqMJxGC15o3FADKsG3mjC3petc44ZvBbJE1MzKUZJ1i1X4pRurzXzfHANkYfB64n23Lyfmt779YVmWTwEKNAPljPz5v/+EaoogAWOM1+ID1QGd2fk0CZfjTA/95aCLLXdJ1Jk4UZ8Z7dQBLPJBGx1c27Utz3naPxLXWqG1avKUqdMPJa/YGaEhZAPa5JvZZGhShk+9WQ/6NXOiH0plXLyeHU6u3yJfc2zAAcK7sDMAQdEC35kZiuyQn9Yf+tPb6a5s6i0PKwE30RgDALslplIChy9jeZ1vQzSb57B8tR4DXrE0d5Yh71Aj7AHNSZ/3CmcWVrIKXOh4BrBs4iTPUdXS9UU2jlZ8pgxsAwWAb6Bl9q1mlhGnc+MzxmHhxaaA4BGDMK+T/mSzaDQBHTBTrj8mjJEAI15uwwYj3XfVQSM82BrNCl9qOXkpWAAq+okASmRLF+mgNAuOP7wVxvEIry1Nf/x+ozAvVAXUA97iDwNfZlUV21adOfkvDqpCqldl56gDr/Q+lm4s5sQDPAW0z+JUEfrzKulhniWEBVnxl/Ah/jeJqEZGisIRzADdO83QSI765NaU/EiTJCDVbe4+ZdeLVJxZp43yIy1wAUCop6Fv9PbMBL/kss2z4Z0jLzDktpmKxkPRHW2vONAD8bg1BQ9nDlf7WgZF5o2VgJA3PKrxhoJ5Zt9dGD7ckAGSCQZgOWr0kXrqwUSUVN1KAFH/z5nIyiQIh51oFbJwAg3W6UcFAYMDV3It9qqo974T17VvhKLtdeZVA8iGFBQCqILgFDyqDxEmWNoMwYDvwryAJzoLqKubVVxXKtm4SAND1EgfEdWEMdalrzcWB/SgO97ZRcPlgOxkDG7pxhA4AIzuHRbHANWIhS6J5aiu1i8arwrUiWp9oNaWjkEdFegCZqQykngrywFYXxNafs9jD1w8fZe5lkc+c+JiSSF7RAACJ9re2ThuDJHm3E6N0KvkvdkVZ8ztWaSmEvYzslMgANMLwwyscvG+an24Lz0I9K64sNhUyqggM5SVeCSVZHwDERx0Iu1XfUUx9/+iZXb6z6BECNvH9EV/3PxSpbKFHAAnTG7vws7xdW1TLcbrZRN9ci3EPtfLSDfgCfNV/DdMA4546ywgW+gCSBbSm+w64nTG3aWm/thCjJpAxH25z9AB7t+Fd3STG7qBYLM0vkUkTFYpB0OzvpKQzBeBmLDB7ACCApLe9OGp5dxJXLzt+BIW9i/Lg/odDeqSukvt/4dcAaqFkIOfZMvMzu7ndB7g9aqEjveeRiu8EtbSUbhwE4wDhwibQ13e38+9qRyMKOncm7WyKVxCMpcNXORXIziWaANC+AvJYWLsxqKO9pX7v1fKCjtH6dKa7ca3lkWmA/cQAX3EGcWkA4vkYfrBPnRoao4vxvjUYfsBuSWBuSCx51wCqlACNSVRa2I4oXEeX/d3dA+FUxMI92ZOb9KoXEVGeAH0bZCMPMymvPtE5PMz6Rv2k3KwYhcYRc2NJCiJoFugAB4b7CmRR2y/IApLYDf+G6uM/TZFfYy5sFwTRNwkeJgC72u5V4tskVUbRvvyVLNguSh2KNsGusV2I2vnU9omMAA4sz8Y5yba/tmHJPFVJ6LhZ6yPmJ/KqxiNw4JQwrJcASW8DVLfrco2m78YTT/NpSyT057FWVkd8l9FF2FcyXAC2LBjjvK6uAo2DkAdpYsC+qG2wBB7GjZ+HOl9N45zkANFAxRI89JHA/EkDoY10ucaTvzVrS0jJzCHPHjmP59cA/ax0h5R3/rMmGkEhBOGe5tcQ0lWk77378tbXtshAlgDf1Mytgdlh7K7VYdHOKPo58Kr23VJOc/1JO+CXGOFdAInCja24UaTssS2T/6cPZI7Vtr8whXPKCeG8HdXTW00AOf66r8ncXnBAnYlIfyDFTA5DPYpRCU291uaEc9EHOwAdFWoX8z0glqXTNYhaapZso6sjuyy8IAtBG6/1Uc+SAKU4e6x26nQHPI7UCMa5HFKOU6IJLN7mYKH+x10EpaoA2VwBFL/EcKmE7oS7luVwJThDen1hWI8rg/tb+Xo6SwASr1ZqGOkOBA0JEQub26bMnd5yDAIUhqN2fpAmAV1TAMwG9nCCyWmr4bO/+HfLBhjLcusARsJVbc3RSLCB0fcAynX7aIqDrHzP1ixWImIUvbFXob1l331rC4dtlkyggACtbFUQyfpBPWDJOhtlNBGBQgp/Hwa2IkQoXYyy5yw9ABOkdUmoGZ8Td8AsZ3yP4MYZanaOz6IwsPxpu5WzOT0Aar7OYHWUdwCGZu3nNxGUQ76aDYC/29WHZH5LNOID7QC4Gc2BBEtvouPOlth9qDoxmj9ECOuH8oG7s74D1v4DAJ7orP+XhPqdc0iRdIZ6ocwoyjyoEdRYmpR7er3T4MoAM3ixiVAeoo5iCuC9aHvbuSPHk5q1m3Q4iXqXpxMCvwBq+RDb83eJA7zq6HWIhOMqJ8jNclJy+TU/MSTbrj+ZAEaBZg07bjkGvyHaB/rnYEN2A+aQZ5UJs0fT8Npy5fwA1wf/8/o/oa/wVvVmjKDFz2aDAxIOcfYb5qbdYtYcmwAA+9sYjbgnTAGX5X1PVJM1z9R1TWV+jc8ENgKU0xsfAAbTdEl3k9ijEWM1ADlFZnem8GnvzOn9sNVm0VtnKIkAnjq9eYukbA0FQoCA7FPDABCWvitu2krvEjRY1s/2hwCav2pKsGPCWWS9B5aZfI958pV+BvYtlRSN5VKbKCPqACK0eGu6hYtobRGFnvDBae25vd1kjgorrUlNiWZuLxwA3eeMYnm3+pxRSKu7yF5kqz2++XxOiBpCZV3EwKXx8wABnBs34zyuqQWWB9Bzrfy6Z1SXXTN29nmkhbXuwHdiAGQ1LG2m6iWw4mAvNn/VdQRx8JtRscBw3r0isx5xiQAAGBSvUsBGijl8QnPXVIE/ZJ5PKMccjuxk2B+lm7I5HQB3YYkcScQnk6N4l8/n1FzK+4vFDdBeRh9ESo3iQbSYAHCUR4bRN3/YAqqao8Pa2WBBPg1Z7ALgQznA8wCd8C0AIboBYob96wpbqBmTz9gaTHYW4Gd5S7HNRxKhCH9+0gCvGUiunl3mLTPkMkx93vPihZUZZ0Qr7PpTz0a2aPhgAKAyqukin7h0LVwh3GLgyevGBO1TYMqH/5cpfky+xl4Adeq9CmeGP1z0soVg2idbI7OYfcPBPEj93VNa954brQAqkzbF7BentH4KYHDJ70N7m+NnhTXbjn/SPhXjAK9LAJEb4ITPKA73kDReFjHnWeLUmj/j5m93rOZ+F3fYJJYA/cQ4kCUmeC28uxrGKfkxPeJ99C2i40YyYutc15t+0gA8oJCh4YB9oYAy+K4OjHsZLx1S2CXIzlowmRl0mks3AJM1Jm+zQ/ZacaPQtGnMMQ9ECqm01x0htBJDxXWRunIAziyGe7C+akXr/k9yqQAsYRhJ954Zg8Xm7f4LiwJU3QAerCXqoUQlTYky6nESsG3qpUW/UgHy7siaCSFZBtjlACLt1WkSRlYoMAnOsB60/4Rf2iO/HMEAzRZlVXkuxJQAc5gbDRqxdXGW9ZkzxnqFIv1ItAurh3l/itgbqw4d7QAKHwxCbSk4EsMf7UmnI3ik1xrtgljcn8BIqGMSf7D5AGnifFoOABWGjf9vm8erby3v0A+vDG6DEdkKTLJ3fOsAHw0WkiWLH01w7ZrmdhImltQG5KBBwk4SPVXy8FEXTwD85Y3DQMUq4KuVHhz5dJRc0Jk2KwDCEpND213BCLLFAPtC7mxUg/NxsoYMIeNkid5O6lKU0jlQWWPvDwifOT8ADKkx3QY8HqlqRGAa8lHxBOyxVRqc1lYv8IzkqgaOpwA2gA5ac9tEYLTwhyNOJYIJ56zad0Ug1905DNMa5WhyALHZVbrTz0njG3+wQv/1AqTsedUlsB5vOD7UJIugQ7oAKu2U9EqZrTBHrHY6IGcu7M3Pv/bWqtkcaw2BRerRLwBHDhGIaF+es6hxeQlA6O8dxVga99DhJoAuBGCgjkcHAC6R9bKKy+dFPdWbyz6jEvyl6kMkoBCu+tznSIlgAp8AmE3xNHAhCrrwP80cEXdh7adPDiYJMoAfj9YFYc+P2ABi1JyjMfC+XdwLzKYd70nkjhdFPwNYz2XGthzc9HQyAH7Ir1xXimvTD1jI7rLMSfLjJpLwNhornvMupC3Sm6EAmAwOr4y6ZzjvUoaAVu5stKgB+kcWPL2RzNsSiQFtKAD970eTOAK5UHhCi521u1TUcr5meKE6kUv8fhTwfKPiALJiEpQztAkNbHk8PcvvQlQWbmNH3uzlyKH80YRUeYUAQDkdctX09K46jsFvtKQ4pT95VMznnyPykqGnAoyIQQDSfUGNcoJ0V6mI8B3H3WoUkk7b47TCcN2vHujX080yADfYmoKWessOLlrQIOp7RzewZzn3lz7ox6WngnrLhCMAGJA7jnXN01st8g7gDzFCSAGkxTMh85PQE15VxljPngDDKI2UrFH/9pY2Qr8sik+Krc14nTmwc7rxmmUEvyprAGYary/DgpL/A41g0XHQ0fWhe8+rw1l0xaAVfKKkaIYAxdPtP2YHUuAVxQy10NfJhC80Zl0pCZrUx0zu7ekuMADAlgRXTyjzbhP3xl8504UdDv27vwZQnAVSsD+llgw2AMDuRthsWZbBo8+DRCiYSvuNz5xD3/PcU3X0sOfW4d4AQFIeK5BcUM/4vU4e9PBtr+xN5mXo9GK0+pFeg5o21AAtqi715yvlg/lHCQYDz0I+eprEzeb6Tcdxdb7hd3voAEGfrOpf9lOW2tAnuVJi/YLvJswANDBBXQuu22D0ZeUA4ZB5FwbKiw17uYZZ8FouykdfSrQyDkFmDf/Eus813gB4g26fIkFfpkO0Q+RNcNzKGgUloYYRV9pIuT7N+gd3AFDUbuCVbLK8+e1OGifuwfzIiMoJfTsQ9hv2Cn4WALEAVKiskjNm3qca9XKMjON1Tln9cadJosAR/Z2rnhzbagC+9Iq1Ei1n+TMuseskK6c2NzVKMP4TJsxNW3K+VLKgANlfKN4Dpo/YG/qJbhHx7v96j8fTDsdnprwOr3FTpAoArSR2g3o8zHqQE0O3iYB+ZXoLDn0nP81zlTdB/ZLBrgB7hyeD3X+JA9AArM+l68hGaYPSMEHfgxdi3IAkYpjtAMgoQjzyL37076fudmF669sarssXZVVCcnglutIqTI8ACSyv9n9Qt0ewvZABw4dyExjry6vyhV0IHze6UiHdHQCEWgb7wy17ul2ig9VFBZKYrg04DqjAVpMclYwk8fg1AI/021FsxUv0ZYUXFLLgXVzaZ1HmumrdiX7DeKu0THsAHEPXfL9boJV0kKN8VISDdwB/+nr1FLrAp1VotByQiwBYc34+x7kBQtcR1jn49Izpa6PkMRj8LUXVZKY8L9zeAEEj9bOxffhQmB7de51XTUz3KLOHgwWl7c6udAdKi8AAVI1phJcwjFxjujEWHeL6cq8s4jtkL0Wqexk3p9oYwwC0ZScBmNzMrZGSBRhQk1P5s1TuX46mxYAa4png/IfDAOZZ289nzRuJEIzTgSqufzyTwhA2J0FkCQyrrcm1Wz8AjOp/TXKKy/nMCK3wBu27foEFHoLcfHqEsR7E8ePo5wA/KYz2xhFYq36QKzBkICTeW27H6s/7nbTKdJmQhUWiANf4FER8i1hYOSCG9C4lYmyop5Kour4RPeqXI+Ok9/sAfk9aiBYbfAn+EIQDykj2QZOYZp79xwqzOo6oIhAoqgBx1u4W8qhzbudm/539WdyktDsxFRYRqQaYK8FfbtVOACGqiQ9e6aaKcehQQSwd11pC4OLOK/6hVpsvSkwc0kcAXK61gDwwyj5mfAA8O3VZ6T4Ij2QVr05t/wBQzY09sgByr5RV7jY+VhLZ1tq+ycbL06S3ZAyFYtms5p18rYraAG+pk9EnAd1qA5bUBGShi7+Q4loZNkcWyUP5zRe8Ld8AlPv0QDtKYsRkLyhNVztbqlBZLpjzBvQ5ROdKvSw+ygCMj/Z7jGa3l943xGqSJ8361Uw9BnIS1TAcHLYmMebxAC0OufVPsEbn0YG0bQnQAx0YmBAJU/LsyUgmy7zxhwoAupSc03xosuxOJcftskTT6dc6U9sowlx/dgP78OkP7ABlYx9PcvbvmsV9Le61GKtJk2EiJEuFtxpHTFx7Mw0cAH0sZYIE17ZQ0mUrcmqMkGbstsMIH5x4kr9N4BgAMnAAp9CLtiRKX907PxzRW8T0En0IWjSU1ylZTt7taa2G3QBIH0vyoUfJyAB/9sz7PzmljO61UA0xlDAj69thxDZLABwL+GT1AoK0SnehoWQMuwOOab92gE4WMXmVX0jULAMAaL7UoqMWGiME1i4byj2hIhbny+3orGrTT5LPLSwGoQCxXQDZoiy0JJxfbDN8uAb1aUywJVuUvbZCANuL1VgNAEP62DV5MwQoaoVGuezxImm6+uK1DXHvPDVl6lygcaYAuOvjizT0bcv4ze2N/EkWzEiaSAWMoalVJjTD76RPcwDTmlTiYVlJeuTgopOWSdrNbJVFMdhOAqnEjluXb4ZQAJbx4gJ6sq9+rRs0v3WcYG235YH5lOcianjxvWbZwAgAw/GVyIoEYtJIPpxOi3Nb5T8v5YwcxbIqX9BlIrTqeQB6ZkaM+hgny0LzazltAQ/PwgECU35XBJ4KdKR0kiYpAKkUbLG140+i2noBOVAcnAWOm23mRA7U36kXgqh1WOwAsOHUIWAnje3gVtOHS3KEn+kKjH1CqB3Qcisycs3BZgBDHaJpYlDjKlyXLwukUAINITuArsJQHKZujUsVEucxAGjdlfe8ceVfgXjRH7zSuEahBYo04LEkvCg+8nmssucABziCC9RzI0T+EVjagCJ61RtMsR6EwaGqxqsu16JbMQB7JNmAunLMz7h8B3GqAmifI52LaDxPoRrme0W9SqOGAE3AizGfUXEnjiZkIpb4U0tr2rPgTPGosikMTXi/LLQAI7eDzNbAN9eWSMHy7Qh3z88CrOo4HxCIxOwFs8Jo9wAwWz3d2eykx3AEj/jliziyCa9kLXKXmz23WcTDD9xTAGXv+c0XafN/WdKMGB43A3qoF5dPgJdYYxVrW8oqYRMAdEuGChSVf3YxCzrWIR+b2b9RN/NQmPioMgzdSjNXwAAmjmLLq5Mcleef/1Ph+2iAHFepZ0Q/k+ZJArNbr3idACTKFeeU4Cdm/uZgaSqeAidSOcHQttV4zeEsV18jipgAfAWAvS3D+NQGQFEM24qmpViC83rLBH/Fy3dk63+cbwDVr/XJ4pEx5OXowc6spB258VWzvVNAkZ3xYhd42RBFANO0PONpZuSv5XRu5DRfI5lNY5tTssjdxYZLWMvcxwEAeoOi8/u7PgEm3XNoeYyu1svmie5ubUVPTGxMl8jzHQBoav6OkeCruev8sVhm+8kGtTGk0b4/xea6TrRiGjSWANr874i/kCXDwbq0cxljRI7zVLn2l8lisko2VcETlvkA4SS6H+IdXr2LR14I00WFx6eMWjqwPpcLFsOzzdww1gCe8YiucyZX/IFYczued9WaGEml2SVxtBQxRvNtvYIWAJAvQkZ5SWoR/Gp+MoKUYt0Z8IwCmlxoQGMbvPXoQmUAG39FXolEHpddnNDJSPlRfJji+1oes00muwDg3pNIyACqML0qp18s2qgKdLtc5W/xBwQgvpFoZxOxVOtImpbdAKv7f3KFhrfBemn212FEhv7IMFG6cpC5XFl7/HXBOREAaXG1goDq3h4Dlx7ehqPKdKSHJGqNn+173NBwv5YFPgAfU6xyW7T6wsrpZUl+vHKaAJirXo+C4A8jiL7B1RTvAMJ33ez7wpDr6JPwOYrjP6EHoQhB/2KEWW3qIDWkSK8ApBo9gOv/BuFFFORro4lj2AVkHtglP7CV2uj8lRp31gASXKDl3MT6/+aizCV87CCr7Aq7ehDBaS6Vrc1+//ybAMHASTQwy/QxWk3Hxw2QdcEvMLsIj5aRV0IIbUQwJOAAWKVerlaA7VD5Cgah11Z+1LPLIlTWlk5/7lp5SWYdzAAhZyIwUbx0jw0SJyJBexyOGiNblC/XDaWuRcl4qA4BAI+PbBMjCMF27Tf+9LO2ewXh7PrZNu76JXHFztiXBmgADmwS4fS1ZuFIlIXCDeIZu9ELxdTDWWw8LmP+xQRT6wBAHIdZh7B+IT4ubdMNrCXBkH83Y6h4M3KnFT9YpOUQAGyHixSjscA73WF9MAx2u3dnKBmni899nUJhW4pk85wAtJVm/0gvh/kPDI9nt9ecOD5+ieGDEej6x41RryL/EgB0BOB92sj4dzxBq9Q8F+HiGtSTxqsevqkMJM7IM1fuAEK0/jOzcNfRWdVkqgSYhDBE1zFvbXDzRnLYNLWbhMQA5G1NwBNKq6j1SCLyE913Kq6ZGhekICSPj3E9e5m3DQB1KCNqhY8qN1D1IgYCsWHHKAPacUt/BGN2lW1DOMCnAD/ammtx/2yNncJtzaRJPzpzcZ1xHKAo97VZdme3CK8A3wquhnHaf8Zdn4iPWKX6tMUI4N9cO76M3g6QO7l33gBxQKwF/yF8FbHbVZrZ8b4IgI5G1oGkDUoQMFfZzI+rABRY5qCf6vF0YgyVGP+8KI9FDwd+akxdUywNZ8TugyQA/cmXTeiWxLGalBk2G0mCVkc0sd0QiUiTBUEJdFh1mACIiJbPq3oirq2YOivtMGb4GaSN1BWbEFA5FJxMhVWuAJJeVp3YDUXfmUmeOAO9vatINOhG6NgmCDcs6c4zgnwAs0ktfKBX80b0IDiBK4oj1t2EkyvTm7Cn+cDcX1IwTwDb6n+BoBPM5xFp6Yr0VW1r6Lm1Hi3qkclzIvgryG7MACsgq8R8hPPR5Fpa6NNLDAgUMofpDwTXs+tlvoOb6UsAzb9PKFTSCXDJoIgoj1FDxz62rEN9eTlHt/2d27zZSgCNKO+WfjDum4mSo0/CX5qIMj13MjCpHBZtFdYJ1eWoACbH6+SfMfU1FBLTX0kVBQTAGvW55UD071l2wVpjIQ8AJ18xzf5/mHmpjA81VoFyR+jVMmrFBJlGqCIP6NT5OAAmjpLlu4POmPZdes/tGyyKdUiWexFTg3NiAa+fnFHDAGi98V8Ocx0l0Cc/VDojXGe6WHD6GQ/kqOy4tV9udBgAZsxXWSR6mT+0RGdAhM/rX518hwlkqFwOCbokFiZBfABkAi8HNdVJSCT/mzJiryWE8y5NrdE3DJdvdtDBJb3LAI3EWD1mQykGP0UBMpEsvEjYylDZamtbql8+BN2Bm+0A3GCHuw1MS1k4e05RVyo+9jwLfBl03u4uEcF2eOIItgDkn/g+N3kfR9FUtabxXWi9n4hqBNiCSbc7kt1KNCYlAFh9tdrusbs1YlrNFt0kfjvRNVUKdPBWzf59TsLgd8cAgwphjUNdOaUqAAnXVXPkFgWSxrJj0BW7g+Up60/TCwAlcrUKHVrxFKJ3GpJpPfE8qjVKL06Nc/S+wrGtq+QCAIYYEx4coXDt45qNJ2ju0gDqhoSSR5lRlu80pSx7C6cAK9xxnkt2xdKmmGQORcCmMyVEh+fzl7vq22fKbuHuYAA11qRcxVgZOJsy/TGOcuiQdi/QkCE+MJUUQNwo8VvfAIU1ipdAQ2KXNVyomo4pRDzric6KAaGGewi1mwlHCkIAUXervOrZfNJN3d2UvJi54Aa5MnzgIPHFUvsYnciMtgBZ8JOuGHr3fURRt1JlnBjKIUIytdlsWP3nd7swhFlWAEQ9dPZEIBacHU/o+xR8JbGRHRZAZo0krrD+hd0fUF4AE2Fko3lYcqJ016Fd9LXf9hVYGiPKQQh34o3V8EC+ngAhsCEzJXSnXglcv02Ip9mu9ONT7JlG9fvEOdOx+RyyAMXmJsD82FSiNw4SGEF/ABiXVEnxt36wXCxUVg5QcrUA6t/htcl5xg07oFzStCM7MjXuk5p4cbvtXj/IrlKBrgCr7OYna36r7dbjShMMrYbeQEYEwjYi5Bu8wgYBHphFABJe/AmBC2teaUtFc60WdbsTBeD7bc2MFMLx93yg9DcAVoxio2ZvQ+/DCqLpNS9K/opZdV+roRfBdKE+r7TMyQC0oC2tV+TLWpGmfeuk1QfFFgfMEklvCy9CBW4G3hZjAGEUacRTj2dpejrQEvqh8NbVrZBORyQuhqGreDh04RkAm9RWqcrDTGrYndbtXhGAL8aA8w/rbKkwOIL+lJ+S4QDqiYBpmkDJ0IhP8vfFkBxLKbOViITGLdzdQAmK3QbqANgJzyekv9FOTl+3LlDArPWATiYB36cmn+Z1ccfCS3gAWMKtCujyDO+Csjkq48xvuSTms0fsFOz9Qe3Eed+KHwC5XgbN2maLbkeXrHXoyASGPLlTNJiJ3pZKC5cquHgWABfqgZPpQnBK34Lbwy9rVLuxkqpiKiePjHl+H5jqZtcAqr48y0K2OgPmDf/xP+TFG0YIRPbXyrP3nIF2VtwAygCwR98CRREGG9UC2lp1nDzWE9t9xLdrPZ8ewbeeahdzAPMKfFF0wzEL+9UNtDcYaJnitf1u8dplzymvgsVgg70Ax/+OJXGlwnXI69ygoMu6/lCUP3Gb4jPS6HbY/U6o9QC5QRe0B6lxkHG0kaF+VkdvV8YWVKwddfrKKgitvdOjADEyImWioDCIIzEPgR75OZeRHDQKxby4rhjsQB2UaocAbKG8l1AqrMALQGSLLHsDlgm71LPEPsRKtTR9/TP5XQCp/eZQY69BD+Sxbrb1WrF0idSP5eKjIRswB5zKNJ27AGVNMbhFYWMwb4IqXQC/fMZ4vWblF/9uosIuKItreSkAAH8Ppk7+silapI9PKU1PCgDK1NzRPKADYempib54yACIW5LMGKRqjeersXfKsC9qLO3/7akPEWDQgo65a5v/AI/CTIhtyjXWb+B8pX6bB8lrUUooqLXqGq7ctO6bF24APYh3K/EpCwz29H71Bt/5bPq7PhJjwlnwfz+tXAzqkgCKl5alLbVLrHra8EX5+XcwVhWZoHTEQctQ897vPTRHAARE33qDNy8AWgkVAdJA8+KeS8xdRd5lvnDvqWaOMEQA8CCuNSCYDBNV1wgPw0GSg/xe6S1/KPQx0wCTaKYTRgA3uVQLCNzqegH2AmTgcXlV2tLyAzeFEtjFmgbH64lRALomqwTVeCKZCLvSWKzr+fGNgaaIZCFWwdR9p8NmLH8AHSrC7sqsBMdwRKAhv2/UaUoVHwY+Tg3IQyO6KsiUOACSBzOaIW3l1SIO2jMd7cyzmE1rSUeSoXnllcZkBAzwAPQcyS7tIcxsEkS1r8L2A9Xgs0PMEgI6VmAEdLWbb9IAeXGhsX5S+z/wO9NlRGtmCv7G93UT9DbXTP7Q+pviAgBy55t4WDe03vtIt5OIj5F+1TK5cJHcGdbfHJtrm+V6AMhBT9PpCWLw1jslQRntxJRsVq9cSbnnG4dx0t3hZ1kAK/oQ35Jv5BUR7yNgSGVFWVQ4CwcmZ+bU+EtFNLEqzADRCczCm9X9iya2Or8NMcW7gtUKJbI2Jdm7XpQzh+NsAGjlOCDww82G5shenaUAdbxPbkEBnrx5AXKgdpJRwHoA9xLLKobW6HOVw0wgHc+NvutS4aER9XwFPyfgsMQJ4wAi3v4VaYPF0PLm1D/rdnpWO/OG5w7wEDPyfe8E76mLAL8djP6N7o6HU0ZHVhVWu8Hp0Xskm0mFWKCEZ91v6e8AKznCOD31L6CZn6F0sa8A9oNtPPH9bUBvq+mb0ajGsADr6lcpndjIxhgl5yQTNVnM9UbFIK61InkcvqCFkpv8AODGr74acmCDFOQ6jY+mLxdZSyneFiED+fIE6HLOTzAAyyC2gpyogs1xaNA35w3LiVM2xsIhtq1Uzp8Pwy9EkQAy8eUNL8OBlJvnDDK23Y5l6yspIZDSMjZn/vk5pF19ACPNldPxeXsK2uH4KUFk/pKuca282Ysnz4B9mDvCLqgAtFNO9xRJI8CVVBwiR5YJmhajgK8b4AMpmh3J8fyUKwCaHmiYWLt6S1hgFhp7XKAplgFAexIu2SctxHscehMaAL8ph9QhT7nwe+7e976sKq3r5yxWl3w5OXq1mCSsPgYAwM6Ti3mTJEitQeLWTchby6T/08tKAZDbfl1IqORNLAD+9f57AOXajPsYK2pDvDa+lQJdtEuER/gTXjKVJcTwANaMezG92oXFVzsgR9JeygpeYJiiobGfoaZBrc3c9oQAW4qw8FcvfWcm6mFiGoatdGWRjobzj7Fi/FagrkKBggAjAJEB6qM9fSdy5L75dMKaohoA6nsKqL7V7lyLrBC1ABor74C1krKg7NhBaOCiBbWckFHExPCYPFAOuOUJKIYAeXzY9e4vE7JdqL43KE2Ftm1+CMNmFKYNW9IU+pUHhgBJoKRbLyUgeYM99yXEN6TiCUbdK45/YCxZat2eQrfyADlur3CKpGiZYWosOC1zrUj6xJubh8cWGxJKk19xg34AAN5KhkP3BO40NaACpZufg/vw7ET7WpOTke5f7Yl/YQAnSCVkhwcBuxsgDuhAaN1dbc2sTG/okEM6eC5ajCXRABv+77SHH757pAOZ+DXJY2MM3vflsYL63HGvY/Kg4kAAMTAQmlHg9t2k4DlfgmSyHVRouwFFiIJoiVFk27CiGwB9FDRlyPXNjdabFPVZRE5SjTLz48klZFmMmR+RbEFWAAJBF4ma1mEOYJr9q1GgHT3pL5I4pCnM7zK8mMORZNMAHTC/6ymeZsn6myeCvCnIkOUTAPtcDFz9yPS0IEvdZQDGIwMAZz1qxIxV2ru5fnTW6TuWulEdxZj49bUGi33iAPSezk8UjvHpzkJYiA9r3nlcu8l1pycR9orS1P3ZoM8AGDgRRDWaVycNBoGt5aLTurqmpTbqQqVRDoLSWiS5MQBrs7U51d8Q4l6stosEqprJ0GKiHGSVaodWV0PfC1PcAGfBrPA5AWDPS5y33eTizAocEPsB37Cq70YQgH+ZpGkAveRmrsj6emmhkVlzHmXAekf9oTTLpjqyVFmG5wQC1wAEADfpBLZiwrFIq0FarAxkEAQLt647rRBN5LtyUsPrAI/5sOlwzpSsvLKglaskD++VPRQU5tffXVtpIWEuggYArp1bVT/UYZUiM8ZU2cubSikjNKRpCYGzAPnYwchTrgBxHencXhq13I2+4AZYJTliNh5wcaGAhQfFwFYrT6SuAC2R2ZE02A5mt0xTapbeH80AcmOH2ERbg91Mx5JwJQoAUWD2qq2FKmyY7qNRQV6nHXXgGPDuRk0OAQLQqA3LUwBJzFLGJPpt21AoyN7+P859LVfLFHtPry2O2+gCjAqQAFzTZ3R62avorm3pN70ACypB2d9WwsMk3X27oc5wOK8AZgq5HyWwTobInQ0j9hKUGkYDBbruiS2adfs9zibrdwDKtA7pjrYN92Gkdc55nv+9/mqK3FqW2c3Ma9sZPZCKAKNHj+TkhYXe60rAUxR6nY7s13Za2UNWLDA5o84WB88A32eJ9xiEUDldRrNrA1lSBJkaRy0fNjk6qzrAajU3rAC7NlrdZRu6ue2eBJOcZwoBibjYOsphFtuS8dYjHQzFAAn8o55mb86/9rhoAFl1f9odPxRcrkNTjChv9mnMPN4ACWNcigmgE3IgGF46MYPIZFfVcBNYdmEXF62wZopB+gBG/G7mElCsWKemz1nZ6G4UGvUhZNO3TIZazGv3qHNVAErfatMNO22qD8Grv7WFmOEiVgkwpSfDHsRRfjfAJ88Au41ZvWOIIMYaAPM4KES2Pkkr75Zt0H/6DUEGNE7aiwDvIsiir9qVsQg9VQxnZdJR0vTHAtL0ROA8CUt0elMdAGXz3S/KEYEGddRLSmXizpN2G8vax3YyitENOQpnnvEAd7DHwZtygLk+X54sm8GmypsTXPdsZ4EPvlAOvjb9DQBCx58X90hWcmv37hq+nefHFmP57JSdV9qVw9fJhzy4ALNhgsTBAKxNOcow3X+TOkUb3wGvMI3HGS5Tk5Gjl4YAwHw1rQ9K8dhoT95X1lNF65K3DObfZ9eV+7Aw6ZUQ1gBeMAgwI9mY+v+4vsxNyfnf7SOkxF4GCnbyrUgTLlMWAP+uksgGd22wNWoEeC7FgHYD7Se/A7JGn8QKBSFBWnMAUeriipwyCCuNVBKvZpmlZx6VCjtxmmHRZ94gFwo3qwCtMt9zBtP7NahM8O7PbG6wCs4Tf+RE/52G/T459I2pAFv4MWvwlLOo2vuy4R8H/a3Odw3HwryK1jLXkCOWz4oAFASBRsj/sqz8gQAF66q7CD3I3g+Ln1oQuVXyNCaxXQDWgbksa3QVeJwMVV+TMwJkUabGmw9Vo3h4OEexQQv+AJLoJcrRHEi/Q0OCo/UYlANVIYZqnLVEetlI4fJFW9sAR2qBhUbORhDiDvcJ/ZUs9adG7xgTxLKu5ZlXXD8i7AAuAVPuXrrvDgIHpSP+BdIXpvL6gL3PW3IMcb5x+xseAMkKkyrv8ucb3ZV2j6pUuRJHDF66WXAbgUV6F78NoEQAJgF8oX7d5SKrlOGiyRMtcdC0V7sYx6XlMDVYqOPOHQDQ37oDhS972ch+Mb9xVqFmCzMaF+/WcQo+FPwQ5jchAIpnimL87AyGb1+TDq9p4pbLBTqCSNuPaba6UmV4w3kAd/boICel4KkDlOY/u3Ucc02iHqaojyoN5SXbMbLZDACR1PZS8Yw/B0pFin7uDPyspNq3NKzEeA/cob9Pv0FJANQWpUwuuCaK6g3qNy2x9Cm1D8+LliFPH1wZrkmPi9oADzKKWdrnl8H4SN9jispx4P+MZ/jg8Bo8n/fNQf1h9wCxmAJhtUZqjnqdZgMUDGcy/GVF0SbbhZbjU4Pkmed1ACFmZ3zVZ2TCFEXzEZ1qdFylJ1zZ6auBRY9luUdtefUArv18KX8W4ynG4I237RB5tnx0OJrkBzE3loG8tuAtxQCWL6ESiPsMSDwaNwqZ1ApIme5fuS/VI+/pkxCD458SALH9jOIZn6Zigjsk8svunVsBz/FOzrJGJYqjA/nR858AagJdcrJ8qHksvnlQZQeE6Ltda9hBQnLvOalu6JREGADFOOhJPzPQUeSx3jWb8xNQM7I/thAhCSfVFSc8KtvVABg7b1BbzaD9GqEb/LFIauWjIrVSkOwZMwOXsmT+En4Azh36D4waDCdppYjJGsoB2+dTEFXPltQk9V9BOpQZBABuuo2+UpMSNGUYKFENWPFHhPv4NrA3DGNfTF8/MyZnANKY3k7Rq6/RwAhodLrtLWNRrQNujcQn/SdEIbQ1pwwAMl3eZMRWuilQ64Qrl12eT3C91ebmrBIIPVR3EvlUngAoKJmWEzFvoxydc4SZpbnpuwcCpBqr96qPKECoPApkAMCc2ca9QxV1heu32dzqYuPPvHWV0FMEb/VVgamQnEcAop78zZ7oNuBXNlQAgwvfMjCDWaqWUZDJJcmaOYOKOgBOK2OmB45/sFm4dH64NMleziVt4EMdzwUPzqBbNIVDAPrAOaQwVbL1vu/lMp1ENjsMRblsVmPmb4Msle+6dkIAM5GBMH0B+kcVOYkUmPIwBbayO1sQJ4a5LyHJ5mssPABV5uG2fsGHSzZApULWJYEI0hqyGnI9KD7aXNZX9f8qAKB3efU3G5wcHFVa6pkWgD+F3SM1gySG9NJtszve4qAAkS+gHj9JYJ7eR6lJBe6AjQ2bs8DPTsSpdD9pwL0bTACtpBD6Dm+RgBz6yhbgMKncgcvMjVNjR/bmjTJihWZKAKfkEBTKw6IIN3qOpFak8uh7CZjeK+iMtFtYvhZKfvsAVx2MEXGhv2W27p1/lZQyL4hxVIYDyONivO6ae6M3nwCSoHzVLC2PrYaRlW5fmpo3DCGEip8vLj7OUf76QkYpAD1yh6/40LpdJAkKWEypo6uXfw96wowYUHiRKfTX8kUA7FuCrUHk2vL4hQgViwxCnJojRJiyOhJDTWerPMH16QCT+ICzyOKJbiSvwg7exeK4aR0HAglq9cJiSEPqUmBFALkH6sDvhVfxXbITLXjutQ7P7dmtMYf/9TWh4ZoXOnsAkJLu3hyBb+3V+L/JmGNhOsc56VTPluiS0ASboub8bwCi6qCbWUrlTtMeQw5Y7qVF6XOlk2KhVNNuVOZFchPRANM9AzPP9HZaFSg3KwgL+GUOFSqE20hhfBxPlYXxhzUAI1kQPzcAfb9uU8lV5VLxfHzaFQ0HWnIEqDbmoXUd/gAcmEW1iQ/g1PNy+BIp6GiOnlNugXGkJUDKJBUl73RTAFEddEcnFzdqxWD2u3tvPDlMSWLI1IwFX+KK74XtwmYAiBZpN8XUN4PCgLOh2kS3xu8eII/3H/R2+zREbHLm2wD9YEzL8P7M1YrRvaanCR8BVACp91BRisP9hiyxYuS1AOMv/NOYxO4nj1SvV1wVLvIoaREDaSZNMxctD80qxRoAjw2vxR6niRja1LTSTJkOLfPQ7F6IefxrVZ+WBu+kcAAgSb9N7RAVZW35tml6KRY2xzizMcZ2SHxVCyBUzMTxAFcYiTALBfZKSS6cMHtxKT+zYxQyUfKDwFDFb1zSXqMAJU44U/nDhpqAeDcqkH9L5svexUr+cenMcUW4mgSKJADFtMDMvgC/55CegJ0YbThMnchS268i+5GfHWCdHJtlABZ/Uh8LeXB7HX7UnFK7YwbWVRQfSrE2mInnznuti2IAVGy4e5p3qBF3qYY9+KavzJyRBrSdOaHxiM+UtAgbzgBfRcbYezHynFEQ3s1yfsZ6LxI5h/ZP46E1aCRFoLuEAHW01yJr3R9HzeeZtcDBW0WvVr6clnUVZjM7bXMDiCUAGwnAvQNo9Da6bJAxKL8xDxfGss10xAlWNtdWLWPgJADTxaMzVcHTJRARsS5b4caFAIvU+zXGy8phuNEEt2ksABmlsc9MsfAh1R64B/+LDHvBxogMwN/CN1x2og/9MzEAewlOskXu66sb0MxWkMWwH/C3YLPXh/4ATsxfAGxuYQBGlV/RaxaDDPz4R7VFb2ZCSAtwzBa6iMyYBRKLaz9TAHRy2GHnQaLYijPtEuGsXV9Q99uoC+BuoVlE482wzywAhLje7lRGXpRJxBHII++eGFHfGbas/skpUOb9lQ4OSQCUQq6UtunLUIxuT/rdl3Ek6fRcK2zSlFa6W2zIr6hbAOu5xOko8MeQwbxXUwBBoNuTDsQM9gCG5EhRBl/F0G0AGs0HGhPCc8JebRTqkMjJXiZN0ihsXlQLW+5lvLfF3QC5H0I7LRl8Mpmjh41ligRZp/52n/INMLdvxyotzo8NAN7cHgLx36AvZQp/HQleD2xMoMd+kMnsmrlJd2bmJLAA0DKq0SCHNrtOUcpbFbaFJFBuxWQ/Z6qhky2ad3+ngwA9AKO1gBji/FvJPmPMgwMkwy7ONbkd/dE8U2ctkAGbAAsMN4SPh5H+81Efr8wv+7He1QUO/4ciqytd8C7V/ZsAZKKbKJ4IXKyLkeUN5kdYmXqvu8ifkx7HHm0zPn6p8ADnqHJpDPJVZHiy7/WXRaWX594i82JCxUIuv9P/rNUlANC/2dggUzmQNN1699PW97zZavfKLURO6C2AP0hQmvMAyFMyXjHFTLrvGUrv/kt7YHjvZS2A2oJt5ZydjSrkmgBydIq3FVvmPExWWZDQJAfZPsFZ88zSKkT3CW/DZfm4AOxzXMhi5UFDTEtU0GcsYdy+3yh6L/go6LW5ORPuLXYAlgS4+MHAhxIB/Dz87GuhLpm77yw+sNp0ZE6N5h6MxwBg1ZLvLj8P4MadNoQDVmTvJ96ce85Lx/6h3ETPJ7C2AJVjjOVXcR+Ia5hw6nhzgW88NRJoPDIhIty08T+IdwMAsNxmt6RwrjrIM0d/TrS53PUdVKYiewCtJfUgxCHH0gAEmW77B9RvaXtnNakx6zpAizz/3LimRkND/cZORf8YAGjfS8GoXFiSVxiw0D2AeZ0UV5ftJ/QzV+MW+Y1p7HIA1kDZxHO/1TU49jroFVW5vgXrRztwQ/nU79wi4INu4ABq0iZ2bPGrU9zaXkzgNRq12/stSX/Z+oBWg0TVsOEaAGhpcJRq+nKwJ8OyM4907+NY7lmYFIWtJqy6nixyhOwA0up+xCpeeGP7NSCswg2BRjzbMP+LrfvTBuKUyUfLQgAu2nd2KCakcZ6tC1+BI5lt8GdGVO205wFyoT1dfyMkABB1Cqj+wKdiOpECMHH13GKx7bMMPS2yYmW7HC/+570Aw01Nnua2VnH+v57GNHYsbxzbbyEO7bPu2UEqHwnjYADXb/cZkCtBM+kg9g5ljH5p9ruz6UH6JcOtjij+KGv+AAhlQGqZTC3KWyUQH8xW2r+xSrBpD2hBrjuOUogqWjwA/f0Zk0CEz6WuPbaVAIeMiN7NNzz6MAJmbJoF6xi5SwBakAmHHFdh1LFpnp8qi0oqTsfv92Z0VaJ6TdP70CGaAM2WrSZlXCoMVvm1WEZqbT0qIuqM+dAXz8Z2SxA074AAb9ZX45RRB3mcoFN8sLlqXl02D5bzww1jo5nr2Sa+CADWzxRfcshbPdjBqK6g3wUImlFsJbtpMOtHVXSlvyzRAJRy2S56urhpt6oQ1KNjiqAoOPJaGYYgbaNVoMlxqe4AyAtmT0FGHZREBWTKmMdDe/ThsmZ8Cc0LtF6AwPitSQCI5J+xYcSqqe7skATWH3qpBjuf+PrV/qpRBzMG3nsQAOroc7NMUhIbeTqI5v8PuMlf4mmt+ocVDgCgOOjp7Y0AAIYIhuicoYvJq0obbljch5RBC5Z+LOwihvRS5WQfqQAIGkbvPEJaOp2XpKVIj0lL2BUeyDYc0//s5WQQ9JWEAD2Eelx1lF6Fq5jmRP6m32eStEVE7rXvNpGWyJ5mbFsA5mruLa9NpQ7sIAFbp8y6VrghuTl5S9oH150r56h6WwA9VpVKW2Bf+x0e12lBeQpLlS2zMo3DgTcxRaDrihMiAC8AgCT0LDH35j5aNDvIgsZanagTx6asH6kLmYUbBPIAvWM/NtHLLf76LTho0L4venwUwpBz4VbPWiVYpjA6FQB/fweITAxJW1P5NMswNwaDpZVPCZMYj8/eU+QZ7oQBACX91PA/o92yIBOd287eVimTPMiteOAtsLjbmoioaiAAVyN1UNJfYGltsiJ0zMIQyHHo06dYOxKUO580SPjXawDX3ePL2Dul78zr9fZPGsfYVwvY3AWauMIADlZlVtaWADfCO1ZOAG7gVp3XIuwA+p/CYG2Er3/IGcDBdz4WD4EAaX32YKcIQRxsJPOxlU813Fu9I/+EmvE9j88717v7PACC/uXQuPf993aQXGdjOxiXfzvyUCIPB2+jHh/awzKXAEBBXJAbNC4ea9iRuNnoHYDBxz9uf86ScIYKnG47AnIAF5/y037nlK+n1SN+9K59+fUaf+EX5cei917Brn42rgDXyy5OGe/JtskdJyRdOZvhst9FvZ16A6UuoPIUVKD8AM/ARFSYc+CTGFsBiOKUK6FW3xhIqKsBmZqzpSMdtr0A1kEr2w8WAr9L186iYsZ3gFYwDqV4yJs4RdeBM9gefwCyhhTkmwED79UL4HKx9DMaFdDbef2JjoL1GimGWZkhAKVYCdDHG/03v/ELBc0DP7EeeZGImbRJPIiSUNcKIJQAEUuSVMwdrIskNZWurfq2FwAs6aGf7EQbK28Q7JbbmgBHt0m870d4Lt/v4ni4dL6R8Wd54JHxfMGLIxoxIOppALdXDL8N7qSN7rEwmsXk6lLH+AwO5JskMd4GyaWKejkAHUpUlUD4I6bD1RWUHVi9oY0qx7zmHo0sIpMlEKMYZQDOFOJ3OWvyTGaVNP1IoVHRmJEL76YX54lNzDTQU6cCAEAnavlM39i6UNJMpEjQ37jn/WMlXaQVegIGylHyJlAA+qRWyJelK00ck9xMLm1eHgPNThDLGXrHi7e5AV+q+wB2O+XMiO7OfjcL/pcsiHGXYyCDgjbBjmnpDQVJtPxyAMq7uyGPjuXgOVe0xSMyAM7VaGccr90xYtktEcTSLckAUClRaOpNsg6zEOol/rp8Y+cMhl+cNhrDX7nTjXecMgDC0QSPT6ItE9TKOVJb2AbhbbmZBDJkJrxOCNpzQZhKAOx8/nj69cKrgp28KMULuInyS7kODO/D5vn7aMTvO60ANSeFddsltDECrTnelNvdAB7jB0KjqKe2/bC4kfxkGgB5BCSyx9DsazIpqCSOQwud7p/4vaGcZAnWLKgd6cZyACQdT5nr0jJgRjStSQ8YvyfEdyfqPlxat25CX0wjhP8AgqtbgHpQmHtRuzJ4MiNQ87dDoXHxP0zadwrmF2A2hQBHOhjqlR9lRFHqHezxb47M6Sn0AuJodaL3HbpOxBAVAJ+6LwPyb3w44rZC9GbN5lTEzeFHx8IX+gI7zkm83PIAvTGNOOzmjepHCbXxBpfOdBR83c8QYiXf3H0tki1KUQApLvIQT8UK/Rz/aSCfJjReOWZGE0AWJWCg/VmqvQ3ZAKYqbaSDjal7iZNTbcVaMmms3OHs0AzyS3f6Kts7q5wAuE8tCWdWKXpH7WLMHOOAcSKyRTy2TeZfWdVz6RoragAEJC1u7QfGVLGqvbdz34iHutpWbZj7Cy44B8QLDfqrAAvvTcZ+iLhjNvOGcz7d+8+piL+CB9Ad5WsvwrdAkgIAl6Ln5v9MNdk2Ms59/MmFTQcfbUvEEy/OyuJ4hZhW7gAnOB36c/50dFACsViNKUTkkHYG7gu5YSjJz+DmCueVAOPm4U8reFXFPee+fOPCg27i8UQlI+h3meNl2VUHsj4AvblnUHLet4bAEkTDP0Tb83QttrtHXyZVhcU3ijvNTQBHX7TtVZgz+JabPVJP9VmCsx1eaaWSHgwBryQnC4BdAFl1N/Sn5xejkTRlCJ/x5UfxsdSJmW89ZHfsKx/ToFEAD3eeaPtGdgwxien9no8qlJctLzptgZRn7Tvk+rslKwCS7oqvtuGH7BZgtTxbPE6NVRBQSDST42ug1U7+8j09AJzS9bnuBuPjC6aT+3Qyer4h2jh0l73005sYgG4YxbwAFdlnaJNHSMAZ31JpWd22pwjhL6hnmRge87b9bpb6JQCiAOT034gTeYScqBQUxzzYHppuWmZU+c5DKFrdYMD3AFtqjBjiQtXxlsCAhmZkinJbr5cRBSO7C/9gD3vqTekA+iK6fvrgvyocv6s1diNvms4D7Y2dBMPK2tNC4/QnqwA0pj1fMxKcN0BVqzUxD9LXwGInp2J8pCZhyJkuCZHcAIW+JqVSju/g6jvIrKKHSyjeEkXARYIDK+6o/WGR2aYAyGZwyEJ2nhSBkHOiYW9HDOkkUxhbhzipp9ce3WCZgwA1g+3x2E45WaMrY+rcok6xj9lPXVVClolVKAGFjm30ABkDPsm9v5g7kcYPu0NDmtiMryyZzuA3MO6VEsBhb9EAKTjVNXEQ+6oKNUMRKQbwY1KHP2aRpTM5Vu1n53HQnACDjVjf+J/fx1w7pOFJhf8UqFzaJY/FM8+dEsVwAl0kAOzgxdA24mD11LQ0SzFMT9dJZ9YZ/zTM5tt8qFh7Js8Ailxx2hZ8Ix/AWRCDWxlbc3XQN1ou7K7FGfTjzrmKPwDsLVE4TJGP5zHqLNewQQrxljGBmcHCTA9qaOnAVqaVAIHBipHtNO519THLf+I2Gq6e/dDrVHNmnJouWLwgUO8Ao4Am4O+Itif3opUy6UMbO5Rq6dlygxtSq3RexxrCcADZy+8P5F88uUWfFu/uh1npoCZq8Xh91Kfq3UDvm8cqAOyqQS8PUo5opVb4VBMruxSV5pL8VPNYOnrKnqo7EBEAfgjazHo951MjMhSuHs2G8EtYJlGBLu23UAgqyTY1+ABPy7oskf3pcLhuKzgcDskVI8cQqtQMlz6reChh6bctAK2FK9H7RmgqVt7B7U8EFaxKZpNQJ2Gcah9E8fIuvMYAP+ne6mr5aDJUyyp6rZsv/b2jOW67m/M9F7dkgiaPiwCh6aQQ23UmaqY03L0J+8QiFu5JmAxvUap1QrXkPtGRADCMWaA70qp14GxIUaJS6iR3o6pJZyCBjPgOCgzqmoMA/133ER7UlYQiNw6KywRfkgqZYOfrqUHNKKTxSschlgAkukdmxoCzI/3OSunoFvzxhn4l8J8QhhZ3KRmHaepIAFZ5/oNtudo0r1jBTOYPstAOpuIqdGC6A+/pbFVNt5AAgN7cSSsyiSlrnAS0HpYNry9gsQY4bdzqVG8KKJtx8gCKY/Hvnk4QPU5Fv1c8ejN18It22IRu5Nti0XPNumOOAJnBOEaCA8D/RKnWNnfUU9mXaMPqF1ZngstqFJMXLx8AUTMS8vQPXfEwnRL7PdfdWCuv93GUEi0x0Tbj8eaMxACnq6bP3kl4SF2ogK3LhMPuvb2f6FsLew7cyT4TuFPsAG+etCadUjeueJM3lisMyuWn/7kWbPC9fmrLfG/IlioA2qk0yCIf4F4S/maJthA8oR3tPMwd/pabWgDWSKvS5gBCuAS8uZlWlS+aSOmOAy7zYzsgCyrW6e5bj+cywjqiAH3E1tRgW6+c7meng9lmKKX4cnykMYA9fVJqDZsd/78AMr9DtsJ77/OHRyYlQ9qiIvAvBBqsL/Pzf4CYnVRzAQB2VSIoL5amHtmJvJIX/kNNCShAoJi2kk16RQ1axy7CAKq4IQ3B/fhYjQEafLvaoIHIAcoBxxgVibj557OHm3MAhcQRgu2+rXtCWDl+UbOWbFIS1d8yywGmEahqpr9BsgC98eifCy+MjLhJnbtSEQegVvgD51yA1W3K49uZZulJAIU5uF4Snb81nBDem4fGiQOZGaiPTK+23RdHOj86wWsATPQ0inZQNFgfNYC1TELb/e4uaWaVSni1CzO3nDl4BgCsfFkGWh+Vs4gaULSR4QBMKBU9Ks3McHzt6CI0q6lRAOnbl+5aS9/IJolGPmEKCDPyPRHmCcF+y+FrFAvpfsoAOBr8hbTX0iPoKXDY4LWoyBjn26SwNzbZtcJD+ZYqhAC6uHFpgUkUv4qWgQV7ZMdKn+3XV4VYaSrVqqQmQyqUAI+vNgS+/uyvAKUbn0KraHTMZy6j2CyeUy05FZ7auAEA61YeO5JNoR1kJBG8W+Xne4CeRgtaP72gSpEQiTBkXQBXSUlZ7W7OEnTRHFTEqsFWzuJ4QDgq3vutNW/w8cRVAFf/JS7TkxVPIKZhKsOAJzFx8HYUkq93vKa3ptklViwAwgJbd8FYJP/bRra73VwSGcumBdeePuEa4OVNplymOQC8oHLXGEMwDNZ+3XHm4QJLPcaDqHTA7n3uU8S1L2ogACQL0zxSVJPpyoPmfNtEbA6q0F52daSYdk9TxM6mGmwAVZAOlBRDINUJdZtw2VVNrq3tQ3XgOyO+gUryDZD1uACuPk6L8UbuVEz3JJW/XLzbI4h1mGZ8+iD+l8k610biABQsptV16Z1VofxnNusLsD7rzfsXb3kOxhI0zIcszn0AEVWVD3qjBxmda29/6dCZDl3Ar61ls+OVxDuMHZksXACafXCiu5xBD+1FZog5BueggnTzEgJfjG9s+lJdAuu3AA8OY6rbq6lcGsSwlpqteuFbw2vfEwKwLpzQR98I8BwAcaqBCa30J4J+RP/+hkASJw7hhI+Ij/sUC7o1uU2HOADR4ApPr1It11h0Ra6PaRE9/Um6g6B6pTvX9uoIuEHjABRdYcSwaqh1ZHMMM2w65fnhZf4uI5rYFQAj6Gp1KiUAb9P4KFf+Dr7nRXz3nNdPiPrunZNTHW0hJBBKsdbGlQC4pmpRu5TlQaljgpN7MNRcm6AQnlokzMf5VH/KBBgGAK1mWq7mzEt3gDUojNbw39WqbwPONiaJ7IOAPU0endUA860zZJ+4AcaGBAYPlHXWWTqEmH3IgeTzH7E/Ju0fEACcYap7aIMnvEhsOMRjpHYJF9vGuIz9H3oWFTm12ShnAPn42zlS/2QKGSNVgsp5KhRZwE6Kbfn5Jz3dmrF6lPcA/542OSW8uixH8bBBD0Ohl5uidcRYxzfApFXdEjMgTADhUh8AGwCbNOW488YBLQCgeDELCEg9LzjOIGE/aX1MAInmtM/reWKUkSTh7iwzWzEeI6ZOIqDXJOs+ccSiiHsAZWZ8EXKh3eINYnwYeKiWMcOqRQSbcx1tGMEOpHQkOQBjyHcEvrqqAY/ez9BYQNN3y4xaQoC8Z4o9YWEClGA+AG+jQYvkuo2kBWs9wJghBssZoBGV9a7xdO+6Usm3MOIAC03d+Re/nh4LEhJl3jTYy+EBHbuL4eXHAbgbSq59/wAzW/RSUvKw5KFe0ivkULG36fRNHIgj6jX3yROvA/AsAADnQaQvkTMPkJk39OtSEHl18LFuFu9ej4DEte3wM6YATY3oprOGAAQihTPr2+c/ZhYqaW8d4uHczrqymYPSDAD69ONmKTdu/06l69+iFWuXm65VO52SalbbM+tBNqVsABhehfSpXTuUsWtmRSnThvJD3tiTzLpzxGMcb+VV3cYAUNYSlN8tpJ0LzCIA4OHzBu71GO8t8m38uop7yaPVtwBCyN4KVmzv0EQCusWoyvVPSoyCarg5YIxBl/bQHAbWAGhmb3m8K56B7j92GlMOUHpGO1GKhg5OIVknEp74ibEALvXIJTmaWo1fu4SUvQh01cOaVmCmsWMWQAXKBbeE7wDNRRYhf8ywtvihBGKh+ffN+HOswZB5Dms1fgN1QSdAALMURhvb4gcVKYjAw2lNHH65S6kx0X6fgTUCRgAjycwATyTHu3HcjYaJREMAG1XLgR/DAzb6ms+qaUgTFJ/inACuLApf7v83AVTowFcWPRd1Za9s76uGhQWjDyRmz5g7AJijIm3Lo/NeQRv27zJtHIQtFaFtlHUK6ApKtDBlq/EAfWmYFPrJWSVPutEBl9ywmVCjs17L2h0o8A9N1aofUQDE7NG+Nlk985n7pX8K/6jNB87i8yqoPqwDNyWCI/ClAIuuJohzLSHAljhSXkHgjXE6II7ncO5ucSN1CX+v+5IAHNJhSMkVijtt/pNdbBZq7XBcU0dBIi603xtbrG3VfABJ776ygSKi4TQWJqm3AdQiMt+Rg+kgQiv1raCPqciLAB5xoQCKhd6TVC+Edj3b91UPPDsQFBRELyoSdwfQh2cA2j6ARGKFtxvRWvnEd5uegRkzUfqWHnY08vhpWnG2NABICGrloKYTgaiW0KZbCxYWflIxSWKaJCk01JPV4ZRaAPDvh5tNUnX8G9/RopISE0d83c6wIc09p6W32vaOdZcAkPhvXbhjcJHD81jEU5taW+TyOBAZvbBR5/rqnYNYqQDVwfDnv7SaDRAEE0YhdVoP/wYJdtXg7R+3/xVcWa99AD+9i2o/QnhXqpn3xY9Iz5MIxmJU8osCtk7s4YIPQUYAwm5nfdyg4tmBMF+hWFxRMGSVogIekT/mSHZQrrTVqwDAE4qndR6k5bbKVJSJV5p6FUXH0Ln0dk59ZgM9whg0ANas05UHUdRDD6p3FbAl48j1YdcdTx6QO3o8rR7RHwMA5MCqLVrxmPifw6IUXZN9yzxG/2B7dnoKu2sO1xGsZADjnZhXsfW3/QvaJNRoNERPcTDe/CvzFYq+rD+jy3WdACNTqkBDlPw9/5HDW67UFLyi/qvfAbbVXmDo9k1vMKwABUoTEKsLroBsHHTBW2x+e/PptkEoMDogHZqCPte4YADgz2Suz78RS0ZgTb6JejLI+M6pxVLNKIq+5//XImXxALk19fzSggl30eTNK7SpIM1z9eH/yW0IDSdH9L/QHvUA8jhZmYXXJIMw+CJYTe0JpMxGosVqKdlpdqj+nbgLMgCw3x4gwJcmG8ehi3wCkSaWCsJm6PsciT49TEF2Blu6AO8YpYNp+lG1bUwWbmI6E7RcmvtOOFXJx1czsWPcC6cA1eGkhp9cxmwVCO0HJWIa3AFhUO9B3KKtTNA2TcdopQBydVDy1O7+c3st3Afu62BKckFFvV5C1pnT7Q+O0zJ1AEG5IAn3oa55muVBY3zwLojWw6TmHEJhJgA0yqmm+YgAo1E2LMUA3EMVdHtH+6pX3DWPWGd2GKKNbC7USNQt9gAwrpHu9+03UekHjt8undGR2S7bL33lxWAgjNjNvPghAMHNlQTOGQeQIaVFWhXwRMEw6Nximtp/SmwoNBqZqw8AwIiR2q3XgUBKMGxqfMwh/QWts3hidAVtfcOe3FuULQDujJvyNS0gfrvcNea2W4m9VkTeKyv+bX4cZujd2JV9AMi93SnyWNlq7LgJegdxEQtRIHI5NjKIGwgEGKXEjEYAqbLqI0qOZfa+RxwSoHTxQfW14Jh+1kq7SAH0onvljgA8ucVJrtAmIO4XvcdvkNooI0qtfZ2e5ZutgeYDxr91AKl4jodJbf/uU5REPRSVpeWoBh3/g+APibcWS4EILT4AyUP2UvK5G77yem8Npwfcl0ojjMZ0F6zbAGg1z9OZmgDz+NanZ7ZN8s465kK5Z9k8ar56EbOin0buI5kG7bqiABvsHQjMeQmzQgKoy2Kfulvpm2CeuwK4XA2QrlywYhQAlEF2dEtAiYHpZnYtUdEv4blU/14/H8sysS53uWiWewDFJFDrKp8vo8WiNXd3nLliiE56TXgIXLRSRr52KRl2ABD4TuJvtm1ssPtecugLt86qEZrxhm0ooysZ5GdazOkARYi+C6QLZD1pZ97T57QqDZWpvPSSUf4feY3dJSM+SQCe6a+rqSxUgjRjI7BkziNWf1S5kc7US5Wy44vIr20tAOTBXEE2GpJWeC8vZAlYyeiIlvERDkNwAoQ4ZKTXgGAAA6klX7s+MGx0eGoj8urqvMMaq7346bAcUu90DHGrxQCJ7uqPhifbWI4cIHWxhzq6lO6CRtMhdqvPdkpt8GYhANF3SZeHQYhHyHLRPZbBCyXrFrWKYq/GKY5tZdorU5IAZR4npJTi7WFSR4Jioide0uWgQoE0nTOhWqzNmf+wdQC5bHAVuMwG47o+X/Cqxd0T3ZIZVYLNSZxbu3eXTxTjAMQJcYy9Y5SSj2htHBjIBvqlxA1XYlUgRRMslx33YV0AB7TG75w3SojOpJ5aizzd8rppX7aVGbsTVwhDK6Jg4ACtxPrr2x5WOvDU8fef8TF10Ey+g+1HEAVE8wYVC5chAAfSVffvmf9FT/nmYDTd5oz2r7C9+rOwUmu1Bv9qkG8AsFlJ8lOlIRNyoMd8y2JLDOylgV/dalGc+6B98KbHMgDAxLuxfFPnU+chksjTPFfkQx1pJfb5gvNCMkksGlSmAG/yrZUkzb/DPEBiUhhhRIIRsGgMiiPv5M1Iffxte7sAujgy5tSttzlxojPLhiMe0OStQveevf6d8a3fFOAnigAQuPmrbwC5gOoAWpVg+Ii+Yc/aLWBWrAjg+zi7s9e9ANQ7j0lcCgyH/kGU/maDZd/xng6lmo1mqKWEvjv5aHcAInZYjzHExAu3SEVe13IbSErHn0nKjK7Vz1DHECa3MABPybEerceajr4uTFD5v9rw7nWKTbncq4OidVMuWrK9AKgKzWwYqn8DNrGugZhDfbqztPfXXHv4SR0PzvTmhYIAKOo7LQS68YUInq3UclUVfIZ68F7Iq4AQzf6bYA0N2wBIenTie4G9YdxPJyOP/cbo67dGDkqyR6pyQuoulrkJAJkqqhmZAVHUXlH+XaxQnnu87EmFbKY5aySx0Lsl8+0A0NkxwOxA1ANYyJ1BZ91Uc4ViaXvCHnbMQmlCmLgxVQAb8t1pleEa3eQ74sKBENN1obx5098hsYZPrFWVuDt9AALPcd37+114z1UvRr3dtyvOUR+o/AAq2czF1rbn3UoAJwgdFehAa5bDR7b75ySxof7Zh/Ct9htm3HDGnP3FPwAtfuIlKXmlDLY41obnJY2T6mnLY9cYhjEiFs4wMhemANZFC0+gCw08O1PgaGSGJDPIRFSDDgEoURwBPxTnZN0AMKRKL5PIBLhuOWvhe1c8sPgbGclow9vfR9vahxCZ9AC8hTGcUtdR853yf7FlC2Gql9RzpQobppq7ekCuILONAPLUvTDTrk25T5Xb7gbsRvVKiegPM7sT0QMazA4YNUsAcRuolCmp1wYsp2A0jeb6eOp4oo4bLU0O2nIB5r3aHAA4N9LPvfpfrdH76Wi/M4hVSJqjob5Iogp/7PhHULbXACfz9fa9o7/Q8Q8aIsH/NErXUd1WY26Ep1aQ1IHgDtwAuWIpA/BX4RuPr7Sk1GugWhfVqORTfiWgc5dtEnbUxgBU1QWwn3Wim/GZ9Vbn1Lmx2n9YuwJGwbr1a1L1qjgNAAOntXA8N8u3QusnCg2hw7mUbgXdeLzNtD4DUafk5YAAUa9ZZ2nFfm3Hasc0K6CCizG3l6C/uSUkhKTk0RkT2gAdztQ7D3hJoS65+tD8uwk/8lIecQF6+aGpYnVSml3kANjOt//1ZcVjOlJHPDwmRy2he0e4pQ0mH/QpwFe62AkAPYkYA/6hootk6Qjqa+9cA65NlAGo36XejZzmCXl1xACF+zxuoa2MTT807Meoa+RLoxvBis6ufkd+zYVQqAiZAJnKfcykwGnXD8z7WWwu83Cwt5LJLTTD9K8fCF3vNo4APKLQQem45j3CSqWH/qtO6/m1tOg43/n6lsoI9HPsKAArdgmfdbJHgvbzFlmKdphWZY6QAPK4TkUhUL0/g4jZAGTQ8Jb1vyX4MnxQcTIFo9VSCcQ90lJSVPQgiuTbPz8A32wPmGtkqG0hgOCQF96ZGxfMFXEyBzvwZYdJVGiyywD6mQrHF+WiPsBeyXEJyL3ZBjJv6R6ujiXKNHM7ssbZAMt9SyTF1bUSd0Acr3LAReb/xdozfDhl/z5CI2+8OIoAljy4AZ+0whznUYn16txqwL2aWiK/tDRoKYhMCUjoeAAXmQ4mTLeFNWN4JKN1hNqOnMbpE2bSm+MVSye8RBgyAKAavPEGjMerUVrFB4mESaWUOdXM4m1F6mcaXsX2bRIAZDqRjYO33LYxNpfSjSGAmd6EIphoQRtf+ys4dkpiNQAP8LdU2LKSt2wo//YXgIER4hpR38gyQtQKzEYaBPv5AFf0woY0erild4QmMZse2QexrPR5neulduGKoPEV/2oAvBcquQcb7GmT6iw7Nzqsv/SJ7TQdqClDdWFAv66pRgC70uLmG6MzIl3XDSi2wWc224KytTYPRmy96V/gWCkIAApMuE6U8NSRshxmen8qAriIUGKsKezb/QPOGQe2P+kAxPiXmEvFug+KGLj+MBIiKbx59modUse7WyFWKzYBdwDlofRjzKqWkXvHclJk1CSu+JaC5SZ7oBwcLSJBaUGpAAaI2E4GWVKZ0+5byMYQfCl0O5vCiRgi5+s5vBwC4dYA7s6W/h1X96gUjSL3GNS2KgV0L1kWO4yufFpjf1AyVwDaB7stf9eR5HZ9NXG1ycg8mG59Ohf48mYwAj7xkkPcALR6oBhVh1W/c1Arc00hTlo0Xy+rHZcpa63UCu+Q1C0AvgKYyrM0w8V27fA3a2rH45hRGjz+k4qPlWPC6zCmmwAE5fSw1HGJs+tT2RpLEh4/r5dIjzrQCdUDDu5n3/wVACS2iFCMap4cziQyKA6tQjOmrTIwFzfNboa/6HhxnIcArrd94L6nbOR9uHbkoygMUTCACD0SWtSk/PmKEld79gABOelPM0G4ceRZJWMMacx7s6pq6KlU7lP9NkoPmhpGAC3MGSik6Ln2TynvBbz4j5rt1B/Mz9g9/Y/S2Ad1DY0ANFmgrFF4P0fXn4KDuXM808RoLxiM1aQ7ryEY+WRZ9AAEoCpQVc+M2k4s0Dv9HWdgn2HtKPga3agrEV2c0X1+AEHxMOgxncLkJzSZ5GVvoTTTul3PfU/X+ImhiRY5m/QARjk2xOO28ep4XJevUvRM4yLPzjLxQTvyZwT5TPrQPwAeZadyXWfzOZu8L30ROOnFwzpzzyFr+9OewqRQXF55ACY2XTivSTCjVviZ6Knuy4+6tQUNGHvNT8VYdnNo9JwAV9X3DmcHmlpAFTp8+8TELuBH1dukIbX1/v6rlW5OFQAybtUsq7bYLtygdyJMyWWEUSLpDExBU7Rkx2H8EKk6ALD9JoQjH9AeTJOGsraV3IdlqSjRx7h6lZpUi4mum+MAMl5A2Zo+Tw1sND2hP03LQMP/fHzyMHkPLcW4jhWcjwDtMu+x/abK3740BGKhdZzgPqW4EYOtUFF27OF3DKdAACFDYGYWR0axPJQR7xDypIQ9ElMcxAmCphmaJly5kC8ASYyB3fengdXcr7YTqfzakIqbv8rPTcjMRQxfXgdUdwDJQX4GpZB9FZI9bjaCVzizwpWagkA0VPL5PiMRHd1EAAwo58E/WSXGHxccqcK6UtswDDXrUozFZwDRKS5cRngAXN+DqOga7xpYQTxXJ+3ke/L7nkPGYmL6xjFJ8DQX6QC/X8sqJqjoterqJttOgMzxwDd5RStFnHP0uXuqavs7AFQ0USXdOnDfubkyevDT16EG4iMLy6zaa47i0rU10FsAl6z8cUdvHRSgRt4JMXBUUsPl0cTJWb+tJK8F6+tLvQAXz2s2DfiGSG7ESL55cXXZojC+bYg4p0Nygh2lbYQSAIh16qxrUfTzVvDdFa89eULGz0U9t27HF5IzQ08xSzQAZ/ds30Q8WXjq3K6pFL78SOMkW8dZzOfKd+6hH0MpwgA3V2dTkfRrsocU/hGP4yytoNhjq2JFK6S3P+V8VkHzAPFOOOeo7Eurcw829fFtyJi7yS+BnoXjRBtIdJFYa6EAQwnUWOHdNQ8ruCCOjjm0t8aXJO3blr27Pd/uH7oEIQC0xrHgmTFNeAFy7lNAWNhroETuFJN+LjiC/nimHGxeAGzQoN1HH8WqhIMvqgUwT2MshXt4u2K+qz9KV/FgzL8AZ+MT/UIVnUT+E36OakbxwUuKifQJaeq0DWU0ftUBBQBKvsNVgF3aTK4CZDqKEl9as1xNhftnUoEzjcHmTYUXAF9XQE9saKL7ika/roP7/+FJd1fPNGOEu51XwIkM4s0AQLKDY7XsS33gnMcKNJhqj1I19lr40/DLv//cCCto7gAObvgHDD2o9EslIHCxnNi9s87G+LZNBUV3PeAuaN/1ALGyJMHCfMhKMqgO9QR96CZuhcPyc1ANcbum7rxN7o4AjrQxdcH+EN1+qkkQ/UgZJwaCMCEL+tsuNu5fIOChcwDsthwti/Xp4lnNRvEZybubWnirkV/r4ciG1DSNF9ftAHlcS1fZCwqXWDVusE9+RwqqSJEb4wqtfDwz6xWl6wEAvt8i2zlH8CuIuG/e5jymO+apPF4AO42m4w8RK/VNSgDfNY59iRlGha1i09XvtlUEVZDVNAWxciykK/QphITSAItiD8B+z2AyjtMCJf63zGfM4Va8EK05iIpxN5SxlZ8AyFrauAgfat1nzhehtP7VMZVzUDyoSDEMOAFfpVALDQD7VJuX3Cd8pmq2WQiYBg3vtJ1kQ7bqj9KkbNElrIdDAHWMqRQBTDa7z9+OSVZAB/FYmxE44xjhHvKApig7RrEA6wQepI/i0/E4fjJkkFO0xPKPqfvFEfu2LI02fTkyEwCVFP8EiKZz/PZSQBkhhLCteZPqOkjBmfzYNfuEbI2UAPihXncmx/MR9ma74qgEubckdN8ljT64MR5rcigk4wsAZMcgeZ0osCMSxPjBjkaF1odA83hT7cZE7IU4Us/4IgAaI5wxCWPhMl/oRI92vIRfd8wOLXLcHwHH6Pwl3sx/AG1Pgg0KMVVa4jvaBBxZ48kuOZOODaYL5hxZZuHJiCkAqNmjdmw3GQE7J1P6tGGW22vCU2obEAj1ybTsXYVEaQAHvYLQPqF6GpSHktrzApEhmp8ECB4FOjMKx9uhS4jGAGwXpfz2MoX9+PEGaENN5Vm42ILqvq+ya/leu/uA6QEA9w6wIk6+mxZ/gHmIdMLgBHZrg2jXGyghqGTgafvbcgBz9LjR22ixibBy8PeQcT17vYbyhuZXk0NZ3NEa0QOQAHAZiwrpveoOiFL1yhTHCZNwuHB32PNdNPhBQ0K7DDMA3ETMr6fbeD43w0Ibkw5wpex5AnwnpOlCwL70ysR7bQASzJW6H8VGiy+TssaWfeyv6e7PFMvpUL+2e0liEgbTABcBYvTv+5p/6pzukUiAESYF15wKo3TuUASZzNyvOF0Aa7nmS/Ru8Orb8dhy+I+ntFaYogXYpg0WmH2QqbUDsgDbDsqClh1N44skPamzLXPIafs9EdSugKkn30z00+OVAMy0qPFvBzenN6gaSSa2BeyGK00zhLbtqnKwpKBar/0ACzN/GOYk33s32ikmxyuo18RDEknBTpHukHDYE9ow5gBpOaPb8U4Vym6C0bQPcPopMdYpr6OhJYvIz9HhSGwRALbNR4kfBgL3EN0jN+GlzdU2PPrEY6RsdFIahj/4JwUAsw/egVhWO+y3VsniU0k12AZ9hV51Fwp+Rasbg8audwAopPV7W9uwrvc26swo9L1P3/Y/0GrqWuyX5iaa2bbKAFEnBcpjfRf1b5r7msGgcTsERuqyYY1QeQHJhrCeIZwAXALvzAFb8OtswPJZrBelxSg6AtQoQRLFfzpL0lptEQABymnOKwisr/TOrY7Ch1GYaLyo3kI5VSbr4PCTNIjrAHZB8RWGh01DvQVj4Q39YuTw5kQmMzNYFUgF4wvLDHEAx8wJrWnjCMr5IkEAiNtkTQrMuqy5huJK1/Zlw5ZnFwC90gZA0CcdHJhye+Jj5mox/ziAT9LirgGDDSsRMyLPAM4BxALqQ3ZvhyNpgoxv7imfak+/pTqNa1qJr02fcW8A9QUNkF0PbnEntnqAC8OA9V7KEw5T4s44Ai9g7oLQugBQ4NZJ0wMWDqKGKMGTMV1L2x6xms3rRz9Ep4b7CqIZAGoDy1SDJhiH8HgIvLG7YIPEbGClcpIfA5jzmpavE+gABXmXiT/93DZ+sPMub+wdthYWObITV7961oVjWI69YwAkmH2CS1MU3wde8208OjHzV21YSg8cm94+Yd3W5t/fADodekppOJqPoITapdo6wjrqsrFuiw86VCrRrda4eR4AzdxLxW661SjFw2PY/lk7i1erb6mHtmCPrI6sZYe4DADQ/wa/z0xMvngINSiCcdAgWO31NJU4Q7n2OXYdcKG7AH6cRPuNcgKhwDSzQbyA9D235cSEeY7/JHgU6hGpcSIA3+Rawz+VjGDfDnxRpERFcDi/LhEeqOG5LJA9zSFwbACaBrA8uJ8CtlTqJVOk8084ULJ78qEAoczqgGEdz8csAHESRRmRV5WCshs55ZMt92Ly5tNCmTcnTYRtg4v3zhAAjH/fjJdgCGUT4NklHCpid0oT0YrARpyhQoK6y/E5uAB1RhzemT9J9bdzd/z58Fb4yrsPXgQXiMEOvM8liVqMAGAT5ufy0HP/+hw1NTaezfDQpp22YXh35LIWzLTymEAAjE3kmYyunwO2V0YoEee1Nz4BQ6y47HyVXOpdnXLCjQCYJ4JADkd/ZP5LX4NYAHdP851XFCIUm5/wbc1Ojct0AFN151mC5wfXCkI4AMdb1COJ4p/aEgD05mxaqcA77IgA2AJeFAHPFXdovp9MV/7M51D5CWp81YbrryisVmw7vQDdjqkcflQV8H6+FNAWbghTHCgKQ2cGTaXG4Eb0GBshAJus54QuTTLPL1vH5/UXjGFBqjeNnK9JHDwkSX8v5IsAY5il2DcgE013e6rzCQ/qSb9jOqywi8M3jo5IM4oSjADUcph6/UiCVfGVCgF6/fXT4g7/GL2rxZZIg46r28eRAOI/rDnnBj4yntm1hqxrxN49agKeM1HUlTVKzi89rs8AiWHuAF9nOxv0E6/dkfAUaLdnu8nPKn27UEfgshw23QB+YoWkWypv9ersCa6VxarJy2fB8ZZIXVKYY5WDfwCoAG/0vvMOtDyGkzA8aWg8zksrLQAEi0op1dLdX76PphQAhlqM3Aji0lgt5aqtJarIBbadqKGy8W18fuxGNo/lawAjIHNfOziPNyiW+k2LT4zJkFXKkFldik8Bx+LVh0UzAIG9AlEQBK1i2gOLAYrimOsiUIqwmEvhz/72ckfiyVcA4Wy214/w6jm9SncNyqDDUqwqp/mJzQuf6TyOoKlxngDepAIpbhyd1paYh9zCQdx+FIghU5cN7LxQ5HJjNZW/ALT6FpXMYSIJwIJBTsmG4Jyy8PWpM7RK/fa5Qxr1VOQAmwiNiqDxBHuxozDmtvR4r3nocddVEnCoF9nT2aTK6gAmB9obRIILxrcI4ybEWODA45Pw5sDz1pYLroMT0MoMAL7Q+DKybUDHj/gcnqb9nmqehzGHyKwZgg8IR13ODsEAH4Z2BdLI4A6YpnPfTdpHHAnhfQ8pRT1H9GE9TjnmfgD0s1rUk6j/M7sb1DN2bDpFt0Epldwupjh0n5YB+ZziADDHxgy/7iF2sokcLpnRGYiEhTD0JLS00ch7oJniYOwAk/DIkHFTxLtRgy6yT6RZDWQfrB5KLxX+yE8Ok2pQPgCP10gaZyhYKEevIUF6UviNRPuiHQ3YgugroqP34zbFAIhYQzlqfhdLRw0+wgbEBpQlWY3iyHeODslsyWPNf8oAbpN1WBb5KTYel7X8cMywBalc5SJBZHMkUvr0sFLJQgBK5PwtT3rRaYiume2BuQDS2kSNSnwdfkzwceSnUHMyAFNbukd3KaaG6H4l9FO3gkZt16j2UmGCZeo9QLf0JGUAl1D3HsFC0y+gU7HMIKsBPvRxNFb1x2xGlIaawNZU/gCO0JPgaKoCFrsym8HjnVFRIsJVFKJEKROCZMRR7lJKAMp3IDTeu63uYSi2NmwkurgcYoq6j1ZuEyWKZJ5zc2sAbNxCLaYnAsf7mpkj+rrabG7c4fM3nPJSTGfTiedgjwCSW83Hbis8U//lKJoMQ92Piy0Dn5dHfC0qLSsUas6hAG6f/lP3Mapb6vJb5YmT7/I2omwaaW5MXLXkCTGlQUUA75zRrxH86IKm+ZkQ2pOWZ5IHvYLLeaz/wONK8tnOBQDf/llK69YjliFFRJpDcScklaL0PDYbZKjD39Eeq5bMAH9yGPcRJwTNgoIh38dncfQvt7LcEi8MObCjR6FzRXMAf2ap14ry5naUNjNY7C9cqaX4pmVcop4uaCjRw9Jf4wCUJHyzv7wCMKBBMF11U7p1cIb39nMc+RH+9fp6OCK1ALlONecXrvYOJfS9e8KS5VHa5hm5dFD83IMuY/IzlDQAPw8lugNz+kz/YFrrtvmBpGXsgn/giKVEBrT3TQjcwwBW+Zrayg5aC4qwz9ofwVtXsicLvjQmDsWsxTvTkqmwAJVN3LHS+pJr5gJpECM3wEjdrITpgAn3O+86XHc3EloArMqp+sg87e5kAeNyrp0RQCzwwFvXL8HdtAujc7BnhgDN/2AWtRa/F/J1A/0D1BTp4jUdI5t+YF7Iz/Stdm1WAFNX6IH3XaErzf8GYLoXHnWcxqcMsLmVg2DZenDlDtQAlRpjCNGDJbhKDG1xJj3KrX7t+RfUnDwZl8S7gRf3lQBIbMrT6YPnpFB7Gd1OjCB6U0Xa3yzaQ3qmmK8Qq/f2AL11Ygq403LTeHWp/t5bvyWlTJldynoKR4xy+8vyhHIAZrrQl0LleSM7Kl6Nw3gKet5xvv0rdSdt6V6Ux1uzxQBjdT287cvkHBzWfGoU59qrL3UcHDYqQJRbd2lin61XAGOP4TOjQAcdahWnYptLZsvITtkKbjMTGYkLwWYZsH8ALcjkKvf7BRVHlLpGealypyXYIaz5GhV+SuKa+Hid9AD3kYfhlI+FG/I+8h59k/1jkI7ih1ZCzACTMkyACZIpAPv3GZiPmNiOxxLoUUmq+tS++XfZRh0jzc0A0PfGHqwAkRa6LRlzae6XDp0TY2CqxCjUZRiWcWalPGZqGxxBnQBJVKyvBAD1pUya+cPhVw/XiBQy6LiT89dRrylx1xiQADLHcqTUT0cJWmBM/Pq3GAcJxvMVqV050c3wwXNw31wAHWY/LZB48pDcc7jt188hIlFebpzw6V8Q894fku9nfgBmt8SUV5482BlKEMFXYQJTaJSA1rupRzy5prhNEi5/APci6+02I6RV02ASjEUfLAjOnXq3lvPoFHaySFL08rEAnVkGini9uyibEEyf4FGYipQ6OD/x8iA58UDJesZcXwDStBb1dznDcHrNKDnLFv6FjmujHgYM0Fik/1Oagz/HAKM1rD3WBdO2g9q9Wh3SVONnuwFNiflQdiQuTiLNfp4AbwHk5ySZhjimAHz2yHqmVabaZs1hvXwIwP9xaSjHkQAO9d0opwqS31fiPRhzH2MwTQaafefU4aSb45BOWs8mAIw9m6p9U8JqF6N2l/w222DuhW8iKyaJfPXfTpdO5AcAvyLtx+UG1n//dpP/qxtBM4z7+pDHNfkf0MitL4NQ0wD8NGa2UzkDgB+Iibo1OelVH9NibiBiNZCdcrrAlNa3AKg921aQDqQDmaBIeV+8UwEW4rwITTCf5LD4rKm/GngAjy8xVFTONQUB1SYuainfPJiFgObWzLXjXNpCTzXSTADa+GEJ3vYPghcWG+NRk7jre/A6vMMIG4ZcTQ/TWS3AAFA5A+4cI/6Bqj0N5tDcN1F3ptSjsKWD+EEWL9A/V6EARgJUiU9GTqwM8XDhnEACbvgr+Gn7qnusgUPb8X9SwwAVZ3mKTBAXfxd0iI1o5JBAsDJjEp7q6qIcJQPFaS5GAHeNc+n2kTmLrql4+awBS/z+ulfVg0xbkbw+PcWyx/cA7WKOxel9LGEP4FwZBeT4JEqPgJOHNzS1nWjQdffMxADlYdENad0J/br2aPEU4pDn3LkBMOvsyzFe5enOmsu8ANt2a+3uuDNaI4z/cz54bfHQzTEDm9g3DXHwYR0guhoAPcwUvIqXmlDrJ1i6YCBSod15gST8Iyj10Ri0toM5egBHXOzlSiCCXX0PPxmMpnMBRnoRCsjX6Xo1pkFNbKuPAA7JkGynCT/aiYWE+ui5gjqoRMXWinC4ZXlU84ATQosAtbyFUslXxTCHeACg6yWrAtiYBKLk7wgvyBB1QeFgRwCMiQ+S86yMGS04kV0UKzBdrtv4QtwVGZXgPo4FFfRyALOoeF/MnpoySEJ/LbtE+Vg/bdCepXaGsgrr5L8NK4IAUoXc/xUHRbBNPr5SnFY9MxnnMfnxfVL7Z+gybR5hTACg0mu0HZEljwl/2iUZRF7rJxE1h/Brr2aOT1x2Li4sAHscR5TQo8odhSKKPZvKJoQ6Ge3vqdEhLMfvvx+6+fYAZacz3I2qQq0oWcrU7fmETLi4K0l9IlqaEviniSOfPgBWrYXcXuCXp5jdVJW9fABJqbDWJqUZZO2wOld67bZRAFoVH7GzMHWgwQGHnoPg70SLK4dwmUnZ68awfCg0DPgA9Xtf1L/2xVGmECzLKgD5V03v4k1CWbK77HWhEqKoigDnY8FfPZLwIQlvYeuxlz0yIvXIVisn7NecBhF5Aun8AA3wbBxu4/XHwwa6bXZqYe8XFPiA45CStZA+x7b437QA95IC4fvZtHdhdVtOY2uvc09EUZTKhtjh7FFYm/lxVABbwxq9+ZvmdaZqqLmDO8TrAHqDiwDI2/FOjOvK+N81AAzSUbheAmZtMnBjBLbykEPnoH1FYETGDwEZ8RX9zzQARLuq4fpwcK6LFx7NGXchxlzJBRainsTHmlj4i2uqCwCAZyC3bk2E4Cvkb3aYILbnOLo5Le15wiZUR7OtaBbUAH/tDnVZfM7GlgOoRGXHxtTtGW599kaeEis8u2Vn6kgA4ESHpYvKJHcSh1Z9k0i59AT85tS4cz2zgAaUsVpOeQCbq8z4M1PnWdxhVtcr5mu629NQIlNmQ0e7t7+cfSmJAOb0NGDgc3ZQdO7kvhrL6m/kg1aEBi7DQkp2r3EuXPYAqBobyeY39jHcR4ckY0WUorYVI1UI4ZDLRGtJNC+lPADwOtct+tsUig3iZq3HIaxZvoUeT4EwrjkKUruaOJN6AMl14ovMLeWW8Nji2Wg5JYZkQkC38BytppUZ1hgNRb4AA35OSnSrUkzDMFTOYZ+9AzkOnJ02jiFOd33jxwVA+wBn0TMYb3TDiB3gXLI4uZGwFvW7xnq9QjRBi66tT86uACShNcko5xljnHhUCkp1Medek7IYH0ysMewhvkev3aAAH80nvxPMGlCswkMWKIn6OdiVkOJjZDP/PZq+3JjldwDC6SoHQIfD1DpFVjj+aNVtPOmc6n+yBnVZ4v0MDzMlAMSbMUnaKFMZ50HHFhJWUt4xrEcKRLM3GRtbbOgQjJwA13dM3IqApIi8EpI+QUixovfi/Vupv7BokU6unjzv/gAI7EG+k4U+9dvsUxHvhYd1fSN3b1XA5BIB12qV2Ki2AC6Aw8SMXrspK3YSx2z1r3wBUwXyL997YKmIL911UzEAfiQ3zOI2NBf+BIPlMAzgydHEpMuOPKu4MKK0EZBStQALIHpc2BqaCQmRssyhRrof6CugNwcTR+16w4SrmRoNAG7ugiN4rDhmEc80WvgGvRUwBhr32md9N22pMFvNdbcA+qhm4IvT3bHhMglRj9KiEuK3hYr+LQFPz8kN7yd81QCAjnFKkHE/hkqX7PRbW5N4IY7TdYYNsVvDD4a0pe+oAD8a6jiNaEL/kNIk7z33MBGRh7PRyJi4fcxAp/IHJWEAoOwju/dyxVZ1IvKiYaxIK5TzS3QzGBbwYOTRw/4xKgD27fwu7/zfyfb6yXW1Vw8FjwApL6VOb7BofDzdxKIDAJg1Y1L61lQ421k6fy7mrmfnRFxDnA4MK/NihGmUE6sAoTwrfLti1poYHrMlQvaWvyTqfRLZOrwwX7wNAs7RdABCHSfvcAd1knbSPBbm/0x9nb3el5xHevi2NbEtj3oKAFnLgSGKf1Q+vr/UphgrfZasOBiwAdcH7FJe2iogZ9cA+UUb5QDVYINe7XebeJJX9xUynQbbyu8MsfI1Msaa4ADtnJoPXwWAgUqsgfHs9dY5E/1CT6KpGmATUZ2s7D1CAJUA7da4TPJs2ofEXI6j+zi6u2WOQAFNHM+RZzq2KNYA1CBLn14V22V1UY10gxdc0771ZQGHP10bVe5WwpCbMAAZ0TqYu8nSMSh5vQa103LZ4mu9t8oyd95SmxWfYwzJAKELMjBgkFHu9cdBCLqlDN21Hz4Npi4ruzKn/jaf0JMAyHsj1EDJycxPgUubhY6sdSpHTCkT/86eVFKNqiQYTgDr8EsIMeg+fRq0C6hUZnijELPtFYSyozTeUHifrrffAJn3t8HRYWoHDnP9jY/ClwnjA6b5uxCVDucpctECW64Ar4x0zMvtPNbwwT2/xNBk54QMmkBM9KxxLjWlDrZBHQBD32y/1Zr2xgLBkyWZfL0hHXhd4/5GimeoP2CHMzCjAOHwCUl55+7GoRQSmvH0uDaHqqCuZfZpz4T2+zbRgVcAWfaTFqf+DKFYv47+wVtGpq7pAFJpt1kXpHVHOSDhxAAqMy07hAXyWuLIcYOhuaWyYZGUTF6sLuxXD88srpoEAHpv5/JnGP9SDpE+TGJOrtami+SoxQqzXe30RodL1OQA/pPQJ48TP6bkL8/k85N58eVHH0Ef11egvJXsf4mV+wCQvkK/2FUHd+Gu4IS2y4ZOuwzyWyoCqR+SnH8//tVqAHmnw7WShKjLNmH0bwfgD5Q65obwAAqZhZ5dvRhYVbQAoJhWJ1fHFbLSVEl7LutGSbgxY5GoLib40Ewh1Gi1fwC4l3CQUSiM6mPhsZdlOTOa7kWzvM7VzRm2JTnTzDg6APkg1iKn6cUWmAF3yyS5ObOsDwQtXSwpJSno1qQ/Dw8AYopXL0hO0phV3jlzzI1OXfWeQ2e5M8A6KSHl62o4mQBYBjjuYrc9ImBPDxfxuf8g4m5TwZD2DURbRbiNTLkiAMc+p2YHs51r7GoEii+a351HiNa3H8gbAqYdpLgpeL8A17vDR56fVexZgdVz4HpoBfiwGukFWSaoxODls5fC6gB9+ZEldosMahHSN6g2FR3aTQXaPzc2S4wsYNDIt4lwADl1iUqe11tRWa/CDCZv4zZ3O1aP4a3I2S4zqMLlc2YA6w3Yf5lIRWnM1Rn7ev2VoSMgF5oLNx5I962twixYyQAm+jyy7ROPWofnqqzmJSFkirQaB3KghEpF4Y+mHM2VAJiqs9czC5bfLsFAA2LT54MBHbigxxi2CckyOj6q2iwAYmXaVzknimNdK28vgI0/KWfB+DQO2ZhKZo9K5KWa2QAajQ1OHSe06b/iidKcA4vHawWoXccmNML5WFlWqh1BAG0w8/60SI7u60jCg5EaMKmIq9ZLkpkNE8LaAEYSnKAADT/8uDwNrIZCVKxhapAUA2x+75oFbZ8AQGRJK3GonACR9ircsoxl3RFFk4e8OA8o/lMjGOpfiORrwzB0VN/6AASg8bWMzgw21XhGXEJlh3OJMdbyreTu8oXlQAZs1O0ANulMGXwAx3DOP7eSmyAis35uvpNDsERbR0MKPQm7sQCpYkhhRaYUmfKMK2Mj5tX8pAcCCx1iQ1mfdOaZ9VPCACzhv5HTMclB0cvk87tE7hFHAEY4WSgapSW96XL/SX4AjD7BvYRHlygB0z+iqIq8w9mYqw9xoM2s2yK1QCTVhABiA6zSyWtErFxOzjdADq3tim+RmsCH+CmQFciCMQU6AA52T44PdViGt0e6E4niTFDKgSeB/Evp682mMSzDLHcAj8aYSWjCoEmKwJkWQUUuStNugOCG61E1rKpt6V5OxwC86m4xwcGdmJJB4yYYYxf4EGY14Pb3dadTxm1W3BLVAHFnWEKzxzHsIbiQO6mrNRRtat4KB9W2jL4FKsBnvDYAIbcy/8NzNd0z2ELDeCW5jSsyzZ/hMo49hIHNuD9BaAA5U3JJcD5v/8fcW9c/xZumG3FJ0Pa+wPKEGb4nOYY4AIGcdzzQzz1cqrcZO52whrdN3KKxJsO3LmTMGb/nBhIAcGnomRwDAZINgncTJizCJ96jTOzJ7MxlACcnghVjRgB/F86EuWi8+WvMJ8huHh08oTm3PI291/TPUCPYwu18AOYmz/sDwelE7/ws+IoYts0H+SrCIy5iUCa6N3RV1Q4AXtZQljJcKgAtIlGmObEIZU1uyKHsugVVzwZk83kQCgBPNgHJzLm16ztSY4Alhfj/KB15YXHA3tUTM6VXPCuDAHd1alfUf52xAQcXonjlVxC7TYq3NQwtl4DgMFp9fSoA9WoYC6snh1MZ8cDMdeBqayteNvr9HNVo42Ppv5MirwAeBaAT5dJ9mXoHoGNMmyWQ6SU8WWpfg15Hxsc3k0IEAHZWVatQw07C8Iu4uCpCVTP33+D9dUpW+dWOC5yWedsAOx066VgyC4u1RWGyRSpkctWWDY84jpTBzFS3VTJsjQDng6qgRsUmEGUEcL7zcxPMs/sPKXODt01vebIRYenNANvG5QpK+imqm6g+5F5eLh5fbV1s5+AmI8MW3Rpt7xsAfD+uYOOgoRAHXABSpDYq1L8DMpaSp0aZ9ismGTOZ9ACaGQCKCTqavcFrIwjCsNF59tkSV1leIzM6Nitl+/ZsAC0R94dn3ZDJku6icukFsMJpuOnfma2NZJd9ZtG5r7UAWufUzxNXitf8bsd6VQZ5jr8ks1IOoZZ2rFj++vZiqgAKmnltwUqpBI4OFjnPZ8iyqwh+g564kR/5mOckJamMAKBbUspmYz64cqahJgTnZHrjt91XHqZCR28b9iu3APAA1h78lxrylFZPGseNtmWSPGcDXW1qQh6dyelhN3K2OgDcprigBVn1qD2CULzxlCf/iWnfdzKmIPmTiXboVuJAAON3W7j7YiDhiTRlXy+bGreCFtFW9TGBdkMYAngqE9wAeMGZgSuCudnvAftNQTZrf6vJPARk6kziStzAuYIbYAD5OSYVc4abw80DvmUU6yQlSCCHpZnLbHM7GD5WEJbRAPRpfC8NLFbq2u20/3NRpGaalxpi0LH4fwAgVEKpivQAKqahOPNC3YlK79fY2YQ9LfI8GW54E50yc+xdcc3XYQBIcPo0uVHOosQgSFk99iFQL5/1W8qHSE6Q4yfOzlKMABFe1OsI5A+Q4QN8J3nTvyKF5PkFlXmatnR4ZWpqz7QAMmiFPA3ZrThJNSPc36TQW3qdeDY/uhoJsdLuCalbRQC04Vnc+fB3mkmK4Krof+xHgNsZQSWgqcZsnq70jYbCAOMLhiLDYSfz0QLhO8ZcjrnjGWZnKA4oYU2nYFq1MtUA1vO4O9EXJvCC2jd90tadVERj6peFv0tZ97aSpbHbMACNvojWGs/a8LOr6MY+ycQx0roWpyq6dLwD7IkgdBInAICOP61Gopc9T7RfwD7HDxOL88lC1Hh4qPLOvLs3yCoAaegcRYb7XkCbQiIQCUSHhLKhKaj9S2VQgCVR8XwnoACwHvdN0wQF2pOdUBGKlXuP+lX2HC8ZmowHjcjYwAZJAGe/gJeL9H/Yb7NwIfgG73FPAp4TR1qylDOfvgmNRKUA2/j/3+6mfWWi67Y3XMGA/O1WpPnfCqSYm8/xikeXAQAiI8+Oz336n6a3ubhaR7BUVaLha0D0/LMg0aaKvaZxAAxAHGWIb93qPJwJ87eQsRiu3WgmwdIuewbnSCq17HIAsKKA//d+W6Zav97QDam4rxMnFyDZ3KyxrPJuc2ZYsgAYMiXnxQyKNbfyn3ZCaTpOEFi2kQ53699bP2FDnYmMANptO/Mw/K4xemZ8wFuSHuLHGn044EGX1SiOALKGVgIAXbdx/7r6bWAaOKHedz7B7EFUz4pa54Cc4V/T+SbK8ACT1xBbVicdqTjBRPkfJUBMVME+3YpfybmMk9Ef/at/ANjLAmxASe3mlv1cxyD+fnFAj5VuEs/mOZt31YOhfCkAcjGE9M2vzZICKrTyXEnSYZAQGzDIVqmIipCD5mjzhwDyu+CGDf0hg5/b0BWpBQfFXUNs/GgeFUMLSGMSq2oWACDfOZf6RPCJen+jgwuUDOrS8UDDTttAiCymLpuxeqEA33iUIr+lk22zSb/KIN6kIC/R7YXj5Ruhsz3dpHrUjwDe0XNPsQD9nV9P+v+vhbJRMNIPl2Zk1bb5pvWUkQbUAO3tYh0woKiEMmgtIn9FzBGVhnkQwoBWiaPOrfBjBQwAmgOoYvgyLjuIwiNpIbE9btdFf+uLfeYWL6NlzExAhQDGL62bXBBZOuPg3hEbw7Bo97TUiaAzMmMzq1EqMlIiAL1gfjGc0IuObCj7f9fps6iYgLiu92+PxfqkG7p6/ksALcyGpEnkPGSyZ4EDMbJ5crpuAlBkxPHwabLsa6OYCQDvbj42MDFvMSySqfwNGEUYjgiv1J5AlH2A2KnTfqA5AJi8HxgizjQjUhfEQAKkBoEsfgcbap/J9SKy7NLojlkAn9nGIGoeVPIGu7lPsISEIpT49Pqmz8CC7VKO9+P6yQBTbl6WQi/v1GVNzN2TeWbCzD4uzTeT0/oWE+icyHGvABH2nPOHsZ25ln6Fd+UKlacT1Xamo4+6+ZzOjVFj4QUA0usBC+vc8sgSMXAgcdOTw2lx+MTUdFJ2s3af1DGiMQD+AxD2QoCBNdxtUrAS4NVgHGhDDCKsdSP4vzbb7uMgAIY62vHFfe+zUulHQn3jgNTzQcYQcEYW2bgaDBXn9i0AuUF/G4txnnL0LOMscvZxfK35DFApF7UNggRHGwQqlwCeJrF5U1qe5iCybw1eFGQ1gRzVH/KIuHIB0igHmAwmAI80gtWXkMlM/qCs8dKnVMMUcuUrK3q2o5Q8rODwrzoAVF1Fyuq04FxFlY2wNPS0j5XV4VFqXk6/V7/gDJKRZQBXTCaQsU0Z5F4U7/pB58J6xQXSUR+dpO5iF5V7yo5JAGDz/YB6U5zMTR3nETXWq9wDZX6UhupSYDP+hIp75bMAXkj0DEF2yCd1PzuAmNh0BG7SsJ5UnQiEGIIYk6GxkACNLNGFslQUZZ4HC3HfYA0g4kNgD4gKM9rA7vaLuL0vAJ0a0bJvHaPm4tqPXlB746cp3vHXhPTfMiTd4KZlLm8AhSvItv2WyW+AM+mXmXZ4covPoWJ2agfLJ36uQAZ98wCCIQ1FlgGG1qPkG/4psm/l7lsHrwj9IePLAqfhOWnkAPirA5zSUQkk19ELOuWUd95q4ZQ+W0/WZ1dDvpZ6AoQA1dhJimBxlXw641gomHHeKZBroye+d5DBjnMWKCs12AC/92vYuFeFTRtgOyRDkEz657buMpizrnVS01jYrc4pACzsvfDbwNV2MP/l8RvJVCB3uTs9tZXjfwU8sgQrIr8AGVhg21TQM5gU7vQdFOY1gmcueBmoQvs93FiNKBTtGwDZxd7jN4mr0pRza34aVBGqedfMKKY/Aw3IUab4kQ/dAP5bWvkQzw6SG2BXHmAmxbLIavRm8KBmfJEyto7Us7AAOtane7WZZVowJEnALenwVge0HAeF9Juk4sdRngJWJgCe1oPHEGcb39+rjxbeRa73SJ0SHpifBWlOvkw0G8fxAH8r0rBnimbmFLgfr0mVxnoYC3hauIOVNMD6A3VjZwkALZaYrStWWG/TxaaQw54Je9ivz6cCgh8gBPR61DbPdwCkpka1kZrihpYLjmeOIxmA8NjABIRSrPGFwYii826VAIXG0/rErBhcHgwD2Mg8YI/YeLsHfKHGdEobPfqvZoQAov1jpAFe/3XWMvKkSFsK/u69mxCW+z+KVi78RJDWrwDwVfx19G9f3K7YNouhMAbJuQPj5EhT4BPDn/P9+eK8ADQJtYNiQ41W80jT5cXyk8SFs/XK0Tjdnx1ZRwNIhoAAyC1FFN9X+lBAoLfDzPGHInLFTLASz4Ih01BSPqMbugB4OEiJZErAfjBB7nbjh7vSit1yAb1Lx866Kp6SqsglADF6dEpvZHkDl9r1wY78WpYDmwywZ9lGSay2PD29MKIASjCDBtIWR0qrDKyjRSFhFTM4G+/4oudeYKbaR9HQxwBzQdPHVD9gXz17KclZ5oC0/vYNZRX/N4WNxHb4s1VzAHpy4ossiO4MI7uLpD2x270GZ0nty9i8fp7h0Pjv9kwAslhMblty8aaNK6R/uQmPBZ92gEPO0i16TCiFY5ShngBYEnjpRXKwm0iQVUFGZmp66EoABeCRvNH4Rpi1qmHwAPfruygUU9JTkMq3VR+NJzXTnzmEGSGmtJr7bt9xw74AEu1hTPUa/cH9vau9hXG8X1BcaK3f/SD99SN7lTQZSQCYhKURTi7iiUmb2S24Crez3x3ZiQkWUdVtzLFzu4eGAN1dbzwX1K1OaThF0pzB19Gtkk4FlgDOyI7rpn6wAOUAA9c/bK7IzFHoCXHh14GmeuVxV+TiSFlH0rHzrE50cABzF05poG43mwr3Du3wceiyi6JrHoDoxlfAugOx2T4PAOfAqNKV5KpzKYS0xYu1DmmRi6naT/VFrFN9FaTRdHwAQEz00xT3GsrDxz/Mgwa1s7Wszj+Yx2MBBUMRZSxq0QB0JvTieNNSrKBhm6yFznbLgowzkFWBpbl8kp0yM1NBAKED0hqr/aPSEiIyopzRfjrqieBpCO78AUZcYWYMmyAAtas1JWjTug5vNQ66nDtpzz+Dwh6NuTCeuEsKdUibPQA7U4GF+ZLMmNcHSIFN2w8fT7p1d7prg9jX4BbCxR4QANI+9LbtAieyYMcVnMCNv+5a2lA0zsOAC8fh14F9zBIAE30Y5L1j3bp89ibiDMjD93yU//QCaoUss5ipNI/yggBKq+c0vitmjVb4qbfNPZpR80jY3xRP9obKpCvZgnmiAIKCZ4KWms255EJjEncBZn/vYJsKpGi9w1YfT/y7cG8AR7DEcbXbRaLyA20cZbkJILu1nt3Ws90bEqGbComoWAD1Bih9R8WlzTEWlpd0olYZIxBjyITfQHISOqUvHFJKAAGDI4x2o4S3RXMgEv2QHFZ05itC5QMe4EE0UV0dCDsAqaWYcgcWPcShfaZ8G1Mc+2VQ0eRA3Ij0JmvVPugr4gDTDjJA29BS4EGaSycu2We2EygBEp0gOq6lLuqyjVBGAFuXvHiSUeAi/XT5xqekWSWz+BSUVVpjzWEGq9ySf5cAZ0WZty/WKPHkgfaqZ/9aomklunKonTbsjUbfjpn9NQDeIO/JcnGBPhvBeuA/udM8Gn4e+SAqvzdKg1QO3zRZAII6z6hGo7rJPmsYclEzO/xzq4nNkCNme26r/EoDcqQAbrT4VuotwZsKVFBvTw42nKls2O2cltYclD24FBgiLgDacOCdtgzAPeCuuJ2YKRPPfgQpTU1KmhQ75NhDY5O4AEwJQKHflNHBX3CbvBR3Ko1mPPa4Mms4jh1UQDpC8NEAG0X47gc+cuIlrNKR30oLQauts8O9KMLO/LVWSpeBpgBdebvb/QO/80+lwJ99Ktq0TEEmOHeoAigVumvohF2OALV5Uhj9wz8bXY76u8pJWKml2FDpO5AbMzJmdJm4e+4AK104KRQdsKPmHQkzpw9Zzw7XmMtx+MXD3/I85VPY2ADkPkkiJIZFm9CLQVWqFA1OLHsNhnZvGgbxCgbiZhMlANpXO6xSI23FhA1JzcTW8eTPZb8jVqhIvrBJU3XTmT8Aj5NPs7EVIxGH7z4ZHC6O36wSDSA82vyUsn2ufpqi2QB2KYCgxZURsYPlUlXp68+YaKcIYev5jz6hg7Og1sKMAMt3Bg1d5vyHHTZ4EoxjJS84jued2kYjUqkwsS9tmT0AKEgkxWlpQkY5qiDpObTv8MM84mKpLUHNesquCe63qQBgaEaUNoWr8Bs8oWBUmzBYKCjfEcKjwjZcDSbdiaIwAOogRH9JeqVvuGRaLvdUQOMRxjfQefu8nNDXUL8nBxgAn/YkK4iuZ78+M2cy+jBKCfANCEVHmYADrtNOUJRW+gDGhG/bIIeK40L4htw5ASmduolce89wjK3MeP6w4vNkAPnRJQCKEU7u+t2LLPrQ2xSR/VSc60OHPpUe0gpFth0A5jlM5qEbmFznE+dl8hDvOMEnLQ7yvB169r7kSlB0EQA2RVs/+PMhrQ/ntKUuPvfifxmJ0hwkvAyouTQSK62rAMiEs7lTue4r1ytWyKwIuHdIc+4VeWqI+9lzcxFhomkAb0E5AoNo2QbNLhVg7gYBKhc+6xPq5BPA3cL0P/vFJwAclcOOdb22Gq2ACLboPpnMWn/NGYjI+nl6bRTFNiKWAMnEQ+xEIkCp8rHhjvgf0m1OdzDby38yD82RtfjlZlMA/IST6s3zA5+ABch/29k35JKTwvanadSlEVddyT9zMwCwM/poq1vPMpKiCfyl7rRZFqBW+NyzB98jvx3bsE6hAE1h89srYyxOZqDTT7x7WK94QJwvq6V9VGDlbzEiYbMAWCpqbhiLCdc/MGjwJqHHFZjBWZlHcX5oLB+nYOLacACXPZGqFXI4HRnaBBq5MRHYx2d8DACYQ2xQUfEnBX5cAIMzRN+4TCsrmpYZRlF578yv0MYzGfnnigFmfi3PQq0A7TXYqoCQsE3vnQXK+dyP4RweYNNI8eNPBUyJ7sCL4QBUGctUNMLqaXa5LlIDnG/apsDUdA/2gdr628VSnWGTAH5ZqPsW8KgrjJENU35VSgtVDBEuTF0nhIxA2Neh/tIAFX9sbgkDV0PdGtvoNP4rRaeFg+jjRz5MLaKP56qj3QAaoDAeP0P/JXjyQfn/NOWVeQuiB9O9BlmkBJgOiIulAG17dmfmZCv172gjD31wPOJJ/8KZkY2rnv5yqskGBaYATo3BAZg1MxB/7ZHYA7Z2kNrvDZqDs8VNDdd502rvYgDTImPb5pZYr3lTJ4JMkI+I1WJGqpEv3SJ1Ix5xsKc/ANKOXHxswFGa2s7gr0HzaDiyEh1f9XJJxhwjeDTrj7MA/ULkuL1s1nMrO/5IsIFV+hJBVK/OJYFI6CRdWKoIswDnkcco77qJKfevgWqATBcME/tnbOTA/hdzNpEeu8VCAHVocXR8TDJWvXuVZpxwZsg5GZBalfDaZ/t0YVSkYWwABY6A48bzesW/WTNiCjh6fesDNOklCTmftV3LlRjYpwChNu+n3n8PChHmMX4powXi4h1XhES+30GQgjmiS3fXAPzFP+3iCNBlGdu//gosGuDoaPPUc+BX/qGd5OhqRgMADX5tDF1h1i71ESArzXf4auA9FAelyvng31x++XK7PwBt6mwEE2zgz7Zjzl5lYuN7ebKRt6hX1tPqFtq8kfYvAGe8U3pGGjYLL6XWry/B/8OU+FIkV9CKhFglJNrIZSkA4WN+Frt6iC6trdJrkEb/4ROwG9ccOBW9tpfWPiteDACeA3esDqj6q/frBixvz2N2VtjL8ewIUzXPf7S7gZLGAHgaBRd3qOgpr6tiWvrLOkL/qjsdtAzS02ue3/DOdp4ANOeC4XllstmXZvhT7L1cqXbEmIla3gz4/oU0ucRgyAB2sM8Vgc5X5PykHFRqm1mT1oaP70tx0PGHtmOH/treABxZ00GKPHu0MoADJOGoPwvu3fDuJzhBKbdwPgmCfQ0AZD15eBo9+eTBEXTWSpvDDaRwtr2vg478G6RxX8UgjwAtTlHiy8P/5YmRIrhQAgVPt3RDEDev7+PrrjNz2O0fAPiYoni6Aiu6vXLXwVbM63ZJtiT2kUKIfbK5lmltIjYAC3EqC4JmNnYPjWToYIXHzs4LNMiY5x2AZM5CB5RA5AAuLir/g/Qavp5Nyg6wohxmJAhMvNnTOxLzrXq68mvKAAl4wUsz64Em/bmfoLrM30Ni9fH4BjbEQnXmRE1L8TsA2ILXfDC14XV+bXQWp5id6sZb48USkr3mZ3uhXm+4cADqQF+8kjSAvHIAk8w1JpIh+gfnyF8Fg9EaBtGMMC7RAKp+nfOIRVAXpe1tB/TYwU+3c+WTGgTwPeO1ToZvDrMAOj662sriKl9VTER217k+i3tR77I7IfypaemnhKgI2AAJcwf/LQtnxrPgpnn4ZuwGq9WacckxhL98QYc7+m9MAL8mTnRGZsHq8N7x6mS6c8bj9HFiT2xHZQPR5TM10nEAQVtKa1BbcxVYxUl5EzBjqehel0CrwWI+P+j76qavuQB+SBBkZL3SsJ2hfmtqwNWxjfM09QoJTaREjxqwua/0AOKuGpG0hV42KItihHWAUYRDaoi7NggwPiVhqU4Jq8IAqdWXoaVz6kG6IPWygKAkbXdLTSf0PIZ8rVKLx6D8jQCuZIZZDEFs/Gpy0uO+ZLPz+WYXdpe+Nf3ZBBFt3D4IAGtUgN4TOA8O7wMGHVNF/h5Uqe6jdCwISUyq/0NbCMQAXXPSgfZs1EMR1qRvPrETkaNnJPrMkDyOev/VtaA2YgCulY03yKJOmqSMCs/z600RG6jh0L00EIKt4qX68/jJAEt74GZinvd1+7jsThuuJYlKUpFQDrC+xbu0XwqE/08AgGXSpiIdsUTRHLcsxat9ZHbjjEA368sAuMM4ZlF1lwBVzHHHsV2RbxnyULHB9gsbOFZwwgD3Kl9nfUywof87AMLpQOnLHfxTdxqivZWm2zkNNSLaMegMMO6s2Z+cErAA4DSD2SEkD20EMXNwUaRkSR8YSNX+jNDqTbmH7ABjIwAOKuVpvo+78x33pM3CEKmwPU2UQ0BM7ViOQOYkPqGAAJD0z7d5l9hVk9BY2XkQBg1OMwBYLiK7nxrXHFQbSSQAFfg6fmVRpfrlFPLbvJe0vfUYHdxrjWaLV0m6PXS0sQDwiOnR1jJD0/FY6SkrceSBODxD5WKcNby6xg1SZ9aqAIiFcxQe+x++XB830y47DO90gfuMSI3Q4LGLldGP1vAAKZ9R5xMdeQpxLdg8qC/15760DP4Jrjo0ac9B9eUvpAAfRN/+Fk3L9MnmY3/bxVa0gKxOx3bM0SXNstOXO+WlAO3ur/efmz/EOoTmmdgVBw9bwgR7OWBNgtyWWtZ75ZcAp5jvC5Pj3uzh0FKDrjP+D5+snJTfm+dWzqoCdk2N7QByGQiuTyW+/enjOnix665Lj82AkqZweZ82HaWWMGO0AGmuubz3CSHBej8L5iGOygRzRn91Oz/byp/WBtuJwRwALyEqUfvvB+LQKD49V9Twa8gaIXYatqoFXgUq3D2gAwATXnZMXJ3DlxbcKCz9Bs+VgKga7/+VFKX9RtKat7iSAHDt/g1rKFEDBFrLXnu/I5KpJpXuMu6qB8/rmduzvs0AAPCgVK112m0AnPNbovbPwtZP4q4YQI0jP1601/AqfABhFb+lxag0g4Z6tqJlCdvDJJwCA2DcLeWfGg4tGr2PAO+5GgvYygVjf7NyUpIv8apkMIuPp5l84+5GyGsw+LwASbDkBo4/zTp/5RI/u0Hv00vE7qfpEl5XXgXZSjtaDQDJ/bQ+Ndfj32A1aC0/cx61rXSfrOzPt4KzTNFoNkYKAKuOiHh+Cmm429Zi2FeSGfw2O9Teja3xuecYwnLwOLcAkfGRg2Yb7aYF2mLD8FKBxcR6sfEL+7ZnZo9WNM9ogQD/wQo4EOT9mh3aMTFxEeb1V2RvDQTlHy/m6azE1ZagAPrFp4rnSVD16xo3CPKXs8JDG39C9BYkKxuyXTs+6ikAXco8APoIeUaaN4QyuaB4/KZ3TFUVZTBEPDnYYYbhIAAw3YrVRksDRDOKvF+t2OR34JlIJr+o6MOWsy620CSkADr9eTT1c8ZpHfLLgUVt/dkicq3gPrdEgeTnfj/tArcAHkPmWBw2HLz6Gm7ut8W5m9sc20O0L0q6ex9dX9o7QgAKXIoJ4ZyFCLgwLiibpKYYkSbkFlrE/AVwq4y+A3x9AEAfQIUCRir+cjtvV9VqFRX3HCFhG9O70ZJ1AneinIEAAWM2R5webzvl7nZWvC7eXExwOpo9fnVdXImZcPTvxgCtBOoajennEjgcTlW2MjPwfKrf/Cf7h8EQnpscujZYADWs9dP58ky2Xho7jZbb6bxzTb2A6lkpumhgP+mhya0AtWGMMZD4ak6WRhyp46L4zE7DpGrfeKBbc9PswDoGrQD2BF7bfDEVfQB1YaNVszrg/TU58oct1oynRlnYpRsjABsOG/CVMH3WkHyRklbBEX7I/sOFLufNc2BgOcMPj8kAhJ1a/2BPw7LZR0lZXt7xYVDF3NrEYISpFpIuwJYU3QBb5n+PzohVbCj5vAXvh6tPsDi26VJMickJF5+u5aONAB94I/J4cUTAgaeCxdLd/ldzE/wKVGkoTSnMDlSB4XMAX3cKkydkoE1GHlJ5USZuYc+IY/Wm8ElOf9+quRmDkQBcOUS+XLihjdeLP5zxyMsjTDMG/OAS10Yt/Z60cHu5AFJ2qAJOLR9yFEGzfK1+rvi+HC5iswHQ6MGpuyRszngAH9XdvDReeIZKPqBixouq6IZoP0c67tr8JHI5qxg+IAC6D8NcCJ/pvf9jXV/6hTugMoQl2mJgqy2n555weQ5DAHvE/52Qj41Rxdjb8uMEjdk8GCub5zUr3Tk9XTJlwfkABim5Osy1jOHQ3hPXK6ASJ63+o/cElP14u06v8XwcogCCmXxlg1HAtPVVJ2gPW3NaXJnclXrVdBfdQ3tu4wivAKwjAftR52g6DpVysjTMRERD+G3aAY5ti2FL7nPn6bgAfI7sM0JgOgW0CyfXA0hCXcg9H/gM1yy53bkJ/S/ZxgBlIOkQPPEEqu6aRdvtjYDNg0Ebj+7cn8TA7Z/mxTkHAGukHsGnf12qIJzjNxrNXl8PT33zXU9179HzOGLrfJMAQ/IneWfMEdFwAB8J0dvWECDszUvZIPZFgu2epfib0gBjt2W1DxvyVAmBm1Ex3ZoQ8Z6zu8yhnKH3Xv8CAoJ/AEIh3s0lPtgn5ggikyUpcwvhScevFqNdttpUvMUVG+YAn+PaViNkxN5jmKVWXc2x4HpEYZyBZSxTU/zrwPk4yAAoFCNEW50fUUSLPZYirRiD/zk4rA3ieHkzu9dCPK2CAPbM/dNLvrJdIRBVN/0LEFbJmu5cQ7ObOKgesGK+kNkA3RadYGiS26Bw83wtpP5r8FFWupGv2RMnao0MqkuZrQDUdl2TiOtlQ5cbb7S66IcpTEhm+EnTlWjnnmKH+flXAA7yYlZGWWPn6W4bWCCD2PDU7lkI+jThbiA5U3M8DDEATND+S2Avk3fB7a1Pdgx7aey5UnX821P80BDH9rjPEACai+vLQ1DAlhyjGtkXX1FUBMYXeobUw2nItPXCufzbAGsoZbtlsCFbgSzTO6gxDzTdDV8hK4uDOkoV1qD99x0A2nbpBWR5lOf97EEqsbwzoAdrhscphRAwR3hlJub06ABpcBlqigCwxhvw92+8cZa3W8DPFVVEG2Iq6j2em+VTANC6uICQ9dpEGmQzUe672kHKNlVDd8dMtjIdXxoq1vAAtfVyIEKBSuTjRIzxSxR7jCHrJZdeEcFcaAdHOhI1XgAtnSn8rpBocJ0RBFkve1MOf05i6u6To5Y0EGDmL3ZJAHQC1nl2W6qLGi2jGHEPJp/NtuOhwiG4137aK9diKGcAQAroCGL1ZN+PrloXbGFSikfTTZ5MFVOKy6ekdFBGrACjeasYHal82dZwoK61wDi3IFNpf7NInGPKf0Fn5UFIACJO3qhqBAac4zn/l7qqOiyE01OIcv7xlLojIyHvkfMAFzkb4gDrPKQvsnNvUpZJ5UO/+g+rSJIx3FyGqINlswA4EEDkbMGlb+HbFi2kBmIbwchZnALjG4LYNVPGZ0n3AAfbRTBlUtCgCRQIvMDHK4v3QZXo0Pjwqytp2WAvLiYAx8qH+L57y47HKiIHVQaOx1mOS2M83XLLEi/m/qq36wCBg9F6acnKJcYZQUvwF8qy2uvvDv2KlhfyNqCbWXogAM4f05rl2en9/OUOdLMErOnAQthEvfO532ity9ErEl0AjgXxnNDn8x0yPR8a7inWkBSm3PBS8t8cZbHDyMGx0wDU6DIH8/mO5VgyP6/GX+yH8uK/kw9Krd7GOKx4cxQUAAn1emGOv+rrlOp+5KXNbe/35TEOE2gHM47f5Fn3GAoAKMljxKI9QR0qKTKoKmIN5OO2GT+ao1KyQGNielIWJQCxcWHZAQyXH3oHz11+Z6BkUtnjfPeCWGuLP8d49GVnADhQ4vaxbPRU80aqcCMkw14erowvEi+2uVbAMz7oMZMAYh7J0ubJdZZE/CXbmEk9JMTZxwQP8JrdqHcLH/aD1ADXq/2yot5Ub3tlRB98MbR6AzQCWhNkBRz0zk3Ax/orAFxCO3O/AHaSTFSgEyxUd2bCeBuzVVRFsgFlssQxM6wARvp/xRg48CUoMFDFXZYXo6Ppn7IS5KbdP6CITQuPCwB0C0J2jdsWvWuLnN2s4E2u97lgk2Mogx1FWiUzZGlBAGHnSRdkFErcsppsvdqOj5nOpns6qwkLp8GjwhKGVaAA5GW/3z1bzYhShJkAGAfrByiY4565zflTEjioTut/SAAszUJICjem8zq67DSVC3XW66jzMwrDgJijyPZczjNNAMm04L1dNk0C1pLjMAS76UWDtAzAOl3t9EJfwOx01w4A4PZ3w1I6wLf7Vnz815XOvJkI5LI6mFmqE1seYerS6QDojN5T/OphUzBMM9zcpLIoj0H9AnPNcs4+AoJcWWyRAKaIQdgrksrfCtaAllOyNF93rPmgrYQyxqHPZ9LDP/4AngbV80SN0raNFvRUuhma8fkpNfdogQbIQYUdT2wcYAC+e18i6rWHKrWh7YY1r9JCtlQMsTmm58Z3xShoGSJAALGTqwRbKPt49d4oq+1sCwkOn9a6g78qN48GWWdRg1YAg2tUESV5jeloTF6axb0u191MV/5r+59fKFI8ysT+7gC6NK4R9JibRJ7mOfUZfBEn3n0R73QshZLKFe26MTLeABBq4HvdE1qimKcURbl4QJh9pjtGigqcTzBFeYfYvqAASc8HnTvaqYYs0z+NEjLNr/aR0DwY6bXjaaTAhrWkNwCSCg3N8cvmMWY5in43yGW8pFUIT01uaYd2nqAHPJz5AITS3uow/KigjoFzsycY5oxyLLIZfXu0zJcxVdHMA4oACMOCjvoM8+dAo6I/sbGFjSIbj1wNcXAhO7BMBjM6GgAuv84Hr18YuEJTWhNfz/XpO3r0F8Jz93TDd6sh/OkIAHlvV1Agr9+ci0RgkX25/DE9dSpLcbe3W/AIjRWixEEAwFlXB2wjBQhJDdb9xVPxHuPAbW7iSFhzr01OtWkf5wB/B+xhZMtoR0+//6SaT0hP6buKN5nMm/qzSw/5YSltAIJtyTyFrmEUnjRooV+snsHXJBEe8GuIYxEgEQpFzNMAutx7qJ0t3QtiFwL+FoiICmtRX48FQLSZjHEmOiZ0uwD3qt6VxfuVuG2CxwBqNYkV32PQRIkTsSbQDPxPPVwcAMbA4O83I679r+u3Yl83iRZnr3OQ1dg3ah/kzuSv98kAvqIQ/G1srVqIw5FzXjOJFz9gpz6GE1dkxvvGMhpQBgABvAOXw78bnST/B/GnigvxoT++3Qvyc2fb5xSqekWSAMzHN5DYRXxbvOhkKnz7PSvvymiPHQrRrs9H3wWGZOUACiIbEgZfyROmcQWVbC4rWsvvX5kfHZqHKJjRQsYwJgB6xAD/Xl/jitPhSTmG0YnjSMxwoX4APuZ+bMlNWJDyADXPOMf80FfB9QTelKaqoKT4z7TDRyu0mJy9cq6j2d0A154uaPffI1+ANmpuPqNoGHbKx54DRaAMpywnjrsQ8gC4cp5g2GSEZ28A2B0Vbysr8zSrteeCiCVM4wN2FIYYAN1w3SadefSyv+wUYICNQ5e5GjAYp9cCz+rLtH4KSW0AI2q1E0GpIFnvyTGyQEc4d7aKh49D8r8rlcI/IqJVOQAyspCxJBZYgC1HYaJrD5+wZuvwJq30al4xZ+QWT+eFAGCdw8CfmaZ9KU+qjj3kdGcaOR87Q82rvZTedMJfXRwAUnv1UTHO0R8KekBMtTWJcFCT5BF5uRTxxYZvgRJf3QBUFS/U6pG/kt8FUhOOcCZxntrlBSzpHNe8hA8EknIuAMdHpXveGYsbyP5JpPJ1DI9c2LkII1uACmAzhEJcx30AJFbQWLBtOG1cmPDdZWE6im1gKbBQMFHzgSt+70+f9gC1ccps7f1inrffYkCJ006Wf/kqHqiZerlxM3Xcy7f5AKkYigtc+yKQ7ove4sDyi+WCip47QpUeU03dy0HUCMIABuqJ9FPfix/4B0XNIsQZ6Ix0VV0FUMDokyAZ8JrGkwBIG14XdrO/JRJ5tEq4Gg+pIKF/7zX4iCqzU1pKvI4wAAcms2WV7pug8tI1ZTwx9xjCZ6EVU2SQSLYY7Y4yRSYAgLXXrd8H2F+bmZY8NaHtzc4A1scLB6ml8+ZypEcwdwAUJ2Di84ZJj6nlJxpnAaVYwvfkE7eU6n+WwyPOq8AwALkAzJwu11qlxBCBANkcfJ5phpg5ZMSVOH55IkT8ERgA+3s5Jf0EzCCVUXJOfiiqNZJ1VFaDYzvFclymROGiAgA8sNyenJS358l+SBxIt4wAbRVItQn62a0cmqVtvgA5AN9IywlMSbVOmrK6YS9+/18FsgvLsEUXzrRQs1I14bgA7WwsEfzl+erFdAGfHowSjuU+Ea3soAxJhwhy8RcqAwD0sC7Q6k6YUOmCKJQXOAdzlpUj99u0sSWcVBC6GkR6AESUVF6cdEnN+Rv9ksFcKtBfaluNx8MoF2QygZ+GbaAAvaAapC9fso7eOkuOZdYchEGr9fxeXqXzqS3UzC9QXgBHFUi6bgtP9J/KdDTaH9Ke1KvF8dZpqF8eT9E1TdIvAOy271SAdG2RDZxbcENFSBUKsAsEzmNa2aHwshdGW04AM1QfKfSSYsd7Sdmn0tnL6qdXOKVqv81BT0JmLjDEMgD4nHmgPPCkxnw340XXm13SfWSRGEExnd23qywjuQ+FAB3zN5Ax9aKpaqDWrQxrg++IYS2UgrrNczavmVhmpVMA5xi0ill9NhlDSM9EXaDtjhuXlbPqeGPpZIz47j00MwD1axmoSjAY23w++PhqaqsBH1Vip36IEdYtqrsSdYLZAHJEZmzoKLmhabo02gnaxPrhczlFQEUu6zAjUduyPsIAD1fTOm4mT7MEG+4Od+dXBBUGeqxF2g6gRXBFjm7HbgDzOLY/Z6N7EAfCfSS/fsn1aejrr6Bggyd6QJo2ytrDAHCecIXjpXBdolEFHZI2q8H+TbxwBNOiPoTPuewXugAAC+Bv8SGMia3seBLow/reZbA4AcpXno3os7zsJraBMwDoh7654YviLlGzKIb7/CuoCWWh8YPGctLr2+Hl/UHEACJcNarMuOHyFrZUzOXp33fJ7xqAOSc7J+WODp+tglwAtnuMkT9zRNsmenAZ294WbdMgskI+3LBxGM1U2vG3egCiMxCIasnslxjtC1BwOcIU0GjajpG4L1MS69dnHTs/ALDMdeeg2zwkv8xsbiH2Ey1L6TJlfaT8xq5HvHtfrMwA0bLIgYmiGgunx1k5StG2JXZT/Lcb2SQUig4wKBKDUAB0b22tHiLrgrJUv4cIpwXs+/yQ1Qzur0vGjO8aFzaKAJSrz3VtnL6lHC/EXHjbxx/zZW9oH0TwYFS4Ou/g7NoAWQFZ7D4caQzYAqrK8Vp7ZGq1ZnIjvHHbBIRpO5GosACh8Fl7eNiMNEdD22bd1u1j0x716KpDbCY5TlR+ilzOAMFgBt9cUuV3VSiBqqk/icaVNFz7nOdK48NyFYcTmjgA42Z6V+VH4PQ+Nm2lzoZafcGuFaPi9nZJdHD/vsrJlgBx2ezjqKYt2h3b/HWnYFo49SWLkOkDNV8SJSMFPTCdAKCQmhuyjUmDdMFWplXbr5rpGiHkerk/SOuaIMEfVn0A14OlmU1b52mp0qIBSwgDtb5PBjXIPCFrXj4Nz469HADQDR68rto7TcWfzewIWBcaWnsv6BU2hFcaPSl84Qq1AHmP7p7Tet8y07/D29QYffYq/OFNrDpheGxjchZv+4cANaW0EbA2lu1YZlu0dQpmluSI3NV0cvN5YSNsoXxP+wCFUi9I7NF8TChFRko5rlW25DkctPCq3+wX8Z+booT6AKVkjtlaOLEqa5sTQ+QzDnt1hu0k1V7PTS2W1gX8WaMAw8ptRyEPX1jJnLFKuIG9U3UKgCNji4N05gYoGJqvQADDGhiaqLWDW/MdoCL4Qnp85YScB4FvbdfIu2B4NtsSALnT6c0SsP9rKhBdJMEubhHUT/IeSMGLhjXbi/jadUYAcHgDsVWc5LoOC5dxH6KaFLiI2amE2XlxTxvuxJjGxwAFjCk8Ri9zNZFz8wZ7lfx4nOEvHoNILKRLQ0eGijCkAJYD+8VoMSU66LNZwmbxq4qQdWuqLzOWKuUguF9qyNgAc1JOJH9SRBTqlt7A5R16CrIRFtu3JIPFTNSjTI+/TAAY0qKKGHCMPfwQEntARH8nrWYE7ox+IjMvJ3gFT7aYAKSzD9k1pkS1SRDa9oh3XzGAbCFfXx510us3cw+c910AoSZU18iumcOexVtAaSuUIzxK1s4k84w64c63xeji9gDktaszx4M+ULtgSo2Fnjzp12IAfTMooo+tzY8BXua4AE+NLzAMLzx1W7lCWweO7Nist/0zCrozpxHHJa5BgysA9hHuupg3ln228ko+jZSmHWQmDQACtRiPFKeDil7LMAB/0zMGAfOU6ul8dGIrKpKFWt9p2GFEDlekXoK5jqt7AM91/i+nRs4KtOqDqI1oJuNFsuA2kLslXiCY5rY10ngA7y48Phw6a2VlKkxfWLoddY85Ke450Px5X6rndP8fVQDwdTdmaoW1mwprqYhthQYHTytbg4XplBf0TfGAut/wAGlSCFcKDngTvKXbat4WHXqCtUMnCOCcXI5D1UTDPRAA9BdpCN2V/900s9VqKNQwdiG9uR3RdGIyejpZ3YytCADNJQepK1YV9pfsfj1cFAWn82pGEecWNaIVNQ1IQeWlANac8NCMOBD/PfT5M9rqfJnbTC46sLM3T+oJ4LWEXBYAloyysXmY8Wy3HozYprKMvxLYYUC9LKgtHZKUD7X5aABjLGHUqNgU6KFpoC+RN7/d9g11BTpLlT1V+KZ1RWTfACNYcjPXLttYwIoZEzAGYljm52KVx+jfNlOhE9JfcEUAABzMwaSDnQve3mPQQc9qP+Dwy0IBZoFbOG/a0lf6RQBit0JyT3PU6B9ryilT/jrv3tthv7jK9/Dl99dHjWZ2APXTA2IK4JCYIXzgMEPcXwCWSx7I1IWnBaY88g0IHZMA1i7IZG7XLnvXedCy5hfxm8KO8FJxTRU7NF/zie1P3wBupOZNjyQ1HpEJsNF5U6iwgK2S03qzdZ9kKGXAWNpSAAs9TFpy7Btsy8zMJwBcvL1yi02ZIbbCKnomBDnDxxkA6uK72pWMstPiL+f/p546QO2RlwklYnQejEFrxOhjQQDGqnD5orLYCyzrpoyU2boqdz9Snw4wnwlTuRMDcAxzAMacx022cwdTEwiAcsnK/szGi48GQa3RB0+CqiwYG/MARswqbBShk8eAVvbCvSDdHmxhmwkGXxpSK6etO83owgBbKjaKhJkr9eV2TVt5ZMgNxyDEOEuaa0apOlUbL6ybAJ+NDEiJi1rO+ysnANk9Nd4BFxRftzV5IwHdL+mH3XIABoP59cv90YL1cZJ36CEITaPTbVMgZjb9at4IymceTgDfp03xJvRXd8zOZrqfHcvM8tqZLFUWH5XFIfdEf3JpAHF/JGGUKSmfsg5K6E+awdw6RSzeMvVDcwSoQQSDOxoAzQUvbmsCinOWH3jkzZ8XaXZD5+m/G197TSHYql7I+ABJbYIh18TxRolly0rLgcKGuYpcCWG6fPc/DFbKa4TRACXQMSoJXKl9ah60O4FOi+qqAm77QiMq4oPo03rmA9wADL1te/JCwUqHdLpZjwbGXX9VP6R8rO1O1VaC6o4F0AATNIDA/h+q5wt+eDFrQTe5yBcIpohKrbvb6fLiUcr/AInY+b3TwA2Zlykf3jdg7zFkAdaE3zDAEiUqadO5fh8AowzUto6QtAXtyl6XE9AdlbXxy9SV1ioVgFES3gEp3gDdEQyipx3z5gO5bfCMaRm/4AFTv4R19NwW/EKw5MjcACL/FmUPXStoPFsREnj6I9VQ3rfXSanBprgioR/axkIABIBd1Yt/H1P76SYwfKw48nismlGVJIWw2Dpy8JvfbgD71r1Z08X5oduO8I72pr6S+GfZqL24c6s272s7puFiAHux9twbZmpIXes8muq9sDZBVImV9pEydYEg4CYgDIcAFnh7Tx2uL/YNjE/clyTOpjahjjKcWlJv5YrqfZpyZwCRioybtRRSjxeFuh76neAY7WSKWn8JEAE0WZYRsDM5AOsLSENi5Um8XNc4h2p57tJhmIZIvpbIFxVXLflfQpIAS5jgc7PwIcpYFNSe96QqiXWc1eckbpEmJKEnA+xgxgCINjln8tzXiFINNW008FK6nFHOHdV5UGg9qdOBi9PLAARiwg0Ol3I8I8DKvSnWpPH1PCxctrnZE5nFe5CycwEACPRbik8fDiUhWnywuH2E/XKc5vXW01sm03gX8264JgDLch15O2josekSRsHn99XN1AlAYwuwStzsIORnBaP1AM15fG6yRUPbQpJ63a0cvJYdTaScYd/PvIryGQD6j1QAPT/MKzXla1uW8k8VpQDwmtO/Se+ADWJN1CBdK0R9aAAF4cWagSsuaxK/IhDMekg53Zsog+FF8NN7F43ht67LAMifdxtCzeDJOS6ZPNlN+SxQT3CGl0LTed58IK3sBGoApyK2fzMYzrS6Fh6vJOsoB3fezSXcaW5Hu+mVnTbfWAB7PBRRk8LLjQAT3/C2Du2jtvbT2OUN5H3res1Uk4kFAPuogWaWRtrYxFRmumov94AabKt5wTp24HLQkUiPycIAq3z1Tb/ZtlDT7f/IQnMx1Te1bKDJkQvsbV1mlBgqawAcdJJCQpavNXBvP+wNKHPjwAR3dfC+j1/zBoQUPAmxAMhHeVB3yWYJggDDL2P+5ZxeQxuYR5s+vicamKme0eYAwgssIY7zWsVgPX6Yg2ISGTnXqbfHpZuum2rW13+svAC70lAWEpscYXo/3dpmKKMEMlX9JBnTN1ayMOwPxv80AFZnWg9/lGK4qJ9zyJc+mYUuAZZWLaZUiLO6gs/HbsMATgcm8r4iGaJR/MpqRDaZ5VVT0j3RtvdklD4oHAWbSQCQGtQwv/6zhTk1yMHdLXQ+5qpRX+5BhfU3efOnRS1qAHVWitehrLTPlSkDAV2kXl5+ZSP/H9Hr4X9xDVUBZzYA60FkNk7EHzDeIb7tk0SlE0OEMXLO+H7O+A4Fme2sewDKKb/X80Sqt0PRTU2ImFyUWpit4W2rw1viwMmoblB4AA1La7Y0Mumt4DZbs5WE3xZpISjHsyRDDWpGebq8nFcAZpVXPTSxA2VUczgBjQkKfQlEqUErE4c6gioT4GlWnwBFbgaOxkXuK+L8m26meJTVYKIKgQdIyg+jIoMd6jQVAHQnezuN56h6/ZQlodnkQ1VoER1oc2VXHBMTTj1ZkQYAnLUnUUHKo4c/fHncZ+v6yE8p7im8yHB/H7RPnipFtgCJqqnRg3QTgH7FmB5dDvdp6Wz7tOXxYQDKxkgGA8bqABz5GIIZ8MgMWQFwre4LH3B40FZvdNfiLoWTCUr+eyUA+ivPinNdtex/KBq7bqS2uHk6Btw8ohXgPWfIH8yEVgDYJsJD3KBQGWbPH+J6RyE361lzC1XGFexbudPUTH6WABqYD6Yc6dPk4Z3B/6NPnyD1Y0F9+V6cz6NxffjiinYACb8+xfqxjk50c90PiFfQUrJAZ7iRs+Uw0Ow3GRmJ/QApqNm+IMt0mpUfSNAQe+8kEfngccrteJ8tlXXQA5EfAPLeoLSmdNiBNG46oKX4IgNRt4wdEtbaGqjCAEnyR8IAz9nS3QN3ceSqWXHGd8eCHIoh3dXyc43sSvGuel+4EwBLQiYqFvDLZA0hn+T3qhD8Xgbq4rC6ZT0H3HQWVvvZAJcpWPHkZc1r5FH+JcGInDkCQfA76Z7tdgzkbOA9wp4A+7rSPiG2O+j/BJCemH4Wwd8rte8sv4JzfDEGvr4o+QCX4qzrskY2cVZWrp/w7qnk/8d31fB8m6JfSfhlKvdiABPwfiFafZWOF4F0/+qCHdqKTIMtSzHuP+PYPpcHHcwAwCwqo4I3y6IzcwUrMedCgqy9GhtxgymYETpeUwVUXQC4LC+hvOlYBGl/a2bDCzXSan5N8WOAY3TYGBLD+RPuAF8za3cu2RRCuMJzVuwfKLbN3ViT9TQlSLZzAsBgJugA7HEAyzLZxaATR1QbqSY/djg83d9nfzTq0j/C8WghpgD0qYQWEChd1g6dtFa321Xl///3P1EBvINTeT9RFhiIABJUBvaCZQp9oUKnCBQBTCxI8sm3OSlvPM1ZMeKXQb8ABcf16nYJo8dqSVSIsLuyLzAk20EdFmNhrbMUHkmeegBF9HpE6AmTlAKw/cDvF3upK0IkuPgvmrwe8VpNYUqJAO+bFRumxs3B01PpcEkBQ8IHIX/modgAKfTxqcYg5voAdMk36X0qADnhVDXDaq3PTcVIjZuBRCUxaPO6W6hMZADSsDhcrnZfzpBuVhop3lV65ac83bYa91UHDNEoBXaYADaOUHDzjj/839YsrFBAL8r4zsmV2ben3TnQGfLrB3sAi5DqsIZBzD2nfMXOacX1BiajE+y6IUa9O82wpgBoyABC9KnktTV6UGvurjdluYVEj7Gr62/RferO6RXSpdHrAPtDXGjhb7UKSvN94UHT1QRIWma6QlHk2YDr7Y0zE5wA6fEtnUFg3eFijYBYy1ZCiMluTVRffqqSaJh7JQV0GwAyp5cMhqQTzMo6koDTZ5/BQUnOnFrvfR85MMsgnytIAAaKOpP/6c6NQJCtX4hL3ocpGdVBJ5DmD5ED0Oia7oIAB+tUTHEQc1UUntc/7spNX8gMkvr/c9XkZe/ifm4X+wDoW+ekCS2Zs76hPoe7jkTuGuxO3629Jn8cZUAeH90FAFjiqjUmFSu4UPzEkEhrzMgYjnuK2x7tRxIMV8UGrgAAfjt9Jeul84bJMd8IOdnKzz/GOis0hn6Yye4rBOpxVAAd7YhBMSCfii+2tgdoZrURNW52NcsH1R1P8d0f8mH9ABUtMmykxD0jOaCY8rTcqjo+34zpqmuox7Rg1wRb2fcAmGxEaV1odZvfPFXwdYGRxIGx435sSdPgbh+c2hdthwDL+hJ2RTqUWACSOEi4E5Dt8pFlIepc63hNGQycSFmhAGLgf7S01gM+s0OljCp+vUqjWftAg/RKdsN33zn3KgcAjnPXpZXSRgCkY1o4ZQsvBc1ZEExmbDC0Avi3DRqw1QAHHicks7sqEXSVh/qwxnRixEHEkkjQGpK78j+DKoN/AC6ElWelnuF0pKCfTMtf46cvpG2yzv97SHCW3ln0aN4AcXSKmBmHsOdPVrrqdYalraVRLznrii+aGmrG5y/9kADZ6L6wKb7rw7k1xfbzV5wUcuJSSdg/neVVSV6VhRXkAE2IzjDr7vR1XXUTd4NU9KtxsubHTchXd12lsHySLj8AcFFYRz7mMbbN1LOp8kfp/OJCO/HCK2RDeoa7xqzMlwAtNUHC3BgPmOvhrfWorMilqk0zMqGxxVEE4GGu3E6KAOybDd6I0jOEt3qQSVpFM5OnmsBnCma3SK3LVk38c9oAJjYGWHl9GWPOR8S+28zCY4xVstugRQ00Tpf7LEXVlACNkV6OeCzAo/7GaW5l6IC77dmubUUER7a1TfK5Rl2FAIX2Hv3GVqD44QiEvNhsUe1I1hBi32yY/vcdCjeSMuAAjej98GhmQrGVBcLAF8ePhJQ6dHmlVqQQEzBQ9/X/UwCMXFgfCns29axlakdUSDVcMhnEXBURB9X0cEJebi/dAGzsJomLWqxlmcSo40LGVZbqxP0DI+JYClruQC93a5YArSC15stwbrXOObeWvbZtGFX4ACK2CYEeu3ngFGptfgAQhgWFOXrz2qy8kh0jgjMm6M/xjYGkVcFmkw0wccHqANIhsutfhJnnOMrOd1PkmjVGfWTRllUUNdDLBFGj2S0AMcPsQeKDP69abpbdJ8+dlIY71p1UUmvnjEv410vcLgCJN+O4TmCVfZA3/7vAhvNWACrVuovTYhKd/TfFI5CPAFErDjmZpA61uS7SdFQWVycjtxeNfYNPsxMfF6ONwRsAnXV0sf+9RmYSs5M61h+acA7a5vEymNoDNrhVylvoUABM1tTFha7LkXfXMWLGF6F0SOh70Aj1T0srjnlQ79TXAIerfBiyykqH6ZtcYzf+E7LIIVdlRASmhRMOO/ngNZUAfpH6CwBeu9gjrWpy6nXs9UpXsf8/M++hA8ntXAmR1ACFrfpc2kfeLm5wq/PbsW8qD9V66wUfq0eEkSrd2kIH", + "commitment": "0xb47a63ea0b1ca02698cf24a2880d2ec8258919a455f0dabf0441e2fb5b0309198615462ff913ea0e5604ac936fbd6be9", + "kzgProofContract": "0x8e7e168dda22dacfb305143e91a6244e7712a70ae5b7e4311dfcb612fd04f2f505f31322e3573cea62d73fbfcfe3a3a4", + "kzgProofSidecar": "0xab1b3b551d211307161b24b32564e95d39d8ca5251d6e5fdf8b1f5d2bd0e4603c9220609a29fd08ee6c58bdf6bc801d3", + "expectedX": "0x5a51257dad1a359b716a50531ba000ab6c3d62c726982b8425f991d86448ff84", + "expectedY": "0x07d51da36ead59d6630496896e8c27dbceaebd9e3040fabcbef45dd8ccfed4d7", + "snarkHash": "0x00fbe54d5c6efe4be9105e7ae971534295bc3871e4814570f5994d2afa56ae40", + "conflationOrder": { + "startingBlockNumber": 1, + "upperBoundaries": [ + 12, + 23, + 29, + 37, + 46 + ] + }, + "parentStateRootHash": "0x072ead6777750dc20232d1cee8dc9a395c2d350df4bbaa5096c6f59b214dcecd", + "finalStateRootHash": "0xea09456033a79b5f8b369a95cce74d3dbe34fdd6415bff1a417ff8a8fa0cffd3", + "parentDataHash": "0x0000000000000000000000000000000000000000000000000000000000000000", + "expectedShnarf": "0x4e584b910dc758442e58e56e0bb46c001addaffe770fb740ea0e1b90c0e2b056", + "prevShnarf": "0x47452a1b9ebadfe02bdd02f580fa1eba17680d57eec968a591644d05d78ee84f" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-115-155.json b/contracts/scripts/testEIP4844/SixInOne/blocks-115-155.json index 9683340c2..243e5ca32 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-115-155.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-115-155.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088","compressedData":"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","commitment":"0x916eec571ec2d935cd92b474ba45eb88c7313af7a1779970db3d1092802cbb1c5507357fed5838b0930882c9573b016f","kzgProofContract":"0x8693a007abc0467d3f4d4fe82526a121fb01748570623242afbf7e90e69db21a50dee2e9308f822657e4f37c1e0c903e","kzgProofSidecar":"0x80aefcd89424e0988e488aedf93cf75fcd1736e2cb8763fc88fb8545710d8cd23840c8c600a98e4ed0662934c739814f","expectedX":"0x4eed403300100175e38dab1b26fe0e9f4b490e8f7bf4481d39885a43f892413f","expectedY":"0x5352a0f677dbf40821705d3a5136a5c4b7081722e0b095ab15198a5bc319c9c7","snarkHash":"0x1285f290abca68475d3404338209480dd1b88b39a46757946be551a6a44c2e79","conflationOrder":{"startingBlockNumber":115,"upperBoundaries":[120,130,141,152,155]},"parentStateRootHash":"0xc09cb8054d47366fbdcc9284f19d41a9485fbd9678d18e3c612863bcbbb4aab4","finalStateRootHash":"0xb1b5db9cb0b7f7bced42b581ab17add6aea116877c248c0d667b8b50b37c0fe8","parentDataHash":"0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487","expectedShnarf":"0x0bd15313e98042703711abde5e99817b48733ef047beba4e1f90d237a325138b","prevShnarf":"0x91f7a22e718c16e213fd6d5de1fe25c402e9a2bd5c17a8b687719e8f2809391e"} +{ + "eip4844Enabled": true, + "dataHash": "0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088", + "compressedData": "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", + "commitment": "0x916eec571ec2d935cd92b474ba45eb88c7313af7a1779970db3d1092802cbb1c5507357fed5838b0930882c9573b016f", + "kzgProofContract": "0x82624a30d3b43cc7058f180b0c0fd37f8d9ef85777054d650c54e251d5426402e7ab9e0edf29e3b03f9ce45986b1c7ea", + "kzgProofSidecar": "0x80aefcd89424e0988e488aedf93cf75fcd1736e2cb8763fc88fb8545710d8cd23840c8c600a98e4ed0662934c739814f", + "expectedX": "0xf0aef465f0939dbe76949b676a2f8ed65b5f7474675b94c7c86d741624a3337c", + "expectedY": "0x17fcc41b9d1c9b3c0b990b9cb47965309c4ce4cfffbc0196cae9a93c0f5e695a", + "snarkHash": "0x02aaac2984c49545c59ecdc8abcb2b853e852a5fe2fe7d661dfe44e7f5fe4557", + "conflationOrder": { + "startingBlockNumber": 115, + "upperBoundaries": [ + 120, + 130, + 141, + 152, + 155 + ] + }, + "parentStateRootHash": "0xc09cb8054d47366fbdcc9284f19d41a9485fbd9678d18e3c612863bcbbb4aab4", + "finalStateRootHash": "0xb1b5db9cb0b7f7bced42b581ab17add6aea116877c248c0d667b8b50b37c0fe8", + "parentDataHash": "0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487", + "expectedShnarf": "0x602c8eeedd7f6dbb7bc0348da1b0dced846acf09586c9f27aa06b494a1c49249", + "prevShnarf": "0x713ee848a009c425ce9721ad48f67720f9ea3831a5f9c08bc7a2a7a0740f5709" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-156-175.json b/contracts/scripts/testEIP4844/SixInOne/blocks-156-175.json index b9737bb11..6103d9ba8 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-156-175.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-156-175.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1","compressedData":"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","commitment":"0xad87bd0b911d6419a254449046e0507f2cabbeef574a95302dea08974cb3571eb6c67523ba993249b185f99a44cb8007","kzgProofContract":"0x88af28228a6393c65e00dea7c0bca83147aad98c963eedcc3f3a1c673a14818db8a1e2fec0924e96e3e5cbecd3a1954a","kzgProofSidecar":"0xae9397b1f0798af0278e9e10d890ccfc582baaa0b6c217ccd3a49338dacb8da4d3f9ed5959045b841c3cc1fd911bef2b","expectedX":"0xaf691cb73402a7c4f659babb088d1071065a3aa4470a04edb48d94e6f2e698b0","expectedY":"0x4b4242cb36c3915c9f9b9cbe8c1f943af9249fd7ca067032533054b6de7de976","snarkHash":"0x1215c57975dceacbdb303a04241996a7c9d2e7387cb893a8e55604a7e38739c9","conflationOrder":{"startingBlockNumber":156,"upperBoundaries":[159,163,166,168,175]},"parentStateRootHash":"0xb1b5db9cb0b7f7bced42b581ab17add6aea116877c248c0d667b8b50b37c0fe8","finalStateRootHash":"0x5cefbda4945c119c2fcb81180a9aff47ae3e557d35f6fd5ed541f334e61d080f","parentDataHash":"0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088","expectedShnarf":"0x315452c8980e31730f580abe9ab2312f67193dc72d1cc00685da6a892373f6f2","prevShnarf":"0x0bd15313e98042703711abde5e99817b48733ef047beba4e1f90d237a325138b"} +{ + "eip4844Enabled": true, + "dataHash": "0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1", + "compressedData": "ABG/PdKO646VG+NX31wi1N4lAKxh7LBNqSlxxxtVWFwASb+cUbKNZSBiuuf7SZ/t1ws4oVeQPVNa+FdMGspyLQAt+nOPN8XIXLgJhjvTqiKwzs5e98eI++Cr0U0n7FTpANSbjyUdtsQ8bZXyQAojDAM2pfcU4A8d2Z3smSoGpaEAAd55LaU+frjztWfPYJ3D5DseK4H8S5i2qLynSndMjgAT/KSgE1+P7RcHuoodUGY01NHhJM6eL83artKWGaA9AEQy1EfulswG25DSlx3Nidj2PIPTBCn8FBRr+vPcKgMAs60zhSJYvvCU2qp57OsQJiOD9L2o0rPml5F2aKsZvgDtbaLp34Sg5RQeJDJ2PJfHHBcyyrrhc6XDUmUYjJw6ANff5U6gecKZjQoIZjwULL/E+hv60vStW2oYJv/8DDwARKm9c5jUhy4CrXTiVvF2orEswfqxufUyuNDD5REP6gC2RULo76BBQk1HISZmla4mRbx9ZLTgPbemLTMb9t+VAOsGqUoYEZg0New3y4iJQsfdU5cwH35djePnI9aL38gAzPhwUQmtXMlKqc330Dr8suTdxHV5R+IEk42QxTCamQCFmedmG2ONu7B8B0qmdtYtWzqCmRpYuNhQuBRjoIx4APA9OZgobk9S4V9rtpb+UUpnyDA4UtKrO/P+fY8L+1cAFXKne64uFnjzwAQr50vcwAADTaSR3FHJZjDi2qOkzQDMy8wO1FM71GjVYsq7pZ5ZpxZuALDgu+1t/kbN1mCgAMV4LPTZRATSwYInvN9IPOH2aHcdstKam9hZNN8ug6sAnb8aTkjGXkSUloA5vMcvr8z2dYjz6Tx10DUfSKt1awBFiDlR0Se6vPyTXqrFxl7jYiYI7mez7VpwORtOG8mXAGr31rFsdsqMz+jklIwMGKBMfMFhmT1XnJ8Kt68K+HEAsxy2wWe15eGaGIgV8Py6fyrChRy2xb5ayYWLfxeNDAAO0lT3qdttrFJWWSiGHIi4Y4EExQ0emLWWpCRzvHmeAEeSKhL7nspx7hi4FXjo8XFUmURF2flvrUD6qd65T1MAS6OOMdtZTGOPJM0Fk4f/FXM30zZhzcXA7Lf37A35awCTWXrC41OXjyrz/BPHBMJ2DYVkW1zcXtRbG8SW5VyQAPhE9bVeKG70e7Ld9qKv0OB1bc1bsKhKbukHCLG3/M8AvrX0vsv947oSzBpakDFGkYp1vGWCNWl3xypgaMH4YgCqH5A4JSBCA5Jpi8h+kSAmqhsuuZbCnkOajxLGvKIKAGa4jlC11RL6qG7+H1Wd/DcyMAPtf0s2J49j/SuSGSMAdEgP0rtEstxS+amyR2XESeu+pLjTTARUc30FHILXeACwouj/CXitnv6ZriZUYn7W4MZGTBZhVp13T0lqpxIuAHK5ajpv7upk0KGtvpmQrT5QRod+F4boVOn9PDfTGV0AsZ38QspugyWyunFk99QUOrOGLQGeC8cIWgnAsM325QAJ1NFkdJdyHvZqatmxvlOrx37angB2LzarUtAnVYiPAA5vhTUcZSjvDaAioL+r+dsWzYm+6aaICylbofRkYxcAR9g8Qf/IiQS70xrg0oVSxB+ouJ+KFDzkRXaKS6vBEgBrBU3gW8xzJdBKCHieWE5xEzbhFLcVeuINaEELC2opAJI67X3Xug1wFoQ9+f96GlEI+wTmTjjv4RnLo+vCm/IATujBPCc5v+sH7XDMN6WhoNR0Fi51WTQ62YBO9P9cgwCwJcLpkLxYjpP6vhpaLwaUqXQZwfJdeDtZwyYgllUZAFmN6T+jSn0cYXVPI95pWVrwgkj6u2UYsO/RaGUhBfgAI+tVnm8fiYN2TCsGQ6rjLr8pTGvpstQ6sgCjPhWSJQBb3c3S3RybQbscId9kT0nHOV9b6W8SEMY1NrtRNv2CAL6VaM83x+qAYjdpJwbHaXzY5L/29gttvktAioaGPo0ATZfy2TYoObYo2cVYIA9Ouj3gN5IiY+fP2Rweh6n/HwBZZEk+hK38yr9bppNBh7cpRwO34iy4w89DJd1msrf3AMuZPuMugtrke+aorkCJT4uiykijMEvKcAg+PJ/i6JcAWAieoA8mKaCzL03RcPeGr1gSPOOd70QrqYYj6GYZfACUYo6dW8dvqhRtSst32ZcMe1G7dMe0gfjVlluJxd0QAD3THIR3Xm5WkllGrH2qUMCulg6Y1tWYgpyVztHKh8kAI2wAaInYGHjCECQG8W+e+6VkfvYmQywVEKDH0SaYKgB/6u0ohHhsKtRcJKfDP/nZluwDQO7AC68XjTM7Z/Q1AMAecmCHo8UZ+OlSO3EBTa3xPE4m56pdB8Ga5XZUoEoAW2ow5cj3vXm3kGkPr77XICRKFizCw4dnKr9RTVoD+wAqEdL+s98SAEtI6Y5yYE1B7zWyBs3A92VxWG4zuyjgAITZjo3EDxUyoIIVZXY9nyW9hafF2Im9yvzB3HeKhokAay+gyqNBSQoTZPPpp0ViQXa8mJBqru2gA6gTBTiLMwBFXH3c2v4sQjqRzy3eHTZII4Uwu+9dE96QGaiqqDEEAKrlIJqwhiBN8rlmubdMkKeTtsK0DotMdiamr9Dh2ZgA8CGwkvLI6AQd46WEBGKHDn5gwbbSt1ztvOVFPzq/awC1qdsAM8b1HGR5kdSNiHmBhKBEEIcKJSnyqfXcINdjAASpf3h38kIXGzKyo284UWA/a8v5XkMI9EQUqnEBjokAS2IcVmJNSqQeVTFXTvk2lzr6NWjsSMSyobiCJeWNggCRAx+zJvI0D/QKb4xre/qGr240MD1+jF4mF0bEwuiKACIR0acDEdrIjaRxrPJUShjnojUeRPcmV21joLxnI0MAT8cd3jq3LML0XZNivpRXIj/duxf799crrKMyoFwIbgBFsmGmaWZsibKwU39UTsMAV3AZRn/iFthmtTHO9PBOAAABzCgvMVwILwaXYsIH8lTL3RY2AjQjno7N9JPftAMA1jUjvRKZR6yAZgza00BYYAZFqp8pauP3g9uZBwx3tgCGD+QyyD1/t+Ooj7Nwss1lzKejfWFOMrD/rXtdRZfeAGh4vSig6KFyr/b0AOOWIAmL2WUghaLTD0iy9WMm3SIALGKNn69WTwrMAzHy9SBOuqPbchN5/14wRFtikKFSFgBAOrZkcivtHKqk/t165kYGzIF1hzM9bxSMOSjuOy2tAGZHAWwlGpEp6IMX8erTwKgfLFF8AB1a33o+WGu+/zMA/io1xfPWtu2narwzF3aeGOK5HH9c3RWOrPiLnFWWqgDL3iLAJ1R0JdHX700Jc55v1cvVNfkSAcUeHgQdDHG1ADI+4PpPGpulOC9w7rOfklut/j5cYAyZUaEVYFJ5NNAAzcKYqy12zitUKNR1t7po1yB/gVGdxpc3oHQm+2/+MQD50UTSno159402Wht2eQz1YI8gaIKhIgamb7gHnCdWAHJgh5szIII8mEuuD9oHnS/lPfrsHGTpmsgB6y9IT3QAzDmlByjNDEBXjcPTzfRHKCFs9w4ZClynoVQpvsOFMwBhxymD9/KRsfj/GIPLSb5Mz6ld+GjM4POj80BPtyDLAHrU0XnuSQ7oSusjWXK+Sn8mAzdGyKuAt9QT9BIuSl4ATieEA4vlfuZVwQCIfgbxRFYM0a6+EPDYyXfdigqoVwDE3BHWOAyty1UbV/pPpykwfv8OblGHeymiBt7rJv87ABOYDDP37CESC7kXUw2sGxGkxadI7ONMsuTeAc2/9IwAmE8eRYd7OlxYCkA3eXFgAJ9z3yaKYAjUYRx8VGqSLgBTEeY7mPtWQmCbBMHvNvy5U8ECWq3fWcS9HRYOlruOAA3zJEVfyfmQhEG2u1agMrG0PIiOz8+XHz1c6+irrSsAiBxHmUfXhVuWCfwJDZsMgjOGNN4mmaO1HkCg1hzNzACQiDYafdyGCPliXQTVv7DroekrTaadMs1jYzFEJP7JAH/PRFlMU6Y08aPDzSP0A85oaAB1Imn8RuLYyyaVncQAtdHKy8eYpkJewrr737cPowUPawT+PPahfmvNJB2o9gBnEDksKghlJ/gy2LS9P0zTSQZU1pLhcK2r3oEOi5LiADO09w6CWPVxpvjOjQpB7fhHSKCJYlaUXwE7RSLiq/IABsAdLXJRKiDs5xHLRJsjCEWxcacXZ2c3JPNHEZz62AAljIta+UKAABlBux9Iupe9IflmfB2l5qvJR8K5deN0AP+Lh+TN0PLeFAdaAfWHYLhwEwroPdYArv+Oukea/5gA63q0hwvbwxSIKBIbpxPHg72WpMgLuDfOm2OrQBWEpADIx0aTJ5kG5rpeb4Ex5X67KMRVTFs0iuBE86Q7iFkLAJ0hiWI3p/K4P/jy0Cueu5CR6WtJA/GfzDdwGxZiqnkAqbim8jySGWipWs40nnJUDi+Bz0tbp1AxuH6EbzB0SACs6LghNF10AhCp9PNN5Hcb0GA8kWlDRGtRpWY3wGwCAMG6PEkE4ElDx3mN5jiaa55lBdcoaad8QaYDraXtA8AAdmEfXPAPNHOwYmOJilVOgqZvtr21YuYz9G7+DEL9agB/A9MNZvGdor+UwS/2J76hKumdGEZvE05cruj+pKvPAMI+zHhwuJbd5FhiKWSwIhuyiGYO17V9f0/goM6AH+sAH/AdS/Ss58XwCPnAj/9oLFMni9UKe48UOutnLaFOBQAE/g4jiKYGBciSYpVRAJ8wASv/wjr3m40UVq8LuvZ2ADd8V12ICTfc9XZfEE+lTNTupnX8beRkE+AHPftvf4kAtylkDR0fOmzxcE8CAbO2Fm+PZ32uyqZiFANWmbH39ABp0Uln4vOwIA1to3eIeuX9ptqtpQSgW1H8qFMumgbxAKHtak/9BHU5MIqMKr01pghClVTSDgDM9L+XDj/teKgAwItJGCKrqNP4Bf0r3bHBcKNPbigINNQ7yUtr9RlaUgA5G/IVDgaRGXG/dZZRVt9/Lju+IBP3xhtmywUDJ5vgAKwoHFJe3p99RE0QTACyna7nOjkdh5V+F86UK4wPpqkAD+LMOtkAP+WkxHrky2JJiJBHAtHWxHIdujnPh5rifwBj/ElsM5bxhxAGfkKYGkp26ka+59ycn+PmbwheIORcAI2k7PWj/kD7zMDIzaG5Iffa3zlgmlKIhmqRTxaNXbsASE3cgbFwWH9p12gOHoRSQJcOzlhiDPST0LMk15jJMgBklxn8PqYc8FZENRovamNevLPS1XkYvVGntUDv3b+zAP7+bfkhpFIC1VMozOCVI8pARuT3LQIgtCFAz7fVaogATpg9Ax6yKrg7dBaQji3lxsXJpx+PFkMODF87lB9u7wCuZM3z9QRo2DE63bszTCnU9gQybE2/91INfsjS9dBGACmJFPkBWQ7JrFBC5A1y2tn1lUMRK84m6K5ys3utol4AdgjyJ3cXtkmE0B6JLcI2d2m4+rJ9X06CvaiRWj6qJgCTvzgpQTbHiyGJQuQgA737cw77EOKkuVxe8E5WzyTvAEQ20SW4b9M35FfHZ/dCzPnJVMhb3iHhpVobpU0acK0A+3z3pF8lAuBLO+CwANJmh36QmnQXS7l8/drcbpAMEAD1qOLqOCnC0Yyo6w1gaAxkRZ4RgKBmtOEpcwQ9mVlqAOQ3tmRCOLZhiAc3DB/3m1UYce92kJ/4FO+eXuwo3vUAmUzVTQCr3He6lxMlYUvhkQSMAWlua4ScSv8jD32fqQDFYJhi4o+luVmBv9SU/1HfkyBGh0d3f5OkLmaZqcjuAODP+nAPlFNC3B9LXxQiaHUfBD0MJyC95zoJYYP806MApynJCbaoO+68UiRT8vWdydEpiO/AsAxtmCOeoYEZZACP4wNxQv8MmLARVCSU/RC31KzZs7ssS8EY9Pb0uq4EAByI9W0qsKsTMxMtQjFn8NDiOgFMy+mEC9/c3QG+vMIAL68GilKGpKpXeI4gmptgnIk6ZmrxDj38g/h/0RKcTwAn7/Ug8/jgcbVD63Zfy9hZVVCZEpAB3DBIdQnWCWLAADHDLf45E2x8BRcETy6kfDynroKtZwDhBql85g0crbkAJ1De1VqEPE0rvAk1BC+cTrCT1umEMDWdIW4stWYphgAuGzBAKxU+RkwPJSnHkq2ZJvkfewbdImQNh78wMv6IAC1xoJPksBTUKXwCRhA1lxLLmkBhZVTh4w5wCjQvl/cA9TV0tdF5zpjTrgFWQQ9XJwXAci5+42WN1d7OqV22eADkoaMdn/pqerLzSxb99HCEC3F5t8Rsiq0akszeUz11AHTIzxT2wYd68wKDbn1nCp22UoXUVy3bEL4Og8ATY8oAXCGX5Cf2/vC9Ru+6mFqmDVhvU+chOgurzvutP3cFcQAT94H0YeMFMIEDXfqD66AO53w+eJYyPtuN8RAs2M3kABUfkblq7lZTli+lPdBHAPlJWebyegI6KW4MEnTLX6AA272MNFfsym9nK0eetlWHudt4MFGs+jA8jNPZlyrPzgCn8ZpV+Wyz0Zj4QxwmJreg2AF6Q0Z1U+s9iuGFpHdcAGDAYYKeyZTHS2ObKldj+s8zPGCw69+aTaI1w51KE7kAT4rjxEycrx2vt4C/no/f1QdtL9RXAfbY1OxI4MnM3AAUc81FVTzQBIZ+mBj9JnNqOUuUFhL6sj8iBuDWT59NAKUg5GNpcxXQAAQLZxuifZnw28YGH6/opGVlv5xjJb8AWQDk/LCb8DYjxkBbrEAxlKCIC0bZkkl5L9b9h3RbWgCkSkQVwCpFIA/as/DbR3iPCK9xbdCB3WuJGz5IktYyAJaE9PGbJ70yihdtojFdil5jFWNeln6Ie5GszACRIj0AHI7NhApqMo53GjbZE+d25tGUSB01XNuYLAVJG1jS4wAZgk1MPw/tblXfwReaDBauamxm6MHMk/+NM4LH3xfYAPuEOrdmOSKyDxZlMao2j9aztaV0cDaxs94Mqsvizj0AVHajnJKpqyu4AXxelNB87qUT0y2g2n7PdS1qQy8vRwCFR+33lr+AlKonUA38F7hV+dm0xYiE5TlN7Ovs31O7ABeMgOfAvwDj27fvr/OSovygJPU2bmfhpOORFVtJo2EAxzMrNxToElSuBgM94f253MPnCn80Pn/cyYSrYjRoEQC6c+pnjLV1PyNRn3NwsVkjt0IIZVudyahS1UxBHQt1AHdYk86J1NkFNC2NsVR+9X4WTCFRR0CuruYsunniAyoA+AZhsp8n2EwDoqKUOXm7wvaQiEJDaoQbo1b7xOcFzgCXHWls4HG2U+8ea/OWJqJQOvWBREIi50l5w2LV6ZKoAJwvW1cd6yw9GIkyTvkbKVrqSmOxipTx4Jj2RwqdEScA4GWGPqy2kYngb3izsPWaA+VvZFXjtmpcd5hPpC/YWQBYq2T4Rh2jSHuCGRvO0Kow4yyv6PrwHSVqG3W/7gX2ABggJXxQADdIKf5GKMG+UjjTZwIUmD7k2bGipQvrSx4AIl6gLNWf2vypXqtQLpCh4ftax4K/c0gxMRUBZKQAOABC7OJ8XCIqEmp9Sl9isM46BrgDytn1K9LQdy8ssX2aAI7LaCGRAv4wAXN84n7uKd5aYcLK99+ukg+L0EHQdqwARd0bNYlPT/rD2rWVu2kpJ/gaxyRpBgrxypYDJnAosAC8phtec2qFOAH8xxQvwkbOP+J6PmsFEK0SRlrtPMWoAIuIKUdNY36SCYFjUTW1Pi5hkjtqxG3TP86nG/BThwEAvOT0xjKTyeaZcCOrryTfmiQtFdVoFRL87XEE3EYsFgDk6El8O9RVQ2Mq6LX7WkHs4Ol1AagaYnqiAlywQa7JAP48OSthmqPYUl9J6XbnaKM4pU4w9E0JX0R71jo2ohYAyqjp1NlicRaJVradrhnkpOHXKe4/ug14OfFf9mzxsACyn8xXUhpElQDY0Mu1HpY5k9hyvaJt2FPOk+PvgZJBAHoWQTIZnhnub9r9Lg4VqLohywjh3cU0rKWyRul3Pe0A6hZzf/2neLZl7O7LhTUtG7BS9SMhe6XdJpSTcRuQgwAC+nSKEmy5Sy8fW/jQeyDmV3kVIXFJdj9u+zaKbocXAFcSr+DRPloXlreRkCiuZlKAFqaIo2j+2118fu6yxu8AbYAzFjfcxB22V/q+EJIGu6XZMGyEmil/c04Z2fNlEwCy/nFTUrSpp9+HPDn3HpAWFAjlrF6i9hc3/MC/FJBgAElxne4kenNOuRL8wFrocgJ97wXRiJ6MncF/MyFFjf4A5AXfxwSZ3pQzlR8xIJMnl3VKtSxwiuldmYiEkiGYggCG3Lc5hFZBGy/E5wguUksBHCJ/7wcpcEzOsBrrlIYIADyv2KX29f2YhcGsazBE8l8yUy3yr8RDC4bNsjUhs+AAaT+FpJkNAiOKx1qMqmuwoBfjtSuLZd0Yt0/TXlVv5QC1cnnFVF6wC0QUrvGUNwrdppitPNTpVZ8hh3BJY9IFACIhTaDzW0zdwLC6/xnCiWs7BBkEgYUIuh0pmyMup7sAQRzFC0dT8dNSTQ0mLYHzqk/tNLNYt29qHUToENcbKQAF4NTyLZfurHLY70sZ1ycgobV5PAIcQZ/acrCbudXiAKC2/4Ej0Ypqr9kdgUZg6b9UTMNNe64KdsDe1iata34AxDg7m5FeVaLoocebZjfRRAy7glu8ZTUygQZ2TtJQ3wC7pY/TbIHaflklwLB8TM7wfkMMzAWVA+PqJqPI49wRADPm7p/oB8WYAA0JCdFCMkEgCuKq9DyF1MXcLY+iboEAIbBMNhA6viXJ/QfkA+svqO4WXFMan44Hi9B/LJoZ0QD+Fxou5malWSsdkzaAA615whA5ts0W64r0D0+sJvqlAB4tE3xFhYP8WFFWzbQOTS0jD/o7UQXVCS79KyliJAsAcNc+r0uR4RgYcxNztgvIKNsnfs9wL3ZHYIAfl6j5BgDxBGVAH7iEhZUgMrOxmrijf70kZGk6VsCGXJiMrn6nAFV2FMCVCWzoyLu+UDgzPG/RMJLPfKwLkLy/cjfnGokA0X/NJkQ6WW7U3U/rVpFIJSV7rYohSIx31mgXkhjhRwAkl0T6m25bQdiawsfG8LHUwYH6ynLMqZLSWlTjmzJVAFopYbF+cElAMcE/C0gd78Q7aQwDG1VQpUxVJdQ34z0A8xgLTZ+53aScFBJS7hI8vocR4rT8JC2Jt5l/+kP40QC+76XA+kBfgXO1ggkJzEl+rYEreV0RmthJRSuT9gzDALUDZzQlSeKuKJawfKdQcUZZY5CkdHbXJBRe0YEV34AArotG0JmjUusHMUkQ2RElsI3Sm2huiK8CTJI8RC7QBQDACbLcz/aV+fPHeaEvnHx59AfAb2E9VO4Kuc2t/fU+AOPCvYhX2gWNReFdpezZAgzWbgdvDmT1WH7hHBedKXsALEGSKzqEku2l7OLcpMd8ebct+Vmfo5Om0OWbXVR06gA7GiLaQ48fymwFXKHzHV+WB+TjW2xCFCqVjchMdLqtAFjFzK73fg2wb/k1c5BekzjRZ+n43NN34xCxj7fuCvUAkgCgSozTjtjEh2ooaU2fDU2nnxoX82+xIHYU3VjIawCD5hb4IcXwBVznS71iDNPwoQotgCrYQeM5EXD32X2/AMDoElGXd7xREJcgmrSHQhZfeb5654WZkRGrBllBX6cAO/TgpMvd0Me1c+c0s6FFxcuNOwCPpt9+RaA5V4E82ACT/TUrrDnbxuUNdMahx+VId8us6i+S/21W+t7CAAQOAFSF5Cwzs75iH2tXmxZBj1faZVhkErWr2iyUZpc1WqUAE0mNBwfGA+SJ0Irj8+ZxN7b8/ywosP2JjG8s/p4opQA/V9uo8ebrXf3G9bPJ/rDg+obIMaNEZHUpgeOoRSaAAIlLj7Q7cRSCCISq8RAPhn+hEVJfy5ziVEqGyjObX1kATo26CvePi0Uo1WjtnqgyeEZPM+kf9Mvx1k9y+6SuIwCXoUPg61FEqq9sf5+5Kd2h6RAjmkYLDL3+7UOXk17hAOQBhzA/hB1SIyvY7Yo/DjyD6v6Ph6bPLfk9Tl4CEqQAFutIIWHNf7brWGwrvUsi0eE41L8WmqS8+os1AxRnpADl87kw5WytWsYyS6lBh3khqeeqNe3KU9cwFQpKJDKOAHWMi3Pid8LSfJIrNHEX1lP2Iec2rWz8R+vc78WYU9oAHn0OSVBiwWO5LCpAL3OYR9epKR3OnU18dZK/ksZ1RwBveHeSS9AjjmQhriHCxQ/5eU5cOtLqxvbtqEogceSDACMi5vbkNFYfM2ZTYoYZr+H1d548hqbui7e3Bf8LOZ8ATggEEk1DS0dIx13OI+mxa/FTvOf6lp/PDmhsWR9K8ADv2L70G9HrSBbJKDPwbPUxF5abqdtqkwNePSlwvSt/AGQRfNh8uqPX1U9b8xBEVuAI6pDlrdCgQc4gUTHA+R8AMqwUDiozSS6sGJW1tnpcngRA/qnsIMo7J4SBtidhtABEwjsFIZfsSe/hTArrhh519ffy1yvzEG7lqgNjBfzhAPsKnLGMMDUHya+7i2o5TAEEQ5LKa4dQ29cUbGj3dbsAJR5WEmDqUFZaN7l1TbTd8ohTCSrPcFariDUWXITb9gDyU/7Npv2XGeq4cN9xfnNCNwDV2XwxUapV6PvDVGgdANACUJ5EuKhfltTDYYkR0iSY5Lm4yRb8TRrgPlMuI/wA1T4MIN4GbUOIGKa9t7AU8mXnbR/yInxcr4E1H++CqABt4f1xA1x4XZB19GBzzNypGXv54xf7l8k8Aett5qbkAJoMxtgqCx3HZe8XR4ZpOmFiGpFN6x6/QBZsbPGOgpIAkOzx6GDIUJdBkAyq6oOwIQ/vI3CuD6BB+P+GYNjyiwBDUOCWYGmFbmIW/tWB0ljCROueuV2hmm/YPD0Q8js/ALEDsGVeIcqVsemlgZq9I0MfWuphor6/HYiDowcHJMcAyS/g0jeRNjqt9nFvXQsa1wP1niQnumU+nsddkmHOvQDM6WWqx5gKjF9zBXwJ5bVklXyonmYl1hGn+wTBT0LiAInsOfd9vbdk2A8Js/FVeRV8qKH2ebECiFzulFtM8ywAFrp2b2UBHSrHKUmcyJo4RCyXg4qX1oRjIEv7H79lwwAidBw4YFTi1yzj9PzOvv4o9W1ESjAhHMe7kkBc+sugAGU+ColECsMRRzdcdr/sGnk7NRf8wU2rs6t/0WKEDRIA2avzLZ7Ih9i0TLCEwRNUYqzQaXee+QNpe4pQZCY6pAAFDOxc/c7C5MqKXKAJGy6ko6CjwEuhtUOJ5EjL8f3BAN6VsbxQkqksbidIBr0lO3q+VgKnqxrPixsxbsaeAF4AX5DrOvdOn4psdMQJFh6ng+Vuy/gF+t/zcrN6u7SlBACVTc2TKA7Fo6I9Qs9/WfZ4q5mrSgkjgMc82Nzd52WLAAqwTnTj4Sx17o1cl4wcga2Q0FfIvbQXX4gffkYC8awAte+SAWvcSkOcndOtO51nHWhaoAl9AwqVcQxq6ME6LgAO7wXW7aqZHYf2jfEpF3GTyTCvTCApJLnFo6OZeq7nAFNvYoxX0Gzh52Z8VmDHvAeBiyveD0Ox1Ufqrjmngx4A8YL+g9N5jBVMkMQilFdhW3T2bvbiBSTnt3OpovitxwBFGkBVEUxvIh6EBdk2mqEPV9jbGwNoYap1iKBzkTw5ADP1TjOUTpAUw2FTtGfgpiiFbUlBuUeTs1E8EM23F7cAkRdp8mFqYgROiWN/0ZSJmKAodykG7j94Cc0Q2Ra6BQACrcUSAU6tSc/bDDT7Hgl+4kwBI8IpujuElU9ViQ3EANz8i8x5ONkG/badk/HdATfC3gjVD7MvNxhzQTo3N5wABXOM21c15STlZgOv6RRWLXZLtDgENCW496cSRKtncwBgTVAw8r2ISy/FL9Rr0tFwRqKMzJ+c7Vtzoir796SHAFsQmTjw/wBH8xLghxu5xQiPN6lpB8/WodkG9AmZiK8AZ9beJzb64MHKr6wkeOvTq/VZbNc0/vIFwn772nNHwAD2Geji2PfwrfE7y78pNmSgOJdIIfokbMk74KV5c2+TACm2du1YFyRyddB1G0wOFk6MHan/Ns1+d8C1aR2N+MYA2wBYDopvVU2g6XP95eqzWp+C6Wo8N5AjgfG1rvlH8gBWs+ipqolGKMQI+Vop7t1qTfzKsxXpMY9AukIyzLW+AGi5kvejaDwWGpd7YcnfBmWWQ+Mi5UvMl59BZS1gb5EAOzOYTsycKMZdbzzvVspe4O3bjETZIt1MJoW1j/4nYwArI30ih4TYVqGzV19mV29M0rOvSeTXZTBj+Z8A+ROeAG/dGa9ZjH5N0JGvpsu91N/TiJ0VMfWXYV0yJ+spbVcAoIrn/k2N2TOV8Ajvthw5dBSSY17FCD7+DTWp1eOb+QD9GHoKWV0hLBtpuq6KPQhz+hJ+Q6708+OwM/9/htSsAKS5y8T/YccZoVoOPQqz1SfyU0/Zp+upgTlRj+uAJ20AB/MEC0tk1dCtlv6CUmJwX8sDqHGvtGHUl2BuudZOFAD69rnvAvGIYPf0Lo8oQRnahnCc3Hk5AsigoLKM0FxhAJotzExXqEiZmGj87Y6R+ow83JGE2YO07mxEppuE5u8AC3xBIn3MB3EPiHW8DhXzqz8UEL4yh1IjsA6miAlABABeA6u95Q3yJdVQScD487Gu5H93jnW9pLxOEbvPb1iSACbWW8Ek0muud+AQYTKFzNAWPbGEQLph2fEl1dBJgiMADwb4HiOM2nmmykHD1LvjVjejJNzQkNjQEz/Gdgc4dgB1XCjFAvH2MysgId1p+zRthROlHEe4DzVkoGrPnOLUAKV2syWNH5JPm1V/jgtJKYFgWNRYerw7w197auAR1RsAzZH7sJoG6ubS0jMc6OYPvRZThtnD0k4Z8rb7fIOLbwAVLNWSAS6r0liSOmSs1m3iWMzGuPBmXzJjE/XlJoRJAKNKEnw37QarOsvaLxXjY7VqyvQizwlS2xWxPYWKZhkAVa0+6chVui2a6PRP0lTQGGUarG9rUUxrwRtrp9WYAABqLXpjOs9qj/vXR5BI9CRQB3v7VKAQ+VTX9FzxKHwkAPg2DoNUGtKuc3X2GnBLzPU51oNsNargG6ZuMoVmoVYAf+JzlNyesNuL3JHRhO7pbA/I/inm4SMRyiAsRiptuQC1Gj0dz6HS2OHQNES0EB6eGS3ZVczBJwj9koonNQWBAOYt39NwNNVmH8BwzeDVQ0ayD8tdT63Tbx6b60Yo/kUASacwNJOT4I/FyIC07XM8XRRFqr/EeJQZcUNPH5EBrQBvuDspYZgTQ6Lx/t4fAdBG8rUD6sxU00pWgn9GaZAxACcZQ05+aSOo6NAvZl0qRSYZfzfpb845ObZ9cYoPnvoAIhYrTdXl1k0dhQLqeWSvyz9UCPTi3w5Fk5x7VTC4AQD9l0alfQjmI4bD5nJ2AoXqOCuC9heGzseDlE6nnQVqAC0Jq4JzH55gRspLGMBnOOr9RQpj1AiLknTeD3G8l9QAz8TOpvSQvmyY18l16lmMpyaiDTcJ9BDjkzBSsW3k7gCJjtK/gmR+eSCKdpATFsy0cz6yrzhPGTo37JZKFQl/AKUJi8IgLzQS4jTP626l9TRCY+4v467zV9PwhaYzNsgAF7l2xslGWdRRpVWgt2IoVfeg0gVPOmYPvgZP09PffwCZWum8ioReIon0nCVFPUJhcGbwjT28BukcDYO5lNV9AIOLlRrl6/RbG291124c/SG/P167l4BD8aJLQE2pWRcAZEY7U6R8EBMj6Y1EgqfReWWu4KQoVyL0bFndMOX5wACoEvgD2j42qltJmnwNOt6yY7wZCte1KPJrZLrC5fvgAM8njvleMplObBavkMctLhFJpcJfwHIPwEU1rJQ9wwQAwn0cEt4BbFhxSOgKy2iS/1A8OujGSZWTKLGZB9bJPADRdWSfihYM0jAhlb5P8FEmNnZmbPislo3y1FCbGrHLAKmLW3Mlr//b0XPqPKQfiPhrTPcc3EHyvcDPsEOCQTkANllv6AiYYVq60lyq9blZtRfwtXRvT4Tv7m8Vck8zKwAZGLiEoxv/edHGL9ZUrx6ju1rpTQ09RThqGP/QlcE/AHLAag65UD+LaNJ2vX+Fv52J0MAXzYFS9+ogpCAagHEAbYTTTld7Hf5hqvr7CaVsvy3Hy5PR9SMBTIFx1le2dQBYWCZEwM6QSoMrCTcbumHl8r23eU0QLlzXUxNpQb6rAA3GjFcswP+sjer2MoSVz5Lb6j9os3Dec4kJqWHrhdUA8xJZ7hXQ+Inoy3XJO7smFEPQt+3gshuBNIpLPOk+qAB+9dXCum+1s5EN3kSFdqG5x9Bb/1uWt7uQR3IIDEaIADX3uLGOfoOQz4YYHH81zBtWLGHa/3/5FhzAwUbVzSsA/wO88h0ncKiM1ELm3hn1fHzYINj2FTHiwnHgPvSYhQDq+NFzttVbdkp74/vvB/sBqrXLd9EhyCwSl1AKLuatAGwLpa7vRQw8sWt6QIWkuMSR6BjoNNYnDbf8VEl2JkcAqwV2zriIukKHj+YuOkQKl4gp2J9wIpABaVi6F6Y8PwBU4zI8qRqsAMAjSHj03PixJwX6kgY8bzDtZ/K9V0MqAFULPH7Bx+hEwSi9WzHnsRZ28HklhHWagguthJ4v61YA0jy4pDvsjdvxupvOBg3QjIFybmx/2UHftbkpeLCKYgB3zTh52TP8lSHwLsNzU9fMMRmb40fXpLAgt47oYtiEANhT/IunzVVIF6Wk3xY/ZEjUN4i0Ui17kPjydy1OpjYAr22wltWm/dygyK3lJfihdioC5CP8mnhpVHA7ktF3EABX9HN4qV1fDnI3W8aMYlSQgleaeA7h50Fw2J7/THmOABMjXE3H3asdB0uWXG71cvcKcDBVAE6sYxudArXB/nwAnzGFZ5ngxIXYvMFVrbJ05Vm9M7UcD81+SiiWny27zwBUwt/TTeGEH8MLFkpdYmxgNUsSwxjbHalHjM6xPpcPAFQCBYRUBMRuzUPhZ1oLv40/mqRN1WrbRirozQjtLKsAI0NksAddOc4PfuC2I3A4jLnsmvNlsQp2kOYwlRzC5ADi1HsLHb6hA+pTCnKToWs0R4NxbLq1hIS9B2d5gowoADJp8+oy7qqbcplovd8gMIFuOylNM2PIuOKZ50l6/+8AOOW1Q4iDCtNM4SUcgC/3J/K2OZn38nxTtD2+hVh++QApDkhjHBv7g43ENRXYu6++wttFhDXrxZIG36c6yo1zAOZsSH5CL93pLVKPbTqMsTMID+K5ef03zmi4BzbdcfAAHFJa9VWX3nm5g1WPCsBWrdDXIQ2Rt9YcsWO545XCEQDn1lBRMOgOy9hwqoK4nttDH7Bv1jlW5H1ARyPDSj6JABxlnH8Py0hGoUskJqdrVV/pwNrwlxwm2ypPNn8zHZoANFOHP4Im/qWqYD8cN2HOnZEoEeoipEi7JOnbjjWymAB2xDQ2umHJygN9tPCTh+JgnYFVU4LotEhjUdMSlviRACnY9gqXLbMbq++plzv1H3omZwZuDl//1UXINFcK9p4Aav3TfEbhJ+uZTYG9sBcIpG+1LaDMm+DDAMnw9NlhHgAdcGWx4cL4OfNBpNP5GEmj5jNBmnfJGhx2pSSY+r0AAB+lh+/qhR8Xd219WEQnJ7IrMXOqOOrvYBJYlmPP718ALrX8XNt0rB0EghTkcau3mU4lg3jLu9ZZt1MIGMMzpgCGIJ0gPNvpO/66jqCBPqKhT4WzagiVJ4uxxMcqZLrTABo3ACt/hc0rMXRE+uLAOnJyG1wySGq41xymwB4HwwcAm/1GGaitdOqYoOGrr0GGbYs6/IDGRTNKxlmmb+FjpQBVuApKQf+5iv3ak/Zxoeij/vTYKCP4YG5Ossb1+254AF+UhwtMB+woeLE3zAgMJH10XzNZvmukpr1Ob7vcu4IApDVQzcY15e41/muBHJXrgSgzDTa3DWScyJStgRozZwAKLzrU0KjT6pZzStNtyV4jZF0PCl+JUR1UmlsyFLoxABJi4eiaKFfydyH5b7Jm/Afiba7lB5F8Th4zuHBoOycAr5/FRU2d63yCFiGa2b6zNHIg0r4Vr8qpTgVsl3KorAC4Iqmoy4Iu0Ny27zb5BVsBKL7Olr+mfVlEz4RbNFWpAH6+zLuv4Ltg2OMn1oYfS+Rea1E3mc3c+Nlx0WX45QQArB5Qc+6SjkOi1kjhBNKWDuIm6D9IdxtVNQ/a4Ja+DABK9lz+so8VTlh54Ubm1VlyuAvvqjEC23ljiG7juZpZAIhfkN/7bqAygpW7bFrAIvT1lTWlHWx3gW0LVvQaVcsASCQZRglbizfTeIniD+wKaaf3ECRN7rKkaM1C5l4UsQCMIpWz95VjeK5/8UTVGhXowGlEGxvQmndF+9pcpJyqAHM/BryOod0lT9zauVYmu93+6JUoMOuGpyi3HqTalmMAD0754q8YaYudnAJYl4Cy5/Gvc0K7ywNj6vSLfP9smgC41k5cmjuq5pd1WxwcRZ2SFkmboBGkIjUTn8MFRmBFAOJMU6L1CcvEDjwIe/tPX1o/iYC/USvUdfsg7Lj9v3sAaA6Umzr0cjsz1c5ZsSauro2d9fI6Mq3g9IG0g+42CwAA3czGHnyu1THtQqxhbPLPVp2Y81OgZjAvN/ge+gYkAF7WMIQByYI/NVaTdSC5HMEySxwfQcHaT6xcO5Fym7sAD9MLE1heFKfcRzxz7JyyTgnOxOwRwgKFuTz+Nj72SwBV0GBkViqAKwLjENGaxTJctjO0PN5qF9DurstI+F8AAMIjFnmSnVHaEzXW97oOlaXQZPQr4s+klIm+LCBZPZQA3bwAmDHmAF5J8yL4rt3O3z33u7qhLDGQsa9urp1TfADmkpE1+mLNGzMI0MQNVrWUsO2SXKquEdpSvb1624BfAGrjptvV1TaE0AR7o0BFt9EDSysemRyowcaaiM/jwDoAAbENJiCyordS3y75vNz8kf37b2JfJO5IdzEEohBTxQAFUHC0EREfUTmx5pwazSbyisO9qKFiPnETOvy82TRKAA8dfcdzOB6IYcOB4CAxMDfDkSFTBC+0NgSBfgf9nSMABNW8ltuWswnXaHDI6k22gLdCNySDQcQBT+grPBwX3QBn5BXIijRPjyJi7aZF7DP3/GPKwSvsM4TcSm3HndXvAEZEUr/Y2y3ng0NWM8K6qy9mSkHThNG6uRILFJ545asAm4M1g2MwVD167/eqt1EiZ49xYl/ECaGVTSr817bPDwAFe1M3dmskk3QP2bbNh7ZEnkVcDHt9I6DPQabnImeUAMfCYxwYm+J1R9+MLkl++Fmd7bXuGcjj6H/jiyPakSsA3XBGeawJV9EqaZFF3DGx5yONzuFEyJYO/QSQElDBeAA7qU/w4SUlDPA6oYUK7i+wUKjMXFKl6RjTXvqM8KxrAJRlOHspbhYU7hKiAXFujdXYhkoRVAaEY5hhZCWtPb4Aw74MS0Vmw1v09ZMk5Nwxel+uEm/1BqXw3uRG2rzcVAAv+7BgEVZ1i3iIDs0TIt1sRMZZUdu6nsfEZdGkNLYsAI8QLYnfKmARC+vvYTd74xdEQKsXKKNYq/K/wKCVKc4AxdPJA/hTRX/1KSsPGxFFZ4gKnBDLfRKSAuPh++XX/QAV1SFAxuMfGy9mxiaNuYKwDCn4fWec//LU6QQb0YOSAEda+argWbfS22Hke4TC3U5jIyofeWOMy1rf+f5wY+oAU5rs9UpDNggExrag8rMgMrV+O8KbhlvwKSNkdCmF8wAR1v5LuJWpdjblBh5WAsqWAikrgDxtsNiTnjEr2YdzAHpTdjPn2iHleS+2RLFNt5pHSPAfpLwY2xXDruiOguIAmW8mhSEgjdc8uFB02rtofftYJfvvcWt5H4yEyDbbZwA3CPL0jTINfpBdssaavaAdlElIAM2Hnn/6x6KM7c/KAKLF2f7Ku7ZYDaykR2YKs5B/mXjTHZOl0kL3HJzVVzEArg+u5geZW2YI5XLAuXmwvEo5wVydwsnNY9XAoWAXWACwSeGcdpl91vVp5eVGelGhT+FHP851wCLG9CMROAx5ABvFAPajqrcu2gCBjKKtyjms5YoJdiWDF0t3NhKmJ00AZiIYv1QSV0TdH/QbdYiuqkoqRmlNnq6KVW2k5s1DngASUmr3m5sFV5MMnR87ytDXebv4aHfXBjSGguakdSIIAM10TXO2T/NEC/oa1cZomhQgNwSCezAGkMWWiqfBA8YAG61MbplGK0myv1RdQLDda0F1XGnPKkh1Lqicff1mBwAsnij3+rC2QjHzfhhTWhIE6Hc5CkPdDB+pXi4qQ7M5AJoZSyyBM2YkyUCyv/gtlcBiDzDCknffLftt7wNvmLwAT1mMwKK48lcLE753ynMEKDOYlLY07+V4chlQOR7dFgBTOsGzZL1f4UsQzEfUMf4mg9o0wuV/RNUL/Wd0zO4ZAOVi7CnpjXipzLhsY4jrXs2D01tHix9Wed31Q3pbcg4ATQfXmyP3ylG0bY6LZt5YBFgN/YQTeaYmUQdmy1lu8QBaHaWh5UYKdBolXeViFfCis03pDze1vYFQ9xRwu1ggAPRRAu3KqN5PUAeyzklttX1lG4RdIU7A+Ctpj18ZI2oAwVtltO7IF9bVPIkK0pmzoOCBSLAtN8/R+/5VCmz2JQDkiR/uVC1W+NYzsWsW6aqQOkZ2n/x+Z38/NukpRPYvAHIjrs6vk9iCu1iylCJ9CNPGqFpV1ywD0YpIqvwV410AhbxW+uwGWq4cIhXM41D/FSuAT8lDc3uhh9zgJiTy7ABVbSN4p95gonj+cjAswVuHmTgE5uCDIEIkRvo4jG/UAG6dPI8E1wQUNE7S9sFDQ5UTU4elfADRyeT/c+gu/GsA36iigLnqPus9wzMYSwJSPD1hgUlb2cbSqN5aKMr2CwAPtg1WzwJc/cZYYMWPX/DZFEyg87s75SAfdnTKyj6+AB99q1UE297OL4jeM9VT/PsBdSZa3cweQTkg/PJm5/QAROsox+YPEjbWjMHytHMxJC5C+nD3qR+zlnFyxYh/zADDeKEeLxf3xRTb9BmYBRUi5FaiwbV1D+R3UDo8r0jNAF+OPuLC1VzEc7nq0yHr+8nob01MZhmK0hXBpOV25loANRUj/T5uFsaH8jhFlYHpfxMpYv6nx5/ULZyL7SKjZQBZ24Mr4twp40S/lWHXbyRAGoxPTLiRV02nuhLUiAWkAM+z/5ZJMNf+/49d83ATn8WWcn0J5tAhju+wHOMgNNYAWh6ou4ch9P4CB1D/8eUzrZTRJsScf9YdsXcdzfBJcgC3YnbwZeq+3oir3bBwZgpVvolPRzPTT0LJr9N7WdxeAFdf7FY02uISxmSR0l3iUJCnSC3c9iiBW7yDI8cA5kkATz5nJLU9+zoZe/r/58gQ9aAR+t2gJXP9ofV7NbZxmAAb862bmjc8gmf3CotTOjF1sSrUuLFEjCpzT+7N2RDCAK/W7NrBxAvi/Y7asiZ/d++M9DOdgyAy4sjcTa6rAeoALZoPbG3EvysMuQcihK67hvFJ17znAqwKMDMyLiP9UgAJWOUC1/FaHcMO5dtKBbuozSRtczwgQEyeTj3Y16ieAJWyAbbvfycUuFfJapus4poOcdxNOT1l0ARmIjcJ2bgAREI81IpaoD87o3B6XqBDQabrC81aX0ygfUwh+hxYJwC8p3milimwVhniseFgotNgOlw3s0c/jnHNa9eQYNECAL0n+fGQAN+E7fwtbh/I9ldDfrZ3tkEg2huoQ84+DY0AemB9Lg+h7E4P7C+FIG4XoCHn+FrwKS53E8G7Sbp7DgANOmHIg8DpCgSK00YR9ZXyQvJolD3sPD3Su3Q+36JEACkQWlK1ExT/0qis0EEx+a0/Y3bt+mzviCJTPzlhg5EAFR8w02Q1ffIfqsyEMEp+23gZHPkiY1oRgkMDOxM73ADEiVF/t2trd7wPLAqTysvu3y4XPOlU8zyJtnD/MNGDAMYzD0+zEkt6QBLirwXf+U8d9WwfRcr3S5ZCQv0XUtoAhmOq/PiwryvKaJtW4aRw2Ppimn4jKnZapbBkzUiTsgAwm6FWCLuGOUPWKfySld31R5QWFPUg7xT+F4GxnhbnAGE53Rp30x8/QVXN8xoqzbrs0jfmM/z1cmw2D50CNMUAZtx6lVHKC0HPLfnjZUdoKvCY9zohdPFcI8xFPLLYowCoTbZz6Lz0FsCApz88cBRl621zi5s4oIYtTo4TlWDtAGKkn8w60itc1VEkc/aSB8oP5mZjIUK0fZNCAYfB988ACnjJrw9SGWeVsbIVrN9lxKVvIa4jI85o4tCIcDrlYgDA+Njx0NCj0rWs8qrZL7LVfefkAgAk/9xw7QAgVPsYAMXXNOAQKu4eFSI5P59gsrpzz58ca0XOHuX+2B2sNKUAAGcZf5t/vF+g+TJ4Jr6mmhx9u64ItqZtr6FiPsniJAA6U49IosYVNsByArGrmhpzMff8KGKc8bJEMPM+NGC2ALoWf8HQP/PTKfsquAu0syo5jXR0V32iPD/BCWTmIkQAAnoLT9Yesr0wzMzNF8obEDnbPmPMGdwtwIDO+wAXtwDvvaII0P5TxMah/AEr3DGTc245zqumh+syVbiCfgUQACBEl7j3J5wYRr9UiOib8mggfp502Yv4dVlswVmWq0gAjsFfVvAItgm4hQPy64P1MLTOzppMi/W9BY46AEwNtADarJ0bgfRHskeyVRLLbOWQ+HaLprckwbL+L0gyWxADAP0EKdHaLbaLa0sF7JzARUobSK4ofUjZQ2V+14wxXjcAWsf2qG29jHH2yqT4d3vY9mB/F+WwgQUcu2DcsPM+xgDGy/l4dpIz358rwHx2BBImsuJnATmSoZN8dDrJloI/AMQ/hC5DbXsSzvKd2PsUGcEA9uIW0oaSwsFyLeo2NYcA/OvJWeE+tOTLnMUWqV92que48SUT9ElDnd0Fv7K1eACKhcspwQjn2YcFmgeM1YziGRnYhdKvMfde1P8536iRAINE1DJuF2xfFnv3+vWPz8FzhMF+NVkF133zAMB22RwAsy/XigQAcK1s5kXtaT5Dd+KQGpDtJJ70rtn0bIaMmgDKB0aiMScEget6OEif4CWZsjlZl+dV1YyueLH/3pixANK1S/1dSQVIfCHedqFC4eCx8rDsNQCCU4COjOXTrgMAWDT6ezHvlQD8bhc0pd0w+9Sb0qBNMI2DOIrrJ6qc2QAeS7iXpluoQurlVCofNBsg+enyNOsJpZCqyz4VRbpEAJKl1sZQAewPTEGJGMZ6mqVkIKI5e1gyhnR2n3T2RDQAOYw5YalDPVIye/q2HbSLdj3zfrpVvPe0FlItpDs7FwAcd7JApc0yUdJSC2P86/36n7GLlIeXiBT/wq+h90DvAInQsVDkxNO19NYqMGvZXgyLJa32Js9is3W9t7kVvnAA72SMj/w0/XfT82S3Cw89YbZ2zooVE1IXPalTFhwEqwBD+WVxC6Aam7krLri8q2ZSwDokca2fxsTgAA4OJSDOABLcDWlKbp3qGCRPtvVBOZqOSqUt3fAvvPeHW24bXj0AtTmk7D85MFK/btAqAt4eOxgwFPc6qSpG7EVTf+S9+wDJKRgEhzG3z9fK9MKrxvHb7ALRXMrnJ8dfSRH9qSxtAKSBR2y+aZNHk7GpdSPpW2fe+H/SGG+LZ0c1XyBXse4A5LBmjvGb5g8xRGxWradlquqpINsTzSuBFzPLpyF3gAA8GHj4Cf7+zcDBbIpQbfxxZGDZ9JwWXHwcuLny2KKBAGA6qmBKmMrxc6XHtGfgNG0KYbKljwpmA+0melPdo98AZyjiGby6zN+1hC/utm/rjW/3PsKvakG76SIPtl2tcADvf4e5Rw4nVZgxbhsSmLnkBAmLM731MGQ5N0yR2JWiALLpSz8pN2YBuuXn5dOyXZf9hk9vyQPXqPHvg0Ud9qkArXyVozRrtcMF8HPVypBpGXfpQAxms5jmvvW/s31F3QAu3gPdHEFhu5N7sMJo2Rgm9FabHPcgG2Cfef1WdwN4AAeJMhfETAqi3PQGyDtNsmNUkqmGXo6I2H6Dq3OATs0A3lb+XmgSrKwn1qV9K9z1ttpa5UGhLTxt5vRQ0NQKNgCagndNXVIpgAxeI7Bi+xeisSfNYyWe2i80uow+3MFPAD5h4PbI/t+rA/OW1N12dCebNdbM3v42ipkeIN78lUkAaH62Zhs/kQVFS1bbHp7LUcIcGwkRJUI4LOKwKsXqSgAd5bYv+4SH6ArFUDwyyaN6TMwRFVXxucgv+c5dx/0AANFfW2J0WMQ1Tg0VTzV0eoLYcgU3LIfAntPbBEAl7hcAK2Xbs+M3WT6oK6UMSW847hBnpvUMgS3JUnCbj9NBaQAxsI5NaIKO9UByYgLZTf/UQC573diCznWwryIVeGopANSus1IClHNyvywhr6nN8zkjLugszImKFY/y9nquD48AhOC5BkI46g2/7F0XjjzhJtiM+T9bNSZZNS87uAOdXQBtdf21wnrMrg1VM6UPlWm6RiKvn38h9kJN9eFESEXdAC4VuNWjB6bSiR0N1yai+qcclbrVzLX45fUU4J+MhQEA7GtbXEixHbE0nslOSA92TXIraNFilalr0aIHFuGm6wCNfNvAjprSRCYUD2WDTjnsYPjiorj3uSYi42rnhzFQAKYGpQHH54cTxcKp8aSW1aqnItf+8J42sFKKss6Rf3kAtVqm5yeJWyDQusxCx/WL1wJKvTDgoIfLAbtIpVPQrACKfqisOP6yoe4qztJcI8jxT937wJwJnz+vBrBQmraQAOFG1eM5TbZD3WPH6wPgacbG3dEuv23B+tIP9GER8UIAmDZZAhIof1Gfh/hk9lI6nYqbe06D26lsV3N1BlQHAwDpbJrR2mknn050dGKDw+URg05KUNPORdWFOltkYWSKALWtTngXgEIqFD5hx1FJnAifp19SHMj5lO3gQf+b1PoAb3pXs+zvGBXXWJy+pL81k4riIVUF/x9mhGy56D/CPwBELRo94Pak4t4ftjB+NnvbPvBDxHIGLjLrumogMNX4AAcb86w5vRhpPcUcJNn04Sja3MLgrzRhbi6gtA6a2ysA4LrgucuMfsawF+oWKzA0RORmXWU8ZPatb2bH3EmYKgD98Pe+ABZwpeiYfL0VffLXRZdmxd/MO3XsxrOoiK1uAErNEPdoBov96uI6M93TL/gzhr9nUHxXuxfvZh2RlTQAlw7d2uUsrJfmEtr3oh1hXjkswAyuSfaou2LvSvg/BgAxSzz2ewChPd4TsVM1jDARwkoVPQvphPvPPqb7bXxvAGY0UmPn0gOe+LpRdcZA4GRwrHY2eQjh7Co+A2dobcoAnYBaXPdcuT7OegjboH5/Ryw3kOw9N5+wPE0SY4h+IgAzxEItpQTa0hQdgHRUPRrXZGTs+vZoSbgilgRCuTOoAGnUvQIyb8PKjOU//QbPL3JLwYhoYGBwcGBDrVdym78AgT9GX6Qn+J5TOW4DFO7/tbgbgmGeBq1se2WZ540I+gDd1r/cSWeegpbT3feqIWnKTR7GY3HItutECztgDPqRAPmHWKhWan4UolXIfVnSXhxz+4cZZQrNfql5UN3+OmkAP1OZDoapgZUhmSlm+LuHVKs3ZKMocHD7MPSx3w0MGgDhQC0Sod4SY/aj0Kixck94RhXVnjoSMSqT/EY/5nvhAPfT4IYoKFsDkwDOfT9QyUCxUtr3vzuU0QAWQTLlOKsAnfE0JmnTqJ/VfobXOQOpu6E2nuCufyZsrB66vhr9VAApMkoTUJCop5Q9XzFz8i5ZVpSC6aAR+DBu6Ri7+IerAJgcJWOa1W81+Bv0c8GpXXuqJffc6aleQYsH1va286EAwAWxOIlS3tcHn/FZPnLlHOLyOsbi2Cjiw83t8TvMlwCbvSJRST6rfR3MCeQAWD9HN95JlL7shJDW3e4MvM5lABlcI+rxsWadKZVuYNmlkILcYBhD6LO+KIgmqEdhfqsAGC34vc41j0s2MZpF1eSOHNdOhAsIGtL//bTKl2C8UwCDOct6IjHGxGJXCUFW+7PGeYAndVnsxim0YKMLIgKoAAWbxsGJDcyMcSgIErMVOzxdZ2uD0gmxz6iJTyxiGeAAGJ3jbkGnJnf9l8qW8LVlQr8wdSg4V2zY8GULXs3axgAcqTA6Uli5RQcpasdsOkAGcGIEEPfGtZUCooljC3mOACXEmoDOvnzOmzIgAn/CHAW2rxdsIao3BNRa4POIsbcAlLxdX3auF6AnhvaXKk3P1yv3ELDWmVOmoTlTb7LtlgCXQcfZd84LGAC6duXGibPribXxLq3tI4bRjupphh4fAJ2e6BhLS1a18ezrBapiglSmuYnGzSO1l2tUPWqJfHMAButGaQQOC3fKBWsKwBjn7POZ/geqhfpM9Ax2nggUXADfij0nZJ01BB+2swy/dNe02NNtubzGzZ/xoKxMrw3gAIhg5EbjiVhZDumnzem3LBIyqIsXLjYpgtEDQXD6uZoABKgjnYcrXbp+U1/tWBXnj76ks/EtDO+ZhuOFv8EapQBm7oWc8WMoRpPYfXhpdjlmTKY10StCWBMYQs3RotmkAPLMIJwSQsNEa77S/oFEFGOkyun0GJgnnbkd3BNosIcApdUFCg/LCtdW57bHhxk6BTaK8ND9nBOPQ7s4hhkQkACU+Twk7swV4kv7pR8P0thTbSOwTofX4QrQo29qHA/DALirr9GQDC2wV7oigcDs/6gCly430vhONXIW9VkhVNsAD8qUCXLtPL7mA3lecahRtrTG62nPwXJ4tuxEHoLGVgCL2C5rDjn8NUwkPrfvYZDPzfz5UusjPzZQtT34g6YRAPBZDsvVUfL8sh/De9N4MCsprPo3wqCXzxirZuPOom4AKqScpmKpAbAsPWiKihOac/6KQPAkikwHwehrED4VFwBxZQkpTPG6dNsPr/5Ga/WGzdOMlTcanUYKarV4hNlcAAqqWod+ZKAtg6a2G9G96N40wCqCi+hN41IRZi6OHugA/yN8Hw8/CSkdoYeIER2Ctor3OydkXqO3skz0KZ+B7ACQTCAKlVGCVxdQsXn/lmjA8oM6xHqTf8ZY08hQo0AKAJ90zjEtTuJNCmsAoW6qKoI+U+96U9sRrnIKMzWM33UAgMfdIsKczOka9cWWMi2MA4XQ8i5Vl+d3aAlangZACQA/Gx6LcL2aHH7U7I+0oSnO7Zoaul9zXfmrrlms6l4FAOBsAIpxILBiy6QjXRJz0JLWUBzPV1GWVMg7mik/S6AAzoSakGAnhOTky6G87sAIZ4tNC3YHtUxDVe3udNI9/ABqCXbMnSaSkx6iq6jW+Z77pi2du7CtfAjJkYuz70xtALrgzbXBymiaPgyL9iAIOmGBwc3ogaOUm7kWKgsaEFIADOZgJMFZZYHzvsw5U2Cud02RrpfVQRd2JhUyWJg2QADDg06zSAWAmu5rN8woNv+zsW4lHK5EtcM/XLJ4SMbqAEhlUSWQrf00maJEhVw3gSkeFLsQE9oktFKBw0ZCzSgAV29nUY93xIOQYbh77BrTc/XbO3/7oJrVVy9cEMoJGAAR1tpKu6slvMu83Y7/UJVFzOxjMxALiuMDuDaLPNDUADzZMwX/dPOly6IOx3BKwyHdPcUK21wYZF2n7drbMdkAkSopDeA5I962elqpgzt4Z7JdH4yVQtzXaH4iqhJpVgDERiWx09N8tm9gKHpLX59iIFlZ7Xq3Tvy1QZIKXZO4ABx+CQfQwY0RfAf8ZpBM3AYEZTUSR9MufnU+E8NHI2sAUhtNcBF8iAbmrN/lLyqlsNVbgQfdCMD2TKLS9pXyBwBUgIEub5ZYKnUF1gIkpm/Bm8nHs7ghZAoe+rCdRuxaANAR9m2AHNWEEWKk7JN8JMvEMLX2gF8Oiwi9AJco9BAA1t0sxPF12jMBoNKkmsDy8MqlpYkF5M0DsE2lbrTpJACEFSYHU8a2yiiSahgXbNvw/uYSQqPiXMyYfvsKYZSbALj1qfl5CaL9lgVQRWNwlF8fHkVzuxPpmbULN9kHCcgAWIMlTS2eFmvW9TA+IhiySYR+5mUmpkmCacBDY+Y5AgAzffHdmY+I9Lji4Cx3v6HqeOoBbzhbBR4Wk/vlsiDbAIuI8FuDCreNbrkQYTMvG5sslQ3yeZ2D9b9TJQVrUtUAbFNhI3STCF5inTCd5Md40zDxoBdwAGol9S+MrC3pgQBhAXV9QGdCYiUOeXl1/UNvKgbAtHfiEK+M0ETLMCsCAMSUHzxS9Bzj5U1m+Qk/eIgBdIeduim5rVBVagCMoMcAl8yWjouRV5Sfvl5N9P/3pJMTK9xW6+xx09jUr+aYrwBHF7d25BndS8U2uG+rRLxjpx5JMoj3Xkzp/w848fApAM47Jhe8KOiPte9TdVAWZky61Cb/Jf01w7KuPbIjuAUAKl2lQ16C3Sc9Vg6QAaYqnRFTbxNZyVvTGnwYQOcYOwA9AK+lULfCD9WqE9bRNRHc+altmH9Y6t+X6bXrKd0vAHQOjJkiB4fuhsolULX3uim6JLybR0K8V/G8/VJk0rgAQ2g4c72KMPAPhQHrMKSGkHeMCo6miuEKIshm64qnAwA81d0bEl0m8CoOLksS2h3+o0DpJ8FaLn3FUEdVN42UAAKQF00dxxHqSYWcqo6Df9qArgBhU7/gqXhnshXalI4A9+AR6LBb0o7x6Kz51aEx9TyJUc6aPXo5puRpKeO9RQDW1q2yJ6pEs9nmoBFXo7qgljg8AOYUKsDcZIgUYa71ALMLfbcKvOXbSMqlekEfWannjmw6sZWoRdYvFcKrdekAznK5CMRwGg3YwqKHhommI43T/T7TaoebyR8Ocko9BwC6clTevVjIurDGyn+OcLZeEiP0cUXJZnedB2QD4/wQAC/W6v6MoYjB2YKwwFigoRDk5zXIkbhISp/ZDtvUW3gAFbdLSTGtZ44/YyhMvnWlJpPqFKeIUjcUx3aznf7eRwAI5Ye5K/VoZEmrrDuBI1zoVcOe3LEbVZ+FAL6Vyv0mADp6IPUaKf4voyvJucqwGVoYQDKqW5JL88WsbTl8QX8ACFTEg0VSaRyxPhfbAhZo6Zb7fHnUupDX+XQBfvIkewBQUWzNLUV1iQfsR/rMbSZqWQp79u/APJ0GZJV4s87kAFmMKrD80A4LHaovPQnUPIDivBR2vqwmc78Y5hw0VUUA0c/r1s8vR28kfhujyvB/c3cwDnV+q3zRu/JdkrlVGwBNZY7f/NoxjF7IfpvOHLT66Vuwb46nuLSlefqoELThAIr5S7Wvq2/0chs6o1UZHZndVKMyUYXNfBE5i7lZ+icASwwQGx11nxAuymJOlIvnQVSMU+HmrdJ5txIcdcft0QAzb/tbuD13Mqfk/Av/UgN8NlUrT04y73CKSuNNSfz6AO2DPT8DgZglHl+Xm5U05nQngpuIlUcirNH84AwKTEgALtwvUsgBUzP4SlHXL9sRJ+xYN7ho9NhQJHFRLgt3LwDvZIJ2Waz2uGH7jHbcTLFLJZ+bk4+6K3rBSQcGHug7APtOTT/Z+nbupC+LFhsL2YN1n2Xar8A3ov8uCFt+MmAAokFu+QJWaeiOOa6zzWy7ifXlGSPHCf45Bs6GKvW2wgATt2lzazNRXJ2xrbqf5XnxuYdFY/SHC31n/A8xK/+OACaUHB9tk1tWeePR7vcIzo1q0q6JNuxD+Cjlq/SzkDYAl6KLOPXHUDc0R8D+HUYG8eHYIbKziTQNBP3hbhwDLwCBFGZaH1Wq41H1FEW1/iboG0ChOy7aKhaZmgzobQ21ACQwuzUjM47u8s32JLW78qJqzuPLiXy5HefY8UAeTeIAd6WvhZXl3f90pqvdgStCjHeIk/Ib+SS0D95KVI2t0gCn8PMs1b2Zcn5f2Mu2jS0LyreVoHcydwVt65p4+mMfAPSVu3FEbColPBq1krjpjHPfWQTpbRl8DYIxhBy82dkA8xpHaK/j68cThwrbeEP95rMFNJ12ZSnbFXoYJLhj0gCq3/fNQkgj6lw2g1Q6wkRtJQTp41W+P7J9gtUe+2W3AJiF9745WnYd6fs+jrf8NiH3c/Zk4qBVgcI7AELKxhcA1HenDcp8QekVXq3jzWZf4kTrAsGExmugR18rdbJn9ADKnHtdaCOCrRM8wAlK5RgqEWy6d4jYRZqWoXr8KrYgAFEbHKTv0rZG9wstivyXhVPqOtC9diFAbzhXIpgPxuUATeTGkBKfCa0FPCFPGKmNYWQYvvII4x3GRxEdLzDFZwARXRgVrudxlqbLGOOIsZFfrWOtZKmZGAhkl4OrgRysAEwie5+xX1U9UZYKKnbndS9lNaayCvM3onvzdrZ9T+4AwKSo2RtKRqsGKSq0B7CVg1IlgUjAmWnObTeJFX6AswAlprzw6Da3J6HJ/XVSRKulxbJYj5GuvXyFgOwoyQ2CAAOTF2JPgO6MIgXUfB+rlKf8r53YRKuwZwIOCsdZFIEA468IYqz20DRrbGfXEo1xcUh4fqhLNh7H2L49rMjI8gDjCaAP0NFDOYSd3R4x4KdC61J91prvN7v/kmYU23xnAKSeudfSFyMEMMjBBWS8Z/vgvBNjbSmm4rza+nsWLusAIEV8g98DkyCHhQyG+GVKY1UwRCg5nicu/2BY8UJ15AD3t4UTfkaprn2MUVqwCh02+X9SbAgbesufNImdR5eEAJzvgOlfmdGncEvivWH2++2FEMDVcgXqZKJoPmdAQhsABm5iAexRyBIae/Qy4BlaVp66TOH3G4SNSFU3ISEO7wDUKZFfFG+fXkqkG9VHTROCfrQx+AdMfu8eHS1Ksxz5APNOkob8jQX0S800IO+YeozKVsY/SVAfBojgW5yIwJoAu0kwLzPVeMILX2IWUz3tKpTsnk22QOB7L06FwfPCeADOnoKFPF+BCH2CXkgEDZbfqMqa4DsigNTHV2L4HmSQAC0yiQFqm9jq5ehJOzpArDeqDfHJs3M6mugLeLDlxPoA9AZKUxvx3fG337/P/9Tb+2hDfup/oxcHrkwmqxO6awDp4VDaELFaefGZzw9EKBc3mvI4O0C425bkv11lNCzzAJ05bTVsD2fU+yAAND2zwDp1IOloFHLk69+hR3uNYl8AT47QcKGNX6f+VU8u80FrkjjHLjj/dbL7wl5bWLzKFwCsgYSA3THsovahQ0O8zINyvcK60HQhYfyk9CPdo1tRAAczfmt7KvzpeE5/GSNSci9T9iAV9ZpjiQMLcAkEKfkA/U5Pnh+Lx5ulxMkiV99Dc2MTozOaRLI/+uwFwLjKXAB8wqqACbNcHo3nN0q4UjBNX7kIE44DrM1SXvg3zoa5AC2cHhLIChw3B7NPhjPjVwdaqL7xtM+or2yx26T3QjUAxjWIVAfmc1YTr5GtYkfXXfEOiItv7M1lJvLP8n4xjgBmoP4UR/Bhu96VqOOpFffDcxAhnbsrl4QXEzHXtNhRAClF/rfRFAMSQYxcFKLpW5cKfcTtFnA+wQjkZVYQAmQAmCBosulm0PBlv8x/LyG+Jbg+pdTV/k+qCki/3C3ytgCDtNpyfZpaO+CAz+zhN3iu4oFjuO5iDdJ3vLI8ekduAKnmhdSUGrJXh2mIpSYK4Eo8RBdrTjshbf/d32g8W80A3EBwcXZBjyd+Wdrs/XiLuJ2JpJps3A78ioT6JQNEvwA3fStns/tO6CZSRXTMRLfYY5MtfmZFQa04runHSzA8AG6SlBIVk3uWg4725SGAX4ZCmnzXYGf2eUjwcZbx0HwACo3L0gIzibJsa9zpLk/abMIGHAmCfZUtnaZ84EhzMwA/fDOYs6SwT55vnwPQ8AsSUuoOHBKv6VCaaF7g5cFMAGFBzL/gidMdWxOVVZXEQ8fOjVvjXTPz2ak137f1bc8AmP6AtI1mBHGRCZH+GfQj7xbwz6fhWuTqfo8YFp3t4ACEJJL16i3JBS1XRl/ixQre8ISHnGutn4Rc1YDKWhD0AHeXVQwarf7abSU+h3bPmfSCspv0tc4UTqbN8LAann4AAEPEG+C7iW6t3XHxuqZ02Qi9gkjhuCRj84hhoBX7xgByV3xHV3FkDIyPLY7C1f+7lvsSlIZDvldBLcoWIduLADOqzM4XmPhMVD6tHXr0aM3O+fsqfw+Rglv2WeecTHIAkrycdTqlQCL4S8tSISxwL1BYLjYmvYauwW0bjtDYhwBrLA3/0tIGoRcDCKh5OYlWlZYUsb5Qhstmgw3zL025ACllx3WBNwSkOPsvbL1vOoH4wzaAYtn+O9t9BBZkY3kAiyu98ESINfY7xnydfk2lK5qbjPgWl9oIGwswJV+5rgDMayxsxa4BVkXXxR6rKLOsKVCjppPOBLVOTy9gV3y7AK9CIFvbAXVCIlHvOctA9MjjweSNt/7TOqBoMUW2bgwAVgOYo6wCeXcxlolKMPesXhO8aoIH9AODkQP3accLYAAdv88v7J6zG25KZ2OcRsffY1FlP4GhjEu3Rkpy1zheAFABtvagfNVvKdHlZ2xnMcFn1NH50V1eBJM3wr2uwRgAhL36O7/QX+QwXUlxnOt7rUkxzx5HoeoYXyJx3+6FkwDmr5GiTM+Av3fnbpauZDzJiZYHZ3b1PK+6aCRDg8IOAHAanmb6fYzs+sM4bjaNm1+CCqx/P5zdMPaxtyQEwE0AizCKhIIwoCzKN4GvSPeIlUJ+hhiWgtSyPnuB5EKR7ABl3arRbSpHkyJFbsT/qfg5WSxJH+C/GT4jrPAP3UuYAGNE2q0RhelS+8JBseW6Argde2vYFomdV6pmBeDQNvsAiSu6GEr8C4+a/EX4XXGhWb+POWP682yGnZjciwo0MgC1M9hOSMOMOWcyNZzHbZ9LD+y027qyjlUIu7rP6sX6ALKI/mJ3KtGOA5RNJa2XFdjsImXX+9jLxcSIRhzUt8sAi/VYKw2o9iK4V5ncaMEfBIxRUBiq8hvGnYp1g8cXTwCt4kH0AJpmzRnk3JwkxTHSw0EWuIJUAgAigmvFTIyzAJjyHspTa6Gbq0QF4mZhFX8W01jlx3AEUTzDQnqskv8ABqbjnYOSeYLZ/2kZH59qbVr3wvLTDLg1iKz1MPYEkwAe0dz9GfuimcrKZ0mHDf0WCI0pDdX/9OTZfFshy2sJAGKwcZuIjzHgcMXRkkVUJ3KeOtjIpjPfCkPF6DApI84AuqUoPeummtZZYjz0rjoIIxWrcga8Jp0go92C5Zc4JgAQ4rtohQlRzPNHSEOadWw6CuHMo6dOHbRLkb865IxTAAeuej+F+z4aVozC1jj6byxMQh93zVdL2xaf2h9Wx4cAIcDV7uDKoGHcKR69Jl/qYLmUyA7pytWtJCOKPXx/mACC0k+i9pa99hvkVSfYEzL79JXI1cYLv0nnVs0hP9nHAIOkgBcTxutpueaYoj2avdbcEd4ay/e9c7tMrTzcSIMAcN4dT6R9d3DzorLrUidPXsz6/waGwJQ5pdSgic+ShACJRPXj8sUJTnpwPL0pXd2HTq+a8VomSDUc3oHryUeBABO/QBBC0N0Zz4yTeifzu0wWlqqWYkEtT/QaZRFfXg4AY9ExpMFveIwOQxs1mphmvNcuaBRRk4L62ye4PXVM7wDN0K8WzbH3jOMD4OVB4Xqyww2z2ZqnSsJm8UqSFrqaAOsoxqfL16ZQEehPJ7SHzjxu4PmIbMBn676IZkqH2bAAU+YzQ4fOAs0mTVZE6W0PrPcQZPOjHyx0w9wDA38ZQAANGjntCqWKbww/T1uGh6Ludo2d5r43IgqGsehsCJZ5AEM3/AN/6e704Jn/9gmc5Agphpz/DqyP2AbbJhDnSqYAUjjcZ0B3on6uz8inNizdfeLFE97Px61R1xbUatbQsQBFmufo7xQV14w5BC8bHM28g+1nWjPmRK9EgBM9h1yeABV1lKxczQSeF+n3dIQgkn1gZ3U8DmZeyBtN6SYixkoAknf7yEDhnGmXif/2iYeP358gSOkxGvotEpbh3X7tTAAqSKEIY+vDa7W0sOYH7m8EhASwiYg4G9iPRc+Ii+crANghS1pZBtzG4GsMYKLGuGcwT1YfOlWgwmA27Q9+jBkAT4Fvg5YOPB6KX6n8/XWnPwtyi2uk2t+IcgXQIt64vQCoDEPwx3lUDR91C112ZpvTj824kodVZ+SQwtRDwAIPAHhdUDrgsYBNIBEVvNOgxem9d1LyRvb0C57kfwLasS4ASGG3IslAsFizXr4oeFY+R9zr4gCXI2nwLm/P624McwBCVfnNL+h86iOlCnHT5zcauQuQshvHinKp0Ofyro3zAH4h80/LcWBgmB8YSo+31HZtN+c4JrR9nuXNYhqApnkAVSZvy/lo8EHhnLeC3ujsfVD1R/qIDRrO5Sp4xYxhqwD+kOx86uGzg99LpWN9hI4UogTFT+sv6Ka4opaOPPrHAMZuPDbVmmqJLvIbmTPZ7tP1uxt+gjBZjp4zwAoeDy0A5NnIv25lDm+ZtzZOlZV/J9XuRbKvizRuUWBopDWNdgBkHiKETZFnl6gUb2nscu/jcEnqaII+Z34sEH9ui7wzAODuTUFPKGQ5Ea4XqkBZFw1Fjrh+oWFLEd3z8cq6FhAAn0tza2fNearNZjAXgbYbPNIAeiTWm8jqDZL+orqVuQAdbfHqIb0xPCKmfpvqRqp4QZGN1HiKuXsG1bOfUSRCAKL2yCYw6vAq4VHuHexCnrCV3+da4jzjuf3W71qaWksAe25+6uU64GmyRnZYZ+JADWHhOj4SBDzrfhVTl1ZM8wAfueaQFIxs/X+rrDvKWoX3WgdoMcurxqT1F8ftBDLpAIQ3WARqB+8eLpCK3c/u/BcbCnr52yzGcLAWfW84MscA0ZlHroqu/9Ybb7UrDZi1QX7vPUXV4rERYP47sIXRhQBG6pzGy32dqcMa16FDg2DLIOtStQ51Xsq+bcBp4XEcAN1NAkrcwuWXvM7pZ21i4lgd176wFx1WOBIinPi3KCMAivtlapoCeDBVSNeqJlUIXoAIo1LFubRFORs8/LnQkABblS3/lFtrS5O5y9SCc/mJwAGE860lJiI06WWc2I2tAAONTGlzMBRqUAhP/aysNoKoTAiSD2ECf2/ov/wPY2UAgmfQM4cR4i+m9qDiKYBggc5C3M+SnaoupcB+fCFJwQAaZ+H/O2ykm73zv62tpKOTuUi01PAZG6DCjct89OWYAHyaacMDeKwzVtEe2y9t6yEreW4LxmuextqF089veSYAJibf0w2joBsC/Lf7XIRzdh2BE0rsak/FYE0S3CNK6QAt/P2tXcamFLU+Bfri4Ech5vbdY3aNLyYR7mR7+FSGAB/fYpN0op2XbCVgW+yR37XjbNzgZybnGJfgrGYbeSIAUr/bL2CZYo0dpDWpfaNy4ZAFcbYo5QPsWG/x0/uBAQBpaeOHbL2RFd2Ws9xkQt88yL7MzDQX7+Gyf3fdhPDjAHefGsLcytYTC4EXnRT5n++e37bgnznEQOp9W8jdGVYARoypX+bUv370uuaNvqVCV6dcXLlYbXKPp7mZsB/8sgDjUUPQorL9Bc6NQBZGHvlGNnujluBAYmuixrpHmHZZALeDQT8tzAxE3iKdXRF8g7PIr2VHC/o2JmzYMz8Eve4AJaYz1DEjV+dqokzX9SVPBLp3YXohT8P4iM8YYWNSfQCRe9CR6HVaBXTdEgmda0kDWHGb44/BEzX4G3uAXHQoAK8uycioYTTjp/3Mjxc1yYJ3ZbP+QcnqcczAwuJl1DAAfyXw7ci/H0zMaXqyi3/B+F5FIZh68Ago5o/gLBcbSQAxXqFHWTqhacMQj6oPonq3MQeaDwIG/vtjRdwAWac9ADnWEvkDuRFlbDDjh87Ts1w5ccHQw7LDQVgnCf1ukDQAcBXJU+nm+D7nskm5iEzPZJLClJ4XqDNoL52GvSfPlQCRW2P5Ykqkgvcs7oT+xywFHRUyXAj4jesxkXQr25lRAHw/blZ9RohtcYt+eFxnDNRUEdRf9AS2HC1qcR8cKdAA4AOCXFHFRUIqZTssc58s3XYbfUZJAlV3sbWIm58lmAAbQ+ZTEeU35DLtFtxuCM+FrO8iU1z/vsaPZrb+wMZQALQ0QyVpDpHBO29Ju9C+/bGW6pFLh9ea5ZU1N9nRxwwAzz06bhWFZ2zWZMTua8eljI+6S38TSeBOiJPF1ROkgwA4S1KpuI0/NX77URlQlviEuCNRVGZjed7QqbFr53YiACHUxJGl/xwWI+Xb6ZYC2/ZDZtzt7Ysdu6TX4UCm1eQAUYYMq3NzaF4MRbC3gpmdab/A3XmVVjv4MlkyhyhqcwBf1uCSDZtUwfDyFgNgW6it3+fNYIe8dicH9LsE/Ww7AEh9g1v2lBJGvJV/YRiX84CmxkRw5+3z1kt4V8BgAhgAdznyGOo+dN6zmO6PnSBXwXp20xQ48tdgFe5WUhYBKABMHqoPT63W3UMGFYDHPMvIDVySvn2/VwQZadXtLBkNAEdBGaD12cpz6fPwP15mFJk8CERPEP5Li83uF9NnmPcAfUvEvqd+eBqtEkD3WUN+MZxpvdqJ1fbEclxSkxr3QAB2vEVqBMNBcS9EdieG0Rhwwf7WEKke4VCTGfnbixgmAHSJ4gAPvXTGLv/p1DXc5OAKtGfghDiy39ectR8QprkASo/lR7Hhf7epNXmVpJL8rJ+4LlZoo4KjTTf3Ec1v/gBmwzw2Npuoa8kg1gVA54eoyYKQ5q0iBOPrORwxjJH+AIoGVqOwCRLVruzkfzE1xHl7ZMI3F2MxO8JUWzZ2HGgAM7lJeIp7+pwlWCGAjH1iEluvjbaHALihKElcAFkdeABMCcciFStcJJ7IeUn/iehbzKpQCuavdJZEn9FP8j2SAMEO7NL6kEPwqaT74ITyv0bKBw+kgxzapg53/nfTa2wAhjDRXQIQ0MIkm/CpIg9pSbR70Pxqr5n3/+nLOYDTDgDnSihHp+Xz5XcoY45jgutq4pB7QrqAaiPKuPh/G3Q8ABCpgGsjpyYmCXo3i0PnkUoAE2kWR/v9nTX2W4131nkA7j0B5RuyCi32n1pufOk9+g/VVRAyboqZUei51eVufQBrghh+IFIrSKbbdwrK1mr5daVgW6+yZm5ItOFNPaspAGn2P+k8wSI8UiyPwv4GPXR4Cd3r7cQO8c2csGWFS78AeHGj3cq9JS2YhKGaid9aTFMHhyDsyfWBHIoLim8bowCW5Fq2xtmZ/7ZFEh5fj3pWf73nEAFwr1kdTNsKXW7FAI3OnrsvgOcNjsrcRfXRHAupZxdNlsU96rwn0WoPdYQAnv3B74dnF0EsdoIpb4omoIJSdTa1L9zs0MLRhP3iPgDTKpWkR4Jw5r8Fu29FM4EEFFJy/lfs8UPOj4GVbqIaAHiwLxVjyVzS4t2MCasstvHDtR0i+hJ5DX22QB/BFGoABTm6A33Xwd11gN9RuhJ5VniEoPdnd13D2qZTl1Cg3ADMQw0gbY8a+lcVvCp+4EdUm10QXlJkxxDTQcYPWpk8AB6I1wxmskkp6RCaJjlo5/tyNmEWCQlj1ybHq2bCWLoAZjK+u6qdIsTPceAgnRF5LPXlMZmHhnsqQMb9FBD5sQAqXd0TchN+5PCa433NB30Y0+Qr8aNKjuNL0Y0FJv+XAA58VPMLGEizKvkWl/1tLA9tHNKPLcDZdpFHytwd/NwA0Q0IaAfXUGg2X4IukmD9uQ4lShL622iZteFCAIiEVwBibYsflV46LiK9kXJi/Fjn8L4EVoau7EMH2xqAvwOlAN2qal37rfcqNQUH2f8kCZndFP05kEccsgATftpxuLMASAw6CaLtaoZO4kPolc7U8c9t0n0xhtif4pBq+jvhuQBg/UWuM2lNViYuvKTDVeOXnCbpE+JWJafZzr+BoXBqAMZ3XvQ5We9sw3F3fNelaR2rE+oobFJDC2EFlScP5MQASG6krQ8vUcuGaXpfZWbFV6vMUf+XZRvjYG+yKa7WnQCN7qLh312KbelmaMEPBnmMiJLotBVDZib85i0JN5vCANdcdNoXSxhSjOAwQuBXD+8yqhcNeq3CAZVYogYwm4AA/Ajfrd8NmJslQHs9+ymNe/Q5GVFBaGbw85nTOlWqCAAFcqzPaCk+49m2UkvDaV+mSUtLj+AgURc9X/78+/jiAD4LqHjfH/mPj8mYcDm3x/gj64VOL8Y8g96D1ecZ+GMAEnao2427a+s4yE7zSJVW59OrmCUQLHipgVRP47EZ1QDBQ2bm3OXu0x7lFF/fWtbiNNqizVMXGkONr3c6BIGyAL1Dd4bLd+ezLj2VSTBhZwhwfUuKF7SRjslgCGcmGcoAVnV2xO33hfqko6ImcEjEw8DW3c4/TfV+FCx4474jmgA8WeKQUcOuuZzcjYgelH04+Bp82ot/aSbzd9auin+PAMMFzTyYswYyqxr8DNKjAXJlLKlfoBHfCI4smMOUCsQABUV8yv20HpV6shmDgEnxzPQwJC2vZlyMQ+0kHGPufgC8iIBEwIp2vm7x60FbiN+eFxLEtyVcX66yI4pVldAwAMTlqpED00H0XONLqd9wz7u/edrW+LoO2+805E8ovWwA8z7AwMTZdIzzaWmu2VBQfHtNJOZBbHfn+XFJahBEjAAQzzMI5DdHzPOupKwXabmrLFSINkoYngNa8AerApJbADxjn61bInfHvFWNnY8dOZg1WVs9jViJg/LSYDRPu9cAAHAzcKkM7qQ5YlJsLqi/jOQBmVYeMEc4HllPnCvDxwB9Kxm6rxcjI5GrSylWTOuI3zkY3aYYWrS942KB/TYRAH6ms/5LYgRBfeR6F5nyupm7u70B96+1WjZvW+UO8e0AJSF9VCziveYyfLRtHuIrEmR1TBCbnMItW5s3Ntg/aADJb2WcT1fo5wrjC/rCMk6kFF/if1LTwW6/kz2y/ZdPAGJzqWDajfYSAU9Rs5GbJWkso1EgPfwMy8/5xmR++dkAskQcYPePu+miH1dXaaW3YMlt8fAgfhzUK8vPJJu3qABn8anl+fEn+LxLUkbOQM/uFvkQt1aJNuCum3JFfMEKAOoMJLSN7KxuAznl2NMRl4w4/yk1uTZ2RRRIYyeWi+AAfPnd8uW7y1lAmexn8MG8MM8N4MczHXf5VbZIIhLm7gC0aco4vWqXEF2jC6kkZxEoU56wK6L19PiOa0QEoWeMAE1jRXKZDj7oO7aPHyoNBh/S0f2RkYOpy834BvLxwYcAT0giOAwkoFsFRewSOuXkeobrKzKBXVt1UJ8HaD9q2wCs5EhbHCJBLz9oFRY3VXZuNPhYRM9zx3nSI3RgH9+GAHnIgxEbBlv2FoZEyjzM4gwXwSfBrn7UzWo1oVAjxnQAqDJo3KQWmSns+5aBiSRikDQbib9n/1z9qRoJSG7j8gCVoJZVztHJ21ZHG0qjGLZwE5Us9kARngEc+ewzfk6VABQIINRNRc5s9oUxIQKZ3jCBhCm72HRzADIUlP4TT6wAkNBDIgZz5ZiD+YIHr6ijjsLSFKfj9fCNp3p/g00zXQCnEV4sKSKXvw5eCM1eOut3CtCV794SXMI+xQULkBY7AFHExEcWrWbNz+wDr1Uxg3qloA2LEwASjYcWWrBeZ/oAPXJXc17CGqJStnenqpj/r7DUIs+Vn+K1sar1GxtsKQBFD5TJzfSABYUAfPebl4hC4vPjHoioYLYsajHdyYUnAJhEdq/tRGLoDWHwnU6XKel0QKtU1Eq4o497/xUYfzMAS4IGlj/8Egxvt29C6C/XvExswFwrIX+wMqo3Nl0wDgBjnH0IjHjMJvzygozbUzT81E0QLZGj80qMR8hycK6HANf7ugAuk3FEO6caTljFPyQMYizkuERnrUc5Tdih9/IAw6I6hEb6QEc8M64HIiPixc5vaX3lGMEBMN0F/6Q5JwBebs4DXPlaUplO6TrtiGc3gK8EPo6JiesGcmpcl4y6AMiwrrWdidj7z9YtisWU1Acp6u+oBhkl+eI4JXAnjU8A4Hdw0lwIDk37DS9PsIN3WEQ5ZbO6XPNFwmJG3FoUYgBXncc1YyU9iNtgU5peUB7tD6w60l7Jzsn41ZxSLzQLAJR5ct7LZIABSgMbzlhOBw5uZAlZ5/YiLtKEKufT914A+w4TuaqsBeS5J1WiBP5amVScR9AD0KZX1MHtOtPsSQAJfTUEVhKuUgwB4On8PW6AP99ljqPMpoTDuBEunJVEAJC/q2zXGIJcAEPYFylctfjF9uycamhhBULoVlUYoJAAmJPcqQo+EiYyj6CyWgn7APMf9HlOEl5yoyprCMqh+wBnX9iSE9qdDPvWVgDTwt/PxSgSvqZfUJaeiMrsmBnnAEEpf37A89+HjT7LHRuVPLqOhK8kWAUfi8nc/2oUm3AADSQ6hOzANG4daF0Z4brcxUpo0Ss8VE+s88EcslMykQCYbus5rUp63TNK9RyVN6sVuj6W9AfBv7n4fa0g6gP5AG73J4ThM3gwC0Uw1IMOtieqij/W0chTMRwp5Wczu9IAiKjv70OVRqjkbAkSX/cPJ+BiQCtG1kRUN3R7JwwVHAA9hDDFMYYkPtRmpFOIOwmu+I0Hc0tI3lzpusSzEeTPAIr0XLf5UnKTdTf4zGLRdvMiYXTwBGLbGF28++FXdF0A2DcM5ZH63daSNigAGH4NStLlXPGiwG8oEzfKzpPY5QDnp5OaFIb7UanLl4NzFtHxpDcYOPWcYc8YAw4NH43rABQsKgWLSmwddUZQs7nqqASmCdB/lDzOvxaraNok3xsAMp/7l5IDlAkuQXIYvocKhNO+y3EW5DYnDelNrRh25QAVu1V/PQBjlVtxDzDnrOA33hz7gv3TcX4Nku2sdyMgANhSPfAOFawTEQXTy4iBqOQAy/Txlb4+72bzXla7iXIA1/j3jiP0MKz4CEiuWLvqsvJSaZLzCd1imgi3MJe8XAD4j4TWj9m8a5GZW5/JVZFCPTf8nFuz/ayR+jiWYWT4AC+xS9ed5FKtTY9WfnVVlr1SqbH5hbwkjJGbqWBIkjcASoao4KTdXtTmB5qLR8SyKga8/A9VmnzeftIDnLrWVwB+CeaQMV1CifNUvZYSiJO2D+PEhqQrgMadFPvmWq6xAPgoQJJNNP6etqKUxYdD8t4Wls+fmvHr1+s3YN+bUVcAfXQv8e1kdRs9w8X4TBYhvrIz6GsMakNmFXqUjZctoQAtmWb+9ndRb6svk6bR9nDMf69knEJ7nu5ag/+e8hl5AFtbK9Azf7YuoJG4MO5pxFQ+A/sJA3DuWbXq8+pLG3EApjCPywXRCGi0YQaEd1IyVH+7dF8CzLRsLz5g4+tURgCStsuiI+GuLj7SVAeTewOB3OtQFph0GPxcRHoc9Oy2AOnu9Kv7VwUEvxVzkpNFG0qkUwGKcUmyTbUsg/WqZkgAX1xr6nFDRy34w3VOmwT3RQ0D95oizl/6PuXBP0WxpwAv2GM95dkj1ldBxXNrO1/IuyNC3sNmKKuo2r571U9NALgUwyBGNQunWoIn1wsP0c30Kqpa+jKa7xxWNgqJv6IAhMOHTC2FNH3KKmLiTuCG7wwoTKS0F3WchBr6wkUR3wCKOfkX+lc75l2jeesnTojhA6LiAn8ydYAytQ/x5Q65ALvcBcKVlVRlBEdK65J+PaIzlbgKt7syziRZMlQSSaAABl7zbjoZmNvhNNkHfWv9C9N1jIMFCtCEsqo8P8bo1QDlNQ5fk4THf3snRh88Pvvj4vW5KQMsXuUjYbV/Yk/NAJrCDEHpdCehV6qBtNYFy4y/lliov0hOoM7WbE9JCWoABiiBg6C1OYSdwRwTqeJM64SdnXZDrQm44RiZVpBWtADU63r7Q+E12oTo/hry2sKycvzz5LSaSv18vFxtrxOEALvCxY7lMqMPReDk/9I6MeMTcvrUMVxBy4eJsGmoPikAErpmZQ35kg8SzSVD7UqJx9WtH1AkmXZ66ufb2nw9TwClJ49T0DgKsP7rth6LM1dX8R+NsNW9noenf6ou19sHAEciFBicPowpMgmiptX6vKg7m/LPU6mAy1mMn4nO2y0APz+dLgq8JbZTu20oZtd7m1HL+6TzvRy/kdVlGzuB/gA8vGVNyoiYYZEPZrInlLQWJRv55mhRH3kZEWbAvLV6AMpHtWqxSrdwaRvnpb6PTN8acxkzVScUSymftHdiEHwAKmCbm9hdFsVtX9fZ7vKz/DXDCjM/kdo8rBEVkrMnhAAaKQrcjuKFYCWAiEWD6osjL6Q5HBlCDdly7Gszr2arANIf4sS+r7qMsGxTq1thwXDMki8RW76MceR6HyL8IckAfZ5B0QQNmTFNyxCTAQTp5IkO0xJQHpkd/seXccB9CACqLMJU6diO0fqv5b/5W+4O6xWqZ79UUtb4IcRqyaffABLkbi7LfwuUCvVmSSsV0EscORK+KH8+wR3Fipyd8VAACF30BqMT+5Lp5OGnT9hkYRjIU/9vnYzGiAG8pXHlzQDrDpMOCfS04sFf7RtAEey+E5Ol84wTe0A0+75krO0mAPvLUj/d05ERRrxTViMLqVfPaQ/53EEUc/wx4UjbCN4A/djzq2T8SgOAL7vJAHdhnAlVU1mMNbTDek5mNII/mAAjeDVO+kD8ePXuTS/GOXmSzZs8+22LcKMfWin0qyfnAOmS9rvcapBZz+vpYjncrjyo9J/MdnquN5ojYioYKYsATV4cPImegObmR+Ns5u1S0l4jMS96wdWCMiRCV/fJBAAu1olXrOppfdl1Y/nc2PJNUmMWVWsqAQ7cFu7vlqKuAIt+86Bmf88w72JCy8MQuKhWnwn67c1FwgZGoEonTucAy/Le6cv5BzCUbIMr/ks3shs5pHoHgecmMFAEt7doygAD74R0XWmvH3VlxS2APF+UCud2pKNWguQbFmMbqaZhAD6CYy2zm0kJ2y7hPxYg+3g2HLfvpc2t0l/HUot8ZO4AduvjvQDSlmdzepNToeVxMazZ2SScoHsc04k3bjoCRQCLIZIXYRqg4N4YR333dOnUaX7ju4j2EqwG+6522L+yACvw2T5++1orj1MoRMarHQ5ts/e0UEEYoyVon3OqqXEAP+vv6wC7U5ZTBOFj+D5nsIH43Uw03fynGzb+64mhFQBEGtRnjMPAceR/9+s/RtRGfp9ZZXsgymZBKPsGc98iADFQ4h789NNptQ9OFcAtfCTNziMehLekFKUqbWkGRIkAXxERsqRGsrnhzycE13gxdg7wlT8/qKqhz/nM0kGm7wCPZ/VTN24CHmQNHic26FWULU7THKH788bDVGJoXt4wACpBTZ1odgwjIqNkwC1yCqWOtKuy5EFMybgJFOf2nyEA9JwR1R4H8v/NOI7oc2Tn5l/f9OJSA/3xXyeMRWhqbADZRY9p23KY29UJqEfma1p1K6OOuiOoVjCan12aNEFyADP1iBrzCuFZsuWwmRTFnVM3ZjHWCTJVfLPUOY5RLFoAMn2zX5Tq1/vrRqfwQ22ptrq3QxWXzfWris3iyeJeWQAfqoEMPicREinMCS4xLzNqmhonzF40M+mmrNTjkoYWAOV8rDH6WRI2QU4gb9AG47ZCgy8IE9mItPluWALSmC0AdF38vkCK0G/ZpyM/w+gwwt1koU/+ZrVCKy7/1QpSuAAgRACN5/gc1TpwU/YqGCy591tWDNhfxZY7zYDwFd78ABB9LPAEAuWPIlgyg6YBG1FeXMbJWo5kQIEGTmI/jGYAFVLZfVgBFsIiGxYjd70T2Hsp5Tk00U6uAmIH1iUxfQDKuOZMNGz2DCtZ1lvM31bBc/M4xlTOZGSiMELgTh9YAHSS50C1h76dqURUTv/OegYCMEpKGG0/icHN1q1J6IcA8ZVNEMNrC0e0mEqIGuMybME+Z8E7YOD29t0Yy7w86gC9jc/hbkwWM9MjwjCaKCjV7ftwQ9Bo8b7Ctu9hPuLpAOmRd6ik+qR6NjZkFBYGZc9vEKUhoUzoEYUoLenJEqUAd6OLME4np3QLZxhuWHeuz3OLoE0YzkL5MLqyW54QzgA7ahcOYc8QgOcCtaA1aPidWdOnTTMMxlJ4/3koxlxqADvEs5mX72FxY6J1dg0mboZ8KYJfbiw0FHdLUvrBzDAAXA39Su1Ykw6asdBddxWuYyOI793Uc8BOCf9cdiI5mwA49J1B0Qgq9W7XM6NfJOeOQVPeCiocljrgwUoV2hTwAAW53H7AmCoTNM8ce3NYKoQH5XecnjWZNly4VOWqm64AKTbryBTcfKIxTP3f4Mg/wYUsdKo4/l9SMQKdU0WMWQCzOYml7NQ0M3E1dycSoFGaSK/xq7ndtibsHBAdfQvZAHZ1Y3ux4vV4QoX8R3+YuGzaxj9RtGwoYsq95j9jlaYAiNloNoDcCL0108+e6pYQa5yLKfGKA2KsY3trd1Hf5gCNOH1ER/FaMonY5U3xaC3E9HrG/q+vGYO5Q7r+7FInAAN2qx5khy//+tkOSjnn4+E9bk0LvyZAI4DlC8D33nEADqMnaGIiupBH2gvimm0qoEESStgiXrCSZbR0TY02kgDS6Zo/oXU5HTLxJSLNOSRqrQXKDhLgiq+t3YcB29uAAPGsieH0f9uJPwcvNinTnhr7Xh0Mjissj0z/obMc/0MAzm53t4oNN3c0KEhE3lm7nqA1FALmfHwWrxeS5uiP8QD4CNJ+6x283HvCVFpCQPc15ZGLjNoVXnMsHVxbL7FiABOk8RDWGiDqYTAsZt5q1F9/YhPVVfjeNAaGqPwRpLEAztoS1MuHDc1PQzJpxpNzIlcp2hZOGon7wYbVa9VrHADZyN5vUnzl69QIKvkJQfbp5cHp94i9NcDGli6J6Hf2AH2wTmcK5dfduoKvC+kuZ9lzro1AJmpLCteONEp/MkAAs0tJkSMT8o8tpeRNsCqhp5Nlasdv+jwytBGdCxGa9QAL6wTmbSj0z5AwU+qG0zNUlxQJ0Q8fTu4lGhMU2ye2ACSmsUArB6GSp0a2gcMNNOU+XcARUm8tjwNuzyYkFpkA2/gtk6KhLfvUasCXXjtFXc8m2xI28Vlg2TtBcdBZ+QCJ2RfXknXidSPaDhbT4j+R+Gh/tTWVD+5s6N9zKWDjAJiqnT5VTHCF2iKOCThVhJoy/UHIPFyNkg0ItITQmEgAnLFPMphjNeiF1N218Iw47k6YSBY+rPrPi8UePmMC7ACH0ChJQSg7cSn/zYIyVJkP6NBuK6s0cEatnc06l7l7AKv4wEGpDXeTbKqcC2qNSvbloO8dNBv3iHxtAE7mlpMAFLNZ6pyoA+Gd1s+HTOmCRLHJbVF6Yn4o0cfJA13IPwAXtq9TgJ3mURPHKY75lq2+zJ+ajL7Jl7TAOLD6SJ0lAGjHyz8IVD/f4evt0ezNamf8zLRYK7Ha8gh3LkGp9XQAVJGM7umFSUUiGLuy1btx6POTMrd+4p82Y9D2Y//uGwBxNOXvfkfE4aPDEGSyrQWbxpXF4Ny+V0x1x8kwpNWBAFXdMpms1sxqGIw9tvo+dlIS39JE116y/c27ubvSxPoAvs76uzPK9uv95YbIhDRhOjd/p4fa5kJ+zlW6m57m2gBfg7ClfAv4S0SyK/Jz+MTH/N5T3r5WtVJgOK1M/rYkAKXBkq/mCpfU6ndjVX+mLK9TpeUUBgnO+Um4nK9w8R8AALE6JsksRFYABzckhgLBQC/hJK8RPSOU8LTf/JUdegDM8vhulYTK9fednuDThMM0bb1pubt9pJOYObzDKjeOAJcpdhPI2nTruzPKvokD3nP0ZT+ilrgQa66lKxclfh4A0XEH8kaKxBX+A6RIAZKY8SefV2yNw8LuofBiSiesygDx106LilqSiOcnuejL95ZqrDYpTBkE4HRAVhqeemI1APVwwQ1cB+P8NOuRStDvlV+O158Izr0LOS+ilMpzyRgAlY4rS3wQQxXYutg/oGdawSzOLb+/hExq3yf9txyjGQAv2taGHrV+JqSB2hcipEL4EQHFn0k87S6R8HnLnfQzAPKrb2vFcBYXNvb+G/D72wNq2BYcGfMJGeT0iBNpmO4AzjQvD4vES/dx0plG8U2xqVispuHJbZeQ6Y4weKv90gA6JpaOSBQld99xNDBgbz31WMilrzhqzHaDRKDlk7+AACtUucUieO7tmOlGqc2QdbkoUX9/uRfabY1qtmgOsqMA1y6E87y00JOMS9o9PYcKf18b/++56//yuYg11+dgagAYOGMzKouwB4M2bhiLC22AIbdkkQUJVixlanQ1xxYWAJYG6kpVo4xnCr9XYgGviF9jNx0EP3g55XtjcrS4DxUArotab4p2qfIcB5uowVMQ3npkkiET1bcnxL6EQFGIBgAwaZL0324/gT0LrLG/ByUSWVUXGO7rtlrkzudIItMjAJb9GZdS7hzTIe+BMKU0JiKd77BX9aY63ZBiPO1wlpEAtr/OapbsVmpDDcsL4HQzxZ0vdiUXD4nZ2gGBauSoNgAs8HEMQeZc939EApzaB6L53fxKjI8BJM+SjGP6eeJ6AMu/hSU2THxQSIM9nM/l5famOnu3vxwDmHVkg4sXtokAeilzK0M3UBxwoRgNwNe3b6kZT/1miWeuu+4GWF40dACvrah9FlFZRIaZoJyeuVxVYRQxfY0BxpcBrCkcxvFKAA4HEGnFN9wNbL+WasiPx3T44/T5YpI1VV8s+zgwMfMAXh3tzZMjublFQoeGbUYLLYvuEcyZ4w1wDOjHeenO0gCrGqv5ry5T9H3kxiYs69RcoMnn3bCqUV2KWoimKVxwAFgQ0DDvPAyam4d/Y7w9Ydx+8vmlggjS2iTk8VRuytYA67OCdI7HBHgLi0AInvpDHdqIi6Vr9UELAgcaHMYimABQtOrXmJ6waW2k36FJwpAvgyWXEZhwzBcpkRQX4ezwAPSndhI/imNLk74AGQlr3WirQcNiNJkuAZTEkausPDwAAXAwo8f+1GDgZ/SFDGUcUtUgYkTKMo7+fiN01rxgAwBAma/37KQWJ85FuiQPHE9tsOk8TTYTvElePtUvKlLgAAhNHI7udl1B7yn3Dz3Yl5jhaARy+2UDxXoQV1fOtegA3sr3DQC+5Vxc7isk6CHbFwIqehAsPCMbUfqbDF+rYAAeHuZCiL9upEvXEQl7rX0N2MXmnBvGy5jVuLlYvcBjAN2Gd+5GClVaJ9kv0Anv9XSqSo7behmaGxEwzE0ufawAz6LGBTHHrXEDCC2Q13ZJSQavPB+aegyavVZCc2rpYQA/H4WkIkUWbIGYtCa5EouhueB1KXSoovJZfEnPMhpCABaJCVhW/K0HQxd3OPtdZ3sG27EhlZcnh4LOsNFJomIAqDawEH4GoZTLDawGJUC39FT6xAfALjp6keTNResfBQDjCy7jSHNV4s28bRVBO8qWG+EzJbe8MFNTNJ0YRGtiAAIrMy9OoxdvknA14JNONjV0V6s0sqLagL3jUzBU2wQARjz4Md93rF7yKV7Iovt6ArJr4n3pPqR1gQsO7quUhQC08Kuj5tw25P+Nbq2VkZsv0vQsdH5GothMhiymAuVzACA7asIoJsABEDMORlPiKU5rTOOAg0hYX0/pVWgwEy4AegV4QzsYmAAJ74Qwxou8GgfJ+oDDoZiy4imR+drvbgDpIOP4JS3cgTBVY1TlM4fjYspaBTtgTedpQmbkn0C+ANKM9e5zD86JVDPoyQxjT6yPWwR7xx8qpPyWVKx70SYA/g+/kjMO6QtBhLEwfE55DJF3ygKMura1ZWiI3lZFLQC1IT6gfP/mY2zA9qbZYwTKXF8Q/dS256l7/f0OW0EcAAwuGtA/coqatxQ5LQJg2pvmGV9MV1ADjlkkMlITtSsARzmjM49A1P2oiMSTldNP5RLzohFAogSU09mzGzm/rwCMlu3QcJyxgJvQT8n81kWadVwMXi/ZluzE5mgSMM3BAEwTUnUS7lGI8OP8ZM3zNBZQoS0VKSRdAOFeDsxKCPUApGsfKWfNSbQE/0mu8/r070Hb3h4RF6o6GGOOwBjJ7gD1XS/CQAefr3pP7q/Rp2oO5cf4O0dCJV5Y3cVuK7ZDAF04ZuD+b60A7r1agcZxUiCSst2WLsSMnrINoKH4wWsAepG9632MTwfLw8DspGv9DBbYYCmDeBGv0bgCcRKbXgBFFddVoBOgYUBsphJVJfDs/jVOulyWz3NVfr15GaDIAFoktWzCbMA/Y/mnq/xaDcT40KovVswYJ9018htsISoAGH3g2VjkS9g49BggNgDWBCjcLXdmVfuqMfVHiTAv8gCgHhCPTsSrzllzDg/XMMhM/TYSkWsQMjDVmYv9KG8sAKy/rdYypK1t+Aw907N+9h5JSnFOcsqJuK7whD1GoYAAXXM06/TRzdbb/2AtkDhpUCj9bYnW4pJ8uJzpppYbJwAOoC+vZH1Y/wiHb0ozWjYW2EzCvLksmvmH7+PlXo/mAGhrwDPpcTiBJfJr5BJ3YzCwcOFhua/yQ7q2yW+xqZQA68ei4jIe0uR2hF7Jfjo4JOoD/rztQDUXL6J5/Z5JIACxboSlz0BESbPg2O229K94F6oboqvruLzMclpK5XOAABV0gbUpXEDJbCEDkJetb2bZpCnMs5dyMFxtke7x/pIA23R10o3HyVMl3f2AXT1el2GPP/6IT8IoKgx6LNIlSQDZp6rzwt7ayvlRiRKPaBf/YHNvyy27vXCfROe0j08IAMolwRQObS4SJuj9nNNiZKAWvWO9KHwRiaqv45bzTo4AdmmRZcvQKn0pbKOxn1A00itbP4bUFCuKeaIeGnexwgDMwRxsb2W/iGfmieNViglhEpBrxQKg56ucLmUpCxgrADA84viayKU3fpujmN20BUbKs9yzFoh00RuLv2yVpecAcFC4D2nQC/aIX/A28zveaNMpa77xDE25RfIF8SDkxwDEjYHmC/yKisslCIQr9gKPcLZC76VlS4bIqf5HQlRBAA3mPcNbXArzg96lyMPb2IQpAELT/u/+5rL5q+OJv+AAMO2uRDVhN6jUBNrCwW0bJ8o5dPiPLQdNZmapUrt7/gBE0NRo8BVexeOqa4TjdtKPfsMhBSjjAzhsX2rFtVfDAF4SpnctzGIBr6ZaTtcmQMuUHSt1UL747HSmIMxRQycA+8rycHDMNEdthmOXX3HgEGu6LJjCxUQJntr6ybDtLgCUjONFqqDCCsvrNNEWXWT3V7TpqLssf2cDMBNHQxo1ANG/NtG9+KMrTo8Til6UiZIVoeUEFYZzdbfSSkBVsxMAeMjUjbXbM26lVE/J6yBJlZzB6EHQpGbZ8B9Xq+2TfgBUoM1PKphF0YvEQlL6T8Q/nLPUKDJ7yBBV8HTvyfOSAFy60w80i/Sqq/EB2RSqOup6LSLuuuwN6PSS8bq3CXoAGmJg0H3qHvXZ6QEyv5yZZkebIhSF13K3CQAqchwIawBmAr1f5Qftlv0SO32qAOl3Pxd56MIWxXHrQMsl15e3AMorct/GqUgBAzdWbV+Dz/goNNzuHIoLWk6lNa8+iugABZ7KYLMbIVAnZHQUfaZrvqw1pJMOTXrIRqGNOrXZkgCMbr1ZpGlQ41X+i53U96k+NcwNQx2d5vL22Ru9WMyNAF3KMv8IMsEJPvFtbKnTLWzOGQ6+Fycvx3jhn3dmilYAaWJaTDbxHWf56SDRXcRnOQwhNYyUKozD/V3lE/C8ywBLHHCTG9aEhpRaKLwT5GYXsuoScBwCcqtks1heGLYpAFkX076PK92i6OeuIWfNJ9eCREyopXKcOawByuRgRWEAeZAyTe1Wb3Q1uUgc2nrG8Wq5vrzjIn1w8OGxH48DxQCnTtiJcAK3Z0SZsWOGd2Yay1LOj5Bk1rEEQkz0PX8QAAzmDy8Bx5/tafN0c6JRoxgJkZOUtzy5mLG1yVqFYS0AIODVQbsqTX9+y+w3y9ivKhoq/j8FsAiRL1cZNDxqvgBfn2E+G6pfW6K5UStmaVGzhs4a4b6nDlwb52jXSAREAKOmFQt2SNXF8fPjo06UXnMKQE1k+IFfH9tup0LzXUEAoqBNn0L6mmrYvEQokFjiqW3Yq5LU6F9bBTN9TxO3wABKpIBlMIbG4l/J/6c3LduuMpAhblzEvAeu9/qlagfzAGWXHjgwG7eYENj6SUcID2lsDqzqERvLoW17ueY2/IcA7n8K1dX1AeuqOO8QrVfZIk0R3+avZpVbN/GbTJU+pADlqi7xFSJRjWqbF4U4cEUa1MuYFI5LG2RJyNgOT2/+AFAauzKFHOazxbGAkS08hIdGAooC0wHufiqwPr3v3YsADvA3q4Si3y+RxWGpxkThkffU3fj4SU35awwP9LZwcQA3K88hp+IjGP6wMui4zSb4E60l7ScFlf16EtkR8XW4APC071a6HNzdT0Te4tzdo7eXXm9vEFoGqsq214BQqhgAcibEwTkuUOdSInNTd1qMsg65oeG7wc09r7urg3B9CACdnwwvQAwt6X5jhwnw5AZO4iqZBTiX02gELD7wXaQEAM/RbPfsPldGixLXEhzmvRYe1WJ5kd1UmrOc2bU0VJkA3AQxowbdHqm0Us2eV9CkY21lT0wTbm816eINipjCwgDfG1W29Ro5hm6MobEJlViUD3qAyMFUQFPTccsDVhopAI3rsRlb2fPFBnWrN5WcvQD8xbsL1kYxMN3hkS/Neg4AVWgzW+3AGkq9n4ZDimMe/0cG3+HBglXeWbJOzqZCAwBne30VvU4oRJMd4DepBWWv3pa1WhGZ+VN+PkbaQ1O1AG/LhQtx4KY4YqOY1YFNvOwjXwRMlFPy+4x4hPUioSQAefNCxAkOWqx2X3SoHTgHv4dVkeSzwtvobKxAnvZDMQBblOO05rjZNSVhKbQmcNzPaRfDRq2PupiaNaZb7e6VAH5m0oEBKXPiWVkf4fU07R43MtsT3BdH2dnf47UTduQAk83XLEPT3XLzUyrFAMeXryVmE5dpDf+h7UNivmf1pwBoDSED4oL/WpFzhid+FFsGGLWtKJNDZ6hf2OmYxLgeAER/qzsFXcddL64AVDyxDVJriahhpN1EETYLqv5d2jgAY0C1bAwl8VRr+omimWDICZWCdM2KyaEmZdk2Wy8uzwAl+wVyp4U0iZIONt6iN59sqL0a3Nd/1DD88ukOTL8QAAOnU6gRIRTfP/BheXdP77O5Bra6LzeRXRzLr8BgdioARxUNm/NY1tfhUd1blJmH3AlI6IvhGznUjGnCvZoNlQA9h/gVMJwzwq2mStRCmFfiwrUJSuumH6VFIJi+EqsdADNCT/9U2JjahGCcfFrQ318CRM+gm4yem1M3J15/EYgAQI4pAqazeFgKkyu6KTGTR5xn0hNhM8js7BwdqouItQA8iuqMro9j09CapidP+Oi/wlXe6hTB6Kour+uSNzu8AJGbNXyV2cqN6ElxgEEwT8AeWKZRaRIo/kJQOd/j09AASqxqvfpnbLGdXyQxruNxVl20lkv77G3j71JXE+7RFAA7BojPPgQhCadqjv3R2EmKmKA4pZ5oz9dPL5uq55RNAGeN8HzDpHzAau4JJzwY65Ju7DmkXVuyZb2jtfZuk68AAA+uU7jrFl+ZAtAvNtUKcp/Y9E9GcTtdIGr3G2Da1QDAQz+7tnL32IRO01Wiw7y4yUntsg/gg3j51VEEU4G2AM3+z7E+Ym/XFT12FV5BKWLVsbzLDsVFLxvlHN83+rcAnZmNXo3QDEe+lnDZ4V38p/PevjkBmPaCWLJ62a9NzgDjpqOwo1VFCV5CVWINSdWawPzVc5LgeqQdcfdTh+w/AAby+5LE6QFTlj7NujWs34NJzoT1mKcW+YMA4m6hVeYAQuiyMskWJhJ7EZNPJCDxyo3kFaT8jAD48aR+rosChgBXz53UjQHHpjI0RDFrgvtU4y54/8p5Gcc77EeXvh42APmED4LCxfXnrUOlH34T8Uq/ViUsP0EHMaj21mc1dJgAUQzxFv+aFdD6hUui27EvQ+Wl1Y68I5N7l2vrP3d3DQAFWIRFqarLT/XzTFU42EajZ4/kW9gIEtA0okhZnihvALiTeAs1jgBORjVENKL5RQUAGn4l0wpyKUNhXc2ycz4AN5UD/9YQ89JXQYO/pG9vgH4enfHGA28ej3MZc9TmzwBoz6qfAoqzaJGrcpPC/QGAs/a+2TZyrpMxXu96PgLwAOjtsKtvCHRwE+y6YrO+yJywMgTKhM/j4/slDLwWVLMAOmlUmmA3H/IX3MYP4kvgAPZaeHNI46jV0+q8jgHIvQB2mF0s8SbuaVq8iWv/2DTMYRRNHw6IbM0vgmw3qfPzACw1ugdqxpDfma281u8pO3KYy5CKYSdXw7BAVP2/NKsAx7TbcOWOgTIut6DYG+ACJjcRTIo89UWaOzemXdBKiwBS9qUN/tNg1n9ZfqIwcJURsljcBfn5O9+zu0mswE4cAOfyV2l3zwPe7TNenhpqQwMTVLQNCFdSkVYtUotbPLwAZYi/SjxsaHsGfTL/VYuZATI+GC6/LBU2z0zynR7uIgAxXbamce+tyuv0aUpNelFd8mreYiAK6juMZr9gIG5kAF1RSC42qDWbb9CJj5P3j6eG0NMHdCLVkzRCR7gM2vQACNjmkHHrFEtBVtSXS5T0MzQRFKVibUWGkILVYCmO4AAq4A8ss+cTT+L2jr4Ihzo89nnJ3t2vy2gpX9HfEqQ9AP/IjwEtHoW7e1zUTmgBtSnFFyUMLLKKzikTIvKD72EAet46pGYW++SpwE+z2JDBOrYWXOyVcqDO9wy8DTBRSwD3c3NklC08r+OaPghcR6Bs4ykJ63tdObGT2VBrXm5zAFbMaD5F/zTED2LHuZ4JRfZIE3apNkndcVIVMvyQJjoAH4mC9hTrgO1JiEOHJccSBiggJIO9nyDkap7EbehU3wAiNvDlXf5uXfYrnGQkL3iHrJZoM+kiXVFlL3Y/wf4iALBfe5EEXMoiAClQhoN6Um2pMf2ZeUvjtMPaSkOGpuMAKrZq7pKHEHY0qLxt42LV1kIuUiFPUkoARLVl8Byr7wD4Uhec6iuOmR/u//yek5c+ps/UK+rv9dQ+TwMbIqC5APSkz4n7/lHoa35axQIMVuTvLOrRbN1HP4czzjkMbUwAwV8PjLA4sqOaw6O+oiHYw2PKbezyFkjkb5vy7UwY/gDrk9tnXfuPinwyNKTSKZJ350wPZAjVdhO2ZgoGfdqiAFmrxANKU5KX9Y0AA7uvdn+53rX5IBFRyEVUlleDQ3AAoZZ2mKlx4XFUSi6lAtkmshGet/uqM4GV8/caNZJjXAAe6SYuNis7m7C8IwwavfUW8SgE1UyQNN6BbyxU2ctlACXJKuWhoSCrQmcW7lgtXNpf7jeJhcTpN9gUUf/8zbsA6MjbBQIUItYBIUC4PaMHl1A9NUvwrGCCpuHEpUoNRABtajjXoFge4yNUvXeSRlNR6wvEdc3seKu0h6M/ye/hAL2LoezbxoE7/Ddz7BQbkMGJX7MRhD+Ur9LjWl2jHeUA7uHZOfSZDwAC+bDIWVby8NG74plHu8GTYmg8hbaOmgBxL7BCqPDZZ5rAGzZUp0pkbL1yd9RXy/OoN9HyLTj6AC6bJIx6CimxIx6+sDt06sz3buXG7GiCJagBgF6aA0MAgnqGlsSV/cmYxG633spKwtkXuT36GQUb2Kndxq6bVgDCOt3s5ZJnnK1ct7ae5UemLQJy2n8o+vHjSAZB41TmAJ/cyGX/wFskFZuBKHPYn0EpB54m5VWoi7tq01k51UcAUssZ7xpOTVxoej6/smeYGQh1yzqujbKpkHKn7YexTgCtFZcDhfxNwMIfIkzQoh1Xz2l3FRwwuZGBlBQsLjntAMLc6ADjNIXyMM7W6Ub7MSOrfNw8i6FgCS6EJlsgO8UA0o6z0dyPoqkry+QLYx65BET6332kIcxmHAMKj2m7twBz3xtoGB/AmFoGx0E4TwAqWh2Hf8Tsd4Pe1ZqlaBlSABfL808/JvHmpKOIe6OTDnWADnlv0fhsd2QXfag9n1UAzRw+67Yl1VPT35VsO+CteQsFBHMPWzG8lOVCc+8V2wBBav0yBtrCAfFgogzypbriq1NH0TrkMY71/hzyU+E9AO0SrqtiHu2kAhHxHxhsklecPeZSeQ5H5q0Wv3gfANAAg/Uhorkc6QIJpcAn0vQME66x0ilKh9BU6yqCWVUq9wAzSdoAjTvzAW3Xtg2dcbku7YCmzH5Vdu2qgSDDBz4YAIYp9jYu4FaFKtR1KWfxGtSh6VGSRJ33HX+i0g6GNqMAX9365O2TVWJFmN4qZKoZy+LWRkE8vxV2Yn8lGSfT0ACWej8KyjLYHpQ3AtLeA/TfmSFgARkSmU9n1Tpv3cQxAAnHDL++butgzeVoCHNDtEFxgbOICXbjSiF9WIorNH8AI7k3Ir3ELfKEK2FgSil0Ay0pXm+ZeavlthQ+H2eSdgCxbZ0ONJqlFwGkWgr/7dtmdsE53DitDbxb3EPfMWVNAMwMBgj3RtXItze8qgYK0Y+ic5aanaN9fNchU+GTr5gAvck9f0kN+Orrn0KY16kDDD0HyjbkokztSPSVYbo0IADp1bQoDzrfRfi3hUPHA9yBW45LpBmPJoCDPZm2dAxKAL8PWqp9cfsCqe7bFfoXj47nJXexu4CYeLgQ5RTUTi8ANAeeSjgzW1ejxvEI120OjlrMbIDJWWxJH9uMsM7oyQBTR5ecwMPtzh2IE6tqPsE4q1Xh51SrFuZf9XtEcWSFALGeDR9DqxODwoKNptQLx/9deBuAGWnN/UmzrAavTL4A3XW2PJq3JzYlDZFzWPmTy9cxNSKUDyee6Vj345deNgAD9/Fib5Q9QiW42TogL5N0iwoRpL2kL1uTTpRNDDuAALeHwiT7Uc/8wug+S9AS7y+oVy3Te+4r/DGtMBxfPysA4u5nLmphusCjYSsi+logr6xdMBuL4LBmTR7W0mEWsgDHI/d/OYEx++14x+E7C4QalTrMF/kJUWZBrAlEHy52AAXqYl28PVPXk1DB3H+EDB89p3vQK4Z+90AcBRB8nAYAJ97wV2Stq2wok1vhGtAi3TTnMA+p2rCrTdEI0r8rtQDqQjRPrBD6i9Al/kIebxP+HclgSuCAqcjUrjDzBxqjAGeHos50OqhvSBMf7QqYqvmzMvjX/8vTv2GwvOPK2/QAV9fOoQFUtwMKPdk+XGIQnNwjBl89Hr8SfxXKfUfHagBHtiJ8m7fiYTh2E4JD2rWjJxeBoN7yAJKhHHDqdyklAD8qTfSeiSBvVlrYOfWnaxAGGcyfrLrUB+SXbpgVBBcAyo2kRv1qDuSCKgakMLj1JtM078/IsdpNddzG7nlyoAACOPJ8GP0wS2MVDLHpzdsfnU7JQ4Jj8SG/tFq1klCaAOhbFMfFWNqvKiiUSbn5c8TAlq/phFKcScHbDeipDxkAKyxv1Oh500/3pscJSMZWB9hwbrI5QPGDm2l2kEtctACf0R1tS1ICcojT7KffQHPin2Yhcx6xaXV0IuDc5TolAJCUHzTe2OQPTMjrR9tzGZqMToXSmiGAOiN31KK2ET0AlSZhWNZ3J+ZGW7Li5gE9/U0XpuYFdYElSTh8v21JxABtfseLy2IXVvruVegv+4RH4DJyO9T1SrLvLildPW2SANn8flQ3vE1B4HCgh74G55WP6SB0RJXQBSezMsZDKOwAiZSyhsUmWMI9eCxAe0BmzrrNXPRa8XcsfH4Iq5rRhACdDGEXUSLQyfZ8PLNnS/wVwg85+im29Bm0DqjKuMIdAG9gzLpXrqyUjeiJQn+tjAJcRE9+6dqElAHcL8ipEY0A4z59/CJuuiAHJAlXHpOwvpmHsEtKkyemIRWuQAARkQCnzkQJzqJtyktR5it340QXy2NFdRf7fMmzEJDPkjbNAPSAiXCylEqlCAtVHtl3g/N4msfV3Aq05lYsIL1Gp/IA1AVqvjQ009TEe016rjOElGDvVYjKM+z4hkbH2AOjhQCETj307xmWzJy7SqvlcfUBgQ9M2OOYry4v2Rer6CgeAFBxnUcDSY+wV8e+qSy8tGfh1W98L9bzplXJ7uPwyRwA1gANODnPznRzevi2KtLtaBIHPI4P6g+K+CJpbLETlgCnbljH+sG++G+BMHY5h7V2dYCu2btqXjdDwiuHOWm9AAc9FMN92rD+vMfxhW66vHtqhIrY86Bhh1BWaDCN6ggACvrJtd1mqJcu1xJdk5b4LEORY4hRizBbF7rxFjZueQAFbAlshJ520mXfP890DWBTfu8j8N5+oWJJqIBUd1E/ACHvtBSKqdaBm62gZR5q4Pu9pssE2Z2oe62n2sxnqDUAQEU0Xp4ttsV1xwBpmYjwwaKEzhnhG3i8gexruFc7gQBp3+tW5qe67Wi/G/sRexPXcm7efAeTZ8VKUHxgSUJBABJqByYz2ygQLLvSQPxxoifYpJlmFQkeiNMinWKbE4oAA0ev+/M6UQDnA92obWC6Dv+WB+6w2r2XiJVbWuPJpgCyPaCs9x1iYdwO1VXRK0a6vQdSqbdI2EhaT+Qi29eeANmt3MxHNOVc3uKGlD4aBx+wF97j+kI6Y1C8UYmn1nwAwu7FWsGjrvgjO6Xqbg3U274cU9PL7uolvZAA3gYF1QDTlWAcarupQwNtN017m5v0oAo1tp+luJUfFrmDIc8nAGuCk56TEGz3Q/4HJzfaKRW/HlEJmZSKogFmIWVX7l8AAvDV0khJxLsDPrLy6HQyMDy4ZP8oVTFs/j1BQqj/JgAsIggnFFOOtYo7T/MiALdMqIWcPplHiFUmHDIzUv4KAF0IN53PvQtBVvlPX3nPnVPSzgFwRe+9bw7+i0E8Z4MAdx4bxiOQGtKKAEjyeUWt89xB5NaTMZ7AbIcf183LdwAP4yO8X4h5If1pSQGeemugqcfYn4LMfZ63Ska3hBv9AKgWr70X99nIY3Y+EsDO8UAinqrD8pFUQddqZAzEgsoABebA5qXO0wyJYLNoGkdxVbCRVo7w9W45Lt6cXZxLywD8ZJ0qqAWYCQnWQwvBbu8jyS/8Tg/Z9YG3QpLh04NYAAuNRa0xIIeLM1nwe46RPcDMgZB/QdDbeRLPGn6JjcQALSvhSCpFPIzH6I6K9LX/cPLYsfMTBNW50//UeffZrABpI6PrNIplzeSoWLDaIW3xIIkJyx84o9SflbAFQToHAPeCgIgVYWcxrw9S9CU34YfoNERv+Rb1gR0F2CiwHvwAh1z34JRKpkVf22wC/smk0UBKU4TfOFwD/5erbhemugDnrK06bvcNtceAwEn7XFebUpyuaIDlS4fFzWKCZsr1AFsS9adhacMaMeXJBhzd3c0rpdwAURH8k6KDO2ppZpgA5Kawzg7yDAGUCtRQ2zVjL4gSybQ9bom7eo/8/PLKEgD/l9CQCHXSh7IEg3zeMPOJ0Oz/hhQwqoWepcueAnNRAPKcjSV1/Hh98u3PUWG+3KxRTo1Wk7K+ImJuIGb0fqoAtMFgxxVWW4zgeekP1kkOYxda00OFUweutzlo7LP6EQCLQvPOWqg6hgVa/A6uTfNBpPvondwBNotGuSxaEuHYAPbzEMS1d6E4/F7/o4VJcFrjQPzDM8QZXjrq3HMvbjIAewklv++g8CUy8GXOBvDsVAKwyJaT6n6Cp4VbnSf5JgD1+MhpEe+vTQxG8LUPZexnKshe81ka1HQuqCb4f1EaAGMU4Fft4tH61V9n5CesyHOA8YUTNZOyxhmHNXpf7JEAix90oJaylSIpBnm7Q5Id8T4N36SUHXeF+lkRn7a5cgBJasPGmVoTl5f/vnvkx5UQO/9dkZz5sQ/XtcNJKSL5AMNp5Wc6Lg4ImX+WapQLepIroPYEf1VtuiiMNK4WfuwAmhmQ6xqp5ZvRnwLNe18cWcDCFIYutlW1rSzmbJeRggAHJI2v3b1rfU+/nfrWOQVoii2gT9+bXKY/i18jhcvWAJLuBUNlc5z1YhH+0XGq0S2pPWoWRsIaH26bCaKBPRYAhmG2BJ1GMRPjBn7KylKr8iwn0Z9ZdJpK4+QhJ8PnAAAGG1+AGY7CooxYhGo7pmq6vBsUi5j1ARySciqE5uLjAJ5qoVkWSgoiXzcrdyd5NF5WiF4Avv0hsuNISy7hnrUAOaAWRZ9XZ5EauTq5gol8m8nS7L/UH6kpCSwUi61TwgBpXGVi+trSeTSkeewjCt4EZfipLwuwufyjsLHtYr8wADuMfCdRNBDhRhPeIvjwDxHvviwDiQze7TUQ2A1VjmoAE5wQBdD5xUp148Qu+etOURI97eGJkfGRSGnvN7NBtQDIfQk840eqtkNtCz5bV4f5lDhNjiNHSk+V9ppn2l97ADdsOQ5slImWgEX4srhiRM1EWSd68Z+vIGZ8xLJv5z4A34Sz8uEYwE6wdWNvn1NYq+PXUyIDFaAJ177nCEfT4AA2kOzGlh2ojJ77i3PnEjxU34fbTkT95D/RgOQl+d7SALo4uReA3zoYB6v/5fUvQ5Dds5aXElBWSDrAip1yGNQAP13cde0inqXlnptA3SJCZLgZ7jWfFiq+NF19chCrtwCplDMp+RrIkxV0+AccbM5PvYJJrZUGdS8dwH3zLu2uACS11Mgg2ZZZXRsTmAndybIaVBNnCd7c+Ga9l7Rg09AAnfjfelhw42R05b8Mg4nV29csR/tWHJGLb4J9ZbBRgAD3ZB729JjZSlbxBw6MrYmNwm88n1na+/ZcDBaVdpoqAGERdG62Ww8CwzCox8xLd0Yrp3+QBSuQxNq9Wq3wo5YAv37b7Vv7OJl1U7U7XZ04X/l4SgSohTlSOMvLkyonCwCD2pIXzAJ1VrOHukxrlHmRjO/vaT+MZh8JoKhlETR9ADgdmFIOsyRQHrNR6AGwUCS7kDNyrrI244KNCWIxABkAX/b2mYurcRkEh/iWFZnN0rSxDO6SBCHZXI3tXEBkXgAxcEVAIBWwmSDwGr+OEvnL5W9YY3fTvG6VJQ9aCV87AFaC/R9+vOTNuoqPGd5qGAcBH9LHZ2OcaYXUxB4g8qEArx8QhE4TPFtxZ9znY0Nccs0zbjTJo4Jugoh10yNkdQDk1nYR5INdxJ6i5uyTyPS60YoEoH3oix28STeAC4a1AMWq6PuRmWUDacnuvrgHUMlnBRFLFkY2pC2D5mKQir8AdqEi4vno9k7e3DJ/AG5lUUDTwWFieOy4E0/+Q/Wd3QBtOUYsZPVKk/sGcoI/AFHhqRvsXVTekAXoBM5DUxTnAGai51IQfbwJg73GCwtf+sxZypwo4Y0I/dAEbW3VPsYA79UQpyVupCaEXG4OHB7VgGPpQyhewWFv34qhmulSSwAF6LeRt5UX80d2VlKFgm8rNwrcL8W5+rPk+desqvHTAJX9uzCGPDkZdS9yt8k9lwjwb4pCqGauXf26ouz1GZMAJF2N+m0gzHyDDd0xWIMWFRPaQaElsT9XcXaHeXeUbwDGsXvcOR4HQuHgFE4HKyxq9NYpLAiFsvYTXdOu+l7FADYBMeIawuM/9XktaqdwcZD75aDYrvhW8gqDw47PtkAAU+Q28TC3UOK0AQvNMfrajufK4cKm67TBL3C4W9d0mQB/btalelJCgjNASe9WmqODqa7k3RLC1cKpuIxNiJ+qAPFKglXSdQ/Nq+qcyE+gZopS+VMkMy3Qf7/4Ex6Ve7IAzjMufTGjBABOMgKNc6axQHc5kXSC6QO/bnAIc3Uc8wD8K5BvjqjRzgIV0COrsi/RUUTrg63239L2wfISlG0LABFDVchD0yyjF/DCQOgvZk+TzSfNEFABxR/l80L2CGQAgG8T7+m8PdOh78HFi9URRn1ZhdYe2jS3fjEwkJnH0QCDye67hCmQX69cGlMOlg6WIk6t6CNL5FJpKPA7alBWAOc23tLqej/l08mB99166Rhx5uuJKaDS/AA3+AQpOuEAj/4kUV7KIKPmap6OAM5Ycq17nsXZmGiili9uA1rAGwBmyBS9W1c06bfiXVtx5kS0Gy4eKIx428LEI6C0BkOwAAxkiWOQu7BFLid387PXNPu9hzsv7odq5jFqjiIVGvsA2rb1PlKBpsubRMU43BAkm4SJaQyEPUgK7BaIkcr3SgBMgTkPrj1rGP8VxzpxzwTynuNuUABA7WxRwjFThtXSAHYASOBTb0i/p3KFbaBSC0imOFByTWSDyHbxy/Wo52wAuRwGw5rzXtM/awoqhRwmJAIzv3raupSOmYYzT274WgAx3FVS/cMRLtSb+iNRuBd7lW/sFbPUSIMVyS2iC+E0AKRfnK3vj3dcc+GhgDfMVUAHubf4ogUX1fAzsPBcE5QACSKqHqgXCc6bxskLzzIGk9LJr5vORnp4y/fNN6VLygBWYkLW0Gx9SY24XQl6emlD/+IkttLH8owyOa/Rys7LAE608qe25NDs2KFaYD3CZT9ylKOSwl1bH4tBiijIKEYAIsVPCQbwZIfCcv5JNm8eeyowIEOYMc/FnmoklPoFNQD1wgdorV1hHvh3gRS+8LVmKUl8fK9udsh9CTpX1guKAFMjikvk8Vw8svUgV2bYw532nPAViyLDBr5tjF9rLGUAAkGzCZ57BRtXefeGRxY4D+FT1PMDX0kx7UFvgbwsBAAZKMxmyGQV3crA6MgQjfxC2XeivLVFw1AcaX0NykOjADIZ8O5acGnaovM6ihUavDSvjNrq4tR4r9MbLwG1I88AkM4JRGb8H9bxKWdQ8NSvhyNVp7JjPv9vV41A6zI3JgAQon9/6/jUh9XeFjy/YtdUXP++apHwufCWZmmFg7zxAJ+uSPYzLoACvErM6Va+bt7YrLyFgXKMtvh3jHLIOYUAUw1CGNhZ6bw2oRSBafFdHClR528lgOe8B2ATsumrCgBwFXs0luNbpNQpsimmh21UCRp9pN3CaKJvgMSOECVOAKcwKcvkh6f6/E6RckCOE2cOZc/f0ba1BE/zHC8NX9gA5LnJd41NUk/oWTvPtEzEq8bLoLVr9kpN+7ZUOmSl9wDfDp3ttmwM1a6ugzPNrfGrzVkCwM1Mt1o6u09yXFMVAPZi+wHhLF650zPm25PYqyviSVLMzWZK2vHE0AHqY/4ATsVocWz7XSzdrsxOAK8Q0KY+Th6TYSvCu15VaO+wDQDD767jdRYWFIohHgO5rm8ORBlcpX36Itkac5o+RuKrAI2ba/aEqfONNrPNKlH7qdAyDNdAsLV4wq9wD3ikwT0A9QvVbtGwT/HG00nc7iut77yg3IT0NpI0N7QcVvGvwgDXTmk+kHCO/2yKtv/AAGzeMV/N8lmYlCV+4ex959pkAIaitSI0p0Gw7l/Dd2ZkuiVvStwZAdTtUUq16tpPcFUAlJWs/ST2ZeAO2u3I+X3nCNHyRlztTkBvShyrfok6fQBK98SX1PTR8r2qN5yAwRCAzCTkGd8X+7w0NV9vynVyAHxIZT5juG+3pvWB56xgmXenvXDZytHKfLJl+ldmyccAG4Z/n9tMgEC0aDLiggqz4SHvOHAsB1y+eyh/nRHTBwAQIuOXaRdfli7y6icfBwK9yzBvt587eOczpe7CxbJwAFXbasSWj+pFNp0rrdizZAKeeC+wwTQ+fLMEBdeD7u8ADOXyuGE16lAn5s6QeV95Nm7M/0MhvKXWvksXTkKS+AB3q2jhQqLuVR9lj9NwVlGoQr7G0l65n0uubEnPjVUdAJWKegOzNTtdBpJaYh4aPdyxFTyoNajMlMFyU5cw+ZcAjYpGvxeSDfU6ozfR9BuPB/ZTDOSBztyJFxwtcS2EYgB65fw3t3uzloT+ZJBsoO/3jsZmvICYMfyMj8FoRLfLALY2jTvVM1QPQRKoj2fEZy88sC8Bxv+VrCUY5DkxIgEAWyvWDaRDOiBlrqzomVQQQRLy8FGC2HIO2MKLgEv1WQANhSmY3wLCLzcfwShCTD8VVO9mnAgKLA7KwZyPqL23AAHYlgkNCxZQwwgyzFaN3J4d7JR1bgo4ZKuu6SI1ViYAj3jf+Og0f/PV/0fxtRj1GfI0IVJh1/L7DbwhbnylbwCmihUIlMXy5JjMsNaekxKMGVWaZhcd7bfemsEGGcrnAGaWKcNrgwsOvRNHjXVehXJIDt9LF4lQlD1JWzjdg70AETeIAzvXAIryuWZAUsrKTfiLfnTXNL8JP9rsKU42vQBAMPMzQxHjY73jdBqwhZ1nUBXj4/mNvZj/NJNyIgfrAEx51iT2N7aYsxAshdaHyJdAbm15no2QbLIHKw5wTDQAj+Bv+jrvWn5YQYxgzP4BqdNYL8almpB5clJdVAOTcgAN815QnZ7eJR+qoADKq8Hg56+jlEsSduYRKV6k75ZeADPGrR984eouwsjXRQahath6E1ivjIUbqHF+cX1b0eMA5gXEk/xIIKZuRPVv481LCdQx9rosKJ/jmfGrWvvYqAAYHpHAiPcKVX7poIhKDaialO55q5L+Iw6UCvXyoVM4AH8MMy1uDBgoM5QPxt5rRImMHiFbbTPpml2CWZVn8GAAq/SHUC3SQUvPcJTbCK6RVJ58AeYBWG/pIYzbdh1YeQC06Fu52L35yCH7aXBOb/Ri5Aw8JRp+loTOmEa0dxDOAEh0Xf3Y0nUpJ+X2xiftsq4IRm1b0X/m17edVQE/vcIADSmvGiLkaXbKi6ouATucQFhf+y4ED7YWnz71biQR5wAhUJskOB85Dzkf4lbO3WHA+18xIzNu7UF6REXxmfDEAHyOQ+NdzLaVXBmhSbOSoWxzgjg7yUCLETYRUOCgkPMA9j2DdZi0tT/zi/xqOtVedQBGHol25JH1koN93gw8cwAowgvgQgwxleDe7mTIXIfqggGi4Fosj1DEBdGSe6zmAK6GKZB8L2J0qtiBrNA2DZQIUIYMGdVeEOyhoCigHi8A+HgbIScsyrNQmNAStnOPwHnrPH10ehBTgskyyE0RlAD+vOTmfGcNpLRlACVM0sWOPK5odj3jLAnp2VRkHz/kAFYi4f0LYZzJL/YuccbbBNfIT/Yqq6yvGH+rG/uXxvAAjS8v/3U6WAj+S+h0MiDXmv7GFzZwnt2NVuwOXixwEAB5FR+SQZGbjHgEj3gjszYHxbTm0gd9a2ZVieO0gmWxAH3TW+lUos7pJsACi6nXNmjyKgU3y2clU0mlpiuhehcA9ul0F2iZzb0AJkKRtdzjq2TR79yS+MXDzYAnKSwrMwBNyEL6nNKM59q5FomJSKQjFzVHMjBXikQtezFOP8OCAHlA5BEoaoKizn7mynJVsQmndbrhfeFOaSn/N3fA1U0AYWOv73g10ZOvivNfAjMzcet61Q+rVU5DwPqIELfEKAAESSwkMd5ESVTBGlqHTdsV6RAL31kZOsaTPu/8l5HxAJjYL0d0fkPFFOdN4GXl0MzsuhrvMQVvbSGlLLix1p8AnOrg0NWFyPHEZ2GrkxxQuiYtOR8maucBIAZUCoTyVgBM2y8fQ7DmJgu8sbxm/b/mBb/oIcQEHRpccjWoTkFVAOYocv8J+C6kdQrfL0hS/gAD9OTQqAHy3cOM4XK1jH0AYdROS7ZYt0BezFVh+8miaHF9xphTDivMBTcHR1gnfgBJVdPPem0L6bLCguLS5RCQcP2eQsCsyXjlAiZu2zt3ALE1mzDTgmXnsdz5bbYpdk5rD41Jh4OLJd36X3I+w58ApC9g/oCCenhs91v9d3GE1n3DA/lSjybadzVFKxuzWgA0AQk3eTph7wuIzE6afE21vX0jaAlvR42lcRHkKQ0bAFVag9Vl5HadxpNcxEARuLGMoerORSQ82bhz2HIKZjsA9agTGqPUaPH+Mg1TN1AyWGYAnzzeoxuNmaLeprUtVwAb0bj7ue5nrvqWxUVYaUUnC/ap+2USLkkFHn+ZCTyLANj3G+BQ3i9NT0ESqwP5AQSyjosBXreCxSPoiaEdtxQAuzTc16Df+eADNhoaUsl7KArgjmFI0pm0adgz5fmh7AD1rH9F8AlrG3b2Vsz5hE4mx6fYuawlMDJULbxs9FL/AKzFVLie9M4utwQSGGDuw/y0j04BMaIQlie3CxVb7NQA/7Ine71rRGa8fclTgU1eK0nlGdWFd8JPrsIbHQpBrwBAmp2CdqEQJNtSj/Nde/zTrsWBrbu3+jUioVSDVoBjACnKqGQmTBXazA44nIOCeZhE1ldoFOma3yms8RpNajAA/tU7eUVvZrFc3fe3U7gmFZRRDs0vaopLpag+HxfceAAKdXILly7LhCJ/60zvPmLYKn0sC8gtqk2mI5jmXjR4ACVw1hYiWUiAZfkqf1VhmzaicFeu7MZaPFFrdOtaLs4A/JTsB7SY5L8GJjiVNeZn9BSULsU4w51KI5owl/YLBgBj2XUsrXKBZKI+6ceTiBgeGzHrwRx8kza3hJ/zKUmoAF3+gG/S89zFPfJwAp/vhiAPQUZHt3fOhXY3Hxiy8HsAsG8ZQhvdjIk4HPkBaXg5aIdmPaaiSpSkBegWu/AdKwC4Nnz3h5yyjE5gFVMO1JMDFNVadFHhEg3wGeSfIuJSAF/lUxDaRzOXfSFkXnR38BHO8sLduzeODKIXFoGHjaYAT2akBwH3yUJZ3OKUSaCuRJ+k+4UHoZe/knT+il9+kADmtF2XKigl5ydOGCQLgLz/cx6UBicoFMTgWjOxwysjAK1nfZAdE4VB2sS7b+zHZ/q38F3s3cY8TZ7ehTj3fkYAhyDL4eOouBCSf5Op/CZt20Ny/hJV3XbiN6JTU5UxdwA+5oGMbAGrrIewF2fChjyCoxX6l9oOcsF3uvtsSZocANTKJ710XGA0KT8Eoy0OVD4l51enzD+5RN01pSPq7BcARPUpur26sCMil8u25aa/qPaK1+n1AjzNl9Xxv4DYDgD5ft38KsJOTQHkZw102F7+4XHz7dlTXxHZGlnCDU8kAFzTS3gjqtjL9AHLeONvhgKDWYIpFTcizSMqNuSbMCMATngtqtlWaM7+T4XJUIBxou58X2hGfrLeSoCVmZ4wwwAQJOW4G8S4aW7dlNYmgs/1edR9Q+4hs8qUOBUmns+9AIdXPDW9yQv8SVhlSWOuVFg2Po4/nQvkf7IcTukCyIcAiQkLe2VbkjWF8VWMmhdP0OnYMcBEbuxHz4AWZrdn6QB37X0roUzm+iFP/1sfvDUO8Lcq/4lFPLi+I69Ur69HACfYpzw7utk0sGEy+6vuXGqUaV4Sa73U0trlG1PGhDgAy5+nLqVDscnv9hSl52QP9jAA8ueftolhXu4IbxBqxgABl1jZqpK61u4Y7hQwlC0vBnVhUUyctBU6w1E0cjHoAJvUifyB+AYXBeLprR6e0wvU+Zgt3ntloTF1wBoKh7UAWahV152uFWfQcILJCMUiYwM91iBaCIzaetkTcYliOADePJfK6fqQM0IZGuygETnIxD8DhB9b9aFAJrwMnvAcAKeEwaBauEY4IdhQBFkMB8x0luqSMcNwA+ksZHz0DYcAO+gCebR379860EqcRyCjg45SrUFTijxiCWVWj1b3YAA4ohQOmFFkTvTlz8K5S+MdkNOVT899rifTZMf6HCHyAFXezeAuEm3X5Rh5WJTTY2P+hCOHAlvW41MWNVQNQ4MAMbs+tBe1FejeiBxcKAcuKOkPlSR1OT5aAK+QZuL5VgCndePBQTfVHSeUTqVCRf+9K3rj8GgLRZnbwbFpXypBAKm6bQczqE423yBl6Y+xyyRoa09BLx0Tp7SBe/H8XXkAa3C4LNCXg5nMrWPOJ7RLOGdYk7pNSEBIkx2xkhHfaACFss1OgYAzO9DLu5ljDoJ1hR1lx1RN1cRzMJNheTDgAJfl3zmQItmrZ1jF7DFPqRZriTnyKNRoMwUm8MAVJQIASZvSh6DTw/bCe0j7x5unQ8P/AYK60a1xUOVAN6HfPACUWcWRd2AyDzQNEhmUFIEnzYiDy+BfY/PcYCPK0ECJABUifGAIIoUENrBeHRsiQmooQoHfeKvp0J+EMHIzuIEAw9SMNZ2HhnttQNjdYooGN9tEPjTjsn3g/zhB7c6OPgCKTYMvCY8ZDFK76nOg62DW6gCgHHn6W7AayWFMzv8QAFNs6KVbeHpsN+SzzbfEpbYZFKxkXUjFLVud/6gAbiUAuS4CVirgKte8OC33oO0pYVaSiOJPRr2POvaUynYR2QBKRVXRL0b/jnjJcuDvYaq0yMTY/89xReaskPLa6hJFAPvx5Tc+ND8hdbaSAwA7lFPD3Xt4GnaELtCzIQvOXmoAMw7zmMjqrkFh+pVCpbH8OjwDmKcSxueZswt4LET/agCjI8iRA5XL9YwEvN1iS+zuov4lmY7XJVqhnP0xSj8CAHAnhSjayD6J5MNF6ODxHnzE9NuHcwUVmThGM5PDw2EADbBGctpHciI1Tsm4jv1hElKywuQuDPjqPknKwjLOqgBtt26/uTX8un3MUA3FkYcEjdYmSie++P7XLILQXRtFAMnniRo1wGaJ4+cAHSEUtt3YIAiGPJjbrHV7henVLQ8AONZkHrPS5ni+Zw4FWBsn9Y4sXYYUtbt6ytJSMiJDdQCzjW0OBbgXJcQBC5OVVbI76sPMBwXp/LbAxM0ZKWUSAKjmQRIYaoQh5FcbrkbuWJBZe5Ufe+RiTRbPq+Y2Ke4AeMaiEsCeuVxMKDpVV5QGZMdqECdwvE0ZaoI8QBmecQCid02ZSrEfc3FIeVxtZSxt7k86q7rHgyF3iHPDOcxGAOPmSge2RkY2giTCFqloLOEGLNac3Iy1Ew4y3EBxR90AlsvrOZS57T998BaCNliy74Iw5OfdYiEJNcHQ/583gACryPu7jWKHO03TSRZMPa/R5VNFtJxnfjNZmgbRPL2WAA21oHNkVOURf5vHSGzYNnREj171bBS0qPR5ox+PaWkAs25IAxG5771kYdEPBE7/m1zgBwaEqimhMms4guBSFQAvsJvcZAdKyCCoYfkAiG1JudanRp+Zyh97WL47Mm02APHdjFXvRyB7H3imhGonHgtdnfmebWNPFUqg5ND/wDAAzOdgLPCfzEGMrPB+ZJV48zlhcNv4euAN+hCNNJrXggBAJC38nIyB+90rZ5g9AFwwiS68zWDcctzwnQef3weMABQhCawTcdPeco8CoFFtJJ3USrbm/HBuwlQhUGY1LPsAk4mKy4dbpTgco0N3emKRXfGw71nW9tOtZXgdqscANACOzIw9Yj8KJgC29V+YQMs8Ga/ZQsk0QLVCjrIAqu5YAFvqYdbvhgG6rSkcTX7ciBbGuN3lQQyK+EcgvU5tT6AAxclGKNRFjqh0nIuEjTcXdh4HWJoI++cuoo5xXroM4gABP02RF7bhHExoZNpSk30dkLq4YOheo8w8n2jdPaPWAJUjCL3hxJR2j5plkxEY/nyBU5AzvKUTYvS/RDi+Y1kA9NFIQAnewjNmif8xq3F1Y2qzMtRvPw6R7GqHcYFl3wDZorCrqVMacXnpQeU34d+1pHDeOsBRkb6dxV0g4o9HAJdPd0gA86JyURHwe/OiZVUmw3NdmWfiGbrj4GaRPQIAX8bb+A/ZZlasmxh2f3je4Cy6sYJq9EQRWEDk8dFcrQD9+YTTamlJihWQNd9zNaMHR+3oKU8JQOFHSrrmYev+AIicaCTXlqR1U+IuBKjsid4qGKufVzDGQPUMU/xkn0AAQRmVzOOlXcZ3T6zZ41pSB+XBFKCKHkSeRw2jgEXPLwBC1Ftnresm5dAcNKuXnY+wH70Q0R3E05ZvTsdQwm36AEbLx1zE+/2m9XdnBSTs78ed+u2Hi1F4s08Nxc4GHU0ABNK4LvKEVLVyOvZ+AqHqroJGuGuiow2/dGoQM5X1rQCi4M6W1H/50MJZ3MoQjEr5zJAOX1s21VhYyix1LEooAEWnkZO4g5BxYelCwV9eL+8NwE+d+dcJRLahUHPTC58ACTbZNEr56svUFo/HgSpoC0XGeLRwqDEScCarWfXLIgCXci0tcgXHxujW3E4hmzzRny5f+0QgDxo2z5O5COTWAP1vrvkM0Xc2dtJC1Ve8FV8TdqVSsnYSmqk2P2KXa8EA/wxlH2WpJPkqKFWrOcnnJA3IDch0vMMcsPoTXOVglwCLPgevu8br29xpgcU4209ySGHsyHvtmP5R5v6/0vXOAG33QTRcrnCmH7h1fAZp4nckyV4CNiWRaRy+wErig/QAsE/wN80Mky2ZIUOWlKuN6Unu6DuOvokIaI+2yIcC8ADfHRXXIAhsvc6BbWrxRvFKqtP1OqFesyKNIvCOYSfzAOmG5PkhGZRczjNOa0ItJUsGSopCEvHBORgBoC2VXGwA14qzHntzJRoGnAC7oxHIefVoMGfgpz1IKNt3MJtVHwBChiUOPIOwIV69Jk982dMpRzKfbp8ES364AIorRxHLAGf+CxSmd/TMSTVSWvebofJnagVbFpvoDttOFuS2IcMAEaUUaOVa1mRsdQTzDHey2/Z2SPG/3UOIH7zP+tXKwwBMBaWQf7v8K/6DEf/o2dduVrZNTh6WYogypCITAsgQAEU/+wmHCsevLAPhGoxE/S7U9HcES/3oqa07vMYXA6oAtIK25DbWbejYRoRpvpa1Xkktj2633jK5UHunJLBAOABvOgxx/hZKesAZCLZ30CoqHOQVAcheA+if5mJAX/bTAIhoM7jp8YjfougSxb4CEYim6IFV0kRunRVYeAveNjgAAV3tz17wPFppUTJGcWg76g4UdpIMcN46y+IAX0V1yQDRcCzX1tzUn1/XxeentYSKHkjH+XBxgwv1Xk1dxoCyAEMLCI+ztwb65EAtAUmLqzsad5SxEu0u5ZJwbCPUA+QA5LwCqDymEnNritIX/bIB2V7B0eoqDIy68757eKwzjgDCvAOl3KHLhqqKan6zuFJnYMuycWguB6RN0vAcw9tbAKsfovd6qMRoF/O8ujdF8MKKYA71EaEqkI3Asr5ZmowA8Jc3dcfUZwO8aVro7XXMjbLzwWpFa/C6Ss8iaSV18ABfAJi48Yk3wEcSxfzNo1MmcELL5iv86PGtjmNh5JdnADFV3jtuPSu0NvGWR3c1xq9BGCjFKqcVKkH99uIZW/cALSPspfuM2l/5SUEvpOx/OUB01077JjZTlgn55YjtqgDzz/r2AEZYOn7yND4IIyGoxe0ffW+WBf5Qju1HicfRAH4maviqvo0ZYpveYwUnUjPpB1lr0TylzdaIOjKew1QAzK9fNsROtsVqExtVjfYaXGAAzfoQJ7kfbq9tmfzVywCJ1yjDxic3kbirKIBg1y+iVHn6QBOfAGJ7k1yJFsGjAA112StL/8YWvEaae891v9eqwUOXtbj2DQudby/pwMIA18heL8ZoGfl+T/ZqrKiMwOat+v+pvkNLQaDr7WAIvgBLtg2oOidCairDd6Bg0MJ/dH4GguixLmhw1XRti15MAIrT0Dgn0fCRRBtzkHy9FzwGSZGgTZMHzmeeXZSOVaEA/pejYBI/rRSSlKdueG/FbkTx9bjFH1hrgZGEeCHtnACZXywO26SZ6y4ORz7WqMOW5VfeEBTs+EiyqCaoQ9lpACahGzBsdnSixASVFl+1J3jp6e5+Wjq2V6k4JAyAHSAA+T/AdkB87DplImqEfD7EfNawHCR5n2tVQ+gweWMi2wAMa85XGq75BFfGre89u66KUnB3E+2F8QCj/liTtsPoAKp4lqg5HiEjcX2O1Soa6IRTpJPxmO8bk9o2kdsTRC0A0fp7jHrxS7Wto+kk+ARQdg5FYdMVj5RiCozwibrHkQAcst1hlEyKd9oiKOMJxiwF3mDDxQtjegrZonCNCXhbAE33nw3Q5pHCi4yrw7lFsEFW3+/B0vb8KKhw8nyqtPQAdliTxdOa+JefnHBfY/wXPW6bCqwnL9wxoUtnUy8njAAZwbdKS9HVts9MsvYr0zbH6g2GfMLt8w3hEjJUzyulAB+IEvxk7bvjK7uw6LDbj54N6ltWSriRbJ9usN/05IwACWUr1vDKxAXq1ETH7fpXR6fY3PVQOj2ndK1AlVvOCQCpSAtwdhWcDGXyzu4WyoE7D4G6Eic+tJ232iF2H1DkAHWSutxq+N0+4Y6OhCj/lU0amOswMSycB+E49pBIOUoAYVVo8Hp90LPawMOwO/yIJsZaKfF0X5h5bjVDhKtkZwAZbvtsNgyAgFVwkIyv4ivc7r/OeKbvKbMMIFtTjiwSAG59ZL0/mLK9G790sqQXIQgaQxZJP2J9lFH0sTe1Nw4A5in7R7nGftXT4pJN/P/V1RlFmFtQty7pzavNUfMn3ABfjYd6MtlQzgGwdRlK2jcHDlrFwPdZIdfVrREhkyjPAF+PUzwQ+0da+mCmH1if22PRpSk6zhAnJz9mlm8VcsgAe9BDvhDWdupAcFwAj+uFsbeuERoupW7pt1a2n2HdeQBqbkqkNUcgOmtS0VlJKjbOrGQXgJ29Gb2g0Hk6EPxyAJbKcXfF8XVKQvOy82/kUihjyC3PeOggJket/3G2XygASrgGhs2VGZkEnpvIT/5RKWuIj5rvDIqvMHIinL+EgQD6/uXsUSJ4X9dVhRwKBR1ynCqP+qNX2AyEp3jqzaL4AB9Eub/JiTdydIfEpWTr7QhIGH3wLc90IxrB8rAhSKMA9EmsBELLlJPKkCH35dhT0sc3hhtFM0WuaVUn6XDFMQA4gBW+pJ/yuQPbRdtV33wExUlAZ49tITEaUlhBZ4xqACHjWZs/CfrzvtjWs2h/i8+IVYP3qZLFbpp3jwlCUPcAHY3u+fTwl55GH3oc/iYUTA9p5NXr8jBnJp7gK4PRGAC28ltH04ti+aPfE9Me+JB5ar8PeI2qQNN0XOefRDWpAC5wukGJRAc8WHr5PPBLf1S5XlFEsRvyHrja9iKwYNQA0LAc1gx0Z1LTxNA+uqgF/a1SFreo5b56NPGt47FVZQCHFkWRfruOVijPbpHs6jRCYegZUIDbCi2IDav+UJ9eAAxBc+Ww0YaVmQvQd+w0q49kUKcHVjWr+UOwPG9XWF0AjAnV9iTRecqBHOtYCyIEhF0BcJblzXACCP441ZKZ2gDr4W9rouAzeRlRi/S2vJC+fp3sFTmayX0k2UYe1bCqADYjNKYwnkANvTxEToEIBKPd/OzTD0jA0f5dafh2yKAAf6VBDpsOa1D5AwSicWR8wX6QURS9LCr2tkdZAZD+8QD5QobCbHJKv2ekU3WgVnLcSGyltYUqPOlabFr9/yAxADcHqo7FytOJBhEpaJQ9G8R/S3ClMVV68xxDrizRa2wAKBhf6sDPvXJ3dBcw9+CVocZUdXrJ1hNVrl2SFZHsVAC/o3DEEa2RTHCwCQaW+EQzuU0MV+eUCZqkrwSXeUcxAF5UlZcw7oAZNcAr9d2X8NcJSOSFbUNaJRirYqqtRRsAwLE4YpyRiinmOVZ6TbvXBmYw+iclirg7bm8Vlc2bHgAkNywWh3obrAMayfvoVOyNGoM6dG5tUBSfJ6pI90XpAC6NhvPeU9AM1pMSd2h+3WKFJu/s+wXo0NHOWqYO+CUAFcJAs2L+3FsKLPR+XRmPswIojxU2BnRh+OFTxBHYkwAJiHgWnxrCF4aO5i1+o8NbALRGJM8ICG4Ic5Qzz6IUAADKVIlOWsTCP/VNrnL2iaTw00M9JchBtkkByHft4oEATnffAgmbW4Le/5B8Bq/+f9qYablf3kR1DL3LjXv1wQBton7gAIQyyyT7wa3K6LDObu2AyrSfWb069EUu7ZaoAKcwH++a8h5K3kNrcVkeyDI5VPv/DyN73aGzoqz0ET4Af1I5QcTSIAa35g69ixZoM93INvx9zJauBuLxyH1hcQCC5biNztCPftpQ05uBUKg4Ipd/q4san+aMI3Gg0PZcANUSRUJWrjlVdgxcjrfGf1CDHMDbm631HNxZIKygVy0AcGshP6yM+3oAvt0lN17Bxc67oYITjCW2f0G2LcAKVQAE2Zr2EmgxcblChYBZQS5Ybyh4A4uQ3/Xkc1zvYvQmABAAlTibeofyNzSfcyyWpY34/jCMh+saAXQUiJdnh90AHYwyvVemYGNtuqyhp8twliq8vlSAYE37xjm+IRd0MwAwfIyfYVKTR2oww9bQJlWqk2XxDZucVdG7iOfaNS7YAL8S4q/C7Alx7ntVgYTdFaI2/DgC7n3XPmSJXsqWIfoAq01sfVvlkIyO9USBJajtHpWm9OgLsQUc7wYtf8ys1wA/a1dMwAameWUGQEoMBrZeeSNmCfYKICDYSTanLCbbAKJS1zWtfdoF4H21ZPcgfNftUZ/hXVZQ5A0jc7wDZB8AxM18E7OWZGbVuk6rrg9GbdkGWWaux20KFlYoN15KFgB/dAtDG4SZ5MSKLxyK6sYmvNoPRrh0XL8kQoUdgNxzAP8cDDOiHaaCTN4RDaK28CuSaQUedy5WvTF3rB2irt4A0vKDJRPBpZp8ENj9y7i+Vl51hQto/fn2e04WNwtqbwCML+dCVWwfnf0IrabU0XACHGcVnytFkp8IvsRgqUlGAPb9u/rx29u8u0Gqj2wu1B2iCXr7tclroOA4i5E+KFoA5sNitULEH95MIYWuL6q7KFY1Dv/tmMcSQ77evhitxQCvM1Do2YWJDh0X8y5EOEfhe1ThV9LEJYuE6owG1EJGAFevLIn4ltWH4aQG2XI7oatYcekGdXz2lyBazgfTv/sAO+Mo4oDzTeRlho5u/gXdvUqNJJA0Z2NK6MdUljhwIACyHDigYZBxZ7MH2hbLIi7tLVVkG2Gs3fAxpeFslE9JALpS3guwXgh2c593+y/ecMTQotW81u2ycnkPaMJykkYAwQTd/p8nQz7ibKYGnitaO24ic0OOEcVaVhsEvaTXKQDokbyNUbJpn7e2ceaz982pW3eZsNKWG5M34QidOKqZAIam1U3/c6Sc4kLpp1PwW38b2f3HcnLm1AmfqHKsZnEAKgoqqzgEjkDF19ILi7D1QU/9vx4s58oK6g9ufG/0fwD6RfbUrsMFxNo1h/VXIbiI/xvJgVotGXg8c7YSg40AABD/W9S+pbvg5b2JMUkJhep5PBEfPWbYINCbqdVS+10AFCtjtZFiQWkFEe5/P0ZVRNQWXAO9P/1TXNq9mmKBPQCJ66UJN8jjEY35rdYrSEySOGVVVRR6Kf9SkmJ6NeDFAPg9j6bQJeonziFhCwo1dat/kHV/aIWTO/JDVLkTlYYAAnMI1lRHdSyNrN64kN4VTG/hzFEswoI603SEgJcCkwAx8nZtVfx8oyptIUHwiyVfY7CBS348Nc+LV5XE3GRdAGPsQ55e/wQsXcrkkrwUeNpY11P8NlmQHJl2llwVbzUAlM3+LCu8OJlHDu6WkoiX7N7VONbNfQD2jZ1gaFhGngCmiyLL0XPUvMb0OaJKy/G4+i6t57Xug14R/RXlq7QnAF/JWST3FvJIDnEBwuwP44txZnF3sZZMy1NjodTQK04Aa8a2Ia0p6Z0atLGVbUrMrKT98HYkbCzUEUljN+qA2wCE4cviaTfjS5ecljhHrdCVzB9pYdLz+bkwFsZ/Z1sVANyS0cj/uxuvSXSXZJQGMBkJlDmEzYm9tPEanrZkMk4AjkxCTuNj4ozwfVY1a2naEULvduMMrh+KaHmhexV+cgAdYApGhBLp5qgx3LFOOiZW67ZEgAqgiVjAyxhey7ISAAMtJV5XJT4azowCb0MF8g14n8cJgqkDVqU/fUkIeCEAOnp0tDnUfZTvZIpif9xsyOECOM9giRq7aIXP0ZGvaACdfp31AaylMJGyfZLysKUeiQr3E30WaM4bNc3MeY9QAOwF0hUDVJ/OvbgGHh724LVBABPQKz7M9wjN4QIDGiEAGjfobF2cCqnMmUMo2Ul6P8eu01E3N/mzmSEUAuVeWQDeoifZjtneRjdWRdDQl1guuGwmMA+5vE69dLVFxaEhAH36dksC4h77ko5ZY377g8vN78yd1Hzhs4oi6YCLrEIAliSumyYZNIt7AHKvzMosMKktlm3Js4qQeQOgOpmWHwA0z5fpD5Cf4vwv3Z7UMLzcb9Ijb3aEn03HyHkEYgyQALVwNI/NWTxZUDYfmnSH1RxNE6aYI22m4GKnsW4Sg9MA+D20r3OGT6Ma9387YYr84PAuEyi8SS3MAYq7s4KncgDzUqOCltDSso89mhf6x0tM+7Pvnp3qM8SzoY7z6kN+ACFMMoT1cn3IQprzchZfTKyJ+hsQ9YNGX94kQgSl4owAr71/58mKxNfHPa7X4o9y9WZ5yTe82QcXcjNjt2hpoQDjmvROUm5lJEzK90MNEZxtrZaplLtYvN9MjimnYx1hAL4ri2HUPwNkfhfkJSRDPKSbQpNXUp3aU5fBqfeKCfgAxrGlntsmNu5Q3eT+IWnzdH8HIPZsTxq7Prnqu6DubgCqPO2zlhmhXYGOvwGtq1ZrXjyD0VWhMJ/jFrOChRAyAKy7ZXyuJwYIp94jY6dmjl9lFQvutPM+I3tkSrQbrzIAuMJmZF8KUHr3u/mnPTejriZJniwtKd3oCH+zFBBuFwC18AosWSsLcQHWxFx7CgJxLVCu3mzTQ55aV/WeH2STALtJ/pYUWEZLZpFXOlyDL3u41WlXpKCsef3d3Pmd2wsAI8OUZIao2xp+SbWOVV+c8MlL4skyjTq9M303mcdaHAAzf0ArDkMgYPOjAVwHmzysQzKpWJf9NbBhQbBapfv6ADudk0na40WJIqlEuWQDOk17DFn6gt5jE3ad0jkg/8kAqXtyu+9kVFtWNgA0djDDBDFufMOP8Zg2bIRvrKyhBgBmOZRNNVpK+Vymfc1ZG0cOncywJQtkdk3fygWndNtLALgzVixfhPoO+mTPfdO/ehMhxErxq6j5lZj7OR2PDyQA1LBGjXNLlCs6Qm4HMj9HuyP/v5h8tFfU79fyerpdMwBQmS+lP1Qd1zZwRoVvbebdYfPM7XVwf8tFlQrL4GyqAG/KuMo2UQPCC1qXcW9pXDLZJ7D+N/WmdoCQmuzs8JkAJpREZjSOzB1NMM2rlK+uclwh1HqZWH5PEr8LtJvlBQACLPbKPB2rqCf8TCZFPF5MCQUBlTenu7TEB7H/gxbkAKvUUuTONO1kie55vEtTUg+h+2azleUtM6TtiBL9Rq8As8nJojo45m1xFEh/ORWmSoxGXXZBVKpQD0+AfeabTQArhcPrpr9QQcMlSch866rcVQ6YWLtnGPQ4xugkpbAsAJA057l5d1QcB89eU40KhBijgLD5Zz/TpWpPg5wjuVoAKFNzkxs8c3IFDnoi5r2Enh/+zlx8oD/S2DHgIQey4wBBPzk1p6or8dE6zH3QVo+d+iRVxcisv5Uq63Z+tSIkAKTOwdzNrn9/LSgsTgGg+GoQC8HLJf1qquGHdzbQfFwAkBeELAGFVVanxuchA11Kcq7e8zWyPesVfY6IzD7kkABsH4mdHMauq+2n9TNqMSLMQxMpKTRUzBfr8f/c1TjoALrDynvTZEVI3tsoNjfyN4SpgRUc9Hq6hch3otgRXicAml2YNnSvh/8+Fv4bqZ0B5jgW7WFxKq3vz2wtQonYXgDNJpLIgBuFF1k3HWTZQKcYpVdd6uAvS5yxdJV28AayAHNZfvv/sL2vA/wsw+KaDcSpiuiETyzFuYWCPaReplYA9Bk77y4GIGS1ae0YlkcM7kZcCRNhMn8Wma9uYp7U3AD/l6twDzqMkKz8LfFveTmQOdcndnUhXQKcOO/blWA9AC7G/dgjjHUBzIQAI5i6eabgC5Q1C6a95kV+aA8k4CQA679HH2M9SwUv5+kX8rNmb3xluY2T26N7e9jCvez3IAAg+wG0PGFb7NZHpqctqi4j0QP6H+kIa8qOXQxabDo4AEo6A02gJ72Es0K8BNI2DMMpo3xwwsMXp9Nsqo95eDEAywlWBzs8BP/dUhnkxj9YCzKyXAp+Uzm0Ngn1zLqNgwDKDYXcGO640ATHLE5K1BVA5uKQeQYbpztiubF+kSQiAD8DcmIpLWWpbX/RdldDJXU6d4LiTOH5OuEVsQBm+ZgADqz1E2okTIBhwRxOpvrkOHCinYDw8O5M2UezrfXzIQCH16ijrV+BUtEgEOQNKF+f/33WHft2cFYOPDZKYFH2AK4Ct2VgeUM/Yubo5AlbcgrYPofebF4NAVnYGFXbp34AyJgoHlxK9pQX2qs5fZhyiZ/oKBXwKGRFlVT+ipi2fADK4E/qAnZUPOCvCJo6eWRKe0nQ7U7RCIXGH109EZA8AOzZxMgh/BKVEWQzEaSnrX1MAfGAYu8TMz6U+PKTRx4A1/7pQ4LRs88LgOfdeUeK3ajpkoRfitRAgpE/rbDn+wBGSCIUqIv33Ny+SwMyrQFh4zYioXjBtx1LCpYYEkRtAHIK+WPRNZW+BNgZbKVbZSr++1RbW4h0hQ8KT7c3SrIAjQEBsP3ivlJ9XKe6LqNGXpCueXRom1PVR0VmfdPSNwD0i+9Ks1ZVzLg1mfOOqEHu29vjpc2kcpZbLD5eKfKGAIf9QpLOosNdaTdd5PRuXcv1Xd1yTIavP9ncC+Favc8APMopxQcdfCiCT8sa+DusayJYFZC5z4kIrmiaLGasVgCCsGOlb3aEdc/RwYw7RzOGQ671D+9B3BqAu6US67oUAIxHaeMYwgeCVQeBPb0mvG3UOXy9gSSeVkLA8OZrAHQAjBlHMQLoFZy+d3hjUIMBrYP/Y74WyrRQxi+La8f3gwAIGzTlIFdu/zdNoA2BGZIjpJbxIxkR1PtfHWZl3h+pABMNxKFTA2kauZqt4Zl/+aeiZt3rAGJWWnu1Cv4w9XUASmsUJ97z/WocpzSprRdfMgViFdJhF1uEunP0k3wAMwAa8UcRsw3SKVgoJA1teQx3hN/uvB7xJrDahKRaAnDWANZLyne43PoNH9zD91JfftOqBGTlBvhg97jcpYW1+7gAZ+sPS9GHsprLn0Hd9EsQuawH/04bQIMWExbM9QNiLAABN3bE201M9N1JJssb+nX3a2HgFybDNwExJR8f7Be1ACuTE7FsJFiqSMQ7wUomuIT+7mMgRqxN6XzFuPShgGgA1S5oaSyBRhchqHQRr0osY6TLv3IYxRHRqsrdkY2nAgD/qpbRhE8sBFcUD2f7aCgTk2MONflgn9l3Is5Abs3FAD1bVCV/GNCkY4Ta3hQb503yeyFIJAN4DA3D8Qycum4AVosiaNYEbqeuZ/AhejXDG04JaCIAK8pZFFbtTvaCXgD/C4j7GZrF0uWrgCYTbLbVoqg8+b8M/s6onNFS+uSjAMDKR0sxuPA+aFmuyQIzHH4L26y0MplcvuRyhUTuorUA+T8pxN41+7oSbZfTLr7+rTq5rXQZ9CHot+LEFF1TlAAoXM3ql029m0yLvnQd1iskQBJkQGnHLXo4w87dZPuSAC/0eJVtRfzRkrneLHOuNPK4dBHVPRH6fCzuvZI6Lx4AjExLnbCg2esx+ex3tGf3arWTLl0KKI2Ofa/3eJXhqQB2/Wt+KnLzySaqtqxs/JfcQxGt0jQo5eCtO7Du3tGSANhxwUIF3oKBYNKVt6AykR92JxBekWo6gk8aeXnQIssAhUO48D1lOdxxV5dZMxr9B9znDbuRpm4v6mY1XlxXNQB3TOQiYpWqysrPUNkpz0DpvTBBOkSkBwGuV71pK//MAF8z/9DTq1DPU9bbDem4w4PjbYVZNhIy2tnZos9wgegABoCz2IjS4DHUVXVy4DE7KlD0kW4ztFEJVuF32Xyo5wCJtoIojVKoxqTCFHq8mFSGwa5eY9JD78PUFzYGF7ZuABbJg1DhVD74KkRfWU1uQsAgPyULk5AIARQzpv3rNV8Af2idOz8JfDWgBFm1oi1QsG9Eq2V8esE7C+WCEyiH1gDHWnMV2LRF6EPqa72Uy0YwB2aF4qHwGXwMAUcl+z+GAKGRVEHqBHHGaTrviwZhtQGoT4AGJIkpa6Amf9i6AtQAzMefuMFBkyq24YdRH0lszXKW77GglGeLUU1rmdlhQgANy+643NDbiYACMI26et5Y/BUz/m9Gt9BXSvDep2DMAMDtwGYOwm5wqNH2A8Fy+iQ3xhqXe6czDgeYU4DiKR0AmEr6uqqjnClCf8t2SCQeJipfuTX1AIKsDGW7A0GY2ADRmXSxPnPRY667X2Y7s5mrahHFBj69JeIWCyvn8xIbAJkqzI9B4ZUajQTsZMvw/hciRmIiBwALO80x7OoAEkAAJqhaQNd4HBt5qxzbLTXgBFBPmylmG3lZZ5I0cu/OVADaehL1J2k69f99q4MgS5tjSzKZdB9WF/QarAx0dE+HAJIdOovpvd4n7Q+K7P2PqmsJ7fmw5vitMeuezo/GQ5wAb8u8+IzZqh0REv584hj4cXDiF7v/87oc9T2XZUPc3wAsDC68GC0orsFErQ2ZnzHyp/QhwdBwTWtctWnYxx4VAKpvC6xN1+VXkKnFJt94U7Fc3DRb5cVJFKcQWhlItF0AyIyDPjuH6aJ2La1TDxCi6Xtu3CJQ9tcQtUbg9exY+AAFDrvw2rNrQB3/m3leNU0nFAialeHGNWmqWvTlurZbAB6JLckp2WwIId5Z5ZHM0fyo6OFultEMqLB7uj9yS/QAXf+Qj6I4KcshuVnuuGG+vxy9TJ5mzXT4GdOt1wq6VgBh1bvfM+pP9b8lGruVnD3ZRiBazs1lXi77satWTvICAKrDGpFQyiuQx4b6NeBnLnJQVciRuQH0yLw4HbcetToAupH2Bsq7kiTToVEBSKGrbXTOJkKMz70nemQVZivmngAZDqso+aOQ0I2kBKvUxcTDc7kXziqfxyl0TrPHBUpdAHXAClJ+2cWYkynmt0QorWeTS4X2wVMGnY3igRF4g/UAp7X/2lKUEh6VEhXUCT3GFc0x8AShD7vMtSSHsGFMJADq2K8QZpI/+IKRgkUT5N/NRGmNlsQEswV1KlZIouq6AHtE2cacVbYjW7gL3dPywUTZ2g7NDo8r6whknEGBHVIAiASFEzYDcgiJ0ku8l4ku2GH/82kuTT4qd4QYsYOAiADO4AF9P9R2c8jBewZ7QBRcIsz7iVrfOyX/6B3xbZXQAPQj2S4Rp5bnFtih+W1lLl07Hd5vons3ZEmJjmFBcz8AmNmL+f2YewXjhvYqRzuf+jPujweBJ47Qgc9rJpgxnwBv3EDt3KDQD1uaDd+4AIesj7dbTvL+X2jE7cTkpHG5AFIY2lNfAxukz0jd6oVwSTx6If0xgNv8oawjxNOwFVgAJsLX5+eVs7MYbVJQToLag+R8hmWu6DtWLMIxY6VRYwDakIvXTv2MfqgzE5D04Kl/p87ef5q+9IUR4QFdSe0sAIFWEnYxSOLIvMiiReJg+gQNy8lJU0G7XO8XVANSVY8AwQI2sIaiN/dvjXEpIN0tvsmZ0/lJOy88YoKLJ8IL/gC8E3L324tT8afQv1bAhzn0Pw3g0UFodz/YZ/ZV0vu5AAxVqtDxcIRQI+3v/QveDSGrwbqCyDK0t937UKOdte4Abf+V+2kur4y9QE8uEK9U3w3VwuVkL1kiH5H7w7mpkADy8mReIk9B5qCnxfkUbzgq2bhAABqal4SW8VOU/eaDAAtzF5D2iBtXHRyNbNxcojkUdmlXxS0a98/lY6LMSPkAowefCK6qXiiXjGLlYuZNjH1otHYojjhBJS32MutSHQCfimdtGPTdv5O3Yo/NaI0Cs0dEDghfGF2EiPQWAuA0AGfWDvK5u36uV5EaSHLukKwQudUVv9Ba5hHY2AqUOwEAwEBYmc83oyMmtTWmw+3GujZQ9afxcFPTCoA5zkk5WQBOmx2TpxdgnoktKNM0uhfWaNPctZgljDMnO57UOocPAAw+B5xKFkZXJ6hnIjj6qBg3OOZ8lqBed3pKEBG68C0ANdptIjEVDIdlN281BBZs/kGjOZ9XOZu1AX2oFjWHJgBjhrHLrQ60sgfKuTL/6VNA2kARyLL7ldCGXDBilE4/AN0q92ryQQNV4r5r56W11ejNCiFj1oF27XQJyDsCrisAXWqPmI0brvE3yp+df98rVwOPOj/ZNF9uPTIw0BDO8ACYB4pR+rlFN4Ys2lQeUjDI9u6nyY0zikeJa3/ykRmbAC8XRmA0PsvMkm6aFDyQI4C5XJCDpVCXt45krKPh5wMAXz44Vn2kbmpHc9CclCMjKYqwwqYLUdKpUpzlyPkJ1QBKSJUjd34gYd9ng+LQNCqLQMbo3hPdKHf/tMHd16n6AEfd460VP47l3rKp5PCerR13/SZmIAhdmYNuIodp9YkAodsDOGyXrX9vSkSdC/apAlt1t1iihf+U6KXrIbcubwDdksNxJ6rlXZ4or7QNIlEO1WmDTk829DKbt88hgEw7AKRS/U7KSVtd62g9POmf/knjBz6ckAQLeo7Y2NJSVhkAjXte5+a0s6mRJnLVdEQZb/j4sPrA9mGRFB2RSm81TQBFwvOU/7xgymq2UB60qW2lN7OpauwydajQunp+UqYgADNMMoQuDxzvXR3T1K40zxZ0XqPAqUhdGABY7Bdu8q4A8IG17sY/je2pEHbrhRM0S+IDlRN/0WExLsNpI15P1AAuas8oghCYQ9FW/S/eM4WvHuC2mduG1fNoEf89Z67EAKgsdAf4aZIdo3yKSJWpfoZjmRXt9P1QQ85phWNu0noAQdfQ35WNj4aRkl2l/7mhs9s7k9uExe9r3ZpFg9kF8gDYrJYIXy5bGIQhKBI4vzqVWj2m/8a2CJ9Bzrs3q9I3AK0TYRcXRFSAkmsnCJVC4ojmsPKxEcSnCqUGFSpd608AEKbJp/ErV6JePCXNzg4/lcXYX3jgUROKuMW+8At1LQDrHJdoytR48Xwlu3zMWEjF/BvD9Mxt8d/nZRCtqYXmAFFNEkdYJle0yU+/flBpmQOTB1auaEG1m0ZNLHSTJJUALgVMQWyFfPT6ujuw7SJcyOMBtcZ4A9yG5lYPjMBD6gC3shsTwRewLJNBv57NyQuch0IJqEAc140PTOuGDI0CAJqXYav2IwjreS+AOosSwGamhAS/MhIJ7fknDf1jt1EArNp7O16jiXTZ7C0Rwv0NIPHBfWSPyMRhEUsIX+BsxQBVQ0BGV1CEXnpIdNX856aVcHF0Q4Kau6+MmeiydonOAIlHjIcAPC7LtCSCv/pA/HySpTFyKMo+RWxLU220/C8AATjK4Zf1sVRB9h986Whz1Fh2T6ySaL2ILFY8zCDEpAAlWNGTuOZ2SAaT5LrHz1iooXvDezSMPwmX6LfikqurAJ5Tbf3LB7P3bW3pFuzU+AfVziu0KyvabE1pYEi3ktUAUFX9dGSOCIGS0Mx0VA1TPx6b6GiK/Mdvz59CNJK/1gAIuhTB3loLgKdeKjSyKFzzZEx3dKz7yVIRCuopStXSALqStHIZHeDM277N6cl7vurkHUpnXotW5R8uoU9tNqoAFOFYCmBe0EbY0BA1RcZycwrNLspbSDIORJvQrbGiNQCWsSz9+9GBq9gJ/H2RRuEYptEgZKineZw/+sGeCfOEAKThJHqa7+4H/d/QCK8U9HMuK5+Nd767wOHPTTlQEjAAV//+U40AD27CHQ2qvQDujivsHS4QAmoA28yGlduxrwDAWVmUJNubetctPLfpuXg4nVT6YmKKy3dpozyWg6/VAKimwJmzeDFRXcRRM/U9f/DE8Brz8dCYujfL/G/7pDIAMGSqGLL2PVljyn4DCtqxewpNPEkxBbIIP0+Z0bQ6NAAab6DVTi2ndPDL8I9/UFmzOZ4sWB+vLHMmYSsIp8gDAJuuC5ZUVmTZwPyvVvj3GB160g/mX7grHSyG6Z77Ey0ArLQ2N2fk3laGXqQ1x6i0OcOKO76mPsBY91NwdxvoyADIKmqgGScYGlh+aMLT5K51JpexR3jFWP4Y3FaBMuU+AASD9er6NH5xFUWTIy8KLficGiOvkqDq/UgiiktqWfMAIoONU+7RZXcXIPo6vJErdrXJu7r+kR3bOUn2xc/VwgCgy9anZbM7yuqIu9Ts1smsqHjnEahqrAh78BgThSzcAMrMu1fhP86sIp256tMseZUYnK0zzgCv2q8IBmOSgMEA/1MGKhv5OnP/wOG5irSqkxYLzghhyDKlufJfI/8+yQD6Qla8KWfNHxbRrpMOACDpxpvZY2RX+EJCDBzm086tAOhFonVPMeJVZEUzqNPnm0J8v84KpyIyKv0mBvE8LcsA6cscwMpC+9ozqtQFAYXH1GzPD/czd0hvDaQ3Qrnl3ADg5N6Yg4U+X7NmZh3v0SwOkaJ/nAybr705kaIdYe4kAAbqGTR7zPNDPxnEtOBJKO7yWMY5Teyl1R/l4DgbvOUAN4utRCuE4fK9yeFtLtX3qNZ7jjogxTXCPKqs7khihgDJ5kqtHWdZaoBgtfzjov3bi2QExfLWMpBHD7d++2auAKeeb9gHKjLJW4oTiMR3iE5GcC4gVgyu3lCBL/W2X4oAUSjQsfcFfjtL3AU0JZwXWNcjyz+FVwbZjvs2wjWSpgA01tkzkwFYOXMWKsjN9+fh4OrViOK7+BDiEVw6UrZiAOjDD8nCQmLagaVCxT6V3pu5osCmCC6lMzJm5FeTZs4A2L55Q9d+toFi5UM9GmVmninprLZTplhRLPE8CQUXvwDHpfNfLyUUB6hT0YyCpYcMgZIIXg+fY1tWR5eqAqcZAGJ4XmJbPnovVPzkhWe9esZl3cgAB/CPFHdj6ZBV244AHRhh0ORtT0I0wZVvcRhWn4VijrL+dpqywGpS3+dM4gB/pIpFRdnVbCmNqtJPQTwRhmyntTuIBkpp4lisEBM1ALYA+f8FqYafELrJLj1W+SJImqk3NvfnZl1Bk8C8LJgA76ch5dS+HULDqdPDzSOYYLL45Kg7CztM4Bn9SRK8YgDQXRz+Q8tDmIXRV7dY9F1lEeR3bZoxzgIj/VpSRXX3ADsj52nGEbaZ3eBEzf3KhoymgW8kqRPLMGAfsi4A5WEAZdouIw4bohR3vNVtqpQqcdt1vfR5Ozv73OzTKIE/AABxYotLfZxjNmDkI5qnjpzxojJhF7t9BsgEW+D7+bM8ALkfYG2o7OyfguPSDYnG3y3SJNo80BOsg67k4j/V+jIA4QilZECn+Rb2TYiQpp9CKECWERziDkRMw1t1za1I5ABCLynKqzkXFktsLArk3xv2n3ztXidap1KC6gRk6LyPAEax8ktW64L7dVn+odCEa7NKM58ewFkX1HKpUVbQlGQAFL53lXFC5mxbCQOVI4HWFxyVnVJ/wp2jMxxMFx+ZfQD9mWnPGG2vV0WC59RxmkWw/aWe4DCUj+I22GP7ZrYVADbx1+UbDFgnmbDiUv7rrqwHw4EaVXtl3WAp2/D8Kk4AC3mjqhsoTolcQ+Zlq0mc6p+Yya5EnmfUFZ3ofa0BxABWj9JByyj3N0YT6V7cJJM5b2aOIV9i5jhxm/3aTuQGABZkQWTjVZznjRdcx6SH3zURAIzJKqwbnZ9iCvDVXUkAs2b0THypNibC1QWeDm8X71cjv2ZA1moWwpp7XlPvNQB3X6Imf67J1/J47OuBUwjRh/Zrj6AqQ3D6KAZqOeCfABfEJPfPVDLttAsluPSq3ROkGf6q3Ew2M64dzLLkc3kAs5ZLsYkUgabCJbQPz+jqOraohV9FgHQpxQwO9whFoABzKreEOMbe3D7n2XFMXET0JDr/4SKoMcyZmVLv9AqcAK0CwirOtvdw/i2IW8iuiyMcq7ek29bHza+Kz1hbwBYAZshN32w0R1ObhnKt/zgwYGRDZHREh3FCPGresqEh7AC8JjqTRqHMv6Ht2u3BNAoZlcRHTq7s5HZSP5c/ufFqANGX0Us7NLtuepXF8DEYKnNLd1Piecmja3iWnzAeSmIA61l5QHIeMB2zCq/sHs9v2toPZn6q179ISztpOZvi+AB5o9/OA4ooRVDHw0clMG6KY1G8fkfC7Q5fj+0rEgc2ALTNZ3X+3jWAgZWZ9/91OzcivPt5qh5amzbqJ5rpuQQA9/1Ez7JwA7Q4OLdV+RgG8sy7TIAy+xEztpvIuMkOhQAnDZCPw8MxnkORRsBieZD6FrbcoFjIkoQEUYbIqwc1AI6STVwijRJgHUeCmX+LMS87qu656vdkbCSpw5isXEUAdZ1TgyfNB3+deQpFXU/GJOAtpjXL94AdQCIhqBnXAQDQsuSWDYdIPz520T6sG25BtPHcY6XCKKHuxaduaQwFAARuMpG33SUSFy/7i2Z6gWw0p8rviu3+izvJod+/ZjIA0p/hY79DSNxJ5TESdEjaS/dJTG96pvIOdf3U37xJrQCWEknZPhIV911JFWxNk0CbWUXbVKANC/INbWsQNZjDAPJvfBKzrrm3q1YGuob5goq05FCnantOrxvh+oF1LyEA7mu8wd6UoPH8ixNv0Hla6xwtsDif51MD/iQyDy7i1QCiO2Ml5vYW0gQlFp8H5c3WA9HlR0tq96KkDvmlXXcUABUhyDO1Ab5h3pZoqm4VnRBM/pkdIfnMf3gDE/kj5FAAuI1koklwnmIwTwaEiN8uP+aDqFHnOt2VwX5dZY6NXgCmUOcBqtPpbo60Q5hvTRg2vc43DN09Z+4epTCRUDQ/AJU8fFZyjHn3afKcW5dz3mIOe43oyGM9utWBbvS/18gA5DxylZF+hthPp+JvlUE05d1nh5uASn1Mw97ArnoDIwDZN2ZavLdy9XM7Y1jBJpCANpNq7H8x83A3cVZQriEqALj7aU/uFoOQG/DWoqyMCTlLBdpaHjnwuQkR5KNxDIEAkevdon40OpssSxQS5urqRAiBy0dHHoMfWXdxD388+ABsSaTl/HNJMJyzipyiMOXHYSTtzBS9DKaiiRC8uc/kACkfT+4o4e55BVbxqDqY1H9NpSXgoIqf8MP/XAXYQPYAbbG2C8B9GR+4CFwd97WdOUxZEg02NrUhwXFv9U5BAAAUzmk180teZujoQXk84XiDZeNALcpT5wq3SWmTAYHGAAi8u9cHfS7w79XuNIxInUUHQda4vNO7fspRCAl8r4MApcL8x+H5uNEo2ApPoVkaSlcm2omV+FrDMJs2ybHe2wANmlU/IQe/DqmfIra0QkwRTr683d0kwOaZzNw0Oj5mAJbplf7rniPzlgC06P/mm6mlvL+JvKAskoOGmIFPp/IANWcqCmJyfDcKWHgNKSGE4KgaBFa6XO61EGBfxSB+NQDfjs3R05e71XEWM9KEyIqvabY7/mrSiPNgUVXAnJx+AOKFLSy3jzWeB6K4R/Cprg7of4Kpb4yGoT5sQ/z9RcsAGLOL/oQy+yecoihozl/g2mEixUvurm545C1N5OGDFwC1QV6yJp/30/gkHvD+LtihI37ZBkYgXtOLmIptFp+TAHld5p/lxovVnFx/egXwxXWeF0mwQ5ofJKuIu+Ow1/0AWCpV6GsKT0Ok9WERIfocOgAPIuvG9kfRSN0+nGQS0AD1fWyOmiFT2J6uvY/Zv3N20GXSfkNB6pRYNQXkpF2xAH7O+iWeu0a9V9j3hcljVexS2WmeuZsJdRU7YRW37CoAE/0VEbdia4SO9CxguNGbO2RNc5FQulaf8cAl676USwBridEWxKAHDzGjuvQcXQGgEOJ4oslxot8ww/NZuJquAJba10L53hcmZbR94dtef0S0aZwFXcf0IAGDjzcS7FcAompPEofn3RV/3yYDcRrOOUnq1nWE5lhuZIY0O9KkMQBdY9SDfZvVy9Pw7WGZgIfhWEKWGI2gZDcOi1PgPHy1AJCEzqrYiQV7+5UNZyOlB/3w2sFPh/Ytr7+mrLeiGqsA1ZUDvpUSqD8VV68PRkPzytPae8s8XqUBEskNUcMs/ADsLkhBN9rTIM8okPM6mzMJgrWXTH8PRwsLIi6xL8+lABHCuoHOf+AxTsLgPVp4uomg2qW+ByZZBtjqh/7VY8gAKMUXVS6NiU22QKxrBIjccjZs7M+ILVPfqXMdz2BjzgCSWKkgwp4vGWnplha6iL5wMOaAOQa+oIXkHvamx8ORAHX671M87VdiDmEzrvpq05OVpaelf8mE7rGYn3n4AHAAM/EGTKsAj1Ztom5+cvsazRQKNizCiGWQRS+i3ZWwjAAhfhL0KH0VoGVkiFElBGZcuhqHyioO9WRcarnD6DGqANaPbkTJkb0RvzVdhrciZiPGnG1f8svw00l//buYr7UAFBItor2ZboW/+b3oQB1yIiUOT/VcDgAi26cG7bSlHADUg4HCR8oHWYXh5be7sJ37yoCyXi7634EX8JSd33mAAHFZssXeaVehWtaEkm+jVIV+OGpa/n1eK472C+E7P70ApBUqioHFCePJxw1adGZAjK2sHCeFWnQ3bHtqF4FhTQB0bIAf2QnTNngjikHIaTxCq3TZ/nRERcMSqfjRPBqdAK1JEloqYjKFDK4fIMlqIYE14f7ZgQ37IpImVNM1R2EAi0FYRdcEHb2YTC6didEM80UOQLAMVq/JCfB0zTEacQBpIoRK/TyYouaBV6c6zWByGabx0PdBi+GzU5KVRwBVAIYWHLvyB5BqgfeVbRMnCSjJDwD6Zq483TuWHMW3W9oA7ICluJdWW2a/34eIqXp0azcPBvWCGKi8cr6UDwWeIwCFQHueKX4dc37Aog2PC4jg12wfu5P1aHjHBA8+oNN3AHMV2z4p//hGRnb885+liPs20+SX41E1eFntGol4/qIAZIR03YlRN6CUTLrPtrMvSQ8b0CbUZHgiqZFxicKm4gDqqivZLDA/whHOJCMnuGmzJ7i5cWvlNcrgh9T3I31iAI111NpPflPbPDth/zCAJvd4LnmoGKlZoW9rq0vLSBgAsOY29gfVjPPG3hSsGBvZs0JBKxC3YRbFeUoRCfSs7ACeVmJtDykEzRk0y++5nVrL9ZdmcWTk1Ja3oWqEQnKeAJ8MTWu0SloNjPIiLveCO1rqkWotErRcmrhaFUySa/kAg4HcuY9GwBU1hQfKm38u2JF/eI4qjX14zLN642t7YACmqG/UWSLkVhAE4zPTgZ5sfshFoKumZezO0O3Jwpy8ABYQCZhJTzmo8f5pmG15e0JWJAMODpuyi6weNf7it38AHOJCVsn4uqRujW8xojshGGR9ky/cyzNRW/viAt5JzQD7G2iAgl38L0JB2QsIwzZRs3QsIeLwBMoKEwifiXXIAJ11ZZPxb6nvkzO66cflYU8eru6AdtKoafMWdrb4IMgAr99PZkrj+dHatcYf2PQKfp+ifsg8c5oJfr1Zuwv/9QCpJXbO0E2BJCKW2JxfA3OhcTEcNbcFjWjIKalHq6drAGqu0OhD8/LDPXevGJxSQ9WITUeuogR6Z7uGST/N7RMAnHHWNx7ggodxkDdiEXXw8TGo2nus89OekdRJp4z7JgAM7mYhNO+hE6D3GVEGPatUkk8LU6CZSl3GaV3Itj2nAMrhcysoVNCmWF5+zeK+n/Byg2YDSZ2hcAJSussTbnUA4hwapwyVMWV2jN9FHBXa7I6bezfg+0dBKhbpKYPFSgA/x9fgFkAsGhwEuAUSjkl3omDncfjhz9FahAJyHUcXAPBGs/QKcSq2tvxPbRs0RCNQIeXSMLYS5NMAS9fkswYASSCUNH1JVIQed6S4p+1jG5l/6zsqRQQBHXjCrlqt4AAXOtaufQijeTRyppnfvni3pxV+MAQ2q1lDNsrCRommAMqecbu7iH9vaWgCpLLU/C+PE3JouncTEoL01h3KXXcABJuq4gtYDSKwHPJnkLy2vzoPzibhx9eg4cwl2sHWzgCJMpNmghRkFEpSCTna6buT9g6z+7991KvlJ24NTF8FAMHOGJ89vQ4IaElFSfDq+DavhQgaLJ8dxiV0RCeoSlkA+IytAQe0wv1kQQu8uRWbFlhKCuh0VLWAnEd+Q1/CFgD+UZrTNNkm6lJG1lUXkkrUB5gRTuFM1FZtxoTEXg9bALsy4WsNtUfLJdpSwzYsv1pG9HRT9V4wfQVc0oU+yg8AOaEq5a79gyj9FESNMJS97rJegUVK6+Taq6MZR2Z+XAChe1i7LaJLyA6o+tF7ClqO90GOUUz6nwRuxAzpaGQkAEJ45n5gOI9QtfUCvmD8S0jLqCRuayYkwpK9ryY7c64AvYfqy1lgs+ybuQF/2qyrn592bO6JAsv1VyM/lFL+FADeBdEikSY8KDpQxpSxJzc3nIJU71zkyDzgCxnTEqsnAO3w9wUnTTybS33wMlDX2/mTcUluJqmvBR841pawoFgAuaios98MzyeGkBdFjWGcCbpmobb8xF8slKxC996sSgByUEfdvaFGv+C/ATpXt91m3H/ReYW60k+9lVDL6TSgAJ21uvQxiqJ450Lij1Q9TiMBA/85xa3N7nRmNvR0A30AhgMMK8laiE6h4agFXqzxod2EtKy9UY97zmVZmKq4jgBrxLTQCqUh2FQdrw3CRYKl1O4bgq6NBfTnOSZZxSULAC8KywRKCsvc6ysrrtuUjt408eAuENn9XdDNVSeNj/YA37wlzrYZyS+PNGoyZYnWkdp6EPQjiiArmJjI44ME2AArWsCNTIyUyEYzMetm3JAfa9bAxA2kL9gGwLFY65stAPm4f1IiLIfzCrmJ9zYeIICbwnZTUrWSKqJCb5JqVWgAPExet8gYmJuW3K0xrQ6kEF8C/UffjIuCAHjOV6AjuwB5/w37cRDx5ItiQOgCb6CXZZawu1orVdb136ZU3TquAGy9atu8DbJijRCSU+OrUU9HAhd5q6+RUS3mwR0HFnIAmUDMEyr76AQ8IRo2S9A1hyu10Zfl8cYHKmLL7C5IAAD32wVEQUSbDKny9D8Wwo9bPFj5VEct31UE9fQHMwPbAOzP/putOGWaLgrW69yFhTVJjctAo6XqM6twO3QRYM4Aw4OzcggREBlgZ1okeTSRg0/dwNK3HcbYgJTdUJ9EeQCQ5UrL/l/DgYz1kxKXxIWwTCzuiDG8bioHEPSTMUvyAAVlorA/kht7kfx/IO0rtyEJi6uYQsi9oH6ONq/qOMkAc8dNbCQL3/S6R3OOcARFbs3V9gwLbtG30Y/DoOezygALtOogMgy8tZCRacDwz38bKKgyMH4C/Ep0ckrFSVuTAC7cgPyF5UxcSW9g9c+bPyLPjWC1Nih08/K7HNm6PrwAxxWgBUIZ8xZFF/UO4tJojlszcg+O+R3PeC4FHsuZHADmZOOUqZZP71t33lJcqE4yG9HYGzHLvKkkUp7LJXj1AE7va4yRCk8/pGuOT+HVopxdFbJ+aNyFA0SMoa5IB/QAOW/b22sj9OwudEDSDlVv38Qfp45Zxztk9d5veOHI1gB05kjbxzicEvJvGvFEe0pUsZkEMnRr4C2DRwUHA4uhABig5grxclO9Ip7iF4t8SaE3ReQdOA2DTHfj+Mn/WqoAThPaoHahYs1kR7tuBvKbQRjBk8MFR9C0Bsk1XQhxAQCHZnYrS1oEJvjKtMhYGR4p5KbuICVARIuuCZLu3aCuALLEG9Jw/Y70qv/xWQIKh53RZ4spqrKh7sCtUWCS+0kA84FfYXBg8LvywwV+b/dBcB7zeQusflcI0Vou02JWdAAhlj6Cbrw77qIgsBEkEMSOGTkFK9ZXzA/UgjspHj0yAES5XzHBoHLErmZfyhn6TZktlI3Q45EXUvj2IzFuuIMADfHGOzIhjp+0tevXRd5vtZYZ7AXkthgA019+xyyvoAD1EUS/GDBquWb53C5xN8UcRr46Ui6R+iL5jKCB/myzANH9eg2mxMiuqAU2U3MBMoabegd/6XNG5ATe+Jc/HF8AFeRmWo6KCdHRuXIrLYQB4yl+ZM+Xot/uzetrI9Go8QAVdhVqSNDwN1b8Yl07WGBJRulpzE+FjmtvoZsoigBKALbtjm2R7/D2jvuff2cfKuQnOAV0XH1qoTrbpVBxOmUAok6RDAFXbLMUDyN3416Mj2CFcC7b5j8/vjnBFVNgVwDTYzY4Tx+dbJsCnewIxQO5eNLFix1k9nf7CT5xLQ+5AFXcFvgq7YOyHsBIJPJBfQ1EyDh/fqq0pS0MF4mn5BMARIucIs9g5hEmMBsxo7K8eMUEC35HwPZgeMZM0wELrwD1tJEl/Rnw/EsEn6gabrmuhwCXT1ZF6sUxVjBtlhCtAM5UkjHTSwge+OijFv5dTsui7+XdWWQeXcapVUV9CYUA2IJPEJjRMDaQNzrEYiX66fc6sm2mBPNnF4874qrs6QDU1ujlQgGX1lRktKyHkpQgzItBpO40XimcGAyjiilDANeQWPZsbH2nSS838YPwT+ni9cL67scMRP0/H4iuf64AE1xaLRhOMxhy3KFusKADH4f7WzDLjYRS6Hej9Kn1kgAqWeC8WVHVKvSQYkcZVfZidDHsDA6A2ORW8tajF8u/AD65hFNDulw/Bj+tlouc9xjle5j+mgegImhm/XADsRQA0SaskLhHo2GDVe1Or9O5jACIVENmiAB/HCy/EnylHgDhAqErpDC/8twZz6yTG3Xw5d07zx7aF7RhTbSxmkQ/AArudsHIYYsru9Z34itFOhECdQ9PhslmHrFTBP7rqwkAjknjITz4hofezupvy4VlS5TdRsODNMGXVMVs5K0LRgDHstrXJ1FElHvaql4H1joj5s1a2Fly8kKs+kzKbYKcAFzrpqF1iClELIpRrFPuFXrIZnCkBrBBhG7zhxU4u2kAqfFUyeE35zy8cy9gu4fJE6IJ5loHkV5iM3blje4dIgAh72y8dtiQtsyrFTduXjU7zkluSXTZm8ibBaB8jF2iAIyZ0nKNjzzggpcs44aNKt8ecGOM1ZIfIH4/nHULu8YAg61FQUqc8FUPR3O8ThzNwD7GfXcumjBlN31E6KuoMQD3C5LPxAaIYGB6lIkQjayrS2ErSfrAjdIMmYP/W3YQABdUpocP0+uLsmjwAKw4wP1Zl0XKwxksBZnusPaGP94Af7CnFvThS4yTnCtA+/4HVQeXBO60jGQ2E82DlqOmCgBFS7DqrVAEtcl9pHPZ86JWsgqHEgntp0aSgEaovPF7AP8j0vmEjQ0NkwOt6d9Dfi6g4b8X/QzccqufK525rvUACgeP5APbgaDwrgttOmTFt7xzbD7oiF4pnBi3oXQA0wB21eDI7bEZiBDB0y+P9s5Nkfo1KjiSY8nhdNCOuiEVAJEopvSt+T8POUe5JDTWa4zXx8dvOQ2B7YnchcM+NlcAmQUKpZRtdLTuTyFJK0UdCu3jkgE5cvSjvCH4hyGoRwDmztwuz1hpAdIUCM68pZBMf5cVAyZtt7cp1mSOJHYDAB/D9p2gbqxIoidbJFJaw8/F8uD6bypHSHdi7gE+4uMAR3/qyLER5qr5hQGC9yPPHoLMb75/EmtO1aiukFYi8wAIdB89xQB2CpJCPx6iYzxdY1mOZz6tFh7JXP6BvOI1ANap3MrnHrbQbiSDOb531A+oSf9kQAvHeD9E99a76KIA4lW6hpu0KFfasa14bU3PrkOd9kv8G3k7DB9hAh5ZlAA0qWlG1MvzP/fBY62Hq4isEQZdP5y16AEZj9+H01JVAB1PSX0f8rw8lC1N2hQ9sMWZQdEY6vi/GYBfLt+MrXQAecFQUUKf5odfl+ewLNjdKpabi2+xoJjTnhPmSWHqQgDfHwCdO4SjBBtonGrShHjHUfQ4Zyr02/zPE1UvBg/6AIjJ3may+aqN/pCbt2F6sZNBAfiw5YMfWYkV/zFtLwQAeQNwFYFj+S7GB7U1n52Y/By3tmoTFbRWghaGsOL67wDNS/XKJsEtNp7tJWf3fjKK4uP6x1WLwNqVjAqk/ne8AAv0s2knyKDDcWyZ76awETnx/RgCy9z444Sxa9pnvX4Ahf8Ha9smAitDbSrHJi4w5rK4996Eb0IqxF3t9NpZrAD12eoCZItxI7wpQMNgPDyDaeCuCXhWwTRsu45yNZuHAPdn+HA0BVLVQK6e6muxRldkELqU+Ik4zqlL+ihnQTYA6BVFi4QK5WxGEvxvoc4yZfTDUxNSPaBElBpAdeSF6wCufZBmc5KPJDKczUFnyeUiQf5pSLgvuf/1jz7xHGf+ADZqfYxLTwcOqjaeg7EWMwZxZAmLzYYKkVcMq4K6Gh4ASBIsjxcL2z90r+yqWNkVzH3A+bYpqYeCncnDxgET8wDdSF5SrU1gJixLORYI2WWDTEQZkwpkNLVgyVNF628BAAlGTHGhiGaOBqd21WIOlIPY14QATcukYutNUk7cgKcAIG3O20uD3J9BtRXksH+uDzy6XUl0WKHPoTBAvugBDwBfnA75v26XuilyYTSGfTuhSRNAkny4Y/W9AE0hY/IsAHi0ExYPwZEjWt/rCC/a2WxWwJxOWv+/jbHab2nJMtAAALmhKXehiLJ5m6J7OsNAA2TFEOwxaii4G3nuvK16iQCc96n1Jxf9dTJ55x+sYs/nw0S6+4kMLZm1eRi9yB0nAL2xTYtCUZyR6ywsFu/VhnClhdhFMokUBekegtUxvDEA6l+yRF69D4d86VxUj1foF9swgf6rIjHs2+YehRWlQQD2Y8odcRzUUYYHzUh0rdkRzre7PhitGkHstE6NWpPbAI1iWL0xNqueky4X5RsZigKjzioRaVai4q07LhzMmlwAPacjxuCz+wBe9Q+y7QgV1GAFLhdXQSfvZBWn2dN/QwAa1C0iOFUuttgoz87TFFOvzvwgEfQYSS9iONpCIGJAAD60GuGRIU1AXGSmnwTKAyyWJBZr00d5lWxmIKFpeoUA3yvDy71nY3N9CJGpEgEDyhrnAODqzIpU5gTIhVdgzwAJIzr3wzZb7aOlIYJkOvXPaWeebSshnaTvUxLU7P8EAF95Ml38V6wZR3VvG+nuNAIJKpu2Hjif20f4on3hJIcAzDWiaorKBOlKet65DfskkeGWCx+si/Hyl4+bqbcfDgBiPP3fdM5Xf6+Lr4xIFVjw+1RhcYbL2TQ8Lnm5iCyNAGPPLGQ4VxxYHQowtjxXKPXOxZms+L+PPd4WP4kw51QAGCvGXuxV30Nd3ZCtNqODlpN6mcXk63r1YD2demfd0gChQD3KfYZl1s9td/lVxKc17EWG5OvLajHHg68vg78aAOoX2kWWQE6tyaGekRwGuPuwymdJc8ApNvatA68jr9sAdUPNSVNICjTOuEbqNwo19jVvNmjXWZY8z7z0QfhQKQA/IevmG1Y4wLrpc9Wp0j70O3fgVqwf2aay5mhNaUCEAKRtsAv0JwgS3RIF7iE6Zj3F4pk6LYcQwflEEJUs8a0AKeZcC/TkR+YsNnzsY48YRlq5jTn1BqcolrXcCg0OAAAvNK4SF90oMWUHyV8Vxg2gBr30Tgz8t2yo6axjPbroABFhVSwnCp6XJwuhU8MjVimZ36vVfQ0zKn4Q4LtXrN4AttwkUcB/lDv2DIugAurcSo/G3ILF+7pu5JZqbumTuACcRKUC9TxoAiFlWMjnbprkOWXMgVDSeeUAMLqiOW6fAH06U7VxmucVKzzZdhTsgm2alh70TCo2hYVp5AyBiUkApJOJQEj4PwDNs3O9ppDVMJOpCujNspmeyah3W1ILaQB7CbXkr1xsTSHfXBPVHJtHAePvOjXbpRYY0EsfYULmAO3/L7aZlcDqtcevDlu9vn/2mGM+c1MqZeJKF+VGj1UAejFHjCf843vOsjJd3FOIzJW8/UaGEWCGbBpqGJfIhQDp0ETTg//hTunoiLnXrbTGT3wy1Gh73O2oR3AFtW2xAA/IzC6o55YxVr6xx17N5yng84dLH8BBvbZMHXvs1OwAoNY+LgN9BjksXqpd4F/K4OOKRdDOgmqVj5q1uSTDYQABo4e+JGv5Kja1eZJbQbr0y7yxYwpWkjRy1aNxkT1vAE+VdBjudPf8KX19wxmkLECfzgxXtfb+bjzXuakXDfgAIE3/51Yf9l3GAzDJgJH3hK7NyCy5oydhVdnlbbNVFwBqxa65qMm+/2JIzd9jE+MoiZIu/9kUsSAyTxsv/HNyAONj+b+xK8aFsNvkEYVMMxKUtGwMs4yagmVXPFWpWuEAKpW6T90j7JHA9077VT7p2Q3WaFRNCTixOPBJ4Pa8mQAQBY8wseZYA6g6xFBhplOoCq7tLOv/HaxttEHUwsfhAAWh98NKcgsc5qUHBntup4VTFhmzBjq/hOV/Ww2kMJIAdNPcV4a5vyR6wGCRz6isnHG2FrcR0KnVXN9ZYVJaHgCXK588t91QJ4YT4jro/4bwPu3HzvJ9fWBQCsFyhvcZAFni6pJlGHDSIGOGpkgt/bjtBfIeiO84p1RpzgC2G1sA+7/uKJXPGj03Ui2KaAYMFUEo81GMWkA2bzEXhHj2TgCJvEOlsN+YhvRZylLTn2chDgsczc9c3cb7LGk1wxLTAFElUueYE6iRlX6Ye5dTD9qHYboNElwnNCJ0KEYCvzgAz7fXuIETkgQHP+Gb6O3ZVa8a25x3s3ZnhoRDMJ+bHgAufOR6codTn2favknupiYzw7jUAIi2cvfm70w6SZMZALpH3WDxXBnza/bs8d5/+4ih/h1cSWm/w4cxW4OlkqUArCp6d7oP63n5nKAdfkPqfk7r5R/6/GF8yFPqJgWYNQC1LanB7V5W0oG5JXkCcB28aL+F+redwq/IDXKVGgZuALgqeEUpysr2FFW3uw88TcY2spKurk9wOs4x9Lm7GtEAKn6n2PkC+DTiAkLVQcpKW2pCVTfC3fimOdIZ+7mEMQBA8117Z9aHkbLmaAFxPyMxgSXVrhDp+dN6VyWMqZiaAFwHZ8zOhFNY86yof/siZeeYxsAmRvGfs+X8t8x/YoUAEV9TEXV+q3vcLNfUDdj3FSQzegXbyQAc+NUOYHPZ0wCJpkt7jB10sqGbxe7H8e7bz8VPaBD4X5Vo+nryVTu6AM5HgA0tNhSl8rcfMxvwWG6ElLtn/fVC9sjvGOItGr0A2kbmyBIi2QZibQHk6JCUoXwySU8p0pSQvuNkA/NomABmFpTsNN08MyR/GzGahmDx3Q2cN5YIl5REwnGLLGTKAD8ehgnHy+vv2YnfNruIcMlMBR03wzTyi3vK5ETIAPoApn/ycW5zlCTSuEOPQGn5XjOWaA5vQYOgIhgxS71K8wDUMZAvHOADafnT/6twIIi8aVVWkPDjk47D3yOoYfb4AFQPsM/h4hvB9w63V3fHIvLG3CVeiToh7P/VivyFbP4A6bqx32IX3uei/37iatGhBgRohyXf1QdkxCGkl7aeFgDkwZHZksKmEG0+BG4k9a25QKudTjWjMrL0O3fQo7v8AFJJwLTbJzxasy+k2HJP7Th29COko6MGEkYHhB2ZJBQAzD8QcsscxGiALnR4nW7m/VbAfHuRPcaMx0foinKNDgBF1jdQETuu2Rw1hxcngVsIVOUza8cx9f++J29AF8VJAC7WFMYdpjnORuF0WYrNbEIbnAqCpoWIf/tzaAXXqq0AKYe/Q06YkhMdp5mzCttm3nOfh7C3TQrCKBPE2yjmCQBcgUa7QIV0/TeL7+qacNcbHUel9E9eMFX5QdpNwWQoAEKGsp+0Y00vD9+VYozfwmyBrirMD992YrF8THvDcDIA1B+p1iLqtb1ewf3pX9dyy97XVQwuRJoG2N8YD5NmLQAhiwh5O4uUeNTmaVz6RRgGw21pRNVtvEEArqnMeJ3MAA46lLnywMC0g+AbOExHmuwl/7hhIAm+LrEiJmpANSEAamWqgC4nOLJ8ejAQ2RTmg2IiTg/a0JFTUS9yuHgHIQD7mQXEA+Km+O+lWredIGepR+ATthOGY1MppsCFTQUsAA9R8sDigKt+kSE7xNZmBuQKQutcXkT31rMrYIYWGzIAVHTUB6YWpKiELynb5ACNtBKjtGJTfSq0EIeVZu3AAgA9WZdPim/FAKfsib5pXnGbUcTyeJyTEvszKgIQ8OCYAOH1t3fQ3bst/3dhv7EhX9w5fNRjT2m3+S/84Rh2AKgAtNTPOdtgO9+vv3iH9qk28dpnrQgcZ+1KbrheT2qAUAB9yqSJ3UqFPIRTfawCRXKFgqIa3WJIDBALfg5SVkFnAGfNB3YznMKQ+ZIlOTdEBV5OOv9XLWFtZG3I+cxLg7oA83n8UydhzIrC72NmsTOmacvfwU97bD2Q8YYLW+0klQBA4GjCa0obu2/vwokeDJ8YT2hLIFViXwuNEbk6wWQaALqMKCpqUZtriUkcryJJP/r+eDL6QPB8uaBRep69rN0A3u0zVDa0EdDN/7uVYOZP0jgbbJvGcT7zvNMcZyEdRwBwZ4jCHIBMtcfGsa4+YCJq38TKIVJfkFXwk+GCv76CAFItogks7/8aF24ZepibL6mPyXU5n1kAPeqaGaoefMEAotbnMQwez/kEDjY/J3FF0R4jrazYmUBrbDGweTTbYgDyNQaLoXV7ldBTbfCwmcXQN9fndspd/HGIlgdaMW7VADNKbi/bmp7UCdqgI0BzSNifVa+3iYSTwleLgSmSg+wA5LJgrXR9Etms55wcL/3zdPljrU/LIhwxbzJm7goJnACe3CbXzzFFVlJtxVeM37pitFKsQFweXBXB8MtD+4qMADxFjBnVQ59AYLht3tWUQ/MpSe4sWj3zOjjRo4Or+2QAggFkRj+VEs3TwuuS0/vKZPXizqezH7/u2w7hWPxM5QDGV+2M5k6nEgP1w+/t0jjS6lShRl6FXBDwPA/7XLlsAFrRgx/igHj2bMu9jUzIcY3G7Y3q2E4c8Lbce1izRLIAzfOUfJKM4O/ktpjR56biOFEFAX7315KMRqlDRsJUAgC00unzbMBUBKWEQl+7ZemuM12LPZmOkyx4YWdG4V2EAOuWZxxdjK+8UoMZvhlxObcysHWGqhVuEB6AUTvExzYAYWbRISpA66y0yhlTynlD8B6hYP65jWzgmdyquoQt9AANuaL06JJmKxUJsWJeFjjw0CVXu5r0CpkcObZ1QXfqAH9qkJ8hzH8YrjmkJ19NodkrURxnTV1r00v3e3ixMnMAh4PDQxIsr3LqoI9YruWRzcy6ko2cXIcS0Cv6XFAFsQCFuM7vKB5XktdWzfd08glSPSLj9yNw/q3O5dQQmt7zAAB/NB6enezdW4G119D9cJ5PJOCjFGKO4i5QIJfa0pgAbQ5CAX2o9iL6jWn5YaKHj8wpa/xu8SpYk4sXqOXxhgAQACuw6IoJOG7Jl63pvstBSX60ewiMxkxfrO6SEJ/CAJSufXPp1HG+XqS0C48M77YzDUmboqTif+PEJ0N/FycAP9YCjqRfmBoI73iT9uKf+euZWuhjvri0jdc8uCfKMABuyJhY8E8JX1BrSpxYqnQTK8Sfj+H7rJ8hRuzOIY/cALHD55eNN2wRjhEbf1jKp8H4h+DUkYudC9jb2lPlXXQAutVlqY9YkNXGuwbTeeafFy+YdXILQUyNQ8V+/DL1FQDKi/Z8J455aMFsH8dic6ocUf0I3Ouco74yTlkiATpmAO69IEFXUO22Hp5L972YgYnKrm44vrtAlwDxvMaLAM8AMHNQgoA7Uo1rOk1C1F9st8fptF5D/+PkAhrsPEgYWgCqXp7ETYcfDvRO743nGwSH7DXpGVml4et+e+Oxzk97AK2bYPtL0QWJiIYXcj5q4jz/UABXci9rLqrp2WbkyCkAjoQ931NlEHrtzB4p1nsqW+balrdzWioK7nhFYWuIcwBARr5skCmLnLpKVET25ctjJLjCoWvdHUARXkxySY9TADPp80QJirus/mZc84LZG7jVgIzEXRtT6DjoSeCjKTcADSkZCVRTHTdu+InoYNXqzrL7o2Eh0eMC59nrvlG+GwB9eB0RoAaTVXcbDy9aXFt8vhSaZ4L9qkUJnv05eemnAFbQI6tl9RHcd3DovDYRdnq85Obsaf9fzoUZuBeOZfEAvHofFERJC+tDVVMWPhNYbKrT2MTb6rLsGli93xb6XADUyMw8ZQyIAvVvJSV7aVhg9hBxV4Mysz2YdGIsn/k8AJuey+sB8r9WPVSV5hcFOF9pJgYkzBAGVk0492GuodQAyvOS9uOVuE0L3nBUnGTB56B1tphP0+osTEd04q7rngA9aYY96xHfXUoJul9KYr8h+vXGryHWiMsTTpdeWXVGAFTI23P/bs9Qlu4QytoAbt4VAvXbLfpr++1miHB1+A4AUukWi+1hoWVI+5EGisyP7OQBLhU8X/hS8vLY7c/yNQBt5kVXmqddq4VEdVZsZ2QxmoWzlyLiC1Biih283jHRADKiPxmQDpr/EIYZ3EfW28tjEh+PwnvlRYg344bkaegAGcQ+8PkBnewk8d0E4fqp8xEg9KYj7TtYGkNrJ6iHrACmuKyt0lSyXLR0u0GdupRQlSWb9N7/TFNdDJUQo+PTANcT7aU02vhd8blZflXr7/xawr7wXVKXlFASvMD3NcoAb4U/i6CRfhXPSodp6P37iRwCzQ1iaxDDInd7TTqDaABgB8f6B4ScVI4NX51z/ce+fugUuGbwHrEDwZoK1X9kAGUFZdOjwxYvTD7L7dbiGs2g0WyI1JRzuRovsw2+NzcA2b/8ZcUf4A9qtjK3HQyDDZOmRw3+MXkE5nC/f7UPBgA8yCbh/n+ApzP8c25nuJv8cKbh8eoeIHW7arIwfDdfABLUxObQTXOmKvusjtLzL0b9NfvEPENVgAFgI1TFBOIAR4Fw4eniwPPUkBUUGTZQgcTpcSyuxauVVoDtMakHEQAyIGevudW70v7emu4nRPYHBxp4Xt+BUo3syWqnGxnyAB/sHJlClb6mrh4/x9RohQuDQSJt3GAZ+UkebBD6pxAArYU3/3ds2PAWHWYuu7Gz5gkTFSXMah9MFv4F6cmf/QD6f2aFSlp0FLv/kIjHZ6+Gz7A/tAB763va4SoX1htwAC7UYwxx2HvOvbGwf6+sXMNBzJCGySqWJi+MnrwpwyEAIBNSLF9nC4Vgco9y1G3yfPKpvkRwjw6gHDBx/oBvegA6miYthSlgUB1CMFeX8Xgvv50PDnniyDNrnWOJrbWxAAsGKwnTXZ6s9bV0ftOfvg/4KRM/5ym9zNhxDsqpOeMAf8Qn0FC3mE+NRi53+Jk+olzk/urE8/98at2z9IIF1gCou2QXgL1MkZ07BzmhIRF8X7DaZfh1zPSyKF56RpR9ALqOQy5dK2LELSeSJr9DDbK2pLNlnp4aIRjhgJJKhGcA2BbPrHLeUHhQaT7SEwwZEpRmwuBZZn0Q+pEfcI/vCgD1kKNhkN9iwIQ08GhtKsOJ29ij1BS/9cNd/yiXZSdTABjfbKnbRqphNY/Nx4lRy1zzkyj/YxPKs62BfMJCeoUAoE6Zl7U99g+F9xZbFgbfcA4mkdk5SJcJC2QltEx8AAAAERLtwsUCvCkh+ZbVGT7Y59NgS3YbA3EpUe2hXzO8ANICp6IqEWTndsUC3enWi/pt+oI0zOvkEuvg6fZuk5QA/G8RfEGivQbLQPJB2Yug25lhB6Ko4D35NkPLJ8FpqABC3cAIdBhQmwY7RuDE2RuHzkUQ9jAPwuHvkUKpiqSDAGTa3Njf/BrmRegj/8B1Kd0r7k1VpATw9mET2YZEnecAnbnVK6ircfn6MVyoszwJz5o2MwqvyFp97u48KAausQCzk/uku4rjNKeRxeyct1D2Rirqf0ymNxjgnuNMVpWnAIEYIJ3d1LEyTWk1Q2Fo999wUub1AZUj4MIlZXZoqE4AExrVRrQM2/87/7Db/d3kLQ59/yFGMAXyfFVFotrmWwBbWKQ4uiGAMljBUXHgE1aXXSeDWn+5xS0ujnh4BSOkAKdcRlNdUF2HtVNJkNDNfwFxlffA6+lmIYwIL5wj44wAC145/ugaaJMerv58cb/uTFwiOIPX1MgA8wwszaePGACQxFy5O0S812ARRveyvm/LG0mte/Au8c+nfsMsdCPvADihkjoFkMF+eB/CWVqQiFU8K16m0Pp+1Gi/i3rq9e0Ajic2/4zoRCxRY3f9X9R8fGzSZQH2y7Yl2PE8FrcOOACpVhmQ/RIiXRJKBN/uLxlzhMhTGL7eFj30qf2a9Z2WACRAUIjrVCky0HxD2ogQ9N23uPP0NZIVA9ahp9Ii66AAzOLAbNsDC9fDPMD9DPZAKk4OsXBeXOXiU257JUChIQBT9szIt+x0xoqYNDRCWZ/04mk2EoAa5ctAj3cwTHcQACV/TP2z0OMlhMMPRjDz5BzhwFUxA3O3p2D3JjHGAdcAv4ofw20J2+FjOLaRtnNzrTzNksYLGHHm8WqXCqBFrADETeGWA0qnDjcRjFH9Fz1z2hTGM7ZYH2krqXKyS6kLADnerKhSHijzPPWD4xUKhvuXEu4VvlGwe5bRM8yYRgEA7549GJH6CgDC2RO0f5JSVxO68EV412JOCEiPR9+MVwBQ8TGcMZxGCXAEqtc0bSMCRTcMkuRhmIfbY57DcHmyAAGao58S57nfFWgSP65wt37tMm+z8Zp+Vz18G6sV2W8ArUbD5pJTjw+7cYubEfnduguj287G3FtaV92buB39gADqAVJSPmY47SaViv03jgaZkFoCrlmvt2+7VJJNbUx0AAY3gtzz/1BYAtbpG3kWTq3NX1wplCrqhJxhPmSj5YMAg2MMvJfc1/njOi0LO+cijz090sfNzNr6MWGE0drxfwAQHMxLRqiyjpdC4molsp2o3lVCvng5dezuQYqTWwQtACE1SfYxCGV289LpyTECBIX7zDLmgztfHXFWqXNraDEA62qQaQNLdVXKehpZlruH5H5UuLQ3/uNntuzWjBnLHgBpRw+w9qSak+TmLYrwepHlKkDUD32OoiWLE0sgPrbfAO8SsEeCTOzrzojkGAzWKBzGpmYIEkkeElyT/6nQfs8AstUTmFIhuzQSu4JJS8WSOy9q/TKEMlilpJZohDQVdABcXkEcnf8hNyyfXGYlKyllcFkyR3qKXu7c0WfFs4sgAMrGvFlZFPIIfP6b+6DMN4PEsPxuBm6Nax2S1GBGWjwApTqZjNZt2Qk7QwKGD7RmKYnBVL6gAS9095M5GPZncQB238vndWUtZeVreONrsO7JTWJSvQrX53M3qqnbEydqABfoIl75QU782cBtBwA76w8vcjQteE4hI3EqPNrl/bUAhHmYkmUN2//oYqkItB+JbvC68x0V3TPq209ovsLOPwAPkRUAbKbX14RVkHLP18LFLNpDQBOINxyMIWgXCbQrAPjkGcLeyrbUURgM4jek3jG1HJafUaNDcI+yZ5uCdVcAwCTzrpjcYIdW8trYkbt0zeKervWC1L9kbjvPYqzevACc+a8lLlXfeeVWNjWNgNGG0EKHMyiFVU0oPiRLDvoxAJcTrj7Ff1GbR+XaRaXuZgVgbL6jdIm4eexFOQwmyrEA0ekO1+n/LaT/OiSEzD9V1Cy3C/AJPgcc0tDq9NqiOwCxDQP4d4ibtTSi1k6KxUtsNXxGSNToVk91X6Z2nH+wAKqgJQlk+uOoddhm3eCprJLfx2LqSG8STOBhfVEo7gUA8SCUDzLJ4viNyYZb7GzkEwclKuH1kDNsz3qhWTEGZwDqtIbAzF0wTFIhsS1FHLGVUXQQQxyf8w2caGJqrSgbALYba11eJ25pxWQD2qFZYOtsQvSrSdMrGIMJxQgvaS0AdC3vWVnww7vAOGeZV0/mIdfj8GQeTOZQLxnsT/cn8gAat/gZqAcmlqG1zaV+6Fugc8wypePnSAvjwPgBtT8PAGMWejzwD/coKjYIuXt9aSTxixBZ1r38Pxc2enpUhBQA+jdlOEVQVpnEEBpZvqpxZ/aMOIm8VsavuZbbjDOKIQC/sljRkHS8gUJvtNYOcDCbjxoecYJA/q2jrYlDCRasAEo9tkzb6WiSrHdnrzMfFg2MCdT7tEYKusNTJN5nYGAAY6CkMrUBuk0gkFJsQtj5hx3GBcYavjXeavDa9hk5cADxxpaRr56+N6WZZuK2yeJnRKp1fJrdUBlzFwqz04BnAHrKo5uEylqQZGL5lg03cns22olQFlQKfwpjqeOr6fUAWgmw8gU5d8gKl2seGt1SN4C1wtoTxpcDM2PfW0lcuQA0S+76GEP4ExcvGd67mnsw/a7aOh64gsf3zg7mh7xbAH30Ui5m2nbxvoUsjHu6VF6FYR1M9xhQc3QJdhbbTJQABmaCVGBJQuMO0l9egOQBgrCUs4fXQ1Gflt9XHDhYsQBqctQ51H/zOp/j4/n1Ajv8z1J/vIOyIx1svnkErIFkAL+HsCbAg78rtJpIrtV//h47Jmc07ElKoFIRjEAmsEMAPxGUa7u6wlFwKWs0XV8vcJB9c35qB1bABCY6Hmi/xwCOJTTMpimTJ4x4PU5heUztfFSH5nugBI1QDatK3EPWAGZMhZO9bdSpZ+IUjTDFpugYH9ky3unMd0iUz2w6ShQApGtIL007FM6v/nBlv6BPD/3iqSPny1RCTCqtz8BOZAABK61LkFdy/oH+gPGs6Kc6CgrWt2mxMzqpRg3vgy4+ACNn3pzvQ7sl2pEDXDcYY/zrA9xRPM+UEmIhlfQEorgAIMmAeZKW7aWJmLFrUmE7RgJblghK/KLgzXr2zjRMnQD2uKkIguPsx7hyuR7d0Mpgipd2oFgb5RipXUGOSRLFAKdY4zlzUvTvqMQajU2w9+A6xAvZYOGKtuFA12uiLKMAVW43sB2gd+/n3MF6wzJAv0HGHLwZ07jGqVRMezCH8gALH9XRsU3ZdDcDzRKogSjIoUdcRtNg4dbM0bWBwAxEAFXnnP3qWQ/rEpJT5mrbF1+k9RabEnHlsmwgQqIneX4AFhITbEtDq61r4urru4VIgE3GWsDchnhd/U6kRUsktwA0ht9mEZ8VYqOSXSFVjlpVAQY+Y1HxRcCIvah9zhB+AC3yrK23b7pjVDeUcs24B10ek3iH2RHYsafRxg5u9NQAl3JYNJ7hYwJxJFPBcgXy6sdyDAfQ1oZ3kHFyNCrraAAfssasABrl5DD4Kz9K/EWUGCubrTHayTIyEmirP6ovAMdiqvgMEChiRpp3kSpfU+obPfEBp5Emit10qnnrHEcAgxmsLHg2hbNk01anse3l9OhzlPhQZv5eiQwopA/IRQBqUbk+YX9/MHIxRs8hw7AH4tUS60inphzSTGfqfHjmAD6qiJjdsCB4e60mnQbWIT8gcbL8B4VZ6YP6ebgdLkoA8Uupht7gJ7/GnHY7BZm2cviEwpe4CyTfHvy+liozygDPTaVy9HEISg0KqC2YuOvSJo2tR0F163tb81TQzLL9AOHdGCCQ66D/Ux8bbVW4wlJCJ+9OGgCEZrQ9BWRGwSYAA6PfrS3GTmGRtwU4VVWXIRuBdvMxA+OSa500M4Tu+ABgG1YPpGdhVZu66hNGFoC1HTmZgxdLnWLx8I1AuXwUACWfY2AaHgKSCovA1OqJ73nTEAgc8RjQBV1HgUZmxL4AZ4Cwp7gVFUsi07MQ97XA936hbH71F7uTCE9Ftgh1igDWyl6vE4o6WyjlQh3sf7/A1E6en0pyVuYOOdJ2JZIPAFMTF7D7kd8fLbuDoNUPaMjX3f5DlLX0TE7vXPoYP/8AH3r293CdOv87EaKH7phzV2K+Ma5//7dnxYhilXlxrgBWvDi/xizcpc78kOObwl7qlsQz0QaB9HTh9ybFfrMIAMNidiVgZnmH0io+6aWkVSRn1E5IKlWdwFc0MTH53PEAueZcSQagcygaXUQbAQD74aW19rkw7mfkP+Dz/py7bQCjm1BALF8q7sHktckgh+92TrRefZbaiZelVytlCKHmAHZW6/EDKZR0PpCVF1NlRhh+e+kZ1LCXBjFHd3RQYPYAQnHHooVPzlB9xPd3sO1e2ja9yTRPMa2r9AIPReDM2wC8fjAeh1tTYC9sNFaakawgkRY+5+cBNs32GyUL1+tCAJBgihpF02zEnVgpKCHaW/iVm5ZDhpAJo0FBeSgZvrIAOjUK5hudqgiDbgIpzcmXtxVzLL4pIF2ZNRy8tniVtgCO+z9oyixn329YaMiOejyxt8C5B6dY7FaMzMEQqLb9ADUaUpzrSU10F/gP5GPxSyy12l29/qjuxOBrIx9vFtMAJ3gVRuo5//YhhaOzgZG+Zg/ya+3GXve0hvVFDOnQ3QA2gHjMhZmTTP4sRemsVXisK4XhKHZVPh8my2QlIXbtALmR5wD30+g0AXOTXouSCKK6yMnJcwLJ2IdUX77DZ38AZ7PXIj29A/KwkTaL1LrlotIGf6o0sBBSE9LZpG3rtQDFN1uxn3ms9tnFSyv1Rj1cxN5ydL/EwmmftgQX8fWnAN07te/r0NyMiIH/t67nXjerNeUGtZBKWYl3DAo3J+cAt0RUazlEWybSNb+3GwPzDhfd7Fbe5lShkaBSAValZABjiWckhEnR35viWvNsrHNPQ+DD9kdVWFuM6GxCmSJoAElmjs4NPlGCEdsVLaXpOxbhEKjSB3s5VY/EHtKa/OIANgGLgZ/O8KLRiAc9KxI/hOkjFYZJauMB4UMX5502pACKff8c+J0Y+JB/j68CHISSYyCx2WkxY3icnhvqT6XqAHa0lZ6/OePlYFgBVggL+vXeg8XWAMzmyljexmlF6KAAZSnQylwB5Nx4BKekTGEuyYkO6OcY45hWWA4Na29XewC0eVBLDVCe7yrN5Nz88lYFbysW+brcL/gMjciMB/saANZJzqsR7E/+kNzpBifJVT094bM+1kFPuJiNWotSFUEAflUU9WLVIW6kq7HqgjjIU6wwjkYiWvNNvVP++09E8gAzcUAjejOWDvXboIKd6BBsO+PhX3bnl5VtWeIkmz/pACzm6dy4nz9Mosbkxq9CFh8GP2mEKopvvdlO+v7oH30A7Zhb74Xus50vKSMebfReH0dS/+hREu/14AzjddYFBQDwjbefS1/5lWYbTT6AXvPNHaXc+7NlTHGPeiNhz2SJAKKYwSAuFBPcqLQLgr7hNj1YLWxj4Xm990RhDrrk7xQAYKb0jGfZYMg/nbcPy7hVFt5aUD0Rp7uG0E2aKe8nPAANBunDQ75A6Xrk3fqKbYJAUBhTqeKKSSTw3q0BMH7rAE0tfTCvOBYq3MMknRoLLmWSvkXyQxg03PxSfDk5GLcAfygxVT4lHI5VBAPNMG7Mso3hrx5CDJGLBKZ4k18uagB5hF7PEqTsKnMPAmC9jfnmVnjRFDqGoE90JRc0W2gHAF8hyJOQu7pWS9oecde7xaMix/3k1S3o2BWcivp4V+wAwwZj5zEBNWujSKpnKF3LmUuujgkON9byAHOLh3mBIAD8x0QEKdwEqxb3fAZrkJ8nT6Rv/TRKiQe1T5Hm/sp1AMb6dzDItBb0613F/PAxWKQ4IkELxtTlvSyUhGvgiIIAFThV8Mip6ESmyxLDfHryIC9ma7CaH9aCRvOA5uXJbgCSmSAGalgy5jNM4FATi/CNryXTE7JYLYlMCAZbqHSFAGnsMx8q6HB0KtWuXGxXa23+9JzmbNpWOyoAkeQ0wVIAqwgVvJXCuEd0fZzHlnJh95L+PFmHjOurxdEKOhjO/wCLSe1IebdTB3f3z2ldoQf6Elu4a3fXrd9yOr1pyWOmAHLYonBWBqmLCA1LVA0Xuc5EUveuSbtKcvjkzQpxikMAUc/Gc0dAhXDJ0COvDM9YCOGQY5tCL61YiEdml34MGQBdlzKYwBDcXlJ/va6onOiIcj/cuY6dinaFMu/2QB6LAAo55wq1EG455DbFW50XyJo3bmIbyD9viAPOxi5pExQAzka3SHM/g+xieVCsAFpxNP+UONIF7dRvYXFVtd7jTQDha2pYtvfIZ7f7VfLlSdhA1qg+R9g9tAJkbBZdtFjsAOWlBYrsBKzhG9K4UBIEgZkJRvO98XJGFH8FLXrDATIA3Yn7ZJvHFACeV7SGNOYFI0WVKqsfv/Y3IhWawyrPXgCbTkz8pzYpkObVUKoRqXpi13+rUIe0n9FEKK77tAXcAJn35Xbb7JEQhOIwt0yGXnywrO/Ydgp3c9TphWW+Z2kAxvAFe5nWAQWdBJHjLXnluMrbhzxBI5DXA05OUKLLVQDlBPb/Mz9TJ6axWTu4zr1xh9q+tNnum6qCZ6EtLhG7AMTzpH/nnDX730N7oEfZruZ2OF62AnDG0Xn4kRQ9TeYA8LfvANghyBk8H+HusqkCQ+CfEZUcxMnGU+YFihNu+QAMTFUnXXDjdH8/dOFPu1E9Un6iGmwmX0QDYCeyuLftABdlfjCijbJtbd+iLAP3bw+k7IWLKl71LZhjgIh8ZygAtUbx6ht0+PNixBiNF/wOKmWPYNsfESMnutOjOBvCygDemQROkipdcUOcumiiVmSAUl3GjHLBIvZ5+w3PdNocAB4tWTXQa8obJMdvFm8QQKYzZrba81Eqb0Tp185FAFgAOutKmreP3DpCxQGCFzHnUyCAm4lAR+/tshuIF8VWqwDB/tC06kLcGPq8O6C2bcvZg9v3rXhcb69682FUg2JpAOwND09kTHMngcGDWqCGMeRmBDtk3vBPGkr5+MvkLFUAWdGxseKjjT2P8mSQKG/iUy4YSng/hlBePPI93sS5AACNeoMQxId2SvzocaSLcInkcWWnEDsyPamsrvosZupzAC88g8BXcVfeP84WMfBoTz9aAPHW24YSSBDgDKaTWAsAjh+xHY1fM0d1L57Dzf0iFGBjnr0xJCtyix0HHyZquQA2gCyv24dgkq5q6soT3yBVP1y5Wo7jySrkXd/Cu16aANh4ygN2dFKpkRcsxr/Tr27IlmhtQ5P90a3vCmAb/DMAjRBMQsHl3b0Wrhxo3YigNPVKzqnFm397298qOAwSBADENI6eT/F7TU1jL7Pi10bToOBmWbRpeR0CxYAB0EgzAFmEDT5aLg9u+xHg+NBd4cCTmCufPvDr4uJMUFMGOvEAChHQJ+UqsvUOonN0hqVE1RDis71A53i6qydJd/hpvABpseVHhQULuK2llfZK2y9MTNt9aIUURwUbK8i9Y3/XAFT7g9seyJayl3gVj65h2uQRRxC+R/HYaEQilE0NtiIAJE4iBljkclAodfIHDliLmb0DLddCykc8VdEGB3UB+AAjj+omoFDSuPTdkHQhbbajuu26OprFe7KnRqzCMVtuAA02+N5ZhLsp8PpSRxS7sq8tPMnrXjwGFo56a4IKSNcArRx9sj4Pczahx657zeHFalrtzOyooxC6hEFsoV/QuADGcqaDTkNxUz8dHuW9JIlA+ZcHqVRMJT0LuWCXrBxcACg8J9j2mlnudgSz5oRrV4ya9vO0f+7VmRDLEM4ygJUAFXdPhhJprQwc+4gWBT0h6WuBBRRNIaFgurRQaY3v/gCXYLsEgmi7IQS5Q2dMtuFTqhE+h4/gJx6/BJSxuedTAFyGfH3nlAdi39xQXC9TpSJa3b7hITIS/Uu+BQArpK0AUU1Uda3anLB28HRia8Wy3Uz6q1CAWWEFobHXsJc+5gC0EU+at7F4jwzTh+zuCMhVKtz3qvG8VMTogNOG5aNQADZO8XK4Ra2IyPt9/+o/OEMPsmduMh5wDPc+yh0mPLIAL2SGMmiJNfRn3EblonDN2gdefRMGpNhtJkxk6PD16gAy/ord2cQYSqBwb+hQZOIlvRjyCnUFFr5obvZFysXIAPvJNoHt5C51JYqcuZTOuUxs71BDy4pt5+urH+LAoFgAlGcvKgTa6f9c5vjLXKffDiWD9ggSFmBvT7jYwpbyYwDXDPcorBPEqK9RyvxgtBUMKUqXOsRQVRn3/N5+tdOZAO41oPCZgT6e9/qSsGgGkZhjgcmHPXS/Hsbg24Qvm0UAOmntVOlGU6AMFGsrg80LUeb/kO+X+/WQYUtqqzBl9ADai9jK7h8MUSYfkujRYEsG7ifGVuetTne04qKc7upzAJhk4NQrTadzHhFeRZBpcFCx8ClZjS6fecoUd3nQqMgA98ZdxSjIoC2EptYBVMLMkJPT93EKlS7WdGAX/sPtoACdUHp+v03t3pVjkSXXl5CiyAqB4pLtkzFXwURetBeeAPw61amlzOZK4hk79MDS2y6N4fHfCy4SgmV7CBtVdrUAJwSqqv+RvDnnVXhgv8mVkklSzuc6OuOf35G0weagQgDFf2jOBseaYmq1TiH7lKvHfAmUdjJnUdYZpJsDUjnjAAvNUo4IZrfsjAG5H3O0Iywed1F+ecdUj5zq2iXddLMA9v1AECuPIESNT58egOknHVrIuBMBHlkWmFJhQYpu9QAlRkdaCDvqrYXeFCWm1HInE71xN+2/6ac23sNeGfAcAP59zlY1pWsCz+yyPuDHo+jmb4uqoV0ClH1eoVZ59j4AaPlwG+e+5PZ1c5YRxjVQ7Cc39rVP70SEr7/G7afmBwDrPc+mxJtzFmiADfX5zdUcM7+xANQcUNjeEKnB1l0vAEbwU98WKRoyDpUFTrkZdWDc+Ut5gvKBIWVRTDfF/1kAQscYiMxw/lz0zqA2WgmpB8cG5Gxxhu8Zn2IOu6J00wCDvIz8lDXoHwD5FuJ0fFi9hatKWEsn1lAlGvy6U6OvAETTSaqnswoLAfHetG3IZBmqDiNn5TdaRDczbUaEuHQAaOUawuuycdI4ps+5qmnp2//1IWnawye6OI1yjHPxCACzyl8LkDB3ecWGJ+b1a4AJ3zGfoEXlXi38wzGuSDYVACismHIY+eK8zHbhnR34q0Mrwyal+CWgINW2Y4Ia1SkAgSeJKjstojOKLdINxnBYenDj/r3n5HpTc9hACZ1bqwDz2LSmYgMrOHOKjgAfsKoBvrC+4Fv90lwc6YFbzBPsAA8VXknGkNJU9GdhPUk+1T6AUtXjUaXjm8IvlKQM1qQAPJM6PpkVAIfOgEzSDSusE70nM5V66MYoa/aZO7E7UgBbgQUZkWkZCdC+ETRZ2wGe2izLM3FHJOkWKIN13r6NABF9IBc+2F4eOd1noZlr5C9lM8Ka0CSVOP4reNCvbCYAxFWhMp48DOPS3bAvlgnuNoI8Vcq68WXozdRXyvAJ3wAezVe8pSAuG/0SL+9PoLJdhs3xt5XtJuUCcGq6WxePABYfFIuad/rmuVidd3RnZedb6rxybQ7sbSvXUEYEqFsAhG8b6UPM3R2SHYlHokF3DPiaJUUAZ+9LSOuQdC8vYAA0k3c/gYCaMlwmsqewMsFnQgN8q6B8rbmFWYu2IGpoACk/FjOFO78ZwcUleSZdumbGG99lzzCmnS4EMaQPL9kATst+UZ74I8grdpswaL8ngGpVDoNk0RY2zUsp0n7RLwBpJty1Zg/usrMbGMCRSSqcxaRLHvQToIZoIcCuMxnWAL36wlC3SzAngf8xd2QDU6Jk7FdCwbKylnIPpTcLPiQANe+SG3JG2UpvNX4U5KnQeJ+CbD1D/ZG13UeFrDqC7QCLSRAn80fTm8IMD6siqgtqqcDhw0fQG8fBsNmqbjvNAACh3YYnAkiDDnpTnW2CvWvk9aoxn/kp8UFGftActR4AFrIEHLyXOlf6MTkpAU1rQy56vm/eDF1g1ye5TKiQBwD1ErtCU+A5qrW0JU9JljbI1rzAcsS3vTCCQFpP5h0OANhE++K3dHa+Z6HUhdjAanrvimkywfkOZ/KyZuL+tyMAOZBgN4Cscxn8wnLZDc3MXnRISO4pEX3WKCVcqjbuVQDmE+IjloNtUqXPrcaDpdIE3+He7RHnkcMHh9qZ7IVVANrCn3yDQCpq7YCsGEOtbnrR907LWH8Tq0SyzJCrXoAAO8Vz3cUpXKYZgscGYQ9jcgZNDYPvJyKZ+c37Y4lbjQAUQGph1wrSt/4Wm7857JsCbueM8ihFkgYNXVhvZ9+HAFCxE8pUBOISox86YRdM7k7qNpmXpbaIAtkIGPpppOAAMIqJmJuse3QjwNwW6xRjg43XveytwiAXNiO4WYv43gCr9PiCQbYNkLQQjg6LW87PVqeDk4vBsxIIQrVCRqfbANMqIXt+mmmXOYLAlKbRwQ4npbYvu54c+PcxsWLKiIAAff3jan1gxasxV4ZlXxaW6wphKKNIHeSbSQbeCx2y0wD5WSKuwONYHeoOiN4TM6s8ImUnOKWmCZtRVPwfajHSANsZ4kUype+CAatO9RS4YU+aVgWTfkvLl8zPmPZXQzIAXljAuJ1yxEJ0XiSuduDoX6HzrA/IhDEV3cHeZEW4GAATQXFXoQ04/JzbLYqLXyhMcNeJ4axm0Z9Gwf7sAScTAIItOSR+vGjwgbRjfGTWGE8kvIDciqhVf0Cm3pl4qTkAzFkjXv3nGR951IzX7GA7NoIxoV1cqdJ3k1xSfN4gqQAuQwEIWWFtVxMhSaw3bvyPUzeNwj4Jm2lYVGnqzEvuAOq8fU3jjYu6hjizU216+/XY6BH4J00UVYjDnrfyZIwAEvwHbdMyGjw9ztBKOszSsAMDOIvwRm4bOVYgAxVvJgCNNpSDS84+tntyh3X0cNGnMGDw7ObCI4ucE0ZscCGnAB9TITDsDTnCXGU8b44VYWKq5NKyzWOl4MaJqxKlWc0A8njIOIl80qny/bBzGVhg5B3xTL7riRYbI2gXGj1zzQABwU76tf2WJyrINJLW5UNGtiVrl410wwEYxjddbDKpAK+hDw4RW42Arw+F6CnG57Hsl5V414StsM5MQsGy6k0AMSAVy0tUdICPJhWnncQZnIn5IvVaJ3ra2ch0+1MBPAB9jr6yo3aA0h9y0YKkYn3VKmxQ7GLSokdFX5TxKfuqAOozBFGvrpmgt6GWzHA3GeYOywSLduMC4tqOPai/z3wAeXvipIZCKIgtS9FGEJ0uzC5dlAaoLljcM8eCOZAo0wBsaimpoaOV32//GJ3eK7THacgEkoN8/2j0R9uTdH6mABcmTeInYXbgVuEic3I8Gh6tFXyQKpq/b/LQPK9SdbEAyuHr5KYnqO3aGH1N0xqyl5jciTHhgIbXQJKsJ4OlFwDrsD2kNf55/lj9rmImXg+0A6o0YuWodWeZUKdbLUMOAEAcRTYf4PB7IZsd8e+2a+5YAYZW5lh4uL3egkShxhEAwoyUHwaaOR+rHI+ykbXthCA7TyfgsxoG2qE06iWxyQA9va2GP9U3eMx5vrbXcHD7nEKu1ImVY7NR3EPIuXRjANcSAU4ZeKSanNKMuEsMnWS8uU6KEx3M7bmErh7Sm7oAGvqOWcZVM2tjH153qpSUj8icjATWPcsFmQsUpewMOwDOm2OSMxZ8QCkyn4I+5rnnb/d/UnAtkyhFJLsFQlx0AH5Yle1hCeUyvTkAsZEX+IKW1rzXPvPHJyr7At6d+DkAudoaEcRlkSmyQxDek8QOvko57WpmHI82/wV2KXdyeAD6V9FCX7fQFrmfcb+YFYvJQQqjMqtq+SjMu+D4KJNlAMazvAbtfdto20ciLl9yOU2mGdf7zOWhxzBFd4AgtZcAujAJ04ZJKoXCagPdA45o2n6dCXhpu35vcdRfSLKMSACrdK2phwL4S2HKyKkZKtbrl+TmM3RsEF6VAYOoMBUVAEUfne9dyXk9dJhDD2ttdrIu3DzFydo7sR6H16PG+OcAv8sBT1oAOwPVXhCur1dbE+nWzx2EoklQQjVGoYXJ4gATzUYEJudDjPA2Tb+YRqT5p4zP9dq5sXWVr9nmc6IdAOiDTcURd5DVTJTyGF9zIcuolW6yow+XYCG14ClCuQoALg0q0vjDklYX1vHvP2ZWv15kXrWUHnmd3T0wh/szCQArT6xBFu/gJ7xGhyi57twVMY8Eb7oKRn9y+zd7O/NYAO3LKoCYcjWEjWZAjuV/jMquswuxXAdmCT9DRUN4C2QAcXt0419uWRk8hbvChxmmkx2jyg/mbDZQHM1sVhDG1AA1VN9yON1FyOcrvgWpvEox6BOVOaPp27ZYz5wMc42XAHSxttjkol22KarAY80evdFTqJcy8NxHI/qpgPB2e9gAouvzhtbTbw6SECrJiLwT03UdELsKaSi0tMVt5DHvDwAAcm86NyNmuOpGUqirO9jk15N+EnTo58o5vCAsUNqtAOuWOSjrX8FIdv2OZYabsmQ8+MsqhJN9M6MjSRXNCsMATV3wcGPaU24g8dWU51CyAZb9NYBfTXxN9fUtnnrxOQDvZxRLGE35vRDh8l9A/ndxLg1rbjXTQYTpvOCIKWEBALrOQhRhIei6Y+0NuaeHw2Fi4dVgDKf2oshMRY/712UA6vOakSdt5aUsr/JkdVvHeD+moy+6Osw7gzv1RzVQ9gAMPbnoNftzwTUNBlxf0UlY5RaMKmQZEdvtLPcGUO7xAMuoAbRR+upa3MAwAJBO3YFbeD+mi+bYr/2iGUnqsxcAYAfVd0BT2lWMZ4Pg/v0fDBYMRJYBIZcfVPiAiChfFwBeEO7Xr2kAkfvsVccCxCo4z+OMbv6tdAmJSkqBs72ZALLoywEXAS4LjNjzXhAX5qIz/FdIZ5xjyrhhEGaw8egAaW0uF9siVz1FhoMWMGSqM/VlSZZY+gPf84aTjfjOdQDOpLynw6tY99t43llrea6HvZAhcd/nndff5a8MObmIAM8N+NWEpOZteFcQIvjQYXFPsydLilCcsF0974qeH9oAxYF3Pw9nSewhvDt0vCKMNenAWG0F2qHq4Sy/kAs+SAAEl4CHpzHhZjo4GllkSYLKDqhHs6jKA5gWTPcX7XSIAGP8mqqurCrKolFu/LNQrBPUsyEgAZY4NUkVtCFO4woAEbwmjG+WwXvYvlbYQnkGtiojh9kFJkc2ZJWlwxOQ4AAsVf99Zzak+3BH5dk9FGqN/VO+CC6IPnrsXLNo4whBAG1YWvVKOrzaXzvKROPvRLxYht8kbGubOlYwlPXGc6MA/XzSP6hP8TThzpkllTGzmXLg9kmjs9sFoK4k1hOsZgBX6nPl6clxGaLnrwv2Qw1pDu0rOe1NZqPIQ8CJEdr9AIvycItfuRliKQuQL/Zooa0AqnBT+zh5br0wqfoKEdcAvEdO7bJXHFuP0oHk++0JD+8wziU9WcgiSan6mlRRHwB/o3B9h9bkUUlcbuzWcKw9dAAhwIo0pB4MuZCnErsqAIdAKNJ8rRiMN33EC+s0we2nahc5C4eqRkElvwX6uT4AX5BQarSPN8MTp5upazhNNWVj2EJz+O2u559HCnNEAgB4q4JLSK8LaAO4kTnFQ1p5y9gORONAGpZexB9g9UQyAJ+Ru7Cy1rq07b9Uzy+fbSMRKkKGcTOegoRLGT3HLMYAr92iG8QE28E8MqfClaz4SdVrOh4eYgcwN+4WKanoWwBmOV7rRyBG+EZXSuDlqOsdzLo9juObw9RoNk86jHNkAOs2PeAfaUrx8MGjaO135/BMpha1FUdpQhbebb3DFW0AwPbQrFbDmuipAPb4cSNnoK5u5a8KlEHFGr4Q0c2ZuQD/dYPX9hBvSdcpFXmFEX9UtypLTUE9rnsQJO8eiiL0AInSxDw5e9LCIaXawdSDv0fqM6wx9GYEZCXaGkcXQm8At3RIZcsanil17bKqCMRLALFyCF8qRzgxyXcNI1NjRQCdu3aRiZKBD/saYnaYDGOP4Qinl+4+eDR1H8L3qt+bAOxDEIKfPU+kB3R+rK9fZgxVNydEYwD2NWwthOZuZWwAkK3D7/p97pCLABgKDKg0eRv//pwqmpEGI6VMnZpgQACnQl2ucsS9adJBqIEHbkh/srgo0XInIHgJn56T9mPoALEiHN0xdPxMXBeVlP9e2022Bd8W+m7BuLeKlJv/2DcAaUCR5YhVYqPLGebHHdczq415IPUnkPSD5IqW3cB70gBrhti2RnmxBYrJpD4VzmIoxJqX9h1bwcDjWm3K1+v5AJxqZuA48xZCnjnh0mn5jnvRHII5+4tsnFUm3hb0mY8AMJ3fTOSBcm5lC+K3mgj+U5QSFFKYVW2t3MdAoMf7pQDj/g44NAuzaSf9+mN9+kYl0nhLidTvPrzz4Uw02OOjAPWnDHSX3yEZQOq4Ph2PhxntrV7kE7Es1wEIUVWgXyoAbdLJtsxIoiKG8Of0ZSDNc2jdplPjwUnqyxWj+B3fCgDAPh2wO5wh59AOa2oiYE3ahTJo9wK86ExOiC0tbz7ZAK6rj3hicIAE+W+Ee9sPzm5ftbRvur7c7r9IP67fUSwAkB5DtaUULF43rBfQG8tCxFar8tEAqBFteonLPm8Q/QCTQY05ff4CUZSW/L4mI/yEyHhJgl3AV7sV0YGecyUKALTyEXZVlUcBU/Rd7mfih/cFBkQ+dF7H3aZupUJuOgoA4fLgHhvEh8N9CMS3hV7VN4Jnumh6jRWgphQnMbHL2gAZwM6Ip4d/GmsEZdtzIEOatXAIrn/MBfbV3Ur4fcW0AN8FFQ1mgjYuveri+6er7p1wQQequayXhkCdj/jgcRIAQog5aLfDi8nm9dIMEi92vO1BDXRI71BfuGCawQeB9QBfSDN7yhChQI4FHaKnwpvTIhDls5Y0wB+2qbGYScC5AOIz7Vsf3IH+qVXjrr2jIM0Fndn41qQ1jtgDnDQdNp4AZR4x6vlcEUtckA3gTHpZmGEwFMWTHJGl9avNcWH/zQDNICn4DeYPhKY7Oqd9YrP/5Isi6hVfpj0ClanweFKyAAZfJJjPC0A+lqZXT8fuescMYD1QgKGD24kB7oPxkUYADw9yT/JLbXotm7Mh6Exxii4syvLB6P4VS9mguX+X+gDExT3wLQ57HETtqoqd/HVPpa1dgSvyTZkWYeG43Y3bAAgLzNZ2EwEVP1wu/l6LkO8xSP9lkcGGedaxsDv4fx0Alqy8EtM74KSN/hl3rTlKb6ggH4aW+tpnzj1YUeS3jQArmHnoGOuZXCOExYleEULdeD/y4GIhkyu6NUfJOWzbAPOMJkL2jbQc34GpB5J5LKpcn6J1ajjayIH+tlaGX5EAgUSmJHZGadByCrLghmZQ+pWvjFkDJ2E3ZTyjLrueiQC0gT2e9JL39mP3wwwx2dqfgBfN3I8X1eHRNSjztpQaAIuneijXd+xdmB3ssrpX3ljoeIdwoByPP9rrEZ5zDokArQQWYtsONkgIroKwPMSRph0GnZ0FgdDyNPKWVcfKPQDDTY7pjZIxjgnA80sl4dRxmo1UvmXDN7zOgx+Vy9m0APPSLgd8gxtbHdELbBPkgHkEsTt3ykh8kqd34OztcO4AP0nuD8D5t6YrPWOwC0HkCh4B14kOZVEjOpc5rE2d/gCPFIudcoMXeut1LWY64qRzrM4+psEwnWp4j71p732qAPsjsdmf9akKfPjcwQj97AZGNmKoMvAoH6f/0Gp4efAAfb55Fv/edpWddmNvWAgwc/yXdnpy38dP6TgOyG0kqABg4Zyw7XdayrIyUXZ2Z4tpM9yNP7J3QsP3QAksXlJeAI1vE5G2yGEri74GS1mtIejzm3yhDZC6UtSsAkjMdHQAOYemQUr2RuFayEHyfjSFs1lpiN88EuXX2K+qXac3QwCNyI29Sm54cV8yhvrQVcvq3LlXDT6HUhkxhcvJGvBsAMKORpEn25mcrN46hyuis083tldjgD52RFKensYhcV8A5CQENk8hW91/uFzW8G3Y0avTo2xLiM1fqKAHEW6A/gDQkayyh5dS14Oul0ghUuEs0MbKyhS2EGZH08Z1MFpCAA15HHlDTEh2Om7gjho1CPU3x0ev+4ShOxwkldUKtl0APtUrLM3zBidy/+cpKKlNBJc/PCSnzE/4/v9ILBqJyABjw5BLqbmPYcQZpQvjYrNCYGlm01BP2nL5tAnVhHuYAN0+3rd9gVa8ZmTrmGtDKY3mapHDTDBtgXd+NaZKDWcAtaht5KENAje71HQj9YV7Aobj+EHfs5iY8rxDCNnjagCZvj4KV2L+tBrfgZCri1iaSyz8atipiATIUCGRwOv+AL5ARBoCc1B18oaMnygWqed9s37CAm+D0zNT2o/nGKUA8Xet1Z/Ldse9CWyLcMttcD1Rd6wyMgM5tk8xGW9sMQBIjk0S6Wu18mDNfuKaCiXjm4J73J7SOzJm8386gysjAPzt4h0w9rXmw/9ogShDbcBDc5uALDxlpQozIUlogbcAqDjjuxe5eqxn4Uc8P2B+3cyV5vEaOA8qGImNkf9UQgBXn0RpVp1btLmqmibKaHvjOvtNy+KwnBKMnbgzwZpyACr6HjfVWn0m31ekU+3c94+4IPq00dxzN2LjQhyt2p4AwnRvSBfDjnxhqYD9TF9qyIUSJ0Zz5cZ0BVAnO/1G5gDrmn+44WHXEp1Gwr/lCwIgusH7DX0l/X5sHZ5/brJKAD6/XDTxsTP6S5U8ZQZPLXuLrGE3NqR8EhxBh5hjc/4AmpXXor9ccXUrDY29CMwIkjtlKgI9hdC5gArWW0T9WQBJM2UqdQDt3TYh8EBQHOhdNUeTTOdNWNg15G73pbm4AAwBRTt7M95O8qylS3jPbvhtI3WIi7lk22rJgOjSIR0Aq5lZMdVui634Ih2d4OOQ36kbLwWkZKlgooizFq85rACFKK9OQVfCAEV65mj25upLvn/7Wh007shIed7AiMO8AMkoPjYsZkShdcisGEOvUwFxRZ178p6sE47h3BkryoMA0D7ViJM/sIL7U2lfUnSEi4SVyVqOXbtxb+eRJ4HIDgD8RYOfrSD1N8oA1Iztyc3UX26/G2ZcjcZIeyigFLYCAG7ceIpy9MxuabgZ7yDClzSw2P6GrVkynzGD0epKSz4AKDlrObwye8KZS9OG/vfF8kGJHPJUnrWlTE/GER4J6wC1p9u11Y06tf1pvaznN24w11tAqA8v5n3bTzMDG4fWAGwqaCWZX2h2AeGAIjNRcwoi9h6yAsSWRCW4MRwSoTsAo2CKEhchQx/MdiLJFyi9cgLhtV/prMnTaemCNeFFcABvyPrRl+0uSgDQSgzR2zOh4uMDkmqhERqE46jJFGpEACsMLkcuLIQqKXehOf4HtNPF1Bybd1R7tqi3wEyx7dIAKI9GEuAH1OXDo0oFx49Sf4jEvApfk4GZe+xV5SFlpgAvz+W3oC+YMc4v7YOfJjxF4LCdv+kwx1os57PwHuG1AGucTi9jueKQZhsDetfg+NEsaPD9Lsb3yu73nbZi/sgA+egnbqi4Cpt9ut5qGF6Ll3P9tth/7p9lXOMoF7mWzQDA/BGBP7eNTWahhx/XD/mABBvF2JpkHE+yzwx8tcdAAPK4GZCYlPHiS9Q0Z9X3R5pfg4V0OneUJBG3bo87y0MA2Ce6K1zc96Te+M7+rcjwhoq/QFY7wRWsRP27L13VHADwf+mtqiWnAMBGWPsP0jtfsSPuIy9hWusc36O9Fyf8AOgeNaxKKTbWQafyYLdhM4gnRurRZpHJs4+kliAB8hsA02YLoFKp4snrxxsFrX52ZZ55BsXhz8w1vKf1Qr2SIADa3F9PAYJDz/5QRMHWJ0oz0yQHavPWqvzpUZGiz8oLAKllThmi5Zg5tdMEb6eU08d9KVK+2sw+2liT8KDGAUMAjj9Gx/Q1eiJ6Og0P2L0+y0XicQDiASsY464ZaXZXZAAQAJLsm2G5Jqvqf1omu04IhkTAIusqQGAjsHy26iQ7AOXT3nhdhxUzqW+ENVYyKbWiam0QG/wCRWmKE5LnGusAZKxa/SdfxdrX8EWcs8DPfBWR/ke7tDCcbzDVgRkIYgDOhVxPql0urWDK23V+QiX3N9RaOb7lOgOOL3nrvVJ+AIn2smWMLLXclRMKSVvweo9CGakOnT5E7bTZpvkhowYAhdmtmqZqpdBlE4Laj9W2t8rcz5ayy39S2dj6YvR6VADkTVcQd4zEXtDUo/ew/Lf03LJfHRwlzjS2oEG0QMJXALbtovtcLAW+p5C1nV5e8uiDuidYAhqwfgI05EHz17YAMcZcZsHX+r/42FtIQNT239vWFLOzo7rGUIekiAmBNwDYfSVpywDF+lTN5VWn/P3DfIxnU5qTHYSiH85vsZcmAH88WF8Jgbk89GG4mboea+WH8HTDe8T5Kutx6kuqmNsAIx6zrjQVAjfr41d8uHC+sV+nAMGALbKlOO7EH+a4xACIEmJUNsrn/MVtGYIdUzrIpB/Cm3iVWtrApKEVs0kGAG82c4FpthNi7iZHDa108sanJxFs8hIvfSi2Hhsjct4Aw+iu5Mzo6JF212ij0DT8C2vAcn7mrra5BxYftq4t+gDr3M6kaBGRevm/MF5MaWBKsrr8w+c6EoML6x0A9AsiAGW8B/mOc27mTgVAHPaAI7r7dLq6wpY2x4r6OcXJi8sAbGCBOMtF1fiwi9fOF9pIm7CmaQkUZug9BFbNIPieyAAGx8ce129l7J5Pk6m830ybn+oBRAykhCXa4k7+CP7tAMsl0YWcjdZoNaBrlOMVTHsWTPJBJFShPbXQ4Du4sOMAnhd0Y4IvUzL3zPUA1JkuK/GMHY0Fue6jyU/Gfe5tSgBaWk8CZJoTUuImjl+CjioPh4UmZa8SuZ5QcG8B8berAIL85g3w5vvnQHwWwXexW3HNxuyagYgZMswaLvrAwAEA5MvGOg9RYIIN0DIRV2+kUYqHSQNi+GTswkqPu6tdQgABYLE0MLoUThzuvJUc3+VB+R/ppwE2O2N0Ogik25+wABkLaddOYwRR3KltWHVS83DW6YwoC8napS9vrohE2mUAQ3FHz490RW5D55uLiwpjkfdKwqhOTSYuNgGxpIoODAAFKvhLTXfRRAo8/LDW2WtUvwHduzXHl0kjntpF2AT8AKntr1vJzQBlXm618pz+awYCT9U9grF/7Yz2iD+VCyoANbd6EWtV/Ub/zrCKHtL7r5ZoYLxM4F0qld9IMsyLogAJ1maBtG1YB/dgcVVocHdazIUetry9N0GG1N9z/XupAP0/HZiI8r7lJS0QRehfUjbX5VyD0/OdzL12NHsMJEwAwXp9XJs4MamIOyx/C0LtHo1ap106ISsQbxQIGByx4gDjLHP33n0JLpFouCFsdjo9FKblvOJhB2hWq3TZHiZvAKXsosKvVKFZQUFDyUdIdy6d6R4iXKlyD2pFaBJPqxYAFA5fhEx9V5EMfKu6Gb+nC8vJ9Bz3b2XyhG9EEgQZxABij2ns31xvJR+qyQLk+FyJPvl+mZSKboOCPayvPTqyABGEQlgo2RLwmVSmPeztUDxd7T0a6Q0fxVleW1h86f0AFYsELTZZD0Pds446j6/Xc0u3AZwPJbtrXzoU9oXAUgAqSXqfdNaYq25wjW67tw2BrPEXItlV1rOHFkbphVYBAMcUCoM4MEATaOCPVPEg3qm3RgoNQukHxGZXfcy0GgAA79r6fKR1UqiVcSl84himQoQyP6LvWTMh+mtjmX01MgD6SK3/QXrYC9Vbpw7LEBhtVlaoZyRx66yXD2f2Dds6AEpSZNvSenhqddFqK5UJbEUwO7uwNDKEi+o7NTP+dJMAw37grLy80d0ubGXIw8NCK6I6v3Xhb3enEmMSKdO3nwBzFia3o1F4FY+RC4uWOap4Z41Uq0cEtf3xmc0G4sqjAHwrA6JGyaEo/eA1D0uZEWp4o6ceuKq3IubifEboDNkA5eg+qGK8eBdAjifhzHwl6IirCwB7mrm+OBZVf3x8swCeUo6B3tZN3gQx0v2CX7CZlJC4X4F9dhB2Mi5y8RabAIUqd9JEdcxzjcJ2ek/Mui20kZiuMqEbna4dFbUsonoA0x5V0ZyoJvsWpIbe0rMWiLoqHwrsbS/rKn9TCW5ZlgDEDRC/A1+h0Y4ttkC4/xD8udiRWMBebf3+2c61RC1/ALsFdkBiavqsXQunom6X4PkDvRdp+LLlsQ9p1+tUWhUA/cduMUTMllguoAvwMNBqIex6eJyD/NAcbnrM7dpMFQCkj6cnolcq9OdEzyEzWpMuTB5H42Vrk+UNye3XYrPUAPiG9rMgWqsjy7JKsBMndOdfrPGCkI9D3Zu/kmQfOF4AyW75Cm3dRyZxDMslDUGUg4WcsWLVjvDk/kBB4qBekwAUwcma38+RqFuJ0a0/JYr+8Te39vu8ioSTZ9lwbj/BAO5vcwxvR+jAwwcv4nq+pl6Jxn0R+sBtQ0QlzQlD4KQAaMr5urnmdjOA4kHpq+TEejVaBgZQRC8jH9R01clw6gC0ZlD4x2A3/ACuY/ieiE90DzQXheZCX9tcPsGQAuBDALASO3PU0Hc+PpAgALCYeSmqyTuZsjQmHgE9MRS75LYA7+/xlm+NIDZeA+WUrQdBpb6thbU8f69s6sFt20coCQAVOAaMInFxkWy8adKqzh8f1W6XisTfglfhgIW1JMPCAJewhJWX+PH1GI6avyhaTFoXqY7Lk38+OGm0+coCdNwAURiB5yR+pkWk3PbvGwD0XLSEY+L+RdEqzWYf6du2qgBO0ZJkHqBBTT2OSeYXkBy1toyN4XvWDLEKZ8GaHDPMAK35igjpj+X5Cc0FYJvbcFDN+qLUkJQTDVdlcY2ucdMA7ZqkbtJVamzGRvuyCUuI1wB7Orq8Lxj2pLsVhxOYNgByc1PBc6v9xvsPdLkZtH59hpytCekKtwxQg/eCadInAL7bHYCoyfbJze0CbqRcTH6dpIHxYRWy/pSmOltX+MQAADb+YXhQK4xRXWAjoxzeErdGHp0PS5gZXuOY3O5dQwA+jIzPM8Eu9RlYSwTvXQEi3AZRVnjBS/lVJwOnVAj1AByrBHGBI6CBx5GDv+++lP2X8FBLZZRC3mI6jEcQwAkANQHBvOe2Y0kZW/ZtH1fWllX5ocDLbel0UXypfnNsiQAIOQzPGZ0ORGEayoTYFwTc3VLyimDpXaNxy0YcXfx4AJNJ3OnMSJvQ5lRIF1WcisK2CEnpIJcyIKx0C/pMUXsA5vSfI0ZbfzEgbrpP3bKGgOh0mNiLtn70MAdnxX8l5gD2vuYfkFjcg/QfReMtk4orBomVQqo75MmaYJonK0jsABpXChF7hl27v54QYvpiblI7Wcp1GtNjSfRvhzMJ8ycA1nH5sFs3KN2TY8NnYSGT8m5tfb/YwlVLqczA3bASMQC8K9bl/YIXt/gi/CWNK34YwFg6/38ZuyrfR++Ml+lfAEbJ88gn0thYMCB3D8jLqQ7eJTvK7F/MQplUqiLiFksA+73PXbr9/qtvPJ/emXJ8fZxjaK6lDsd1a+q71vteRADPF15e0WN2ftNCEYoVeHVZEuFThf1XbVwJ95/cIE+/ABvMivtMxMah02niYtYYLYGI3w0QpIBwsGwKXtYFbEkAg0hqxpGOM6ua+V6lsKZsrEUDQinVLUdlm9xwUa0gZgAZfGkzsFzCl9OIj9kz49Hw/YLm3xVqRKiygO11f4j8AEU5oTNHjVjje6UDTXyUo51czxJcgVrUd/uHiofOQJMARev4/mAW5J5dmIOUj1ivNhtlVmFgrYpnU6VW35kl+wCH41RQmp8DGoq19fjh3g3WzN5zRqjD4MUIgVsZPmieAI7UXo1rNZmKKL3sOcbuG5jpLTAV+dBhWsFamnnwrioA95Lj9tpYYrbnjcjL5HdA3JV/llFXLR5KWSigTGKqOwCfc/bgmS/Dj6hroNqj5hvvQ2eVYi5IHBD4O4HuXvi7APVdqMnYIrr1g2pOWBRLuPJJMGNwPNYuEzcdxZCXWQQA8Z1BpV7QIXSxcs91MmhhCEN3Zd6oq/gHoFpkjTIP8QBxhwxQhM1UrGm86gs3oLWFdmL/blMhUUN1i+Z16/tbAEcHCmvQ60aC0NicZOq9l5WQwUv8I4H5OBoBGxl3PzkAmlI6+DD/trh3RQ+rpeenxN8eKaYJu+nhSSLXV5KwZAAc9E8D9EzhKs7kt79H8euWQF5yE+gAPgoqYSJ9mZawAJRJ/4tGqBIzKkUIj7TqdANqCWltTsGDYiEkd8OsJwMAlwjUhmyTH3vC98LpDgX9baPFfMBR38aZDXB0scLvzgDYCLhLDmXMwB4ueUu3XpJehGxGNRY4BjH2T3ZSM1rMAOQHclfJUVAyW3VyMEABsee6oVCc8wF7DnIfbBjxwo8AZrFdAClJes+1SiJDp61Lj3UualpQA9Zxb8BMe/Q3cQAHN5gj97JEcB+QEHIG8oLCU04RuCbo19YpTdWr8xYpAL5rMDvaYYZgAN1lS/eecD67sipXBH+SngdLqaf380oA3RmOcsedt/ejeSPwIkV4nfG/SP1khmK7UTkbOAgjTQDeyiCg/JB9JHBie7CCGnQfk9D6pC1KUzF6/Przww3LAMO79DU1sRSf3VYtLvw40ZzmXS4LYwNjkPMe+treUmEARfymf8xZNw4skE+J6SGK15Lh6kpywdJHCuH92Oc0EQCwsZMhX2NwPmQV7om5+1q6Sj6d1lQANsl+coblCajMAENxo0IkzcPRkXfXt81LDp0vIGd8+ikVADvdDb1WCU0ADnSoSr+L44OuKHWCg352oBn+cKw3YDfjt89gDZHmJgAHaW0G4JEmEhGJbIFd6IPDbjomKcXyTeNUq1v8D4GxAGdIGtHTWx/N3Mje0DdTDII9brRSO3m6n/llNdUC4YUAgswGjWPH1Pim01j0QPOolYVmmtJ6pSdQ4mz7aeKoyQConSRi7qEmr6q517EcczFdO0Na8XSiel4O49RpGYCuAFEvssXKdzq9Z1/1/VLY5FU/Ue3rqbkarAMlx+ctpV8ADWtgTR7CguktzNps36Z3moodjYm9mySHMnmHDnMXBACTJpzpjRYEYrOfSaNNvm7d1zx9WMVlr1YyakK6iBduAMHuL50bGVDmDhxKT/QPT8iXXftu1dU6pWpcM768g+8Ak0uwsIEYhrZ/sh0tfd4y4oxc0+Xea3Deb/90St8ZSgBX54yIOTh9YAYLh3u4AkaB5uGYTdp7PGWARZKpeTGtANsAYbB5I2kQKpPmWFjYnIUDrJoP8JFtkqZzoD0OP9oAv0LDUGfJVPwewmWEuguiYYowoEpG5giReGuM2MudKQAzKN/mjsl9pxMYobwsSHIgEwaY12Ip+Ml4e4fSPZAfAM3FpvPWgCIJWVT4frhCbrFQjmxSL+sg6h2NjQcCtJUAHD1a/Ks/OTQDYgCmAX+Hbm+lK6q4NyeOkSYof0tQcADYX4E1uSv8/AFMg+/PmNscubMqXxXkIN+R+FwIGPhLAL0Bv+gdI6bn11QVaX+l1T+jI63ompRqDPWnx8ZpzXEAlhX3p4uFpooOnMZhCXLmnL3xb9/9CTGBNBsPeYgjKwB6xT78bNnfGtKWOOrBLfuAP+ZVbnFrPYBoFXETEDziALguqm8Zurjm+NaPJbYtCaOar/eMdvSHcN+mj8YvwdAAjp/do4wsyX6uRCs5fgRxU8ESCYf+cEnznnB7dJo1owD1oXUes7ecrc8HHF4xGViiZ7ZMMn6SiPXCqm8pmEUuAAGp4TASCQXb/4C9e9DwBed3mSnGPDgfZXgpGvnAC14ASlBj5/vhcGME2/E0xRszdfQbnyYfCPr8qmz5PfOC7gDwqvavbRoAvUBgH3rSlpUas3MAJqrgx26W7l7SltRHAP3gNp5aH0/zTaYoevB/bsKjPdRKp2hjLeevnv4yhQkAIWv4Fr/xUGFWAXoAGlhlWUvDEZRUJDFzsQerWunYjgDi9P7oc77stjcW1pTMbs6ZDkAUPHJpG35hzEZNO6NZABrM3K0gUQvc6bdWU7Nm1rbYTEGwhvwGIr1OmhJdCC0AeJNAUgw3nAdJ8J4a0kI5ZRWnSOaq7vuqXYF8hBGrkwB5/G1s9C3K0JKzLP4Y7om7nNfK5W6lDeAFEw6vGP1rAGao0O+aStTCp7IvZhzoRcfkHnungfwmivXZ/AQQnWEAW03L97MZITjK6VDmmTl4ylmZB8w7idf3KS0cX0GPfwAaBrGchqEl+o5RoIjoKldpOvWLnj6r3j8UjQ8WMsH0ACD8DK3y7wa9GcUWfh68sg0LlnLsQIdSZ35eu2gPchIAftKZz3Sltz4fUtYaaE3+iWzh2dPqxIlTPMCwG9jOXwCtpoS5rSWwFHok7RHN9Cvxvl9vC4mWVFfiZFQzU3D6AKmLiVmY2Hc2yc//+hRu/kWAdFw/rTPd5dmuHKze/kMA9v1rUAwk8eH6rJ1Jb0Ke+mVVHUPl80ODWZX4DZNFvwCdl6aZ5++IcpKG70vVIcnm3ko+JXaqrT86AyQoJR6PALwwf6KqOoF0P+r1YjveJfC7FQEGW/UUnTTEoUXeEVsAWg/ySCnZuZ7oMqWVRnqQuYwwqGAJslVzAfEbSwhj/QA++NtpsQz1GrSJ9pwkszvad6m/ercHrYlZC8uBIHc8ACa5UqdTtHR1A0UcDSn7blVkj1N/4xQzS4hTA5rWBRwAlutUEkAdF9OP/4+W4/SqJMgGx0A5qcOCdJN0OxxxnwBT+6bjfHego+9pXqqpjFdQj1h+Sjo70qAfBbY+9F+qAIkSy7CbS93VXShvK325KbltmmGHbdsXk8x9dBzv6EgAXCFYxPeZbA/Mfg8nHElLjV0BqEovZG8Cg+0CiXY3FgB1eBpo6bAwgBvdnXb0UhFTegsyfIyY14bcey0w0wSgAHxpkbFWGVgy/BwiEbg3zKlg8uzQNo3eDwlaQEbhAsIAL0hwt/Iz78dkQUCthqlkDY0K8iizfSRTHVqedA7gqAA5ma0ycY4EQW2eEs5FEvhUXUTA+y5Fm6F8E2hNWWXeAAv3s6/A3LT17z796Tt0AA+z/1JszGlETFIzX2lgZ0wA02QxZg7A5Wju5eaDqL5kxEiFfXA1nDv0DTWuWxXKoQDzhywu1Y3eOtzFbiJmSqHf7n9jByDPaIebV8SenfT7AHxM2MU7tZVD5mwE4pz3GmGifBiLAp+U9+C4Aw+yX+cAgOndj152xeMdSDiv27tVKaZXNkONjSiuf6isY5CmlwBYyz1INuppIbLojVacRe453uUfHp5RE5bZzYuebDioACNGKFq6yVQ9oRNtEkzuVRGRlNOc8tJREF5wX8kOHLQAO91iE9NnwPenKPNBbXnMv5PHZA6y230HUl3h2g7LhwAxAvKGZGbcFH2qWwSVPT2IzFVocxovO5k0FRqBW2FHANSzLN9h15JV2wqp4+DeEOUSzeRp15O0vYtR38eip3MAPs3Fqx4+n/Gryg02VlyCZvjlpRfcxxI8Zujgzk7iawCXBh6CO/Ugfm78KzMYXM6FiufMK6mBqvGRJdzwLt4OAHSEj15je4/pyVR5/mRisLgiuYH7q0HPsEXdeCFkybIA9NdNFLbCM5yHBSxlutwx6ptt8e9d7OFs/4HSzL5mHgC3iTF1nztZ/SQGBNFlKvHrKHvQ3ZbqUnUvzu+pmi69APpOgMYN0idI94//jTW8IuFsqfDq9eBXLmU12/jqyisAJqvv81iBrkeKh3d3GaN/i5wjaPTOdhnShmCmjgkaCQAGnR8/4Rg1/WlTePmFKNOvML0ozTob/nEJJb6J4mxvAGR1hg4YVYUUqFTogeot8RNxnxbd9B7DPrB+Vt0Jt2YAbsOPYa4Q+WoqpAdeTwFDXh2cQaOJfY9Ih9yu/frBcwBwz1w3OKPwfSeEUdvFe8ZJmPVMCn76/eKxS4N+qMRgAEjgw4dkoQvkvLhwds6FVbFym9Dvi/iv8YFSg6HzWY4AhctYTC+bleOMilaqurcd1QPEPt60jxY2k0qksjZp2QBy9PuavuhdTTew+8ZG9m2C3VtJWdrsb1CI06nnvYW3AP1w8lBTFWUtIZ8gUotmyX8sWy5DPuAoWErlF/+RFdIAXIppOFRhW2RQ+aV6GytCol5TnlUtbnQfdqbGZpSZAQDJuMwDF6dlA2GLyHdxjcSXOJDnhBGr8aJlXtZpsoBHANOQ0xkmqCvqIwfAjXlusz6C6wTxUdMO0umNtsefnU8Ag2nJngQh6zo8s1A6CvsnxY58sctJXgus+2QOpE4MOwA9emEWrgWqqFsK4ANIxXRyFlrrBSF2PQob92gYlSdMABIqODrDr7WXuP401MLjRPuA+3lFwYKYDfb6l4B3CFwA0AnDX9tbz0B1ts+t04186KRi8uxN8Q3NUEjI7gEkOwClw1bJhbEap9C0qg3DxrRnGSw4tr0jO6gehG/tg22TAPNlCDpmhlK/8orXNErfA/RgqWX0HyXM7Y2lEEr5OfEA+4PNH7gANbwT3473+MEHxRQCwFpmPWW27eyDGC2/DACCnNvHIdjklhcVt6wj1615wusIUSptjVEBTyFzEn+HAH5SYicg8GpXysdMNAbwLHRa6pVUi5b7nyH/LSq3RNAAumwI1bDdwWEl5oos313AD4ARK0sG680+nG6i8o9CIQA/fVt5ES3YeumBLI1CHSudLGySsdlaF6rXDnwnGgeEAKdJvmfsNCXmQFeu0lKfS0HTUisTRLa2UDPnoriKolsAahh4Hflnie2Wn7yM1DyLbAt/mc3Wj3wkaeadR10NsQCauePemHbAEIzhl+Brqq39AWCS2z9oeakrFeb+viBaAAl4mOhAiyQPclA/MxKyUNwBLTRWjm/I91ItGVCPhIcAIr1usGRTJvejj9wzrqrqbuBckOPIrLAoc2uuTUn2bwBVDYCHRAikReBXgCFu4A1hWYU6ujV6s4/ifxd/+AePAFPzGlpRLNkKn2LIQnaHIb14twx5Jm8F40qGpxY1bGgAaF3of6SYXdSnWJyvaV5Wvd7sfBp5yO7FOHwL4aDkqQBjg6+YiSoIcT2tkvNphgGQTs305fs/qu2JO86AH3/3AKHuhTcEsxs6LsFelfSUtu/ugI3NnvKWuqk4Eh2i4XAAi9W1vYlYhDY/hoZEfEHTzTO1n7KF3+CJZ9cngGqvGAA1ZtjDkdVM9CZb3h+2UpgggDZs3E04RGocIr+xEkbYAMPvTzqFg83Z6GVgN5kwo/WvDJF14jzLVUBw3soYZJcAoWIAxleBPfWHTyBHuWcD5EPhRXpHpX+c2Cos5z0xMgAV+aMIMQj3+wTETXxkp85malEaZbFXHPB35CwFf40yAL9CtAyTXZw+i18KVLst/RAmJ53cXsdLWdKd/ZjMs5wAYovMH5bHIQGfBBlCwPBcV2X9EAG/5FwIv19T4q+RlgB7+w5456CrKUJN4eL5NzRn44DVKeM52XdnGZWqafLRADasxq0wrohuyLivqtOG0+kfScc8HADdzf3+i1HBWvwAy2hqc+Mq/Kii21bjkh0kf7Rfz6hZmf9jeKXEVIXfmQBU+VsO3tzMnSBWe8WW8s6aXcF1+bFAs0aKUyO3vU0lAM6lVdxOpPXO7pbTYcxylG5DV6ThVas9j6QmxLaJvosA2mru9hZ5DwB4x6CYDHjKPEjleNpaOCH45B3MFjI9CwA5IJU1wNNHUIimfoWtETOUX2T5AYIuXG3hSU1IBRoRABlunocDUgFYAo/tAQ7nGDL8eJqY1NI63Dgll2jhlc8AygiHeCBA5z3txgTZiUwveeDGZKu/DrORXtiacOKaIAChBZyr8JMhhqr/PMf3HFHDr9XAQ5A624cvRU4KzUiKAD479wOunQJ9KhT7ZOY5EZx6iSoxmU2E7KD3XNLzBqAAWx2HdQiBqgjLzhcbSczI1b8C/oWONIs0FYmPOO1IqAAlHvxXJ0yNycMLOZfvjHj7rifxzxIJpaMXBegZIqG6AMvHEVkqyEOlK2nVHcnK9ZGC1RcZ+qZ5Chmqs5CVaEMA/GiryIzCZ6nNYLksZAU+4fZS7rr6XD8naYQzmPVJxwDL4X06n3Uz1nZBWhPc+vRnlkuxe1kDGOWElpX7noabAMWYjnXUtqqle9VJvfn1mB20om45dabmHcIMf+b9Df4AZixCICgpiQyrrKKIQ+brkSDaF2gOFh4CqA6PLa4gmwD9p0qJGhQxoRjCnd7nt/uRiUHitWbFf0ffXpEuciTZALNv8LBspfvgyIO78IWFeLhmVfXlvu5Z8fqyr0224/gAJlXORtF7xG3ATlH9gXzV6fCZrQP1539n92Q7iJgBVwBhpInVsbzQupS7riVmcDPcbMhq4ERXAHa0NsCrduR3AJNMlti3qg/MWWAbkvUXP+ZH1U+QnHDBOhbT0lFTHTcAdZnVJrkQqis5ccPw+YlynNzp2gd/yrO9ymur4O2vCQAI/wM7/knIDpVmCO+mNUPoLjtOCdLxaW9Dy/DRp+t1AMqB/zoGs5n2Xj8qsSF15M812ExPVp4vN9G/lElsaT8AVzNzmYhVKA9GfExp4lGvTeqdGGw+2yr4zX5nxXXBFACpopqe6q51hvHOv3S/6vWvI4tUue+ZEscOm+53d1PPAE7LC2MY5vJduGmGmNGc+sRDJuJmfut2C327ZwYnJtwAtg3ZECmVekOp3aYaWh7ZkFLKi1uBL+4ovdlud/SDxQB09kNM+qM+sCpyop40rz6K5QjjOY+6R9dlZz/CkbkAAGlzLcMRAf3wyNwtzyvUN5jk6DHiV9g88T+LjTS+BlQAmV9WVEoc1d1ESSlEzeCBNgp5AILK93Mtu/RhXrYrwQDAX7Zl8vFQSDx4YvRbHHWL1dgXCnIri1yhjyFQN+/PAF8730lf/f3GfGAmWtByiTJgF8YJstUnfq6eYDwMSWQAxvlAuubUwEHo9ZjoAP1evtpuYqJhSSaAWRYMSAKCcACxyc8oS29zu43C5l1ugY4nFehYEEZfLRybO2JFbeGIADLrTOubLzzTyXj6t/wuF4ZvicWADC/MGjWb5F70Cz0A6OdL8UDAB4OzEOnSj5ShDdehpbrGDlUYmfgEfNSP1gBJug4kfa/4SVp49lUXRoko3bKZOv7SN+8wOoehJSSDAMNOgInf/Aw1B08ItvUQg0LevyIUTeg3Bn7F1m/F34QAzWKB9MY/tVVRzm6z02jTBnuXmlcJi4uxZvKOCNVjAAAMOykJfzQPEwlQo0k6FLQIkLBCKYAM+tLdOC0qMZK/AHKAaIuJDW/O02r5mSQovHBnC877tWumTJkwTKPXoqcAhrVjZGJBmhQiNH3OG/MY8VZ97uzT4LNr6HF9dhpNPQBgRSWX4ysCc7NT7kjvdxp0CIVvOpX0XKyejYq2qdfGAP4OOy4QgvVZz5sM2qFGitsi3Pr+rR8AUdJvWUaEOAAAaty0aya7X+VDCH3ycu1gktAmd2PvLwW04srXp++fJwC7hPxfFdN8jPou1dSg0pfcfMHr8UWCKEKMCwVI3EYlAB8Jo5UB9FMO0r/sJpWvwxL1PQWUPv8ssOHlYNo2uPMAS+pVkthGPU2vH1hNE5YunKnykD/j3D9sHNEDgkHHYgAO6fTjhhvosyZAqQ3T/hG7rn+IytngLzDiaCsDnI/4AHiVq8opg169GZwNsy4JJMS2c+noLqxj5crQiWYGpIcAYnD80pSGNApseP/Gj2eGbvnkzgTCdbtij1BX0idZKwBiJxBVbWpjuZuBg5Ye71gYzRwzj8rpJFfFyTbz78EHADbz6sUuvOM5yC1MrSI6+01Q490mE7BTDRxnbihx2D8AEsj56M0fzImoKpnCTACZ/7QhwTo1QsB2p/9V/P+qFQD8F2W1jWig4htz/rgjWHlP21Yym+xzrz7/zhJE+iLfAFmZpVu25Tt9kNfR6mWKBLHdESbbyc7lVpjsG6N0FPEAwTIH1257ExgKHJcx0Z2PEcfRQGv6pXGOx41KgXAfzwCLADXQUZy04QpCC7wNxDzxbNFqGg6qzpYLc1S1ZzaUAMwpz8CYoN5KOoaciwtmY1JWbrYVjk9uxvYT/2yDlIEAEiCzkRg57bKlTxy22KyXVYudA6KLeM6YtlIMSi3ZwQA4dnI0PD7c+7vbTs+DmDrO1nxMtlq4+I2h83P0Pd2+AAlm57u+aZAMPoIslNCzOVJl/rmt5rDGaQKrJ5YbujoAO+CCAtsFG27VNPBbPnzt+boA29OC6Q+Vze9EshxxKQBFZrhSp3kO8B2GMiqPZR82vU45IWUZnRY43X/fu7JkAKmhiwSDPeU3UxJCk03y4+Wu8HOsF/DbBu6tMXPnOvIAOwgepllYdE4cyToTjpalkSMjxOU09m69gTKXRaVhowDSzMaGszS4WvqISVd7FDHzx8KdQYSm891OSv9UgX/0ALfqzkTkuijS2bmJF5i+J3OYfNepRJQaBhkRiNMxRlQApHVDuPdFj+m7ayDwu/gPLRxctmFll4Vt4Vh5fxCFYgAbBRb/s5RE+rRO0bpT1AeHB2sHJCox3+HjhtFEMC1WAOnw+mZB6uSTKJIkLCMGo/AwkAzDmBb/nBwoMh50vcIAk7VJhhb2GMP8Tq3mLXa0R5Q88jWQqOuNVqyCDy0mCgAIv1QcqHsR+lg+hkssy2Kp6bJVPfup7m3pxw6C6Bs0ABa3WwvE3i+s98t9NaIVY12u+/llW1dzRDVNF9zYSekAopLHQNAnBSHpymdhgupr7FrhYA2J+0NK7R3uS3o/YQAqjMPOO6RQ7gUqO+Q1teMaUp9jIIDuPlQ35DiZ09BtAL6XtvSn3gIINeRlIvV5wGM6S6V6gpaTIqJKkqlBACMAkjdqhl5y4Qv6T4ANc4IGi1wcQZwQCf9I4wm/j0wuMQCfzG2eHw+YwvEQOHqajQPd5D9TI0gIvyrA7qP18kW2AIHNeoNu2ys1Dy52vI5fiylprB/fu6MmHsT4bOFqZPUArmQEZpy+ijL7a5tSZ6aQHHwJUU15GCe87T8YYV2bdgBesBead7Bh+/rh0DYAG0vB0kIvicWErlLlMD34Of5cAFSnW315eQ1zYBilvhFKZgxYyV6G6poNnuhHTbU0iuYA0Sd0izWPLPuCKzkjRAKMgjzzFlSJt7McwthrsFqUxADAaj/NIEwMpvFMn5Wx7o4g11RgWCIeKbpHo2k2aC1TAOf0lP3PEiESrGxOShcgjSet+SsDFwtpxe1Nlbjz3b4AxnBv0xw+8wKDrhQDK5ppjIq0VG2lKa0nxjgkSLf0cgAOKqRgFPlmF/N+poCqpcNH1D5EZIa/joee5ExDdpwsANpS1S+lncLV1FpdKLbS25IAvQKur+66VrxQo8ri4q8AkSDTzG638ixabCu74mkOEyLHk5EkrKzrq9wQ4uWpyQC/7HvTk44uVWS0LdofWtO6Yaiw3X3ZT2ho5eZ+PN/fAF2PrUhsD1szxvbG2qJimawQamHK0kZKNsWlL23j2JYACkE96X5J7MuC00F3JhufHFW8xlhfetwX4z3s2tAhzAAsEQJ2390oWEZ2rIcCt5kqhOkhHN+CMqaVvbr4ZnR2APYhPE0K3QE20111WTlKFTN+lap3iuX6SGqU0QRIbCQA9KWLAAtwkixTGFaX/uAQSeqGzlcwyqrXaJTv1fsn5QBbg99t8EPg+oec/jyx7H5HcBrsyda5L5yY8n3bl8sdAJw/ZvHXyThMQgBwlkES8+0VX0Nux0JRhcx+ZLmQCGsA+49S9LpebUQWx7I3zsmRjkrZ7exikqTeMYaT6GxjdAC080Lgjs8z0lKhfB5iJ0FSWKPQ9/hTunPJMURWEYZ1AG1aJe2fLf4rowaMnfC394rTsQGuDFnQzeU29TVawLwAHqHV24CSXwq8cNfY0QU/90NmBNEU3fKvaqgArcoGlACOKvw/siRvMEr+tkbApQqqOYYbuHsVGzn/eKhxmKNfAERo5IFK0qCXThBZmSUhxw95dD3tUJXQtk3HlV71IpQAnzXxp8EidhUi+F5pdMY2e9jNooYgn1kXe81o2DJY6ABvSotwgGtq+amQVDhvdjOZ2FWQpDUnw1rwSFlYvdi/AGa92z+8htmppR7AdrXq0xyOf16mpXdk33lI+OCAo9MA3krY6sp4e6zm8ehI0V+R6L6RJ1IRW8j/JPBnVDqgtAD8vOxh9gp9tkSdzJk7lm1HHxjwH6gl2oQ2LmcFS4CVADIlyOW1R5tk7avUN/2NUlgii7UnF5rJ6Vd7JfatVPoAz8mN3JuMXiZZKO9Xykb5iu940VWD4gcyZ8rBdT8UlgDjqHypGzd2jSyzoPU0K0KTCNNhkbSX9VexKkKKNfVmAKg1L0/HPWt7gAqTpWEtaDMRRjft/1lilp6hMoyHuL4AENoZ+9LrngBjlI1gVQQtXlCJ46JjoMhXgs/NBYaZSgBglVjg5E2MZsM9GoZBhs1783sqmGo8vgqMQBWaw9TzAOhdzPxqcFuLDyg7XKolvxGWRrhaE7DGG1kQTwdkVKMAKwmCENGhwxeuQpgu/P/9j4WdrolvXn4Tu1eNv0wZNQA5r0vq9+qbV0BKd56Nl0O8m8cgFoTdbjsjJc4YKCNSAMt844uH0TJkzw+byAmkQKqj4eyaE3oiocUGhDOTPt8AWrsYoe8N3axafFmY8fQHuzVX0NTv9n2gztqRJL6AlACw9icgR6QsLToro9bScVaQuaxwSb5fXLMgSj9uAho3APNpQWOno9hmjgh725bCqKyYsdHpOll4Mzck8WA8HyEAbh4dnBHijnHwyVMQt66HZKrt6i6OyyO2JkQoXTeYSAC8cbAVqpt3kBxt1gTMIvYYZ+e24zLPpsJUwWpbAXcNAAZp7isSmjhHEfPig8wpPzIXTpWm7ASoE4LhlamS+dEAoiN57s0+wsYYdPLFa1H6TIjXtYMsvCVqI2jos/oP3AB+0KabW+pay6bhIsogO4PN5td/rWYy++kN5D2Iw1naALWO2+U6jBpn40H7XvnLXTUBALdeS9M115UC+6tSIkcAqatPxkzLWhlt3IgCdOQ0LbJLHQ4eLuS3KXiKgLPawQBPcL9sFsh3ZMJsITsynsZAj5Ckgw8G7n/vdmJQYsw0ALtmeQTpnCdl9+9DbkDi1vWfmTcJZywYZbWAMtyjSXEAvXWe3SCIzmcmEX9X5QeOM3mADrl3y8AEvSCFEu/0JADnKCeDrvTGDTIKncpRSAfpK4cnrHC5X7CGsAQg7Q2JAGmdix3b+U99lVcn0VAlheiToS/8AKesx0WW5iUEU8UAmVb4VUs4X+9PpGQt3Zn1Kq2ScT726ry2NJ05KptnZwAqs6vWTfCSHNyrBfnImYxY3B23n+ef5MmV8BQ9E8PbADTuyHP/bXVt3wTee5gVUf63c/OOSChwo3GD9Pz55F0Ap4KcYIQUcnVOPRWrodMbHub3tOOWEvBuMTinpoe4AgBOJUCfZo0pFLkz6qyzfjlzfwLOjbaYXqE2HIkKhxzIALQgvMsmgka6b8+0fOa2WJ+AnCa4bsLWOOdCoZPCONAA6MVmYgt3Vo2ly9ajScAJcSy5WLptalv+anO3/iVpfADqmwUYNpSNmxjvi8MKPYdwZVKByTZKhPxDgJt10TS/AOFoykrhVZnQxA2u22ogp43rZLocpAh6jM8/U0foVsMA0GSMGSBVTTKFmSmh0K3DO+OEWg4lWvkDZTw2zBSZaAD2bPZqG/MlFTZXqxDZIxeHytK6m8VII6/dYN9MTcCHAELFi3EzaSKiYcFOyIbCyAUyGk+J2V2/YX80bKuzx7gAVJDYdFdigiPSCBAUYiLOrFbmVDbbcGwMOAqMVhmPQACLUS1NLgcuwM9kPp4nnZ285vRRBcraQXUv09fvJtzpAPx16lOww0r8TozvkaQhHDyYgih0ESKRapWGPF9oX9IATPQ+nlqUmJp/+uYZkmvZBc4LlZX3f864i6IoYtT/0AAi7ihwV1U3N5KhdivdRFDoTN3jd2d4s7QvD+315AzwALFbllGI/xxERs6SPSeOjcUb5KOjgw1SglnQNRQipHYAn5vXQa2UNJSiDS6vCnmIpHcCrqNzH6Rj/3cPtQTiaACh5fjFp5K09oX+BbqJsXBJe4VkEVVkagAtREwOGACAAGwKwEE5vGjBfdmy2O7MOtMDFdA4PsypaolWggqrmN8ADrXWKJEyvs5WBDB8GQF2mMvAlJBxUVmbLzahY91oUACrRLn9VWGZH2jWZ+8lbnfD6kta/5CSJrFLD5RyZyP7AIZhZQCHstgLD2f5G/xAH99FclR/gOIJy9agv8bBhSoAJWuhVGJjKkWeMRNF+SLKqJEQpNRpm4qQfvntZ+BcZwDkJfsIQptwMTQiwoSvO6O3WQEwgP1pvTI+muPjefjOALa2D5NWKzoSPOe275JfiC0OW52Zgk4HH8k+Tq5VcQsAYZ+1/9Rqy3v+6LlGv0qIpplAOFg7UqTitpWfCHm5TADc+4/p6deKu7wlMXuX5TBzpmNl+gEWpQVKpOEAOJOJAFiVEYgVIyzu/xLGaJ9C4dgjN+4Wc8vob2tQ46Br1RIAv9vJmiAH7mEAA53mqAvtoksWd5OU9BLUKFJqwSVRzgDSPC4IXzSWNxRrE5jJJKQWybJuySDCbtfijAmLryQZANpNOJxIQp4cp3OO/oeqPqdkkxzj6EDjZrsK1hdkF9sAxbLByxeNF9YXl9vW29Qu8Qqd7x7/qGc589RIQvy9dgAgf6okaf3bwCXHwU3goJOLRgD+T/xpjAl2EaDEaxgUAPUusPPiaZ6rs5LasNTHvI9qVjA19h/7UpBQKxwWPiMAXfam0vzum3K7rxWm9lQan9A/OxaEWz1odEoMnSs9zQAI8sOi3hX829ncKE/v/uI83Kh8xP07BKnEO4rwRuqvAB2c9QR3okfFTsedQoPioph0EMW04u9f0PqLezp3KA4AYmHKTp5Rhgz6Sq4xnH7DKBtnNtI8IkgH5d6VSLLupwBSPLq+VOhuDG2BFVkokus/rP0LQEsOniWzLEGQBz+3AJvur5huromwusDfgupbELW87ZTuCk0F8heAHwzQ05kAnGfKCNmf1g950WVpXSwzu6hfLqZfuWk5WLXGrFbCEgAvu6YKirap+1nxPPtAXmoo2bDj/8pBfvPNnhCEMEg3AJyV99544Xw7vmlb/2toI+5IED+YhrvFf1o4qpKj3qAAiitY3hudavlpxRL1iruf+4pzCh9ay9Gj7XMKnDYFdAB4UvUqv2km6EgZPE+fP5Bgtls/Bpx4DVX4T0ych1+BALyhG0DQe6uqbIBpwyNSFGdU08lnIr2AZzmVMb2suPQAh2ysxGG2bc6xoaJ3tFJiiSnzLcH+TkVEvBKGpm4LFwB3Qn3L6IWA7VWwyADUaDgQJPqrWEk1+TEsUFMi76WxAKx+BVDAXSFvZmLDH5Ry/KY4W3PJ7MCrqtav4bgD8YIArbrzt/4ch4MlBmYK4zgad3UEG2k4TRC+K7ljVdMo6wBry/S5/c/Nf9c0zydtMCzOWuWHGVXae8u01/2fQajPACQX0feEgY16T5K1fW4iS0VA+nplZkF7iFypX/ImEf4AWRnaRc+Zt7b8+h9ECa6GD88ibc59NutAFoGeHZ/m3wCEK1fJz5feHqFrVVBx6CVgBSrerE2l8opgBQUebXgBANFOsEue5LnciqTa0UYmD4QXPk/4/ti7Ue5qB/BIZwgAW7ndgZOZmdzSZCcu4U5TK+d7Ju5hp+loQzmjYYXfRgC9Qhpt/t+Vw9yySXRb6yhVSbpy+Ve2nSuuw5NNLoy7AFPjrJ/0CIDObwZ5TV0GgD4kiBl4RwO8WM4BvDL0HVkAsKKvCS7G3ubk1jywmKNn+wY81cL9gs9krOe20PJtIQAZ2y259crUyRdyoMJyZ7OlheIsV3X47V0wDtm3wBznAPT7Acs/4GPXqbDdgUnVvA6aLNp5xBmtDHpGAhAZ9bIAdWi942ZpEMrdY9QJvwdfDT+VU7kr6hNBh3unhDODbACBBnbukccJJJTxsHp+k5el2Qo9HmJtklfijpjtCPruACqvBS8O1LOxj+56DARb39og793BjVF93Y8eTdq7OkgAnbBd09ehL1Qs8TZFFJ+ShXnQD648rus+RKqNeUyF4QDYRy4rLUNpdX+dJe2r6ZPJ7XzOSrTPckOZ5U/3VE1kAAhjKjzb+mHz68GHqyykva4hN865m/PzJsF1CRu8jhwALVEz9dnmQYZ0i54xHZIaZNlS9Ea33BW5kokgZXk7CwAaqF+GCUX9fhpP2Ld+s1fJ7jX4z8+0BU0rkzCIhcodALunBg0O9dCUwzg8L5u6Cm6iVXPCSaBJiBDvK7NtRgIAtQfg31dwwrlDAzHV1sdjq07BozBrGcZ0sM/f9Uf+5wCFJ2mP/h+mUuGs5iroynBzHcUNFSdkRV10FeBzkoagAHr1u98FUvF7nXoTdUIRWdTac0Oh+KUmuZv9NRGJQHgAAhz+943Of45vz+Cc+VBPH8XKrGapEilFRLunwduVqQCtcHtdUsNqU2hAlKgUxL0uWND/o5w8xOK1NR72nTtTAJCETl8IKFMfwYjj1jCaihj79QLGmWnYVV9YDygYo28AQj3dgDUXBAIsF1CT/l8GJpbTrXHD0lSXc6cqrPhQtQAxASYkBNjvC6LgGqax4xhUADlOMGHdNuNfHvJQVuBxANStur8DO+5O1qJ7bVVu7zepZzvokBnra/Aq0OyvN0gAd5CUvr+H4jHN7FnQ10M2PdSJqyoehTqRHYslyuzOrgDR6hpfkbvFds6W8qfmr2j/K1ZL0tNVTEvyJWrGf/lXAA3qaJvW0M3UkivU4Dos6f9aB2orvJI1eESJSfdg+VcAQ7+xR2zhyB44Uc6UnqGb577btHUVW6ujXsF5sW6NbwAkRTPEPs5Rwo26NFLXYlvrwakcnkCF1ikVHr36i04LAP6pbjjgMtPRonHXxrKN3lfG7JKitIFVjsCPUqqacBkAvo6hHHM+eHXTOBU+AFPRcexbWRyDLwKMaCEKvKT5cgBSi+fCoBPdtHaHwZWnybH2j43dSHVvSSGA0XSR9r98AGgqHc0cADP38U+/I6hmSbu4S4ZRVE//no0nKc5PWnEANmPdb+aPBeXCh/31vuUacogvZ1W+sUFpqjhJnB0UgQA3lmsLm8oxaM/DheYazlG/pOzIm//pOqbUZK1KuH36AMvUdDQyQV79vaDMCl3C6O2wa9UeEEGXO2247VPaIbMAza40UC5oOyDQbbOpIPIe7h2y1s3CvrhEPZ/K9P3mMADzFGY2OJJrV0no1srBvNMg6QhZW+0PDtseDHfB147vAI1iTNMEbnzpnaBP4unRDMDsww6UGbsxeltDEmPgczsA+1emZutbscMtUXXHyQSrxc/YG4/2XepzqL8xMQq3OgAhPhaiNrEGbjbHnesoZztoGrx22tIc8pEAqvi5gtWUAJnw4/8ABcC1Yh1YsudYJLX/RGu7fh9Y2Jo3qcM+JjoAdVE4KBy04BLyCYQ+0FRgtax7f6ckAR4PithfKsPvngCL0cn/ar1F6/RPpk/fsgKm3Ks4COyBGC+MPsNq7jvVAPEpgaGi0FrHl850JgWABzO5HoV4RDJH/OAOcb0hIeIAabR5tsVY3G9vpxqdprrOKGsUdOwgCMPDtEZAe15rHQAGX/Ofx97uDyy8zW3HnpIntotRmCBqpIRfZygEUv2mAGMEkMCgkmR8qRfuFmD7ph2Tmtv8Nl6FShi/m/fcJoAAb7gTSzFV5l6QmJ64cXcbUlOE5C7m9BpMVNN1l1TxYADFIkGIiGHAR0T+l8PKHrDAT3GM77O7FnH9F/283KG1ADauYO/rT/3BGul/Et0ojRMaZ+sTvj/PHGnf6SmcIxYABpAjiYpfFnxLUEy0dlzehfzdIZQBxaVxGU2VdWIcegDWISjDwAJXHYWa0RqLfBQ0grrssBvxiELc6Pg8Bz2mAO/v0jRoMNJ67nucTlFgQswHk+NFe7jxFFuc7C1sTsEAgeYUdt57pN03LK9vOhAYjU8C9wW1cioqmQWUF8ufawA1Mrz6kIHSh0PYojh932t9L4BuD65VHW+8MY3dYXLIAPh4u4iojMsNdm7hkNnlxBq06zI8q8F9TWrCo5uVIicAhi9sRAoxNY40AxQ2kf7w3Jz3Le7tQyooWYLSUaivwACDA5MJFyJfA7pjSvwuYeneGMB1+jdOxQaA6frpzrHHAPwaG77EnBtb+uq/H+8/L12lKhUXgDAorZep/nYlIa0AyfY9fBdczycmys9OQf3iZdpoaAkT2l2cwXQoF4GF0QBfo/C0gxpKUXWoUCiLjSIrZGIowLB58ef8XJYcKcdyADOzeADcUrB6GNMkt0x6uCq13HwzjFv65+iic28phooAPMu4E3/+va7obXTPbAq9JBvu9OPOXRY7zJzXEmbmqwDjkIzFd2pUDUfXRGAnfClUxP/76Hkehj2cvjzw9Q1zAEH67h/aiDCQRUFhe/3f2yAJV9GDULSqggjETFSVImQAq+X8oYsrN37HagfBkABGL44pZsks/yZS8BgSC7bXYgC4ye5wWQL301fF9RfwvhMI+btV8K3pNwbng/+0bw+cALkg7iYlABakvMSZDf/jD4oIW775wgsmeIETYrOHaeAAWBqHD/2LUdcFEa7zDDcSeoEje0cxNMofoNfWfAm2QAC2ksk07AeuIaqAltHdkHF9nXlv380X5Mk5eqyaZni7ACZKGE3f70zod11JQHcDLa/1+JEe3342YiTvW1PrKiMA8JUhYQBbRrBIlODu5Xzlqu7V5asXr5iLLR38pyIeBwC2/sj9Cj3RfGlxUN5tfRjsl+2oCt0MaN/87TU1eH+IAEZuOTiFW7apPp9JcUy6QXCfsmNxZu8PPsxJfOONnbMAgMYs/pi00NOpN9KaFccbXJcljC4k7CdLBgPm9nXxigCcNs9M900NE/C6p5iiO0gxzBQQzLA7B+IK5ZKxKD9sAJbvIEgKIm5mzB+/r0UOWIDHywGefYtF3pgy5lZBf/wAPMCh18znNBbJZNmcoXFttF4YRdCSo1gLayPg7iPvZwC14uUpb18BdO7lm1EgWvWlpE8uReHalpNdnYRIx7msAJycCRtHPpc0aYHIZ/eO7r35RUShrfbqCm6RofHiKoQA0b9is9zs3O5yLg7qisNZSuAR75nkd0kB/w7pajr7ggBtv3GIh2IUCqp66bmXpE26HF3EDd+XR1FTpVsJUyTjAD6UXOEx+nQw2KA6EeMhtnQnFGxLrRmZNn51J4rSw4cAvB7ehR+hXXsXl4/Yod6Zlxf1CUAWluuUsevDHdTlywDJd0EPUTmt75EuVi5kcaXrKc8CtsVstHVCXwjNO+nHAEAKOOY8wiJyjjT+di76wGc4J1hARaV/y570DPdS/IcA8y9V7Wkiqofh5o9k5IQBHiL55do4I+/ccodUF0OpJADeBlvndr0NkFZzhJW7sZqBKvUEF6UkMj8m+okNgAHZADGmK/ErBvVjqHmXBocfaQEFgn1yYECcqJSdkl2SKDkANWTK7+R1kwiY8Z6roxOu+YufQuFY2w4l4TO337E3SQAhQZCO40NiaJOrVAoFQaBOigA0HyJQLjlTP7tFcIpMAIdRxR6SJgAJNNMuOMdmF0HcWN08UFZoJvmOy3zhjeQAy0PEUSNCABb1gjliVcR2/LqibFMoo6StKAuncgzf/ABYKPNIfVw4LZE/nq2NrsV4x6zCxzL/sTPFFhorBwaPAJdSCWN8cZ8htVCkdFLsn9e4GpgmMMsZTUqhWu6pdNwALzCD08oNu1iF2uKS9/YQ5glUS4Dx20/TAXXrDrv8iQC3Lc/xOO0hX6EkHIGgfyx4p6b3ePLM/N0S9xe+a9JKAL+3uFHBMi5jh/nfc7rCDIL0XXJ05qIX9w8tyFBbOHYAXYQuwiCnBu+3YQFL3WpWsooH0sl9/MxLRjsN2AVp0QAMPB08rDSK5GQI63bxWy2LOnezcDx13wC+yCX7DQJRAE6M1Knd0/Ci/MS8rp9VQlhp510iCrTwQzPv3itHNz0AHMAlh0TyFDWpjQLCmqBdkfcoaRGe9D2XiiueIL0aVgDLpDiZ+cHwZFHSSCTaU4EwIXoAjkRO4j1JXZ0yukOfAIoxTDb7nhjqkSvcqSxJEoYUu2EDIhqt8lPRS9fg8ZIAlRqwbCNua0ztlyMPHzaOnbary0EMiKUZf7J7kXgPFwAeznBkhTszoy6drpf9OHlyO1BWvL7MeTFtYv3OmsOwAE8CgnOTcEE3saSvpSelDIeWfoTmsS9oiNHtmGnxLqEAtUUrAHaj/JErSMIC2AONNzkxoioJxdugRQY7Si3Y1ADUr1qm9YuVfmKXjKPZFRplUfCRJOSxp636gG6WdGa/AKmk2Z52bbSt8jEUvI/LhvXoXzs86IFkGnYZuDpT+OUA+/9GUQyzTbltjOox+puRFKAlxY04kPL5h4W5Z9VTDAAMjcqgIguJnFm98FYHDZ0ZUW2HE9rRGb3R2yYs0rCQAFd2K3mvMcvqz7/t93zvUF9FsGn2Pgh7MXUyEtSAG4AA8f022FKbb/KaaxZ6Jwwa+dWOo0bZ4p5DBB9cWtBw2QDknIIrEQj88qiJduQnWpEEOHK897p6yp/WDcViSyD1AHpOEu8+7KyfK985twHJWwjoVsjWsi6XPUEHMrrJozwAs872cIHbOK2s6tuCMjV1XnTq0ce7kDcdpy9x4So4owBzw82UykYLTHseWmX0JMDpIlOelV4e6Q67Snlrp6URAOUZESw7cLsPU+7HYzDz7hWdzBU2pd1NAEPaEQ86SAkABY64nPxOzv1WsRlScuRXh/SCTysYdZgAUHvg2/hl7gChuu2dgq3mA16zM7uYS7POAISQM2Opoacq8VLRfW/kALtt0IjJV2pFPTKPy2GWYPb3a791IhIdvUF1tZo+jikAGOFP1s3gdi9VSbeYxDj4TAQRqJejWF/Y3xMxJC+2wwCl9QHK892mJogl3KffhIzhAvkCfLThK1hLZmJXVBgWAC63K8bfr4lBZ/V9+wz0twH2eKToRFO8XFqoIJF799sA2W0jVCDaoYrQniSgyBMSnMPoupeQZUc7xpwrTbn18ABIGx5WyfZAEzPL9MhScFP3QSpu02RvE6WSWfIZuhN0AERxQs4Lfbo0KRnfSiV7Uv3eFouFCCLvJ56rJs6D1lgAi/2FwrSAnMxou0GsmTBhG18zJmmoZ+u0OyNOxk19ugA3k8z91HorJIk+AjvlYQAlu8IbBJZaSgYgnXg2uRyAAHzqq8xTnpcbWJdIvSuEBxZ6vFjwSJAT8kHzr7Cm5JQAcWuTwE0s0f1Z/elmp5dk6W7qESoOUFC/AyO36L5kFgBNI0OVq/k66hiQhgP7yYbmVnluG+ENao2N9nqfyLSJAGImJJUunVvIB60r2ehn9Gl1Kqch6+EfPDeA4UVUxdwABkKhjhR5YhdksLY9ZG5Owlu0+DEjf171FoDvplc72QChjG7f6+DUMxAWCIb+BGXaST+Z3w9fnrfmOiM422MwAOnWIebQyud6cYeAquK61oaQFmUaN70BJK6W0s6ydPYAPIJNf/O2iRsm3/xsHR0lGDBaNSb/gM9oFluSLENn3QCvebX0Y7StA11t2jSUwn1x3gvDbj7gbQnKiiG9LCn8AKVcWagJbVGQ6x2s6hRNdwDpg4B7GIxswOeMYuIb68IA4J3YBNBdpb/sD4jCOddSfOx4iYfVPjO2jA855TXsqwDOFavO6WFZr+I93u5Fg/8+5J+z4J0v6R88NSlfJaJzABa6rggPYl673VnIe2RNBvG4wG8iu9yzICjm6EndOHUAinuaKYrFO9WjK3fkT4eIpRKFk90AiKrl4W5ghC6H1gC0yrkCo8J9RDPcCLqza1JXGJtWXE5B8ktZUo6cSCu3ALMYxgaxPxuQ8EZ2PXVPgKRBOIqDhA0lEaMQlXAvuHwAelOdILSc2CxniDCs5Th8vA9lBm9ckVbgCBDvVpxlAAAtyJjshnFJjqBT2EhVnVjsbjndX/cgzxl6sRiVlfODAMx4s21KUct19Zo3blXDDNr6BnNym8uk1QNF5Z9VmVoAbTwlt4jwCuVzHFWcfAfLB+xS3edI0k+Zw5Kq4TvwNgA6xNnl3Zmf2R/56c6210t8hP8AF0wovzDFco4NhFLMACaWeFsPLAWahjUNUPoEY71xgbL/g4IZHyJV1nGhCD4AovrqOJqnlkW7Z0kqaT4XAWEGyhsHFafH9jWGWt1tRABBysTdQcTYzdJYm+BwdQUaro3SMbKHw0xjOmSilaP5AFxGVWySUbvRbphffvt6KoGEuQycxTIZoQ5YgYXNvpMAKbk1c2RmVPmL9OcsxN/s7ODbOYvoOT//kUaCzKvh5gBW6W36TwS83ePLAp73GmNNiDVJkZw3Bm1Mijzckb8eAHCuCq1q8jFdXZ7KMXTrTFx4unbF/vX/tJ87rIlC3b8ANpN2sUuR3nMGLdHnJ4nee7NRYU9gMllk+2D7XXz2xQAnI8i/78ss1l5yTPDq9FtpbIS8h7O/YL6z+O4QmC9xAIZKadSnGbvE0h/MJlIxyAkZ9EkEMsh6J2MkMbMq9WcAX6UzcWcQH9aAL/0wl/IY4LlesA/F8DDlZPcnm95jowBHHF3vkYGD8uvs6Z1qZW1L6QVUxP9DHP3gnsHiYbn9AOBSMO7euU/GsfCQ/2IiYp3yy6hVg4lbEUkYl0A7iEwAjxVf3lk2BABnhI2S2floflEJuaHdZnSPKafHYqsZMwCCcB/7LjhYVsLe6yUiOOOuy6cH5F/OU9ACuQn/e9wBAAx/aa2LJ1XoPSnTectncgyUbc2eeVmsrxX21OrXLtMARYCjpA7q+SEfU5be4+vh3EGoAhssrn2HySdVKtvD5gC3XBGMvzpXcN6v1rp/amyzxas1P1u93dpbzbPco+w/AIldpGaWSLG8gCRFQd1RKoT01kbKub1465PUs1iGUicAdYjRSX575qzlsVFHJAy1uf8Uq+e27JRHgcb4yHF09wCBHqh81GYe/DJX7PVgEBu8T8/rA+KaoZK9TLfF0wGcAC0jvxrbecaAGISyteJNTmfEEn551QJThoDQyDabb/cAIXmXf74BUvpDo4tEnh1jXPf2kXk0GPAelfd8STAYpwCbaO6rmGFZmCdpczoi76D0HE87q0q41BkbnsAI6xddAMouB6cYO7vq/KSB6zaDv1k2vviMDiv6iPfnmgJ9230AsnNRp1t63nsdi+ZACXtP7itS8Jv1xLFV3TZJQ/3QpACOyQwPwmak8XsJqtIKChd+DS6y5yBwDwLqF4suEIPtAP7zH/5gtbQv9MvB9nVuaudecXZiTFugrLYboIwPb5AALcJpYPu3gpuf4sXzcc9e1cX4mpRdywUi/lxWlvgXWQASxFM3AyVGHNbjt0fYh5xFPaek8wY5MBwylasK4PKmAHnTyflZKxWnLA/nrgHReFjmsrI7SwU2zsqGhC7PYn8AC9KBQ0vVdZEkwv6ObB0YrzCaAxngX9i7QQhaF2cxhgChJ/grOQM94X7/WdZ1LB3x13uk6Y144qhrAugHc0pEABIDld4OQ34KrSajMQTYTePq/Hl0NOMlf0oTRPMOCroAGRMcZWJj/AW1wip0qsLzt7GG6aUjXS0KrJ883mwfjwCoK/UB4I0HWre91Vt1yBe8g4sfTis/KLDndwDId0q2AKAiI8izz9xKlLoFdjGdfbsa4/8QtLoFVNl9O3AJRVkAyLcae8E6ASNO2lTbo5Z1uXC4iPEYT4Re61ItQb41VQDMNj75l5EjrJ+4+8NIOEpKxdG4i24oBj1OL9Dmp649AJoCIXaANndjm3GwvopKQAf6L5qhzWO0OJKP22jqlZoAWORQZ7dTKZ5HtlQjZ9DvK9BOkr3bOyT6KAyM6XVSRgC3rM3KGMfjOd9IhEkWfWfrkjwU8MsKWjTggzgfUt/iAP6ggTmQf/eXVQuEE6LQtSho3qLq4QXweN7UQY15PmoAK88QiSWbPBTfrQ6fsupQEWjYSMuqAlUsSqqqpPRTMgDE8PNy1NHkBmS0zQRDbRT9de/UsnaWh5V9BXddj1/lAJTHgSYb/gK6aikZM6Z7QjTUbo3vZOw6r6KOeeLWY6QAb0Kufpgi9wt7Pn3QBB8dwd2a8I+7ciEUkGDaX1Y5LwDroZ6bgw5yJDtRmKSpmgjx3BHWPjSySgezEXL43aqSAPEDsAplZ7/8i3k3bnwaqh+TSWYaoDI2fIiSJL6Eyr8AtESH0+RRYPwCkuKTOPbBsoe6+JefM0KvXAPpcHFWOwAV5P/zdgx29hk1BBh3GlQGVck2/B5991aUZJvYlkrDAHpy/Poe5IEpPg2cKryBNwywIsSJ09vxRd/Ac6ISG8UAE+9BmMf/qD80idWSpolkGNGEc4rawf7XZaqYxCN+nwCMUU6UWjjT/UVFMjTtCfvx3bu5RNLZqboBfQV5PSbNAMPfrsUt7iFaJCFxLRgCHgvvkV5l7fQxAt7jju3UXYcAMm9LL6rIdlHVpSHAAr3PGE67oBhJjrbgWxmys2/iQgAngYAnOG6zipV0hYNP8wWh/B6Ye+r5P1e5T6QZnsLDAK4nKf1brxVDOD+Hq5dVEQsn8IToSoPI2Wy7pqk4FQcAgiG8O7cQFkTTpLNKcM0kCXFDFCJHd5I2qRamf3BswQAPszOPdO3t8bNfL5H4UdQdfvkwZEHwjY5wLj71VXT5AKn7NZZWgxdnJ1dPssf6+bjoMw8mUAUCT+WH1aPC3YMAnLKrMaYOkE/Ew2FLtlS+4T/0635fJ8DFPJadpHe1uQBHDg9/X4/dB9iyQ6EgqMSsO2Oxfg40oN8+wysE2kI0AKIJ+eQ0wiXScyn5iUD4OFWp1CopyOaXDB10B8FHhfMAJcDN/vDPDpdQYZ9UhewYK30AQdNruUfeTykZLorbfgBGGjWH8wQsIc1ghqZ3HAM4H+7HVd3yMjzK0ySsAYOWAI5cYMoZsc0dpqCUAazFIVSx7uhKqvtu/kq3u4N3GzYAn18cJgANdXS5mXa4cp4JeyyaUontGCqvfbvvRLmW+AD6LdZ6WUDubaLegJmameGi1GGY7Ea096paR9sCATKBAK8imtbGg7uzdXT5Nt8fTJVjV62zAuh9OHZlF5MBS9wAk6WqLvmf/yJftZFCY5ElAKC8OHHBNfGAOpJTXHFnaAD1gY8JEBFfl//fY0Elddjvw6IVGZmvpiliUS9vSDMKAFgkq7csZ96SGjNWt6h9YXdR6n/2zbyq2z7mLx9UliYAjcFlBzIw5WhKlfm6o8Tlkc3A8XaWFMJmTus+84l7mAD04KhbmjhyQqTChswhe3OnZjIKI04OwgmDwdV+cNJEAFZkuGkVALtZ5pRLPCHfrscpmgHyWdqP1PI69xdNdpIAdEsviGAzyeF/uzXE1K1S43SfyzWykBKUlUC8Qg4ifgAIW5Vi/WOq1pE/k6Y9z7aqoLVRj/v6WRNlW5RlOumpAIPmZfnSygMhT+5wsDZruJCyxk+eEJO8wL+QATfNp98AFNlABIBvfAuXn0UpYXvpmL0I9jnFUkP3JAUBAyg/owBGpFdhW/gmpoF2CrRkH4+KmP0A4dmhP/+Dy1b4tXK1AGgXvs3EP8LxnbjwiHOP+1/Rhv/AagVdckzmC5KrL84ARogIW8wCsjlP+mCSOvrShTqwOA9E7sDYlApsvuidigCeHMgksTqVeuAy1LPJcg5ZNUs0iTgajCDv0ktR1LSsAAnSvX+nma237hkHD7k+19kl5F8aDjhJUZbb2Kew2RoAdXhs5SR8Nz7YBFdWyNNviimdFEmohUkhZaEpctPHXwBVl2ouGTa0m8tok+yxG4qPMQrhixRlURUOPszRGTprAG/wkyMGaCDY47GyohdfeTBNDe8MPit/3gG5Yn0rFgwAGXeYIXWGetJ/MRPisbZRZuUnhJGASnOz8gh9LiW8vwB144+ainRJyt7dJKljOeENNfEQGz3U1U0vnqm00QoyAI1JRo50UW4AGAQs3SkagHI0f689+fO4ysgr5yR07P4Ab/DAgNmnereP7HgbnMA9pSLQMB9s2ZaHEfQrgFRJlAC4x2JgXReNaZBED1IGGzle/G+MLLIZEh8koWvZ46AVAML87vQuVfCHFsvhu/b/UGTQFc81NoxTqv1z243cqzcArfozl7pwpwLmLlWNU2wSJ9GxEH/zD/Moqeb/FmZa9QCwcMeLQj/InYT13M6FAZOGuwTn06SGbHrsB2U1++1SAK2u/6eBpRWs5zeDcLLAzqMcEn7Op6RUvZyVydMpQA8AeYC63U12gszAcEjhJTeNgpBuSPDvHmIJ9fHHjgKlhwBlp64ku3x/Oi8tdkDwwc2FTHcWGZBo7z2TlDlOy0GqAL0r3eSvNCy6Gb30a/kSV3uelrJjAUIbaog1gch/ZA4AxacRLzQgH75kL4rxccnXdgzPw4dhgDDBT9NY0WPgiABG2/ovz9nP6sMIchs2cql4hIiaMrvbt+x/I/R9HXpFAA/ixtWLTnMbraNucjlTIoB8bH7MD+iDDw7M9vUjBmwA80vRQbayp8jOPzdqeHc+Z2fsGarucFzthAxUJKiy5gDjIk76Bdg1bjzZwx4tK+7c3VZxwIMUfFh8JxsdyPaXAFChWIIjIrlgT5DoZ2jvkM3mxEg5u/huhQjdNcTo1rsAgOTFghoqtZWc5ghfW2ZnTL00B3fKqovHincJp2KS/gDbaEPOOtEE7q2ZJ+9J22z6TDiVCfhL2OLi+CWDvYjzAIxqOXDj/I/mQKhEDgab65s3thd35HkWKM3LRCcgbHkAxgutF0HnLdq3164quUrRSyuHHJgkvwpud4vx+84qdwABbdO4xu02tuSVL0Xmn75/GNf75BARCTTUM47r4VajADElab68HG6wR39M79+HoCnHkz+KUX4NlEW+gnPM/N0ApC0q70aQnNia7UYzskdoeJzat9MuRl0hVL//7fggKgBDjDHXb6KJQqUoL+MDuApSPAmc9A6MJtri++hwg81TAAuKvZ4FGdV1eLXeWxATD0hxHORP/U/Su0OuVc5dpe4AbiltLZa4gEIlFkLwr6HCe1XpM1EolzYEqoZp2fzHAwCL6TMGMWoPS+HzL+MrYtYXRbuZjWgbPof2yonJjgEkAHOXwZ/bDxCMys0n5GLYOAtyjeRbTeJFssKlEtn25g4AHyXS8HcGxEfKpDiskcnzqjpUFkI7dMkF4G8RwmzhqAB7VXD1vvE6oxFhvnYWjQ8/l1RQ6KA87ob65Q8MeHobAFqsH6Iujntmpe0xE3RAL1ORny3kmrB7mCVQjv+2mbwAU01pYj/TLrb01ALgothRqVaFMdqX1JoKNe8cOJOtZQByMLGoav6Djt+d9pe7dR5yebcTEyhqb07ix/rfkA80ANjbxx7nftioEw/Je8c0PAaUQ/Zw5BijmAHkuJ7YHfkAHH2tTWh9eIPx+ZPb2wK7A0lBFHMlXHq7k78Cji625gA2KtLuAFK/p5Pa2nDPM8R0uQYbYQfFkWQwFZTTs3DgAOXH3bR/1b8DRQHmAFi9PzwDFdYFuH5TVuvPPsYTJrQAKWf/6Nt+yqw+lMF3nK68osySVE4HKMF24FDO9mCiCgAK6CHLRcfbUB6oUU0jVDuxJ+QS8IgdRrA7x55fb0IlAAKairdooTK8Qxzs30d1WUV/kUQa4HFpF/N2p6wNSnQAK4fdmv96w6yWM3g0qIxM32dXoVYGvhhQC/1FNcjnhwDF1116EVX3jqoBbHaX7/ux6vIB8xRGBI435XsGTbwrAAx2sJJMF0+dZgT2ztP2A/4W9ZHio6q5WWCMnaqL9JQAL3/wsBTgljB9Y/hIFEbpZwphSGDtOcoyKUtWhXEM6gAIQjRrpdzlfTNrKRgqyR4qicyz9iwi5Jr5+TPa3fwdAGEelby/Hz0utK9/LAxCW7aHWlKxGCdibvCLzrWfWzMAjaRcMyxOXp8gUO6+LNjGruHKmo+nS1iczr4bM9cOPQA4H5sl/HqJjaIyazWGQU2kWiasvLVVhGpqvOI/xVMlAMxUezkJsKsVFNfTWSRZ+MX9TcEJhHHTMiaxsooc5/0A/KLHK61dhAplbvQ7F0LtJLqgPtTI5RYGKo700alyNwDqEOE1B7cTd3i0MjvxnzHcL1JZsdAxmC5F5fCM/7G9AI5P+79/5lQt8GtFJo0QMq2kv4qaQGZkt9aOpTXXWVMAvjOyBiEltwK6UQOO8vKgDzLP4hlRtDEGmSfK5Kv8igAIVePGo6VLTivu5+gpUREguK9I/E+LUa2bBZwEiT85AAzz+6LcQT6TL0kgYvxIlbLYuUZyu3zvcudMOFRqFvgAywhGWdPSrIs6BhVR28yqwLJyimoIm2+ht/lDeBQO0QBo+nA/rmOJmogylc0GL3yCzfV44JwWQaIkFpMlY08QAAh0gQOFm2gwu7q0RQ/frFSJZTY1FYi8G1qloN4zBfoAGVELhS8dzlc0GP9N6ewMn7iSJPqmlwFJbdQaLhlYtAD+Q/z5F8X5Fs5Swz/vAfusJXPcJjUNhnTn/eqF3S07AHQKjf/U/9ygMnXoLjMUiKYGQvInyaLFr01K3n0OEQAAqfk/4QEb9kxUJfayo09Fit+/VAihGh/gsdjoLmEL5QDx9ANYYl1qsSmLQV0ByQu56Oyf3GmHqrkHcBPX0cTtAMcUE+P1sHTr0R4FIo81RZ8GmdqTcQuCSdFhunmLgnwAr20RBiL1dB8Y1ZFxicgr/GyA5y6RkJWny+gE2r6GnwDvIHIRRTGkHmHeyjUAoZLcJvoseDeDqFQ4mhBwUa4NAM+q2SX78JK8Bpsd40+fdXGv5HHqSPoS1/GEDFUdmwcAW0WGpiLEBVDIfq7oq3A073q+dp2nBLTjrWCYDCTbtACpk8vWAtcAnGVCa4AE5AJF6haFFISnd2KDa667Q+4gAK5wdKPlYYW1FL+Rsyk82pc3a+AKkx6GsukPI1QegHMAX369M8BM5Xa2IvnX4nwc8H8P7QNtmBzXlijxODrLogCkEf77ZRtI411gK1ZwFbiERfLacxA+Umgm2ZnfhXZAAL9EVvGa+gcZsrtzs9uKSD7oKIrPEEw8mklKFYCsAfQA5mN5XyZAON9EAF2hrKfyutoeqyzhtT1jdVnMhxuBQwBq6OArulr69QWiWoctXLhU41wlIg7/QtY/+qkbTvJjAHFnZ8LFBvkDtiC1X+L7/eqFocbQ3S5PxKLYha8IxNgA8bWF/pdrJAsY8XNEH8CqsPZTuqaFDeeVC13hVjZnUQCf3LF0Txa9QPBGkOHw+z8QA9Ii+WZg7BtC4pvY/m90AAL7y9v2YGRPcpsCBMhBZ/V7LJ8gNPEGfQdOOmSv4KkAIkPlvsAC6ahCN3sj0L4ofd/KeAqbgPtaoZtw4Wj48AC4fR87e2IWjZBsnZkCIoNYknk+D5hhn4bjNfX6FQZCACvsp9pL6WER3gRbCgp8vEv70KKc44V64uTE8WcGHQ8AUeKkYgbzwtzhsQPJ5yqFCPiRfdSIFK3dAYq7vwlBlgDGdplY23EiLDVsQ6FJAhYH9RF9D7fJsVFydUvT4+08", + "commitment": "0xad87bd0b911d6419a254449046e0507f2cabbeef574a95302dea08974cb3571eb6c67523ba993249b185f99a44cb8007", + "kzgProofContract": "0x99a74e1bc851c23941e854cd5791bd0ee67f1a71d603ae8d68c9bd54592f9ad5a80a53e8df74e690d4ec57e9230ab28e", + "kzgProofSidecar": "0xae9397b1f0798af0278e9e10d890ccfc582baaa0b6c217ccd3a49338dacb8da4d3f9ed5959045b841c3cc1fd911bef2b", + "expectedX": "0x8b73e4748e360348513a35874143b10badb8bcaddd02f56d7f33c21ddee0100e", + "expectedY": "0x4e62c69481ad944c44d84b38ed41cd8d6d6d273bde0c3afe26afadb2ef2937c9", + "snarkHash": "0x0b104c76db165c7bb304212fc9fc8a5f5c27eac37fd57648d3e78b51697d9a77", + "conflationOrder": { + "startingBlockNumber": 156, + "upperBoundaries": [ + 159, + 163, + 166, + 168, + 175 + ] + }, + "parentStateRootHash": "0xb1b5db9cb0b7f7bced42b581ab17add6aea116877c248c0d667b8b50b37c0fe8", + "finalStateRootHash": "0x5cefbda4945c119c2fcb81180a9aff47ae3e557d35f6fd5ed541f334e61d080f", + "parentDataHash": "0x012cab32c78df416fe59f8f123e2ded2466a64e201bacddc8396231f335d2088", + "expectedShnarf": "0x8bc7d2b86297249b4302cbf065c0bfb0a21a3937b49a42cd31b090c72dbdaea9", + "prevShnarf": "0x602c8eeedd7f6dbb7bc0348da1b0dced846acf09586c9f27aa06b494a1c49249" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-176-206.json b/contracts/scripts/testEIP4844/SixInOne/blocks-176-206.json index f292a3b08..ff48e34ed 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-176-206.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-176-206.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x017207990658280f269f538918209b2ab0f4e70c4b222aa8067ed327caf3c762","compressedData":"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","commitment":"0xb15b001dae0c8ef018dd82c15d2d5c9182fa3b1d570a9b9c7734444558c0cfb44dfac8d805368535d54ea1cf08f0eb24","kzgProofContract":"0x8295a7e9a3797e4171aba840741350fe1bbc458f95833cafe172f6e18741dbee3a1be8904619aadd63e0fb19d0ad1b24","kzgProofSidecar":"0x8a9f86ef4068206c14dbf3d6ad2653e9eb33a60eed14b89258554f9572fb7f10919c54a37b3a554ff5223368b8a0b565","expectedX":"0xf6283243948d168d9f4fb134e0be0a6ef566e9bfd2d49da75c2d52172debee22","expectedY":"0x0de40f96982e825966794375d4b57411b4b74a48a64a064a0ef24d85a25d809f","snarkHash":"0x04d8d33ab6b53c9a72cd0a1de471a4c745e1a1d395f448797b6012b0adc7b8dc","conflationOrder":{"startingBlockNumber":176,"upperBoundaries":[186,194,202,205,206]},"parentStateRootHash":"0x5cefbda4945c119c2fcb81180a9aff47ae3e557d35f6fd5ed541f334e61d080f","finalStateRootHash":"0x6bf9c7e48c802160ab3a01c2905b9fa4224fc69e9effce893c643b9d807f61b7","parentDataHash":"0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1","expectedShnarf":"0xa17470cd24e2c8fce4c2db16907ddd6f7b4a20967ba3ff6954fb217d7f1c991e","prevShnarf":"0x315452c8980e31730f580abe9ab2312f67193dc72d1cc00685da6a892373f6f2"} +{ + "eip4844Enabled": true, + "dataHash": "0x017207990658280f269f538918209b2ab0f4e70c4b222aa8067ed327caf3c762", + "compressedData": "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", + "commitment": "0xb15b001dae0c8ef018dd82c15d2d5c9182fa3b1d570a9b9c7734444558c0cfb44dfac8d805368535d54ea1cf08f0eb24", + "kzgProofContract": "0x8af7131b320b1c64608efb46ba9115aa03b5b8a31028311fe76b6c8f7ba9c257484dd2b152cad2154f250b92c305f5a1", + "kzgProofSidecar": "0x8a9f86ef4068206c14dbf3d6ad2653e9eb33a60eed14b89258554f9572fb7f10919c54a37b3a554ff5223368b8a0b565", + "expectedX": "0xeba2125f5ef7ae7ee362a836f73ebb8bacfc44fa38faba680204d466e117127b", + "expectedY": "0x3fa3dfdbff0e77bc3d75c00cb33d8eb0140a239d23b78b8ef646011a13ab2d2f", + "snarkHash": "0x06eb42f68ab8f484f974ee4ba1a8fcd97a0eb0a7b017451b8bb1d185f9b22c36", + "conflationOrder": { + "startingBlockNumber": 176, + "upperBoundaries": [ + 186, + 194, + 202, + 205, + 206 + ] + }, + "parentStateRootHash": "0x5cefbda4945c119c2fcb81180a9aff47ae3e557d35f6fd5ed541f334e61d080f", + "finalStateRootHash": "0x6bf9c7e48c802160ab3a01c2905b9fa4224fc69e9effce893c643b9d807f61b7", + "parentDataHash": "0x0159ba31314753be910d2abb9b7aeeafbefd58cc4163e8d3cc6695315960c7c1", + "expectedShnarf": "0x96ed18f2706ace8f30f5535d286087d34d1cc04a1e03b4100e24c209de5dcd6f", + "prevShnarf": "0x8bc7d2b86297249b4302cbf065c0bfb0a21a3937b49a42cd31b090c72dbdaea9" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-47-81.json b/contracts/scripts/testEIP4844/SixInOne/blocks-47-81.json index 7ad9b7bd8..28f634f92 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-47-81.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-47-81.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618","compressedData":"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","commitment":"0x8d0cda5702ff5fe346575acd5c1f0c13f556f573a99802b7e47fe765f55de623fa0adb8a88bd4b409a2f22c2540bda07","kzgProofContract":"0xad6ef888e03efe929a054906a821bef45ef8f64b3a66b0f6f681eab03ec697936d2e1e56acb835332bfcfbcc386b9eb7","kzgProofSidecar":"0xb17c0a962bd0ac8180213b70285a1a8696b5f48869053018c052d637043bd9eb84bc212e14010922bc5c53d85d51c62b","expectedX":"0x0694b963320f0829c697ff2b06ffceea00b9461aae8e00196f630f555f4c2522","expectedY":"0x6a77822545834aacd7f41f8081e6ec5643322461b089db0d21147ab28e9de6e9","snarkHash":"0x04a1efda07e595eb193d2d999751e3451e56c55f70e9d3e3f244146cb94d7cdf","conflationOrder":{"startingBlockNumber":47,"upperBoundaries":[51,58,66,71,81]},"parentStateRootHash":"0xea09456033a79b5f8b369a95cce74d3dbe34fdd6415bff1a417ff8a8fa0cffd3","finalStateRootHash":"0xf0f26782f7afb93f926cacb145f55530714f20b1356725e3971dc99e0ef8b591","parentDataHash":"0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95","expectedShnarf":"0xc9b52248ba020e4f29587e15f18f1ef132656ab90d040c47ae93d82c65e6d022","prevShnarf":"0x3c5b711ffc8d48fd2db968d678f48c3892bb0bd8fb0ad74e14c98a119688a18d"} +{ + "eip4844Enabled": true, + "dataHash": "0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618", + "compressedData": "AM0VOdCPfAugatg2smkO71Cv2GYJoGclF+wO+MH5R5YAQMX4TQfo46YvsNSNQYaCFUsK4MChL6jbEYfIIBADzgCSsvCrW8WQPFv5Mia0gPDHnt59Dq5SQ3hl968JSMNlAHzHUJeMh4qtUr1Yzwd3Ffi+BhitfAPiTbtRPmcraRYAi7KuEUoqejvANiiLeBaUj66SEQ+gL0379Gqi0Q7MxQBK+nKIDhYAA9QY8YDxcLH0GCa9Nv2cL72Iq/2HBotJACfcdqHVvS3iL8Jk2ll0SjLT5kVFpYHNLnFLZLWMq5IAtkl7tAjMN29X9N0SrWTotzhudUVj6PWeNjvPgKTfdQCJVoJSmDxzK4VHCXB6RWgtWy+uWIeOWkXYjMutPRiMAIeOPP3wm7rOQVQt0Gi0c7AJonUJ8jB1mmmymaHWYDgAxNLFf/CiSmTM/OnvQvmVCv0BGM9YeQEow2MVtIW1HwB947KL7OFNzWqvhBdw3o5ETdc9Nl9AZSej5CghtYPgANYXI0hmghFKkDm/HpMP547MDnKgMOTbxRbAcHOsXxUA8I3Xm8JL9iX0dw9Zk/v8fzPpapzn/v2FRXi2rOinSADqH5kYxBRUJxFLZt45+wneUnl8VMXdfijZ4nNvJDbXAB+gE5vCxqg+UST9tCFe/M+ysWU9+f6rmikZxJULyxIAnpuoLsDckLad8PJ3pRbDLEEjqmAniYo+k4lVyQFLwQCQxc5EW4EVA8+A/fK08LGDMFFQCLXisGevK0ZOPHGkAPcwbmWX/k6/3SSdUAXngLCum1P3SYw7EC5h3P6hakoAqI11IhMnWJXcfTnwn4CzrypYG/FSK58cZsFxCowsMwAVP5Eii0uImYtc3YesC4DNRnie3EyIZRG1En/OVK4oAEtMbWFZskTgQdk9O5irGEJ31qYG/1CEAIILpVIy1zYAU5WpCeyfjsyDmUfKDfsP9PC47r7YVnkcozp8sb0bQgCiBs+tU/c8/W1vGAeQ0WZnQpLhmsT482F3qIv2f+zFAHXo0/TgSc407WGjKwq0FXWhx5QVKOq9aabVKdj649AAwZw3CVBHRKLjxHWSv8cyr/mQUih+EQf+5GPHR9fKdgBYtwIwL/ieLAoLXsmJAFEuU0UOgzzeLE4F1y0a5LujAMb9yOFSAywnl9tq9HkGXnEEQP9W86wPfbBm5UAsh5sAIs03pFeebev9Ki09qD3uAJ6J3Bx1L2dodM2E+AqlkQCHkwm/pYY0XSMhHYowxlT8uIxhQg4gFvaiDyDYH+UzAN9DDJoqhN7NhK6AnNLJ5Na6STym0ed6i3Iv1wOt5YAAGg208WHs86dcnQgvNyMVKWNmrYHxKVNXjK9iZg6stwCipRnCfZBRoO8BJkY1bTku+tb17I4nPZwuC0i/o4uVAACjDIeS6Poz1wK37A1hJQ4VARpllXQn8jE6l4j2L7cAhX7dRRC9WhdZWftRgJcSs4p6jlCqcHajYcoSzZkSFgCuDRAnlCOR0XHT7TDigds+XfbwmWuNCkkKMp602/8dAMj1k7mca8jlrSfCU+dvgjatGNAeFNtWZyRW51I1/WUAuMEonMNsgxkc5izwrQ3uJWawyhM8wFypAPM/TUAR1wC8BRPThzQxLe+HGv1TmlSMKF1KhC7nSbY4o163+QbPACVdgSIvS6bOh6ebJWAGNSf0QfndEm7ZUKVLb+yfLHoAoAYbi31olHFKycL496dDbuDb36UbiNPR9evLqBEjBwBWqm+ASOzPKEXhbhMeVIYfXtWOKOIDnM1EWPWIaiL/ALX9Jbzdc4Itj/PHwxebxtqjiMmV7dwk3ozxISQQdJYA+3wdaJEP7v0H8HlE6PGFTh8UmIxZK8WQ4IGEfnbO+wCwA2nSjWfEyBXdO1LmqS50Fq0/LfZKAELA+mkNexolAHL3WUdbIDs64zbjPmO4/UcEzRMzxYKixZ+rPyhkUqkAIbcMpNdotPr2uj0YPmwsqkS/KQOzcbCPTNcE/KgSfAAjcdhHTHkajmGDQlkxWVPl+7UN8NLRsAEvyLKzYw1mACNLdZkZpSlD7kQfU3J/e43XVQO0PfvOX/LG233o/z4AktCoXblgJdYNywT0Xyv4VyfuaYziorWJW9S2eMF3GADq/gCTbNg04W/qsoLLCSDx44XN6W+EpcR6gSNx6/xfAD4fd7kSQw6SNYsqtzis0y/6Zw5EDpTJC+q6IFDWj0wAMfG9T8a7SeJ6qGiGS3XJ03nR4bvS68oYWs3F+nRrPABJ6DGup18V88juB6qKQAmF3rcYaxAJI82roIq0kHmDAJGC5arhzdAj2zIhAiPyDY8X8dwR0F4NM4b7CYWdIZYA/7/w3zxgPRCWY5THmANzctPd2m/oKHBhijVdhdh8/wDtdkmaqbUvZWMyD3Puqm3OFubVZ7tq5p4+fizzjaCJAJqeA2+06L1vNpF5QANgI+vf2/SWhXPVeEBofJxokowAp62M1TWJ8Xt2XsxqUJgSzZckYHPlbXmenRZo2YQNbAD1SGJsLVQnVSWe9X9CKKvFcWO3qVb7/WJtdgRBf3D0ABA4P3IYbFrzgag0s+5fmRYi2CtQ505YrsuGFE3WD4kATEM0uhpYde0UYcjp+bd+NArmCkUYZAe6LSw5Qm4LOgAe1P+YxEUwsPvlgROqX4t4Re1i2cnDWjHvodhWKxLsADY1N/Nx3Ufo9EFpRXNhbW+h3JFwH4ryNVyAlL49+rkAz0bohg3+eBuNxvSRkU3FurOo1NS2RdFDE/Wh/t4MXACInm/9jyFt6Xwsq9R/XkIctUeFgrCyP1OrABUzcxpiANwfSf4qA6wN7SGCR5eta9gThIERAumZ3Qu/kKkcUdUAFMCN9IUfo5LhgJop/uH67w6jzSJ2+rEhZShvgRBYDQAJCRTK5Igiv3ArUuYqKelJCsSQyI6G2kbNAfihKglDADE9WMCExmJKCS2bpRamalbpsrpfXlU7bKyEoLsX5fkARLoAvui5G/biiZlG8aBVWNnltxbVqkdchGcxYbrPAQDpJL1oAZKVBGNbSDUbgM9l5XET/UVfvrDqAEzd8/X0AKqFllqRAxnu60eTo3HIEAhv69JkcxmnMrQBsrIXWzMAFvRQPgz53jnTTU2iZDuMIe3MAuSBpGIUeIr9KeG/CwBJjJ/Bl0Pgk2m4PWTL9TS9T1Ot5tSybNpyUrx4ApE+ALSbTaB0va7eZlVquIEeF1sfglQ0xMS6gEiU4QYTAg0AnpJnlMCnLAmbf1GkJC2e3IG78/itdA6ARPCe2BakGgD1/N03DosOfdR9U+bQ8EqIat1VWT1PaiRbEefOyfHyACrIgewpA11stW5ozbXTIWi/LwT2xxBn1bwW3/x/XP4A6Z+zq7WFGqmlDFXSjhP1ftM0A6AafsZIqghRZGDKUQDPM3TMMzabI9Ex0oGtrccoFT8ve5YHjb1MOJQyd+XzAC1Z5L7qjnqzs4ZtfoVu08HNlrtTfXK5/RnAGRT9ZNsATp6B6VD18/CwLhDaEvxvHHrNx9Wj+3D2DMUwuAG6ngAWIRuRHZOvNFyY1O1nMC/R2W2Owau6ATzevmvq7JWeALYr3MVmRKXFotYyPk0fF1rqRyGYXj9UtRd88Vna2KQAwjWC10Lc2ju0CiGuq8Mc1b4UqSFUsyD0zB3W9cVfAAD0zhKLQxM2dMT0JBTfVUL3gPQ6yrYzR5A1sV99A2UIABAuXyfWqzZMzZrYN9JA5aMhQel469R90wWUUs79O3wAgUdmhpNo5kXGudKPJr1vgJ6s/YA95oEV43myNMYwPQBNydpw9R70h1b3G8bH8y9zKRLEJ2DovW8uvSBrUBx1AHRPBZi/6/xdXShh8y04xz/ffQQVrqtdDreYp5dmRBIATECU8KhZuBQSmfHCpj0mdsU0DN+XkB/mAYKj7UVc6gB/B4gIQz52VDywL+ALFx0Z+dXyticUb/LQqcjyxduWAIMPuGSjrdeDTm7EEx+6Wsq1vI1qS1gELRbpy7TQJuIA63sl6DbU9NNIK6uZ7pXckZUzbMVaVMg4SKMmfvEeEgCBTbktYGNodssywPtzGtoNAoZPyoJYErNJ4Cqt3h36AP8BQrK94f65qsoeiLA6zRM5ZsFM+PxsFKnNpfAFN9gAJLSrPFLcQFL/qcH55tvFZTNebB0X58GesEj5nF/pfQBMq0W/ZhylttjUX03UkchE+iO+pwctzmDapg3VPi2YAIajXjnRBGe6eyQSmexxGpN3c9YRgX54jY9cvJ0HHqEAgMpgXlxVo05SFXEiXfEg58nrmnMgNWaD3NskDSrzYQB5Ycj6/sBdPWJ4002sY4GlL/rjQxpT+SFCjxlG6B0NAEi4OZgsi1xVbEgBN7AFTayN+zt9+xFH9o6TrcujRv4AKML8+4FzQLF5uXa2Fj3e+Y0gx89vwlGRgx2HY2sCfACCyHxkZ3kXcKh/sOqVdgU42aMEpiHF7OXO/9wtZzveAJEbpG7nAhVe3V+ZMbJWyJdjTUIUKIr+P94wV5OTxW4AQjfJBOGOboaDvEuDjEJLPheIJiySbhioBkDt6lqOMgAjjySRPPsUoCPAvtFN+XHFpgynzOuCfJfVDbOgVRGTAP4JyfgkKTMohTyfyCppeVyNw63lkJXAe49Zh3dL6Y8AkPvntscMyglBs2QiQJvfpDJL/tZb1itzzDF+W82qPgD9KQYg/stilmyVNzjcHCIgMqADGjugaZB3vvf4dMRfAD/UqYCV0BI9o/8GOvgMhnB15/yiJ13hZjKALN/K4c0AVl4v+D1ufscEFF2EsBwdOi9018L1Ycbl9Q82epOZqgB/UATQc5wseXeAdXbAa3p299ewBFSGhMeIPSRf5zPyAPff3e+0cRtto7iyFWxBgR33Nspyti4mkR5+WGkg4Q4AzAItgYQuYKyMSLXsbyYW2CcXzDUCFyHklUZhAFUoRwC2y0ta/FoX7fY3RigD5ZZciGOFwIBno4Kb9NcaK28FAFM6WMrvp38aUG483Bfli3C4c5Jo5bTKAwas37C/5igAyBO+mM1u/7DovIj2dE6TDljGR7Tqv9nhb+v3hwCN7gBG2cIIfkGwNmG7zDhTCL1btzO46gZuizHtJT2J2g/CAF/KcKXNsWsa2E0G8c92aURnKbdDjq870ki585RLT5oA8+UMfOqkHNrXmMa8ucggwTlpsy/2w8JAhur4SN8X6QCz+WaO+sC+wlE0cB/YjwG7pin6BEBvAPohedX1HPdCANhGbUL/Afbcsi/EcfXZwqd4awoaKdIOBymh1W2T9qsAxbBSGEEcut19j2CKqOPgEC1nIm+b8ya0rKiWMzAiowD+HyiWtWk/bF8SADQC82bKF7jANDYe9lGU+v3oSRIfALW8HbdH2+btanNEmsOdE8QUWwUEotFz6pRTeTTrNAoAsvzvFYNvOPcenitrSv1M86G/cOUvhKm0hSx8r9OpqACItR0pPJsSLBv2DJIsYFrbPPGBYJ6FM8M3Y8DigTtuAJcNkIySYKFAZLqfkUTdb3Vy/cSouflw8rRdmDCXSmQANY0iohCAZ65goxv0VY/gFZIOPP3W6+IuLwzqkRrtwgCktY57hAw+2gj3xcK9fT0nMVirb+cXV9jx6YzxNsCJANPJPQeV+FWsqQZiSlsCMs9CMavAVUAU6YseVEXJbrUA7bd6m+31L9wdsrzorQJ8naHpONmBBavfnt+GkJHnewBfbBSgg3ZD0mj48LRzDgoaLs7/yrFOWIIu4FJlaQmkAJHFsbREy9sPSvMSQdNo04sMR/3CC1W3BFHjWxE/uZAALKRhffylU5azsv/FIYuDJj5aKlULRbkLZmnqvJxYpwC5Ex34e8Oe/mwE605eClSoDNs5bMMBHfB9zOaci2uCAHE85qZUE9hwJB0chUdkcuzTZ6h94wTnMuXahysn8GYA7oSU8+1O8x1n1oZgw2vKdzbCr8R/3vlh9SoWr+qj7wChKXaLwHSN/fZn6QtM8KVC18ptRmaYaKPwbRRt4RLwALLyxY7eTQc2wxaDK8tAjHMF8qDIEhk42m4JeI3y44wA/VEuQMzY0O190XcYBWMngl+aaptbdRFPM99j4xKg1wD8oOpRIHLKbniLw8OJWrXf5i5OAkoj7NWAWakZz5GnAKOd7dE2hzh5jG5vnHWz9XyjlD4D+lkXoyRZ72UkQb4AVLHnauKv5KWjdTDGU1DYqOPstTbSrL0JKwMZGq/4vwAaGYvurtXyfXRtsyHQLo8zNqX1uRHxk1j5SUdvxPpgAMLpgjgfHp8rHzzyZyhDsYS8K7Fwq6CiWLiFJqcDqQwA+CO0I3KR3pp7sDKjI3sUjhTcTYrGSMRg7HgMnk20ZACtuba6atWJ7D4FSwpJ5fi4+7P0peV2TDVKlV2OMFjfACswdCsrfDCQATVm/rMS8GcAV8Oskk688OmLIRe+TxMAWM/nQ44rXUblunrrh2lyPZLRTiJbjE3KtjCWuGCJewBFDF5FB72ZrIUdD0MFwR1wxi60N+UikbZ2zaM00GLPAAdQb/xBB9Y1itPi6TRRtXv6gMdP9TZCExxxNKQ1ToUAC+1yLNF0Pa5145sBWseJzKOoiZZxRNm3Eg3CCW1UFgD/Q5W75OcIEnpAg3EX6wnC/M3nWs+3ZkFg5LiMj1GxAMeM98hBXeWfzQPf2ZcxDZ0vHZiRLViq6q8gJSbRIZwA3a5bigfQGUjTDeWr/OmIbrKfconBd88dugZcniX1/QB3QxJJJIgMLdO3N1pVTHLhpPE4BnVvhP3UtvDTNJayAFEcpEo7pJPIoSlXjwG0a7yqwXQ1OIW8I50nXCQ39lEAPAj9x+Wa7SddnrMfjFkw7FjVcw80jmwUDevHNmW12wBj0XjZoCnjHfuBzfZvblGp940TbBYYcdoDwSs2SgLcAKUkWM2PfXLi9/QJXVRVFqSJUNvDHh5+XPTbP44NajUAh/tkl9mww3L3gRmraCN5/qj5kkIGKT8D5JZxG2t5XAAmDYiepTxb7sxnDM9G3g4iV2ndyaHs8kg/RhQBxJLuAACJM9ic/QSdezzqHXeNZxvNhZ7bhBIY2L3Jp+0VAW8A8CKGQy9ZnzyWOy2s060cLjIfJfIWKTLaYKoPGUElXQDXFypJS/Jcub8xR3rTJghMsBRraN4sVxTMdwY1UMdLAA4RnBiaW95oAgvcgS4sCZqikanpnWtDrgawq1vGZnUAmRFKAu/GFLWBq+8r9T9OIpmisbT9c+Fjrr7hJmglAwCuUx4JDNAtIMZpygW0pVDUZ/jrtBGgGxY+ZYaoo5pxACz2wRIK2grJcyUAcuEPTXw2ZYIpmcZjJa5UVb+QrRIA4uQrS0J9QGSbywPvP9lTz2DbxQKGSnD5q6TWjieq4QDyvz+DZHIdO0aR4DMsn09cDxpLs9sDRv4wNJoj8mNZAOH39tpUn3F9VihIRVcIlbpLncEVanl/y2PifqrqPR8AdkTgN+otc+7xb77LrA7BuiTu8XZMV+BMR0fWGcOo/AA1TRh9KX9ODrGk1Bj0/K1ghbicr+17CU8pCc5YegyCADdSuVM3chrn56gVJOLATgbun6op9KP27XEwkCe2WtEA9mstWI32xlUOTIH+8p5jErGXM0C1Ujzwz+S/iuWHnwC2w/OQIPvH4938qTBxPqOdtYlg3wtrztu0lBam+beTANtndBLQmp26DrP5m58NpPm6Il3+Av7eWfEvx18+Nn8A3LQA2RuTQLX2ioX5dwA8VUnrD7uV0cXx4Pleox54IgAKfurcg2DmnoEh86n74pzXAjHK0m8E2/AkWEAAlWK1ABAzXKhcjrGYXO6f9rt+i85lUO+2Z5fAJaqRN7jVzCAAIZYV05oZvQCXHNepNzVIdrSA7VByeTtL1FmHc7kFKAD0etxqebI/4Is6BhjayDxfE1i2Dw2TC/KWZ595iY5NAGYNicpHngQe4OO7ujyE87cgJNV16ZoyNlqBmGgaGsUAwQaea/9v5a9OiNYMlnkTk18Cq90uRi4eTh3pLHtPjAAGo/XAJ/Per2NUPnn1G+ynxEoY38BGM5apfQPc+kr1AB8DxFNQXSDgy9uOj2AsXZv81q7DPfLzvqK8QBTvG5cAE1GFz8/jdbX5G9nLgmiiBIUq+paJK9Aw9DUpEeJzYwByPCGK542/QyVDlEeLPEZriCoHn5kOWT83MlD3ZIMAAFuH6FCCdPft9hwkDepq5ImBwbvNrzRP4pWL0yxnSEgApT6R4bVq/ToAW7GtVZIu941RF6Y0Ul3ol2DjtzBeKgDlBRY8+APRrAIKsbyTcOY1moCRoksSA8y10IhDZKBVAKMOJlV8feuXv0Kwbi6ByKsUS7MXELw3GHOYsjOZxXMAmvQHi9D2h6vJyzGdtdiVWJ9GPTAX5Uhzmew+ZEqs/AAfeBVTnOX10ZXtFJjW0zVOEPqRLWphwc0Rb0XEEGeSAAaZsfI48koWhF3FaIeX5SQuMys8I9rtUN1wEzdNHiEA43OCRbNhJaGaw0gB8PtKjwgibntNC1p2UIpLTmgTHQD6yozmGaQk0rp86TO73p2ij3mVUJQAf78Uz5fyF+y+ANXzVh0nt5zuO6uMo+HGYElQRY/qhLd0QAdgfSSZVbQAG4FFoAg+KMrwU04W1W+kbksQaLNb74v1jC8MITCzJwCBpk0joaaAPIcn6AE5wYDItS2BAPNhwKV21/Xz7zkLAHPS973oEP1y+SN1DVddAuIJ2mZwHrK6SZuS8HgKdakAYxwO5/NJcfT0JCKkETEj0jXNG2Gr1xVOLqHi/xP/dgCmhm8d0fNuwsbihhTVFfxbXr/5wSRB4c1MzMS+3zZvAM9bIGWnfHrx6ADDWId3CyVgmPm/IQ8AN3hov78xU1gAj5n4jTOWrCs3bQwbfYglp/lUMi+6d+m6rVVN0WlKlAAO5omaiR3mmZB1Ydlv+qlYFaJ+zzD2FkWAaSgJtD4bALI6fAf5wFhL3y2K6Kf5P1SwfCilHt1SSyASCxAYh0kAJy9a8DYoEbQ5DlJfghXbHQZTzz+G+/BDaEflumhOMgDGtE9ak6yDu62HbOjCqzQ9Fk48IccvoVmePjC20wlsAPazGwfTYinBqdyOJLLYGqkugdzJgPxy/3WghbUyKD0Alk+Ix0UPO3dqVywtmFYqzArbyYZoE7/aY+NZZtFZBwAxNKAnxRy+bOphKJeNCT3R2sVRwAmzoWY9Dupc7gIzADg7cWwfdc1e7nH/uxlWpbFcA+U8DIlje+URtuOVgIwA04eCLyjVjcn5XNHiDy5dDrxzGhZP2PUb19R+pl9PCQDz62R2+h2lwcb3Gh6R2LD0qr3xCox4eFF6mBlOL9bbAJ0bhCbIShLtuPUpck9zV+S3kdWWc1XjRPQN9kTCw9MA6oC6ZJECLT15lVAdB1joir7NyreD2AvgPfogB692hgDHk7BB/ndmZw6yGBSZrsCF1g6w/Dai0eIdppZq7mcBAHxgVHAb3pe5wwTW4kXeRLJLbksu1YV0/PzY5t5Ig14A33bTyRanNnA5ccAKPu2uQaQotBIRw+A4WNTeOS0ERwB8Hmg4obRffd+i/q3LitleLBaDZ4A0i+prs98kBkjbAJAmzqZtczLqnpexd8k/7Cy8eJfe8zRYh4cJU+e9QuoAv3samMA76Izp2q6jk30yZdclAg3aLaW5qxXFcNqTjQAEkKV+wPbhjKYAnErysWiUsE7YdkU8NSATHWZTiD7MAIGntO4nfbR8n6tv7TXGBhlj9DvxE1Qnk1xJBDF50pYAZZr2E8j+XGa26hq/wNlgG9OK9A0VCSeHEUO9twyA/AC8ya51nzewLV4eE369Mv3/AzfxnDfRvanhDr5PmXHlANzYRkFdIQ7/qXxNV21rUny1L2adglHYep6y7qC2EWkAhn4TUnJAQXtuPXZcXPF3IzJm6+NH6SmTwL9NxdB5kADfMkmdwaxNMAEVn3V3ZjOXt3b+FnGDZkPdbzwdmnA+AGWqvSpWQR7MQvEPTr2ZHl0EwTkEhActgxAp8CPFn3kAxSoUrUVxwHGaf3GI1Ntejj1krXB0oCs05kA/JnvQgQBVTtJqs8SdY7Iq0LRLeBF7mlF2AW/tFrOrOxyz1oFgABi+o5Kr5Hzz14PN+EkYs14VXyeTiDhf1LK+czFlrlcAql5ejNAVaXkvl433ZmR6ziSeuzwbM9skUDbH6f+ocgCDLO28wS/gAMd3ZzKXYErMPB3m5qLugA5ql6H0K9m1AFMdXF7e8fIs6AMLqcrK3G3HnGzx1tQSb/n+4uSLZd4Asgo2F8lmvsJHnX5Dt1aGoXXu/KXvbWCawXrYaxauqwArNF1fBd1y4tX8HW7bNsdQywwyE76Ckk8XWtJirq9kAIQMjPO2Z+qHcCFXa7H7xRMir3bNxJVQgaBUp0OaUtEAWXqoPm9AgzrxYjhvHGOotb+58+Xk8orB1zLJqKp9TgACCyw3Tex7MJLlg+RVAVRdTZWJvwjhGRFRCBpMbni6AF0yO7L6syObmsxNmp+GvN5IIaY+eawhtCmVS91fmSEA9XnFSI5/1OAfohT4uORMdK4HqtO4rDkVAMHDVHRj3gAAy8GqCFzO2iJA9ox8Na3KYZkiXEtKvGZveh+ctxw7AMiFx6ZUYICTMzcmw7J0JkY/2wjHNsKNGIzYCSiuZV0ANik6v0S66RCbsgoclLXlvjkvvcEjI+GbGOqdpSaNsgD0fAMUM7u5GzlfZeHCQ/8QE8DiXAsBXklxLypFfXUuAFOFyLajN5I+HXMBaB5WUCG9wFKk0SKIZ/rwqyYQy+wAdYn7W4P+bfeVfs/rleuX0jIscSTzdSyA1wkiBYC7UQDkiFVaLKD+ukHLC/5B+Y94EQ8tXek0kozU2U7jC+ZYAAQCo56goDsVBlpBCsF3h3OS1Kxuu4/y3Vfg0T04h60AqOTMeUqLMmLutZsh/3FFqPNnBSAakNzLPNsD7/027gDLkic3Xt4x8Qq/lIzQXME4I/Jsp5rCs6lEsBJgiACAAMkkeofL5xeV/UL04w4kb9PBpzFLB2slAhQ4AtEYbXwAsbN0NJYNLRzmgtZSD/xHxHTgoeFHCM8EhD/iCbqnQQBzB9LmSeif3Gw3EAXmrkO9gx0flJuSjn4A39JE4NiJANenme5YjamqIMzbBRgTxjojtYdZODYcijfcrZjKuioAk7LQdAHpS7qF2rAgmEXu/SHBfsjjvt7l+YKww0iRvADVSKVUtdZXlkMTDi9fl5FZBiQA2sslDzYQnHN3jIF/AP59BB0gwF9HAZjIySGhYfJq4mKXZuB87WfhsDBRBu0A0cuqc3t+1GecXZJWmGuOQopuHmhEQMJbZV3VS49ctwC+pMaR/qle2lybq10aY9P3q2OeZccA50upf9G7HP5nANMrUXgsfzNqsieOIdqxhdDq7Z+EuMEyM5GKU+VK8PYAfVYOkMn4D83gPna3OvUPZVqetMVb0ySfC7U+65riPwALFYxvwMvjmMi8KVtLIoo5dY5ynvu3aFmJNRsWuNQOACz37JJInl4EJTWAWEkWTT0CiNz+I9WtqeTLLB3PZccAf3Z8npoigXg/o6cuedNIT3rKlfB5WZAtiD7fJ6BxCgCl075JDPio4MVy43b0IDiYnyXh6bhWyeW8vDBJ7uk1ANqFjJvkZpnUw7OU7kLZl95DdiNGlR4Dh3Y6uQueGcUAje9DG4L1DJdOz3gJ3NHzm73Ib0nn+VC+n51581yKRQBPpmgFIUI0AkixWnNO/dtOXR07UuZFHRDibQ0Kx+3QAN93R90ZLwwR48trWoutntHnNj0/mlsKe3gmzRWmxFAA1l1RfsrSwbHwvaqN2+917nei/061Le+xsLkn4oiHcQCdvpPBngREg2bV90GvSv43okRRSPCK0F3Wnj9TOcHCAHOe3wKVJxNHxQs8aQ/1NYhl744JM5iOSqJ8ThQ7TFsAwW9Z+b8Qzm9Sh+M0SLeA4FLZjNUdiorUAqlkspvY+ABMk8TLUeQA65zE2IQsmCvhBoPj+gVPn+FHAirSmAGPAPEU6JDojZdEJ0fiyStac0kOMXOmEY9Mv+n++YrSYewAAcI/pOtiVJSQtGnUb3OGFMXIxU4bBdWPf8AHifftqADp42hFdmHInlMVOM9W5na5fZVVnAA8ewy6E7PLuDmnAEQ3ldiC8e3Z6F0NqGw9qhjAybRhdrrQjlIi6C84KpQAEDl2dmdntoyh/I2hfZrw7Sjh4Q44wwKJHbFrMyOzAACuES6Os8JbOht8H8/SpmTs1HhgSkg5v5cBtDG9OJlkAL3pLbk3HgRttji/+672SsKKZBUyXybQFoK+oL/HncMAiujCn7L4TOAnJCutmlTfuy1t1zGmzShYl4sk+8G3/QBm5oui3vnpi6WjPKpafyCxLHhW9Q8KDtr1vYRvajKHAKkgD6TFp8gnEQuOu1dN6iKwwlen5Z2YOJdkbhaLfB8ABhiGs4B5150ilqW8HmEYfePq7Cydx98xsYWlvnQzywA8/BMrhr/w52JW7OSSmtFJg0kIYqejaUB6IfzOGr/1AA8L0IqQjctVajGSl3NDm4ED9OTw1cNQocu50Z0+UO8AYmh93jiz41MIN8FPZEpSZJ0zArtej1uLpllmGFx2FACdxzZlI3qeE1Af+wEwHdzqPgBJSJ3LeHVayZ8zgyIwAHGaYFbn+TwjgX78ZQIBwKUHs3d5rxu2mI1eFQTtBXcANAk0UILxW4y5iMG5DmA3aA6Es6eWiE3yqd3fR3MPWgC0/W3EDB55WUsYBsjgljeccQKfO/L2SLCbM3YIOz4fAL3K2hFFsJTP6BwGQj3xm1ASr1ySmi7x/SBEKGV/WB0ABoFOk9i0zX6InzeZVv4FBSnfG8EJcrKgPfZwT99hqQCxnhnLYryQGS7LtW83kMP4vYAhkNbM44f8OkfVcPZXAEEd1XsAerlyg97Fr0piIbxq5agg+3REy07UNDFTjRQAK6yUHNWJxQw2KktnHCSHO1h3/f883rcUtg4ceTe+rQBJH7BY8JM2oWTqms7jn1vBAcXwRAfitj49LXI6N4gNAAeUK4C66H2YfbVYxF/8t2+TfBH6vBPOTu2mQIRaKYAAH2sgASqkfEPC9XB6wqOOf4wnN/MNyQEf2jfv6JO4BwAu6Pw6AVnZIlRHSj3ACL5Px2bjjTb+i8Vq/fNs3akSAEXXZ4eNGkPtO45/03F7lJUnMzF8vteEuD1xEf4NIIMAmfLEqdnHf4g1q2HNTNU/D9gP1ba0aH/FoPl/YBNHEgC0cy1EQvKvdtKT9D5BE5utH/opPQATL/OafnqXx7I5AFbfZMeGwV9gXggtMgKU0sjMX7smceYjCXvXw/cQPpIAOd6ej4c339YlLEdQdC5+tmMTNUcakFVjijEPLHkaTgCAAojH8gd5TWR2SPnvJ16ayi/daol39iZ5rRyLfb91APjCK7QhglYvrK+fhWFi4jLR9pV4h0IiXszdrKYzj/AATvcPn2gBJ381a3AJR0Rj/ACugDXvwxvsHknNc7HLCgC/K6mnBflta2ghKIcTJiOA++a5D3Q5yfHNbgKoUpFHACKAHhU8SZz9BkWjvXoylR8qmTi45gUQ/zPbQR/XdLoAoLY2yraESGiYwgUdfriftnU8i1IQXA059ZPt51OfTADnXo28u9k2l7B+lkZwvMQu/SBiyQQFnmMAoJFNTtGdAHs/WVaMu1YPXUukUBXd0GpyVxbOliXdiEbwd8U8nBcAunz8JtVOKn9ce5+SgRzY7UFTgIilqwptZ7ilOqYnegDIB0s4YxTCqCiFBMa8mGHgzGettZJhqmF4d1lBSkbVANvtDLbo7C6xTevBbX8W/MAg6GKh/VHO0ZwF+2PPVtwASolzvHh4rW74nykADnKPtD9r12KJHj8HHWzQj4oURQDWq7jLECmK2lostt6mG54GaGgcALaYiv0IN35CuytuANSQK4tuGUDRIzoFSmR9RZRWCbbTM1uz0tCxnu9NjEoA1jX56mM+5iJKyBAP6zRbQ82xg00W2al+ECdkyFa0jgBo8yZ9vz8SC+cR5Tjnfz7SqLQC9jhZKindDApe8frpAAcVRl6uIxE41uz4tQIYC6WZPowUKth4EQiDN0wVuWoAuSuMPjvQ5l/vwyOklbMHdo+8l7OoV7/G5qG9jj1cQgATfjo9IiiU6bTpCyfSFvAWM4HTOTidSvcfh2ZxTLN4AIVPaysNU73hGLO/Km+Xh/X5zdo1DN1dTNQZD9kSNE4AvbS0aHXVYR4SwI525NR1FN6AU9qu3hAEh4SGZuI8QAB7S8acE7G+AYyGYk75eP9tYpo50w4BbAYMyYNnUq23AAjzgXOv15Jo//JsG1v93DjMQ+2buEBs4X/EUMKQqsIAMKOxUP3MS3qECSkcng1kagPDdHkAfB9He/fdrOs3zQDJ7GbR7g9pxRaHFQvsezXs7G30G8HWqurxhYkEReQ6AM0CTJYJC55hS+3ILFqzi4NKm+D/CjpPMG8pVeB1dewAeMw1CxAIWF7+7G0XSqzjAuDcGluYKkClvFNlSnI0gQDwD/I4s6hpLCrdTzh+WVkxvdcn5tL4l4WA9nZxKCFiAOFyPo0z40O4iYhIkF59tQBDevT6aqCoHNLx3mdqTVQA/0gC+lstDgUddstDqvNs0gsomwL+wMMyJpB00FH/xgDJcd2oRfnOWLJb7897AQiqVxsTnvQPhXbXW43SS4CGABm7L9klbcT0BsuvstuXvvN7hm1o4GfJfF5sKoNuie8AvTd+DL+ixkKKEJAUjYOFkLDh06hoMgzsAcXdO4mhSQDziSb+0/xC/0RrJRLAJ6vAjpSgkv81AsVWX+3XRcmJAKWpXdeN2MvHNfD3sObZySMl3s2x+bGevWX72iNlbFUAghkemhD5EdMeMzWLCjXh+gYKDXibk/jyXl8qYSkSYABtNgcsYi/fiYYSaSogXbLr2VtE6NjmBbPOAo8qHsNFAMxUs3Jre/tgtgJl16gksQ+26K6kyk7X4e8jzwSgn+gAg16ySNNn8DrPpL5yXlOHlMqZy2p4jbIQkP2rQCSC6gCTZXrjt9iha9TGL3Jb7RiGATrJO8aknJXslx5BzsnNAJigSYtXNDDEebv+hcCHQ52c7kPVut10Y1P6Po0j/zEA8IRUOi2YQuLlTSmqvTARG1Zj8UJUXfn7uxbc9kO1ugCPNHLwJxrY7UHtcFHeiTg7AfgHYlxdN7gf3XRPMt7XAPvbCAGvizDhEaSPMoI2zRhJgbfMKn18D/vEdlCYyf8Acl9RwNcAqPqwbyAuZ0EnAWVnUcb2F6ieay1AJ7Y5lQCl76KPOcsZpGd2YfQDI95A7SEdAK/52Ep/3qHqLlXGAKisQtk7jgJ6Qw3hcqU2OVZkO4Llq6Vk0uvPOo2i9fsAHNdExes7yy/4frVFY8b0ZInMmOOSIr1IHX9lWdBYGAAxbFpST4TRHpz0Gsva+JAjwlgYLq1kHj4kkUWu71iqAAwkzV3g3u5n5atX7BF8nAx9FkAR3a1tEMVw9RvLIi0AKfXjaXv0pqrzsi+jezpmjom6KyVfZOSyITbWA+ao4QBlCAxa/Leyeegiq/LF/idmwDL6hE3eMJh9C7MDhj5FAOVZ2f5xL9bGE8lwuio/0lPqHfOWRhoCXh+Fq+fO0oQAwbNr0vFLGaqEO7RHzYUmB7v/EYTczDWoNsJlFQYflAC55LwxkZIrJvUg8eNuAGaWMdmtHNCNUsfIvdVfhfaxAPEx/kEw4A05rsvNNNnzpVQkvTkq01k3+vHdZ3xaK20AnjlQGs6JJ4tu6hXc+wf+/80yH4d4d64Ll9eioH6AiwANJNbOCgESmshO27tPSiZ2o8rNjpw5jskr6PNzfiGQAAn0qWnGaSkXK/hDV83G9/vlLY+yMr4L7wHyrOOVvcgAWS9Uf9dIgUCB/OOGgSw4naAIKlz/2edeLDrSKB9CtAA4kJZuaxXxUNFSWYYd5pPZR94FViuLmqQOV+h+4VsMAJJ1gn7QvWmYR2GEuVXg4F4twwAG8p5Ps7WUq/T03eYA8+Aqnq8U98bBouRlkd+Bb8ptyFgOpRqR1QIirTfdqwBbGelLlT/jo5x4yWcfruRYL9raGzryunCKICBogOnpAHU1o/4W6iB+9oVNcMQY4E3skifxwChjW8OT/PE2QxwAXZ/py1I/PTIa1HO2moblFkgXfZ98rOoIyYI2gSLEFgBftuiEtH0TSpUQ0a7YVhA6tZEOEiYSY1oDWSFOZl9rACXHkAtqTaAfInhnuYEo0gJX5z9cOM7C9V/FrJz0ft8ADtPJp9+KYmiZv2OuckEv9dAxE7BPKB8mf4FhndMGYwCWn3jHtPWVsibn5E8jzYRZE3Ir6Ov7TY4SATPrAGJsAAf7zOT3vgQg+XVh4K7Z0vpObJP5m1kJeDDHQUEvUaUA3kZzD9qtCpCMlCPcwhAqpdPKgDU7VSXDFy5UDIUN2QAjS112BzTy/zpPLCe9fXM0t1VM3TDuPiawDxTEc2xxAPVGFXB7h43mgcfiYLicB2M+c8icb1ayL7T97AbdhsMA3RZpLD8cu1QlFiLDR2UNAwW8qCjyxtcVs89hjLhclgB00+6CoT1E7lz2XT55RLm52EY59ennUfVkEfHVWm8WAN4DdZek2wFbd68Gl38S1LssfPwnGfOKOe9VY7VXskcAWSHmiZcWmv6PWFvaosYxDKPRxj8tW1iP/+vwllwq9gAF8qmoaf8Se0VIGtp+kv/ui+qwLr0ykMdC3zLfOQfKAI8rYn+cbaQ9il5TK3H53mKYD7jleC7CRwOMEA/EuasAaq9CwNmNJ6S7do81OEk6ow6+QpDVCium3VlP5CXA6gBA6CiqmZezUJhblI3JT8Tqrn3qAnH/9MThV7xUK0g/AImwLmksPNBdnfO/uBo4B4/6YF4EIk9vsNqvzgHqazoAUCq0ZteFC2W131tjE4Un+ORFjpxnHt62NzidmIPkQwDusWh+0s1Xe7B+it8+7yq04O5hGjDKkIT5CjvQnJwKAMclyAURpeYdk4xjqZ8WMVZ1/l9GMQnL4PgINmGAhN0AVx8/2M29tGWsBUk4r/hm7ob21MUZzDjnIm+PwTgyJQCqMHf0EJQmzTyChIa+81illYImZwz97yBXSaK/UgSEACARTYjYACPNs2mJ3T6k0zpLaJ2FYwy+Dscu8Ui/VqMAevB4Kky26FhlnYrav+cH1DlYnH4clsqQglwfwpdpewDULnMjMIF9oGqNaIoA/s9niRURK6cm3iNc1azjttDsAKt1JL8OsxS0HgyOwVGC0ydR5z+f0t208m5Ykks+q6gA5VPIIXLHaUjAFx+MeKEKBUxUdkKt52+4+7PtFxjF9AACc+E4MYeSgi9eW29/6b6mHY11v7zm/upkrX323ewJAPI/YkFMGCEBLSvPNASFA4MLvZBydhzjU9L9EVjWKwIARBhXdo9sqKTb9K7Y0pJNadqih/YnBvi9aN2Js62pXADEWejK6o3bT0q8itg1u+C9tD/kRaXOPT7+UDH/PJplAIXLrKBmYFm0IFHpG5fHbMCBpaPf8iH2RQom57JqhWIA64N9mryWiQAiMFoHl+WoHkdOvXKWJdzufTtTEdJhewA2gvk+ImA9ghocFVN5uh93bCHqMnxpqZGNlh4cAIKoAKaaSpkMcDXIz0pYnth6svLbho9N0cqgf9JFTxUpKnAAklDxn/k8dcms/3PHAwuLCNbF9D1Ajeh7nnOyZ77DUACBAQZIXqiuhwzNKiKsUr30bPQPOmfOzqQY8uQX0KZCAELjR7oFJP+/OjVhgBl9S3bRMGRLlbglGpaV92zZKuwASQmMdOmTPg+AEZCreR5ZPLySSZ5ozV05r7PIr0GBCwADA/CRxFvb3Q9F4ZAIEQ6CZ7+bmojpfaiQ8eppHLY8AEf87sQFC/3IJ1deDO+sC6tnPEHTsjTWgH8Crhn1Ak4A62t+IsKjW9SOI0ioVBxv7ZXnF3EY4Cf1B+U6EiSDFwDUQu8FpSt4oRRGm4SWxAtN6dw5FFRs6wmcM0Rsgc1hADb9j04m94udx2yJM6N9GtNK69lPkpd2sKuNioqYbFIA2kCuCfa923Pd2+e2C8pQum5taFS/bCKFCRJygmsz8wDAzYhru0bH2K/dbzoLzV9dPWSJK/y5/rBIFvuEWlyGALHTEBckZe67Z3bgTnypAYnFJQnLoZ+fttl63cHWqTcAkR55Xx2ZSlaBFXjBvAtsh2Mxz9e80mSo8R6ZDnFk2QB0+RowUMrggz1LUNJIsVYjSXy56w4OTgaomwlnRTCzAN8dVNT01XEAqHgqHKLUxWpTwkX6XvDUzmzBtC7gDoUADZda+G0AAY3YJjrw8F0mTXAw/5OEeEGEWArYPlGUiwDblEQQBDXW2jLcElDhJFJ52pxRXmkDTmNaXmc0LjY1AFGPb9OO2JEdygC10fn95UqiSBcMxQNXeHQRSrFaxvAAzMyih251jjxZPAtcbIKNHTfzbEenM3tVtpzvuajJBADR4SVVf+nXTeMuNUdMpBbB9yV1UavrgDtgNBzqiMxUAHqyhAtQGO/wu76GEy8mgJgcqC88s1cVS39su4SQ90AAFWhEV47M0espMz62xRUGGs5wgWwO/3hwFRT4KVy4LQCE/5FqFQF9thUzkzfy905CNdZ2nGIgQSMI7R3HQhESACeyWl7nw+1HVCm2sW1qPXrSOR+pfVNEa1bxX36/9xoAbPFr80pFEgCHEByOpqYcl9EjKGNIca7fRwjw1H497gBUk6NJ0dLdQxGaOV0FcSMFePuFVUj/4yxdv/NmiKF4AJq7AMxlkgsVNwfDG1v58+uKF5rn67yGIVUPfkcS8IIArJ488hShcGXGOuOApN39AzqfDuUEcTEZVRK6eZ9uegBvGvuEmtEuU4ED+MCyAveRxtPkgMJ/Thn7gFglA0cSAOszdKMYFA7pGbPzxZYJi1+63L+p6Gw9GCzK7j50kVEA9IHk70IsOaaTTZT2e5apOzfP40gF6ga2fZZUpsN5NwAmUlMEzudiNQyw8GU1WLYFc571gpjqPEPJlXIDT4DuABRH1gCW94qcDZLMTME7p6ojZrT5EUFFUgNi72rQ3NYARc5y5+puZefueR+IPl9Y1S0uamQDyqhkcz15sdys7wB1kqnpTQD+O0I6o2odQbl//Q8fKOPH0ujLNMNNgwZUABpvuKeZ5+FP/PcO0gL/crhHMSNaWpqYoF4ICrYr1kcAVWIfRoSsPjjx8NhlEz+UD+skcp5JzVbA3EpfoMnJ/wCwspyDr32nK6EmakiFoCNQGCdzJ+8dWNx8Sd4pKmAXAPUDqgdATx5dPrUG2/fGTKHvEK9VBvqMCK++/zLks18AhuyA3JlPgN8otOfr2MHLuuGV1J2FJ3RXjuMmlr6IngDa8Ahp4kUHh2ssVvGHmnDsxCMN0ILlfgNq93B3dDNyAJznPR/+wydcQCtszwQCEoQRR3lDrYQpJuuPVOQ781EAkKlO1fKmDuEGr4TJv9sIBgo6nX5IE0LLRbIHRorQ8wDsgn9o7zgmb6OhhQctGqI4Elg8bSyUvgyAnrHJcPdGAGe+1VX113ETBciuTQmBeYMGPpj+xphdxaITaflII38A1mxytELLa8yKK8/Pn2tC1kFgc9chc8b0/E0qCX+KCwClzk7PAkTa8MXzGJBKBvoAx7LmtszaIa5htXv/feIMAHRw7yPdurqJOkY6ZgL3Z/FXzlXJtJR2ZAuAP5IUl3wA1WDHuJ0K7ET9Nb2oqvRo+m0nRc+1kOw+uSxPvL+4cADtV04komUbkYug5z7ahnsbnJOEdF8qDO5gNz1J8DbcAPVCq12ppT5B/nIgphftj7lPstKkHPTWXTxOcd3ydpsA+Tc/N8x5nNNJcA+IHXyVWQDBMSeeB4ZQXZ/t5e8HWAB8bS8OYKN6k6FTQBDBrMl1sQR7ZFLspjKw3YwStTSyACxbumbT/PsKK/IMsO/xVD4DHiFak1TY+3tfaRHgV3sAXa7LP66oZrfbUzoVobD+1L4JeP1r7fKGRxltnN7YHAA2DuJe137LGKnnCBpIProdmKz2GkdRMVOjdo3NMUfEABYAo6zSWDy3kZBN5j23HLUQ2Tf0iafGJrhKnQgtkwsAkaX0XxID0tLRBw53JecozWvCOidC8BcjT3ILWGtNigB6E0Dm0WkjUCTKDpfEQbzNO9pvZcwaryfiOqn+qOhwAHeCeyizMEs1uEwl+bByeGrLzwugm5ie9F3SEjfKqKwAt/1PTJvphYvGN7g0iFMcR4+EWZ0ru+PV6gWRYKIKtADSR5h3lmfo2cYbYgLQzGXcJAuoRHeU2QlIESvjzES5AI4T3AhNx3fZ2rtmqFYaKhsMz8hm/Tcd0HWlLxltY3wABpd2KdA01HqGxSTVNT6heDAnG2wEeqfyza3JQmiagACHa6GYJZsF7E9MfFyS5tqc3ewu+vHFQJFS4k4sCdHFAFajdxS/y9IS/c9nU8fVtoHHBHni2pPFdd8jzB976awA632YTM1Vxl8LPU/mkSCnpqKgDf+mfFUqOHIfw8WImgAZurfLTxaCytc/HmHkhp2UJaPLqy6L4ZYw/YQtI+7MAPYPRgyoOjD91rOr1n9Pl7FAWY0nl3B/IPd6XakwR+8APJ25cKH53h98Hj1uEe3T4PNhpjo4k16pAgzKbY+aQAAYP9/JP76wxPhTxcckdz77JouBBp2qhptjo3yeSKaUAOG0FawbXXbdqwoFa9tlWnYQyln16gUaX+8RAGckoooA2fF8upEsD6fOa8UAqB+GZoLsCLDx/NemmAu1pAQOHAAtNiByWxRTWpcPTwBRomOhl8V9ISb3AZqk4whmxpkaAGZsCRMmpPSL/UbyZlIxLKR51AtVXreJ5HdW1HYBsBgACEyUgJCogz1JSBU8RGwB1RnTA8fkI+7agLdvVfWt2wDWwr8BU7m6AZ22xbrJRHsC/dJhbl3r3ebCFMMxaMroAKQcSFvx6W2AiQQu4gMGck1cyY/8sB9rkpdKNLFOysoAtk5pTfUyVHBJ0YIpGSf6Gm/bieNWppTNHkIsxK7DiQBeLcYB6nmH7Ir+HUTPE14dfTlp7iUlMZM8tneqaj51AN0iCErxWpCty/GUy4XCr52q3xXWpTDUv5tQe1sqssoAmyNhHQIYlmp9/oJOEFYegyS9mlHU+ISxQ7tf+Wr4qgDdhuohm8l8m2QAV45FoIfsnz/9GBX41QhYwGbzHer/AKOe1BhdA3n6n9/bd9iRSYaJ3Yly+6DVsbxRTSREgy8A1y9XF2BH1qN3EoE7CPX5SWYPWSolveTYc2T9PKXPjwBEvpi5uPCKngJBVVqDwPiSZyop7rZ+Gi/QubAiw5ynAC24PEzdYuzwrcvAmdlWr6fWRgXoTwjTXnYuJBPjoEUAc5FMchLX9t/zMqI+mwRzjAysVwfq1NHczJm+6uv83ACOZqrI3vKZxNOxs+EGx5Cpi+/8peeQKXZvgcfu4hjqAE28FHLF2qngUmN0tvrZUbqTGidnBdANhcDt4+yV/w8AZL/uv+12Ai/KyXaUnDl0iIVWmHBdzdbuaqwzImc5fgDwcWIZ3jcyqzuWi8JGPB2x9J49IakNPclpDpEsZvaxAOKdnxrCxJC2P/zXF5dw3Z0G/sG4W7fXUe0EXW3sNaUAEmfpwhiutQ6NlycE0JoDw/AuRoih5GFcsZzKeJ6tUAABZQ0Cp0pef3/plasg4I3mxZhQpbOLwsZaFMGCM3ePAJurSsxmkmYsilI0NbbSkhl4lNZLPsgVPuWUeyerVSIAb8/rYK9YKMtyXjFxvhfpP6YiNMW7NtHMbvoimUn6agBYhBz5Vr7W/T27Pmy91IhmUqesYOE5hAyJCb4o1NLaAP+b68h0Jfj/SmTnFAyzGhIZA4sFAsZx8Reloypb6iwA0wlkQHtN47OYK4XFg6wlUdmGW2slkkG6zRc8rOzmEQCU77DqSOMt9BjeAZaVziuJHe/41dBFZv/40752i9xRAN2StulRNVGWoIy12GwUIjkeZ+Vu3lJG/bBV0L6LBqAAz30+Iby339w06+rbDN4kTyo4DcwRI6+RDV6vYkgAHAAxEpxQ9mRJPP0POK3J+WGlYcn3xAPMKkCH+aBSTnlHAMfonDWoNgF6ck9UE3aOs+A5GQld5/JYSI9n+1c75lMAElGXgsv6cknDsUrpDzZLr33eBmyR6KloVCvma3AZDQBHPqZsyUFm1LXrcnUDFHQ5yy7P327EIguKY/fLPFzHADSXXF814TURiC4P7olgTF11o6MFbdfl62elvBKikCAAkDRYsYvoDELjcUuyuAUyRGY+EiNtyAM1X6dFiO+ypwCfd5Y1YR7izZ8nRiZqOUm5xjw14c043esksU9TTqhAAO5l7jHHDUxPoV6PzSKUkMwVtLwkVtWEw/DOYi75OEEArZnmcKcGU98jyjZW7f5+H+fwcQAXHEkoKZq9omNTIQD3+4ZQ4QG/66eJIpR8fD3bg2prBBnYqxcz+k78ppWiAEKlC4R/Ho7HCNDXfVdJ+nAkS2mcrKa2nAVV8NwRk/MAsdcIYGkZDcaYcl3K8RTWtslHTK3aBgJx8TKJi+WingBMvvmjoc2iv6TbYNXtmHGBLcUFz99HblrrkV461w6FAAv+ZMiWW6Q7jRfj68H28EjOlhNoY6hcm0+8hdoI43cAJaEDiZDH45wYsCWiNkksGlMEYaGuCvdXRZcFEULxDQAvupwNemvGosj2W6HgyPMaIsxtOKqpapy8JVkqJVvJABliezX4Nl4kdaEiwf+q8U3zaYBsaP/0O2tvXehxXowABGyeETFb62K/pAXJQEfhqBRYj5NTc3F1wxJoD5E0kAB0x59apyXELN/hnBMT9p8Soq0/7AZRcwlGsDfA6qdaAFzRNb+kKhncNlJ8DmPE9lPJi+4ZRjMV80Yin/Tz4i0AeUPhw//y+gNPbFNEGXrQgp84m/rlvoEvj4bs7bx3swCUPHSxclI+6PF6TmgH7njCmkrg9ujdL0v1eYegBASaAFKWsSJFNmuGqpZvUFOCXN0OMc3434pF9eeKjC+XEngAPnwRYVSrK6YjGbw278tGG8bxwNfgcFIb5fvjpowRNwDj+VWTX3AncgymTraBCZwou+0KraF5UFNYCmaQBBuLAAP2kgkozWwhF0Jme7Yk7zS5W/phRixzopc/PE6aRYAA0l2/+ghrp2AiKODbclDL+FHUk3ZMqyV7IctNvFhtWwBU5/d+ftXgz6nIVFodHcE/kfrZm7dma1xXTC4VnJg9AIwfh/C40zAwQcYW1TeWyJijjf1CvoozgmwjVNzFGxcANJRLAL5e4TTe5DaBSqlxOIuH6lMjRamds7LCTLRMlwDZ+//EaWesIs5T5xo1QieNX6fZeAHZQ7cCihQs7FI0AM3+M31T2PY2yXhJbvHwskb77Gjmx+ivSibXY9hiiWEACFBxpewaUmVJ1fdIb4OTptEF6+watQXDXwkL3y2klQDFRcxZ8PQgVg8eAaeJRbQgTnLlMHkqZbA6S17hezLcAOI9J+WWel5qS/a7TLrzexXyxKI5NOcR8u2wSeT3WXsAmqqAdzPpx3qG8R+YeUcC9cKrxlzdfrGsKbJsaJxJkADSq2cXvLI57Cb/1T2WSXNjq3+PpVCZD/UL3YzgYDXZAJOpESFGRmK2LP+y3kQoLIdaF45uHkzm/PKXGpJmvGEAm0q7mYnBAD6Q5TyuSBdIumsLh/WCQikwQ8ViSdJyWQB0NGosV5O28PlrhX1MlXV6RW8FkGxrOpZdleblbjRBALiLVUjMVFPpOsfWhMzRa7sCljo/B4q5XTQI63Be+ggAzuix6EN282eYHlAuiIZ4ExrXt4KRZtR7DirYMVCoNwCX1m/7gbSe07GMH4ZV1wE1YqJBXKsYxwaRsUX4kjy7AE/95Ckp+FgtaU5kCfThbMQ0zK7sB4sDJ94rkGar6rUAM0q3xSAVYdIWq8kvzzDNoWgrq6ArvbcTErdfOesHxQA+jAhBt4EHsTxt1uYkru6wBSD5ulc7wNjg7wYK6q0VAD6nkgwqM9/lkwEDVy53iA5RPUv9Mz7zmWNAT11KkQcA50CVUQtuhWuhOrl02ZvywSSoM7Hq2FPhhy7mgL+gIADS5P5RmIkzgrx0FBZV5PzkY0fJVbBayOY8cfznGRCfAEq7Rsy3KUIdv7ne0AiDPW5AvaEIIC4lZz9kdJ25BScAiOLCVq4y6XDGYjDRIBW0xudJ5Vky4TBC4CJq66HsSwDVv95ellP8y7IeFjT40MXThNaWK6Hrl8kNzsv4/HstAAhKaEkKhRHG1gsitWR4Xia4gxTJHGQjgfwSEwq2D48ApoWadMlWquOcBv7a304gs2V4iql4KtZzG4nqwrEhQwC7xXzZYi8Mbz5+hAmdzH036QUxxKZZj+2tP1wXb8nSAKj4rkUQIIM8CAMBiBu68PvRAOpOUbVqSwX/+3sZSUUAQLzMRsiASs1y5oK/eS13VDmRu2ouJL4XzF2IhdVClQBDx9B4T9BmG/Iydd8qa3Ap7ROJRVbxQ1g5JgRNuutnAN823GTU1DsV+atCwtMIff9uyz7kK6NS4SYpVTBb+PAA1ASPAKS7WLWXx6jRzJf9SnbbLDc/kD+D/pDS2lOMaAC2y/pd8N07CwUvk+cUMCqOrx3poh8Lcf8Bw4f7Os9hAIRgw2b06DjwHnz73HXwMsyqxO2t6aKYAEysyaH7CEEATlh73IIM6ySJKdJF4rupmX3pzV+E3V0duus6PClRQgDTYe8inLKYIwT9DdkoJtUyyGoJtQ2kKyQb0vHeyoMRAGpRKC3LaZ4uIqEVjP/IszmOiEdl3qME5RlzIESQpSkAwUeqx9c0Q9n2WVSQIl7P90ekkPlo0/vmo+uXgGRmegBfNxdDn1z4WkwgBkDXJrh7cSyerUgJ2+3znuRjkPvMAIow9IzcFW05BNVLyfxz4Uir3nfXYmtOxVncdFEOky4AJ3UL9Nl25TOSYRHGcU8itqJsYWOFBX1XDg09Yd5YOwBpS0hkaBadTyVMmu11MT+nUd3fzSthZ+Bn5nSIh3AMAFdDqq06gQuVNy7AuXY5goRYWtSBCmjfIzelR6c4C4oAzp31XeTauNvLXfRTSq/1Gll0GzqH2qeeoopN8KKUZgC8Z4RyYTFdNssPCXzGtm0tXaTs3lQPuv9bUEsWxJN0AIaGjUf+HWNwzyXAnxWJLw7JBXm6rOevbL5qR2Yc2XQAwypq5JY1m8yHZ99GCb7wolynJKvqVvyupnN67B8JbgDD5syvmJOFZKKvmB2Biw+DGlZ4T2RIaSWFIARGBmFoAJLotBg7PFTtakcfT7bBFo0dv53tXQrMEDITgiB/yBwALkAPe63jn3xJ52GpPCYKOndzj9DGpEbxPXW6bt5hNwAmmUnQnkoHC6etE0wgKZoy7/DsOWQaD80iIxfzTrtBAOMHr0oC0dpEp4qtyqd0HVMQACsxLB7SVfbWBqtQpKkArVG3OSDoby7y6qy4Y54jZuQoPC5VpTAwum3psYkKYgBOmNgWdpY+MKTgtxoFzlJ7yuQ/8umJl6omLpB0RMspACoRpJOSHYnYpn79Wu+X4Y69PA0kJC1h8Gc+vA4S/6IAJOco/Hs2DRsww/UBy+VvvfZfBvYiF9heaLNBK7DVGgBdKgq8Hj3ZucLJthl2vEBLka2pcbdpiyCMyRcKLESgAFoPY78+N3NzeJIOPUe688iS38QnE7Icl+fV+qsXebkA33FswDYJsG6JpE+Dn68i6PEFBvZ1iBVgp4gkczXz0gCaJmIrlOYmucdFXvKNrUxvb32Hp/CoNheSAQT5uQKaABY7n0UtjdpfWzkcLvD/nBtLNhdvGsDspMzCgjmHlGUAGu/Nb6IiqgPytSMv5UQ2UqcgH8eDYbWF7LfCuLNHDADfrVHtdq/ge+5o/Vp2b3LmX/8xfbPWtoEZBsXrT42dAFIQilPzghNhyY3xbywn3//gq+mNbC6NwVn/uMgjnywArtEE1ivqwPsg97vjGwP7fNmAhF29Aj5CitLwZh7wigCYh2yuGupe7+oVWJSWaSriPSyORXVE/2IUrlA4E4QFAOILmTZQDvzMYYAmY+EDty5CnMZGhoQXYBXXGqv9hkYABB1o4JrJynktjmBWYYxA7ydLjGhpC9B/BFOVVP8GQgBe4XrlLwWDUiYyRl6YtXFhB8VSgPiezC3QKtv9EbLMAMmKHWOJEA74q7MR6vcUiNQtS4/r6YT3Z/Gxqc/NqHgA4hNi9O3HCQO9x04QacCgwuVZxC8ciodjDafJEARY6gCLAZyJA4dnGU/58RKmcim7PunxOKLQAPkrboerHpKnAIvP2JGYkDJBkWHKiJBWCLujThPbmFEMY/KSnVkiD8UA+/s4jfFTeXRNyEzrW7+AKInHQ1APW+8hiEnt/m4wAAAz7vEa2KlU6AjESLTIuANpWN0DSOG/nGt8EmBJarRBAKj7GEPivWaYbUayhawpHuDFNEq0UHz/TcodMikoh3YAN8d1wZcf05TPJHU3EhbLm5vXj79+xoRWlRCNSwKYWQCqHy866jIdB/USjlsCpfzOyofBWQML1xmCac7pNDKfAAOgDfQxUlPMP0jQlaxQhUAnEnINw28l0CQ6blPJdlUAu0J5B332x5b1j3p51QQB88B9yvNRb5SdQLSgAdcotQDkXefXDRYMXWI4MTo+H4zRPhsqRtRN29Nppfl9KiyXAKZpzyXHDIKe2h5BiRxLjHD3sFMxsJG6/W6gebZ82ssAEPzCteA5iJfnjzlIt9VytOIFPB1HdgOg2HmC93D+4wCJkzJ7H9Ypo1m66Ds9bMKSfw+0XHWY/7IGRtD0pqyPAKeGtbsGo8Y/cLQIGnw4edIba8ocA61Kpow9Ep5vB+cAAZ26u8b4RK/+E4cCndEU8DqnFP9Fh9LqIlQJukZstgAi/BseB4Ys40+X0/+DtKqSGNB7bAZ4+Dcj8gOp2TstAKEDyXAUdLzJk1F5eqMhyR8uzDXKawhB6B76/gTMJzAA1zCLOcdQq+g4krAzDA4gn7z+s/lVeCqJmkQKnEJ58gASaRLNqQstYKCV8a34LS0LA9HmeNVTzLzfast+nRoIAHAWc4fqg8b/dMnTKEk6clCfxLEi59NbvjDcvLgtHo8AqPs0QU73JMiVwFFm90RTDBaTyDZ5/jXGiF8c350pggBeXbGLxMbHI6Vu+bd7zszXsfKnbvHIDQPus9hWAhYoACc3cwGyeQjIdeJMJsRBDol1M6+MNadEAFddeiInrekA3xFCutNAClqH1F1GlrnUkT0oQYa+LlF4ugGKhXSx0QALm3BPKqXNyy3641MszQh9LqJ7lfyvM7uKKZLYa0V5ACCVdZV01Bkcbw3+Lkm3cNw5e1hRJ108USdGcyEBqmsAht7iVpOFytq9CI4/HzqvuSl9FeCNJTSBSYYSi72nsgDreJ4ImHaTWmxE0HzOliTFa1NespQWQ/UOTRD5DsT3ANKIhDvgnh00RMp+D8wv/93o/VrMuwITAscKkMU/WVkAYVwqWWMuab1+emYQC38dgP5UBoKDlhKWFBtuzFYYnQD/Mhn79sJTdi65VIfMjHKpoEKgwxz49mgRP53ra1R4ACLZl3fPF1OE4/FwAz6waZ2kP3v3gRWdIHLT8JrEChEA9JTg/4diLnutOaFsSYXx6If+RXNS8rlcc1Pwn1IZ7gDsPWexknoLgvMWF2LbyyIL4Vh0c/a8s6I0v1mablnUAGK9r002+Acrq9qDpKuzOOmqzl+8K8MDCyIyzDNrQwMA4VGWXdFmMRCHXsTzs+Oh/rsJVBthqRkX/94AMBZQXwD5W8/LdB+5ZQX2LWq0+g0viVhx7MzYaJ9p+1bhqB0vABvVOik3GqGR+GgcLeo61FQeDIR2lFjW9b5DEgpC1V0A+OnXSxSUmsPQBHNqqrPII2EhFJt02VtHl9oE9/uS8wDv9r1r21I3ITVTeHY9fJUmWHaalEMxBYstTsKYBjxjAFhN8e2ah4xZufFtYf+fjtPBK1yg9/c17WKlnw4aNzsAOk4X82tF+nT1UeIRyYYFPzHagOs4W8ePhoavXAfmNgC/2uQ7JEB6SQMn41uKrsZvVrkOAm6Nd0vam48ZbmraAGql5BErXgv7F5GOjzF6yBNW7whh+0m1xsVqoYe6jDkAiv7RomPHBvDQKkGMs4QEH1BHgKCyKwZR1ruTJ51C0wCPT4zThjJgZ2RzuAMXZieOOgg9tc+FhfnDr3042xRBAFKzGKiP4WAEYfLsGIH73lUw5j12s5BtZFt4vprRRsoA4Nyagpvk3uJO1IyJ8HgIBCN0L7vN214R34fMl2+3gADidqKzT4K4m5faq1FJ5SGJWUmQvhPcVSQUz//JmlTLANzkJEyhfeQ+UDk7iPiWTjZfP1/gvoqE483n0R1YojoA2pjQBwU2/ZhuEjEDzh2F4fMtJxEwfrJrl1VZFcER1wDKvP97OLMtQKhG1UJqCvSKe4j+t5wu5uK//hqT3LqGALrQUcg68vWAvos6rBqUEs0I/nhbXxdpCShhp2GpZSYA0/I1mBFeQNDUTemrHIR1n8U3ib3kfsbGIubx+61e4gAZpwDqrUNcDq8tfhA/5SGW3d++/3HCyJXFLXPEv24eAGgY3i9svhy7XmGRZnoAPkUiECWEJ0tdnqy6dkzsD7AAFArt0NyTcYQom5k2BLAKSUh934s22f7WDblhQWbX/QDYaXdU62AtTuAYcrh2rZ4iRsD49VhZwAALAF3fo21oACUekEbLCd7Jc0rZ9DGZ4EEFAtozOXzbbcZl6oDQMdAA6WVSzztX59SOfYoW7M2PgElgUECmhB4M1m7nwoFwhABZFDuGTpwLCuJDDTZHTKRR6ah2bE4AWedRLXmPD7EWADF0UOWwJdhkjqTVcu3DyV3u9KVQJGGnOOXFrHhEMkcA+I2xcpS3vlFg590Mna2su8tZIsIMxtxK8iWuI6oSRwD4Jpn/OU4SyhWPz8sTwLAlsBP8LAH2CEAI8j7igs//AGmA2ZNDUyLtwalbKfUAJw7VNLM8s2Jea3NCwMucJm0AWj6wW4S8jE0ei6znrEw+RVuzImZwu0kMaDeKW9cJIgB41zD57WtSXi6TXu738c6HLC3zPxHN8ph70zn+q0PBAJ7fs633DoXbMsB/qKCe+onqqJ4nV9FBl6dbRaTbXhEA+sVvkVG75jyTvLj0qMiEUqaOsiANrWpfpIGCjo0/RgCztytetwUZQRDt8ZqpuFIbUiMwlpQzkDZQotAuJD5RAAtniPKIIrpqE/+wPzcLl32VhZMJuyyL6T9WX/Jazt0ARmZHarO33A6NljTV5CHsvnZ1jouQSgXrnM3F2m+zZAD4eCF6Gguqx8kfaPyNgvQvdhO6CfZhxgDHKfBwzx3TAKUChgG2xWeR5Q+LCD23EcfTbzNW7VVKQgNzRxxBEQQA/cHJc1bhwaZiF5WAxtl03LE9wjHcFA8rYuoGuG5wWQD/ax3U4jIZkeOVQ776iZ73bRLTsW19O9hQYEeEbz59ACUrB8OnHvcvAZhsrWTsAOYAkLYRIMObkr/aNqx61OAAvxmCcBcUgSnC6MUEZTIUnWvox9LfndLIzkUXYdFNdQBoCFnCXPw70HJPpID093mXft01/VPzmjXrsRPzxH2BAHoQlh8hl/6NdbdC4I6z+fC0nag0KHnvvSRz6OADT/sApuVn+puBg56hGXPE+2kEfPl/H+2GzJhluJjMWRjTkQDamvI0Q6ZypLTMFiV699tBlWCF6Jbn8UcBRuawy6BRAGQJmthXY21yGBLU/vz0Wh9Dt5MjlQMqfimMdRoNwoMA8RwAdYrcFHuWgUNgNnGm32jJ6ehOi78yF/kx7ft7/gBrqbZcnimS4mhj3+EJZpy6a3L71TAbbGzmSlVTM69vANmwTV/raK3/Tt0nvYjdPL8Pge/MomjZs+XqoPvO1F8AzmRLQe8TMoejzWOi7lDlbAcPntCxaIR62USOMupcsQAobYPMcQQUjAbEKh/Aux/lwCuC+Yap/BXXPwFdeIBjADm9jVA5nKlmNUTS7Ma5W1b4PQWccMhTNIXSURF0ed0At24TDAc5Ou9Q14Jt5WNLf2Zzy1KUtlFE11m3wwkc9gCGx21PTOvWF5fZVNhiJY3PVmlJ89lNqLdi2z6gkKJUAA1iNrOPlAgVaGgLC1vzEbUrKsHIV8sHXGTANmTHAlAATpoYjEfF8QT+tD6Q1uX/xTQXyKdJSaPdgDu2IXuvPQDLrimEne+i3qPqTiP08jJ0QlgrQTQnpcrzZRkxVfgIAOWI0z6bTRnVXA/ZFGYjFpMxzfbyPj5YQyUbvpTNJfkATuNvr8AX7u7V/t9OVwK6l99M3N/xWh46qh0k7/s7cgAat5OGQPDqMvLu1Zo47XzHGBHN41lYIl3wDYsmPT1DAIwgKvgT/HrzPkzhnQ3kmepnLdwztCgDCnBCnDzBZS0AM5ULwD/I7BRaoiO8Pjrrm78eahzXg1gZvH+zhRoOVgAsb9CRDLiEJ27iONMqbl4pNWaDnrzH79IrUCWyyiu2AEu6gQXgZfp5p83MlaV+9j2Tk63+mss5B5ehI2DR1ooAi+bmFFACsxIjLMmwMir71EsIOXw3RYruGwyxLzRUwABadb2bdDi+eG+xbs/w/FBX850mq8u4vqXNTV1zwnMRAOCz28tnPkWVllk+2xfhJy1KCW4vFcEulg4p5g11QXEAv3i6cz56WNLL2PqGrBC5td/KzOTpC9sZEFtwfJBEQgBPg2ELunE9MCKWKeu/DNRqTiDDKAXkrrhm1Q8UVME1ACi4KIp3pQyeE5san2/CcxV4GuocXY7BVJAgCSks3QAARFyvsBgejVKC+MBGlgv4jvSKArcdnIRXAWbeuWZP0QCnM7koLCtHSuzsZTiHQHsQfqU9FUHrKkoX6DJuLX3SAJ3dN5G0z8Fuwnk2N9roKzcNVz5c6ECxQuhi8LlOONUA/5tK7Ww7owq7RNDNaxB2Y2WLKEMyVqLmNi68Ry7bIwDDHirMszCxhcJ1Kyz+rIcG8FgIlill7/GbeGGEwpTLAJbhWS7gMvaiMGhMTFHNIzcuyoTAWHX0FEUZoMCoQqEAkpA2yk4dFOOKmb0PsPLk9Dvo0bQJM4rDNK07ZX189gBbcPvrnYU0AEajKK7wHTr2XS0yqSCnqsqmLMhE1JJRAJE1RzEbQxN1i+9oZz1HKERlnHp8hPRjPi4X4oAnBKIAc0C1AQv64CkMnchD/SIEb6nJfyLlD1F7iZs7E12phAAzontsr2kItn3uVV9P4xfjXsWS5ZgYqT+R7XDVxfwGAAScvuiyVv5FTWvh4u2S11GGdkrnO/xtiUit3p4WJgwA8QKp+grXOj0o4x9rrDG+8gXPmHwcnG8Tcxr4ulxBEwCyltqWz0MBDJFoclT2zm9njSAXNCRMZQTw6gsTUWxLAF2duEu2Vws6ZBXOqwiY4BvdPnpIKwCBkvLHrTP8694ARzlGuducu2h1bfgjNfcK38p65ixMzn5eT7PuB7607ACSwYE375Vp5mWjTSC9i6G9dyuaRYezYXXUuEGUQJmcACVKkfJbnX1HGxI85d8RQirD2dFhEr1T9+8CbA4QgM8A7HV1nrxqbDqzAxJaSLY69fjjWo/SReakmN/K8kF+SACOfuWz1eqKJ6nMwJUqsJu5FcTQnKrfTynDTDVkvZ/FAK9qvvgykfMUi9xT5Ra326a+WVIslyTY/xZRnerxNksAiBp1zytmVl299LzT8/Dju+GXZajqQ7H5EDB7H+WzCgBmHykJD7SnkhJY4SCc+UEgItSBuZJQG01T59MDCOpvAFHXcX1pLzIH55rODa2DiAyELx02y+/7EhUR9dAaZh8AjuCI9gvk0/5Ju9YfNu9vlDS3jBmDMgNwOQSOfP+XjgAiJcTckl3wFtafY7qQ4opOjf0XmC7Xfo/bEQJST2sYACnaAS/Ktzn9KnI/347sEgNsc4rIvCLjpK1VQy9zWTcAWCbikGEFM7r4ZYDv76d8bk35SgzKe1LEehjQG8AK5QAJkYZHdfq27TpcebHNSjNAgs/NXD3rYiXsOrGZOM/ZAIB1caygyZ4E+Q7uIwt9UlxGsr7aHUtGAdUqbDBXY+cAgTNLF7jAxonIjQcqUiJFzpPhfgN2nYjeE5CJ0b3T7wDkc6RpL4ytSXnQ1OOyGfxvB6kDUsmDFNPQQD9Q0ei/AL438xwP+5WxbHO86dLyyPuMakrRODCnRTRrmql1tfAA5bIMzP+wzH6/Rv/42VvV3Wjxk4YmW6Avqq13vK3vmgBjDLX0cLFGllNGZmDbQ7eV4yZkbKIo0hkafjY/O3uIAG82Ny4vmT7PiNI+v0n+ywRg378GQK31iGOm3lkB3IcAIB5/d/rCKvU54ZiivG/E0fafjXUye/E2/8ZYYd9yHAD6xnFDrlOP3ibe22w4s+Lp6i3Ntabgab351vId5MzVAICBd3EZeivSE27cVsVOTOWcp0GfyQZ8Xbjyx6TPOCoADdRW92phpYDhuTt8hIcnJOsacPz6IB4Pg4RpLMDahABzKDNHvry21Ru9oJuoQp2pKiSxgTqqvO/Rr0xVurDsACcihJq43wqj0B1s6zRarH0KdQN4Irc95AG0D9CpTmMAoBa/Xt7uoC+T+R7KgL1MGELWvQghwqC2JkWA1ySeaADCjWoSWZnddggG8Y1H/i+NZNjkmj6Xw/9KSRyiYbIgAMiroEyhCuJYNcSZPkTcrzB9Fs+SgO0DVy2JorpM3IgAtLNZqg5JAKdnZ2z7a4qx3Pnm/Tdoa2pa8NF/0jDx1QCy5ONFWSm5lWRB1PxdHskpLKKQcdemEGiQMZtM2d2bADN+g1/bkWH+pKjl5qxJDDIerEimfPvVdjSX5jMZoGgAxlUxpCh+2e3VUROg51Ph7h17THZemZ0E0XKYgqq+cwBIXW+WMxOB7KIKDJve4ItBhkUox8K3Ql7aNZOES6WYABgPmPA3xrdwqgrVL77/uaP9JmZTPpm0rBUsVbVdYekAvpLJPGk0UjD7o5cv1X92+NDay40vVyKYzFZw7g4YrQC99tu4rX1j5B+sG9Knffhf0W443bZzWf0ubX5+bpLvACg52nX7xNS3WBlS+X3OHdqWMq3hz5kmg8G5nNQ9k7EAYA17sTnHBEvlIXqSEUbxLg54OsQZAEG0/x74npEhpwBu7UlXDFzWEB4lANE6Qjzg43GOMEBozX282v6AOTxYAM9slGxo9Lm8sg5ytYRLjgWS90wSLdwwON7cTNbxJ+oAXd54HBT3ZUlocSNlA10vrXviT4HfBihgn1WgmnHFkgAR1yRheR3vPwlLJ0tXAKsgMoNnRGCI1xZjFcjeVp8YAB0OtYYkT+GaJct10QG4EUTCPeiFd28LGHURbshrw0oAI2whGrCjQi10rYV9WLAaBXEA7DKDPHaqvJp5wogYsQD97JZLNC/0H6P5HpUGjPMw/zFNLq3oJf3yMO2DmzWOAN87LQhS4DEbhse0WS1+G1ECWrSlGX7gLm1lwqdk2iQA1cg2iD1gnjngRk+2zDY+DSR7i0DlZR0hniK2i3vFGQA5/DBxFzK6uHxptz0AZMv3v/hex4vHWIqUSSWentH1AImBn8lDYbPD8Nw28wk3RkqkzQ5r2qfr9RmPFz8Lr2oA83YAHlTklMq7kuBl04G7apqeCh2LEFaWrjU6tXigRQAYHgDTLwN9Y2xjg6GS4yVuvE7Lg+9Yg8gsBwsAfze1ADlrjiCjsvIrC9E1k/bRy6VivBy3HRAbTqYfp+8LC4gAmODUi7E16XHd1RHtcEzFPmIBff4wP3ptYAVrgQxsfQDeJoqQb8tnYuTiLBm5W2qXPkeRWSSjj9drTjg/KYV4ANJFVqWW7retBIXveLE9D86moU6UXucWMhz7rSN/yh4A54BdmUo/7eQkyWJaEiKk4H5TMxvb5Nh8xLpzacac8ABLwSiDWGDglSQ6qFMHM+BO++qaHQS7bN1Im8JYC1u8ALFlhrTpKQH/x9ORu76UbkjswQL7tXmPElsinQDpXOYArEhdcH8DdhmwRWyrrj3p05a874/SRGHNEVzQv51uHAA8vDLujm/b/AyOc67EkfOGJNnpma5dtPwjW69bGbb6AFLkK7VUrDS3ZE3qEHXwJdblKw0rE6vscgMwbw4ypywAhNDlgmJViQuxY41LoUW8AenyU+nf8VS1t7imC4OchQCcleMTXLg9i2OW1DOdM6iJE1hKr5pz8JFQ2J8ye6FYAOoCEpXHGozg7y8MViRKwt/mYhhl+wr+prrd5wmWwhsArxs1hVddvB/dh7gPx9hEbs4n2lsA9+oWuD0T/ISEJgDcCbw1MEbQLB3KNnLcUSZRvuG8aSvWbU8pSufggx1oAOmuJh87/7kiUmP2w+VUbNURANB3RcMI97OtFJwqnwgAhEpqD+ShLRT5kRtdZjzsFHJU4ukYXgXzTq1C5SwsbgB08jca+XYcHX5h+H4XJRT6HdjANi6ava3QW0MFPoiZAHwhI5wiWk8QxXNxM48xpQY9lVzs6EZGb5gTBbHq498Ayg6TxRpqMhdXOAFwzHYlIlC14WyDKY9QD3/VJm1LpACt2ZirV9DtLouZtl+tb+vIhaO/5vKDaMdfatI5ydhSANkDs9pIZhz3127uGXhH991qdCKWRWr3gE20l5FUCd0AesnTrUs6z7rvUzgp2jtBcvv8E36fjGxROv6n3+cxBgAd825fAam8Re5eBezphI4aTaeHW0SWnOB+a/Q/9IMdANHqfDDhwO1b8nb+K3C4EicEFX2vs5w4pxGrq7NexI0AIjK5WQR2e2N7fi/FgvcA7EQfGPOTdtt0YK+630KYUQCD+RyUOGBeaHkK+1RJ38aE3drAvQkWZLVg6uVa9/XUABNPrDuZdL2y+hEqcEOKvPPcLvzRCqxWcTKK3oK1sxcAS6uhba/73I0cI/vFhKxjirCYtz5ld77YELip9b1ClgDtaANtiMcL1+xDKzRs+gf/wY/qqadFLOXbb+o69EXdADWmdi1L2meQ17eygxByvn7zjs6/qfmH4Pr7+fBiW0YASyGMD5Bk2/zhQ2sudwtlzcZsnwf3xVx3eTAJiDANtwBjA7M9w2OCnwBjv/zbmATh2q4/wWhb0oBlgwbVs+3VAK5PgHgYpwepbHCK9WirYT2MYDDx0tJLHUnkieWxSE0AKSBi7WqwBEO8vpjX08B5wtc/slpK4xajHyor2wn1igAvs3YNA5W/eHVQgwZqo50cEuvneBPy4j2tCFX6zD5VAJQMjuhcpCj3rU1wtepXSsi+jWtgz01CNjDTuqRoIT4A9OGyrmpAkPLXstUQoJLT34+kRRnS2BeuWYorwSNVFwDfdRbQ4sSTMB6K8PaTlzQpl1PlpTe098SoXfrNxqSkAE2as8Nuhin67d0GAuRrXibf53n/UDR/GP+VrcJWMVEAxCuyu1Le43iajy3yvDII+/DBDiDZgL7LJmGzM4gLyACFohwiQcGyLCWRkKyfkemZaKp9fJKUiBYmA5nuIlaaAO09k53hwwma4NHFOW/lx4GYOwCztBwiLv6i7baTPZkAo+YM/Tz/1Q2a2w4eJMUApgpW2K8TfA0dxqkd+b5S+AAzv58LIOewtts/7FREC2Wz51fD/MTZl9lPAuN+kEa8AKVYvaft3ZW2F24MUpOtLL7PcxQ/8CnBw120bscXPucAiK/W4zK452nOMgIfnLF8U1N9ceMyG1JM7wDGH2jdSQAUUai9ryFEL/H0owu7YTQOHtba8P9hBsXlGjTWQwanACYJj9kj8Cofx6N7ds8KhoaUr7EvyHrBsSiGfkqq9d0AhovNDmiKoI2Xe6ugz38rprEEW6gpWlJhwHP7kak2BQBPJQCWkIEGMkmcWygwIWAG80gZDcGTzlpagDVO036KAKkZvFDbBTf0sSreorA/PxrcYS6F9J+CLFMHo4Ph3XoAguKMMcWAKIeTHf95L7XoFN6e3UatfkP2q+UupN60NwDo9JPm2koyuckse4nIFlgRa5ehvySKt1EsSL/lZnILAPqmRwMZVD5/Icy25mE6h4/CsrXvAGKZGFrDqGdYsjUAOo4CrtRL8b1l823BmNFJoSwmzhcC28Jma2QGI/L5gAB+EeAjIAoyq5Me5vXjLw7sYuEdUlcQdd/5yzgU8797AASl1UIKcbgC90PRXUaovQliQ48wYTVDqShL2NXpdDAAC4gzoBdh6ZDcnbA4D/Fh6DzRVpwAFhejgIu5FhfNZQB2ps1blFiYtyMXiyjVug239SYMMGfpWflT6ZVgTmdkAEmlRGWhvKGzExBVRLvmBmXFdD1pfkqLqZW1P4wBUbAAa6hGryfdH4ouxwefbo8uj5t5qvJ58sVPA0oJKj+m3AC1+PGz4hao9/xwJPGHeeNGaEiamQEJ8hRjpSj4+XEfALURD9soz9p6C520IRAcFsqzFPmO3nJJHT+GUXPJZIoAZ3b1LMETo/JoqzXFATYLhg8Eic/FHE1Mc2zfBxH5swCMKkzIeXZa83mPqAZyinnN8sO+6RQibIKYLeiiUS0qAB5+qCPN9Yhn0oCg847Q/YVstOgbyxPXfh37TbeUKukAtC4l5XTDu8Lz/OYQoUkOw564Io4na5sRfzKK2FxIOACYLvKUX1+XmjxOJdeg5lLGQeaJ1f0oJHUs79N+eOjnANOshqAcI4NtMv2DG0EW2PIhC4eTK+89UJZ8Y7yDaT4ABr2z7ZENzwwpgrNksq0qq83rJCNdLis+RXakkoKLqAB5X81aQlh8+EyGl2so+sTam9TftgbWY+EhbQXDBipmAC9S+Uz4sv0gWXaSLbQeTWWojjZeB+9sAbnGup6O12IA/EP/L0CCtfZrP/d6c28LHHxBE2cFToh+ui925UfbJgDzQg+llSNzwlBmM6v4Ul96xXB8vzDFvW2cWsG2a2mMABl0sTu0u7gp4y492KihD13spYmbdM4kipduq6KK4GoA12jIRx/Zp0mmaGBjRUHvvDaLkgrLhOOA9CgconEn9ACeIGI3kMAr3MrGBccW2kk/b7YfNkP2do+z1TL98B5UAH8CnAGFm9Ws/OkM/3pqu/0X9Zv29jA9FsTwYtO16G4AcmWFmiIuujDRvqv9cbpQkBHI7hp/oOWMFODknYnJywACLM2lkyDAkIKKYNmwtJXeyCHtt+AQwMXCRZzKnQuNAFVUvcVntGgMMprB369+NK8pbEqWnR2EF2z599wsK1gAm1M7FiEhhD0n1ldx7n4OjvWX4lNAFobsJFvVdkd5rwCZuO/73tbQh5yAP58lbyZlEI0fvnZfPRraC67GdMNGAJ6n+DBOPdefzpJzhDnjhmDUbgCUKEvj58NoxMJurfQAk7qh1twXoyDG1kzlonKZOK/RMOCCQ3HOiKSurS+KzgBnuEkGs7p1wJaiVW++TvgR5PaKchW5VR4qE1vCfcxmAKQ8yCSrWO0eTx6ljGXpwU3XMWqJtx/eu0HzRCF5Rr0AKuJgU7oQDTmlO26CrYnIDMu+BrMSsWkMBJJNEL4XuwBCde9CGj7uMSQeYTRfrxff3yM/gsLcVcN5mVIPt/rtAM6II3QsTmF+3Vu9wZG2t3mL1QJkrZW0Y2616ZGTpbQAQZWgturzudlvC3uBjhmaXNW23XM8KjWbmAtkpfTjpAAduGJch/SIVx2NurJnnPy3R4HtgwmW9JOsiQmf7nyjAF3FUeJcL4i/oLLAoC+JCKwJdiBj4oVZA3biYtxcpQwAw5HmweSEPyqc+AwJvjTuZSsABnYl4uwW2/dATqx3OQDaS5Rxze8+V7l7WpL1WNs152iKVg8TRYRSclwADliDAJfphb87/eG6/XIJ058LukSmi+WncQ9Ps3Rx5l1dn+0AZEKEXHyl0lig0oMcqVDeANBfLL3+jJ3QavyC75CT4QAIrz2TkA6FbDBOl8s6HiBIjaR7PmFSBegWF9Aje5mrAHRaSErLOWqWfV0mtKAhQdGvx0CNcIy+TFAh8okMExIAXrbE+/FR+bvGbv+Yh/54HOoW2mZlyZMNuzxAwDit7wCGyo03NKYJLXx0GyAKu5EXOpi1e7d5rwktjmRTB7jtALDsF0tSADR7JevggdLIDmhg542GWn11eV+NfrNw74cArSKMABzG9FY7dFdVG9cjQgbW64b3x4pdKa3fdt4bFwDAzQ6Ah+k6D3yuFzXVkvptEWYD+XJ8RyqkMM8gJVRzAEMnDzRJ1QBtHD9joav7bRmkQHdkk6E+dRH+BbdSn0kA1dI8CJyxrf/6e1g1k3QDLeXH03et86Z3XkjUboAiHgAjNwXaK7XLau4cx71qJ4eG0VobxN3LJ49LUWeOAoS4ABqEfMCYzYTEPBYHrRUASeyFyJPGlz8jpyCWugjXQZgA1OBkab5vgmE12L747NJOxMooG0zwUdfY6bRJ6SsVewBDw4+cHMyQpCUS9L7LNsbE2iUgU1G7uX7ibjW/S5AdAMBC5IQ8nDili1onhRBa02NvM7V8KlRrHgfAr0jgAxkAG6MiFZyVXurQ+/L1JMDxgFxjO8XoUDFR01o8DO9aNwAaUdvbtj9lTIa/OnAAFuvJTJBX//S1L26jj2CI6nGSALhZ8W3VZXBN9Ds1KSlcz5whg53rNoAA05oavWw7KYQAZBjMbQEIoebJyz1oLgEAIBEbT0ev3spnhJ626Uab3wBO4Zl7X+Nr2dnuLCOepDYcZAVrY62KjbHdkjnlKWaAACjxCWJ6ZYdao2CfmRL6HIJIB0No855I+sJb2fHW5FQAVQlSYeretlqr7c6t9+Y8pw570LOho7In5y1oDwrSfgBicEpPTR/95lQaqKGtc/mUnZV/Rgb26vB9s1LrE60PACBzabu3QacBVSHbDHvLEWMz/GYA0ulew5IVHLxJiH4Ag7qt4ESz2il/POrGBPMrNILnBox8zWSfF0+SWzK87gC6jGKq3uajl/UVe1GK0RuLBcdNmgyRB0hhILJNMFSYANy9bDdnbcpeNSsSRreppRadtIiRQuHQf5USO3aax0EARluQdwcNPiFISw2uosS7foRUGX/BH3XWtG80m5AKlgC8HLT3B9F9Dckv6gBU774O2KQ9yu+yJ8+bpQ9kQb2WAKBD7a1lBBJg5OdNGEKEZ0L4QOiBroSmQqoEIaLLDaMAGG3YVaI7QboJJejbELWPX2H3PR/wnIq9isddlufU+gCHBR7wnB/9f/OtUIlpCdpJEHKhLnRi2+wJwJxNlJqfALUAhfhT2FbtAkeLirbJF+8G9wWpB914/CQ9bzHXEm4ARaRB6aA04hM2yfBrmQXmMGy+IZrKsybkdsDRQnbQ3ABQU/0IYJhcVz95VRHz7vF3A7T4QN/exHSSEWv4hS0jANn+kDfA30jO/PKs0nJcWjyP56WZ1+Enskk4ms6iWKkAawJMqQIC7kfmdSMiBaaO1X0cBe/KMgh8WqeFaq8k+ADYEIEKP9DGiq/ewK3D7qwWyCG71uqYxpb4j2I+TCj1AJAhu9W6yLhWPcjiBShJLSdGF/HCH5N8UBabjXV+PjgAFmXoNLqg+kVZOasZGUJoC1s4nR9Lc4O9qEm47Vl2GwCrKpB5NFxhE5eeiXYRUXSMUve3ZIcaY3By58KtHi4NAH8xOSO+wjD4Q5bhkU5B0TDNq254QXq9LoI2AKnio1kAvXPRA3YOJYAQ29yBm5sGpPI/wCbKtKPohXnt8JA/lACjEB8dYEQcsvSDdNCgkgojE64mbssqrnG3+YGaovZ7AJfObSMs+UAd825vhrcydSD2GzfchnEjlpyN+kzW2OkAjby+2I+DfhpuyH9NQZmXEc7YpraH4QHGYXTMxFgz3QCM8AKyuseqzI4IsMpIHQwvwWV/G8/JGSSQlcYxUTNYAB7XGg4XJJN8+BPscvp9W7T6FJsO328Q7KGM2e6sajsAtzwUr8i9gnGxFkObqGzZhkppixeUZJKCkvkh6D/NHQDCMvd2Xr/qKGVZmu8UVhUVKhMAkMjrJsvApC1njh1lAEvCVpxbnp/9gihrdIkJkq5CbmtgJ0FrkvZJAuEvSDgAXsDlo0yuYTeUGLPiKK/PDIkBvdKz5V9LnXONhE3S0wAyWsZ6DH4byzix1qTGbiF/jKG8+d8Z9DxGmGZkaFr1AHg7I4k1z56fzyA8bszi/Stjue3WqvKj2soc2A2Q3DMAG0D1/0wpjXq9GgmZFh3i3nr8uPmUjxf9iC1rGrqjwQCkEepoDMkubaM9OesCeL072RgexKMQbwG//7v12t+PAOFLOubotRv1PqYGomtMh96pwkYu39UzFp2/xJdfiJAA7+N3rE5mrSLdcOpHeDKB0niOAkQJjkS3Ng87oZ2JkQA2SuYtgbVxKNuFUyKR5BC/w5b+tTdrjZ3vorKqXONjALf3MaX3o8k0pjJP+WqTSRFSZclR3+HxgQFWR/nVsxkALnaTp3xOueKGMNJ7PFFto6OTmjxHQK+W81/FSWiJ4gCxEkpq46I/jpDAXXlFmF7yizDTNXjuzMWUy0PnzaL2AMWfvpt2irB2TB1oMUrIYrTWUnTybQnPMljYSp6Nki8AIfqqsW67pqYKt5Vhmp65Ea5yShYwpQOevtni1RO5KAACN0MFgRbEnSJmFG+4FIHrZnULsa2rsUbwBLRVbbxCAMLNxf38emJo5k8WRCcdv4tyWiJbKnwLi+DBppLzPzEABC8Nzlo0tMRU3xXGhzRWsY3actgMedwGF1qhE/jKcwCr+XhAwXF5djPKZRKEPvAAqEhRLtyj2/oDczf8EsTQAN5jBGv4SbGoIVIT02Km0ON+azpZdP3Gq7zrVxwqxqYAJcWlHWps2EYFX9jd5HlKqmUdUwoI0NpwwS76jaI2GgBfg3wD/1pHSx3zA5AlcnJi9Ia4LV/CmaUNrHMP24dZAI58/ZgGs48j5KWxf7g2mQLUZxEsPGW3KVL5dUxY3gUAz2xGXYc5HBXx2dlbsqYmLOt5vOa542qBKYN+z3r75AAEzHGhR2ZXrQWw95bUi1b6HI9Jd1FAwNcqxPpSbBtqAItFDwBRZ/ujXEzPD/qi0v6EV6ba0d+ZwLlvr09ZzXAA9eDTK8LV67qJGq1iUIGFUnM7opwcjtRrlJ8HaPu3KgA41f8tCKj8VItHwQPWCO9hWofpnaUaroARdxDyh7EOAGhaurkIbi4LHQaWtPySZyMx42/UF6dz/lS5qpSlgqoAZR069DpvBdmc54KvkX+Epsy0jDRScyLoiT1ibOCn2AD8xv6swlrhZKt1uYU6oS3rr/+OR18/rSBDPCEacadBABZ72f5OYY2tuirAtpsN01o1KfS5Y+T3EXb3uaeFpDgApOYbAznQVDs5oCa24qJRqPHFw3iZlmZJ/tL+IwMwnwCEdtSvkpVFGunSw3fZHAzQ/0Hs2cx3x2rLfQxf/1YjAFDMAB/XzMRnCoTWrNpeJZnaAdd9XsLuKkTU6dOM/hkAW7FqgGn6Pghumzsu/Cwa2QC74bAGmViY/eg1rPULIgCjEs01cusKMW3/nmc5MaKzgXLBK+ZBMOK4vFxnA1rgAF1b4hLR1Tf9unvaW+6RE2RtlfbPFRXJ0CM5kcNdGScAP7/YgGdsvsNu9eDvpGl1N5yHojOOd5o3qjbalAJDjgC2fR5Tae7DwLkbaM351E3fm7pJcGF1e9jU1aL56uyqAKEXRb0NMFhQUlMZUETKzGFWTeqK8gmYI97S/Ok+Wg4ApAmnx5vxmeiG/9GljIsfJN+3WZA8U428YFh+n83RygBrtnzXynIbWhPOVEJ53cfMJgiymr2R5jZqAwk0/Hb3APIeqZy/+x4V42iKJS/QDJkcaf0PJ2GbwRlGjnZ37IQAy+evamIs2SnIg91Z5IcZumn6jU6mxlaBCQiRkzh0uAAJMq+jJwFpZJw1EjZ7xYqptOuDP0Q6oz8eB96NOt0mAKrQ6f2EL/ecnpu/4xGPm6Mx7bc4uffFz8uVTkdnjwQAKTcyWupJu4SBymMInIbG5VAbIO+w+YqIM+yyhX/uZwBo73TLjRum9rBWUJWLQIm+3mWIVVI08WxecM6sfJtsAL/fdkw6tKApXlkLuix+WQiw8BqmNjLQNaedRcl7IxUAtLa2zWN4J3ECUTREAmIw8Wb3c6vp5Bs2XPfvKYkiJwCR8iFHFnbCXX3HaBDqKI2/MzYZ/jUe1jPjxU0Ki6puAIlbIfdHQ7tGeWE8AGTSUO64mNbKRqr/54LvgR4x8nUAQq8CO4+VdPDFLNqy0G78XPgK7N72KCONgdNLhSmRdQBGaM2Ho6tsIXHFJu641dxSCwHNLM7YVc9+BlIejqB8AAms1NwJFgdJ4njCEEchv8ACJzyqV2JEdNKRhRYkmz0ANbJKxbTYJ6bLyMEOdC21n8RiQbvvYI/KlwlvbrU82gAV2Uz8gb7c6xBNB/TsdlK70wuo9cXalsZOlG3kftXUAAw5+ZHog66/7zbjviYXwgVu+1uyLUJ8HWFDAcIKeyQANpwRO5qNpZfOM6bKwplx//rarvprqyolI/S6Xe4qqwBQBi8L0YiENS980dtSLBlJI+eWBAOt+nG/St9qQzUhAOq72ry0igCi6DDRowCbV7S3njvx/qPI6hr/F/3pFfMAQpYQZod4rpheqXg9gdQZwv0k8/h0XjKcUZ7j1MU6pAD6fA0n0mbAe17zhHIjv8EpGVuNhPxmIW30wamXBi9gAPwGNdKpFAat+FyNyijn0ECsi+PC2STcbwZ1AukqEhYAxwWDIxxdSTb60O4vhg4uxkMvCh13dzgTdFzOkWNRmwBtCqqudS/2KakvjJIr7qGkjNDVv30YWK2SPBK2Wq8VADaJLMslOJM/oQ9PzI0UJ12Fht37Ui7EfCPNAAwsFdcAfRziORIxUK09LLBTJOHUuianmpVlvrOOt4GBvMuSSQDDevjoVf890iTzTRq/zbN1jtcFMlqrM2ZSy13nn6gKALrreaoyboB4ytne/p9o4T5wIQWDeo5RdfMxTnV/ByAA0KAOsNWmhirzbqtH1Nfh1keJsixMUVimgd0khXkbpgDhI1CSfQFlJWmCB6jOTwkGmsyLfFAmZpRvJVTAkGMxAN3+0583IQPOZFjp+Hvk6632dLHoVKxQiJxP7jbfUf8A1eR/Pysf+2/AIUeaLru9nJUjyVjaoZ+/hW3n4Wl+rgCfuaomly50L4LWb7Rew/dZEbjnuswASX2OCHPrvXymAIE6YohRHjuKOQF/af7NZzaEICxGT+id8fbbVn6o4BIAXfMhRfbnZ0VU/q0P3Ymcy70PyeFcB/1fFbrVYShkagCj1B3/v34aQqQm5bkXGCU4DtAHd2nFgYOXISNbpjidAKkwYB1YOIB7I4LaYYHQQbF/BKUzZZV/yOgC47tONXYAHnmQpRp6M23JXIAoM731GjJwcAUTdphs3j+V5Rss0AAdoIgxezCX4uzjLWU4v4f6wk4HHNYFdMi31+SaJF0TAP1q+xLJjlqvnfiUxrvGPJd9yL603hO2UsjdRgz5VxIAlNfNu3nGN6W+YnKfi9yQeDbzQGFZQlXxOdbjy8LTUgAImGlYqP9K+48Z1339vmTIlGVP7gr7smwwGK+O+ouyALj/XZFuDR2lnzN/TR77Er5XxmYp8euSoRVIhgogtvQAsCrAdjUmdLQMUmRcG0X4UuxXie1BN31Krl3kzKPupgACiHLVoXZg0qPTtH+BE0mlhMsuyHFGVFiqQISWpWKxADMSKRezcd7C+qlszSIreATD1yIK1rGLU4zq4FK6V9kAYqiacgFXbtsc7Rvg+Xxl/7bB+V5aSZ+EjKzPTlv9KgDM9PmR9kjC00GUHUvGpOjNmUrHUB4gcC38mcxd4RSWADk8ZbNCqO0vlwUgZ91qjr0hXthUxV2VF7VfKkgEnhAADUL1RUT9o1/eZ7kQ+/nqPEgQIgnn8drNT6qCz53hywDSvvMxUZ9EA2/RoZ/vdF5y9Wqn08Wju25eI1bcpvAcAO7EyaEckMBhiKjYeYbM9WtjNSX0jBsuFFaFBOa619UAX3hEA9ov2UmnZ3iaX/DXIJBVQrAU+dc7i6EW11TJoABg1D/4KY+F0DaMVAGOIDSQlUYcTUMMUdikJdZgclTJACAAbeJQ35ozWtD1NWgajN23czKT2HIPXCqZw0vx+l8AmmxKzO6FkW/rEWdD88SLFVXhVLGLbvXPcjr2iwNgVgAGOMnsynKfjTqm05w6ZCkFJ3ZUJ/mZcNi6Xw7pCw6QAJ+fD386zXdBFzcbSQmN2Q1BoHif4vi5NqxfIY1fb04ATMbhwbRIgK5UexPaPsQ8YSsZuoo+BQ7w0+Dvlt8cYgC0Hg62RfbNJijDtQzZlRU1a43SsmA+0NED+H1Zd374AEJkFFzzqj1ThWEVksRITKf3awmx0a5UTELYW2uOU48A3oC5gyEstIZ81VXpLkogUgJU7xFmjw1d4wSteWJTQgCQvSNKc4GQ8ZKSuhTtROPQLsW7ouwwZyn5S23PfkS8AIIT/rkwSRcrgVXOOD7MxbWGzPq5ehg0OSFTzVMFcsYAzLgpd5JBsWJ+U+sW+lxykq9FmpuqsVfn1/eFO/zqqQB/z9F1B46xCZoKPVnAbTnDD+b7Dveeoa5CMdmcXn8QAPEA0KfP49nLeyBthMzcxq7lpuktcUWITLCTi9Cvjt4Ar2lvFKjnmgwOEWBydl0XLXeFPMSYwQHTPGiipu3JagDosFv31i+E77SdUk+dl1NYmwJ6v0X/qB8Y3hP8OsMXAG4FME7TpN13p65vhHTvmqq+HcRAVrdW2XWjfnxD2vQAjL6aHoc+4V9M5B/fqtERJxb2iUozQbzpjeX0ewEOXQB/MBOhsO0Hm2AuJAv4RWwJxNzl6zZkXwSHW+InBqRoAPe1vpeqKMrccEwc+ZC41q1+j9bA6NGL1Z4AxjnQe34AtsRV/7dradxRSLL1CZenEAaTqyRusXCDtZKgw6d9IABgPb3d4uvAuTwUtOd0YHp1eOSkUBdLRekaSuXljA5YAI4iN3wotfRfc15mJoNb/CW3k9N1c6rcWXLrOSvFZXYAAqO9b2zjW1UXPuIRRAIHS6YEloj5TXP5ZJoNHTKHNwDEt1F2Th7vsbwUIQicxaTHxjkSyZ/QGeP1ss01lT9yALuAgsFIG6NktQMTuXqzg+GVEIxMVD91N+Ggh0JOaWEA/7UFZNpBCypMORBmIVIvzu75b1OwIh8z2yOMupp6HAA53qvO2NprgWbovJmGbOB3f1Hhvhy6cRi94Pw5jjoJAHAkabJd4pEgGDa6kYljimnldNDtvzTB1OICVVWAB/kAyTLFZ6B8BxVg18jl73mNMYpQyGP6fQHG3GciRzNsNwCvnG0IcDxAk3TI/z0+ImI2JZgvR6CmPsuB0NtEVfODAMFDUALlx++PqfCpeZyPp9E+uAWur3k7+Sl5CIBUfKYASaPCk2eM7ZvHkLGcmjoA2xceScbfHzit1oWlFNjNVQANvOI+G/UOJenTCgFiu0dUkb9bbG1iqpcRBps1IDtAAKZtB08zKlx8UMbo+akgPw1W3gpGOXGRKKssh/C0nU4A66NbwErcU6M9rUHnXzcWksnGEVMJU54cdgfPkbAt4wDzuL4R67Fyc1PV5ds9+vgBp+a5sktxj/pRltIumGGNAIFOUhbU/wMMitv7VDwZdMMar9sMuY0VOwTLAYK7Vg4AH8nCmS9HpifRC8dFAscA8P/dK2xf3nfXGAnnfNLA3QANBM0RpSAJ4cRwvInT/GLuUxBeSwH0plWMlOIXmUcIAMy3GtVyLqWln7jnC+J9CusYnRYPRXoQU+2agBlwnRQAnX0wGfhorrs7LJpK3qdSuZSffgBy+snXkjk/tX5nawChotQgsTtV8K6CcyK/FROvHqyIEVJXTmuABC9CoYxEAO99nrq7RCk9QH5Mg1kj2VcDorsKK1FtrQdy8VRgHCIAUb/OOV9gZ7lOGshZpHdCElYypd/DL+WtWHgU89zlSAAGCtYiBwAtRCCAqthJfVb7jhuqX/6wq47zMV2vvNtkACFwTA/ozXuOh4JL3MntvVV7Nq6rAm+2+JGEs6trL0kAlhjS2tX7C38Ek8YilDTSK1jlIQrNJ4wiJpjOO6bHSQD8Xa7POqEZAgnzgaU3+qzfrqLuv9Uaa5uqD6S4dwBIAMEPDnx0WFa2uPJZxCEKkOING9ZjncKWpwaGFvPB6j4AyLB5g3ZCG08MX0C2KetTfY88pe6MNBcxDJTPTCjPjQB6vzYXdeNDPt3cOrxchP2t3kJwhzjF31trK072dl/ZAEeOMzeaMBlEwol/4WI5/z0x0VdurUaMpdlcQMdUalYAVQIwEMCMHHZNbLl8pMkAmDewDwKQHuD9l/3AAxcdCABYcircanAC7/tUK5H4fKbYoOO3giiOwK2TEK276K6hAHxTMUJ9EvwRX4CcFoxxu5BaLbs7miP+3eDTqUhonKkAENtiDs1N4hj0oHQhS07LFlY/u/X99Vx5wRj39ryubwAYp/7HUkPsPxUM8Riuwz45kxcLoX6/DAi4KSWZk7+7APP1bIpcGt7Vlxl7RUiN1u8qEpIt57B6uXTTf9fI3/wAi1xAEXCQVylXFhgmJRShQsto0MoV+c1mMg9lcOwMCgChRdtne+Y2vHIHx//yCrwPp//j8CNERwW2ca7CgOKZAH375V+xYGkNbk8iIupgnOpw7g/sTcvCBIzVEf6F4tYAtcOPwtSFuCfg2QgyScevDPuv+7Kvr+V2Mb/Nnp5hYwBhXbfnxnmGrMjHYps2jGaPy6KIE3aLb8oJSFQ5+3/pAIymkMqQrxYwAtImzJZfUVrfMgRwYdaoWm1KHG8CiRwAhjDg1Hg49JI8622u2SWXR99EUImxBzdf8nPTf+oIlgCcUfRbRae07zOfZ+1yIkUl4AeX2erY9RoUESPyV/+tAMbAB37NhkglV7mwX/azi+/4nqevbQD3H9XP/voqA+gAghAU7wC8X9WuJDtaSXFB2xYjcRz7x/fI/scwj4TJwQDN87QT+8VzgG2tZ7CpAMBflWuifWi/yyFOgjAF+anAAG+3CwJEn9GSnPr7ZvIAsei9mNER0cV/71F6Q5JgiC8Au/Wa0AlN8dTedJ2BL7apxiHKD+a+NoqYeS0ncg4bAwASq/T7mzXwKb/8ydhOqEebydaFkysGDhOXc7mcGUy3AFHag2tEAOCHWWugMnFujuB1RI0M9uEmkKXMb4r6a+IADhvuULgFv4rpqVmOkRfoBTnG336NyNQPMJq2r7DrWwBgwUR+h/jBEDoWR+gyN5ayFb4yFVgZOv325svx90ZmAG8poNy8lH8M/V/6nye4TvF7UlLm09/EN9Q7Nsz77o8ANHIyxCFW8eJX4JcdzK7zJQnTTv73mwyOeLeqV7WjjAAWqwrK6/iU4wDEo5D0m1cUF0OAhEM2scGaKk4nAJVOAKYvx+X6T4tGXP3ImmtJZ4U3MD3Zr3qZrflHHWEIKdgAXZVelLzW4BIsyI1rwZfkUFS6CTb0l97lK4nFklYi5gA+fGtSuV79kZ4OS6SZ669xy+7tHaKQwEZLQK7XWBxhAMICXJWRd+tBPYhh9+kgkxUrWDKj87D0KDhoQFbg4IQA24CtA+YY2kGox3WxhizxKmrYsoDOnqzIPnutgHjZ+wCZotL/zUBNjR9j5L+/ydyAOwEiSMTxnSNQ67C85jCAAPrDD8tIDyIfz2qy3JTHa9IM5rIcFt6ya5vFQ1GORd4AYm6/LAxbTEgCIETLyFVlq1kzWN9DmHxOEmCEj6jP+QBZvuq6sOLZr0JItpBlW/3YFlkxfmSSe5de+qR/KaeWAJM3WfJzdJJyNAQk2DL38rg2OBrOEYTVN9FOw8FzT1gAHUJHLHrxA9o+gfzQSEhw3E+lNrWKaMAlNrC3cnfPKAC4xWoY1TKlIfUnUYyFNfSkXVwYoXitTjfylmqyT5M7ABIbP8N9YKYbCxGvfKYJ0n9Ih4ammjQfxi3MPztp97EA2ZMUXUtH/NbeS+0byo8PG/l3pl3keT5KrRjxZbrD/QB61skjyruBRl8gz64dmvig0DI/j6n1sYDLHCiAJt46ALL4RrEULISomd5R4WZXA0Hz1YQigs1bwBho+UNuOycAbDEeQ/U8qYvMf05kBcxe8iQw1LHv7WYYaPSt/OwMAQBstA/kxLubGOa0jfpr+6V8u/UiU797eixpohwDCtWUABEr0Q31xu8z+P7zT5IY6P48wMyawVGVQL6tVQoEW7IAra9202oBi1eS4wqbz3V74fMBfOq9x/kAUQ+otYaQWQAJGzJMOuTCbdJbcPTsG7S+MDS2fBzOj3CYFVKAVXcLADRG/2bwLaraxi9q0v4Mug4IddsZNRsi/ngtHy07WNAA2ZKna3J7oGXfKoxVvaP8bqlFKoFQlkO3NZwmNF9xTQC4bfOtRJm9THLMQFx0xeK4F6Oebx6oo4rbC8Vl855sAKf1suW1BEakRkjbABHrxV8fhJFy0nyUZ74Fw4srjfEAWWlp80PQJn2PKmWhKzjcHPU3wN3xdK/dT1M/6Tk/dQAt6AT60HrcY9bQBplGEE2nwBQxPpcwomrPD4rgttGNAFRwzxcIfSMvrDyDCKEQpMXqBXfJFukwoI+Mxk+mPu0AC5H8cjNxlDkkkivSqgaxdw3CbfQ8yVAcvH5vSVHvqAAddBTjQYG3kHg2SYhHt+wCtiWWnIXB+WdD75/E6tO3ABjDRimyXjIXIXAwKD/nzWwahhgWq88g+nJWgkriUnAALaUOE+TPYXrqm2M+HWzdXBxsnBYGbJx5twz89CJvXQBM+92jHixpnN8FqgEeuv0K69NjXkFDPfa90vBEV7ByALkBuNLtXQApK2kmlQFYpiLazs/HVRT8+9axSiIVbpQA9vJ9IzP/ZZ/mkyK8ZC/mNe63322bsNZqKIjPjLX41gCaf4+mjINiPa91kvFvHbWQcMJ1vRDKdOZA1RabEbyQAMJAPXEr06h/ZckLoppno2FXQWqL90/HrYUMPy1rOlEAHJijJa9M55fwOvqiKcIOQeHf+J9qvnyONBxB4+gGugB5unUu7HH2iDI9Ee/EH35QlgPZKKXW+8NSiirlS1kGAPxnKXXyDq+yDFV77sxQv+ibNq+teiGUnn49fGujILgAxbUeutpcCAgATpPUrat66GEtTjMYA6uzGHA/SKKwggCshWFlqkfsN3gZ5GSloEcLYuiYZK5chc/T7vcauREMAEqyO8HemanVtqRRnbnN/z5CQhY0cdFyaKVIwTIXJzUAfqdlyBTOBw5tU3kW2dZiw2Dj5iRsg9tVUWgSh/C70gB8b+2a6IHUw/V0a/94sQGHkgKW30yNAjMrklIDhbimAKTKn0vf0m0o2Ig7kJ4aoMGixq+GH8HlN1cT56FPpwQArmhYRfO5cldJE2DUEQ0RfsdfastbUIV1IVcE4Bm2RgB6hNqOAj+hRQdOm+Q3T2Szla+eJ00JZPFg1HLGGD9uAI3y8xP/UZThbED6NFEVQEX8+pT3YMkeGAZOK2Zvon0AVNJfadgeRqXgknrTG70mlN/l7q4RxoXeLcJV8Au4fQANRRhjEbtZgKfqjYrIshMoUICve3lepztO3sA30SIyAP1qOJSfoF0cC8d8eJlFkw3pobW2ZNYz2MuIldPuDWUA1SUqCDAwkxY2cxvkKhezp0F99xIBvbDonVR04DjKWQBGcUDGQqeLofcV6G22Igxvr0Q+MCMMUPLJ5D+E+AkXADvXvsVvHACq1CJTEi9pnPakFLDQy1Sa12YOUSXoD2oA3bNeh01QIMWjlvK/W62CP/bgSHQ3TW6/aN/q0cSwlQCFMvqZeol3odOH9qzKxWvstj4s7dJpy8VBphSGgUp/AO00RvtUiVWlV3lcKAe+0UQU8SsK2JuyxCnSYzHVK7AAIa9U5/f8suLgj55vO++GMu5WttYw7GllolaQzbpJLABy+AsIdpbYU6Srnf3A78aoGiII8CstqQjkewQJBdE8ACTxXSBWQBtNZahmgi3668kZIFmGgk/vVeOg+NAy1L0AGxPN1impmKBhAaL9SK+UgNUHa7KNdGnNy0nTcuIevgCVx3nv1N6760DvcZGiJtZYnZHcBZbDLwRW7FK1wV7CAHn0iaQ1gFoOKWFor1LhWZ+ROaJNsANTlxwwFuTSCosA8vYGVWUv9y+NOU3JWCfhcrTO00UtAelfy56497ffzgDFYhOr39bdrZPRjV6NSNWn0oizbGx8RqRPjpoahSmtAHNM59EgLEBFqcICEu2pCT10hoJn4jxsc3CwLdwCHCwA67/rNdoxiCDiPYUtxu2Tmqw0IzSgqRw4ipokIPeBlwBUxKHFzXM1LoaoA6FWE1lgzeHny02EpP7yQaPOa2miAPPYdYVGkFCKkLXQi0MbN3pt25+HS5PeNDm2Mao/134A+aN/uMzky+pP9dJOqBbdjIktFvVLbMOtnffWb1EsYACHnXClFJ92b4MulwL4gXiugPiXRA89I2/NvvOQAVYJAKwPq8oUysW0kEqDfyBWKo3QxpZLH7hyQnMLEwrfpv8AJ15o5oig088lJe26OicbOe6PZoD9zYz4+H/oH7o5sgD8IPfPjwI4eENFIlUaIDI8oN0Sx6HiqtLqp+7RCWeUAJiO9Ro/eKFtS/0GJx5yC15RFI5TILT6xH2sZSy50UAA38HCa/LhTSFWi0XDY9rCRE0g6CY4xl7iyxGHgisI+wAKpThODel+wkDJV1UDdHrcm4GdF/LGlUhIlcRGPT5SALCvZLMghMThh5PU0xo1EdeQS73RkEcQIF8yVO3C03IASMCe4i72lHfjEftJFE5AxkaJVQ7Tp9xqMjECQEidrwCFvC39gdUQXwKldowhQJK3SC2k4TGl2lCfOEWc+4K1ALHQurqmQHvo7FpqFto+uOpF3A04kl584usXkNst/kcAS6SLdzWG0TOvD/YghALs9nAJN7TGzf+xmLzgCQFeyQDhoDM9q9IypdQowOYLngjd0aHNFeafot7DYoIjDbbgANtPyRApA4KBurYKAsM0Dv3QRFwG0kbV3SYrNpTSC0UAug6S1bF4rJwI/5X3Il9XikxpYkK/yezTZk6dkw5D8ABszin4rOfhwO9IXOD2gYoHvWBlXOZlk6oT3NPquz4kAGFs3KsRBoExWgiJclWeAjok2FVBdA3ASwaj4DrAx2MADnyYkgBbmEzPw9JHD4qNTacadtjfXS1s+v+GnUECbQDZhjWJnkw5zLdfY5cUArvhCxbMuWRoS/uuOuJwcB3JAOOD/STDC2cTiL/8ZIJsawJQ1OC0gQhxuvSPYTbmNXkAp+0ZGcEZdpAvt8XheFUHzUcAwCPxGC9bW/1s4cWY4wAtew3l///R68NjPG2vnNQ0qglOPi1F9pblxda6b6VJAErrBb7heR89vSPYs1/9730H17b3hS3Q/kdJ203U2M0AOMJ0TDvIs/ii+AqyvxvkONu8JzYSRgGvci0kvZxapgAxzh0JaJM4w3sKXI/K5uAKrajUUHEP4S1x3hMA9Fm7ALm6JA6KYnZq8Ig3gGEZBdR3vzGafPIAYeqSo00Ho9wAeDogdkVoZLo3+0EmyaffoclIVdpbGmWbn8ftuqtV6AD2XwmNeSLI2BUvW0q1v/M3OINdX0zjFEUCMH/IMbayAJmbbncpCWbyMT7JJIGSTynMb50A0HSMKsU/Kids8NUA3BpX+YdE1h+DyWnGrq0iz2jRzFVc7tn1Dfd9fCLCMwCY6Pdrw9s/NBTxSdBmUvZfER6zh02ygJT7Nx+NaOR2AKZakDpzNznvIcXWX5FIgxDka0K736z9xoUn2CJKfGYACTIJM5uEzfDF9D9C53gY6A8ZDQeulCe7LLZLYQVLBgDEd165Zyty5n8lHPJ7j2dCw16XVAXPMTEVGgsW6uILAMcYbdnW/EWgdI7Jj0ge/TZvUs2dnXt6hyeg0ybxDIgAVyJeke5zt8acm5yzvjK8rfzdPFp9mwvRAzCRMk9h0gDE6FDxywh9lkfW11wL9A9B0grD2UKFNpXoS4YpLv9RAC/2iXymOMKi0zXbGExHpsb7vnYcXmVL9uLbvAlgw7cApNlTt9OyBZt2SdvMASACLKA1xLUA5q221Cg+dMkmzgADgis91F52G5cFuzRUpDGrV4JQyBjvj22yUDudaLBfAAaShIpeQdEn20jOb3eyl9iQTf0Tp/hekPUd/py67zAASbP9pVz7NBhtIiWT6peZGA7ps7ehInhDqMsig7j7MQA/P4TOSDGDUIYJmfPWZeuWS3KTXXoD6kUqYAtLhHuQAN/FGfZojwFhJFfQrkW+G64TB5aW0upmd2XbgjOw0SUAo2APfs9soJLLuWJHObyKK+R2p9auGq5cGbBdCktMJwCv1obS97SzZksnnM4ce3UnHUVFT+kd/lBZp1gMcRwfACUl8GlZCNB6gPesYK8oUJmcbXkpZKtPC8PgjYfHQ5IAv6BBYrsdkj+xlQk1XMs7S7D9F9e4LgqOe5I4VmtRiwA+2ugunp/OsWnnNHy2WhAb2/Z82FAnM7oe+nFKnGD0AJiZIZXnXuxeRTmOGSnaLti7DOJVxhVoyXmTlzEnZScAJvm2+Q6LNGH3Y1E0JNfNwmmoQeEZ6VV90fv/6M28pwDEILbdgB/K3mzzKAfgKstNtVF98u1GlzvcV5jqk1XUAOHVXLmRA6BRmTe4UoG7VuhRZGYDEIRps7x2DHExO88AzOnDVI7TcmW3kd7+ErolS44KcvtxL1n1pc6geafn+gCmbNIqygRefE/UNnxiBdvZJhRIrJu7m3Yl+nwVKNx6AOzBDreCV+W7IUw+aM+XeX7DxE+7uEUoo0Y9D16dzCAAxd6YZiAFCTsUmXgtthIasCrK7GYMkkc3CrDgu8TtMwAz7Uqwoep3tecgkiwDMsfHUdNoIhlTpE9M1UaLDtiCAMUKoooDarEDjrVFfqg2TXOzKJELyXVjXw/v4WzAiH8AAdCuorYERdgekkeeUpeNYi+qq4f4W8UXQaUXR2OYxQAR7+KPn0RcdB6hF147GgvaTGxIrK2+tjgKwnUelLGtAC6EQ8TmHiko262Onzy2eCTMrTQtzv89deoOFlCGzh4Aa0m4A8KGglUVnrA6pjxzki3iZ9eauvHUkVRk7pb0TgBYTh2oi/PThC1ngasYn2rIjRpbz/nqe36kM5eqylrMAI+lNWkWpUkBhllCDdKcVT7zsGxnqZndQJ6Ebk5335gAzIJLxdGsZeA1E39qaVKSwDq/6mte2yKPsxPPuuxk2wALAB14JQEJjawH76RHZOf0XQLC6r7KwKwm/lXzg5IiACD0Nv/00KBtzPjSso/UEf1VpNhzj1lmyBuZpj3B3YYAMcqzxirVjbJbYfSFxPJI5ZydBYzuPSNjqZBrQQIdugDteKxlC1oNrtj9FIqEHukbh1f8fxJeAqteFHiR+yvLAAqsXpDPHUZDtCSRw9zgdGav7tXSfXEX4n4fr454RKgAgiolqNoe7mPCbezgmxE2bvSxV8QfPck5vFB/8v6slgAC/2cIb1ElQX4duxxVLUaEiLjTxChXVgQ5gtaTG1e0ANj/KRTBkzLF6bli6udNi3ViKCs9vpQS9iOk8PA7Kv0AGqEI0tv9kx7pqslFcIYIhhTLX05+WbsenQOMwEQtCAAfOyvknVSXzHte1IzDdyRSJoEDraTefl59VoLbKUvsAE7okiRNH9QceSZ0s5xpQbgjrFfoR4peSalKikcMrXgAbGsmYWv0pKpbaa5kgK85VcCfBTtG2wYBc6K6vI8uCQDrLxdjZsCtagjx6TgaO+kVU0pkHhq2oOR8adnS7yvPANfiGRBn1/31UJyqpFswNW+8ytgCOYPDPPwqRJIma1cA673ga6WZ5S///OO9s/Cs8D0qjxuj5+DfTLuUdtM87QC7zlC6N6SpJetBQKkvs17fxifKF1rQxKNeD9kTxlkhAJGqDtDx3Jm7leYrPKrszNe5c2MmWSMDQyKpkjovpCUA09HhKe7iRZXLL6vtXzbKlCud6ruH4bUBEPebD/+qPgBwO7pWPJ6uqRZ+lpuQMcS0lUmcGo4aKwez3Xt9ELoDANWpTKJ1eZlaeEk9GmIfCY4df1jMCNC45HDHa/hNGr8An4hupKjwjI6odF7tjDcXNC+swG7hEyfoQWP24hUMqQCs6nQaYR9wFKBSlgzBBrqxDc4bcZ/seA4LnF8uAzdtAKKf9YcrljkZF14VAbMjW2eq+Tb20IxNauCraVZc3pwA+BUCMrbD3wyXtlvTt/DePpcNCekR2sKFbQP9v05zpQAqbmKSJKBmwpXASbumvV1MVNsL1y3Iv0/qra6HGntwAFVOltrQysfQbfjgdUmDiH6PGxLqQFGWwU8h9uGtf08AC2GyF6BXz92FJ43GqtKKTbC+t4eV6GM0h4tedj5WtgCfBo7fzYSuoLuzwKHlN52xk8Ii5tctiyTxudS0n2TMACqplfIfG/FsXbhwAdq7ymSWkPnhUd8SylgXk6ZGpSQAxMcc5ce9BaMAFylNY2Dl/yto5JmD55FYcUfkSCywlQB1vu8tsHRwuECxkSLz0UW/ta6x/YsHaAVaJPw1304lAHOKjt44FeSwT+fe0yJcwFfC/d52XsmYNVMW9xAkMW4AyUCWDcKck0OWG/dqcaUGm9bDgAhUOcNU9kfVd4QlaACdq29ORlttZsMxqBCP+isv32+5qZNI/sDa/UTUb72ZANAArYihXPgOnpMXgCEEZvHhUCfl1HttT+L5DYZwJycA1THoZYZmac3RT+1Q0PJkPGqgwDRn1W/38EmEZ+tdrQARmUFqOplBxlr1isg2AknVEyS7w8MyvGFwxnvJ9KuoAI9IxykjwU5bEvh+a08V1OqqViKo7N4erxlaMAsufysAjxnsillD+eO16RjFTh8ujBgDUwx/PrPk0wV5XX3INAA1CSKWkU7+fwimMtBCatQ0/al0g6MPmPhhbNlGo7j8ALui1RonyUqe9Ass+oqcmMUTuRkaRxewZgPlLFtpcRIAveG9l1vaZVC/up1otSlPYcqPaVLz2j9D9ZaX9uTBawA+fo8WLyIo7HREN7vyjgqkb5KhoEAO0N46nBnC7e6dAH6VZ8S+ZicgwHcFZT210t2E+AWaK0DplBJE7AGfM7MARb50Hgwf2KntPdyu4LZG8BMGN/kiF0NBvQqw4Iii/ACYCZpa/uYK3OVc2Nz0qAFiNsas6EXgVF/naf6pZrEMALdfPQ9GH5tljLaDv//iEWOyWk/ycqCA/srBv8ZnEQYArunFjzK/kCEYW50m5r3L2aZsAT276ZILDKdQ9AyOrADqbO996QXx2buJKZPOnDPW4hpqnLyyY0ZaVSjDHShjAO01frcFMKHPM///9nVLr5Yv2ELdUBnM3LzUPd/KeFcAQ01QCSVJGcfAkXu8YhKMpIdHyhUSHFWdcShk/3HFBQDmNcL18SJ11BJeA2LH25y6lK9q+alHA1rWJ739AyyMAFcZBp/jFzkfFUhK9WI2ydq0IxPUDgEagWyc1vz/mWEAN54Xr7+UIAHuv3gkZp2z82lBGcfJmp/BvgQ/9CtTcQCD+O3ZiUbJ0542A2OV5yR0Jxh0JH9ob1oFtbzyJp++AAAzS9qzORSSVk9P1u9popMX+suK1yOCqHPc9B+m2JUA6xXjDL+gjBmsgffzQHQkgapHj4/FgfgVtzi7WMr9LQAH46y6nLN3Ipsw12SdCPMNAWP0ncyuZ034yjCPlB7gAEWD/EMu+GTJCQn5hZ9zBM6IxDrKlFqgjlDFuVtRm2AAIajL0QHkoZRefKUAKNOSBqvr6gJJriWWvw9uLFZuvAA3fN6ULUAcP3R2uZIQ7q0PXiGSPIras+/E/GEIfH9EAKZmhB0yn0UrTKv8QsbSRGI99stb+Asv3komExKnrt4App1IxwQ2j6XaeRJxpQWfFQTc8S/5vGoZVZgl94/n3wAe98cJTK8JG/KoszWSolR7TAIsIEzCSKKIs1Rx4xO3AFIXbOCBy3kIT6O0ZT1kZiMeotAbEhSrJOMYgU+kNPQA+HyVbJ15iSssxJ+/xBTNmoS4qDBX1q+AG2Gs7gnyJQAICxIofO6aZUVd8j5MonD8L3SL8cYFjDjWsbExOUdkACnlGH9Qg/fa1qs1VtkhM0YTvq8vu/4EJLS04YbIp+gAX1qQ8wUp3D5YMBUUpdrWD0b/y1c355If5FJCBjsgbQAt+rGwMl95QbrxPAtffCsKT3tbEmumFQGxj0VE7mMfAJ63+L6+W9hV6PfFWlEALFQddO/6foK6AMS+72AP5CIA1vlhh9ZXx8v9Vk/ULia1bWc4afVawjIs8fYkKCygTAASQMNf/kzwFY+xPgLd2KrbS6Xkdq76K9IkJLWfJQveAF7rbbOFOOM2p3SE1pq1A5JzjCfqsZRdPaWRGgpNBrQA3mpRiMTHJU8BIGdguXEnXNvzqCcqsCEuBJl61obXGwC5I7sq/HItB+4Qoa/el0s7egtEyJlpHUGIk4wf2huRAEUu4SB57hdLK6xT/QQ16Pz5MXN0QCDQiAST+qic7NUAGJhIyUyk0+OHMJeVGUhgjNmGJ4+GbBq4qwX7xxXkLwCxRauGUki2gUANJMXO8dSyjxQ68cMEDJ8jLkOotkQtAO4RQiIGFSwmXClu1uWehBOlL1vQPcwzfw9K9HEBtpEA9hiklznaaD2pkbM9GfkuF0EdDkuge0jxaS8o8/QhjQDvngtX/twQZVho2gEvONj3b8Z8oMp7UJJjYlZVjuUAAB4FSg8DUuk0AfRWNekz0HNWfTIwyVjlHNFjnpJv8RIA57XbQGM03ZlHLcFnGzeSLU8DYy+uZXCO7nAOvTJnHQANGX94BW3W4Siz8aOgn60XGqiHoRiy28IZcGEGVGYdAMSY1awanYBK/R0ADQv6KZscpRyQ778V1fSVm518kukAOhWFpzcNuhvBB1x2neU8+EVTBqCMnBcY9TXN551vuQBE8FirGRUHm49q5pdQfD0gFTCyC0aSdg4vw20tAPFsAKQzZRYpegFrxKPrnx1AD06ueGwdYJRBDvxm0M175hwAVOZwOxNF/Rvm63A53xeGQUYskQf+aYZDSifwJMGrgACpNBv+gwXbmeeMurM9ektb025jAwzBkBnov6xWHkxEAKpa3n7rij6jCIweMxoKRTREaO83MWJ5hPpPyOaqHaYAhufzqCVotNuX+MeF0z9H96i/CihybyF6xeeIZtGyzgDs3wvRIPXWvhGC8ugiWts/mOSbXXhFJ7iao+iq6XEwAGwtr3xOG7HViF9oMtq5Mvc+ELbv71jSh2uBAPXdktYAQh6PmRfmzrnJjKQE1j9sfHRJpxWFGX7nFB6FkZLICgAVDpKgyPeCNvMjlY+IGFBKvInAcijL0sLMXxIbLRI3ACyTXJnlOj2gtjPGn2ZsYZruK0NNDJNZBuqS5el9bBsA2DqKJH+/1JsTN3fB+ZKR0cz+hFXrfs+bzCvImoGZBACW+MSCrLusFZKEnLAWRo2JJwb97hkCoMGzmZKFgrLJAPKrH6eOFFV7+9x43mu1NTUWQnV0h/wByP2EsMizPEwAWxL3frmXf8fG2KTAd92+bx6/lrfoXOnG4OY4jbMWYAAL01aPQsnWKz+efn1oTXpFbR3yfiHtR1G5K60PWPIoAA5NOxUR3tGUOdik7hksGknZ1EwlXeGKly2jFJabfuIA36/ku8+SN7nMMriZM6GmCAGTvEWsXHZQ5j40Up3ejgD3TibPdQOCOPJMHQqWVUWVINLSpCXWGYboQJFxXG/EANIaxboXZgfkBad0w2iY7Vovchejrm7FDeHMIbZJ72IAgnhutC1DjD5FkYq4/TkEazdGEgsrZ9IagTgx56tN1AChlrXzLx1ufDN4hXBpBWnSmNCOP6sbqR+FvfaJ/ukAAE+FAA8/hvwabo5P5HZG4KYaaD/Ww9uP01gvzz4/gVYA8p8TM8DRYqP13RyosieI2J/J2vT4tdkLQ2VWAaFEQQDwzhsqI9Z2HttOcFEesnSEhNatYTbXUX6ltXVq6TDUAK6VHP4E5lUqSzAZVFADn2rtL6RYptKQVns91K/+eQkAOvkbE/5iG7ratTRDxANtDhAC1bnaOBUW8K16yqiE8QB2tPieHIE/Y2MkIpc/KIkPQziFX/UpBYvLibScaLIxAAG5vSTmWO4nFaeBVPvSz6aWExoXIzKR3y97peA1dHgA4Dwtz41NW9kfS5yn174rHwI17GEvVSovjdOzU62FrQCRzsjuPBflziVeRg2QgTZOSAKKlAeu/uwjwGTk1eXoAOdlech65PhTEvAbEk2O1OcAlrPphfPl9UStp16dM5gAzT444CUUwgHUPGavsTUaKcMqo2Lf7d4G2qp+8ZSqEgDbcCTv7MDJg2wgR/zVJB8e8gfXHPjrkaHrKooEyg8wACdMFv1Op2cY0PFvQLjKmeacOAwkxAZ4IDc1iRPtEfwANTS9421urX1atfRIdyNffTtsNJ5FfS0/uY3n5BUqIADjx84K0AqOZrJW6jgpVTTP6l4hxM971oZcn83MexrzAFichs+QaVXlaSLvejbEd4dozSTrvwLres9adz8EjZUAxy11CpN10dErXFno4Xj1fsC73ete5dKH2hP4KpBRagA1EdGTQMOTvda6m3KNhJSbyfLWUI7H+O5ZKm4zE5cfACBU9/B/bmAemPybA6ux4mrt60g+xXxgDYC+d0jtwl0AWPDBM3oTxr4jlwVsFGEfIscsFVFw8x1Lqx366mI7xwBHUqkPt9FGwg2J9NJ9sLuiZNeYUlK2pe3bUAzcA2RJAHzywdKrRPOHPH0V2lG06z89lJSmju1Wo0LxLAzB3XAAWNUtcTOHCr12XKbGKdzFzjfDrJruwzWrgY/iSRLCwgCRdBVcQxQu3WUfNplmiq1Hs2iz9MXKNDoGebOisAg4AAEx3olaS/ZagYXsc38cCGY+QAij+TdWAT5yfPvGGiAAjTNZjCS3MO3w/ssCJLCHamGWby0U3V1AKez0rzlY3ADD/BDTHRAuw/DgZZ/1C3+r9jWwRV2Tw/98zpklVCOlAFos+xm/bBvjTfrLPJ/i5gY+Wb0UftFy415Tdas0owEAc0u6qgs9bU7s1n1cP5gpwud558RyqCtahy2xd/CQoABx5jK70XDExYIuoxrJK9zsZ//4NTcsWIXqRCFuHZt3AGrs86C72UDrs+OIEZFc1mVOLfTXSayBqnh8l2PuKdEAVp33e+MWZcyScHPLuAaGfCVLl+USyXbsTCb4Bq/sYgCGw6z4fUh9eEyRayrKzusegfNYGqVFJifxaUouNoeJAMDSk73Ak+t6z1ixzAWK+0/BG+nxzDxj05EqKfZYKrgASjqOj+oul5C7htsFTbgYTbq3B7yuKduFbOvjK85B1gBdTA1PBC7HU/1HQR7tIZ4fcdSoDiOt1M35wNwxAOYKAIgI/vQyRNYFu2/aU94vi5V6GAZWZdkYCjlcilEdIfMA/KwSSIqYKHrCwmpln1CbuHLJEuIB35ybD0Rp+oCsNACa5ZQzOvEQwiDwNdWtGfYPo7nolGdAbJGBIOV5NDkPAMnW4V3pPgENWDNFKqyb3sAKL91U+eJ5dWYC5iEV7/gApwYfC1QwLhMESnthkN9mTWoSzlPmr5jOge7PZS/JewAihuPoZ6qRnQOPoPZ8GPudwbxNuVtDM+l2Trml4XpBADU0sbCl1WUIHIWBzXwHnyVXe8Qmm7bGiZXJUnIKKVUAU0DPEFmpFrJNKKfKOypKfsz5LT2rHEKrXapZj5l/rwAQm12BR2h3rxjLCTm0CMvBiyoO4FRFchVqW2fDNRL1AHMIhXDG8/34wcO9C8pxdOSPC5E9wdlurysxOQ1u+k8Aprti60Afn8+wUQ+8D050YohlPfweZw+ytIq2yik5+gAwLEXk6wc7m8hXgDG05JyP5H8eKtKFxdE7hwdIzWFAAPZbYLAnB1hMeJcoGGqHzqniz5cr9DVqSRTgchWapWYAB+S52gjbVFV8FHH9aBDtYu0XvHd7slTm8NDjXtNMbQBiItijDDhcslOtrdCJNaoXzhkQ4SgIvaiNvq0c9CIAAHw0kixXG22z8wg3quLZ9YipoYKI8etpJ/AhKE+Jn+IARQJ5596YK+kjLUfiPjum87CQpEa9ptEvbxtXX66e6QBBf5SRmt2lUh0e5wWHyjhLhB5XPDpV7aP6sNMADIIJAJDln6tODRsflAHUDt8Wn5WobrqXtMH+BOZXRl5xcM4A4weBEnXIZMHqfkOL0tQZf3SHaJTvshxmbu8PDBFE1QCQsyWNwLY6J22paKbebb+rlYe5MedIJzqZYmaHtE0/AA049RCofFVbofYSZxhZVt+N/LOOw9KmHEo+tdrLLZsAnyhMFbolb5039FtSTKeV7ocT4bnTRBjJsoolGIL04gBFV8BWVjnF/Qz532tQEPX0tObTglHsFP0TEqiA8Da0AFSq2QEPF6hjPVP6fp9SBhWRPwW7Sktum7Cie4f7hWQAOS+gMZPX7XO0hEsbXsbqYRRwW9FPbzIbRKtDD2HQYQAyJjs3d8KjsmLGZInj0LxYmklwYo5RkePoUQcnfOd4ALAh+oLT4dTBY6ECG1Y0ZhM2NhzYwKx2N07XtdN9QoMAVClP8P33qqjH6HLzUlwtoBR+r9XfWqKI07WA2hibPQB04VHdkD45kplP7158+GULzakzAKkV52yV/KJ1bh1KAJP2mDKOwjWht4mpxNLR7f9Z33xPNmaHfiKsZPURGkAAa1wf3SNp1NQScVo171VvdmjGl5mGTANFWg6tsDXx7QAHNEpsMBcFj/Kdmj6nIQRnASLvhcZxduMYEtIUP/c5AMwBbyVryJAC+OmvMtsr1pkMj8ib3f6v2jHwP2MjCCEAovJlNfUZDNWNVb0u4FGnWqlJs1RxevfhhdLYslD7QgBBX1dzSgXcveF9ifkoTYt+NparGgQ9ONQuAGo+JVEeAMoryuFdaIPPDu8+LqM00pp742gV1RnomOGqGewls60AhChIdhrVyOoCZHaIWn5YhWqjuVMJ63M72xFYIBSzrwAdq8qkEZfhdgOpC5qR6KKxPD/13xlljF6kbAVSX0cIAPYB2DkmP2MFiLiaKvyUwtK0TWfBipkJUzPMI5kUtegAe24wLG5XtYmWkg9yueGI9JRkx2ZOaiSXhQgxWHJTUgC7iTIGqfo4feVAkqeOwon46yw4UotLhZEle+ltSOlkANA6Oq4UeFISYHBWOaHfde8Yff2ptYQgF6TBZsXtefgAKVy7YzcPjGnALEs8fvVuLcZtx1dbbRXdgpQlmt0FYwCioFR0pPwWiVhDmeFFa2/UZsMUv7wTuqq3ybVY/487AJ+wCikZiUcwopUJg4siUqo+JdfxbAVmOBdz9C/LOLUAJbDPImJlQjyRNF8pjsoFIh0zD8wdFJDxBDcED+YvwQC0lBUMi9UaRm9e4LDMfegrD3OyHjWOHr7UFQU54CObAMRg6jivGFTsT2bEi3Tg2/FhQfgoI5wg0t3/8qjUYowAKhiuIPJNPab4rCPfOFZMWMo/1UxqgyqimLZwZtcy+QCFQBkIfSSxlUu0IU/DvLvn5+69eRo0IDqNGRGHdWeSABW+5VIYeamS1AkWqvG+paf1/V6JFOXhKjQNwncd7xkA38z/8/1mJk6dBWdDxD1uMlKUkHHfRGNl+So4Zt1hPwBaz95o66ABNZp87t9cr1uaxDzPyYmBc482/KvNAb3ZAEnOboObIgi/KSRM1Z1IsAS1bRWfWwoju/0gYPyVtU8AS0l37lxfnliRqqPC+DHrUEqsu5BzK5JvcgxTDjyCoQDQw1rf4pD5VwOfGXCdXQ6EiS6AeI3EuC0iwLdyRB7aAJlrvkKVWszsJThtKE/Oeacr2oWebqZ/aessR+PsVewA3MP9EhNqTeYLJTCeJFoIJ+yn6r2i5bGASORIZrWdqwATP3U89sxFJkIQR4yiLpAs7c0oJQ43S9VeEDX1o9RSAIVpBB0yaG4l9FH7SVDHBGUur3XSwBjK2nxxM/hLrrIA+RHaIyc1bnZbhm4pyU4wbYEOjJq2gXtOqXOdi3nViQA/NvUUeq+ByhXEiBBolkGiTukSrw+WROVWm4Gkaf1/ADozO01KvVhWaldgPasT34NDbrShDtObOK1kOTVRpwEAlaYN5NxrglIPyIVZJNnuUXfU+ClyFxr4zPuAsHPeQQByKCcTrhTmIUknP4PSuVWRBmSr3EJXm2UbY/ZQXLhQAAbC2qDMbRYsLlQ71aeJjqFodqBN0Qt2gOu9IpvLHMcATgPzqQAwHVEN0mwG7X93kSlp2Y3xsFShxVOa6/+wiQAIs8pnRuS6ukFP/WKQEpGyTNHyXQXqGgFVdA7SSvzVACgVdKRzoxxoAgEEPno5K3vDnG/ET97nprSB8IouoiEAhhCwZoNdlljZk3lQl9gKmqeHLcjLacRDRCyax0iezwDwx151TLjGdq1tLTW1czasFfa42x5yhBOKbcmmf125AHlRy1srb0mQ57HTe9eC+++ii4X7q7pBJYp+c96Hb/IAXm4baR34XBez2ByYQkOmBqbY9G7p6fNLDxO5kd+TvwDJbtflq0f9ChJVNC+oSUWl1qJSwQqeGTVm1hywxobIAKPGFMlxRQXnwZe4o/avuWYwVxL2zOKosjEdGkSvVGMAmAuGKtvDM8DeUr8pxDHEsClTxn5sZSpen+h3Cxm4lwA6zfH3AxhjCmCdaMtc6w2B9B0n/KbKVRHaSOBpC58kAJq7m5nK3A/zyY0GGMUKxXZxLh4ex+z8J5ArbVNGUEwAIkwX8Ac0ibm7rPze6k3I53MJXNkqgKM2v6t0tF9gjwCFAJ+m85Lq3H5i8fFwmam63CtvPbMQJtxf4fCzTXZQALUk6QpCeTlpPEtzXzAfYnH2T3602ISvz464QmmivbgAyeSxtNlvqLoKIMqJMwgihRKRmYLpwC8cjwJ05dLc4wCyqPj0FMs0IWJIzPgBmhaR+byedchGd1/b7g+ht3BbAIntojThji3hicFECr6WZoNlSOYNoZFWcIHMxO9w064AJAJPJGZRznUKSv2SvD6unbEtoka63kBOFRRyAeYicgBieMBakrbrKxs9YBOnfGK47dNSRIL64rT2kHuYZIF9ALeUn/LkfFnDv0PevZuPOe6YaW0QxwXYHZBBnByfOb0AZG7PyzqZVUqzxRdVzymF1X1+X8lj8QXA5qzvh73yKQAXtjchudzoixlSvz/Mz8l+w4Ncpqr9U/MipAXlUXhqALXoYlFPVk3UJOpsKOWoa2n9HSG/KZg4lJktKl9+5bIABZQNlEOJooIPcW7ScWAm5aXaU0qHiXzq4ykcFdPUIQBWZ3FfuzcIpyrwGIO3Ij+PYrhTc0nW+1rtZnSRlwYGACKif/g1bO9RJOltsKPVsEt2J6S0eX3eZvQ3ULrUIzsAOcPVVBUQ8pak4saIHaVQS+C5f3KxjOykSNrruLkJAQC8zoqzBYm4OgHiYBZIYzsBGut2VjjKDp4cbHgTXLPsAGtypiilO6DktQHmY1iTtIrKnqkbPazlhd+X+xrkB3EAfuQWqmLPy0pJ1LtIwTcXauWwT+Px7kx0bb1EJcqhSABMAXiukFXZxBeVqfNZhRR+eEi3tUipIzi1yAhCaYbbANZ1eWzm4IQo0uuXOPs/KoVKyU6KH9GVTzffwYpVum8AvFqi0jXZ9zPPtJXywsppFl+slUYDUXHFR23/xA034AD7bF3DBU77WDtIVGAFX8o6kdkbw7MN5sFrsGIMF2+TANO5XcN2tReijEDiOuQVQalMMk+iFmHqWoG8HPUzcsEAVGDj/0lpAJYUXmt1hDgPFHRVFYLmmA4bOTWw0cuk1gAcuCziEkeTkuIW9Kh16f/h+EIss+PoOE2AnPfhd4NHAGQv4dEv4it1cx/09plt5hVgGO8vHYvBDoS2iNstvSAAh3EZqtxSsPEaEGLR/RXk6ixJvI2OXjtMk+NKw7VAWgBgtO0yLZphKZx1SNjw/auzHN/jXhUwSNdGxqnTB0GtAOowrLvcsRWBX+ow+rgYvm+h3tNeZlZGWsLVbAhLjE0AxfPQqJYEI2QmcYV2p+6oENanm2BG5pGBAE88OggfAwAxfAS4BTILR2z55U7SZbe6WMoUXEyogTW5yRnng3mdAHDIANz3zvwpzEnoNamxpgqUHhfru5V/0pNYkIQ2trcA6tBls7ek9skb+T4DMCNo5KUHwFShQ5nvrKWWYKuUqgBNGjy2lz0TubuPhWdt0nQJhIbh+edpoLNYpJRstUiCAOEikDi7PYlJCd+RMluxgvYPuSYE6WIha3uXQlRQHscAyDu/lDWWAS0XqXy8aVfs0hnTzLPKjustRbPPo8RzawBdPQejySLlqFBHpaIVKSFAC2OQPgk9hGCoBZU+aoO9APp6sUOh9lfnfOp1B/jRH5EaIzT4MfD3JYB6BNU8+SoArGwbOjRa29fmJ1I3jEBunoeLV+KpbKGEhs0RJD54rQDNvehI9LkIs5xg6LrROZmUu7aEhh5lbUhelZFHxLE5AC5haYZga+/b9ig7dA2QpLGrOXH/UGKuMcLbVAW+yMEA4e+utcKviYl0ytq+JHWG/3Tb/fXQUGFf14JI0zumgQCxeQ80mWVS1lN0RX/DWMK026qQXqy53Rav/klakHZmABpRHRGz1I/CGarXvhj5y3BjtgPrzFU/Ot9nENiFQb4Aq9NT8BWNNF7bNoMvK5jJP9/fA+iJdnp09ppeaL/xXgB1K1pQFpUpMCaTViocDg5GvX1+DTBBYqfwS4f/KOecABm+A0ujV81EYwhNyUGtrENDDd/siuQUxoRdlvTQ2CoAvSDqdZEI7v/OJ7vliJ5NR/4SaJcUd6vZjiEFPl+e0QAbkNMD3km50k0YqJzPLcrLYFr4QgOFv4sA+2cgnJqwAHlQz+Vj9Umvu/C3qPiM7Nqo4fR40FchEKlwORYbV+wADkmoSKUQJKPX7uO0W5GAp/8r8nGUKNCo46iv2kexpAD+6LuQeYNkLkNzkyYuMz1l8zWSYomHkE8fKac4vk2+AAXQwxih6BFBqvbPVMlk0l5MbZ9kofLiaRmkcRvtjlsA3tcHHZaENjFub4fvP1klKB3y7Wnl3C68LdOSvo+HowDP9vESr+T1cVvFih2AGxQDciz0L4FIp9g7r64GeD/YAFnZkyuFZ4AmZ7WvtXcQ852um2SUzpdep3hPAb0hHf8AXxddCVxwSwgU0a1JuiNBGV7eDf/ZrAkzTZn+IiO3OgCwbBXYTJ5gW2uRDnUePMFyFmJY2wRUOBXpvR+uxXedACsKp2UBQY9szN/aFKVYa8MU5KH/9S2kYwNNJLnkLo8AtRhkbBtF7xIus1Tvpj7thTUKfrLSmUraMfLmwqNDhgAUPxoYY+XkJqo7N+BN0fihjE5dpwXq92TD+aWf+oDRAPqLKjpYFnrBEQrf5mQEFAHOrMQJge36vt0lvV7fbq4AGYxN8BPs9oZ1KY16/vD1/bGfFgzqUdYCqp6wd7Z1QAAYfUoRVibfbR8n2wVDlcbqoMQrbjqF+YPA02AmcxnpAFwNYT7IGmgC2MqNv7so9kadAHd4G3xTZB9FgMYB9nwAlnUq5VYYJYDXhBZSCTWEf12G4Vg4DN3IU8g+TJH0BgCS3CcYesvI2jVAXD5yXmdKd2xpSOBQWyT2ARW9IGX7APYxa0lfwyNDgTsq1+YAJk3qKdpMVrE/ZBhLAM3FrGUAeAteBtRnr3IHCWvmeferUNTfqeVBsrj5bX0jMsPHJAA742wTsgi6aXcNNk9EEZr003QAqdcYLZ8spNDj5+exADyKRsyu8jM2aaXdgNRy6YbRJBBS5b5mDz6eeeI08Y8AkALTRW8F/ERw+7hBITGs4i0CbRkzk5okGFVnPEp9bwCxAwL7rRFkfDfI+rFq6w0KzeKAphIXvvcnEKtb+a8IABDaWQx8j7k10jk8M6/Frxty6Rw7q+/heDbjjAohmhMAPWh/MAxppDaZDW9kG7B37/Y19m7kzJtXDCncUZ5yYAB/mAqktYeor9n+aRmE4uI0NSuegctucU4P7H9lkfYdAP/yXDf/BJu/k14BES83cvSUDi2MiGE2M5NrVDzR2mEAN/mbu7a2vOvF4CL3qZa/21j1x0UoROywRbHdMIdsnAAJXneloHJEY6rLJaR6c6fn40ztrJU8zzdKrJIhGPzqAJ76/l/JDVYHIunTjzMkocjCqtxc4evTNaRS8y9cyxUAdviTxeW/SsW/y3wfKTJyvaRNnMMKXkJ+krHsVD74UADwG0l4Uh2XvnkwQWLjxRwOOTbBl0msOhGD0aTIkqjgANJ7itN0vaGxPRxMSmGTb2gpsvHW5y/Mnp129uKbjlgA/yL/Lf3h5WFVb2Fj6ESBwLPSfTCa6M1c/pc+MiS3+wDrBhrQHu82aLmUeXuCvpmD4VHwJDN9eFIt6QV5TlyMAK7mkzSsjTdkf/BRDBGIgPqZoe3/0V+BwI7lq0t4G7kAElq7rUi/FgPjyBxX+RhLQ758s/SjfTmBI5Akk89WQwBK1S2uLIwFxDmNqMiEuVE9qC+m4PP9Ey0u7ho0JV+GAKgSeEIR57wsXQr1EXFKl/qpmwi1ynKx47Sa1GDmgMwAQJRl5hxMRahCF0Sv+2aa6Ocd5SELKKzfd4ngTaglHADk6LJI7hE5sU9//wX8iiAtBfT425mxFSCTHofCcw7BAMDr3rRLOPI20FMqsXWYNyC3NPE7CBc6869ctY/eHAkA/sa7yk1keWjadKIIBSSJtvjJLM8tvyA1f7ckyGmBEAAZHPp8RC3rDHt2Xq/P7h19Oxp15qD0EDQaTMHtQzJEAFx2c+1YEbmZsRIxIbWstgApaM85jA/aLZ2Pz29EFaUAu9wswJCNso/C5TDHOKGyZcpzZCs5WUNWdTD/hIYcuACwZc9gZZ81eZBWrNCU38294hfTjx2acl0VVOT1avzjAHPOSpGzZfyJ95q7Rq+0OTolu57yUSqP6B+76j6D9GAAWPTMlcP5wNk1lgeBXg2K7AUplzKneIWCmQ75w9xqGACcee4wYydfwdihuS0xi1zuhpZ+yMAfUu9oHRt2d3qwAG+q0u1AcC+UZYByA4Djv+CZKRvDAaJ1fI1zFa3oOKIAtikl6QD731DMXzfJeYT791Qm0y5PVqc9sDlMR4ZEJAAaPiznN/sKKANbnoEGSJrZoOIQAd09yxPRolHM3AznAD8jczpIjy0enuvZis9Zbv+hnfGWyDOSPStprvvfTNcAyVc5QUK7/oSH+eXo/45Z2MWSdYFpfKWPkDkdFoknlwDh8y+DUdKDK7DQocCyQexTsYAqYU16VFnKXRqBwLjlAD3nRTCNCfOep6MpWq6eR/jszPB8piwLlm8zRACMiSEA5uQJ1XPqj64XHQUqFgfksdwCX7+aZ1xrGh9MVTgWMgBwOUdz8ML9S6pC774VM7eSatos76jsARt5n6m+1CtAAEi7RxL8iTi3ZX6nUNCu1GGeW9bSyTDj6JFBtGNTuf0A2gntyLnPdXjTHUwaxz5OYxKbB4+UkJrqfJhUd5V3mABZn0te0WG/+1x+CXRFMzXRqe8cB7RzTLGU11cWJQgOABwSZRDxdIzcmYwyyhfwoGR50Csig/9dMYONhpqhaJkAlHtAO6N17yFXGxlbr+/U960PMMN/7+iBnOskiQgdpgA75qPuRN1Ropl1Pg3iXVq3/Vd6FctRqOMf02F6fPrVAH/EeQAhWzTwPbN94UZuPbw0WFijwWjc35yXPJe9lcUAJxihGmDsLD1iUW2NThgG6dGrhlzsizWyiKp+WoI9xwDjHT2kleVLBLTPr/19qiwDtuypRigQOm3hGY4oVD2BAAEkPOTbPX1qdahjoQrnup6yPxzbf+vZBepqLvblu4AA34JD4hOVDsSr5ihz5xvmp3LSgMbeUbLbuGgbVo/lVgCMRLK61+UhBOCGEN936RUYmmvzlGzRZIMNM+0ifsClAMQgNmJnpBNfXxHbc0oAqfgmEtPtQPkE7152BYiQaioAkY97Ai9wN90a2qhZFibhkUVl+aYAb6M5F9EhBo1iywB/tJm85V3Dq17T9WdNxe2EF6VSDeExYyyzUQYnkLS6AEA7Leldq7rTrIxu1Fdy1qNYCjTLnPu/T8SjNiJzUO8AFf4D3LBbAll2hOO9B4mDle3IygTTjt+E2IaGlTTm0gBXDxeP9qmNHXMPIdW/RA7qTSTQ2fbar7U/NLg2qc+KAEY8LBswzpYvz7DvqHJKAjKAZqPiXCynQAYCzegwIbcA8Cx+MpuhAI5G2jxUqIXcFjBVT90L1JmeCAUeODOVLQDNFKIDO14mmCQq/J2XmQRWAnDMX/PKgdSkgJmg6jZOAK89Hj09RnLfpQRwDLsN2pOvUyoVW5vJtHFtAQufxiEA7oLPJ0lx7fJ43kdRsWEQFX33Z7fQtd/9LCRHxQFssACBtl5myvhXlcr0r27w6HfLRmoHbmRov5/73gwbNq3IABa7laC3ILQbpPlmGi2UiVy/7OsRTWFwjuA0VfVz5q8Adquvjg+oDlmn7L5igXTcu/hqCuHbAi43gdSIZzyCHgC5dDlObBU9V7CwEmXwWg8/CA9oBdzwV+POD9/3+a+KAH9jWfsvdI6rnyZJJ9f+eQrLLyvhexlhk7klqVnrnXoAway47qB9cr94LY4OUo1CnCFf/EtcDdm3T5un75aqtABAMO53BmQmkeqe2jeDiRWL+qc1iv3QmBAyYdiJZ+i9ABXvzJM3SEUlY8ovNDBWMIcH6cDXY3ol9AdLWoWyL0IAjzxjB/ANTN47NS14bgmEas98ltoU8B+uOK3mIenRVwB69Cf7Guw3vgs+Fql1ngKJkYt1gjCeuPuUoYms3lqNAKhlnCDTOzjzMLVaRNV2nPFpGYegc6rCabG0FWAzNbgAQ4VNVW1maR87e067p/f0NizYX04Wepue6x9kLIN58QAXiezwkAvkBzeW/4bH/9up0+mianFfTdAQ6Zsd7fKbAJd8/CkLOB3YMFC4JdPKlopAmbLsrFCyGNTdT8i3TG8AGkFAZsnuGG/IKRtIMrP+AfcYyx8RGMyFaWdxAuEa1AAkTatLQm/i+HqGmnNwxLkak2MOERdARamANBGbmsK1AEX289Fg313lnCKgQcnprcM48cxelChdLBHRWMN06uMA+/mw4crye5yor8C0Q+mLXQ/A5aNAAD1V6DEsBbybgADKSNq30+FkHF7ejOmUBw/fkvR/uDOLTglSK7bD5oKMABhCRh+LkaXLsmmEv8yCnNOUalfnXnIF2sWRQMfQX0kAnHT0nFyE9iJPd5h8SUAGFQdcpysMZSuJCLfX5v8g5gCqLWRk4eBHpTDUkjY7FIWLEQhbQ/dReTx2blq21L7nAGtsaQkNvF/zomATqNKNO4NROyCnIbzYTnwAeu1QKUUAh70HG9yWewsdsF2I+1m3X4qAQaMR7E5xFCTBSJ9/4gDswC4AVVH28StH5TIcWfYjbx0rGs6vOEqCZ0ngRw/RAC2dXaNdryMlnJc1ft1y0VcIa9t61tiwn3sxxaTL77sAC3ugUgMkWuw+90qWqKINWx19eWVGRpy9A3WifNE7FACS1D2TXFoEaoGrEX2t4E2kaa5Zwj1lUsnbMqIuolwuAKkOeci7sN5F3Tei5QCLrNVKW3OSDKoJZEEPGq22vAIA4Jazqn60DxOWdA0jtQ2U9pMOHfNMbx1onvHaB6ShLAC/xPKLvkHISfPmqHieEfpiI1IbGUfv6UIcpbZMRzNQADJGhLWoQGVZWEph3Y/e5ayeZ8X4M1v+ZrqpCUOX9lMAI7Ey6MQCimycCaCAZ2ElDwyxbhmszQKZ5hpUt4U60ACavbnxRBx3GWXQaA3P9ZxjTccmVxmR+edSkkrJv4rcAFzl6TMGtcpg1nQDiCbz/w/nnKQg9tYfaaLr9wMiS+wAZg4Jpzk/Y1/5bnjBa0XOO4rH7Hpqggo4KhCvr1cz4gBvBmiS7yDpVq1GwnWgy6lkze5xpM4EKbSEpU8DLQLaACf4l3VR6oq/m+E1Wm/sJRahXGno92cnl3bnQ2sTF24ABckEPUZGNTIsIrLIiMzadL7U8ZlM1YmEnvjK7JvzVQBW75uXasERGI2kkgtW9h01XN7jNixMZ8peMs7ZvYCWAD/PKgCqcp4SZefYB4Z8lvDV5C8zsF2Ozp1unAz8T40A9g+E6mPih1HB2/zw7jnjSh3nZF0iZJL9N4Xe85IUUgD/ste8HH8shFfv8MhHeTSBMjj9xM0RjwEJK3owj81VAInRVYztABT3DDROUseImXqu65UH71XjjbC7a3393xEAE4c3Jtce4p0c6RLwdgIIyORdwpIVTS+hSOh36dVhkQAtizQB2lebfyyJJiz4w+NbjoTDsqVApGDasQ82jpP/ANiJNGER16zAhdlY/vgJR0wSH0Jtu6krfHVdoBfgsRsAK4x7NOQnVR8WxNO9Pj3AzS6gsyXaJ6C3km/bwVuzDACF3wYzz56257Lxp9Roefq4DHxEg/4Ea5bHUfI6p/GoAOQojPKceCbx3TNHOTwIdB4CBYP4isYsQg71Uv5Vm9IAiWRKzs7ZHTJAooj153OROOHKdsZ45gxseagFjaZovAB2zVUxekkWmExROdOj91SD+enPP48CUOR/K9IZPDRWALuxR+uYBNeVbycBL11J11TzVUsaia1u06wJrHR0o0EAxY20191M+r8mF3Jy84B3uvCfOaYBwB+zmPVm/sYjogBAj0RHM05Dc0zty+NElZJu8OUJPI4aBup2+xEi4UUUACFLbv1ngk2UaRUPUVwoiK3aCJjfJy9MyP/XCy/MhfUAAKQJVztUJyPz/XhwaGg2Z6yWhzRST8jM8wEbmGeCCAAyEG9F4755Q4kqPgHKWoGus+Y56Vhxg+rLzqlSHr99AGDbncmC+M9wxkB3s3bOCKqC6si+dOf3i976MfDW7jMASxQxjHa1bei6fJtytNUr0YdKEiUlle8Q2BN+LmVz2gAH3SFF2B4KNO88eOIakjlFuT4NHXBs/5xQqt/ROBcBACARVmR01y24jnhgqgh2eNiZGO4ZhqpTSF+pGjriZm8ArdBsYFtBwAxs2I2gDK8kfJNmjfng/fBnfVLauQVRQwA3iI591Q0w/gwapPL8QTWlEomWqidBPsBkcXh6heTRAJRoTrIEvZ+RGsylp4ebGLOpaS1Mw+0Mq3EV/AG8OtoAL2bY30z+xBemmUzThfQzo//GNBdxtm68koTtMEl9qQAfsryZ2x7AfieTEN8o0RwPKixSpTRPAhxfX29fYL/wAKVkdIyUouVuMzhEzcIFRWJvUIfH7GJ9ilhZOVtXq6EAeK6zmOBqa/XJgATuPHZfeBH/bOmeHXzgFJ8GefILJgCwHbLghHyAPNxJYtqD+q1Nm/cpAo1Q7syq1wNATur7AB7SUQvG4AIEDlsUdFOagt5TQQQEGaCK9U6K37MyGBIAsbdghXjJqBVfMXMmzIBdUi+iyvxbJk2ns3zzY1FTDQDbb4GAQf3af8zPbN54gGOrDbRyVC/mBAYMri0NM8vpAMzv7c18AHZOo3/PLfbEL5LVd9hiqGiCI6BQQCP7lP4AX+2Bbuatx6YzPQkuU3d1SuCn5W0l9cU3R+mzwZ/uYQC9M4HfKNXKClMFRw2vKXYcjB3EdhRUiKVmcmprgxNtANF5QDMDMqYaJgKKMqoomoIfaK/0T3TZGXWw1Ccpe6EAb1QTRPq6lIG0erFtjMW2HmW/cBDYUfYrORKxb50b0wDKUsq3/rh1UtDYrfvQdk0+3Pt0xLITFrVHT30CN0Y+AMwuivImF0c8Ujo0TB+bFpXIinNjgWFbhuqSl1vkvy8AfrplHdA5OagkatbowQx13Ox7OfJQQj7A0dpcdaYtZQCZUQK4M669g8X/kJMVhJq47OxnwRMmpLxSWiVWNLEQAB+N2BPvHkluSVnd4lMi+7YR/b718deCaIPZlmZq8MgAYZukR6QY8/noalUDwzag4MJev5VifR9FCy4jVH7z0wCpOqJ9vN5o8N3e7Evg0jJQxEd4hkH1QSlTSap3f0IUAP/uElfuUxWi7rzMxv3jHPSD8o3RaAq+l/NOOZZYBnoAW8qG+q4e4513Egc0Rm4dhTUxYn2HjKRLgFDtFwhNKQCu9EXKN0a9tPEXP/FZ9kYVtMW+xu/9He22w53pXgvSAPvbcqlTMY+cmBvCsor9YVQ8SJvR8CdAZ9Jbvfb2IPoAoWotqh4FQSsJx45UJOjaT9WPoXgCE6eLbjIgJCjllQCO64/iwPXJvToDNywR9WrIhC7WJ4H4zk57aJ5biFNrAPuwXI7k4Te/lMrsLDeYGNDJnGEeuceS5F7z06O31aQAQHDUkRKbp0PRJU6dCQqwIA4EFDvJrsOjPLi4/+bEfQA4Q4Fx/qGH1n0eIUZgJ6dzx8mA5FJGPGxWA1AAMg+NAIF+/oSizv4EGuA6a7zAXbMfElDjODDTqlBlHa0svHAACCnUnGaD6EDHFeM5vJZHBD5MPyejJsAUcCNvHOF55ADWhFvRkuIFgFQ8GDIwYg3I+8QzLIdgZ9/UR9sgS/BeAFrGsBu9uvVuGkwAy/dEMelEWb/3DNgn6Vx4C5HX6JcArKljQxOKKfgOF1Trx9uuLeHpp4Yy2Sy3HPSLN1fVEQB+yKFdd3xC5srpX8N+DkPktGfotkNzDViux3mYowE6AKixqD+qx3sy07XJLiZP7u9dBSoXxgTBpiHzlDbQyMEAb2JxYT1jLt3H/oY9J5SfrQFsZ6fBOlyhe47lQWgtfwBAvCh/Qq4FLi9S66BA3lewaCpq2xTc061icMoZ6EvyAFxRrWUJoMJIxTbq/1bAy3vPPB9PrO7++lF2SUpZKi0AB7HbUI3XIVJdZDAH5PfU2iWjUoRdcDUFEP5YE5jdOgAOriXdrOPq51yJRBvCDd1/QZ9vq6mIxm/VFVVBWv6SAAUJz5rK+Y3+cvPt5Qp49sm2anX6MtwxEfG4GylY4igAY3tgaJdubHaYn/LKpEbknQVL9Z+zmFemtu0X2XMq0QCgv/FtoxDA8C0hhl3DBf4jvQxa80bhLhYV/Svk6xa0AH/xeyvHiVG5l+3St7XVLg8QzJ3/WaeOyRmTiRbsGbwAWe5zj8Nh57UsFSJOudacXJGXzlrMDzx0cS87ZxLQZwDJDPHvERzCR03i2paR5HQaFk+ykKvriFNCoYrkYqj3ACNerWa9HIgoJ/UJprQiR/m6QEzMuWaQ03zR6UJd6zQA8wv/JUuPqpEEs3Yt4qKy9ibqi029QxLaa9nCc4nm6AAPI/5d8EFexd22S77dhdlffK4NBs8c4scUquMLcZJxALeoxpo1ags1wJU3okQXGqi7KwItAHLB1oyJG7VUSH4A7rUj5kl91elSvIyq8ok1z+G3L6QZxgT4fJZdhNnZLwBnoFI358/Guc8Lld7Nb3YBgTL8nBkARCfJgOe/nGVWAEQrgybMhlSu7X6rHi4gmxhoEwplF4dFzMYysLKZSSYA5xAbF3c2uELpxGRBcG/8sRlomZNpwHWIIQHIGwEeyQAAJMlDBSFgn+Z/7/Ay3e4Chpg6VG2QbnfY4qgmkgWeAHxAMBlV8MGvMIiFeT/AGcQsKG3Pie3hUp0xgZGjJ7AAN+2x5yJufDxftAu06jFhgkE5MArZ0xFiGiAMURBfbgD3vsylm0vL8xrcDyHoPi8Hq49Lp+pe4F8ezmaeeYTvAHcEe30CZniX7kTxFfvt3NRBr1LCYWqV6gQYG3rnIsMAbPlf9MiLFdVqjSGlgQu3UtSx1H+fHGAO09GX3/pw2gDshmMLjySYrcE/bf9T1ao+5Efm5lQlEnj1y5urMdwYAFW33OPaBKZ9OtXrvDxzZQgPeY8P4UovAy361AyGm8MAsNOeLB/SwhMx7E9CANkMvN8Me7/0VtxnKqINA68b3QDXqLTATlXTdw5aV9wt+qBEdgxFbCIvgEx9Hx9o5D1iAPM4nk84GnhYlwZ05f99wM9ehDTMuPyk/4MQw5YG5VsAEBkrPIwYYAk2elCFO6hCfTFl0FJerPn8728DESUk8QDB5bzA0RQNHcnvS5ed1bvrq1oxepDqAH2wb4TbZkBHABSaIqUzIHtNQx/Mr9bmi1/wOwIIsDQvKKmYKXxOf8cAWK0nupGi3mkEpVoRBxKZt3eU9vTj1QVtBviK12PasgBe7vltjPeQaNm84R41ZKiUqes/DHupx+/7+ac8gBIvAFk647yNit0up7cDuHm1Cs2TozcIc5vz+RyTp1O2xPUAJlCU1eyNHd/JO0ADM3JFmqVqlUZ1vrdERoxkt6cV0ACYJilfhJ/LHpiWI65fcsIgB82d3jXVoYGnyiIVj02gAMse6/nSmR7dFW4Lt+tYVoOjyby8SZaNPMh6DJ3McPAAjzmz8EClMh0DQdsRGqI6985jwACzF6vbaZH0lrWtkQDezMhC/AjBcFc3PqoAuKxyCF4DG9L5C3dcUwgWGmRaABfpIGrLcFUUhk+BZ1qzBjzUKwj0nKcZ7sFMrUA5xjQAXoa4HXt1V19QKa/pHZPvzZfUCJNTB0dh3eUCCjTWVgD+J8cujtpHuX2kXqFDWKPu55WX426XS/FKKuDaRKWtAMQDXf1p5PNfnGG7CnUv90AfSn/0I2dp91Edd6tI7tUA6jeE/pPwT8u7ohY6eVGbMmnB9VcV4OQdx2ALeKyGowCHBxt0PnnIsse13rodLwWDSQZR0A2z/c8Gl/b+fNELABQ9OSVx0hj2Yi41/zhXpxcFPisIu5QVV4ByoBHXoQoArCt2xCmkOYNT2WnPcTu0y14x9YCoCiNxzovccdeUrwCf39vRqa2xEIzl52abD0+4vYaNtFgnLXzMJta+mQuhAOZKC8SBrdfYe/QSOYDGb6z8Jc9tmYsQzRnt01i6MtUA8QAHjsl8o6rXqKUgliIWQpJ+kCeMTj6Coh3m8j7kWgBAcL34o/Czzd6HQPpxSNGBjFi3CfaM4mfxqLIGMuDlAIVrP073mMeknWHrk3PK/MmhkxuHckVx8NU/CdCM9fwACYaazz4akXnPkGLDzeHQSHLrHFtmNYkbX+OOmf3hFgBHNeKN6ggisyS9rMgDecsjuO9EDDn+UDxXndzrukq/AD4sEt13TUI7fS4VOPL1mJXCjfggyd83fTSR4HAth6cAPPCC/VmMoLJAsPENVAOQzJMHaRx63Tw6Kq3YF89FCgDWnrrJpOuGwsIFNLzYU55KhX0NRn4LAL06OhToWtiMAB9L2jfMm9CqqZPFH8f+C3S8cGly92NNnikbcLYr6o0ARGR1yXmgOK5BsgI1zWhLhfImUYLaNfRCnQkW9liE4gBlgRVOAQ29/CD+6THPHx2A2GgLw1KWuYh3bCr7K4GKAIDd5f84ao3Jn0KhxwdG6ju4Ze8Pd3R9V1oOlxGNypIAvYhRRdVjuQtQ8esiaGlgDmUTvaEg0iFiMkmO38uv6gD14CRijkThZq57XBiicj3XrjtcrrUYQtWvaViE69EaAAxTtnOFxb9TzsLBWDNLouqgbruiq+iTPza8TYGicisA/8g/qM4KkQRb3DxYuU181la6xGsu842MYFh8rLf5LwCAf8w7x2lpi0jkujNcmZgfNVX0msYLD2Kc6zEvHEHaAESA/ndLz9q5MGvuy0tczkJHDrw7HOl6Mzmbh1rXOKAA1L0v7zAMSbetb7c1+DPcmMaxTlY7e9k3OPa4FlkIjQAUB7lDrfzm8MNwZZ2E1SjMJSndLJWTInmWA1VZtPLpAA2WSkcune/YdaiqnZ28H+ObSHUrxfIyiq4+9XWPVAQAxdsUu6k4c73aYTLsdsI3+qdg4SXz5IucafRtdCzCpwAHDZradsiZX/kq7TN6BCunpxuRT4YD0AnMxU0NJii0ABmPkTTgYSHwrDRl/TaP6BuLJODOeA31Q0Stt58Jw+oAs5neQNz8V3sy3o+vzfNNYCQOQEVWLZZ5kma+Hvad2ACpscfgX+0Difrg+tuSWXT4ITCoFE8sdNUTsbEAiC4FAP7Xp1RMk9xLb5jp2jnrDGuTimSof7TL5q/zoKuXyRkAhekayW31u2C0q7KrLTEyTH09eaE1qa4cnfTPgFVExwCfBbUGmi1ARmZp9CC2SJ94mjuVbcf5Y4kOtfhbI5FOAG84a+eUgj0m4XlLznDgVgjISOOVYldx4AWWEK9gGbUApennMWudirVXMg9czJwoR2IaRmNdxN/JIVYK5hmazQAOUMNwNBd6PMgscmElWEYrOuBGfxGWRjSH8UpXl/LgAN09ZjTBgMyWMkusMaok7VT8mqW5PP+UwgobphB3rtkAI5HMgjoUnKsGyNXqNum7QaVE6ablTs0tDymYQ/x1+gD/kxbGR56/WwHXho7LEzgUfzShmNrf4/dgHXMfTNnLAEg4qghWqp2h53/16oa9HTPkSweYvaSmxJi/d43PKpYAgLlXDypp5Ge6VciMNgSWdmoN27pKqWLNb7VkWKwOzAB9StqlagmtrHPxAqpj0ptF7BJq/9XJtvun0F+nX1sXAEr9Dz5/iingMuiy8uX8cAf7jmWwN3qQjh+LFyni4gEA6xbFslu5SzoPUj0na27k5/rhC1cUyKj07QfVAqGD0gDYBhQ5SG/B1yu5xKIPJhKggFzv5G6sbu9TKoJVZVNsAFO77E7JpvEpgLtGvVGflKg1eiYuUQD+WTZIy+cGUkEAXemJZ7yhLfBskA3R74sXWkDqgH4UlcjND6Y++VfsqQDITffCBLVDzWfTcgijqOzsYSWPWsw0tJzhGkUcB7M8ALUQ0h2oBw/JSEqRCUYbO1tTC8UuP3sn+M4oPjtAIpwAzVrP2BnNNb4dP7CiCnoyUzfWzKMWjH1yB1nFXH8YHQCuyUesRUgVO3CcpWrsEjgWhrWZfH7p9XQuCqyPM/r7AOwySvw3flTA2ObomzvCi8qWa/w70FApgGVYVLUxx78Arw5KXm/9/BPFL1E635c+5htN8O4I6bx/LEHxr6Gh2wAsCCsFpunoZ9YUGj7jqpTYMx21IN1MjT2k0Id9UdqQAItdsbyNijaBeaPrxqmmPrAZWBg9BoILWnHX78yAHUAALb1EMQdDaBqzXNRXC2ABaNtQlBOKiV8QlXjm7l/AggC6vdK2fm9uRejGhTmUpheY0ZNXOAj/JdI2OG3qZDVdAOGH2eENcMGC9YyolruY3VYjg1l2+whg08xQ7oG+zMsA8bm5SH+R95hTy8/tQo2GSYSryOypnp+FiXphwOeuYABcEfgmXVj6vlAxePMgI8XLzj3oMJOraHZc9ljysUDLADmIBIBkVkF7WrclfwsqqwgYB4NBDY56GXFHPmrXPLUA84/R+21e9PizFOlX/3Llp6VRIqy82DFBI0smvfGrywBnnOFMfdt9dKXyc8k3Bc7CUg/RSns+Fbpk1RZMZdaRAEbjES7CQCJKZKtpDlDC4C+iG6g3NAy9L/jTvFNvysEA5fdaym413agTWLL/sb/j/aPQhdY/PzRvFTyzCQ6EBgAwZWRIMZKOATWkhS9+M6ovaYThjlWMj+rm2J/5UPtSAOWwkwReEk48Swh02gaFFnn8WyqySzHXGcC5XBcugJgA/6scq8Mka22iLlgkK3vz4UsScpRIgcAQ9EMpj1DGywC2lTNZfI5aWNAHa/iTs7l24ucZ3p49BBI+uxcayv4ZAB7zFt5BeWj13bxnQWZ5cna6M7rX/iZ1UMKC7GzjjgYAUuDKIMqNr7D77A4Ir6RE6ETMZgjbYitQFRaUKuY14QCjq87fh+S4ogJCd+CIh0nfhZQ4SPCUJEjjiCwSZgjwAEi3NwbwZGoDhh04tik9nEcIJ3rI0+yxFkdxpOxJjN8ATppQjxvWglR6jcp1B+Vq3XDoURZ72V5f1La4LrfbAQAp8/hdc0Fos7jgUvMOvJse+JgtTKWychYWc+vITE6/AP/byj5y+zAiLnQ+TZz+TyldEnorJhoWKRpN9jHxne0AsIDtVJaXpn3jhj2C8NopxS3s0p9ToryabmXSYtbzAQC/LT7wD0fhXlxqsslTC4RzDZU8pNABr4ox77YGN771AJk/dlSRAhJI4oJsLM3mhXIopITycl1yjIrBJs2PM9IA4VY49Lg4l7Rt5H1+1sa8MwPNEdSmXE3xMdVkmwbQDgAlgUk/01S2fFky5wUzsohcAKJSi127+Sjg1PymoGycAOtCCGSO/qRU1rcATxUClKB6XKGyWeunM4+JteEnBnIA3dGB+P7T3feak6/6cuYPYN8Vj2SZZGusL2XtED/6egBodLTYwPCn1Fa+FT0aVVLDunFNQCpBDh/jyA/Q+mZVAI51h/1/nvHeLCqTral1/buWoz0J7Kek/5+9bFF4HYUAlAWhQPFdSZZQPisd/FGhKpqPZ8H4dy7I/Qk96CnXwgAItTIBQlI7R8mSu+2qkUQoZ8mbC2ocGpnG0fAI4WOeAGKUTyIwKfri1Ej54ugJIBdbGhDU3NKxpbE6koliYBsAJlXmt/KkIPCJD4J1fEJokWEQlD/oMdzW+86ROz6RYAAyWEDDYFjw9QrOt6Gw0UVJtsH+4EGdZjkDtgJycIkvAIBGZH0Gz3hwCqZH7191b3ZjdcHsCnSUGPEf0jyQhloAqiWfGxc9xHMHMAyro+D4zgXBOXFtHx7IDhiC+pXXtADfjL+oE0S/ftmauLyZFyJmW69JO2rCEUB7C6eG8OA2AGp57/Y9GQ7GbKCivEq4wTSsJayL/aCcWcVnIufIUT8A66ZJn1TeHJEpVi/7wzlxrx8keaOwuVDKyBxfqKY9ngDinnZHpv8B1zzYFt/wEkTDZbyG0lnz1EQAL0GycN6yAJL5E4W7fjlwtbsI749ArZNu6LEBkzvqGsDv4Od6WcgA8PzfP49wZOw9pOYxG4eUn/wUFea4V6c0RQrSRsQK6wBoi0FCQRq2MSvIgmYtoDtz9974DkxVZDF0uStUCI7jAEXToNJ7+7i9q4NGy6p14XqGjDezNgcR8XQPuPADGtEAiogibqbajYS1luZM1mI/MYzx4cfDIH77cchaju/2KQDbVGbwfI7PIeFLtwVu0MGryNw9vd/w6Xmzd97RwRCwAKGC/nraPndxkObiMxeqjmOy4KnJop5rQSkJ3t7fF8EAACumFo0SCJX6c2oeLcB7M9SbNVE2a4D+PvtJY4Y4DgD7rWdzZ4IPfQ4JTAhA2K/JsqNWLW9taxy47XKS6vZKAFotPUGQx4UkfazGi1Rr6qS/o8qveNM3+5kGqOy6guAAQD5ZdQVXGlqurKaBZFK78fjbKtl9TcF4zS6wtpxmOwAP0ryuXNYew6fQk/w+jXDzfF88EwRNNiRVydt0raoUAD6r5VU8I5qCEnC+iiISV66IXAmnwBXsvDhH3ZRKNyQA1p7n+48tQRSrDlNoTt/cnEPKdJqSBIBxKrOlpTzexgBxEPgNuLkhPQhuLlNplZCOGH9hy9n1RsdcNoObiePkAJSq26jB359BquCCtjd+pXfQSYHNcvHEyM6fFUzh1xgArYsPy1R7WYFV/2eY+J3KW0QeqnatYV7waNvYRBYIOgAoSyoz7ZSxQNmULVgMgpSAN7IfX90/Img6iWVCS4XWABv6IAGDa6q6nI5JS+4tifEjbeyfhSSRj/E3aaWSoDQAtWtef0UB5psf85e+VRgNOXhq/yJXiQoWj+PPqav6XQDQu7PkK1NAFBGJndhRhH4wNV1ZaEaCm9JBmsfKMJOXAKlxhgcweyzebgXRLIPwvc3NnvFCqDFyOLXO4qE2K7kAGBMNDj1dMBALuSespk+6uKIKWRErrw4k+FDUhBKMYQCbfJh7NMzdZ/VfxYmgS0xiY1/qPBcvCOzpYm5dxM1yAB//O+1I4GzAmywtTZr1wjg2OmR/eTUMIvMqNlEbgoIAQ5APAyteXbAetk/04KTcFkVDUJj/geVc3wecEbFqAgDRPAV4CAE1mKl2tRCFingbGl3YyY05BRcmqlTrn6bpAMoBpXNwQKJkPK8E0eryBJpVZB2S31BshXAl6VkvsEIANchtvXbPVvlTKaD8+30Fo3h7hBoh0oggz/OB5ILPpgDBiHBZRcTRo3uw8RWNQgKStAiLRZIICXfBcdEmVUpFAHnLEUUvFzGpzjIQT0ypE8wwuWo2lrJ8WS00lOOONt4AQt5zrOJNlVJORsBQdV24DTHr2/0GBd7qtpHfNKzVzQBnuyFDndYJ0rWxsqfQVxmFHPX/zAhOvHU6FQUJqPbPAHbk5cQats5dIaJtlgrk5w10N5fDaUv6/7KPJCeLGJUATKtpaq65FzwNhlJaV0+3fg3mR13hKZR5QLgXDONMkwANM4OfwcIwIMehCebsOSjIpvNycYCc7evBvg0L2Kh8AND/awf4uXYNqsPOJL2/yURBqoNAi1yiWhRlzFT78yYAgy2kPOSjNBgAV1Sm4Rn06Q05oVfs2AM0WqWJ6QWSVwBjpsx4iw1arGSLfZozGyE55LlUKcCW/q6Sah5OzdrPAITKMoRl6jisyjeys85uUEfJwljHXIeTUXrUnqFbKCsAX7h2AxSqi52Yz8UiEFYmfjLsT6pMvIeUpC/xFtWq2wAUinL5KxqWI9fOImApO9lvcVkjHbE0OvSztsRO+7U4AE9LtA3h97r5JRFLKmdoGG0pGHZCOgQ6x7i9X/iGjk0AiRvgwVow/v+Ws2fC4782o8U52w+gmyYip1LFbST1lgCrtpaVdVY90erEdnoWX15p8FuKLwWaGAITUJlwjI9dAGolDMLKlxlGgFminvfgMeDFDH8E8izunOK/JBGxVUQAziwpiB4BVnirUfKRhDSMZ+Ihoh9rqHQQp/DIQ+4BYQBwVe0LY6bGSj3hR5NdiPwfAzp9034k/JiaXZw6aJXKAOxVs90x1g817sKG+e0iC6B6p4uMBeAuId3Ai8uVFTIA6NSwwXFoKaUDJDJi6iUrS6hmA5qN7RGWW3dltxu15wBB/Z+sxhGRsk6OMbue9M66FI0S91n3NkXStKNFd/vvAEUa4dI77zZ4mug86JUDPGvDCfaMW0d2seJmldekWVoA2SG3HQpw10tMTKXXQVNLeSXsSdWi7ebEGv5Lsp3FWADZB5Oc9K2yFtBj9P4+hwslGDW7/mj7CWstWl0rMQe1AAz1aryNEemgTHAoZyJKMTP1gaboCkYSxQ+sbs2wSTkAg9ptZTgsGqir2t8owsmwole4tuNYV0UL8L5xU+yNiQCeE5nWb9uz14Wg9S4uQDMJmAffbI3tmpoKcHYKVNUvACvroATsHc5EReHg8TtjZdTJvtL6gFvqxSaOH1NWaGAAEGBmsgW9C+5mwLFs9WyzQ1CYQy6XdeiCVksF1e4y4wCPxE6oSDz3QVVMhKhJEMDZZnmoKfUL/R98KIx0wuZsAKzMX/XdMWmXtNcqcGd/ruJod+vPsnyB2jXt1dm3kokAfVvaxSQyXBz3sC4ug2wnd5SAhbmAev9sLgceVtVfagCFXchfjLI1L9mgby17VxYAVpVIdgIQCO04p98V1i+GAOI/9pepW3+xM9/Ox1aX9EQZhLZRJ/ftPnU8/TcObuYAhpOBO2B2wHQNbeuj7/YIZwyeO6eWMwzGuhmKW8+rHgDH6eP9f4+eFj1iyx82P6dJ8XA4gC6ml3o0qCyhH9deAG/dExKGIb0m2cr5SrO6bZ3e8Y+RGEmSBbSk7jRnVCgAv9m2Fpu0HuEGyduaEwCzCuL5Vibkpa0VRO1cgkt9cgBpALTyg9365O/TaugOocVmChCHunegJCJp3EZFzh9SAPIs9UiLoO1eHGXrDUH/9P2PtqGz3gPAjiXIrXA+r9wA0of7ryAs0k7k8iFh4yPPPg+2TK0Vm/3EV2KYRAeKYACG6y5N6TyQpaaeLUqwk+g0k/zKt5Aurgvi86X/k86ZAKyGt5RzfAbPh0OHB5X9Un97ZIaVjruIt6PEOfVhApUApYWz+hCHwTAfcDU4vrxwv3WwwOLuPTRKUhufhDxcUQAZNRs/gMZ31MAGEMObLBYqZJLEISfh5o5m2zvYpeffADyDjb4McYsIXQACFIqfqLGXdmlU92REeQlYA/+DrysAoE8Y7odRGWJRjsK0+RuVD6BxA46VCcS+yarsRKTbqQD7563UDsuEzSiKbLj6bBGdVtX3r92CW+cvnktdEBXEADu9PPDX7MO/stix7yNnWagzEHbyR5SGzHuofFU/ZSYA08qmCAvzNelx+rG8OUGQH3LvNMMjQCvSwZ778AWczQDDrCqPq+meGUVTSlLZr5rqjrXSBZY4hnuoXg5EtHRNAN385UeTzPPfPnKflxXh5CO+Nsy4gB4ihWBgySms+bYA4qdn7QwMWDeyjotR3V8k9qoKzd1zaIDcrvVkvjOZCQBQMhquHDzuerkqJ5etHIGyMH4DA8fK18mYAztAo3F1APmUIA3+ZeEiJ8akCJDYVqfHF2xgnolEgGfFE/17BbgAf5g+ca4iMoCeo6PEsCTYBgBqOu+lQuVtpNLS19lOZQA00081LYOVTLAPoFrdG6OjHFxEZQJpSOdeUz237OesAOp0bZBd8ayNeqNHec3qbmaZF2TbP3YsMJ5a8MDLjncA6Xjj5BlAZQRGG4YdDVlx+HPnPNaE2C6BcSBnjyJBoQDEtkXefOEp8+6mkoL3EWB98f1nRvrmrVSOPk1aHNeSAJrmY2bn9nbFkZ5TS9NZprpxOLMWtC/S0+T+CZQKI90Axzn0YCRitG+b9VUfQuRswutQDJyiTUWnDk8A4gcRFQDMZQSkryTlHV3bHJ1hRv+ZJZqBjuUv5vgJoILtbE3NAOdVXZAdfLOLz2hXwYMC/9hhW1/4AvokqiJL8oebJawACEjm/+VyF+s8auA6oI+CoIvkXNHOUR/YZHRZewuwsQA6XbG8J2pVLT33HEmIl4phRJeFOWlk/TCPyBjw4NNlAIIeVjWz6mcGdVJ+c401BnzbKEtU5tjSTlvdxOgjmG4A0q5dB5j/E7lBuV5vGhHC1L76MET8Li8ZoL8IXQnICgCDMa8ccyCsyWH6euJCu4bEq0GZ85fAi1DrmSBHNraHAKxXpkE4iEyXhavWLdIOkI+OAndydJCR8ai95iXYTd4AGSrOeWR2QBMc8sX087ugYV/p6pH9SsrWqFfxheQEWQB3NrjbOosvVVfG7TYLejPoJdqKrr9GGlVj5HJFQOyLABKAzuyXlqDTR9/GG5KPU0ioRtEliJ4w3HbFce40XBIA77LKV5o9KNyy12vKTXJTfmyFJ4EMxWpEz5VBkgEA9gAyGalug4nk4z3WQXcuYYPTYI2ztR6uvjY9wlf+8JXUALFypmLZxZN+g2HsCwuN2ebRYszIbw7c6BJIezXfl/EAR9BO63Xy4FSYXFIlgHM3HEGKxtpuRIZ3qj/sLceQ2ACRQ4BskKvDRyLCn+Us1/vFrbFQ/L+w6c37Von/tZcZAGWJO2UDlCfEhhAhPigftgEIb1TCJ5gp2Dv5eKluGQkAJ7h/ItxUiESuC8EHteWCDY6sKL+hMY4gzu5GF6GsiADiq0hpataff2qD36sNsh4wFHj8LyqnbEd8CsY0Tam5AJz1yOj2SidfKO4liJMbZFV9q0qQIqdlmIu2+dSuSUcAbtNLgKDnd3QVp+ccGQ3eMCdm/5P3SWLHj0Md4gFJrgDh14V7Cfz/Qfro6jubXQ3q9MuQA2qL3w5KKurLAfnnAM+E0dQThT559bN9R+rixr42oLxnT3CFeTAHpa6Aq6oAIsKqLvZ9id0q3ofdSbhoYkr8FBNbGZ5wbXotqM9sDwBVYxOsvgnQVDviOZ/BQfdXYajfuHA2pjocxoU1XaGZAF05JCNpmIZSGtOc0+ZHgR+3/ydTDwFvrJZR9Q0hmewAFYgk9rvIReQ4voo4KEJu/n6UXqQUC4wBaCt6yjT2FQBDHzz5CjPAddmHP4RwloPn1LvZr/erlie6yGmSCSqIAKyBLny8yDe7OqZAAL2rG0QMuKLHYoSU0hJpO6wv3LoAj1tYFhrR7JE8HF2+g+sU0wa+E0Kw4rsKtFxlLfMmjQA3wGumdBJS97/iBWrRAGVnb90fExiwHKRn/kzcXMEDACaYWhKFntZdrB0bwwJYW4/Vwwn+dsc6JUbkz6+Y8J0AUL/s6NnxcCy1lsGmB+mYa787lmE1gZji3gpTZkeQuwBSVS+4tCOMWQKakMLlf6wQfyhvsRKdJdD5RWrG5B1/AL8EGWtcHm8jO0ZTFyrUohre8eppxphg7zM3Xf8xJbAAOeZAWu8SgFFwupulkriJ2AVNoh26AlHEQV4YI/kRIgBHchgbTGlGA9+Me7ERkUGHpFVdUBnolKf/1NVKSQGjAOPEp/m7jhWyHPxiKD8qUTcIKXzlNc3MCClmKRAjEGcAuI4BhuAZ99Dq+NLBJvtl9LtdrClxKYTFlBrzMtzkgwAvVqDfjqxuBKvq2wnSXsUyvm4c83ZAyUo2mjPqw6zOABrE36vcQ5K/J+xRFI7iqngJOiSjtAVWWHpF9CQMfa8A4OrzxqsAACJEL8ugP8eFPDZfdB1Ey/3hwws8YAUHRQDzTWeBXjGx+DHBNTzHn+YNEIDidy6kdCcu9klOs8wiADIt3AwG1lHT6WAz8HOQzm2Jd7ivAzSBhJVdwScklV0ATG43QOc/hYHsiRrNvPrF2pthVFzMrdfMrThdMTkrpwAOIk/huef/lQaEob9JHwiumb0laqOzQGUGGEQ+3UBOAPqSO9tsx3j1uz7PhVFmvWQiMM0dN+hYg8RIiwluDygAa0KjHHSnyQBT56PMCc5wLeAk+eN6rXSEECq6UQAsLADoRMZDzseqCemmocuJvOYoXU0//tfTaOvg4fX6P1tiAO+toGHpJPxtAH9b10uR8st8gRcfjKHzLYfCGkpN6P4Aswj+o+t4YZWvjIE+GPiv5vD+xNuFxKUwYVrsdbHz0QCE1UNUnuUE7G/73vGjVRdaewhvUygSRjR5MN+6FD74AIlM2SPVlDQ4C+m/2pxIzZ3paMZWemXYk6x8HJR4bqMAJrU0b6/6GFcYw0uv6aWDkI8LH7fjrxVZaSbUFH8kegAjS2kwg/GC+fiHL3YD2+vexGdqko3pL7H63qBV/2RHAOBP5/s92PsppnxaoUEGJeUhTfdOKgCMzul3j/XoJuQAXDD+jw+pdhlfDR8GpqFyNuk1LziNglDdIfNpjKx+bgAo6IFfqlgavFmsZKRdWrbsLrY19Rupv9R/jLERKmRaAN8s3wCysjwGuerI046vEwdmRB1wZSgKnYYPW0VjN9oAsPKtiy9a8HRCMAmP7MrLn97xGXC2p74AkbkPDqQqHwB3O5D5BFWyMtP5+ORSPYITthHRPPd4iUWeLUzRYN7eAH1oSiHaUF3gi5RVW2JrLL4dNCFj8NxhoEqPcWx6R2YASE9AcbwFkUiyKnDAlMcJ16wOSu5R5+nzK8rPNHiSigAHKAKvQzGx/k8oQ8J1KOCd7BBBtVh4MORM8bFLZpzSALpz01K/pscni66z0BXpfWPJrkuS9TIPRZp9BtPsXJkAefqbR15cyoEzZn5grqhOrOH7hz8ZJtsFw/KsgiPXJwCqmZiSr2ZpiFjeNuhYi9LQ9v9O0sc4s64aeH09AFWYAEN/pIcfFRoHHZHPTFofK63UDNAsOX5gA1qYewnqsFMAVgKk+IyLVGSDQPYa3aknFd1hqs1eiGS6aO2jqEimJAC/QWCrdi9mKn0DKkRhOyfsBEI5wtANhLnnj3UI7+WXAINCzIOl4Iqq2IUtE+TC5H88MmAGg2cvNb5DI6yCV/MAgDr9XcGfJ4BRWDp3+wD3S+9uxpXjhIwQEexM9jXHMQAokL3usfgwGZvkoPqrxTsbrA6Q0MqAsH6aDR77CDFUADOivb00qT7r5+i9b9rkNs+9tUrkoJkKF/bEz1u3+woAunPH7QlCACmXOhIGCPDCpD+fveu3YwQnM80X+hVxAQD+rGt/MVMVZTBe4gYOy/eP0Mm3zaP88/jbSJiGM+mGADDo3zEFozswN/u1mgmqdCnlOmh8JOEWpAZQIkhbgP4AGWvLgwpAzVfxaWklchl9cElafG0BhMUJPcyWDhOEIwCb3wJiWABJCGIKacv+WCCAPiDa1pK/lPPnLI/Cw7JsAJqKExG2l3Ce5C5Kd9AlL4pkjD/NlxRYPbPQStNr3V4AU7JUy8Csn3etyFZQEL9OI5WXtp/qCZ8Mk+UzgP8T7ACGggthgB1AG0nD77k1LMvRvo778g+916qE5l6GfmmTANdUFg1C8PkPEC7Bco02rmr7WGRF+qVzW1j5eaqLatUA163ulOLPymJpPivRW9h0p0HmZS9llauimJzHnsoqhQDi0FIoBNsXmEul8UtGRtZC6CyIIg++8PQj0Nn/LfyoAKSHmF3Cl34VaRivmTB0Rq9TCF66CXmbcoCPG8eKEHwABAuRyuBl37B0I7GTD34uVsdcilkHx4iH/AomNLvedgAA69ViKAccYSO80ZnKAdAu2RCD0W12Xg15n9Gp1JphAPF94QQ/ecwI16UB4FcT9w4C1gnMFiN9Wg9FbM2uHWgAUUuBCuQC9hFejuk7b8Hq4n1C7X7yIjhp4VN7JdTDXwCHCY4DY0+NmijIeRtKqpF5lKhTwngeJA6amw8lSp1vANBpUTMT+oOkfh6Lib6UHH0poWQ8NhUDQFAyA7vErBsADlyPRNEubvumWWsrDvMpVbw1zdxnYLesbAjaa0GWyQDl3A6LV+5jyqGUnVxyyL3gCYXEMNAcjxfJ8nLvumPQAFwjex7T4KHpFgOfgZbJ6j2iilmOUOGG7tFNT1rPDWMAW+cVux+sIjeAl59g61sKUyMoz2ff0vyAOZz1uc5+LwA0J4zxuQNRVfi0CM/L7f5E4MUIu1SPaW0vRQ1VZYWNANPoyDRZf3c7MhTtFDpa9cMANICZGrvH6GQtcYEd4+4APRijBu2hVyEydudDJAUhf+AZwfs32iuQWbA/9V50wQDYQsqDy7qecbJsi7puYMAeHYo1yYG9vP1Jb3Aq7Nr7AC6nYBKL9IjJE4ocXS9LZHdkcE2Y8XE/TIegkwv23VMAxn94ajfsu+RB3ZQvmrBeReZxTdrg/Ld8e+TcOPfVKgDdLO31zWl6N/d2+LNd9aEtY3hV0SL4cpzLYWrONd2FAJAMkeO9ScWfdw5FS6qDlJ1K+s4DqzM60rMZgN3XLt0AOk6si8Icco+mbeCC//7Dm3fSbTZjtST1+NV0OyJgDAD4riw0w/ekoiQyCN9a15gS3v5XZ5wdLhnKAsVQxfiEAFUM6ByG86PJeb6Ob2iGKVzDv7GasEfAytYS+oe5TyIADn2WAxkk6E3C19UKP43Noi9u9u5gk6EQHIYdhd5FvQCIqJRlV/koEFgh+C75TJGO9znom92ty2F4CmGdF4BLAGNKq7Z5AW1C5yEvE1xrzqvkgyaULc1WBcbw0ODB7DUA652jAwXx5eX8VJImeIQ0IekRPV9kEINhwRXcmZUlGABJw+TFtvp9Skd+CXW/W8929TYdrYL/z+l+Xw8E4R11AI5mecmSfTHSnVlSRR1pwlqI/ocebjcHwEHh9WaPjNMAktPycK0YjeKKmhtqRaMU8t132bgZ3PO4wg62NuyTgAC4TuY4E6qbNSffQk7MHu8uKPNwnumD+DH0ADFZF3zvAFEbqFHJwBE4d1vh7iGzr9AG9tAj/4nNPJo6Ep1ng4oAFXwGqLX81ZHmxq721kdCZWxz5K998vZT2yKvwkahDQAOtjIgDrAIxMXVZh43Vd5DS3u7Fqn+Honq2uhfh0vRALfxXftnDnR34XNFXdjnH+L2iuOulOpadDzpSGxKyGEA8LtnnbrvBjiaTYAsmgaVF4aKtiCAXqidg2PEq129JQDjat8E+rtURjFDLCw8rIXJ/w1wXM7kq0rFDc4E4AjKAK6arqy9BW64Hq8Yw+L32NAKGsuIixrelX8dbqJNJBQACq8yNF8euJEyCCUen2oSTk8wlUG8Nme+JOVWqx6+CgBf9VABer39EAbsvyVWpEzMzWBBy1oG68OWI4XZVONjAClt+zyAK4BKYXwQ+DXWD3JHn9YnnTwg79mU3H5pyOcAiKUmU7HehDejT1eFhnmOB3MUSDfUosRixxcr7tcXqwBe1Yv7T4P1zgZPPAIoWfH/5SEQ0yxyCald2VpvSkeKAN1/XPp5CMh3sOyIfeNibKJ/2lwnZ0CmA1SObfkbslUAznC9JCP1/0vIQ+XCY6QwlR1CAzln8Dw26kkkWhSAagAHcF/nWDRFdjqtqQ3jCJIWEecoVnW6WiS7kDnrvgeMAHkbunZF3JGcr1EE660pHGuYserPsQ+6E/KXRCUGDncAHcwVT0vKpZUpOM6Wm0BA478x9D9bPPYFFYQopllVewBTPPAB5X3/GNF7IdccU8vftCxKCRNbnkjAiSM5Te4PAAYbS/aBmBW9T3B+IijwRty92Ps56Xe0hwKvQ2fSHaUAxuFuX7FGpj54H0cXXAYhWHc6RQj4nF+qe3THF1P71wBJH3DuBZgfU2pCsgDOwkr7IP36jGSSZ+GmGo+2X2OaACjzkSbz/MBvnKwTqhqACASBsRBzcN/4fg9OoWB1gEIAcN538IwKpk/WV5ZM2KviDxvy69dsRzYKIdUQtgfhBwDDqoRdxzqRAPWY0cIDkSIXRi+BzA92SqXjlkJltOO+APercUsIckXqUOsOMQjw/T4hNm2MJJQE2/oAI2ft1/8AX9z75uwgMiUnRaFhfBOdJNfbPeY5xNNkPCWLTpekkQDWC6z7IL+MX/Ba3PpO1PVOvQfeb+53kDAJjkP6yzSbAIMYOHttueQuQYkfhVQzonJO3Y7+rxXSYmIBFbG8YvgAEnOwIvQGN5UuDnY2ujNByXg+ZDsZupX0tULazjKy1QCBoyOyECS1O6r0pzY//bmNFKmVb46qV5rdynZrBgGfAPzsb3LrdBDX275HvC66ID/GWIniDm3o2OVCPYfIuHYAoTT1+4k546BDXLzTj/iV2PM4fDYUVcfx/hwzd/KRUwARavYcJ1CiEC3EWzRRzVH/FnvpwMgokslpc0i/5Vy0AO0jovf4I+X9m7d9Zx88C/kSaCQ4HB7kavLmkx9o+aUAUnBLkP8SAjRE9e1G5V8BCyu3Hk1tzgKQd7W74nFp7gAMKCcLskZfF7bhbqHdxT8ovN0TkLQQ6lg7NN5bY+56AJ71DJ5AKi9I0Xi0MkUt57x5f8WK4WiUyF4rOpoXZEYAuJMZNHu9cCCLSoix8NlT0qBlITtreCMtWnxeo24EsgAIswNa5dbt57Xrls+whmArugIz2EXRNguaXPZYW6vlAEWZaoAFhpuvdE5Z4eTwebFcmYS52WRSQxTlP/GANrwAEJUUaaP0NermBQicOkvxvhUmwXMssKTf5K6zYzJH0wCSM61Ty0j9SChSt2mixIbNtXrPki1dPeIFHphsKzZEAGko93P5tgX4i+FB+nM4HwtojUeiGExa1xMBPxHFwLkAyAEXwdgHx2E4ePtfLTuRyFzWRlSC4k/FTt8L8LBZOgBQxHj5mOhgi4i0Xd9h0QjWcNhVZqUwFUTaozHH7ZP8AP/15G7P1A3nVyJUyyE39x3ITdRfcFzXTtwk7GVoeK0AmM/V2rAb8QG2WZKDxBoBELfuoTKCWmqYFH1RJoCUCAAINdC6syUYeEtcjzY6In+HbB4rmwp5Rh0vyKMo8DmyAAUFLbDtZZ6vYT3hykZSgtC959skCzotPb3SIx0v9y0Ay4ygGsLF89JhQ/pss5u8M/u6H/EPpbeWtnzzr+B+lABevXUcfqD7dmkXozJ/Y5pi5aNbGF/M6RBqOnK1q1ftABiRCflID9xv0DDDH/nSZ/zi88wjFgcujUZVCDKPRGwA+hBRkqT3dtGI1OBL/WeofHVRvDtF7iw4KM5LmFMYIwByaOmU8iNHgRLu6H/LhWTJzqL7L6NEDYb98iiSHLmrACUOoNcc4DwmC8vpih1v7VqY0LWXNn+ejnmHyKzqoXQAB68i26xzSzpJRYjg9bgujh0FAL81O1KwtZ1UuIBeYwBP9G2SHfVxWyvZCi8oQRMDJaQe1FBRgBIqqR8zXcB+AF79L/lylLlNMEaNiip+AAosLAHDdpfKYF0NNY3EaSYAWkNWl7ei1Ijw4vI9f6i+GGcwe+C4jDdop8YjB3FHNgABh32Xvy72rS+n/V2hPPzx4vRkU9z0JJZAm58wQXBpAFQTsFbvdnDtA+Gj4QH84A5iQJOx0T23OI841ZEJ3GcAmphXCji29TrhbSc2ovmHXKdEIAjIMQhswH6ORfDvAwBXU6dRIps+EVZWeP1a6zbCppaY5HwKaV6obB237y1eAAlM4XmnaAH/OH1sulT+J31OT4SOBj9HPj5iL/bKc/8AQztraYzmfUPu2FBNfN+F2+aI9OjGkxcLVEtHndjI7QBDfxPgeI+XcDtQgcfIJvg5kt4umlrKVtrnlvGDSTyAALgBaoTDYo3wQijWyhi2aOgIT4RDH1MBbf0h4v9/obYAdiWd+kFe30H8EcLTVfNfGBPdbTkIWJBeLAQKeGHpiQCBb7LX4mTEfUcyyh/icIg8VOYzQVgVbftAgBLDfx4wAGiA8xTIs8de+VEwDJBIASDIVa9Ig/xSgOuvn4oCWssAh2JuRlQqUECyMaCa+D7In6vXavOrI/kBDrKwhPKkyQCmVMVzCNulabGf3ksp7VhyMsSVHlwJ1ldxgEXjOEtpAOaBBRPYb31ruSGP0dIz7YM/aNe8B1WVFQ2ddArxPSQAbIs/vkVym0InJYZeP2c2dhgO0qN1UgnsVbwXV8NUHwDGCBsCDzi4gx0Si6Ty56YLblreKJQ4gedi4l7HOzz1AA1elxLOecVOnhmG5wTVvLFsxLG3H6EseA/1eyrLV0gAPoeAZBTPktM4WoR4rFsuHyGvtbSa3oYtgqD0kgkvcgDwYwcm4reqgMwo+yzLVPB+irTyXPyz9yVewjESkhoSAKNRHCHVmRlA67FLurSrAIv04ZQe7wUopfHrx/tngI8A/9KrsWGDw6P4YjwZAFCH3RQSpsRnUo+viLg9RgncWACKZCs+g9/CKdSnm66AuciQDruAL5gSH7NgmU71qwShAKtj0l1CfixhT/2DsZRR9z8y7VEnzKj1QjAyZGBdZfYAfyH7i3z4+JhVtYa42Ss9MBqrMw609NJcWf5XYoLvXAAaBSiC8dC/lNtiyJe1Y8u+mwVYYWbiZx5rHOWgBPVQAHNnDz/YVcrzBmSMc2bME66vPd9qFQBP+JY/ZZGoUToATL7yS2D3QwKIEvMJ8QzjnCjl5hKuezkqygL+xLcY6wC/XztF7tL45By70ZhF77htSKznb93j5afG97zNZFteALOciH53A651yZNA6deib+a6/EAya+fvqYwzZcCJ3HUAuE6850YljF2+oG15wBhc5XeYElZeWMt0hqTsDYJ22wB0+Y55dLWNC/WE3lRAOh9q24dXU/fUFC7AmAKoY8LPANjioM+0zAQCdDXxnj2zWZbA15Tms3859cEonkf3F0kAR6S8TWhvvSoIOuxeOWiLCTQpPMHtCgAc0bCP7j2sUgDt8m5j01nv2R8pYIYUSi1tmnuM/VbKC+9doKRkoxZRAByuxQFCGcQK+PQB0+uHZ+bfb2cAgNlu2Sd7eN9EB9cAJSVCm/oKtZ/gA4jVSidxjlnCMpSxSTELTUB2fclpVwA5YAtG67FBOU5d6jB+69wAPhso+vyNosGTqH1DjIdIAIEWPa745RSa/wOruz8miPMeIsemJgqBJRa0vo7OJrgA6GzfOlEk+M/vhceqRbtBsrkRdLnXHfdmAVcMOqKukwBjRJgH13DqCCbIb/xwIRU5aYk+jivlKjEf8QIR5xvNAGmipNSqr90nakNI1VdiAOuPxNffvDonpCDsvbkBd9oAFRjK+71+9cOQvMyQ9Z6FWAoMXKzxXuxnGYQBut3fGAC0IKjNleKlKSIReZOMonexwDAJ89QOLe5h2URM3gnTAHmNn2SEZVE+0C/OoG5plQT2YuGewOe0cVi7SHFlifkAjWR43NTBPKOFmlzgnFg+6lGMf8wgxQjNFn0EKbNB8QBl0gITZRhUny4cwy+KHAtjKi7SE8i3snUl5VmlNzbuAIN3h/PQwR+YfK1w8y1FxToyZQU5IoIU+tDGV5IgMHsAYmkpxvpYI678owiMJoG7kddga+xhtwBxgSEGNTD8egBu7cQjXe5IVwGp3ff3OEBnMYV7a1+GjWXutLl7aQH/ANcJk8BtzHpOYXDNXvylW+Hgvbg+HHcaO8pwhBP4Bs0A53iLPiV7yBc4SZJ04e2rubxD4uM5WUJ6qIR4DeXMpQASSozqjqhVD/kXTiypUHEh5969hcIunOFq79VWmjNeAPtks5Yv2sSg1NWo2jf+qdVs0SQCNCeVyv6ttR8WSrEAvvdOnOk+RmCPXsaefH0Zr7wd5qJy8uXVwUR7CN9mLQAlaBdr5k8l2fUeWHKs7Fj5c2IuEnN6q1QH1f6o0fUpACDiPyY+uUiXFZZdPjrzHeP09/H39tmXlH/1w3WopLkAgLr04s1o6BLJAPO11GxrfYa55fHfgCE+rauqwPte/QD6PKUPhTcIRiP/7RFNuOxVOXjjnLXdgB+zCDw9GIUIALc/97U4b2rsSh5NrGBLHhoLf/w0kxL4VWKEPhe1X30ArAbHmwXuY8un31AGJSna5hKrpwRTLAVUNEQXOJktmQCLPzs2bJaiQTpLxSnOBZP4FxsVHalg/n6hjYLcbD5XABiaWPqvPgQEbfYpJw/aMAHVoPNzqp0UILjnFsmZsoQADZ9E50Qy4DviagKWNbOf+lBCXnDN23k0v+GfziYBLgDlHms7bjbBaTIQt+pAzBPNYRaNZGmAQRYT2ijUnMT2AB+R7FzdglTnYWKMXqbjW2x7+fiPxMQLyJTAdXQDBDcAosoLC0/uYRDlt6h4LsdSFBYesNJPp0pmjyFdDpOwlACeQ56eMTfHX4FdCFG5t22Jpg0KZ8FeD3UJ8ixYyOTpADgu7BDlYTWa3Xt9B+7eGsmDWgrgPs6uwSABRO0UWUMAVKn1hAa8g+GIUr0u7L0rggnQaDLKS1O3DJ51hmjJbgAYx3R0lgDBiAcdU5V00QvE4dPYW7jFi4DCPNiseX5ZAJt3ipm9wHuXzKR/oKnVf7uZHuoRXqz1/P38rM3z4r0AAz70SoTlCG4y8/EzQmc5FXLxZegLWax5cldH+0tTggCCaeZEV54VR7ZzljXC7zNlOQjy7oFVx2Y8vmG+qJAVAFe2sBWCuaIul/+vePN+mQXOaAsilztAW6mQ2e3DZAIAXf25IFZXKcje2JlGdQh2I/mxkdXxhjRR8zB+FeBtgACjcWuh3n1TsL9KnHjo/tlYNjrq6v47ahvRpcgAmtP+AN1LvWvz8wZLCP0y2rfVdi5+ZgS0t8+xD8U3VnLK+uEA0WXs8bgGB0CRrD9+jRsX3RQxfFKbvIlSavfhSVRlcABglXpLgYqFH8x45rLUd4QGYLR1VsZvv8hZ/4u0nhP8APh8/eDXPDd6q5QsX2L2iZ02jQk2hG/eyf1ZTA8wgakAG1vIGBNq1e3isN4y2xrKZk29Y3d+ph+eCjbttRMiRwA5zral12f7IAnQXy1T2+nHV3PaAbC/C7YLMlKTf6YeAA6JnVR3TeR+uR+IDXRQSRv2+oPiPkuA45ok+Xc1eMQA/+c06iNzBiode62KHHCZee0x9l5uxocCGrAnGCRxcwCZa+cM6VE4KQ3Lda4ZPMAvf6y4L+Mn0h7ybRRkUBp3ADKTwqLOOwehPcWLJdN7aqDowmoDwYSI1nDQy7zxvQoAiqP2eYrG/pSHZu0Ko6BqcAZSUyURB/cUkAm2q/cb2gAHmtsqshwSeUEEsuAcTZgDLacXibVyJx1/kO7W6gapAAp7loGwUu9ME1IZlD1lZOdXIFHCxzTBRFE1AgGc0TkAPRzLxAMKD5QDqwdJKH2EQLjepcab4d/rwaxFigTY1QAaCI0O0LqqG2sXhesUcGq2nhcsjGgpYlMy8wulzul/AE3CGl+KdumLt0kT/ohMUGBxXtEaUZZwV3HDaLNlP8MA9zvPt4qz+XoF+pnpROmThTiRnYETJUuSPDVFQrmgIABn2KVbYYlzu9MDOJzSA4y9SiDZai2krPT1DiGyB8qiAEhsFZ6INakqa4f9embTa49cH/rTvTbjv7FqjowxqJsAcySCXtGLDmLGs0XCvKHqRb+Fy2rKzAN8uXskY6LOQwCswIgUOLWsICpD7OhlDwnJsp4YnT1Q+4iMAFl9Q9vUAASgVBHoi4RBOQ3Wp9aQm2BZoiQRjGzfp/3W5sJvAEIAbxiWVOxJorZQle9Eqhv6BTIHO8UVgC1jPvjj0lbXKQDtlkERg5FMBq4VaWnLZPXyVT42cmpkWfsre+BWq/7mAKI4MDRdT7+FE5XnmqoVHLEcx0dFcaYVsVdNFPX5Yn0A6w0ZFSTai6x+qomAXZx96+Zju/KQ1VWsKrpARgWaLwCmp6EC2THlAfqBMTlJRqj3zfqOuNgFVk8BIQeoF2JiAGt4lRag1AGw7/VHVldDHK9VJjzc9P+3LLJ0yUQ0JxgAcTif5BRtpHLLRSWppxc6/1Xqa/DIuSDc2qNHWhTe2AC8BoxG8JpbvwbGTETuxsrs1ljCaq3gBdd7mF3H3UboAL6dt4h5FgiEZBy0C0PdImOQwAVp72DfFgMX6pxQHNIAoaRDpOjazeJZflSG7xyPZYz4G8Qb4zoUcxeUqH5IagDdIezlfyXHMpCmIn7T+jPxRDExJeRwWMW6n+iU1yyUAIeDQGtHOKcg5nQcMAfPS7TJv0fWYjDUYpcpMzIZCUIAkWPtlSDx5qP/W2P/4yPjPE3XOB9nvTtZGEV+qNzQzAA42XYxAWL7OrFe6+NpB1qOHDDS+NbMOK1+u0kzNKp3ALxexs7NWlzM/N4EZ//amzW5T3wMowzWow6UNVS+S+YADjvt1V7+nzbPQjv3q786FIiP7R5YrmvhJigA+7jIzQAJP3i0iJNEZSFEODTu1wSstONXhVhco/Nj0lnrDBTgAN+FkPFcwKd7xaZyxmzF8bzXyZNAEeX2xLxdC8Xc4cgA+H6XFmfetaXETX8nIjqKB4O+wTpwwkO09W0QnPjgTQBgJYpIGBqRykBAc/wxAwICzoocJHW5J/I3SHqxaALVAKnVYL4qgOsTVW0N6HidhnfIGLrmJmsNqdrGkepcM6AAxqgoefT7HQnJb1InjHWwC5PzXIWTAWQ5udMFQnBTXQBNe4NgiVcTGSvMC0uTgNkLJpZZvmTXEiF9YS+A+bcpAG51g54QayNUKGCS1Tgemf4ERpE92nTgv2hK7HHizaEAGmTTFn7mTNMSG1ipAIVu7B5doUoeXb8SnDbIDlGDLgDjGC47OcZoHkqIH4lxUbvKcN9Qj3TXXLQmSxlTn9KHANn1dUkW288VW94zIN1qlH3R3651ueLoj9AjnFjnqR8AJ3mp8eZL530ak8Yby2Btva6jY5viI2gKdZivgslrVwAukSWaA2vxTop/uH2aVGM2KlUmFH08hFsGX3nO9Se+AP2P9dZe5k7oI9mCOv5RBi6HQeA9618iANYak6aToMEAeMj51UhJ8fYqAQOA44k2qyzvDTF1Wc+M2XsjuNtt/ABXnNr8sQF9EGL1YLiEwbsU7I1Kzjba1f612Y0rU5mMAACrebQEp/ysIQ+2fIBGTn4P13YSFhukgkpSR7TeewIAQCF6z/Fjk3L7kRQNHCMRPLikCIHgRqeohkCIrTXM6QD8hhi1LLMN+CBZH/w1gPNzJgmEzJeGnI3dsZz/UGJdAKzfH/HcOkLKWu4W/I4cT84mGoljlUOpxiUONAatGD8Axp0nGOp3H9rA8xWFOAaPqmkNTrX/ic8LqAU6NoiLZgCFfeYPNXxRvpaRLx9EMk3ZEYl/KBjvluGWFL+aRSnmAA6JMDDT0Rm1KKpKULQuGi6V/t7nsdHaL0f2PZqArqgAq3j7+dVr2zyuyqEfSpCRsTUgrINbO0dgqL2G7PMRBgC81IslxQDm5Y9c37pYhlxwCuD/5bDUB+Z3QWDrHK8JAAVor+O9UsQux5sUsgk5lFQ0NKUhBfOimySAGn3umFAAoCFbseXiHLWlbMYC6j7xC6Pq1/Uhxi3w/CzLdGE9fwARXD8Vrz+7t4vt3h35Ew6ckH6XiR6ANpjwHsQpJcfjAJ3PPz5wK4t+N9jIcozY+AcgOvhHO0T0L06dahaIzt0A2abbTHwpwu5RvrQdDwv/bDATyMP7dbpkQ29vV5iMUwALKOC51rhuR0xkB04afkLrbyIWAJ9pofyyaPaTrw98AC48xbHHk41BNJ3HVqPk30YoPT03oUOb89bc+4/Z1gQA0qYsMnE9pPPVko3ow/5pJR/DSGwmy1orXke28dpX6wBG2QWjq9dqYx0wl4cWnW+IfESTAl5sYyksXYrLVP6EANU2psgJV8/+K78cpl1VfdIcZOP6mHWMMuXYIpsc3Q0A+aVirmSJFXWQEotNmf6M7iRVf4ACofJibsuVUB+/6gDqvUWZ6BYSzTZNOx7e/DG5II5Fw3yJor+DC8ORnMtCAMrfJoR5G7Vh3VvPQ/JsC2npxnWWUVU4CT5yCKfUzhQAOoSbkKNIMTkckmOoQzqYZNo2LoGciEX3raUuDTvUPgCnMP8OHIwN0v3tfNNoFEeFvqlqRRCs86BnnwK0cywKALDRIgKC7EgksAiPPmZ70dAd7yWAnUamFHItwqPoUOAAFJW/P1N/l7bF/Vcc9M8kr75UlQYvoVmjXQg2M0EpGQDcQZ7sx+L0784ySHFer31fXbJ7mz1XgGFfbxYQDnYSAKGxCZ8oUcQkYb8W5M1FimX0Ud9UoUYqv9IJvPuIegsAifaoNo9g0kW16gL16kJjjfB6Erto0qkn2I3Pdd2s/QAX8Xu+bub/ONpeV1F3B3dkpapZqcOeDo5975OYlK1YAHoEVnytYaDVNJDxWBbzlD312uy2MOLQSbXMsaxYA7AAH1MUnoVVjlVKdu/RB8GTGmTNeWpauDUcYVpRlRgsJwDf79m2v2gQKuAGUOtbtKfMlY1MBHDk+0ZJChAvTnZlAAE92zWYXOl0kBdkTFOuAceiid02z3tYQUV3x7Q8WT8AR5nemLZ3sq+AK8hdoNRbFJgJg7Il0CkFidPqrOjDLgDwVH7aJQNVYmL2k+mh8+F7tC54bDUmyxDLpHroedvdAPbTNKNjN629LaDke1424Q4GSD31gHX38lVgUq7cD/wAiUx78e967fPe+zOC47rt4fC7I/cnrwq0oRELwsDBPQBFA4Jb0H4Ytb+K5xYFCg7sqjXVTapdKt8GestSfpLSAK5qjfH/yZ+mwIXxiirR8DnrxtqWTM7u2X1urF2f34kA9mIDj98iYtXKV0EuZGFjmWqUXJtem5Dw1F+e4JxMXwAu22gxsp9JXuKLCkuGEMt1IUuKQOQZcU+0KRNmYjM8AOcqL2/XC1fOiOWV4ZoBiTnFVEXAXM1G2+9WdwPTSuYAaqU69JSSdoh6feMvjigcTcwg53aCz6HjH47MUo8B5AAIyfC6Z/pKOjxikbQIlVJQOnNvDs698vd4RBIFjj1eAM+U1+VYfl9Oe1RxGtjL0ulLbZ4hLqbYyyIRpAZCOgsAjE9X8Nr4cBjDt5xRYQScqt9oV0FSs3Na2xetkPZljADj+JaO455aDHVusPSFR7dAFZEubSuI7Zo9xpAsk1AsAAw8BDzNEJTTe+QU+X7VYI07t8+22NfrtBys8Hvv7soAB8/U/GjdUFguj+qYOoa7zc3WCMflfVvI/eXJsh0OcgB6B++bDACN4ScxH9DDdNh90rCh/+xZgem28YvVjoBCALeTfhYVkTdFrcLCVeA/Rvav2iWcSQuCGVOqIBGnup8AabkZzuNqknk+ggjXm9uJtnGSf9WWJi2w/hW0xASOmQCgV9IDxpy4HJkN0la7lg1pxcHXF+BsKn/MiJOixV6+AO0sOCuXPc1CAZZUd2iqvmwFB0i9/7n0ha2kVpniFlgAM5vwczulu1h5z2wHJpwxCmKuMH+LbULfu+ORUgfbjADfR9xg89+zQwTjMWPe9k3sNDsTcDCdiyrFGj52UTU4ALJ3WVbEshrgOlSgGXKVeoFvmnuSSZO5oiQauIhvL7AAmBgWQcdwnkrSAilmUcZmcRCjrZ/jpPcQXVq3puRKeQAHKrl3d5CBVwvRhxzMtX7XFzvX/VmHnf0tdPGptoHkAFXZe21Ymzb8LLCK+bdZYMtx+rwauRpxSe8xD+kZzOEAfl8rac9xh9a+EwDdezq7fpbqMXTjnup5AMW7804T5gAkx9uGhhidAPCWdz+L77niBdFDaJr2ukXLqzAYca5gAC9RR1RGHdS5EqF+qmBSJySN1ZMv9auNHRxAskJyzxgA94J7Yi2ehJoOI1bz/XmpvCXyHZ9UAGYKJPSueWOV8ADNEYpGyIKMsYPQanZfZL0QSX575fcMSDxRFU8+DYjrABN9YGsZW/qoy0D+PjZEr4gMUXSpgkRXolYbi8LHuL8AsgOC1u43lZGMJ3xUywsltIUarWmGCU7zZS7w0As11ABsxHIB/4o3XfQVBGGnVo3Cp+8Mer2c85mLTSdb8fVlAPuVDxKKTQyivUsvD1pk+jP1I28b8RhViY2T39HzARYABqR+Z0bf6r2zW1Aspmy+q+7rdaUqlEFVxZO+pMTBcwDPZnC2QvpZvAChWYeyAORD1tDHmk1MRgz9VwXlnyF/AGDQj99tbdkr/tkbE6Cs9dkdLVJge1djMx52xAbDf68AVYHCjquoQq/OYeLlhxgQOWxtVEVaRkDJC+T3ygLzLADSOUELsoRSqTeI8QRSrVVf4mjr9grINrF6Rxuu2OTfAOR9yjkaojVconY/kzIcSZ5DOE47lK2V5/uD6CFTJq0AwSTnc3ddpLjIFtUx7fFmnqJfgrRFr0FIEmOgZfjAugD4dWCw4+SQ8meMtO9BVbBgrn380hNlOVYqSjl1+K18AG/b8PnNZdH2vBk1g2CLbk/080Dl3aeb+ExA+iH1CGkAXZNKzNhExJuD/eYGVaoyINtah3UxtfjMahb/1AjL0wCNzMode7/UN2ta9PjbPXsNXi2JfhWWxzqzhxn0ZjbsAHubvNgf4OBtzdVKx6v+eP06YaZgg7MyNsOTDaEpCXYADA89cJn6WmTUZA6mvslmjG8sZ4fjbhhRlxpq5KQgPADbX4NHRyKgiBC3AnQjckeHPQ3qYOIdUPddXNA4kiCLACmYDsaoJKwHt33zd0dW1H3jzdU65F+ZM+LNyPDTDgQAfBA8fN2Y/wdviwGzg5ju3evQVzqhTpqgF57U/MwXYwBcZewLOZrP9itpzTO27ifncTDANY42ahUSogoQXq12AOgjr0P0o6G0gV4BWnYN5qQormmd3ls1APPbyVECoYEAi0C6dWg2CVsb+33T1WqsYGQ/Rqlp768iQQZiZWCK/wDz3rdkEhoEEBtg+xbEH5V0BCSiSlhQKFQhXRaIjFLyAAkzXMjTsYqN3hleSGuGvNzpMD1H2pozyGEeGRzXPqcAwwIkIVXQf8i00Yqrev1QIp+iyhotw1cZQBfSii0UNACaU5Zj/c9JGs0E4xWrlygo9tHbkwBqVNfX9T0la7kvADPPY9iZFjcNQHxO+wfBaqfK+adI/g26xwwrW9HWPCYAtn+ns9LkYOhp9BD36nqb+SpccFF3kwO0cnUW9brfFQBxmeM63SZlSLSw/dKn3jUWN7Ydvx2X9BaYnHsJkw5HAFu4f5bSsxGSBYgVWuAklwJVSL39wQPoK2TDXQQZdikAJp8J4TVUtVxLfxYig8jqhNC8LE9Ob+3gpPV/Ut3pQADsrcpKzMqNlXuU03XH9KsK9oTOovV09vFeOrGI3tdbAKYbzha6Vkn0j401ZWssKnj3OF74XM3uyvMHLzQ0SmEAmXo7Ogg6Kgb1tT2CrBxdtAectoMPz6lwENdJSPQ1qABBW+B1VXWRG1G8Rx/fhs/hjFFeRgaSvhGDHAYZHNpfAOtD9wNrVJ66R5v+kj+xP0lSon6zoZGrUZvdLMXG09cAA/fEdcPGYujRAz7KFBKKNT8koKP23XmFPtzIgA9vFAAOEF6SFbDst15Vcomwg83O8Dy/zoNjBf7tfY36gDh/AFZrnAkFGzD0ZGwcvV6x0XhgpSdJ4iJ47tTCaHAPEe0AZ4tHqVrz7fsXrWeOj2hakkRfBcCqwKP7jgjHgoNueQDhezqr8F5YT5CEV5Z4tlReomvP2qpAh+VNwEJZV4RuAKMbv8sZT1QFpKYPm0KZlCKDbBRNtqcv8O2SmiBlym4AE0+17pH+qvA5mYfr5kop3fzMyQerwmpM6JBAUKR1vAATeU4Y+8eZYRYu+AgenMzxBf/sIijBuSGXWzgBd7dqAPVS+wK+GfHjy2nNejBmiqtv27CPT3e6/XmhUSTW2bEAou5LuAuQhb1GSZXe/I/g0nhL7jfAshvivmNmszLZDQCx0bIelvGMqP0k7xiMkTwH4qvnQwebgLqWcAQOb86kANAF1lONKHRflWTt0bLLUuZR1VQsSoyJq12s0gF0ibMAm2nmKgMx5f3j6c4HeuXrkYeg5jwvShzGcuqb4LQSQgAZAaYZ7vmrb0+b/x2849gw/GSeUTDxEYChYpU8Z6NzALnBXarJaFh0RjB2oRgR/8cNHFvJGr2HeCv1xldi+woAfu4MxIzTNgJghGl35Qj2Ux50BPAPVizP+LH2DqfoNQB2TGpL3aARokJavBvBDcBxKOcXxh3dCqPD3JLi404WAHrKOStWks5z/Iql1T7mAhYkRzGUfUpnUwvVPjAwsVYAJ1VKiSI0HB1i+oydhRHlDW6WueD9QrjEfKEvr5GR/ACfQK/dFkZYtdzWW/d7TkYv5enrdvDQUI18lM/JfV0RALqpdmuduqRm4bnFTmry9C5hL6ShTxJ9IQfq17A8lQUAd35TkE/i2r7wIuXlPUB/BLQXxE8G00RvkqSqm5kKmACjfZG3Db6Vt2qZQplXZpkQJ+t01ZY8bUGjQ4RHljNuAF9Ix1XNINrHG+WI09PLebPPsQ3gC1/VOWFby2SBq2wAPdcy/ysCHxqXfkk1fwfWTb7A9KeNu5mMhZp6qHwdqQCTHvRtcVgjFa27HSA41r3zV5zzoHgv+lKOPaOv5w8NAJm5jhLilIhYWplwFy3SxRHv5TBt0AsDxch79zu1SaQARHQFKKe8/fQZ/eYK0iy155OUv1doB7CQKul+PNCiBQCXhIi1gMfMDHz0iVt9u2XM5N5gw9laZl0j53tHaostAOp9CAFlepvZQT7uxSWaDfR0euBQqwJn4b/COSVdR1YADgT1PZWQf7rrYxzRWFbkr2ZCHUmnC9HUJYIsLFREDQD67JZmunGC86SjmxNJF/gh8KHuYJIVFc4Ix8AyV2EPAG5g7FEYfx43rHREGHotbpgRxtLvJf7aHrKTU5dOgfMA4C8gBO71uvEtqc7OEteLuynGcyzHZ183xSZOC/x6agBmdeNW2uhmPShm32EaOeD5VeF6MuQEC9aPdne0dQZzANjLFJCqsoFBzVJuXdCz5+MhkTa0oq7AQ9pYVQh1l20Asg+wn/rmTvWIHHQQnaqeRUVGy0ZlVOw1X3aWdrmqogCXosN9XcWd796+nsEZI3b658Gx7CLgdIHleKyrBaZuALvZI4u50YOX0bBAg5njCsp5heKJ9JICFlJC2EjeF7cAk9VB03twxQOBm7uIkB1EOraOZL+dKmws0CNpotOFawBsqODpdDHGLhmNS7oTcr2LTM1lXZXs6KiAICLoOVtHADV/ZSV0zZHxaWa4e+m3sxhmuA+YOClxYI3ZSx3XbzMACTmLTAt7teTYd3SZltXkC84imjct66M6SsayFOdLIABXH/FqDDfycJ3wSFb6ZYvMBk5/zQQPJjuBumvUXXhsAKVNvn1bACNrmdm/9FvUaZTYfLr4NDHMByTpsS3o0O4APLFwncFPRUSFbuamJlFm3Pk4Qlwa2a7444kLP0x1TQBT0alRB1lzbknBDaC8Th98iHTPQkTNnvQPoqHZVDZlAHx7eAIO03lYubmLbZ2RNMVHRXlhCvs3SM75V/uYiR8A0LZqlqOudxx1534QvvCOzEm3Y1CvUMyoG5AJYH6uowB5cyg25cEmg8AA6X/qVnjKWKzwAAlP+h3NTpberx8kAEmFSEPfSKT8ssfWQ9E2Ua/q3tyZzsI1+OFxk/lo2gMAVu5Sur6NZjbFWRjtKVUJq35UZ8KG6iqGuB2+eLcIkQDpGWULh3lQzxr49UsYkZ/dkymvwRuCdJpPJ8fRwi0eAFoTSF33/xaczXunK0n411dkxaMbKp20MM25slhWN0kAo8YqEgdRAKGNSj5074omSwryf5+NKB/NoN/fiwnhFABLmXMeEaDaGjSN9op7JZO43Q6RFAudlr89qlhYQxHXAH0EmLOdiCd1mLuq2GgrInRpjqNKWm/Fq3Pd6xHZUlcA2p5BwwAr+pEBqtXuI0u3OpYcUrAxMf9Mdmls/qsgewAC/Qnie7kk8N5OwRhNJ+QsRN6m6089guk1D/TmEg2hANTY8ZYCt1DJBiRe+zpv8KlrqrRabGzmWwM/ehlDD0oA2XJaBmqgKNRhlX7ilKpnDyZ+TMEbbcu+PH3lKU5yDQCqvP+fVdWPg1cjnP3NX7Yjmu5U0s2XjH3xe/ne0e9cAJb8w66cLS0Icr3WLifo0tAJsXofQDs7zQdJ5jUphlgAIvil87StQEYmqEmI93J350kM+koitnIgTIJEzvcOxwA02MFAFPUy/n9n5C3zrLV3xcssQjFXm9HfryCYKXoIAAhykdaCNRZl6Mh7LhNlFrmjZcXfsugR8aKrwcahDigAVrSLy8aHE97az0/ot+vB34OWsPYjmQMQl9dkdrmI3AAi1wRSHrCs8+Dd3ku44dChD9oSgnkrNjOYQAZAdcFiAB6NBRh9j7V9x1vFJMVkWqSAWJ6hLC94dRb6IpmBhYcA71Vk7RoLpGmF2f2aSWiwrT3jId82rV875KiBmYBsywD6uXDNv6BoRUVS2GM23lUnYdltDa5BSTCvBC/1WSb/AMLPXL0W2fYcS3V31Mxtxc77hiuH7xUJ11DOVTKgvAgAuFftD8eFkxDaq5F0CnmTucWLNysWFe//rRC+KO5AAgAjeZufE2dZGLFqchdolE9CRrXKM/YCf53YZXO6I79uAGqyA6rFB11gbJU8ictVNh7tP5t0AJm33FnbWGS5j4AA0uTLViPOH/BdUF2ud1p10X0ZIEvvd/uBYvaaNJDsmgByf9NdXyF2xJH3LnUeXVY3N236kN8MJAdGHSTtILISAJcaRO/aiF3bh0YlrLeS2/hvfPbA3en6U/5WxSZw6S0AzQiBmgpk484j9JfN+ZCcaFVMW4IN7PxpKbes60LBkgAvioZm54C1oLe5TfmXNgvYXM2vRhAvNCz48HKMVrFmAJvsf4nCuKM5rHZS8RFqe4jTjqLIapSxue8KJM74708AaJKoAJVfRPoNdCorb456FL79RbobP4tDC/pwJ4x5IgASgRtgPTXssKHmZxYSBGfQ84JdSvhywvhaZ62fI6BkAAEi4aUiNUrdGtOh43a1poval+0UTjK7+4cgLGQttlcAwUrL034+93wt+q7VeJhGeiAoTdO2i/Lr/ScJYcxeugAUl++k3eOPiaZVT6muhcDQHF+TeWIUiiWKblq+9Xs3AN10+l41owg90mWo43szYlSmvFbzv/U3fL23nwATwqcA3SBfckYnfQ4VL/Ljmfkj44ujVogrdSBI+CDOlgiTfQA/XF6mIbeSS1BxZob6SQIb+NihITISxmPIDyse8hJqAJX5lq222anyUfiLggDBaF3AZ5lO8QxN8y1KFxH911UAYEmB4k+cCccNj0NkJorvlssbXmMtJ5fcURXG5dpRZQB6WidJ9HNbqyCFS8SJ+GzzQMH3ElRew1TlEBnzBaVPAHU0rvFs+YfLqNfAaWZ1FW3YHkN/mWS5QC1QVTVKAQ4AY+FvkYHrDVHqAAJbllTjUkRqS6693FZ/OtvYVUuU2wAA7YRwLN5z/52gJAKkX9b1gJuoJIDWoshC4qE0+UnEAATyLTspR0jfoX8yHZS4UCKVph3E1XolnvnDHFtSaFAAxD9Rm+nUifTO15fZ/W55thjtkURtaf9WpXWB35uMJwBQK+mVd0EGDXY3BtBJ+4ozbBHa9XZ66I/JkE8s04IiAA41mZ1EsiAHSIp5AQ2/skXcY5YFcqiO+WM9aYqCT1EAPXnTvyyenrDCWeMMRl1FJaz2NbNXXy+Cg+eN85gMDQBL/xVknmP4CnlUSQuREz3Cded79/8LNKmONIvkg9TrACK4HEM/ZhlK++VoAMS+rNPlSHXcVNMbiTHsHJtaIlIAo3JzsuiEuMP8t2R/Sx+SrfnQiqtS420H7UbszsWdGQCfF7jcSxPlFofrOllUgIHBg3e4VUNu49KikLecC9XvAIL3fEzZu0Eu3JxgICjXz1qaK3UDf8eNHPpUG4yJX+YAyogdZuSY+ELXhZRoFEKmeXEHwzSWoOUASmt27szqywB51raRgAxu7xJxosaB5KNR6rM89ZtdCjbCcHhug108AKzz+VGBdRr4pSffBs1LrQdQgkXR/hcyTTbacZSoRYIA3joq83PvV7gGWETwNapQtohWoHjQmOriCobJL47+xwCcbH3RXM10i8zLW5DEK9PFGwH0rvQsHR3D1Q+qZh+8AP5BnsUvLe1l7DrHV0FLjqmsRoGCzmlVQlHOVXtlhhYAx+XCcxy1qfdRoiMtS64561OBDMWpuu5fbHEaxOnpyQBcyrAmN16m+rUe7oIJVwloeF7sLBHDM5bmI716R16+AAS44kts+8mrTOAoFP6WTh2wELUmcNu0LnJUqhUXqcUAUvXx4gJtod5vY21jYgMtOhPCWdHR6CFPQ/AuTRy4swCVZRZ92BZRzOt85WLXNw7XSnD2Fw6kmuDZ9BiKlGAPALLWQTZe2GKRdRV7GqVT4t3y/bPjYrVmUTgp569u7jUAXldNJaUtSHzBel6bzt2nq2lf2nVyfcSDuZUiNi6NJgCp3BPK+rmX8D4LKpbm69jlMTXtdHIB0tOw5XW6G2PjADR5WzaGtMgAH7l+Drc+rCuTm3ZZl9bEy7ljOcZo/IUAIl378vLSleJaNfJYtKVZcEVHSGeO5CtR9sKiefbkUwDrUM9YCzAh6xD0dJixuUBJlTn2o3qKicrrXgEzkSrYANejMwr+fWgy2XDxG887N1sgvitnq8O5UTPZwhiG2VwAtYkERm1/qLSzxETJ/nAuBkpR+VLgnX9aQnfAu6gF4wBPTiIEpKDyYMVXnqGoEmTjY5MNQG/C2B7OAnBmb/OLABEw3xA4vpfZe/yV0KcviJfCWWMdGLv1nVTng0Ye5pEAYVVwzUWiAxuZBT/hlsQTfwPJOReM9XlLXyvxJ5HiRwA6KsrOA1Rq+l7iPqZ6hKKFIKs19RNAzl5b8sVH2oFHAPFAuZjaIZksY5Qm+9Ft6gzsgdMyDma+S8MKCOkhXsAAzYwof80b2mdbGRiVpbwI0nN1oa+g/6lbCQpI+9pwfwBYzRl0YAJEvo11qWTFWP9YdT/Mo27zFGtUnRj3TkySAJDIkBSNpFXKaLjYTVwPaQ/g2E6m1SQVGC3ZU76I/mQAZtkPCAzTagXVic2UyJCRWWJZBhsGyZn7sp6W2Nwc3wBTRBumXmRU0OoJWJamdXtS67GW7D9+AH96ErojmnIQAE2b3j3f5qG6Douxv2c7QF/ZRuJGigH4UUUiwr/XJAsARMIalBfTgk+SgPAWwN2k2uRv9/hcqsRfRDvopsrQtwDzRSKG6+Wfkf8+8OTMzsfpGLP15zSWxBA0JWsVNE06AJW1MA8oVK/E2pgsrMSllIU8E+ayQoV6POAktskv/R0A+Tt0CSzfAelu3u4hObMQWaeaft3h9/edwJm1nG5HnwCqh5IeIvIihqqsEto23+5iPVodlwEL5FfgkwIR0Z4BANhoHwpzmSSggKjHV7fZeqksuykx8Mbf0gaeU5BiAhQAV/aUPAmrekiptJXMztq6xffqyN2d+NbDZr5Oie33QACkrl+n4mNg1FXWleapgqt2SWwDiVOXrQ+iknbVU+DOAHueCGbOMh0Xns/ANXbClgfbwtQxxMYyZkec2VSShKUAWUQ6Zmn5RXMOn6gKuDx4h9NmDZ9gLvLHbIoOxA6TugBSM5N9jTq2B/EaGklRuW+mNM2okVzrIB8ZFGDbvPY2ANX3fnpRHjh/7VJXXkdobc83QGOo/g7YUJ4YNKTRRncAozgUEJs89IprZKSGPjoFgJn5i8/q3xVK1tyULXsfHwBzxgpkwecj7iy/lTYC1rn03iPQ6CERrMq6DfogJYeSAJrO3LzcKWuA2cE1CdJq0Djt2u2Pujlxdgf8rInHX1kAAj/vy18ufc4xgqpeuxQnuGjRuhmCldzQBE+ePv193wCirb4WlfIEJs9lqQ0/wZed1ZWUNVTh2nFCTTIc154RAIydQMJskbseTihphdupEH7d0ckZy4tfdAcqO/hWqwsAZ+MUW6NNRTmZrN1hfqaRt/zfPyNFGEIGHvzuf27D4QBfFSWJRRQ1AKBcPEQmqJuHUTTZo+RdZJzC0bi6/lWdADedttZRqIgut0SvSlC82mYEwJ7Wr+a2MnSw47AqVxQAn7O+hkJMgpKgYfZ6SQu2eq/iOmbxqB+9hyZsqkAyDwBRnU6TMAo7Ql6YtmsidktiHdXGTSufJbcQLbw4IJFfAJ8mvSrf6huaV+6hZUkHKV6Q98cl/zidSihsebuwgEUAsT2mtnRy93EIJZmIzP+NhqxWb5BIwk3vAVrYo4ufxwBJYwh3Hg/vKs8Pi79jnLA+xbXNAhG8ZiiptMfHG5oRAPLk9E0aKo5LFVq7tZb045dJQILWabw90e1dMPCFHT4Akaa9OeW3RwfF/iUzNBkKVCeskf/Cdif14sbgQFF6pgCmJr1wUdkXaCcfmGC3it5zZd0eNwFEMJDCdzhwIvyfAJAExMPqGHKSTGWlbSggMg8jJFNKkj0b2jiMxtDqEMIAvEDdWFogp9+f1PpokAv/JIoogSCCGm9t4ZbBoBBc5QBi0G9Qs7YodW9muw+K0Z0hqD2V0Wg4xRZ7YMdky/TgAGUHbaytx0AwfJuyeUoWUkGwAAsg+vdMUUcCv4h/AmsAmRFDpAchaXA6wgkHTYyRy8mjiOMGPRwKCjDhDG1vcgDB5Kw4PHBwukY59b9zgnGvCm8g/ZV1MqCINWjzqkoqACqmFuAMp8wiQWlEgFV4IsZPO/QRMhxMNpl+TEBAY8kAOfTdizHTzl5LhkqMROPybodsBsIyqIsTY0T8eDEhawAibx7F35mFvJiiu3WC0cBSUI2dsACS82/lTvRM5T7dAA5CoUlRYo9tnAH01ThKGlv9KjY5kf6UmWcnYmiSFawAVdfJGn8W8sbav4nhgFp4tFC7JmjViqPIXyC2Y2NcRwBhvtpL0aSsL3zEOqjbx8t9L2NQR3T2s9LEmVVPQ2/IAIYYCu6p3EN+yrkx4oJrYF5kaGrawpMbykfzcmOro3wA5fd0jtICgNPzsvIsdfm0hZ1GH9+6DrmYhVB7a1dZQABPrwTNkv82mBHnrbRd7Kxe3llEJ6Ivf4E4rwcwBs9ZACfIz8TeaHqyF//NZhkJmVhYSWgK1toiiKZ3bmvVo7UAjasSQBP3AXkMkKwHRjZMLgtxc07g62AL1Z8PdsbEmQAQ6n8vyv45JAZAWt7aOBu4BxzDmopWanuFrX0mtE30APOxHLi7IbGYiIQTnMTCoC33j2cctwx92dtNy7XCh/0AwfeQ1bT/PJsA4zG9N04deG+iLTz/S7tSbXjy9lqx7QCOY/vA/404bT6MlNaEXwn5iCiELWxDVqIVySmdyR5TAMuvyJ17oChiNvdGx3wRIMiB023lt1QYgGjK4I3/+hoAoQxdPu9cd9sgntwvEaToE1y+4EM7ns2Dvm2VLmZxSwCDzPC4+JEQRvY/55PfW4Z6v2Ynug1QNgZUBDJOP6rMAK9aiMf4ZTJ/OrFAn3rJ6FnKRZN6tgPgpA+mg2XPd/AAjrBQUJVx/ZXpCj5ESgPLzrW72MaBWMKvhvQSocVE6QAHqw6bRyOkLHpiwMCjRpxT6Y5gu0o+/QvskhGXhtGDAKi3nB0otjbEBZOEfA9lVa/Cic185XeFByHk4P1pbbwAU9O4JozMyFICcsW6IwZomPqZF1c2IiKdtvQYuWq+cADeuSslVxD9UsG8aos/HOxF0fagf5xey1qIiPrehvePAA4J4wM5Dr+Panw139PF6NGfszvRA9x9oTexkNuBH30AiGLUlgzMwrdAAanXyQSbfwjv77AG4QVMRUR+kdlUPwCFFo0WV79bkJo/9C7h5samRbeXeBsy71z4ZOfplMO5AJesE6nThzLyiqt+b8erk3v1lXlQlUfyATV9e721hB4AQ9fqtOEjvr1TIkOn1qqG0opYSC8OQXHSbunSrb3pDQCK7KmGx6ZO/zmhLbIBCPHjo5noNRW7zbRsQeF360JQAJyoNZYkM4v9XDkLAklZ/jzR69BoQonAutqyyQ7D99cAMV0olP9/KlGPSTY8mgPy3jNlgxCRwawrlU/9RlB73wA/G8CmHfXe+RlBbHV25LwBzlp+1XlPFEf9AiA/AN23ABUGiE4mzeUw6jULMtTgp5DMiFnBef/HWCP9NcW2XEwAvPN/LxFF9Zg1CCaMteHddWFfkmTFWkhabkvVekp9jAAr9PTiLXkfyIZuHZQWNzQIFA7seh8lv9e9ovPsvUvmAGsIybl/1WOHgqldyULOUx22DApFAZssEsp+wp7muZIAxBAce8PQ1c8XeQ+FVBbjjbnuCNSD2Bb0hdxIjT5HvACv84ZfhDFPU/VNAkJcm0G2j1wXwLsiUDWCTzywhsqhAIbHAADg7pVDEiX8tMpQgysD8qbrTHqOFZWG5qMdWFcAXTKl4MDeSkTKKpZ4Vrm6/6KclcKjTybQo4wfFo0PigA0zQHXjpEucv7pga9j6F0/tlvTg4pUwh7Lb0zz96KeAMkgPymjp7ToqSbnetFvoztWM+nIN2JAzlGwRyPXB/IA5onY0JejIXhnE7Ln4Kyaz7XeipKR2mavPY0b7hTKXwBWSrhQ0woWzEiXoSkYgNtNFcS0b30psVmayFdtCMZjAPRQMbjS7GprkJJZDTGvpDapPhjY9jdJBIjAqCPxpMcAPhFO6u4sMFZuFf3evW3vQiLzymyWPEupARDe+925gAAV5GXRS8T6Y0/ndXhy20IDGbpgKfIrylmP0cHOj/l9AHdIupiw1+NQyOOEkrL/XrKRAyoLPzvH6EuDK2/RLBQAYmvudOMIug6rFU2ftQ3lOdaVWyqg2jjxl+WXfYE1UgAeoO5VgEo46ZhZpmdEkp3J/L/o6TAaWnD/M6p40K8CAKULJ/163uFLW3qvCt5v47PB+P+wOzCr+2lSM3xl/uAA8HcrwJsKFY8JUmdcxRgBMLoOi2iLo977SB260rtnBADmpe/67gT+VHTqUl+nXbdZVImF6OF6sPUvPh4SYmYGABDG8nPkuweQF5QLilBvOPzgq+EDA8iaDIpSjQgSFNkAoKM/UXVlmp+VWT/FmQjSmtbu8GWRL89w0tIxI0iqYAC3pRCMLDN2i5DZO7TmgvPR3wFAo0osoUC0bZkyOG0OAJpPGm8Y9qCG9Yu7ohzNJ+nKAWshN2TQXWtHljVckrcAoauGf6klhBrGHYojAfKEL87az4nKxIMRaHB4jQtajwAtxJcLXG8egyU56ie6nwmIjA1pLCrFFlIaZwv2PERkAHa6t1tIbMHabmAiDBLDsIEOFdGPj5xYXPzrwMpwExEAjZIWvuT/LTqy4iXJrf278T1gtpqr7cpz/Fs+slmyWgBTfs5l3gawlbJJpzZFS88U0Hc0czJ2HxtG7Ehnxi3QAAxtKoJVq2467asgDfWUpZvQ8Jwd+i/WQJvs0ptZMS0ACYTH6Vo8c/2ODLFKZ/ibeqnnT4D3ocKzcH6+RFeUtACIN2BARhedwRBKGP6hBrYyoUKVLz6OBaD4qQViuY+RAM+4zb3EtN7lKe5Re+leOCvGFfRiQIe51eP3hU9OWY8A4c7J1RndXG2huQowEjhgE211wHLlyeM1ac9VsGUbMQAqhTryVMGghNO1LmVkFSIesFGbfL0mffO1SZuU+vq+AO7g17vPGj38mlK+EtC+5bCtMNxNEjkyyfW+Mw1Jg+4AiFIvJT0Zerh4w9AlvF8jB+1FUDdZQs6SMF5p9PGtEwD4YDYfKVFiWNJL8SrPOhRvkIisfX2C/bs2uSQ58w1mAA/gZyBSZVnKVYMdq7txBvlqjorSMWR3fX+OF1PFbMgASB74/qVew/1L2oKAzom7wrpDxbAsUrKkCcOmwgBVIgCD5ninjFSnwhPYrngIAF0EKZUO5OI8tpUjJWgsx1/AAPH85WqUKR+LO+ZDpIEpQ5xgx7G8dGIOYHph9tGo49YASSkPOrjmqqrbkFTwxD1fc5sHgxCHYghIBkOu6nQTswAeV/dMv+h97KA6fGchCO91U3U+bffo9WKOHSwP4wqWAH0rHGAswJHYHN7qrBvuSKmGXVroAYXinRgDJ9enW24AnLNZxR1wIpiZy8Q0PCVl7UVLyqz0V3Y9TmzylEhJWgDegTsC4moxkDrKGiW0b4iwFsssqQexGs+fRvo7gDF+AIPDhzn7O5ubb/+x0uz3CPO3kOPfJ9iINt3sn+cCTwcAcuRzohQf1qbFqvKse7lze8DSHKSE2Q9kpk6CUgPwJQCfxcAxdaDrKmflxuTFWT+02fChKXGGg2HgzlQIZ8q/AGdG00hemYvg/NAK+n/4K8F7fDqCUg7qYB6sOUDWwDUAM4JIuyBquz9KEG8ySLEP/pWxapxtxRjic0KgWwXIDwD0p/Mlr8UXdL3hyRSFz/p3vylgVX9iE3qNYvf1i9aSAAtEx2VNPI5Zed3joodhww2cScAl6414zyT85MAz9nsA+76ja3suAhPwCohxXomNZIcmlUEwLKQc1wvcN3SUoQC8xrdA6Yentxjs/k7SWarmjECj3GnhD+Q+cMDuAY9RADNq5If/eMFzcfATeH7U+qgQJQGJP7LgeLIZ1bgYBXIAdpnQwP7DTB5yb5Jk87qRU5vAUVhkAVgA6o0yRnSsFQCox46OeWK+1izyShv/tEamXilJSNiSdpR14BtAQUUzAPSYp31EbenL4c4ARaM2TDhoimLPU5tRTtAP+KFZgj0A0o5Eji86hcpucj0UAR5+g2MCVJ47FIOQbFu8PYErmwBz8h3jy/yYpWdO0yVAxaBXnqWLVCTDY0obHP6ae8LrAHlI05pk+pIxX/X2l4drkMr9PLGg3Cw71WlpFqEOtbYAMx4QBtZKyflN4RpmH6H1fS2OrwAHlHG6gcshn8VmJgCdlMJMsgGUNDf8L7Mard9Gr4DrbnFsID5H9EUCdYEpALb787o1UPrK27+eQmLDq1mXGsmIbYvblxI7lvHtcpgA73ARg2V/pTci0tWJAmlVHsn/OkPZua9SRfoSA5taUQDS8I1SCpfyxrR6HgkypBXDDQ2NrT8MS2iD6bA1xdbaAKyRJ+NJ2hpFliYiVflB2TUIJ7fZGMPb586wObetlBEAszKQqARSqDCIt027C1Z2HWAijGhawuZqSRBHZ0cfdwDfSt2tTKoo0ImrWkYHT1Jxi74rV09RmzR41WYylE3OAGav48aVTblUtWFE+sCcmzXQSrZnehvLDbnJiPeS/ogALJuufqNlBbn6pS9rbg9wM3YlmLcOE9m6hb8VhipjXQBahBcb5fo/kUE0kP/KKoiBmS5Ynr2MejLUDMxDVXGLAOp1rcxIsGsAql7Y58wj02yiRIMxCNAHmenDbGKCCy0AlDryDGwsokNlk2oDgzcAcDY1lrXZI5OVDZKOlFrTJQDkEczoGNwDAkCC47zpRFAVfoBVZdx9x8SSmsOEQqMzAGjcyXOm5Yl77d3UCxnNDBYc7olfHwb2gtvFjnjH8bgA0kAe+yHTmopHeEN5Mpk1upPBzmfxy5A/gvI53tBdgwC4g+FRvHJue0HuuZyUMosLDyNhAKUDJPAClSGj0pyCALra7/l8d714SbeZl/3u7WTEz1VEMLDGsaTL7rUnBzEAd43tAo6tROZszjdbSZr7MUc5TYOitijDNHhvQY4Z2QAS1WDD5HF4cbk8gopP5lj2c7cuJ+18s3zGeYQ9f+aaAIxb/1gRTpFmibxVEAi0u8/jWAcVTLbYPuO9HF/81cIATEFnsDzV66hB00lpmzP4HqLsPe8KuidBbTe/GvZgzwDLiomwGlKTQogYD2UrCPs5JJMcqO6keYVPCfiW//HkAKKApMgu0/dZd+5kVuqD+yGj0fcsTDH87P215KEqDCUAfH23T2IF+Wa+RpJyE8qsmaZmHtNtC7iYyX+jhL0kCAC6r1ve05sUXf7gyaEGaN2T20rBntFbNNTjc+VdIo1JANbvHIBUCTiBL2LSxzLn/AEVe1Ah+UiOG0u6zk+KjScAWMakIq4ybo1/mcB5eCtwrk+sooeEOlLGz/HmA1GCeQBR3fzHOepLq5a828+NyBYgnugomtDiKXW/c+SBJTC+AFZ5moG/77WkiVlAX766GRSISMeGybExgS1a2d2gR4YATFaVt6WIM5+E45Y4FHZzhKmOPCzsGxnsevcyMhr6pACVzjlffbIpr3YlpT5H/w0lt3wqvJvP4dOuOYw/a/CyAMcteYvOb4JKUoSLpwqbAbvVrm0Q6LkbaV+ULKrFJ4AA80zBbtltHT+HADdkYsiKfa+w9rA2k2Bj588wbPVpeQC8K+3YQWH7IVR2IQZmA/lSwy5p1BnTbIL7KAX+nZU6AD1k5LAxenvcPZRBUmEN87EuoIgtYHM4cqgipbw+0KQA/cPpEgoQO90JFewgY+TAVfk/QUyVYktNvLKbauDYlQA2+f5SjKHnGwOWUOn+6D2uOMtww9jx/Vx4CNqy7v4kAKLcRj2exW0hGgJKERMP8m3R2x+dMLwpJzwdfFkw/AwA/fDxuBOYvbVigDu9m5lGm9wVEtd7Ra3KWEwkiQL9AgABVyeq6W/QyymPKB5Ry+0x5osvmW7558TLfR4HDGN9AA1ncVaWJHBS24lLUsxWlMzV63D9qrG7ZBvg3SdezHQASY/tbQfoWKapLhVfMjnRaTY6iLusBWZaZiH6VvkDkgCdDtimnP2py1DK7yaQ1d1Y33+M+5zV9sNH1+j/CC6bAJfCuZqsZt9k7sE5bP8qZlxu2JYKfw2ZzHabauTjtA8AXQqsSR+NhFkrde3s4+U+ydYoyXFb+/pUmk3dh+D+IQBe03RyYYXqJR+tmuTUY0xB2imodkCFUAHP4zLeyFXfAPUQOtnWBvqWNEKeFal0t4gnvu1T5+n2J4E8bT0id2EAqPe2W03UwDbfYSzV4c/u8Bt8qdB90srx/7QdP5vMcwB8yve2jDLG3KHP96yeEsZItGRufs3tLvhvVclI/Y3mAEoiLxw4R22lQklOb7rkEnue+olck0UKT4tvGkTMfbMAbb5opVAKdqfuFhWeEVxx74tEAlUioTbXdllNRsaWFADHH+2uiLuKdVT/mkklS4IM9H5bl723OH/JZ1TwMboFADYKuGVo2gSWn8DvZmzuyOgfKb1KU7HSQtd/G4eKRYQA7swVM1oMHYQaHJ33ew4EyjJB7PcR5WuZSR0/yrJTSACINCY9+ZCpKfj+A7FZ9+w3kKI0VOb4ct0gryhSCDHvAPt6p2P3734E3ktetFacjM0a5DRrGcRcVRztRcxXrYAANkOnhZqN6LixFigJkGgI8mLdIWEpBV8wGHG2hCMlcgCh1ZcFgMRdBj2G7jsammw9ubSPlHtWlOpbsVSQH+lBAEi4VPL2z+bpgoKXfKzXMzXEnikJlD2xw7weD7lOAggAcIXiVIDJQxVgT7RCZXWW/2xZUFZCp5caVEuvhpegAACzcLTDhKlLSgD0XWEdJx9NQIpG8xIDB/Y6edHCZlGKAFA5glbyjD9ewQ5ABQT2yQGYjlbVWy09qX6oL3goeb8AxGA0gdgcylx7L9lSCkWaN/tHgBYYB4XwddEp9UvU6QA4cit1S+ttlN8XBog7Wan0ux8fl4SYtrpPss/zYOLrACVb9ib02j35CltzAfnwoptlpviODP3NA2AsUTrozGMAtar0Fli/dl5fXVQqKyn0CcshGREuOru3qQ4LdT4oUAD86Y89i+x0fZ1fvNJhLPUkAfyBkZQebEapI+JV89ZJAFteOywSEhqNTITB+PBEXc0QhfqyPYlo5KHDhCu0K4YA1hmheUFEEx62ZEBo1FK6TRg5g2AoFPKmidMOZCpR1gDNxQfxtj1jd6S5/U/xP40cZjqPKuzV+3b62MA9k5l5ACZfVuq36aPWTJc/9EonvqibKgV1+Ooue4FdFDXmIRkAGuys4ABDPopSTMLjaJQwOaRYEx1yDEV32pD5NFfG0gBS+zX5yaQrYQ4PVORRS52pjklgizByxiQpeGctRQ6tADDKWRsPabFdpBm8NsaxpCv7EMgDoj4/dJCkwiLTenkAu1WeLk4ACxft0VmYt925EAjOZLcBoUkQET+EYVMvWgAyhMcqq+HEySIEnTrGxz8pZcUv8rIPLESNJMd9TkwKACmYgH+eUU0iDwugAzRRBmfpuSV0+ij0FZG2I83W540At+GBMBXMoep0o7aLfmAldUbB8dU8sN0EEkdMvUIQFQC06Z0BzjmjDobkBXgPRVcsKcLKmtSv9Os/VqPJnmRxAIiep6nd00+/phzZACZWaJQXtydUQ8sUsORbAW6NvpUAPtr79EApzkYj5y0jkh54tjtH256EwEyTdcjBaDyCbwBufXoo57inE9Y+m7kREMKasvmm3e3CYyPVuayUpEMeAFK0PWD8bfzl1BDnrFruGMgPdHPs2rTH+mQvmByeqT4Al1pVmFxfmQUZr9aXFvfTkGfvB+mT2dbOwL1JwhD4ZQDvdLdTB5KhwISXNC2F1K4cZX1DuQrLESk8OyBDX7jLAEtqIdlOQZSyRE3h4TK/NaUqzoM0BvjLWm5KLtUv6GsA5Rv0JzVOHjNgZICD6432eu1QVYT+3lYyTOw/ZarntQBL5SH1JNw4nxjjqFtLtRieby2f3wJ5qVqqgCev6aSpAK60SRAawXE/ohsPT5oT/N1PCBy/Weh5Uv2lfZj8F1sAc67MHwDE8+GKHdjNHxy0FQS9hKcCt45u9tkCvAOfFADFOpeGxKctiRcAq4w1cwN+qV4SnRP7bSerMDHf+659AA8cgUZP5z3JgE0SKFxmlQDV4BdeWrgmAj1cvfPcNTUAhyzwHWunSteZwbKhtJfHty2cs4uf1c1zro6EyOCkRwCQ5yPwJvpESF43r+hcN0d/Om1uFiNGIM00EXXJhddLABdni0s1rVE3KBU7yZ9iN790vyNKxuBcYQtgzcFrg0kA71qBhfDSGKrBT2Fm8trpFA+XVqGjBvZHZIzlol/MGwDQAswksuur9LyuI4+MqEpDfNYOLbB+c/0TmrtsK0woAJf8WrpFN7mg8O8UZS9cnVs4wkV5Y9OYzYX+JT4aE2AAuihpvKY7MIKx4scYYqf6Lo2/ddSYXMQuSzEusVkrCACMtioCFlUqggXZgL5532aNMY+FyqfUXMKb+Y32ZLZpAEtcnORUNtOLHhJAP+H58iCA1tBjLi5t2z68JtWlHVsAEz9NhLS6yG5lTtGgaKbhH/fdTn9T4BMtRLl1ZtLDqAA3keCaBfCQP5P5cF1I3I0rDVHPXt4AwsjL4x/nWDQmAEYNIi6QynGQ9kZcGopW8/OOIC5/SAo7HJCaKvZIVHQAcYg+ovgOiLzZdqI3SQ2OzBbTRhQMa+xM+vzEkKonPgBlE6iliQih/TCVvJC8qUOddmM8MUrR5AhvMjkNJiPoAJpwYZqfhsM7LX7ck2d0qn74o/ZGsFQID/XGO7X0EpwALIJY/3qqYiJ1FF8HpfxVdzKdzbIfOWdFuD/VhDFsOwDMQ4chk5TSbycpwpKeW0oi+tILpFDmBm0KswKx7vn5AAtiR2hdG3v7/rLxoSnti0EFPWk0qnp4LZpaojZ1CtEAolCEVQDzGM/gYhzUXao5hbnHp7xnvXOeCjfYl/VCXACpdtl5O0dKU/L2nkDIv+HRr1oz4KR6lemh1rxfJ8R+AK2QoehV6fAOnxDAkR7KK83iqaS2VGevhFiTXnZsSUQA9LnVZrsfuHvqclVszW0eK7tXzdkq8IT2gMLwUlbGmQCXnXweKyld9Y96n7ClZzWX7Ha++sU3z1U9heUy8mBvANuYfnHBQD2ilEs2Rm1kBje85RJS6QDXtOAqSSLG4/QAspcIQTv16WvQ2fEM5YYIoaeTccMMdX+onwrq82ZyJQAttOYMR+j2LDBQZ5j6GMRrFfveoTtFTG4P9Le2AVyKAK3+YXO8+Y4DUwL6NWciSkB/74ejCm/XLxFKm1MSoq4AL7ETcG8V+JgazNJ8KeooPqzNMtDg1rrpGehFzWRstAAzp3GMWWf+T4jcpH2fdLtSW0UFB62P/l98dv7lsu4jAIL95s0KT9GSBhb/u4K8C5Iivdofb0srV94/xZ+CF5kAiFIw7uchmb5VHGDYLHB97qBO8TCVHGm0XSc071bpwgAq9pLDygd+SYSmvRna5ubzzqb/PBpgeceXsu2rGyeBABKM7fc/dfQPjYXPr9k25W8QkKqoumWiBnIogTxHdtcA0cUaP6Fy3sXKKTYvw/ppioa9jhPhaLluEgbXW61zQAB9LkL0kOjfkk8dUuZ20EcBJMzjJR2+QHFS5POgoJPvAFvt6jtgXIJXK1nchtFAdxdY+gvQa8ckCkiVEunBV4sAMCI31ZddhGRx6+qK40VC2yHfcyLzL7kKUdl/+8uSsQCDbMIuVI465L3yLEB0N4p9aS2ZT9f69MFQytzVzG/TADynQh1N/m08gqMahD9TPuWnL1HkvJSLBsImKdTdooQAfSHZXyy4pDQjEVojrSGkFWZjnm1n4coItWkX2aoBrAAIosVssbxKhMeNGeByzbiaMun4Zq1yo1ZC96/RtWNeAE7zMvZkvtjaV3eEjayw4LDiCRcYfe5e5QdVKUK7QGcAnDRYViAc1LMn/NHKKbeb7NaWnOkgSP3K/babvGQpSQA7vwycUEKSuuP48exSBf48dwx3YU+l0nqYUnAspFe5ANFUflJaOAv+fDOBh9YzIdwep7aHHVL4ka4uwjyv68QA6EyyoLUetx/3+fzzifbH7S4abnzHwm/GdFE0XuKnYAAVji9dAGOCn98qvWAYTq4mwezZ5cu4vv9hh/S6gZxpAOxiq4Ccb+NpKLISbyJkAYCPeUP08Cn6DMtipCTwY5MAO+OE1hg4U9d8q+k6J8euQNZ6MsR5Arf3CKfDlTdLeQD3lV9BezCqIiwdA4Z6cjaudDJUuslI1K9JmOQTieHgAKIo4ert4/KX9QwbMlOFh99hbChq7ZMTI9k/Dgos4rUAr4D27t6gtDpcqi0XC9+eyFYzhn1a58McWEyO+Z4N7QDbmcDv1zFUZe157qCA60zP0C3V7UwmO3H2BesaKq2OAE8hZBZ8H+l64wG1W12n2DUPwW/zbK4EGZtcBP7BxBgA321gwJkPSPpmcXKIPnY4Qm4bKzlgfZ0DWvQ1Q9dacgBt8NOOLko3pecyodHgmiY7wKmhIoN65TGmApP7Ei6yAJdQPVSwkBDbEyviuugeViGWgC0euy0n9sqG+u+9b1kAliGFubOxBPIhSXdX+74evYunh/JUPBj2iw4Usqq7NgDmF1ttzkwYpJBZ1mB+EN3T82VXa/AL4ujxkxuwqiI7AL7LZN7w5OYt14sVid8Tf/DYg21hc7QOIlZ8eWoAXCUAKDxeCqjPa+lrl+Sm6hkqh81nhv0DRK5TNnAxjaqBHQDg8LumoOKyMowQA2E1K4dcUuIARfJBveYOV9a+XWyJAFfD4a7HYsdv+Ufd4ohLBoXlHMtjGkm91AQkBZWbR30AqdhUVzHUmAq4+XKbM0J5YHnjWERuRjz10EiiaTsN+gAV4tUeGl4NKXC1k85R4QjMMoXrztDl7p+mFGqhFY08AEwTRvn9o8MVViHEJHJqKLrSCbL/cIJeBAVArMO7hIsAY/d6NG8tForBik/pfb132Ux5ayh7kiq00oLIunfYtABmAFg6Wd+4oT3Vdkpc4Pztv13oS7m6+sS07cFQ/gx2AL3W+7zJgOmW9m5MV8g9vmgx5kiKn4C40YCj/U48iF0A81r6qAWf2hDy1scaZt3edTqjwKuhSfW9pCzwmqc2yACY9EDfFKKhgNV47RotruTkz5rei2ZAiOuHt/zJKe5CAPbSPy+UOvOcReX7csbW63Fu2S/Vk99YJEwF0HGaViwAwPS71LSYZxeOHMN5e9QFFmYkJdfRA8HlzJvySnZ6awDUQ5HzDaZlAeHr4UCCG5zPlSDdVo/dABSrHcaMXwWdAKAwCol6EIHx9rl1GSkh4mFJN975EDrOZkiWY15blJwA8Jyb5k63hCVP+1KoZse48LF9p9YoejVwXITlfKfcfwAGzKeKfK0GuygF5JEynM9VAL9jiWTawqFEfmFcbgedAM70N3rWiipD66H/Gj5RH5e3Gj9Pvb8LxxEnMkcwtpQAhDbWp7tMlKs1eZiGWqRaNF4UtHGcjPu24dZqLQBe6wCrAcEDfX1r9fUP9rZRES5PoRWsS02AGrAjoz99k9p+ANzpIEbofJjQ24pBhAAefkBYKfSKUFAPcoHjzSx2TqAAxTD2GMDqgU8ko8Wb7S6oPCcMMzTt9+YLe8atGJdk3QAgSd66xmfQveD0NE7ze1uj30tU7LdoE21THICZ59mfABeHEF2LlgyaPvLRdftzitfukPmu4/16TT6gA/WPltIAPt/OHvMHzA3v35ujf/61ONdgj9FWCcc89EMX8zEVugCpkg3oBKhRVMS1ygS3p2kKSVID3+Nqbc9nv0YxbPCIACcZ4wEHH6TLMGLNsuUXtGFLajdFgHZBD+gIganuzp8AYwe/x//RsmNWWo7OKqLTEBDGCdKp1jKVohqEEMNLJAAThN/LSZ0hSjYhg1ZgezJHaP6a0C2/pfb3Y5gBBl7FAPKginppqqToBY6E3cn4RA03NfVLYJaXbgR7EBc+0QUAwaIhe98307PJjysfePz5Z3a/XnAtj1/eDgCBM63OUwBNqzDvhPhPQJWLgRy1m2jNiWQFaW1HRycctRctJHzLAPsjr3R/CruSnJ4nFf1fvqqnSqObZgnb1kdQSVnYRqAAv9XvsmHWeE6mrjyeswwf5Uiu28j6yi8C0zDBphs6nwChbAITyMMPKJYWZgm2Ula+fTy+312iXqMWc3CGmXvoAILUhdXx0A5FMpxyoBsKA7tyM5jqqZPQH6gyUD7Be1QA78jVQfqYd66sjQYom9LOrS6c6BFfCdcDEvlx+xPVcQCr3lacQBrmcR/8LPlbHsev+vRGgvT2Cq/X4/LkA+4AAKlXCi6PWH8UbAqZTCkHXVYRhYUyM6TNv30hGIGqmgQA+9ylRJ1Q7ZmYYgyQ6l5GZi3U97m6+tkQrzXykxHLTQCieS8nEB4QyOhlwP3I5f3ZEQQdZer12E7t5mYZgV2EAMGEgQkS/tcBV1eiw+Fx6A5LY7uMA844J2qoj6JyxkAAWpPZabyf4qCYNHh3HVj4OmAaZZShcUH7E9H8hMNq1wBVbRssWAiCEURyqc+76oEdQub9zUwF1rrHtsSFrVbpAMdgn9y7XDXIm3KnPOl8KmXpEe9+3yVy1DHY+6tFq/oA8wZP/ffA3tG10yLAUXzDQVWUijPiSPp4oeQH9XnaXgCJHL5seNlPtfakB+TJ7DkdP57IjBGo9zwXp2osrW5WAC+wzt42Y6yEnkTwcruOKjepTUjSuYazhXfgNFRkZekAODa/6L+fhTNIQ0l0tfSAcYtkWbx2LQd+dDZbHKrrZgA7ueq62goAL4Bs80yp/MM7P27nl0ULZnhfrrD01KnVAIS/61DVeB/viI6kfL7/+NS1COPsH0keKEodTjWLbCMAgXquStPo7xTcIahfXLwHh8cPV7JC00j0YtvbhBJVqAAEQO1Cz7VjAWZ5RmBDrX07fcWrI+LlDSI3thGyGLIfAGPDarGLKoGsav48zDk1i2GBLXYp8l34jKqQivMqV2MAzhai+qz+8xJHJkoogT9BmWjG55l9RS7nzY/kzHiFpQBJjqM5M94Yerqp8Ocx59LvEqQ6l48FQPHbb9h3u7u8APQEv4VZHOjVqZLj6h/ZBffKhxSF7KeUoJmuUTMxo0MAa4Zim8JSDpIOcKx6sBIfgCOlaM6IDURzORJPUH0tcABESwQ1nFs0GdudLOLgHpnPmC339t99CdSmGceO5rRnAJqbbeWLjjUwr5YjPk/j0UpoucCjJcSOmdvmqE95SL0AVovDwxlQ3TX8nbQqmPEeSyAW6Kvvqgh2nfmAnNfzWwBWJkhjThl7ypg8jM3gQaZb6kuHH9XFPcd7UCxCiq4oAFuzISMFGJWnt31cwSarl2hH2k5I3CH9x0mnC280lXgA30esGu/TTpKraLjhMhaqmEMHmdMpmF9UhG15b/ZpiAC7rH0oeR/DBhZSvtjOgnl94ipfX09N/bHLNW6198qnAOFIvKaXrY6BJhd9tDtpzxZp6P7bx+qhL1/GnpAGZcsAPZM2X5+qmIIelvb+xjCsnd02Baat5FvSYT1WTQft7wAI167cY+h7ttjVnA4/+aMLIA48PnIgUnOCRqLrdQ5zAA1lOnGZCR5JhLi3PmC7Sir+p89jN0bAnOKoXU+v9NEAFmo2dSx5iTaBELO9CE+mHn/tQCXPxN7zf7SN4cGhRABaeDgFfAQAhLDiSOvniqIWJvOjLKpGvwrkBGorwbdEAG4TcnFjIeVxV9gzpnxsH7ose6LLNSgLPb3L8DXftv4A5UPHjfxhfPsk+rfpYRue850vpzNuSIQJbBgf/sPQqADDegI1vVBnXdcK80JpoOl4kXQb5M19zOcIm3CeAKfrAALUUNgJP5mQthhnflDxrGhjmG/QXSLIPPmyTdoCutIAMnu9oZBYU+g8HJZMxPtQueXw3HSe6uVPl5fl/TL3jQCvpeGTAsIw6tNyILt7Zqg6xsXoU6r8suokCH2ir9wuAJa8yWHgqz8CXrslzOy7RYUkRuHrIsCarABupBUH2uIAGYl1bwmKkPtv7DPiBV+KeqPwKyacBcML03ss5jkSMACSp5kZKpD2m0Q5C8NUswzo0YquwYvYmuSGrfwSf64lAA1GXYHc9x+/tiUa1hq3Rt2laSYERQUQL6lBdVzP1YUALuStLW2JNhotswq9WxU66KHs1L05gwZ80fH5E+yEeABimpzEHMRJwGtLygboZk1nScRSXUBxAsA0SO5rMBKKADFlb2vR0rN8vAb/slxZTgBpztivfSvkZG0VLBU2XNgAcJLq2xhAjspUHvKEiA9HL2CnjVwLAwke+35wQkpKYwBypHpZ37IX1x4Zsip/eTpUC0EuMYEzZWWySBWvxC3TAF/+R6KocAuPB66ovKeL4MwR8Nsn3MU3S55ZN2FsUuoAlrtMBzY7hbpEAnagHePpqil51/4AGVqvvAtOopyb9ABD+Gq/gtdDvnXNbfpxxS9fqVBA2+L2OC4GVr7wyzd9AP2rBoyL42iBV+8ebDroVAvoGspAgvO8u4wt3SafMM8AiyrSaZ4jVQIBZK2WwwlZhy0bjk8FyQQfuNI/CU5QMwBaYn/Rb8Z3w+m+MBUEruSPUyJk/BPBWlcjWetYhPbZAPEZC5yghmqJHFL2mel/Ud056y+VpseTPfOcQwO/zjcAvduuc549r3R7vnKfgIRpgrUZOnmwC7blGPfMnSrLRwCSUHwLvyMsnGd5Nyt8iZOaafFIis4+mhzvHHNu7zluAJECG7u6qCKoyoRhZ46WV3eIjcOmrkZRX9iw2ngKOe8AL5tz0Rg8EjTTpPdxW8AD6a1SJl33N4qgKwk0SVshZwBo/dJMK6w2A5buFWa6FyRXjJHv7eFnUs9qN+J1Zcb8ADfJnJCfV27V8JotEkYIBcqPJ3ViUAZmhUtTQ/7DqZMAZl+S5JStiHcUdqlCnuR/hmQD3qweYK1QZV/YI45/3QD+2smbYibEOkLJMh3FuSWo0IABxirpD3ZAtbCDijFpAKcqoIbvh4MGtRbSCNXltmgIDBlxrPNUfmxcZ6Nt7O8Ax36NHBN792ush1F7kbBGPyjbw4gKWsXudqN+iPZpMwAw/+sbw66Nv9SeHD42a9YwayKt4UU/1IpCytJOHwDQALwr46aWBEzQBb4k32KMNKufkl4zVxZcdLdhieW4HkcA469FISyddzoEm8OM8bTeQ+t5HfsWpsxgPY8ykhjxJwBq0g0AHP0XqShOSqC72KXQFX0yhMoDEW+aTA15Vz1sANc/kA11oAfxTmyenavQQ7hRhzhXBooqKEEa1arb5Y8AmnTNkXtSsgJ7sbaC/XJFmECjsbzUKJbGWBvdEeCXjADRZDiUhqeBgUkJd7gtWagYuQHNVKWh6zXpbr2Xp3N9AHJib+s/bQw/hkwauZj1Ij/fnv9nQu9vVGDr8RUFPRMAXioDdkBH2gX1/uGTtwWJ7uGdqzsphs6IJGtkqBWQuQCuaXGd0CpcIdsRh4BTdAMCv8YbMIvKEA+bc1NQlzJpAIIEWVMV/i46yKgS68Sl/03mzOraKBl8LE/w7d/0WNAAAaKfBc3tSUl3yqOUXavVLHXsIaHHYDOxdUBtizQ5lgBdF+QDsvymrpARLizvYDnYOtYuV3ghAD7N+kRmuDgYAE3H4xHFWPzIxIuRYwnkRWwp6oWhz+fGJIgz8EClaMoAbimuMZr1s0SBh3U/lWHFMaT9fj9qHx4J2+yBTvvpNwC9I9zcEiPGYBsmEE760JYW4DvgGhNKIvvJgnO76zWTADYDaQxE6pgW4IGQ/6lZUprmCtdtAj9YwFqwJsTQeaUAB93cqmBBryGWdyUzn/mflwVM/3sYTL7pAoRG0++TAgATCXnKfM0imYxdmgeJt8kySDXpTURg7NSOGbhkWRDYAKCI3ikxEtt9iMN6MNzGEB1XVQcZqQGVwFxOQ9C+O3YAAK7uTUj9Hcvm+j9RAk3ol5BSrgR0tOtwMSypbw6ipwCMGoP8mYRcgPO1ktXKV5iPUsYBhsRFBc9vl0BYnGazAHxqLikKUAK2t88IndjuVZo3lJbxf/UCzNqFgAPBFKIAEdoAfIwJRLZsFGcd2MeAZlbxqQvrsSAhwY5Kw6gVxgDQA3+xgeKBWFCqWZ1ZsvAfSfzfq1FKin8YqGFtmEyTAF2fcQGNKsUk448N2WhDF8jaA1JC8OSRyHrNxWnNOccA68bo6gmPPdUO16X84pkhpqpYaLyRAje0wM4mAb6zNQDUajRf4Z3VRLAv1DE5FEf8+vU51WnvLqVvWIm+jrO+AHzE/1LNncoJT5YxjZP7SJ+04sn6ZqjuID2GWWE/beAAKI91dqR9Bx0ggLbbqfe9ejp1ej07qYfopCpxG1sPLQD0XtpNR9SRu/voS1R7zyu37qYOMjSWvR8eMcnE5TlzAEvzjlNS4pPq9MGyXme6fraYXDHZeDANuzYVZXIHG0oAjI+Uod7YBOx1wpFpTQCZVGzqITeMKYksX4trVxlivgB92LTuAdx8PyViNwNBITFg/U3rUUZqo5By30O2yllgAOSVgYCJl2YtEhRxDY9rku8NSylxe/h7Vo7Bgk+Djp8AAYoDyoP85Muq/i9OBTSNMYAxJubV66odkf0QpcRlyQDDzE2jnIqlSWT7OvcAFnexYc6VR2md3sG5w4E0MnmeAMdXq5EBo72iV+ZhLVHJ6aMGKkqRJYQEpU5rBGhGAJsASgErqGwCJmBVBaSCDab8icJ6t+nTtDG/tY8fF21PXwBcvN2vgbNEKDqNAAEcpAkqBpOYIK0xBvorCF8SssgeAIfUK0p0e65NsqhKXLdKpfUAtMwyJgJOs7LgrlhvIgUAuzdqhIENBkwZ/DU62Jz9U6O8Rxq8/aKeADpOm4fMbwAwQEdC87UoEFeUVaYKN2hzLuJKt3hJTMtMHOY5Yxk1AK+JqIjMYuitv3FHuRzHKJ9t4n4y30kfM+PsN0DE/8oA82xak/wSywvbIDbfEmrpinKWOAD5Ty3g6FtcHb6SdQDyvPXEbZYmYkHxWIrNYag7xhp1sbQktXwODVgzbuUuAKpHcR56hqe3cMr/5Xwhlk/PIaUAjT1MKBGhXdadK40Ap5g4wySX2EyyRWpEGMLew5lRMICXY2PvsAMIRm4yEABqZo6cND80rlbCEMcy9+MeEM0u7yPaRN3Jtp1hiucGAEfsqd82o+5nOtGqUhPhvQ1NZ6b+S8pxPEuLXb+Dl/EAj04qwQhqoDNakqKklgY2KGlNgfj3vZwyqkE8tTzshgDIW85BJYHIES5wlgFzhxTWKO40nVEF9G7rOwSYY+kPAEJCW8PkSvPjMKLyAjMJyOsdLpWK0tbDztmKWCmZncoAPjZkLTb+XDgqFe7w5W2eplZy6V4W9586rREr+sopCwD8BEZWu6NVQsnGTnE5qdgxdNa5fLkud/F9RiOtP3J9AO/xxxAMvHH5Mb60U+VJ8Lgiq70K2/8X75y5/Xevj5YAQdqka5dlnhhlKRdWpS3Gpm7ALA8py6+e7yyjIe3DDAAsiXdTiFBKpJERjDS7uUxzSlKeDkIsoctyswrPU82jAGAIKlg8F+M6U4FvR8SBPRJTXwcG7fXHjEuAvZ31YBYAcFcJFo4QOG3o+r3/pSWFDhGDAweBca41wq2+5Clt9gBS5s1hik4tZYojoaSvARqiqOFOoDN96A8mMVHH89DIAP65auSo6UYIX+iXXH/Ju/6IpZrQS2slr8dARdsR9kQALWArGcnbo6kkxUW5QTNqGGZ64mFKABwLoszVC7B5fwCc8E74dlndNGJ7MqbMCznKTuCpGOSHuHasMXp3s8+0AJQ0tBHa+QqoRbaTxGmIyp+96x1MbClGg0hQZgEopNMA9ugecBNhokNeJPBsEz9aKTuFRDDVTYAlVShdW+l7GgC3I0U0gUPrh6/78I2zSj/Acc+QGW+RmOMIG8qWCU1ZAL45tcXufV2mTvpciXFkS2uayfn3IRc4XwqtzUp1aV4AE02eUFKy9T7zvMCuuAEt8SriyS0RZKSyc2x6dm/5cQCrH+NfBO5gBS1JBIKEywl1hAKFicZ6gNAP+8xEJT9YAHD7UIWjyDPjpvzeRX5mISg/28ZbclF9hUVhik72W0cAzPrr/263nl37bASD7TZ/rmfXM8TbCFWefT6Xi2ZjTgCyxmBn2FYwMxGPcd21oa8O9lg3tbzbpiR1OX/ghFTRAJ3V1bKzAVerB8eHzbUTKl7tt/dp7ndwVxR2kjnSb6AATxGyPJ6urs5iaFFZnf0uTcGzJvaVfT24WM/iYSC+IQD3xSEdkeiSo3w1r519BETD+xSg8yoNC5VZ8igCVxDwADeHpLE9HIcgKBYMystpaFLtPWs7plJOXnoLWy8g5oQA+8N3j2xbJi+DqMlgHnhvtgm+syToZlH9n7EAPLXiOACR4krSK38nyaZ0sZ0cYwKWlyybtCyCTQfHGeMbzbWIAPL6nM8TuhkbkUaHkJnay8LGon5vL0tI1gZzDTNO80MA6sjfpsmml4knYw1XoQu6T1TzjFzXMjevGgR3SM8vaADKbvdyt/RLWk3JlRv3R6K4i6Mzd+vFzySWMmn3ktFrANFuFh9PmUe1zxO3Kxnlseent7nSxrq5MOljP/e6z+AAwNEbFZO6m+FSKzlh2xJ/uRv1UzMJ8XczHE3II90uVwC8oMOj2nFfipVIcjnkB8RGjy/9fBkLQQOSu48wY/gCAAnIglgrSa+t82TmKnwhzrq+oNmlsYJNqJ3d78gUl/EArE+PxoRBf7BPM0SmhyNcVW/Arw/mZlgY2p/lQzmYlwDB4qHljvcOGnZcetK9t7Kzy8LQ3QM8nez2Q57R0mZkAK8MK8DdKL5NsmIoXp7OnkZaAHsG/MbAjwkQERJjk6sAsGVyzTUNXgy/4vb7TK2sMsRMAgRfpoqxGjHZCpiqCwAeSPIv+cOoDfIuSBxCrcomp2a9ZtZKXadN5HmaReIDAItLm/OHX/g+uBslAFDigHTc4MIzXdSytDDwVAD7CQQAaknnqcG//wNTaRHbcWVOXFO0/iTR8gH2jJQ2rvZrEwD04mv5AmR2p+YuWd89zCjSM8gjRMhW1WyfPC0GwN9MABqHX01EYXKHyAuc2lfLo4tyToXxQ5f+qIHlEkCjfHgAgFZlgujImk9Ij87UxnIIMy1wa2L2z7+OIos20+lE9AB9WI33FD7iDWtzfm5DjKYUluNxiMalW7ezs2iwfyCLAJw6A+7XKJ2qNWqfYcJ2xaDehq7o6xAlvTA4Dadzv2kATig7xeRcRQyltZGjGGkFdiwCwMqeDjsuIPQZuChxoQDDgRHPYRJ5rLEXDe5W1b4K/N7GP6rg/8uchsKsgCpSACz7PgA2jX+jyvIlyi74+XHrkl3ZTcb//6rYl/N+aW0AbY0SDEN6wMJ2c5VeydjGC3cLZ3gCTz0uDC2GukMlcQCPeqDCIMmOzNXo5h98uhPRJVJSghf5PVi1awLPl6X+AM8exA8Kkj9XWhCn+i3tsK/UQNs0nsts36hcZ03r1EoAsez3eeg5fB//m5hoIIsCsZhVzwtteLTFXSdAKzi3ugDZlaZjrmw3FtRaopGZU2b0XO/KU+NgVTiJIMRbGap5ALTTWJzcEbZ3XGvFdZH2JMSLgd4azjwI1i7Pf+74uPgAR8j/PY7Lft/WVMZ4T4WvS7AItBJHF1hNVaglqa49OAC9gLNm2el9mkfR308A4eKMwXDdts1AmncSPIfQvBj3AG3vix6kEcFZT3iJ+ov9FOZv5Gx/qnDCtFQ3B2brfCsAUVjKsNxQ368qJ2IewuE3unDl9rFIVr1OU/0l0641mwCKw7R9RHDrYtbWiSXDLfLxt9WJXf37H7vrvV2BDxCoAGJeTv0PsFJqld5OJTQEP9xKjXGHCfrxyAWWkqVpLgsAkar35CD7/6RyUizvph1mkXaYD/c+Qb7UZLbopX9uggCRo48rLmFAuwUaJEeLgvSGZB4ssLTHjFI+OrWGFVGsAJXTbJd0bzJd/8hLCTGZIgIesMDEPlvmFKwEat8HR4gAuB4ETuptMk+NPv8E8otkJ3hBeyQleUcXow0O1VeA3wDM0DYxWmpWNPzHhxkrouTMYsfaoW9AcVWhbVCn1mUSAD/lFDJ7r9eCvrBWLdGqg4Suw/OzUeKI7S8GwpScw1AAexXvxJG/9mWO6yFLsjAof2lLEgeUldghK1mMXLfLiAAloghcmN2rAWl8u8HM7dgqUAmaM9oWpjFmxUYou7bOAKuBG7Dev6xtNe7yr2c4cCKYaDT9Tsm1B0cdM9R3RDAATmILOM1TmLdXG016lcLSNQnJqPN8PnDThwzUJc17cQDwrWQ/q7lOuGJfMh4AaYJiF5Nuf23fKdyCRmFWBcrLAFL6PaGzRilRhYc9tbMUwuJsVR6bEsPCZHiwci4cXOwAzLrxdKbov5L8zL2Y9C5spoc1C8T0JPqmDXTP9BQExAAvxDKrvJqAdLg+bJXujxqTu/WfPZa0jSVDHcPByYhSAP3yd4bKBYO+IIaIEQUax1x8N4JX38M6EK/VGe9ClZYAkrFJ5hNz+S+sWVWGxvS42fHFybL3NXI/R0m/ltL1sgDAGPgtDqhZBInpjKQnnzC9SzKk/WLmV03cT2BtZJYJADchD7GD5uFkg5fccxeoblXXygOm39GANVCTKQ8+juUAc7mZvz9UlB4/PND0eQGS0bwD6M0GvF6iMCjmZXNDrgD7HWUHHEG/PJhfkH9ksX46KPaDA93HsNCyBbKfHRpaAIZcbNJRYMnD6GKMm1m2lugA1QOlvr+2HytuaIFURdMAOFcXwdyR2fVexoj0sJTOtEOZw6mj2hg/bgXN1gm/QABvszhBkTV32liLbUgIITsmU2aRiaIIIV9cD4RKHKMdAL80GBYKJCuTDoC42NYYYot69XstX9x/Z0JPz/xom88AmRjNvBUah012BawgvVeHytlBVoqNFPggreVG+RCjGwB3LE/T5f8I3cTbV94+IjBd4Ds3qsdoH3//bTRMTp/CAMjQmRCS+Rtvuzdx/J/td/Ko9qELi+t5Z4xRCTmS1/YAopOju8RSRXYybPvWmnmeiljXM8FFbSDeuFWdumqMoQDPihrY21m+FJIVFJcB+apku41i93mBq4p4xIjANhjgADWSPaBlBVuruXiZ4upE+/ly2moOH3ggKoeeGewNsd8AZQEJ7v1DXxtDOQD0y6BMmHkXFMsOTJ2MwMRFencsdwCR6QOInCHyZFxyaTusCGTFbAVx0IM3NaBW4G8PTWGqABN2PKpNvRv4eBR84NnFyZ0bvcNZ/akuxYvcjWhTRAkA/AgyGYZlObUs2flrCCgAocRtdinZPCeM/A8PPSmpDwCg+1kz90cVkPR024J7BwsVTXm+VLVfbeee6OO5BNFwAMNDhK4cmRfxFltB3OHT2SsL2pTWTpeLQ5ao0J4ZovYA+dZ93axWixbn6A42FIzwcvEzu75u3FLEJ/oM1W4JTwBQ3pNn4GkgR/7CstXGdfMLzXwejLXzA403r/wAKnULALSxXerpCSymEwtpRiH3FB3F4xmzbl0bQquHMaDpMBYA55me7JUqI2TRVXrYC6v3IVWT/Dk80q5qgWyn8bG+pAD6P9p9HSsfHGC0lnZbSSGLrV4yaU9bd8JR62fHXQwMAIuPkOqgbuMK3te3RR3D7Ya0gtfj1BSgM9Hh7BbxpJ8ARYakzg/hIYMKo/aMwT+EJVcQWWpItREgX57RFbpuFwAp64KqqX7bFkrIeXCxRmnU1Ck/yuMz6WJb0/FW2h6NAMLvCxwUH1PPpvfky7x2B7u3JU/VLALA4eOYZFZe0jYA2nQzJkJtuUPKms7wUCsTsryUhe3abv2KE/2VSv2COwDsG8X80aGkHYRxmBKdkc7TOoN7pysQZWKwE2tq7GBBADfW+QIpM4Yyj1jPhptp79l9B0sIKPyxLP2O0ELNjWAAfOT0+mVaB7+qG1vMSaTW+k3DQJ2GsEBwhshRlj8zSgAFB6Aylr3I48yM95E2eQE9VKb5CMFZNvxguG7k34YrAMui43lBLH4A+MnbrP2gdWZ8hX60mDCuJFZDbXaNzgEAho0p0+lpaxcMZ2ieUS32auJ2QJ0pwq8jmjLzQg4W7gBGGFQrvbP09UM3PgWX4WESTSPnhAGTA3NA1nSRALhTAKrq18j5ZeW84dtouY5OQNFf8s08b8NKqDPk0w9MB3cAgtiMwJI+t0L4wV1wiNNF0f6zajGNu3VdtLTw3LMBlwCcik4wL+jATqJd6PMmcGK9WRjOzb27ljZKT+vxtF3kAMHt9cX0Ffzmlc5NQLgrUjP5wCltsV3z78aRCIji4FIAybkEJA+Jg1qJ/duS5+LSV6J0PrOd4WQl2v5+bxhYZQA23ypnsP+XtF9L2LTl828dfBMRLycVysGkqrntX9QdAAaJsjQFW4BUt3caohqf+guQvq3IQL2msAh/uExFdCAAoN6X8Xkd3BuNEKsLdOTWsmmbhi7H8XmW60pjmOXByABmPUPBvMwjYnLPbPvhSFDh2LXAY+wzFgVanNe7sSUTANiinYY/LTmGI++miRJfXfjPtvvtgOuJ7Yuz15L1/rEA7L52OUWB7qDg6AakqyZhwkDxwY/AoxaXlSqetP1SRwDTYjphgfc2TFJNOKhAaqXOTTkDM4LQKbXfB+9wdEUZABKYHio1UeZW/7nOxpM9EuWC0KH09r42qXOZDAPecOsAo5IVshakoP+a4Sg5lWVfd4Gd/RSiJguzza/00KDQmADJbQc3MvHsLswzhQqXPZXJtPcrw/w8CLz/hRZtXOCsAJxJcnj/ohl8h0TKfLjZ4Yv6/IoVprp2VepSJHczz1oAgodLQBXmFsbW9VojPbyd+UgfsSo79KjhwfON1XpXIgCTjLCiDRlpTbvXzO7XIZofeQuYQX8IXtniBv2BiE7SAJlrJUoWNWmBK0eJR2ATamwfXmog9E9q3FU0twGspN0AsO465zGfr08hKPKJr8x90UKpf20tXV/5o3HhIMi2cgB3lqrcgP8AWpz2r38SpBzjV3DT9IIdrwhVdIoQXD5iAMhR2FOLAAZVaPYtmUD0PibHlzVmQtbTD/Q42NuDBewAU4dEe0eeI+J+7F20QE0/XzhcT9BtYkVX0TkIsxPxaQAB8s0+9dXqEdkSvo/1gBiM7k+aB7j2LkQWPDr7OWq1ADtuhaPcKQ8kPk74feDCYfFem8JIXTlMF4/6x2ms0DUAdyN26UhWUvoVOy0OwkuY+LQx5jDgo2kRb9VeJVdNTQDMeHkisSRgrQSUhuDOMUJhOnRN3P6DAnwEv7gfwlMRAMgWv/paReoad6yGDV/qnBN+jrKlDMd/Aa0Vekd2gt8AzufcSPFNfv+XTE8+q2Sqk7SUF0+aUum0cmahvE5AtgA0kg1O2nxZvX73A4Rqa194GiYW8q7NuT7WtAZZHKLsALQaVAm/Lpezv8oNCfVj7vrFey7jEoJaTndh8ckrYUcArfHWUBzxUqThE3WrYGRK82iOSXekQ/1KtUW8BHAcPgAftgIvj0OcOmVyLwyZ9Mx/k4l0q/qrjuKRUTTXLZ2yAL8g95B7Kz3othLbGwXp+CQ0ElRcbgCB+/9h9XkYNPMAEkrR9wIP76NCzoo/ZEL18LSnZzfXFpEt/y0leqoQxwBUB1TCp2Nm6H6N2UOvvO4cd/wssY5PJKda6b9IZV+ZAH7GK+/Gf8V8T+8QpAHnpAdvKefa9QTBvdl56U7JAuQAHKfwqubK/po/U6bVpw/dPUqL2wF7bTvZONCCiCBhHADPZKiwi1H867PYp7f7EKmrfuxN5OwQ/mHo7nCuJPROAEeNb0ujfz7Ly7myNF/qoDIBA6LSJI6gzU/P7lsY7bYAhAEykPW1tO7LY+HQphUEbWYjs7vi4ZlAsqlEqYSzPgBDPuvMYKgSfMZ/CNxVA2XcoDyJ5jKRNuU9fHM+tqjZAP69EZFxVzBPnZDr7oq2UKE9KpFCpE1n6Qa1ZFEIyDIACTdMIFa83FmGqPzZF/kWdliH4Mk4b4fVII4rWPmMogDxNX6Q1hGEPDMoSmkY7POIrJyyKrHAve3D7sw021clANQPu9KUMYDHebHfCRJIxPiO+LnMTOPjbyGR5zL6Nh4AcAsfkzuR+yBWw9y6Qd21yUKuZL/x8vc9RsRG/NHowgA9vtlooMKWZ66GXNy3TvWImoLL1FTbVPNyW1mY4Zr+ADIFD7Pe5M5WO2OHCIuL+aAGg0lanDIcsaF1PCYAcRwAWMWgeGudCgn3ACICiNjaGM+6efll0n4K2UN8xZNu0QCpzJvqp0TnU+NavzZn8lPTBg6jokJq5hk0x7zXwi1BAIF6FC+w68J7bN4EKn/Z7CSc9hHuApli3XA97sTF5IwASMJVNlaP04pPRI20FK8NYaUyKO1LUIbeEXJMYWgpXwAi6EXhN1b2ltjqZ9sfS8kILEUK0qN6OM+Uu+XKGBUqAHJF4hU8rZEwuxbL+Nm1aJp6x4ZrXzOo4GekB5Ea5ecAaQ0vcgJ0yewJm50Btjw3R1hbplBFrXCxXFCXCIv+8ACZtnQtdU7qANi9VcNdlaLqaYkVuZHDldd7AsIzXHfEANfN20W8txNHrCUbVZeEb7PquloHaUd1iv20HoVd83YApSC6di1GTWLrHH7s9Qz3TOcjM2MW6eJKI750pFy2tQA7kW6ovNN3m386OAC41GVCzAAmN2ZKRb5dzKtlX+ggAINP6Octfp2IxAEFkwcS/whRc0x5DTcdz62nR/GL+6MASSZ7JK6dnKI/3H8Srbn0slxywsZBOqkUxM6GlGqpFgCtMIP1RCgwYkv7PSkdjQYK3g196jDOObbqcx2CDRElANy4szaalb+f1L9QI+a5lSFJvDtLkdIHVY2hXhJ3WoMAqBH9hkOVzmcVHTpLylA2/7uvpyX/2LugUniP68R8EQBXfWp3l4iGgYk9MeffaM/f2NnheYxFS6hMdrYWKuJmACTMuSeNUeFOyammB/1QkQhLVNMHIaFL8pDE7LgdEqkAtHX+ma4FqmMNcsEky8Zc60oOcX20R3XTO7FOzthm3ACS4253pxm6n8E3b1OsGFSXyuPoN+BWTUl2LQHg71lPALt8cvl+2bLjhyFA022h5skLjf73zUkb6+VFVwmR+DIAQGC0UiGPr/GgltCb2LRiAQpHEWWgMpse1+tNeXEehgBsN0TZ0sVZUOqbiFHcli2UzUyXtHBRnM0s97/btJTDAM+iITbPqzjoxP7jwRIaCcnRlSOizATgHDTKhW9AfREAWYWkWtvwbaZhiZWAQdnv1YUioCC/kfrBXk//MS97+gATXF9dtuROZEPcy7BPT9NX02sVgolbp9QwMPmyCfNlAN8RTZgp4mzdiUuGg3FEloTJNrO6nxdfebi4L6EEu9cAT6qbxrYo910FIQ+oc1NShKjiDIG9DYC+BgL618lFngCH9hU6QFwBscUIJ3a6pi+fVVB/riGBgjTQrw3Lsq3xAKpfHuo4LZoRUCL2fa1n2HXvor4JJu3/WGmcRYCcv/8Akodo/vGx1YGFyvqe5GjzlTrntlpc20OCdDyHeOMhVQCbItI+k8MAvgFKjJIU7kkTSe7GROTh5EqoafcaLDS2ALEzs2Q7yqi7HpqEboaH14CLFhY5iwFv/9DZTrM1mFEASV18jFZw+FpebYAuJ4Syt020t33QcW6JYoZd+SPVfgBiS870hQoYU3cSSTMaVL1dU90IRz8NThuFUXMTW2mOAIL0RWjcjJNDZyUQONu7VwBQadf8dwyHibq1zl2IzakAveu+GHhpozi2lPTTV7vz98KOKxni6ZMdyvQ3oOnxbAD5FMzwfPSRYvO2JxGLlhHd4ON4TrDI4VD25JxjoYL4AK7viRqsaQFXuQKupvpZGFNH4Ay9qppcnb2Iygz+XL8AuoQsnhQSyyS3r7fOTzd+KG7o2YEULkFlIVyw5bQmEQCvW5+35fQ67Vsfu1fBNn1Gh45l8Me5ZyUsRLcjbkJsAINwaCeC7mNI3kV2gQHILaE9dBCMt0xLeWMpSlqSBusAZfoynhn+BytwtszC3g8Od6o0teJKWsILN8/pgLhCIwAFLNlWjMGu/y/84AVwgweM+EFL/ZHHqoPiJlWu1vmCAIaTWnF+57ROpQ9SDj4Xr42HOJfb9bwYZc/O6nqVuakAjKvF7FP6CnwE5G5ZbnDxOT7UT8T/CR3raOZz8Ul6WwC9hZ0EQ7UQMNYed1gCG93MKAeSJPVrEDF87Ae+rdMkAPOZjY6LzKaf5jINmgIkpDHGxZ4pcEgNJRIozPV7goAAuClthIP05bjgssx+ExuruQXTG0lwWom14xtpJRE8QAD35vPLBSOtEL0K6NTeBB5GkaHWClrC6/WVamkIh1oMAPZKlO9pBeR/PcrIp5F9lQCgoWDKjNSd3pa47GGIBk8AJsozM7FdI/wLtJDmhlj/aMlvF+00kugW7SMkeGnvDQB1Z6Ld9xVxb/HMf/Y62r9Wu+FDg3/jaD+wgUSqmMGEAGtEevj+WMJ4UOSoNdcJ8icUwWCMEk8RJ3cLVW7S5n0AOwtZ0NHtjroSWr+0nOaxoPVtp8iJC8DAwBepo86ZVgB1wG7EDLDgM2eMbAdKSwK8D3oaIVE23u9oMv7jBGbHAI6j5WkmAxu/VZoIhI2r2EAQ56Aug2yJMx7nY9WhjRoAMpjystlVt7qgDbaS/oIpwCvTTdshVc808nv8Q35bugD8jkizJZACOA0krIicmmCTORLuflVottMs3j35vKqwAHcZHp8i+5mx5wTn/imWMk0AtOqIMVNqOPDVCqk9cA4ArNt6IbvFXMq07NPQ4J2C+W0DZK1a35aJTgHssDLllwB2Am9n5h90U6YculY19WXRU32cCKi4MvhZphi0c1+cAENhnOgUmC0AvH7zc2nmFKbdRKU09Nna8lxprJI5IUgAPAXJkI/nJm/PQ6oPqoOIPzfYPfaRskcrNELqaW98/ACglLQZttEwLObOPxmkEQy8R+LZJ1JTR4JvghGW4Ih4AKa/bbU45KGF3NPkHYhdP9WLpnn+nus52oXytYYi5oUAjLRc9xgZGzKHsSrag79I6JMtsVudCs2PDW4E8yuXVwDUPKxsy7Z2WvwG7UyCA7TOxuktaUwzqiZvLCRPH/SwAGwZF0paNinexieEh9MqfgFBVjRa9KB5sPtuKIswN2sAw5H3XlMYRPxA+EYwnFGoPgAgLI1Wn3RRv1VBW8ANxgCeCVYyrXHtwyF7ymKEgZALNy3SBtrSFShU4icI/LqzAB1lR56IWlJy/vnXP6BsKiVqmdzzwgF3VUsGtD6IPREA5l3qZP8Rdkn5dkkZHn4oZAJYdlfAB+JMe8h76fY/QwB+SMwTGshJYjPU+ok4gmv8k3wg3ybf5vNn3SEdQGkeANaa618qR2eykBB10JzqiHYEuuVosF1FNcm/dk6x4oYA7OBCrxzzdcNqXktOruiiEllzhCnTb3eN50Tsyq7I7gCB+4GuWR8L7IueDhIyJhdKAcoTvyxks1+7pkJSTrPwAMcqeZVjLpoZJw6LnEh3AvUmncyIfJVs9RU2cKgI05YApFB9mkz4VDro7oT/T53P7d1LXKmpqcDyJOpbnBQg+gD2GW8H5Z07oN42+yD00/m2nYeoQfCO5QVaeAAfC0mhAAUNYGQzHUMNylKdx1LcRBxCt8H/3BKna0uA9QQJ8R0Al8hltGFgoX+tjeoe5zNPhRCkvN6UE51uyspm+5hDugCzlLhENX/Bw7d5K7HuxY/cGloOqNfRTL17aE4j1/WbAPQn+VAfoKozqHDFs4jhrzc9xkW0DhIJrV5PRLO5ZwwARnZcqpJ+JMbz/xKNzmmFqPcyFgOLRlGKmeE1Q6XgogAexHKtv1srGT0UNvOMNJCmja1m+s8ZB3Y+6SJ4EpzFAJko4Vk4vfQr9AzTbeUcNE/vefDvrIv1M59dtKzt63MACKV2wJMKsPoVBkHnejEc+vHAadLNgHva3d/zRIAQOgBjsHOWOReBKKghI2A0HxY11efJMRwKbw9cVclilEoRANZVyIUcvmlfwDodNxwnbjNd6ipWrV9Ir2Fvh6Tm2twAH7IW/woNNTXzRhkKo4Q/G+2P95tumhC8Q3IcK7V62wBlGaO/+b33H6Aw4GoQrDwhAONlj8ybaXo/GaJ+i2SIAPz2PfOCucnb9+7uS2VbM+feqE8NVAPXXIVUL/T2N4gA86Mdzg3FFqqshzTMX+907HPprPtncwoUwbqz/ENd1ACzKRwg+GiEtJ9JOAGdDr+b6Ag++R2M58m7GcsW7hQ7AHFihRNkmGr1NyU2ez8JWuRqrmV3PR4z19DRsJaT2IkA6/OMJoKHNdVzremD3orcAJ2rOfb0SmzkSm+DkqaoBgC2wvKzz6ZCQFv6663cg3cBmGoTlVOZ80YxU4ezoDNIADF62n9kr5DcqcG01l1Z2sVEypIUyhsjZ+7I54aKyscAKz8TGrM2AlB01H6eQ+cfmLGaN9mdROYJoiE/MTVQ0wDlkU0cWroCJIiuD3nkohnVJXkX/BfmZaVz+7MykHFhAJMxWc22BcPXk4mXT47KgcECLGGPiHNZN0fMCT9IHmAAN/gJaFduihSh1EC1erZboas/tW9Dz8niG4pFxqjgngBLAi1iDbdYdhONphE12OBBH/kfuBpL7vio0QcpxDVNAGnuBO6WwTGkG+9LybCbgn7XP+8fygUE7yGOPSxOlnwAOdZPnAkyLn36Flw1cF/BO/ZnKiJW33ypo/CLhzBXzgAA9kRgzx0aaGbKgEQ8fpPBQ9n3tYY4ml3BjoBZC5x1AEPmrMCzmbLeUY15ClDFG0Fs4jG2fbmLbfeo8giXwuIA1grNC5mLfGfEeuQyo+buLzP4H9ml7BgtCGvvewz2ZgAF/g8ME+CRKZqLPEDzy5n/e9jd5X9j2EMbYWjiJ5WkAHfNOxheZDLiApo+2rCcYpk08SBBJhHpN+D7SXBYfkEAzgeTDWZeU2aDlXvnN/XdbCXRjeM2hCJVDXHE1F5ivQDMFkOKGGu7ZXT4F5cyA5KZNrcQOn7TVCFBr4oMp5z1AKEnLduNXJNzOXuyKEHA9DBKKyLZP5pTKPcN6yX3TekADX9/qu+mBONobUS47tJCG2YgBcBjgRu9QRy24wD9JAAwThu/9mIgWm2Dr5qtgjNmfbMpwWo3n8wJBSApMqoCANRt9ry3cTTdZjS49xeD36zJ9SbWZEgP5T6y09DmMuYA9Wyk2Z4uqST4ge11sT01c3b8pXPV0ifvHlv99ocFRwDH7lYn2sTVLgOjJr2fjeq9Cz0n4SRbCj+hcqZ2vUEVAO1ljAPa4Qnv0GGFXgT5hxR9ZZL9uHOxRfb45+a0IkoAaSPA8UGE4BIL09ZBuoyOD7/FKRw0YUVaeYsO18paHgC2+anbyg3hMLvmk4O6rWWVf1GE9ue8v19cbE29SLlRAGqnTBCeELeG8CMgQr7HA1vLlIGqz2xfi60QHv8yyu4AD3bJXLjnKdgKP/kzhWu51A86OV7XFP9WGDkb6GEm4gC9C3yF4rLRS08/SwUPKmQJwsM/JTL9g+RisfMjsQItAE+rnZA5lNjwgho7KNFsa7zX8wKVJDzKZV5btCqqjIkAAMdqb67TnuTO7oUuTXHddFcLqJDoXysHq7WjF9fMFgBgc/V+3MvH3V+G8Cz94pX2AUXdSkyqWQ8+CIDYxv/vAGO3rx2Ulu003+D2pssqcLlc7Hn9a0Zv6MzLbg7q2C0Av8Dhe1u6hsQYu4UQbME0o8Vi7KdAwNm888Y9zAQpVQCcICZhPNLo7PYUtT6SBhtMIG7MQraFzOBchVxhw/I0AGGGxfxI4nNfInZ2jtbLMKD5Jprh1fK95Iccag7FVC0AzYR8pYaz7/v4fNoJYX5/l3kdXzJmQ96amiTYukC1/wDd8YpahPPUbpTvmaDYTMbl5/pgvC6yHaiAlSzGMQ73AGRYK1wg8GhYjex2UwCIn6/ZqhVuukmWLefDKTEiJq8A2bcssxIi7EWYICDlXXomSiJdCJ2NsycOdcpwr1VhewApXla/2iv5Diu58VRR/69BhVPEmhRZlyYtm32pD9JvAKVjh7BSIkDwpfjNhmcPcE4FBWTuna+ozu7v3y4OkecAH0AVG5apo0bm1nAwFSAmzcrDQByxFK7dgtgUFBA+FAAjBbyR1a/z1M4AnZbeKrPKKV1volEsT/Y3+RqoSrhbAFN1haiforHkoSuJ8ss4L+BXcQfLJHqVW2k9gj2mXTcA1JZEAojmCYBXp5nuGga2P1Vkr7fIF0kqmV1l7/XuCQDbFs5ssoXpEaf1ywo1Y6Zes3HhS5r3b6prNOKNSGcHAAxF7sDhZwyjCBK0NElv96MNoX9lzWsvZ83f+XpmUkQAiNeO0/yMuvY7Z3bXv17BtrDj6uzRLvbCLrzTOoDZtgC2dc8MRz1ggmDCbJLgSLDn/eZGmTAw9K9ljoq7sjlTAG8eaSNGUdz1g879KXUmAtkTnyAKboESLR1TeEdBSpAApRWny1QCtIfhso4JzAyt5DSB5t4isaLm1huoNp7EvQCJOH1uauCFC+eF4cMvbugX9hvaIzbWZOj6HwOHNQHoALumdE0OTpwsygMwj9nU9KwX1Bqd8QboheI6y8Q0woYAleKzSYw8bH6YQu9BojFdj2Ss76Ez+e8OJVc1+FemJQCU7dzR0AfnXM6wnT0ZHcK07N0v2jJhqdgp0NbwMHH1AI6wgtSu3/8yQBnxPDu3s9KdpSH4F3jxQlbZSoC+lYMAa7ztn8LhjVqzuIhmathd3KWZQppmZV7mSVyArLulQwA72JdtqpdQSwlIQC/xh/xWOKICPI6su/cw8kqocTy7AHUgF8haNnuYQjPE1NKjKG2f3Y1TtD4xrypbyaO9BIEAla6CwkzvGqZ0C4wY7TjoKoy3XCwYRhHIE0w5dAAeMQCgTTdxBLnah0CZt/O5stgrFeUCoGV3ISzE7dvDDEfBACX4sikKKhQYImaA352swpWdGLeDfNHDkUTyKwDPKzIAsQjpyWqR3EcfABBR/4UhAZr36WTx1y28KZ3G9YC5TAAMFZrzSowoeP2/3iRnI7Pzubo0ikkrjTHM4MPMPwM0ADpcWLVAPGgyy7bfByJ7uMkA2u5V6RKGKQ+0x3VYwkEA5pDXcDMJCYS1pBIB2e/PG+OuYu5gO59Ldr/pdbVKKAAOLNwvd8WqEo9an9GlStPsU3xlS64wyL6KoBBp/8RnAK1NEzwul2whUzgNkUro0AbZ5ZVFsag+734B0LyWaUcA0nrP9M1Hws3otThsGAerEvBcYX8KBJJSp469S6pw2AAl37G8rLpF9pBEaj62as8vF+PfaJWZpsHxDgyCjjjoAODwHJn4NZUpQIWThgDLekXEd1oK1j1ZZZ9P/97zWPQAvktYsx7K64r4b0J96ZA5j/SpMdtT79yu68330fgJkwDE8tTnnvG6b9CgdKp8ui2vfjLWXzWOj+TINC0qVa/WAPwxkdit7S9FzgEln1+Z/8FMQFX14eJ4xypB/e94/88A7DTq5ZvYxj0k1cNDQc3vaQ6BXSlvu8yLWf0ORQnQdwAdz0bq0eHQtN9+IlhVaE+CFKxoV4Gq0LI+3DYsFHloAGgOR/wXtmfHcalnpYob4l4yF2qucVfseY0CG1jOhtEAtSL+ZFRD45PBQjR0DdMJjZUZDUpXt8AbWYC5KQE6WACuH1F6RRJ2iyrU9R8a6ibLEFf4Gyu7M/iS++iQyMCeADTo8/iITzDRgR8Yr0WhrOk1tvY74bzXeKQqbfmfJwwAz5KFA0xziiWKLaxsrh2rN8DMxXKA3LVxtOPSn7ApKQAfK6EN51gu/XZltXQfCkm+XQ5dMTNfyEjcSYl35kykAJFbfXtRii9aMrsES5imsQYqZNO84PdNjsyzi84SbN8Acr1zxyaRM2P37+HSirWihrAg/5ZQmic2G2IFOJJkJACfdDaHLHiwKguKyQMFMLrlITHZsd5i9KrvQ/aR3LypADTdTKac4l/p2hJMpne5TZgGtGmc0nVnGwHAp0zXkt0Avjb+TRJLUqU62f8334srtheyoE6IaqEMoaJPFuaCqQA7V7mfEOthwSwJlUnquHZLyOBH1XqW3l1LE/jbcdAGAIks9VBjppaXSr52aL9JSceaZKzuNiJ5hdvVsyjMnT0AZ9YS9qa0fUkzvFFJ7D1WvNwaIyw66b/eJDGKNZyZywBAA4a8lzLds+XSuPNy4xr+yEDwb6O+5LlxJd4CW/rkABReMzgyugRfqIl3hmfAHqu710DovDInh0NwHkEkrccAetqqdEXCTp6i/I7h7lwpfPpbs2j+9qm2klj5LoXBQgDPVUxImBnPSS74FQNh7jUsuk7cvzaz8Bt6wYuRlZnvAK6DsoJUzTpZutPzw3ETTD7wluwCTulyfn70vqRSEvcALsIOSH2pLaxqX+ZQzA/uBF3IkEtePa7rQzc2/xSQNAC5To2sHaeCavTOv5Jfd4cXH3vHHb4pXfyaoV6PV094AEAdb7re1KQ/fGjrVlI+5hm7g9c62iKNdRZwFK8KAd0AINxjUe6PMDcD5uEy5xvoT73NGAH0tIBxyZLEo7yI9gAowJj7DlrFDZL7clJPKdl0xrHr+TvfmaF1J0UHPPbBACS0VacoFGARwavQdtf6ITZyT7AfJ8gCmBC72gNf3CoAW00E+j2uKgmZzMIqE03IvLKaBsbENo6pJkhGMqYM7gAyJEgIBTeKckUDzwKI7AAFiScWT6uHS6vYWeVLD32bAIaF+biFseMLQM60UuPhjhNk8WnKrFa1hWOxG58wZLYAhWAVn42JatNl8A39cT3LEg1hXh56OjxGLpH+qeQ8KQDxDAN8k0KwW7Dha8aExknghaHjicLHLdLnjMk3mrkUANXVrxPSeyWerLaSn3IJOuIHTl2OWkBKPLusOEQrQlEA2XTRl51hI9sIVYatIrnEpREfQDQYPxfImLVqMaJflAALZgkqYs5lJUtJ8aaHtLZH2wWELiNJZLKL52sSZPa9ADAx/m+wOlt/m7SGjmA5DARH3yRjZ9A+xMR9ZkBi3s4AZR8aQd1Jzr336pgIGlJEHFFx9hQSb1kQoWlPrI+i/gBJTCF7vJYAmS4zl7r/N1hyrOrLIcyWD6np9UiQ/PVLAO+7LejmJtMuHhxnBcUU6pWahmt2FNWHhlB7cwXSz6wAXBZQLc6lBmehFj8AgmykkUxLLshOLh0rgYEiTqIzVQDrhSyeHBJSvMsNJo4KU4LqwvvajA0K0oh5eO4d5+TQALnPczbYp6aWXL9/wLnh0DvfpPi+tI6oDA3zrCJFwXcAxVK5B6CwuOq1hFEoZTv58MfLLLGqTEBZ9i42EEyyqwDH7bzbpuOJhycT4EqLTwvOYBVz2DdU1S92ylwSe7AXAPd7Tf5UFzMvuqetwuYIgXcYRQwMKFiiMGh36kVAOkYAPzSJsuxwDDzvmfJd+h/aHPmXw0TR6jCtlH3nYGNtBgBfqvPMP6eVmo360nt6rHIVeHWlQopm18jy0e1819NzAH+989OfT8otv0Qx4suTq0toaunxo0R9d1OC8kvrFAUAKwRe0vMGHs5G2d7hx9pHH9FlUzVmOWuAFqKYwUy8ggC69CqoCi4l1rQmSrP9WrJHu6CsM0i0pXSku2W00qFJAN+HKUXb7OgWD8Q9s0SiM37DI8shJNaF93iuxvuOJUIABNM79ibsQlHiv9iLkUyrvm5L5TzvDsTqMfvhjcS1HwCPkhi/VHZxk5dS26XLNlmbXFTbG/Acl4greVXRVmbfAFitwSpT4bIVBpYoFzgLi+d7D9Y46NIGW73L6ws7RIcAkTBbB1IQbiNEQChZEeZVfutCn9lkz5atdqRgyohTuwDuFsbqNi8fi89TUkKVDjT8Is08QjUrx7RW0MIUVY2SADkz0DjMF1SDE0MSFDd38YYZuvi+b+Js+ejJFaTdTyMAZXqiHwx5mE6OnIm5ZhnNHqXIo6mfJhZOj8DbKhg99wB26FdmPgw6WzNzC2+EhC81GHiZ2EF9PQLGR5ugof/rAEKAmUtH20XEQe1f9XfMYB6ILkP/snC4NNsbX3ZYK+0AsWwF9qNNw+hGovMB0JanfGT9DfFWAgnln3Ip5fuD6wDOlizUBpNpNEQa8riDbvck5thNU6qdxDuBLI5l0sGBAM3vU5qUxgFL7I8niVMEX/OnjlOCuWE+F2qRlq0QmpkAGsj9pCKYVxfbD3a4RkmPsrcA9gp5oJMO+IhyT3rN+QDolvRan6GBbPijW+Aqdsdc3gQbDoZH9tLHP/u1sT2IAJUrPOyy4cEW+BU1AXXyw5IiFsunUNDiHDnv8VBhIeYA0cdb+uZb00JLnbJv+393uNL0Le1Vd6SbNdrjNvU3LwDir4t7P7kdH0lTmV2BHihY8yxoctTUN2BVfnGW6v53ACNrFRnq7YS9JReW163UxmYRTVyTxepN6I62rdNR5/wAzTNgBMDyS8tha3mCUKXvps/84IRtu2OCZA2S+YNJtgDxjX7pYl3MEGEMqf47mpcIcf78yzi2k5vsUaSs7nLJADzmMbT5QGOgs+V0sFvmftkDw60/dAWEY9R1G01jsAkAuwLRHWbcUnpL1D+pq8cditkvEjDzAfF8TYino/jHHwBvGN9loK1Apk1tpgh5FeJtaAVNNaVlVkecwWamMK8CACTqYNfge8os/eKlR1z3WC/39NdWquQsXYC0HdSPCqYAL4vEnmWXfNFLbVdcwv94eFmBQoe/wjwqrZM7F93MWgC1IWG3mwnRClxWkKh+SDqN4h8fEd7kvDkYZIZNefvBAOPkCRZbzC3vPb6b5vORvuI8J0ZE1vndfMt/4jt/BhAA2fUVp1RB/9kIfV4lzQ3/oT044ViRKeG1M0K1PPNteAAcDoROZOdp78FSvNwmxu6hsKrskpB3KvV/enGr9BQdAAL3ZpjQ68vaVPg/dcqX2YgzYBf4iLTUQxD8rQmtB44ATrayUW7y/eTcDbHwOmdf9Hws+Px26RIEyfbP3ZjD7gDhymU2uEGkrYqG4+dFkV3g+9caZiZDXF7CJbSIsG9NAJimPebBoMcgGVeMXhl1MdbPcBtYviV/cpTO+DqfzkcAbNJWB16mF8Eo5JV1X1DeKB5xtNqHKRwXzadx2LZ99QDTfZFIXV7ff4b7M3U9cLZ0fl1AV94j/QZPE7OkmULEAPcftSIAMWDWWHLjZu00lZSfPbVSANyKiDxUpds+ZJ0AvUVFTnWZKR5X3rnHy7Ll8K2kjVo3mHa820jPb6Y4RgDnnfENG052ZpttWlMYNAsDYZABs5Ry45xeWix7ML/XAKwU2dMNjPb552sPiaEBML3AWaewPH2Adat4Vj2n/mkAJO3daOSWPX0auwr0N6iMnXnLdVNLE8QfzsI8db0LFgCmhIEJ17WhukSp665vbpLBSbz+14UZHyvxSzT43GFwAKOJtCdIzOgimn38JoMAwoeNlcmHoxSBDgozHmJebL0AtKgjmUebcUK/OVuyIO26VpnyTQxuWSs4Lteu3nPs2ABF6iNivhfGWp39S4J7yvVpggY3PLH+gjBv22A7ld9yACMafvrZ5FANxAxeyIxtduEl59WOpABWXJd+mQim7q0AQyb1kKVEpPAg0L8n3RNaN5c2b7nTIIP4efoy6UkTuwB4L9sfHbbs0jTuftQznVwRBL5abaWgNmsbV0Y95a1aACuSvrZpO5VKyPDJ2G+c3+ehoKBPebwEzDP1kFVWWYkABuX4T/MLoLyZM82yHLraKVARPoJhY7TS/0veMS3oZQBUDGR7g5cK6cikUE4mg50nVXH2+/jguc13lzuUOXxFAJROwVZ4rmaSbyIcJDD6OFzp5BtfacKuIQcNfCVZWI0AafJT7i3FKferhCKyF2XTi4qfTc7vUQf/rpFy6+URbgCTN/IkPSbUFlXIPOYLnke/9PVv4J8N8wCBKBUjhOW0ALhUuLITttq+o799CaQ8J9ghVnoiyI6GRlSV99ow7qMAPPtvrlQjjPA70eVQUP4YxOS0QF3obLejOnykznqSJwDxDuPwgzJzOSxWJnVTqPfolBw5qw30JjaXqkluXBFrAMeRpDgmjJQYUubY6t2tp0cxWNp10LdNfijN8FwqZB8Az2KwxQS8RdM+Z9SGQ9kBKc+1FMQDxPdKytC9sfl52ACuK2aMZH5UaIThtC6TyCVGojzQetjnEJ3+sn1YW1L3AM8kOSZlY+yrO8E9/vm7zd2WwRqSrHcg7Bn2nJs5UZ8A66KPwduEk2L4/BAKrLXwGYHEyI96U4YWZ66hCL/9zwDRc+i6ePvMueM/x9++yoEbiHoojF438X33VRgws4MdAPL2x9VIpAQ+xMIWGK04vGakFdwRNLgjh+Lpt9TkHAMAc2hyAiORNZ8VPH+Gx64laOa2o9PTeT1xdjGnJM/hbACuBfsddZ7UgKni23fFLRq1tgxx1TlOan2CCxBkhf4aAI4bXHem4g4WEDFhch77paPBRpYo+JSeIAwYQCNB8oQANczsKu2fws01Q4csesqMwG8GheHgtAr3lOwUwc6GSgAZgHoQnRxuAKMlkJ6pVUjXD6/s2nPrLnNJOpl+TEp9AHWgji7AGtFgWljktRAerPxHI2Q07/n7cmMr7lZ3zRIAuhVoUHZFKCeTqwkOhoW2YwRu1yeDug0BeN7c71zUxQBiEbiTv/aqB9rnSpQCthOv6LcCmbcCLhlvYK8uukzXAAglSTIpxhZbgg097uuHQvfCYo7TZtmHTl04AHtNmFMAQkFvJlGxLXDJ9uRn9nwhfrKBA0JDUnYq0trrdhK0dQAoEYU9d6BMriD+vOg1Vw5ni3F0m7M9Jb4UShiPETncACfEWxTEad31Ah8kthuRTAGufPFxiuWAOeQISPqXAdoAvgWoCBHCoKP7BtLrvFVEdMlhOMX0xQ4qUV72Dq7rZgAhghO6ikBfnj9YzzVUQWTn0BglqEkivfvJOvibqjF4AA0nGxgTfdHgfHN2pVPjgTV3n+JdaYvitZ1A9dyLRAAAlLkH5CvvcUpCpfzHxTnAvXIxSYIoquDl5Tw0uxDr2gCXoW5+F4GZqo3xdWqR54rIAJB65kTCdM8j9qbOKAGSAFVFUdCQ+5MxcixySmW58WNa5IGQ2l4ckpfNT/e0AGgAGQ6r0GZ9I9jxXnBI99Jexk/S5PW3l38/ncuaipLcfgCryt08WSM7WG9btgKPxQJpTb+jP/QL1pspfqYnZpwOAJeFxn5PrpdGd+wCEzytB1FnXLDGNro/mP8srayTlIcANMkFKqUDlDvgdJ4pca6BmQzJGfgkKXGG7hbamW4lTQDqUeuyvEdg7Ky0KusuFPHYf9/NMiXDAjxauDWsRnMBAEnFuumx2Mxj8labzhUJOP53dTdol9iWeAtKj0g6hykATuBE5bxEQ+ohFw+HZcJyC7tZZmBnGP8ou1Ph6eq1YgB3RgrTMp2/W+KsX1bqqtE17CWPx7TNuSsFhsNx+LIzAPW22n8M+ZJ8HnUG5uUHo9hEiVM2f3TB8pZErettT28AaOOrP7L3mi4zImFKpvL7FoWckSSRAUHBfNjzKwnLPgDp2tYnZOiVnl7KhiXarPjpW8/qtaffwbxH3Vr4J/SYAIGX6OJ4NgaKVj2Jl9Zd1Yh56H6VYCR3FnCL5KpMtKMAzW+Iq/ZV4msJu47xxe6MNMNymF7KzE2xbFB/W6zxygCgbk49p5UAqhNYCX5yhXHwH1RG6ViqFaGS8Hm50HDBADMQcIJ+f00ViX0zSLEFHhuy8O42QA5CxDnPemrpjMQAdQSGQRulOvdrKL7jhq3eVM6qRVphEoIlLVnkLUQdGwC3jQ9qffdAt0zezbeeHYYeOVGsuvRzoXcDGteTSI4sAB/1W1r1oqDbV2/xLO0jNJAxyGKFAcVNCK3yxhfPbzcAGrN9ry7zXZh2MSuM+4BS9UmA5dtMOuRtuPvjgSrnfABHjav+T4Eeczj5MzmCHSKaAsdQ1pD1VeY3hH2UFIA8AMcqH5kDI3bDwYPWf9S3wfpOmCPq/VIWpM3RHPodxg8AkhWGFLEsauUwPqNaXHkhoVUt0zKRKk08fVIkzV9DBACptuFhG8J5cAuUBEJK4W0dx6Nyy96HAFgKOElnkW60AHdSl0wA1lit/vQJbB4UhvR6NKoEfQWwuyc1rhT/gsUADzyPyGqsdX1QKj2rW10bB29JWV7CxRtV9fv7gAfbYQAlgroV0EMt7A0YO76hKiCcyA/QqVEXoCHk5nYCN6SkAP5b1OLuLhF7FGcBZbZAq8yWBn2bYMXXyLsdBEmzyNAARI5e7TCyJHJHsNERg9uaAuTu7AfsxEt/lL/Ih5FIlwCt6RrprbB0HS6plv+mfgMGQWLcf67rXII49HrAtmvJAJRhJ//8wEjq6aSGfxFaqVK4VH8+pJzkBAnacyd+r6gAkGKAzLe2bBmzsb9ZHLNVZBfWnAGwnpVJuHeFUsVhoACbotYZm7n8vwh8Qf4rbTu9bkO0go+Z4OE/qr8WMm4AABsu6w8Dq55rNgDEqxdJDoJn32f5JT61UfFFgwQ3XmwAb5EH452LzR6WSKtF+xHkhLhfe7PWUolCnbxlVcoQmwAxL8rZVRqiWcJKyk0oP3WucuIjx0INf1tor54vtvbmAAskNM9UL/znn7V7VOZwx4x/fESWdoMZjTDh9gIr9g0A5m87yWdiYtu5W6MoJ18bCZWBL2C6Okd9c8urfr8xsgCfrBks0T+Y5lgh7M78IgxYwx7Cqv6GN86BgnKG3qhCAFpsMZF2zRXvM8Z8eJnsgimfhpGC4Zt0Nnh/fQlteogAKy8mE7u1LmtaYxbmyZrr7jTygzIDotN9pkTQyCibXwCmaPb9ygOILAt114z/P6wUgZmx1dG/IEgas1t1QiBQAH/iJdPGxrkmAJ8NDkUxkbRyMUzTOuooROQr0pbHDUcA0ttFR2/fSbbygnjMOPL/Hj60F3wEsR4m/MBwLqV0MQDNkfwWVn/wr/04oGb/FMrCZAaTuw5nFjrFI2VjvrX5ALiIhf5FMfLMFPc9a23VdOFHtu2dBAC6TNDjpjqeF+UAckHTJ41zyfB9nSbtwDJPNxx9OLnMiohfn7lEJs9acABhfzics0L36cvlcjcvAF565y38M6vgiXsF7tiz5xAI", + "commitment": "0x8d0cda5702ff5fe346575acd5c1f0c13f556f573a99802b7e47fe765f55de623fa0adb8a88bd4b409a2f22c2540bda07", + "kzgProofContract": "0x8dbfa38fb6583b63a0f20eb844109b7ef94934fa9487ded8ec088c2bd778153f34fbdd469b334d5eeb92d428c30257cd", + "kzgProofSidecar": "0xb17c0a962bd0ac8180213b70285a1a8696b5f48869053018c052d637043bd9eb84bc212e14010922bc5c53d85d51c62b", + "expectedX": "0xaac2efd7cb2c3df9ccf767b27f226da7c279a37b622c4eae0f318504b0f4481d", + "expectedY": "0x498ad3669173b4fbdd9e8143033ea3987934ecbdaa2532de64fbc6fd98ab11db", + "snarkHash": "0x11da2f43dff6015b16bf7f681018d1c33ef96e93a3763b42c4fdfde21e328474", + "conflationOrder": { + "startingBlockNumber": 47, + "upperBoundaries": [ + 51, + 58, + 66, + 71, + 81 + ] + }, + "parentStateRootHash": "0xea09456033a79b5f8b369a95cce74d3dbe34fdd6415bff1a417ff8a8fa0cffd3", + "finalStateRootHash": "0xf0f26782f7afb93f926cacb145f55530714f20b1356725e3971dc99e0ef8b591", + "parentDataHash": "0x01f5853fa56ab910be0933f2ee811bbc437500dba4e38acbae17eab00eec9f95", + "expectedShnarf": "0xfd910670a8da6aaaf2431ce7345a605dc15dc41298b9410065d2f7bb1ba99fea", + "prevShnarf": "0x4e584b910dc758442e58e56e0bb46c001addaffe770fb740ea0e1b90c0e2b056" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/blocks-82-114.json b/contracts/scripts/testEIP4844/SixInOne/blocks-82-114.json index 93164f7a9..9a1b6990f 100644 --- a/contracts/scripts/testEIP4844/SixInOne/blocks-82-114.json +++ b/contracts/scripts/testEIP4844/SixInOne/blocks-82-114.json @@ -1 +1,26 @@ -{"eip4844Enabled":true,"dataHash":"0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487","compressedData":"AOGX24kv19P+CjiUUtrgxdBSDiPRitIDJ1RuIYmn4/EANTtAUnWqSXMTDdACA62kNrNMJuWLjU6uevYIXbEN9AA0MGYg5v/GZQ50mgBY0mQl2a8EJ2owiRCylnOaY0+fAA7jn7M2MOLmmHoUzdg0SorzxqBYRojrptwoMmt0srsA9zYXOAcYTsZlAHFWe5Fzc+zSMB6eUAC10uzzhK4c2ADlbHx/VEi01Mr+9vxXubPamfehT6g0perlR7GurXsTAHyadc0mlxDr6Pshy2Dobj8L/AC/yM4JL9lnCBCc/kUApSUXRKubBSumzRfgZPVLrU5ZVYQnfkEX/Cc+YpYoEADXTfc0ZLhiPCFpUMhSNhyFJo+4nLoD1Pi5oKUjJUAEABuh8eHNrh+v6GsT9jlENo8EK6qrTEvHuOdh0j2sh6UAcCh26IkZmQh0N14P1c8VP1ChCXsEH+1QAMlqszcjsgBXyNWSsPBsJPuWMrBVAHam8VLXP5h/j6heGd+lMkT8AILH0v/0Owg9Av0snjJjRpqPgQpQg2eVFXyCndngIEcALmWLv16Blp+DDeo1xGgu2CH6WXW2PdIZ+Z0oAuK/igCYN9Wda7zBhnirKucsLkQrBdNd2YPWBXu664KEBMwFAKTMNyIPkoUyG8573O3GLTW5wnuBQ3mjgKYzbAVzw5MAcelidD/SFW2y5hzAAR1XiDU823bWutoQ+DD2y+MtBwCaw+f9fuyIdjLAT/mdbxrZ3AbEbV0C3JqOl6a2te+qAJwazLVj3mG84roPo6kh+Uvb6Si7JFy9Lph00jU8lE8Af2Uk92zhRmPn5pXHzaQCat/lWQngL8+qxxCEHLjfhgA8yanrSwOjce2UBqzKwILhtp6QpeaEo1vE7FWRqpXoAFMvSY9KdrqyiGQvd6tfvwW67RsTOB/acPcfaeciTuoAf1wRIxHx75Nd8K/MAyfQ/PBgkvuW2sSRKArcrGxbQgA6n+gaQkycIXgMwbbws1PRxz4uiarbCUB4s2aGZtJUALIuHbg93h8Za9oIo4Nsx0F4FLqCUpDfml3l7cLJI4EAVw6XMJReVzyNQ+cpkBYXLE8z9Zx4CqorfHwbczZVuwAs9TpMJ9k8TzlpLApZtmTiYfGqIl1UP/VBlqVOya8ZAPZ5SB6yyQU8NvtgOkBEhCaEpQmSet8QfFZaPOUoeU0Afcyy2GtVRaUg1ivsaSzfe1W9sBrce2GUOAm5ZKQgaQCWZ0aHCGMiApN+umeWeK4BDSP8mVdjhfRlKHO0N9M8AOBC76cBaY4Ock7mDxk6sdbJvC/XPwI8p4dx2qorc5gAkJTowD0605Tq5aYb+MacdI9xBA+vpYgLGMU60PwY+ACc7us4L7YGk6gi1vBRljTJDE2x0jcrMBfOE+hiCXngAPvRqIQml+/31oR3QRw8El5hTE0JZid5F2YMEO+iopQAAfvLhdgUptyXa9b+g5NwObMLdjVdmSdvqJI3HhhKVgDouzR8oB8pz90d2np0bpBPABYANG08J+gmSouSJdljADagf+ymOO4aBvInSwD+Q6qofFsL9BaoYIB3btnz5ocA6rXoPE17+/igHLXsuCRTXGZsajwJIVYN5dQko6eGKgBmQog3eYOLRaEXTFsfRwXcNiTWV0pb2C7z/um2V8ftAGBGzrgmU4okPEWUGq+wVgmF228y20UPnO7OYzhgCyEAa63BhsNX4M6lT3l37HbSgaoq2U1oaizhkIp5pamrpwArPPdlR5NdW1dP0sY47TDKG59HvgX2+gZ5IuFWRvlbADZhc2X64C1OBe0r9APKjdlu471fMWWRlIS0dSHYuggAAvh98PmgsbUkFjtrEHF0UGtWScPfJatsUrMV635rRQD3OGeEeucISaDaLFcey2+I6HL5u+6rfoJ4s+n0M42JAIPxlZstOby5kBnttJPnzAZl1Vqk4155uXiRuv5lEBkAMvNCV3Xmxpytv8qLsxFm3osxo3lZ4F7j5Vw8wAppZwCFJ6h2C2JVR5DJ633JJ0P9WDpYQE0NXVLG0D0r/RENALxJ6WsdVlnhbUAL7wR77IARkoxPFYepwFHtMqUgmLEAGMG2xvuXlUA8CRrWruqYYLO3bXmGRlGleWuYpu+t3gCSc1uLFNol0qPxTDqrEAO+ufC1QzBJ/eLDU3s4qzFxAMzyyM5bwwHnD0KBq86FW8EgUX3+5FF63ypCPb4KiNYAlX+3NxBZoUQx5iElnvhJLgOigDgXLNqVMDbCZFkV6ABUFi8ZdxABYSAQiOiq4nc7IZqKulr5ZQiqbR51JzBLACHH4Sc4kR1bXDUGjMwiFPUwod+qJroYNjhWL/PoDZMAqruAf4914pNz4Flaw+QnYrM6aU4n5Yt8RSbdplhbygA+PPNzQ1VaD0etUO0lAJm7xjWgnQV7dZcj8EsNWNauABRRrngA8uDn6z1y6LyREjCM34KCGrih8nwXLe2rFdYAYvss4uvJvYGDlToiih2lFGM1025E6BlJC7sdPE5Y5ACFnCOj/Xeip/omBh9zYcDqufs4XNS0PERIoY7rHKc9AAwblbPi7p8II+fUTspO8SQr04IhvFrDYKHMtvP+sfcAwf6Vy9Lq2O8cob1zneusLXRhuAMFiftYaYyFSexyoQCxmPoToEK8msmW0+FQdSqoMw/UtO4dkrFyYY+7w0TfAIseeY4kZAu4jzDTmQ4CDovKOipygr/Zah/RsALlB6oAx1AVRhOP+2b7vHzVQX6sKAUkODI6xXTcNFLI+EzymAAVD6qPdRp/r9Ozg2BYLM3P/4WTyn5X6eQMePC3zK8AAHuokg8O1yXCn9SSQgx6pQoPLd99aqOnqyA1uUlwhtQAqY+lkg8BZFvKKr516L6ZBzei55RDdJnyqW7bRsd4TADKwuZN3L9GbSXhlE+h9ATS4MhkF8UNPOeNHM5tce3kAPM/cATR9v4KsIuMAVa+TdN2kwwz0vPW8KKGhaaHmasAx/y4KhftTv+N5O7vTWCaOmLp/4Ggzqr3VgNTy8HNfgB66MBzrHLuFLcLL5J7AguKBzYdAFdWX5gvI3Y6Yy/QAAY7JLcZqp79WDLTPXWWjVpfjDa15mePPx0ff1UsnnkAWH44enzdwNn88iy5a+uIWU1XvC6Wn8G9gAfHMdMcCQDoGNK0cDvuZ2EwQF1eVNjy6/3RnB9JPeU7XnPAv/X7ALPj0mroq+c6xr3Ele/NUoEf4xcnOZWagm6g698exI0AowT2WCu+E6ewdioU4JglQkmF3RwKqsNeH/zB6Ml9eQDkBRUvuxuHWfg1+EKDFX+X36BNt8lisqLC1MYlfwW4AIz7X/9lbRU8Iu6v6mrnf/Zq4eMn+1paAXnega1A5aIAtssbDgnqOvgKAlIC7cp0Agkfx+lX8m5j5MH+yNSD7gALrP+tQrhYVoHuDnJnWPkE4jId75XfJQ03Lbs56AT1AGH3POUffXjrNp074v+/VjRTJPgNKTc7IMuPOpKKmiAAZhpe67GY/YDbeEBZTpS1HrGq1W3tsCyA8LiqPeDNkwB+CxyqpbcrrL++Ywn4m9dFA147ZzrQa8DZ7R67AfcKAEpRmlbKjZFK+a866Q8fOCmAeFSmopVgIuzTibeZr6sA+em4VRmAeQ7XNJGE4EVU+iJD2dJjiF6yu7mb1XCDxgBsP0YGvrVJvqFxWBeU1/RuQ1HiXTfNWb9+csO1XUEcAJmKq+7FHTJNvwG3o1CWam001lNOxoxtz7dllbK1MVIAABcafh24+zSL4j+ffp3u8D5lqxciHZRbIjA54S+G9AAZiX2fsKx5glpkMTD5/f+vt7vuvvx1BMGH1GNGrHgwAF1tddusvJEjIpA+WAFlYtpSxJXh1eRI156789r5LncARf0Fo5fSYLUAzMN8X7QQnoisyK9Me0hTyWpFKEmDsQAovNZZOQ0OlaDnUazsIq0SwdPQWOjrt9596DYeMR4rAOXB5w44KeP93XGaZ2g6lD4AO/ht4VLc3NHz6cCqRDsA8vvYMIxalIL2K908W+O2he0vRgziH4R/pBf11iWzJQCncVDSQxnJ6JSVlJGzPViyLjbf2Xzsb6UoK+P8GlojAIAZEe+Kd20bFbrVwGNZzdD2yYXksWABWQQm4+J7pQwAJTNfPpZDfLqyU5WzNvef1U7ecxhI5bZ2sgq2+NCgzgBLlAwlZSCOJxMNmFidnGjCeVSf5IvbU2XMD9TLjYGQAAN4oVyPq9cvIcqT7cc0yUezkXx9Jjmk+bwrBLuXlxsAHTEWCf3wuvvWk0HcC6TkqmEM7jfYbOUgl1Fb6jM5swBA/7NcIcH74wHNv8pDArRr6fgltjB70+neIpTtPsbEABi474QcgyPvyJisa0n/TICX90u/N5ycj6N8QHu/JO0ASnTtLZMOUzKnH1TVepGk1jCq//6nrooiWACHnV3MCgCxqyvWjGrXgJXjuUHCIlBJ0OMS+pyDGJl3qkxao6HqALxHEQ0IblySqI01Day1Nsu1h12pFOT76NSjcjdgN6gAwwzWlH+DpS6kbljh4LbtHaajUXkdrazXvvR24boCRgDTV5zdrTd4jeRcvVK9GHr7flEqgNfSrvjYsdbJy9YxAH22SmKW8+9a6+oR26L+tU3ps6z7+RaMmnvMlj7FgU4ARNh32Qo1KcOHFsud5nKJYOGa3ZNSbNXtRz56Q+ug5gDzsfDru89UwG1RpPUgxp7hV8TrcwJrBVtRtv4N6HMuABOSLqogXqUPPYXqqZ35c+kKxU9TH8pff5qg5cDNvnIAfCHMHPtPb2V+AOcCiVzOJLGCGsXe4YO2PS4WOFnrSgCWB/oEjMrzdRnJXvfdahGE4UXz1tjZe4RHrt/u/TYOAPVfqH94eAwHPuFaxU9i7q/bgbhKrlLPTJGaGklyopwAIViGMCDl0Pbu693AxWy87+Xz2MZbHshsJwN37vPFRQBx/ARvDhsjpp2Zw0Mwx4hpc1BEtkIQeKVYkRaMv/99AOm34851lujrWjZZbUHkjzl9gre7sCUcksUGNwZsF0QAX4dKyZJTh0VYmrFRZ3WxullN8kQ/nF2p0PL3LHSJRwCiWgXkKE1qNkDP0lfOyXQpmJEWE7XXWHxWXhtFUXvCAIr9dSlq+rmsAuPb9qFA02x4NbMwZEmUbhjCnBKCv0gAjYxwv/cE8ZIjYwGMwMna6/4LKJW13SkeyYuKbVirzgATTHs9+FNHuqBWloqSyCny3pgoPsyqwbpEjEnZknYSAEa5Yqnt/L+8vlx1JJNXEWSheSuAZ5RML0cTERcXKHEAlAnVgSrAqZ7VDQT65bz25609O2xCrwz4NH1VPNSlrwDBkaWJvYFCMdFmBWmALck3Sod/2va89lbu2X7tINu0AE1fe/55xEjDRFuCG8LNp+Gl5+7ktzZWO4y76I7xE1kAyiR1/YhcbD01o6OqitO3zdM+BX1y5QpTSOWTDbETggAfAL12aeYZl7YCG8XHiLdxwwgMidJNnjQSmJFEwO+IALJ5wogNhe/zy8X/XHw1kFzLq3XiCVv7RjVV3lnkOMsAVyYeTr4UIpDlMi2BWCb9RNsGs9LVbkbrmKQN0xupTAC1w84B3EV+6F6CSkGDjfsWMeBTKqYth8+N2x6coU63AMQ/6ibcgrCP/YXVl532ZAC3nB7LrHEf6usZElhn77AA8Tfx/z1jOhMoDz25cEyQhC4bn/SlsGnaLQfwsI1jEgCjU2ouV9ufjzSF6UUuyXKKDO62yFKsH6cPB5tOy806ACPTCYnOqlOECPHWPbwEs/ewnXaSXvH/QqsEPMtxStcAXcOO9GX+dpMP0eOqAgnnCqOeEfzo7QOgDgxm0lOOcQD8XUL0a/ooUxQ5ivqAUPPCiZkSc4pmBmR9RWzi7GmEAMJ66WHk1q8evH0fnakCNh7JZ/Xxk1C7yUGYqH63YY8A7Tr+DpbV6nde0uVYsTcy7fDXMN2Til5RpaXTWfwD8gAZtT9/OF76LeBrSOpjTYt4RLdgJmeLVnECEzMXstyjANlcS1CIqWpvqR6d4dP1I5+I9DIwvkWPaiF5jKN5yy8AJynFYYrvYuc52piXXHnLt3GRn7ILQCwkyIzSG6C1xQDH10BWq6wUGZ2LCERLb9/GPh+EbKpC7fyG8R6fIEI7ANQ1f0LPjSn2HkX5edX4oXt76NB4Vd4s9Y47Hex/bkkAcZOBDeSGXWndaFRu2OEZUc8XWA1dp0azbHRrSXWoPwAR2yR+DbnXcSkEWJFCEP1QjLxThkP+aSRERCabu50JAIgvT3t9l5t4AVkhI2bxpb3gT504tlahBhK+SlXaCscAFFtt+nnct2uaZNqdntfUxbDfFJyLZ62t++6IEyC5VADR4xYVvgHNDkQk+tfs2nti5Vt3okQUt2QJEJ+UuhAQAAZxGFFeAEltnXLomVKl2XpWgnKg5CyH8PCivWOIxJMAiKY2b1e6v4H4o5l1Nm2vhpjdnBu57bF39VW/XQR7dgBKOZOC6nq3wz2wPkL0lw5Nk/4utTrj2GwjJNfhFC8BAOOH/G7mXv+CHK8McvjCYXRPrq0A1uX22owsYNXp3vgA3mWhilpi5aw1APr9Mryefojs9Y6aSGmRFc8uVTza2QAo8oFjClzZ/jLQOg/oBn/tvAsH9waPHMPwS45zka9nANtNzSQQvoRKm00i4OmrNA5mW5biK3PLeoURbbP7uZgAbACOP5ojQRYg7CwCaAgHkqUT3r5imELMSWQz/FAihgBJJZuExvjYkIDuF4F4zG92OlBIqfTGub4+zlHK9/4IABnNVvQ+Iv4XdN5u0VsBTvwgRlE85uQzN1YMgkUPbcUAz3fXbN4k7+Uyct3h/l8Ap82xRHAe3D+OgjEp1JlmOQBy4KBv7h2YyHR7c+CVr2VAt8z29yppV4EChexiCixSAJo/6gNn4/hF+VjiMzb08ihxpqMy2STxhirOcIK1VJsALsYjYKG9EOKAybrXhcoklKcODzh3NpdJfLxqdSsVuwB4pCdpPkgPbViia6GSxz4AtmQf3nHn57SarfvzpotIACDeL4KmiGHqUGn2xbYzFAW6QEtImrG6o1zRZigIzMUAZi9mWPgJWrgBs8VqthL/Nwzd7crx6CdoSp7Yeb1QogA5VL6TF/6O74rdi00IDJL/IH9cA/VJ4dO4Mh7Lb496ALrv+Hx4Krx5A60R+Ur51qK0vYhQFHQtqHqteYoh0PsAMNGPDr6JXiRFhhCud8kD8J76ull62fF6EtuhpAuiOwBKRRLVslcGqyBS32ynDnynw+PiDBfWRj4VleyolR6TAMqLwelUkzAQoYZ39SGp2nLP2L+3dMqhav8sY8kIlrgAJSNHHXd91QeMn6BOFF/8TMoEB70jq9C39GWyTVG3zACXBEdX4v36s8edAbIm5O5zj3B5dty3uZwl1Ltv3lOaADyxFCIpJ50MS9Tp9RDVQouhk2tT+eLofRG9kZNKytcAOuOt8WDAuXPNR6oYfvnRuJf7omnnHQJ6UQZnjAsdRwBO6FlrMpna56CvDIzTV8oD/mg/1er7ny572wfdGmPTAH/5R207rgTtCqAtquEKPkSJr7lVDHhb6Q3OuijvtH4AVEJrVCpFoSZUVxqaQEAISqxwvi6HrcC7rDfXaqTfHABsgBaZVSg7/m+hRFhRsly1QQGijTvN5/Ey+1ASccUOACpswI2+nJS7MgxrvInhe3UUY+O/6kVQmistCOFwDukARG7My7jfZuuLOSdCLT+lckzcWotQ7yfFspP+rhpCUgCX0pOsntjcd/nb9TkkSAGWMcNEKx0CoSWQ9BxJiNSWAC4ZFuCRvHSkN+VwHdh8eET21GqSYByiBcqhdPOOBWIA9BM8ZmjFbQn/W72/rfFJr1x/fhFkuvqXQzsJdblSigCrNk+iUmcvlLWCfHf1DYPIb68j4z8OODVO0BSo3b/TALyiK0q2UsQdIw9/QvGwNPLDkvwPiYAzFRCXxGqEpM4A/v/fkF+D8OczNh5SjzENYRvMY+AGayqyM2cx6mWpDACWjqUh43pW62q/wzucxRmdFNdqnZbhqHwmAcUA+TJJANVGCs0itlxkZzwYqfgAwqrsAUkwRiNKBi8yn2yNIoIAGRm/yg661u02P7JY8WCjOpeK6kiW96iLrjH9CCdqsgAEzta9r4U01vS2X3mcy7enJClXv4oF8aiRb8P/Ja4HAC3QvqMV2GF3h9jG5c3zniheWvn12s13L6r9GtIWHQIAF2CgRZta0x9Aysco0iU18WeRfURXEV2aSCwt7aZyeQB1BufrPA92uRsrKguvJDALYATbUBcnAMWiuyHJvvPGAIuf1I/mA23bRaqhMqbuYD22riwBBpvWPFkaE9+MmvcAiXPb1aL1DLEp3DYSYIZf6HaFowSRVk6mAwlFgUA84gCfhbf9JTVBNcIXl8KYQCnyIaE0tWLQyFsI/3COZSU5AC3zUCxjjkqWN/V2Jxs6ISt9tPanGVzL7V55tyjl+E4AlIUtRHo+Z5biPwpzCMj0TFH0jrVMYg3uPekO3fAJLwDHEhQiw3M33r6XyE4gmuWbBd2FjSNrEiWvFRNv90YuAIvCwmhFxJONxhP5IlxUeF1gGsBHOaHoDFW4oPrzM94A5Ugj6Xohdr9kFkYYc/4Xnn11oiVcTfFycQhTZNcrBgCKlig6Xi0n2VnmVanEjcsx6XWicw39M1OJ+SqQAdZoAFmwhQSLHX6Gctiuct6DS+7TTA/2qKwOQkGISAg9dxMAZq2gqx+P51xyt5mTXC0b/LOIaPT9a9aKRX38RTNUTwDdVIRvyWg7FRah3f8s/8MFAqeigs7cnZG1N5RPTAy0AMCCU6ZOBBK5Qog2iPPAT0+jhrNNy4YGD20g3kxHoBYAn6BbY23DkwNhNH+jjuZClnH3swuZczRflLoZtFr4zADLqk4X71v7Cp3AJyIxwQ7Mbr6QfPnZJ4DC/FZzLwSJAMzgz0rnXJDVGVJBMeRQU6NFgDdP6hJoQJDCare5Je8A37tj5lcabhfUB/2cFa3RT1c4PIYotszteElOBojArQCoSURGmvsXCAE41AHNMF+Sh7ujE/jVBNLnBxvmDEI7AAWOYAc1ycxIs48z89SLurI5lwKlF+G105MCgpZHBSoA6zCabp6ePt8gSLOSVpLIUO/55HZsZB9IQeh9aEeLlgBRFogoYM2Bciq4odz8CXQdzH4sO+1Hf2/ySy8saCoCAPnhnk21LKo9oJlAZ9oFS/DRRqEadZrId8rYkDR6C6QANiayovEWsd08Xje2PuVhqoYfz9rZHxr1DZRuf07yEAD87rUJUVC8jkpr7M2ZHUadgA2Ek9R44d/ywjOFKLzNAJwQQ7MY4tMVtZSNyEJrBLDLALjSIiMe7CFx94kTtQMAv5zjtQNRPTgfeUZyKgUb8ADhOS8Y73jEtaGGCJy1gACw/sLVTuTdpb00XdaAeZ6W4A6TQw2CcY4pBI3kgqnxANs8mGck6yZxVlvux+Lt/C6P+FYYm0euXk+BzRaZvZ4A7dxnxCIm+QnoYfwMGG0uxJMJMR/wtJbvO21mROumPwBXbG1WQ560xgKoijmXNDDjAMVd7LORMtL7Vz594pr3AP6WrQjgAChnUwwcawqjjhSw5BA/6vaxkShMGuAXkuEAsKPcUHpncqAb7gXqVgm7JnupbacRTc90tbCP8C4bSgBggnnlSO3i1wRKMztWw/M8ssLiZGWgx98KoO7I/P+SAJWmjt+KiuAMcLaG802qlOpSorUEzRbQU5IQKM946ZsAoSVoTYpmSWzLsSMAvaPbEzSmyu6Etw5XPjgIEpac7gAMkcA8wrKeY7gx64rujiPLC5+zSxdkaJmqDH5huJUwAK6KAroBeA84mzkME68tRlOSL9jcYUaKtYdKlRjaZLMAzsEYqEzEgZNMuk6gKPfwmF9veVVyY5GziGSI+Ab4pACZ2EVnwPoXdBvbgsrvkQkL9VLBOT7O1O93VSHdg77NALjrwtCfho1V/1RMH5kY+eSmcLbetxbj/hnGqU9F1vYANnOwKmUbuOR7OWEz3TkW7pUKCUyYBnQ7BqTfH8dt9QDhs6snLUSVoj9wf+r5R90F/l/doQAxMIod+RhnhJFXACDCjZtMAGfZ+Ik5H3L4bCVnMtM7DyK1PhEonDtSqZQA6cIndk20/+I7dLbkVtWfqCCsDRcXfT4UwtmlK726gQDP6Mapkz1sLh9IMY1GBZ7f0g8H6KbIWnDxk+VaeULzAJlPGUY0OY6OXmIQFcYnbdol4JJH2LRTdgVKggNC/d4AlBItPxpIcAIqRD/96iDcPi56e7GAF7jlJtiEFbLnrACffU/v5ecIuyMlxvqV85Fl4WSHAhiChRQkCZKCqDBzAKXebnxymAqVtsJWTI+kcM/8xamME0pLI9RP+JZvjmcAa/pEmJvnqNBoidazDRpiorqjFZ8TWDAeEczDHoQq5ADo+nfcDwwlPtTUZVnTFhfShlLW8/csMQdowVGwV1DoAISYC1CoEl3UFt5VfFcM7osbDBlkk8uJDA7V8AcCaWAAPVwz6fZcwwl8P2G/tdgEA7TChIDyfjszfcd5aat20AC2sid6ht8J0cZQkW+oA5vubewDcCA97BqOe8kmJWt/AOK1QrxE8nF1a7yAitmMFqfX9/2jrkHGlk2ogvKITIMAKw2PSs7kHifEZ8tNslmxysPCD15wHjRInDZE+k7HKQD8txNOHR8d1uOwDH1KMEXuGJTyHdt7KHWAYf4avInEAA4HtaBKbfLSg5GH8OAsBwN6cTAyYlND2t4qQxGEPRoAdsoLrhzXMTr+9XkKQsHj3JpFr0OF+8y9RHR4rc5tvgC+TW6wsPDUOvDZWz+8taLM2epUSWEfcFou6NthQWUvAGRCiTx58wXgoAuaLtmi5xrVV2vWc4qRm2YijwSf+q0AmPVu1aryP4jpRH681rU6UDiMlFFT+TcQ9ksH+7Zr9QC2bNCcOg6vGIni8p08CwsV96ULumEN4dxlEr0IGAgYACZHjiCjoVhG60AvmTbCqlTQpQJk5m9eSah6o/U84FoAA0/OiuO2GvnVNJ06R8UklCSbmNmYIFggFt5GOHHAOgDU/fHDRHBvvKpZzCjohAq6aFtUi1TfAw7f4WgCOv1zAKqvJXcZQOYXjINPRSq7WvPsspKFeJ4obpXVYj2qg0QAChLecluU0w3SbdHRL/rNbE+IubWE6iRWCoBgfHvl7QB2O9vxDiRY5rp9esDPCcLP5MM0D6mEtqVDO8hZH1rLAMAN9SjFznvPY0DW/Na0b8hX1uNbE7XKHUZl6gm2w98AR5YZMsW48hiIH5EcN4P8ZGfoX0WsttiOJXanumh4eAC0BQ9quDRSkivRnW3RQ0IfEsJWPL1BU9Mt9vm4MmmUABdrDd0GfhgVEcA7gk9Zu4zH7VPi7uFP2i1/NndMYq4AuIeUZCT/miTvZKgPBpNQlP3EuJbDPqKiPKzafVBhCQBUN/MUbBHVVckzGwvWD27GnGV/ldbcsj0nzKgpUfzPAKVVam5L1PM4Q8Do/IXyppYm6PwlCNx3Y5ImYUF8Uu0AJrkaNUp6Uo1WBe4dp2A+NBOQnjA/Zdo3ZTGAmAqu3QCvMtSyiRDKuaiU6yizmFxFWcCL4Js3d/cUerx0SASnAL0TXx11HgDFD0dcdwcdX+pzhKl6HNyKj8pzy+nuxogAt1yx83OcRhKZbWuflN2N0FKf4dMuD/yAEbBRJS4MYgCf27aUodCWlzaezIz6iq8ecPe4OkaifL85ZiX2glXqALLd8uJJll+xDeA5+QZyurfVFyaZqsTzcYyG2HBZgGsAVFb7N183oyibSsOqmG/TOon9umvekGhFzied0l2gFADUyTbuix5/ml5TqyyFPoc5dqD5kwVDZtxIVI49YOHOAAa2zJr8RsDIUESPdqlh6oqVO845UL8ByR1s5VLMus8A8UfLSyiB4aaeGn+1Jy8bV6iYxuYKW3t3D9YwvN5XggCf9zpbFz1utNRDIyIe/fXWsYjTC70RLDCtaUs7AOVyAGoy7NzF6QkLWzxzEurycgbm1iY4Ulkj/YZuNTt3VwoAz5l/AAeBaW2Eh6FiVXocw11X56gJyH3rzvX8eQ0MgQApg9wwqmZQsEv1yVCt67+tzjPTofj72XR++EFzgxLhANBZG0nlgqy+MaQ9GavsdAG5PQTuc/YTsiTA13bWWP8AcSGZY3uz6dwdvVW/TaVaq4scHY/wM/xYM1hL6nc8OgD2aDtQwCb5UEFrUVovYih0MQSXK1XPpm8rttEM7upoALS5w4i5fPHRj3IQ1A3X4q7TGBsHXSxiCddDm1eKWSoA/L5N34PFv2i0MEkbmjrKCbONIwNQ6lalYi09UPI4hwBHC3cbkYvTEjFZX/UiyjHt2MfF65GBUTT1S9+c/NUwAMqMAceuvh8CphItqu9+fEEI1OYrL6ti1h8ydaO4wLUA0sJ+l8hLmq1rmpvDn3eYvJveBIg9tO9etRXel2f2mADBtDzNcwhr9fmO64I+88u246MOrZJnrPEyNbFA9ntzAB3Bmgz4jpQMsW2rrQ4OaHFHrNQxOQEdiV5Kak8fH8gAflqMv21M4oczevI7OU1f9yoK7jfwqkh96dntUKQ2YABSALSzH2PQIvSErw9pp8C0QpQj7waD99sqBkB0aaUhAPeRwd2Z/+ylMomgLgAmJvncNulNnDs8MnJIVHw2pmsAXgdNTZtW3DSxx1dixdjFfHwC/SPjieGUfC3Z+ZVkNwAAM0AMcFTy0UcTxZSSTFkZ/C/5Ubyw+zvaUpryzKWMAFGa8lF1dea337PGNLhIwOYdOzZgyE4JDyfnLhPF6CwAvUKq/BknOAUdMG8IaMxZVID/wityzvKa83/AdfbGRABJC4GmoQkv5FQm/dLb/+0VhKRdStV+LuFHucGEbb3sAG13nm4RGN54bW1v9lZi+RqODSxcN/3C/sIPJF3R/WMAmXc6hQ+ES5UW5XfTD6TosjbDS+fz7LqgA53/VimcuwDc8fhzZSsxg5+g+P7pVLI4eEYWCp45zlCSo1TvaT/RAJIdGlm+FHAKgKjUDEFmxMdxFty92D6U1/dvmgt/7DAATKyTn84V2PZNJhRe0jQWZUWLJj0KGwSOz2FdNNFpkQDEXrdSGxnoP6Wba8Km0ziQ9RosjPeKpykFkKSeXaQOAKMhOuYY6v6h+/sM7haxke3W/c2QKZ2C/nAORBZRWtUAVNbt3wOT1QEHmQ0qdEDA9x9RyAnwGDF7y2eQiHNHGwDXYNRkyoUuId6ejpmqryJBHatSk/No0SsOISFgBkj7AI/3kSWFWLXWJnEzBOF+p8YbdgzVT4u/hCI2Gt1k8NYAsawWrX1svha7w6ZourcDlQ6k2tZOLxunyrIefbyNGgDF5njj988Lf1yhJbyqwElVrY71PxRKzrZ4IA8NoKO4AIOTCs/bC2PW7ZyZt7WunQdIH/i7Qza+L9qc7sDS0UQA6LWhR9MSzbDQiia+i5gsmFHRnCtfg3EYRMWwdnQX3gDr8fn5yrgGQVVoOeAeRZdgqgBEIX3RzLC5OVfyQ6utANXkG7M5oGFTbnITClOdV+Cv8cVRiDjr1pSKLQ4B0UsAUsBJxgcWRVmNW2yVMOGgSfNWzzUrv8+iUPDDJAHPPwBBAF8G15nrdbxvV7i/CnkJlJxpa+fZibdIvAW/YcmSAG65BO729rgGT6dc4zu/Tz1SiT5vhD2FUzizuWVh9cMA0jgOSKPGbREzprfNGmt5VIaPrhpSe574AfQKzu5moABqsf+BYrMwh/7LmZPNTJzsxnaLHGPyWnMq+fabiytVABbLszUuDJQPfgiEanRVIzcOe3l5wwXRTjVHAoRcCPEAlhj1/WjKVwYRvp+lrLJcnaVRuINKj222zSbKWHrt7ADw3TeZbBRFR7O9zTqGquSKkELlX1Y7VZB4guPtaVUkAHlXrXlkarH3+LPmyTFnAS5E2TJtK22of0wgA/mOgSgAQO25p8X2gl4Bb0XwP6g9EukzmGNAlq1LUnyIR+d3SwDkROcMIc5M/E32GnnhQ5R1cqwyln0Qf4dlCfQC0hluAPWqFB21P9dP2h7HPJHaM1uCaUDt4FKpX/RHKJumtRsAmyUTHYhZbjS7G+Q1DfSTMB/eEcLWwuT+tWg4t1RE+AArzmi9C2UNTg3d1Crtw1kiaPpdV+GXt+xXJjCJQMM4ACUbDtBrf4RZIK5Xommu+tyYev8BNoDS5Uw9tjYFjNYA+zGzjQDpJMv8Qe7uVjUi+rym3c4GVsF9FJzcxLkRuQBdMKNAoyIdiJU2sOjH2Awq2Zb+1bnB37jJfXly0L3eALmT31wbf0WhSQ8PTDgBb8DZYWmEEG08vWNU6OQ7LkYA0DWDR+KxvtTrjrjthhHx3GneWqaoUR/oRZ2bLMmeKQCwHeQe0uNmkZytG243ZEgf39O6XCcC4VWfqu+AtokxAFmlF4dhF4lZQdDg8kHPpbv9mopgCRzHpTeMznsnMKsA08E9XrcOGPjnaW2+qEb+FeWd3LykyRW1edr7cqDbdwBHhFadoIO99B5FA3EcxaPhyN/1GZnNGzeKt4YUAflmAEcQ0xEVpMf0opX24tUc163u9zfOyjk1WL5L4dbLUMoAXbu0lqsAFLH6LClAF2j+NjaNO3jDOugYkbvsDU2oygAMnliqiNVan4Mq2jSCAipL5rq80Rhpy33Sw5IpyEa6AKw+UX/uQTIY0IupFwoMiCmSvn7xPgxdrJWe8du6HqYABQlPgZgvNkbPVibz2BM66Svf7PnSge8gFyeBWpWX7wBKcqLi9H4G+lSGJTpGE9RK/hL1a1Ow1ErqFJ9BpVGeAOU6jK+z3rhHNueFiWdPUVazjaO5hZJ6/oVHwCITdZUAbum02qGkD/599UnxBMw/KqUHKYNtAQTsvK1BQy7EKQA2nFNagHDSOnJMC2BcK1QPQe0wa1V/ZtuG/bVkyHBSAKB3FdxMFl9OcWc5sz43TgESaGbsRd0GoIAbqAv+so8AsFBYLEDbJ6CO0Ij1hhKC0wH/CF+ArL/EGPxpV75uRgDHCvyEZfa7/pMPjsyWxOCr+WbifIMPTZ4xSwu6ZOPwABNp4Wvk6OrlQrRAzEQqC9DYk1OsA0seb81n/AW0BnIA60iXJxVB5Sc5fTBHwuPElzg90nFN+Q3xEqGPhyfzSACOl3FltNghcVi3+Dei55DA9Xvhz+kMrTZLGUoHVi9EAE+j1opfvS0NGuoS+Sfww6QaUNN0I044VmZL5EhfvDUALqtu4UPQHwoXrQj0yMuKLr8BRrBETgviF/GvTKRsOQCz4IKXNrAit1Z0+ilYDYmpx0+jXJa7CJy4UtTuWi+lAIvLfuuDFqkReOgiq7Nur+7GObOzsCnmUA9Ao6cGw48APN++7r+n/hTqFM4n07+xw9JShh6WvWvkvSLMCVe5SgCSyIT//6q5X7iR8J9ss5hWEAC9dc+CWVwUq//RVKArANEnKELt56mx2Df76kjaYiqpzmlPXxwtyqboDxI+TA0AHRMNHLeX4HwW3hbLyRznjVKHoL60lQ6QVcY1ftN9RwAzRbk49dovaN91eRePQLMjV91T8jfXCTegszEEezAFABzw58MwtFl7IdEPmnjSpcxfEWGgybTXGfJLi5Hmd30AexOzHlSvfT5wza3A+buksmB3+nq41la7T+7Fy0NNWwCA5/sHBxbKCwnBlgDXPzB5y6pCPcTVs5gVHJrEESzlAJ5MXpabijW0A8zwBj6DL6GYYQ9pwVlarLgOoZEuIgIAcgW0rV8y8Ix2LzzDVECdgKahsA+DbS1sEb4n8vt71QCByg1hk3kWvVNzPwCA6KhMNeM5rHO4eRENYA5MAkkUAJ9STBIM7su5Vd/kVnNmTH2mC3FKS0/VpFew/Jay8k8AUgXLyszJvHt+ALbhdvNbHikjxz6RXFSkYA32JA8mxwCjTwDqvTR1ic0juo/7Ts4wBjblJLhqZTC2qUwq+0i+AFe93HupM/vZhNkgyzjWsV+wEspkVO2OW0JHJkKPP0gAH92A4uS7PMKgmfEID4Vij+iExmyuTYVTlmXzD1GiKAA4oWn1+KR6DKL+xJJw4AjpV2i+B8oxRLkJBK6xfHBfALDn3rj2KvfGw0ykXizjA8aRlc9SgaPqOtfNXhNm7WsAL4Nzhl34VeHi6kFEI2Nt2vzR+fHWQQSiQJxiCoLi0gB50/cgyi7imJ8dLWxafDaE74KG2zI+WT/zuqAecT/mAHgjNM0u+EDtd6xbiK2lkCTOR+EqG+mZUcPw/eWCsgMAGyOJm/VS4Zw2hRJQH006yIpYdnFZKd7t0CqP8f3+awDzXfuYmk5GeEFP33JQy5FeQZPSzyWkX0BHsOxBWrEuAN5nG4HSbWdTaZINtiOsyl28guVaI61yWwoEBR5roXMAkSM3NKI9yqxUMvV6wc8JEQGpgr3+cDwL2K1jeMJhHgD3yzAAtSZMcx+ApQV/2otFQChi4gLy9Ddka8fSGmLoAO7Wo4ymvePmpQxXgLYJn7x6MeFq42nBb3ke6k4z/FEAT+b72dYWtNBObburbCDW4xfvaXZ76tCSLoACj6P37gB+BL1fAGsrrfxqIhJi0oCdGepO2RQl8OoWy4mF3BFdADdQH4R4b2aNfjeT7AwLbdUkjq1jvjOps585ZBZ6EdYAYs92PI3K8sky4mfZJstuE7LgMfg5Ne+F+WsM2u/wBADWql+K/aDnjI6C8nlxUA2wRkZnh/upB2BG4s1dQ8nJAGoC/DXX4mGiNGhdigsnxFBLlRhujhAqbxJePSZgPgsAWXpypXpMtReayoCZ2zkcPQpxmhxPYzCig61SgZV4HABEglaZqjwkpwNOXnN3Y6Pu04PyMDlaGqcPVpj2cFTFAPXJybLBPsqbMU1IRXzlQRr5KyAEiGVzmyZEVdfag6IAXhwuXQ7HkdmmsnyMrDKdELvhkbOo3wmQQCu06xUsSgDGo43IgH+i2zciRYdHjQx3ORX3XUSaA9L1y4xwgUGOAGIMxN88d/8/upwiX1iE54pf/HEh6d0ZaKRUycTrHnYAfn5+5MhNb6AqpKr4qwSWybQp8tZSw8r1OA8lNefh8wBp8tXE1Kl0GXTz3VFk33UsWsLA23a3t1AjJ0kIuTMGAOu/FvEnrbxcvtQzSs8LNXGJCKN0eRsRLf5Z7BVvX4UAZWwAAGWEKd0jYWDAYPD0CB5/NK7pRgz5IX9jowqlGQC3MDpwINGrJO/PYbeZCuOs+/daSN/E94kqAbHC9LsoAEVRrPU0O8LuA9ixyuz44wyWBlZ3k+7trLYMlfdMq2QAGzY6NYpBBovJYH57/Av9obZLzWCB3kbT/Vk/pnJ6lgCYvqexsmgoi+NHCzWEA1nmlbDx9nbMHUfIK4tqcloYAH68JzPcS+FirBOwPs3AoAIH+Yg4axi0WJ1nuJSHWZQAplfRPsVGnF+//pqTmq6wsB/OyQY0g2KiAqiwe6gxcgB1pqof1ux+FCi5aBDrRGzvQoSMZUOwArQf6qWDBOtsAAGYBupj0z+ZodyMP3AM4+b38F+M8O8gf91e4gx2JOcAmdg5FokrNeyJnppO5g+EGcWHw6PBEvCWxe3MMELjfwC2LOcVeQjbFL6KFUn2V/mswhqQlZ/P5pXegGMfRAIjAGgVEGhMKc3NagU111bbgPmXqW//QXI/XmwBWgEdqxEAiIuDNfauiqtDuEd0MWBKNp4V9lwuwESZyED/M9ko8gAkfb9DSuY6Ej8/J9G1tv7IBBn9UqhR89BlAA477tdzAJpe7vFAcZDa/aGo9u8wUkC/YkGhL7nrD7Y+O18ZBYwAazqYBuU1GzQD/+1IPH/YK6PUDHvjDxOz+/O4zxOeagBRF+etzNZOIvouebNK+c+0qwdHphkd/cW1dVS/Zmk4ADlkFgXI3lDvreS3R1U7ILavzl3Yz33opShyqIMwuJEA5V2a45O/mrQBWjexxMgQICyjTfIQ1Pe8GIG+TYk9JQD6pNC1zjKR2glwAvOFqUZrUGH/kfAdRVggcE1kAzs9AEosRKjPhfTau0IXJQi+S/gcBV4d6An8TYfXqLhejzsA4Lzd9sbWDM/IqJKbwT07uJxVsEghAOLoj4v7c3L4swAj5bEqBFKb75nv0DxfR+uPEucZWchsjrX6qHdtgc2DAMYIKWRV5L8rx0RE2GFqgZ49vsaXuHNV76rQ3+67dc0A2l4upWizwMjoQSeMCJC8bHckFa6cenxIXHlik9U3WABIynrJe2nGKqJtR7INpEJemYOe/3yJx/6csJZPPVUXAO7ki+2SmEhZFlL95EhhL7Dqy5dulmsTlAyrPyEQiowA1W5M9W6dpsyajUZsu8mnTfCZOlD3C4TtZ2xo4MaxEwCo8MfXSm4l+1+1rnDcXJvu9Ip520Kq99bLTEVM+jsNALEsajj73sn/JG16RKCRVVPs1ulM5Rzv3vIcZL8bMvEAuJWVPSgUZ+kJ5XnHvBzzaRwdDD45jLTQNb4saDGOsAAp179qVjb9X4plJHqW1/6oRECpu760vZw/JYcq2pzjAL118TWpjV+dKE4Jsjdk2XAobvtQxLWYDJruWYMpTtoAEl92fnu58eGfVHnaqbxQWWS1H3X/+fucOQNtMyqKkACT23fosxiNQBv1yhUZN6bEpLFOfMaIL2yRu6runlzyAM9D/iTi7RpEzkeZl62IdKUd8ba63NUpAJUFpHdRFPUA9cHs92+uQMGZawiz/tzg1HNaehzuUWyq7EPMXc6wrgAUepJu2gi5BefLZll7Y1r3SHCAznO3wQmk+CvmSlsGAOwAJBlnN/gG2NZFR3WR3GoaA3UnUWFJKmksvS85+oYAJg5MLDtReRtGTW8nugeKUykAAEIVvHfIJlBviC1KCwBR5gtd9QWfAYvyIO6tT1l4K7ep6jmi4vnr8uGm0jHZALPrVLJFdQzfwwIGdkBlxNsvEz+MAXpLjOLGKzNjTwUACRzr9NPqj6hvnTMLRoyWlzGGrtw+g9XNXuKsy9PJ3wCWYMklQ0X9Q71wht3IQ2d/EpKFON+kWwkuaXIfodu2AIuzIdzFSX3Eho752KnVuUfVYm9CCfKpB2R/beHlj9wAQ6lIBteLkrX2sZVzphTJ7K/cK5K4wV/DYqUVorL+vwAa85yIkAw2RYKgqrFQT22I481KjYjRoBVHC3ZyaDFGAHjoVEXrixq87ldjAlUmhWzqHVDRAxq/D+lLIal9LGoANdZLOtXBsAnB4en/hne+5EKhZB3+BfkhRbJKRmfvogDbf9Td5T2R549a3srfMh8WhB5OB+7KXqmdPTY26Tg7AN4Z+mLfg1vEnqwK+HsRSZwVhuJl/Wys7FzhXn86rA4A0c9AOB1Y/Fmu7KWN0rTfCAGLNE/efV0IsSjSuITHbQBfkRkvML5ZTdh4wOd0bCKuTprqeyK0CJZbM2TBwCxPANRGERZ5D2eVGOd6E4LWjYG3f9DRHy2Ts7REKML8v+UAwvqUMJ0RZt4YoC4iWc2VEXrpMhiwppe3jCThdX0LpgAoVkXnMrkplrKcr/wdTWFjglqXS5kIgU8Ltb1zEGxUAOPVHCa/bTVEhwFkzj1wo/nkQUfPDOBVogX4O3bH0woAm6Osks7HMLZXNrCFMPZi4Y5xVeragjuSThaxjlE6EABR3sCpz7XUl9SpDw8b+ObQcpuEQXvt7jaW+zUPut0qANGBQOqEFrUdfhUhq7GOPX3hUR5jYlcI1PD1qnmh3hwAsDrfJy2G41HathcqNO1Ly95X6zJAv4vT0dWVM+4zfgAEHdN9QPCgjyh6JvGGzkwPAGYrLXN93j1g18Od+M1TACa/p8Ej0c/vKL5x8UXORG757B19NKWSVH1fUJgRcgoAup4pVK5mULEoZduA4HxT0D6M4yixmydu66LjZfYodAATCHdy8q8buKqunVSaJJ2JqZ8GTh/S3jdphWN/jISFAJtFdX2paNsTI2LPae5tGnwgghIBzGSZhYyK0qSjt94AoOSiqfrosY6Oo2idB3MPP2UUz5AWrkO7v3pVWTRhxgCNVJ+jMvMAM2H2Q55WqwU/0usgoBc1jyvetgdI8RF9AG4p7Yt6GktAED9fq0xIgb60gbdlpZ3YymOTu6CylgMA+NsexwLG6GpDwT5Mc/myjJMEvRBep6Vh3brXtmaSIwCC/bJjFqLzwDB1M3yMi1/0Nd35P3XDjN99V+yixm1QAPpTHFpMnL47izjfN4vYK4g45LijvxI87+HKRcnAn08ArekJKEMgU3XC5FRmjg/T/Zi9f7r/vRHvkRz//nzlEgDwIf7e9hUxA1Az4OPJtgtOGZ/22uXAEmUY+o+ZGxmwAEAsIcpl1ELprSdc7IoEeIG8DSOsLlQKJoRERTa0CXYAF77U5ZbiNyv+njliAVK/WKBNbgV6JV/3AO22G1jnUQB1SApx7KjH5fByhQYXz0ellmvm58PNCCnkYHdqwUVuAN4MzXp1ZsmDGVvrxOk7Vv28kpjP+TYtg29/HiBvTpIAoW2YSlJ3b335AIC0jX1Pk39ElUlgOO2PAz+egw0zfwBuf+jPmks3kIukmRmhslkkXAoSRX5rb3QOe0Qj4HRLAH2JcRMeqCNxFJ8KGHVRze2yL7UU9AOnMh99btyyWeUA9gMD+/B57+pWwrCH7CfFlit8jxoEsSyzJGJ7XH7bygCPXw3nPHKilLobWNHLDmK6bY9p6yRC+ww+8G5RaSUiAEPY5+82GGIeasD+mvDY/vduETrHLzLoyu1BDkkfpbEAJ2pASVwBl4L07UHwJoCTeugv+9E9DPK6JGYSE5HbawCVgC8+6wRCXhvXPE/6FPiqoanwzNw+xzfSGoQE/vwxAMNVnEGZ0Zd7i43qdzv9oLnhijpakeKRGVacmEUoBYoAmmBWzsLPPbQ+VaDKgKc7oMLOK6v6cuzdyfWCuU9pywC/xR3lUGS6frk43YhaPCTXLl09qoixtOrmHRl+dQCwACTRuJq7rWB1gLGbiHmFmvu4HBLwIEyUXVYhCaf/6v8A9vGv38em18sL03fsP2T6Gw88qNQ1t8i41PxJFCW9BwB6Do5k/9Fo9gN7DkXTU1qrCUVNpqY6bQcUhP4tjV9HAK3BQygERSTBxAtRgSpoj/NKbi4oIC8fPmtHpaP73skABlESpaeZM8ffyENpSVu5Zs0THDqczjmhAZX7wDRE2ABx4fMvAnDhiz+hA2ZH5AGgSwC01NrFchdlMWqbJhAfAK94DSegA+bQFA6YMMhh1548RCuDGHCD+lkJ6FdxcXUA5imEDXdZpxkn2i1P8jVfxF2+qVlCle+RVA6CjScNtQAK1yYpJFSy7SLhRW4yeeD6s3vUECZKrUdepABiP/8cAOJOCAySs6pKfEDSk54NAB3E0kvTvphhC5/qeJnnFKUAAXPzqg7I1lihmKMkJTkigfwnl87bOTlTVH5iqbP+MwB/lh3qEq64yDdQjOqxZWcYX/Nk+iPVEonJ1nxT1p9YAL9Z6X9lRMTYX3RvOia/RFzYOJNxmwdTHa+KRyD9m5YAVonqKuMJ/n0DVeivzSAcNIcEfNBgkdDmqRsrDg/KDQDsBN5+Jd5ybrCuW6bj7GWCDdIslwDG11J/xSvGMzv5ABfH/GNltZWjk3V47hZhcsmvI4syudf6AaCgw7MHPOkAixpMx98Bw2E826SCJrSw8QBY6dhATwlizrxlEe8aAABiS0tCWHwNRl0zEk89T2PMXgzYW0GXJ6HmjeZUgRNhAGQFARq59UzzBqg5wiGJQS0FK60r3uYDlWn8IbR6pjQAqK1MK9Xqx0Zn9rLNWHrFL+0hE8YCCcFHagNhWcTu3wA7wbUhd0J58fhK2ee8Neqh33bSS0O9ArGZczbXoyXzAEWqFah9oxhMCtLng0jfKrYgUTrbyn+Stye5W1ElK1IA2R06Lj2NrZGvApe/qHjxSnqVqYKs8CNjNjVSuVlPoAAV92yHvEH7iGJ01JglYr85IDXsTx5NYT9kBHR0qAHjAF+8YmFJ3UxJ3hFl8vy4VxSFb3LoAUDs8JVzl7iSOEwA85e0ZoO5vURG75qVAbtk/n/reYIpES+cWdYKau3L0wBJBC8TxyIzjGuY9BvGf8BHwJUgdOQWYQK7E/LvbepqAHSDTuN1ItRvh4f3bsJYlPovoOGOpiQ+hHGbaXJT13MAHVaSh3YZ6y0u0Bu87R78D4YqrTuJQ/Oj5A+Qy4+rrgB6XnzWo1PwSH+cMOVjaSFnjmSPvGzOAsAPv+5BdrWIAMIdFdSgn09i7zdNsTAd+eDfwUQrZPkMDcQWeEwKXMAARJZhx9lX1kstEMHtIkoHe4k1bVJK+G7aMDVMtywuWgBEWNPup3PabnndDaV1GHNPXb0JBahDACvnfWyDW8yQAEsAdDhHtr4GnWTDmyyO/oS/lnrfz00XhC6TVqqcJ5QABxDpPQdf9wLdLr7JCbZ+FRL2wzNP1EYe69DsZFSWBADGNx8avnjDxdwQv7nuLZuZJ+Ys3wUbQrituf//AYZQAAnTt0zhkd/DcOaEvpXS36Yx4vo7rU9ZZYaYc8Obc80AP5rqT7iLJKcuyLw2sssgMxV8nYk4oWovvP2/YFAP+gDP6lDTN7Fxb/zbganoNwvoRkhzpf2SNLi4sy4I48u/ABqWzZHPyEvB+PB6nPscZWZlsWw/B4VThm+B08alJOIAAfnolVgLEXuPHA3PyI4/9yJ8CjBXD/X4/TDilIa8DgAVXiA3hAv5y6auaWea36JITSWy66I3Cu4NhkwiYJPlAFFTK2gqkGeuEBNlgO6yppkbaPAJqAg/s2D151kReyIAQRM7wlmiCM4uCcOiMooKo0n9WGn6gbJ1EGRL9hWWhwAQBEQqd2w+DqgUWhpv/Ksk87EYf7y6/VkC2fqfRGO6AExLvOy7EYyfuh6kiZzp6nvObzdlzGrxP1gaNkPYbGYAjTw6sxysUYRZBAzQnPLl7ZltKO3entvZFyanJt5RJwD9TmeVSkSxkw2dM5AuigcrNHXDAOzgLnWoZTkdGHzsAObODPVw2gAVeS6A6y2kT43G5kv6uAQVujoXB3qqS8kAYyzIPbwcVCBHnELpcFiot5c768XHBnMCW48nbIr81gAEWRg8RvTSDLsxE0hyo/dwHUfLkO/zv++e5rnIx/ldALMy0d1huDIfH/eYgGnq4iExjsZY3ekSYvQEk/djU70AW1JkeWc1ow5jhwtkPR2jReFYu2DoQOZ2rqa/dogrwAAH4W9mXUjK8aguc+jlvB8uhzQ/NlZkZcNNnhweLtsmANW8JQYh9U9ovvzhv8eHmtTX7MmCxPXVShuoXmxp46sAuqz1W1fqVWgpk3utCzQsZMR+FOvciDKnw7fJbjk4DQCCgAdBiSkL7N+O4dKb9fcWtExF/TALYbUWwb5YFeJhAJ8pt2LOVm/gUz9zjjU5a0lt/kU2QHigDsvwLLDBfiUAL55rKZ4r0RQP6g08FByXtQQ5+IrI5IRLiYkf6WqfswBs4IdIhWBWB4ngfpUsmPr50BRyLdDD5Y4RCrGiWy1MANOVt/I45fSI0L33Z/KtelPnvhxUqmYbL2PpQ96rn6oAwiXR96tPVy/yV6OSj5g2vaJyhs1AOEEM6nPCmbX8tQAvEJ8KBR90GWV5SfQsftsLQRevS63QH9M5Ps3U+vLzAOZa8SxbFZ2R2X6JH8EPXLCfxRNJQ82EQ/xc0etBA00Ao/+rYIDBJBkMOT/66yGr/eKCmN38NoutF9Ts32aoYgBwzA7af8PdhrhQKosOlBdHGfomIoSR9mLyMAxSLuoiAP0xIJmeNuYn1D1qMslLZ+i+4gDo3vbAarZKFaC9/P0ABfSTNg7BLt9c5xcJLagFqf0sXgf8cNnX2wCIUvkaoQCpLrBZBemKcOhLNTv4ScLa7FzboZLy2To6UNYMfSa0AGp0Aea/DcEGMeVWXZjelGbpFUp+ZOLQGEfij5q1afEA8bl2Ih5r4ivYgZlzqM++ZxJuVPMfRAUM+PJYX6MnZgAcJ3j40SLhBkFVlF4lCZVNxOS/Pn8fjNOJkXAsHA9HAG/P79QvIblzJ4f8FOOVx6ZgE21C6JB3Y9GbV01C+VsAVA0dSGW8xdxXaKdK3bUDmfodK3OJKazdaZYTuxubggCYZItdtCKfADtJtAwEEd8zlmGEYKMqicjMJTslIOvZANUCVDvbCKGuzM9yYpO5tl09A9iOZsOOb84JPdE3bO8AeM3QL2boVdnIEUc8oM0XZ8n//0ieKQ09yl2hzvqI/wAVsqO2KQ2Jr2U8EGEMJ5viKh9Y7kaL8/TylPUw3gAMAOhUt+yeWmSr71HdLGPJHZlos28llNMUm6Icb9MPqjQAOoEU8hFzuGHHMLe5w50dlAP2XmhmMfowFKvjYzrpnwAMc1PF6Oh+wEtGpr3Z8AIGHiMbb4PBMfQhKiIQEvNUANfOT684phl7SINLS04Gb+jC/0lREZ1J4H0mL2GmFMkACW+W7r9m3FYAxIUhGHXEf1+75RZ/2bOcLJKVCG422gCPGuaUiXlBqogVUB6PdvvbzJrEF4oQqWrTs0dVOkJPABPw5BynBWTe552fqyomk3htgqt03x6yzC5oUthrA7oAzl6YBzGlY0THqZVonTAWpWLtMBn+NsxODjgvshcHdwBAZLj5igbUVi1R+pLzn4WQ4FDSGrY+nVNh5UM/SBe0AMu030g2XD6XH/QgLFwdKc2kl9vF9hQX1AceOpj1sHcAlKFK5/el5T9xgp74hfyVjRf0Sv2MlBdXEMB/7FnH1ABSJ5f53Md7V1E/mZdgu4FvglHmi1c7qILnL8c9KOBuAHzPUdvOSTBMSij5roaV3mQsv1eAzihyihvary6cwdcAzK9FhUxcoQ6iV2+ayXL070Q1A07X10eu6wjF862vMADnzoZfGPrGG6JMpgxh/jDgn7E1phL4/+3TT7gblKREAExT9QpZ3rferP79HVUFT4089OfSXX3DQjDHVwHC1oUA81x2FK75JluS2bkxOUSLl71JRrIVPwzVivDp/rDgHQBqbaaUu21OB+4tajpqIDYKwrAo1D7VDndEF976wA+CADNdN1a5VBNUkEnWl8t7GY8uz/b/NI6Fjvy+lsmhnbYAXdUdLd+iCaL9VAkJc4pcT7F0pXjR9rK1JRPOzOEOgQC6mkkWWmS13FntjjCr5F5Qa7osxEE9vsAk9ucUsH56AIctOasZg7PGFO+ZntDsjvDQ3ntjl/KuVfjMa3Qx0OgAYJTQLF19Z8Z17nGe3gHZU9LnjMIy1nMfOrzaMJ7HkgBkwZ1KZdI+sAZBXfgh5XBJGJs4ESI3OmJKfUbrOTdkAKo5Kv7BwZECOGOlLEq6oE4sflVHitxbbB4MRJqMjOQAJkG4UzW8MYd6OrsY5RTNGDg868APKVgt//RkVpRrlABlNNGGJuARPn331qftPRiOrMx12paojcqowAmPjsyPAK7MA8LacUobfzfL95dkvTZYlhqcCl+O4UxgcsRtdVUA9DSODuQru97bIdr8Gw9/qnokhi7pOGkInSE0c5hf+gBOXPUJC+inh0UBjc8J4BDQ0yTA++HialrXH/3nTPPEAOYqmsv46bFjcPWZv1I0jBlPcP8Ny1Vf6fVjgjGa/YgAsGVLQMKWJbK3C0jaBz9n9BS09lyhet7iXbgg6Z3M9QDAoevaQP/jLIYwpb6E1p3ioXlCHVOS9HkZXjIBXGUSACr6dq2IOc02zZhE/okql4Mwca5rm66o2FrSolTAHSkAxxujnMjvjWIXcOGfposUh3EiCkTMcoYL82dCfA/NtwCZtqkkCZMnOsHSOhN1w2rz//nYBZGN1/iSqAPTWGYKAL0SNPsDJ2A34f5fvjVLDqiH3MNVhnIvCtXvr3NEogQAzgbm6mu3PPAGTc+VK/K5/6arOX4BzkXSi7Qqk1FODAAEo7fwW4Ymh0neurDFYHMnsFB1FOHeqrJ8p4TMNWX2AELDwRUcNQB5TF/VNlOGz91VRapRGEHo3/arVb/1NukA07tjcAgiuny6tJjrkLOfk6+jLbDVZ97iFZ8GWkXt6QALfTRl+vtLkG0Sej7JX7RwAbGPEkmktiXFLDtDVuExAKPo2ne0kSIvZLO/kE7e/GsSKD8jCWyiMNqvBHjKzJUA27ztel0g+fhvQmDZBztDF/YxGdQcJe3BykB4nWnGkAD2QvWsMmiJkKoukEIZgAsnztATmHYBiWV0X6tD5TfdAA8UxFop/WL56W9TVRIDr2vR32aGJi1H740p6vHUQsEAqlOZ9jkgT7BwSw2xS3+xvgYMXNWEFaZV9ATegr7OAAA6gU2/GwRv3pBSnhOs+hMf5DC0qUagi8jzr/irHSOaANIkTiEdM/cgnW53SOLlrLFXU5AsTmcMKHbXDvawZfcABYLJK0P2gfwkzRg2OAgKxMt1lAdjwIhbAtjDRTLncQDOKSg6OulagNfD0Y3EF0csCvtyjzlFHtX7lmbvS6wKAENyNNUtjnvhwOsnVa6tVw4aYrU5bu/mI/I5d7qse/0A/SQBk0f6ZLMnNn5anpbuiQyv+zttjuKm7xJZKPGj1gAJ07PF0xX1/4SCDarKhkZ2bzohn8iW7jpPrppNBgrYAAW2TcAeIuOE6pufJTsAFIaGPmtbd9DNBFVBGR5WgYoA3Sf8eD59HpUZ5I+bGc0p/vNp3CRCggKYFoJPZAJnpwAVwN97/R6XkH2TnEv/vn+V3g8iav/+Td2LzklpbaCAAMZ23aH+ibGXruHTs2k1qjsQUVU2mnz7v69+8akQWh4A0gtI8U5Bz1jzSrfMUS1s6ZsMFp8s+y3f+6kHPLIwSQAD7ylQkOQ95IUlAmPFj8MrNvfF2cFA18BQKc6SimYbAN0czmYvZX1qU7slSKjvYBU01AR6RVuSWX/Dah+aWGUAAMzHW87l9dqUm6yRtBKgl6U9bSJBEKuBZjrvbPX1GQBfzZcGQPU7fed4LS0bdIkRvHYelIB80IwyWoZfzz3PAHBuLJR0oWGj+v3M5a1vKitujQWndginJhF5PcdybgoADgJh6ghjjV/YqenKrHI1jp008+bPwfA0lucHfSRQcgBu8bYymyAV7xvBPyHehKQMB5zTnOsCfEdrZLLE73aMAGbW+7YQRd7UmgpoRBnWoUDxG6/oVpDxJjlYYRolyIgAgvXcDGo8ZKdJCVKRqGdWYVXePF8ndJfXnw6DdTG3YADO/efbT1Ox/IRZHzIP/uQxzO1acyXDTtkuzE0U2mN1AGLR2rfDDLoKGumXI6wXmt9wuV0hd6vmjZxirvQJS/UAJjJu/uqs7om9+iAYx9AuC8IfjR163E07GSMUKI9bWQCh1XIFPqgjM0Pm40AU6dHwkZX6jfFdQHyOtCYajIjIAG5W4pjkG7SPi7aMpoOzIUN7lryCFllbLRmqik12WgQASnVCAzUWeYZiCHmEAyaV7p0u8M9jq88bhy8NZSWbBgCTDQMUy4laZeEiyCW+AveUlyIe9f0IHSw5MMwOAC8hAO/2aC7tC8MmlsdJMMkG/zJ48XT4rShe5t27vsOhpP4AJcQDIMjTduj/ZgNQGtdUHagQuAwyQwS9W4Cy9ZuLlAC/GT0B4N6Cs/uiaehXumdoehQwE8jbGdQWTU0l3M+VANI4C6AUP/HtCBY1Id6j2139+s0VEl+XQDR96UEEU38Anuca2HxYCAmJKuhD3rT1EQRkQHjHE5sGGz2tDss4lgAy1B9GemAL0Lisr7u/59FTkkHruuhn7Fqqgq9IlnrpAHsFN8UHVXCRJjz5t2aTbFnPJocjwFavy2dEsKtg3egAXfkl1nCbrGbivGIUZRpDeEBMzAc65a7Y/Lqg91m1yQBui8g8oV5oFKu+O89yw6U9ISr7yQL0kFnBpFw+mDVWAKwkyXqfBLdN5eOrGZnHOiHMU1l7zVqZr+p6cUqQ0iYAnKpPMsb9NTEdyoJUVLwmDAEpbQy4nucldRUdiKfrlQBDBLiuKzrYs0f/DwT618IXmzrE2oO8iQjoRxquYPKOAKZE1aUJM0/L5XdZFGQ2JUyLWULa+LD0hEXZDlhkApUAKHdh36qrOHmpRcVjGDlWtKViBu8Jl4Xi5vwZ9CWv5gADav7HqRqGUTrS8aUWui4ePui4OVgYK+uKYAMYA3DcALt20BHuekfqCSfz9zRlBDgcL+uZ/YqoAKxUE3rjBkQAz7jAjP38xvRaKD+ctosytx2ngRGPkeCN+ip1Kk+cuADX04ZBDVCuwqxXmfAbLRuEje7+G8ZiLyTtRpjZDAXnAAhB2gvUf7s7WfWzDlOma4+KWwjuJQx6h869MpaBXSsAMdmQISgQpNaIb/U4so2QRu6x/eKTXbR7+aod8ih/RQBNyi+CkjOCP/H7gZu9LgiIoQEDO/uQbsyySVkkXuRCAMkGbZ+yqIcpJRF7OF7SQd/dvfmQxGR7tAY4PpcfZ4AA+9+okHKosk1FVebx1+3aymeKiDmoHa4mIfkDl0iAKQCs6bmIA6axuvO+ETpIpDQvHZUwgVsMG8o80hlgX3flAG19Sq2gPtoBap0DMcCkmvQEWJjw1i21jRWwu8QOdo0AVFMKNT07fZof/B8NzKpNB99edHswwi1yPcKhNK9oPACW00LVL1Fj554pgHGRlcSgBlNp/QcQ6Mrf2MYbJ2xzAEfNLYJuK/YZU3OYzGyOEQklrd0D6q03yP7TSWoVatMAV9kHiCZxu0W/37poH6bF3/qytHBAOiDAHVnZ+qVFrQBO195baXx/doir02HHUGznYQbTDKRnDeY7yLNBOantAHwOhyVLIQ7JUITN8b02400ZidiOCokpCOdMKQr+sGgAaiyo5P8aqektjWNLboM/B2bSh1HGZPv3F6kRgH3WEwBhAZu3XlA8h3aVAgIAdAnaJqdS3JkiopIUVgKNmVRpAGAfd1XOkm53gRdhjZ1ijNuaXJTNgyWZLMee6Gj8ovEANdcyGsfRS2ZKbPQsQ01R2CLf7ZBT22J66+LmL0WyagAr+yBAxVJgNl83Dk4w+10uPiqnFRtDq1AYt1U1zwQLANcH5I+A8wMSeWmFs+wXL1PvjXtr1BJSX+mgvP5cMwoAFtKZESUkwnf4aDqzxCIfkCEkGR5TmP0uouNjPj+TKwCXHJTYwlqSBvAl2MAhtx/U+SPXJfNCgbiKuqCmamjkAKMoBrqVQB6BODxw6f2dyDrQKigHJOblKffPDfZvV3oAbV9ZETUcrG68w+Ne1qz+MbGyTUZFU7G/HKKhzhZC4ADCjqOiUA8uFc3E3IXMjhXN2jPcLzo2MnwVDLKdlLa2APo4LbMp17nrXJZNScioj89RK+jdLhjgxmEuTEBtKm4A3JBL2kwt+fe8tWRARHGsgO0DmYMci5xQws1PPEW+pQA+DpwEiq9M4fSoXFoe0/fb1uVmd0WCeUBpPjM9P/0tAELemNJ6b6lLGx10bH0W63UlXVCmqpOXInzFje5+lBAAw4DPHkVp4wwmLAVC+Il4J6WltwqW1+9dtJ360ytKPgBYiRQzfba5wR8cwd6DzP0LMmJgV5DIFBJS1sIk+2aMAG61MeOqInUwaPIDUao5GeuzdxdJe4fRwkTLXgpJTW0ArxqwA9DNbDGb3PwZQFUWZwBPX7TqJ8lf26jsEUIzWgDsF6N3+EzcxQPmCkD2m4twcKq3SNYvyMyzGN6IPbD3ABGpma00x0mGaXPNFs9wRsUr66uV9KSayXpM3FkRlMgAfXkYpXw59xyFnHKUtn9oF3FUEYkEoyQpyzzpbJsWuAA2d5q2SMHnz4ZVkVA22ALbqbeq7R6RLeXochtPam4tAOnSbGAknvBP7POC+wuKuCUrexpFcBXx/8JDAT/oyZIAqe3nOTLCxHh9yiBSa7T+p5LiMcwskYCQcerSDtiJGwC/rFJbJXK+qPzDjfGm3qWb8fB3LVfC4G2l90qI0d2cAGby4pMULmoWeeehbkeiuAyffOJri+LvVggrWOwCGOEAs2jW4FL4t7vHWIPT0GPvm8qvgZRuFhTIjz2V33ts2ACEj1V1vLoytbYh61xxg10zYOC545JbD44wdaFA0asOAIiVdm/E2CN795IbyZfhpw+w4O3DtBCeeofb7heDr44A4kvTZSKjIxf4egx8lBVapGAwHMvsOq+IwUZwds1BGgD5aazd23/dPpSPzq3ymK3K6Xm3cdgDwqwUmrr603pnAMC9Ni7CatT41pqw1nYhUN3nvPVLqLmM7WQuyGF0rw4ACNDhfWAgOJfcrfpyiHolzQnbdh0RAhvsJu6kEmg8dQDxdmVVUG+DqOZNqBmB6pF20b2AxSwBT/IAeCm/TvuXAJImCGEmYPlUt2d0knFlCgWXEZGkHDFhEX7xilDk4sIAVIIIhkaflWkZcZ8VqqXtE4+oFZNNv6LmNl3d60VgugD+rFERvCs6t7cSvk3xHe7Y+2z+FyKw74A2G6I2/pMVADv9WDJem9xNw9vMs+bw6pL9WHlXEE+qC9DLARjZBHsAFs18TWutod+NmcsPH7ZN5584YlcaMRUbTIRecb8kEAANsltpcoyKjyoJD4cKYeAv9gW3JeY8CddtvHSQkmfFAJP7YApDhkq8OeKLLlcGfUXH4qccHSk/baWtMp+2kVcAJHJhFlerufTvQuPxaeNfqj5Ku32wqBOIovEkIC80SgAthH/Q62diyX92g57KQCqXNY4I7G6NFNlPO36UDwNYAC7hJZ+fblhSOa1KJl/n1brLV5HBAQWlUYP06TRTf0kAfM/ljCL+Mjc2sOCFkRUcgLlx6OVlWkiOaeMWK32NZQD5lkUlNo4O6T2wkGvbABqg/L3s2tHITYmjlKYdlRWgANIN/OHWFnTpq3OoUtC7xIx+Voxpctvhq/oXT2G7vVkANgooTCxhMn2izsEPwUtuqAAWv5TzdqI2j5AWYmDfvADC94kvzeaJelXVIohToaImaJPgOBXhoVve0WBQ8+z7AMGBebvKYsROBxIs/XWd60CaiBRlUrqlX8VTyZymdA8AVx5VfRolhQjYtLf9ZDgDfGUio4watt2QzeDJu/nmdgBGjHQDvBlE6q1ovUbNKvOU/xhUxM159gEJr+FxxQDiANuAKJdMiDIc5kS9TAhMNaN6ZIUYBRsT5K64AUH9VwwAF59El6Lla5yVzBFLXjjRy6PtlCEtqjTs+zYKvl9HEwAIXJNrkuCvhf3jIY4+0QNJ4WM9W98LdUErfN5jNQECAPrdzfldG+k1fbAoqqkZq2ktIYoSUiBkG27ussA8tC4AQyteuWUXFIfMA+E/R+sVfULPXid3R/zX+Y7AtLxBDQBdim0PK3QmyfrnwJrErmAZqxH6WZKLh3J7R8c2/E7IALFTImP0ZyS3a3oITKZ8mtvGQmgwssQIfUzS3nbIMSMAwzDksoHJMf1VuMJ00JalwIFsUiAr01GKr2LTAewEdwD4GXLhE7BlOy7E/qNmbgWbYfX029B4NBivEAx4t3cKAFEiYNh1AZ4FUJTHXCsqup6XexEAdUrbP4nwLPvMT40Ao9UqowuHIzGHdG0XMensGuy7H/Ulr88v4+9Gqz3M7QAnFZv/kIgg+ClOwVTBrB5eieHp+ZdcGuQ66DI45F+YAPDOkafI9LNitCu8SSczPpNTOabh/z/7DFfc1OY53qwA4YYSmlhyFvEBb2P96RVwisNa6ZRSIY2AbmeUJsuaKAChknW6orCHmLeGySDzVh9pnbZFccIpLo3pETfKpRh9AMzd+3fckZqEmym4s/guzq310iKrmtDvnvb8+Q+UYAAA8kcSlj1ND64eYG6Edrorv9J7fhu6qqFYSn9fPYqLNQC9TMcsaB0IHkvSYVMKT6ECzXzeDFQg6YoNJPYehOxTACb4d1jrqE9dUrauQrBWyOqTwJ8YblPIuaFa7hCIIvUAr02wl8a+g5xuamODEcN9Cb3dZS+weuv/PUZYI6aFAQBZzaUrhENbiKRtg6FX/lUPlCdBHYDs/0KG0lPILsVPAPsEvxsql3A4fDTXXj3ewgeOgZ53QC2eXfehQ5OKAEAATaKwb9JaDVJXD10mBD7FwMVwqzpA73tPRxq1RuL8twAY5qucAjYTPCYszSTQd9LaMcX8vqu+bOA0AA3SXK8ZAHLbFHzH3QL7oyFE7hYLCGOgWqGvPLlFuY3zdQSjmr8Avr0FaKrEFFhdeRagYDdPwszeS7ntBnrqh6Cb+d8jwACZMXZ09ikHXzPE99FrNVuVv82bltjoHugno4DojBycAHNSmdwaEUxyYRvQFURjYGmHKwes4c4MVVsdW8r5FT8AIF0wVqWjF4Xal8dv/pv5mEE+rrQ0DszAL3jeRDkmTQDqqjTFcxyo07WeVvu1b2frCjHRudIvIJHkgSAEGu5uAIQAj6jVt+OqEPlUkn/w/hAhjQ0yMgD/KSOusA9kwwIAYs8zP2ho3TweQR2CxxoNbamCjckzLPPdmSVnbWMN6QAcgTxeq/bIXdoTOm1hDWnT1kYy2BlPRa+L5oI+fvr6AMsmlEkFfpxipxhjUbyxl9/rqBXRqmsszzm0/SBf5iAAw9aO9quXiyvFtWhykFkjIpcUouaLcvLpPFVBhBYBmwD7f/gdFRJGAHhfIQB+UJ7b9gd7wBgDC6KI1jxc3mNwABADQsQOw4M58qk506Qe91doIHIJD15XsUVE1E43mLgAHgd6YfsHE4tbiljy4SWRaG2B7woIjUYEFbvfPGrmoQDvplbcY1o9HwhUpsvqkW4FzlDi2/eLmjIdpR95nW8YAInMl7ZCLmKMyfzne1V48OB1M8YmdP5jlXBIU1zXSNwAgpR98L4+o6sbaDnA6nF8FxXeaslWmuN5AuhKLXzt5AD18SLTezreJx/Wo2hgdmaYT8nN0XDJsfNR1l4OPEmoAGP565CXGQN7Q12Sd6SG1MzKuRwy95yEyRRrVyFWWXYAe7n+QcmZKymIhkyr4BmSHet5TvRUxNvzsndDKiolZACce0gSNrWoKnjAN6/NaV2EVrtZErukvJQR+gfQoBr2AA4Qmcox/3vPSQrtCt2baRBHkMz/HgfW3iTro01GhvoAKVfGq1zQmsF73e3Wsyt0p7F3G0lyhkMSoabetI+/pQCPcY+D5eNVi/NUVNYMbYI82Pu/n8zqRppl9BdGmhVGAEdtUR8rO0i+dz8/Ox49dsLZa8+CoFeQRZhQDcDZpgAAaHm5sxMpsT19M28locGwANgC3O336wUsL6WU74cqnQBegwXNkERuiquw/CaaRhxU+NkUwvjz48J85bjcbzgxAGBGycjPLXQzwAvWMRhtLZ3IAIKgpCU+Elu4xS2eR3YAnumbxjb6I5XP5eAzcFrtACNLqGbPaQl44eMMUWaLQQC5GZbDRPhU8s/wPhJAFZ0+m8FaQiRrR2glLrX2XO5JAENg/393hHRQqR6rXZbKE+Zy+eNqBvC1H1KjUWMmOdIAYOhLugLVO21vjrt6mmKNPlx+phCLHTarQeYo87z6FQA7BUW2tQdBqwshheHo20CNql0LlORUGYtz6EaTnmWtACbXu7BsXgRAxjWPTYSoU1atikEDs6cMrkYBouOfJA0AAp3hEFKcQ6BDb+BzMarrZpC0NmswB/hsVhGuC0wK6ACZ2hBQf0dRJiVV7TqGrqDw1FaH4oiJZ3DUa5sEN15WAPgETBhQL3s9fCBTyfWWoDjB6YgXBm1cpvjq23eLdc8Al/bCt0w1Ask5IHtvhC2d77tPl26fd1ud9rvi879ZMQBdy9MDNByCNxjjveX6ftiwXsVfT/UnquEa0GNc45JQAAFjfJu/wSNbP8j6Clq8M5nZPSFAzDHhH18ZMDYoAgIA7upmOuNK4kYHe1Zi4flioo9sCdC78LShID3I6wAkxgDcG8MDSxek3cgXARSdFgRc1cFhcXgX0Wn++TZ6qTEHAD21oz9ttgjixvUeseDO33v2y71gCzAAqm/s81vVBXwA9BtqhKX4Zu373HszwXeWKeqhvx6b+GEjfaO6pNGNSwCahhNcp7co8jvjjc5byHVjjAUj1WkzJ5f0raKlgzA5ANO4WK3Fd82fA7MBeIXW0Pe830QmdOuO5q/zqXgm1tkAnZIorCFL7S2b/bIfQJSTXqRN43tjDAOog5bfORiToACbBqqnnvZLZKxRgyCWwgHpDlMx6PbgHxofPpGCfbcIAOavCDlthjeIaMN2MMFWGXKmEblTPgxwxxGAF6Ifty8AcM2a7UYwL15P7ezqEWSuI/Sp1oZfNyAu2ckNreXE0wAh6RwTZOsT670k0DakXk8XhHSMRk0s7QidkkofZ8rVABBW3XigX0O6cin+A873rt7H2ehafCdKZl1ZY2vPfdkAesH3DoaYTeSEo8iXrosGgkdeENT1SjCRvR4GcKUujwAXITPFt8CoklzZvwiRKcQt5BN4Xef4K9T2xi/KA7nZACw37oO4jzsAqAEeQWBsIa9AKdk7ZC7JnAgtpk3kzr0AM7QH37Q7P6Arf7iICfWIZ04/cM+P//TBcBBYLChbowBXsS67ScSS0y6n7wc+xqeByWtxQEXNYA45IB3FTs+IALtN9D/gwnuXW8Uekwk4gJk0WOmMjdlxtgkRjkmw2+QAht49ZctiI1JLRpfUvP904EZ85cpltEIKW+FzNVDaDQCSF5HEoxUog50fnphPwLuXevi0Q99edd0IP3foHchNAFejJSVZOF79iN/Z485g/DhEjrv4z44byYndb45TlUsAi48J5eo72vsxO0Zpck792f+EmpwiHZyjx4xGkDssgwA78Dqm6B+33l29uvEGcYAl0iLM8Frb8Z6oMPmu6Q7NACHAOhwkgiCn/wDQuPT/l9zV5YSavKnQBJ7TfqtdrcUAGACsboX2Ngp5ft9cFfCmFaLVFEYcvfxkuaEkzS3d7wANEr+Zzj2YCWKCbCB2ZeSVQT2mu7yFxWTVUTd5WjO6AA4iV1x1y582WuhlDjA5YFUqxhsWYZflGPIteJUbBxQALHoYFWTVFThS3/QbCiL1eezIm69NVvaKERnv9tAViwAL9yLFTa1Eg8cf27LSYTooN0QMzjZAdXHP0lehgiYSAPlX+hgMtrLjhOy2EeNxUbP0Zl+SI2BC8QfR1ENqBpsAAYSPBMagOIKKx0PcGJ191He9SaTvGUEL+7ue5DCLaQBsRyyDkpZlby8gZtANoXl4NPH52DecfU4Zmk0j9gDwAGtY72X9eiRmK6Rrb7XneVlWJiX6vLO/qozoFi3rva0AusDk5XY7ooZso4If1sGL5n0kB8nw6m5cQAX3E14N7QCFQajnq65a5LfiKldAhVnmBPshioFaH+TKhM7lpVrZAMLrYV+45nwBpDbQK0c6xTgVBnW10Rlreg+PmVjs13IA7qIzuIhLh1ujlrQCMNcenbHFeVhG9t699J9Mk99aYQDzKATTCh0YuOA+JoJStpZ2/ylLJbZDfxtEIggy0Es8AC0ZzTXXCqXNlMbpoYmjWkJQQJRxqOBBqXLoEzb6T8cA1jifYxWep6OeeW9vCUwJo3cGbitkTG4v2vH/He/a7AA5tXnuu8g4VWPs9Oxw6SWSinm6cynOcCqpWHeEWqFBALLpzmqNEO/sK77wljQtoAVZSUWRDssfxmssnj9jr+8A82a+VJq7SWqEusVU8s70kP3m3+erqLtwN0Psu8SogwAQHC+QQFOfx5eKT05/tLB5vKeDL/TBACAH1q6AsAR5APT1XAma50U3ny9jWjsjoafePTV759Fedo5BSYqYdRUArma4vIpH4n8SjM7lrro8zR8cy3VCIKbtnOcYZKqQLQDH9KGmwrBpUn118hS/0P0rbnoj4K7+/HoewzJ8C0+zAEpqweYaIDZ2y2saW5cWFh1l2sdYQkqiBTRbhG0o5v8A3bfOIDFkInMokCPFtbExbtFxfy7ttfXHBp+TJnW1EgCIG8A6iCW5wI5kHZuIWGpAGtvkAQGy87h78Pbc2cS/AMeRqz7klNAEcLUoh7XhIKGVUttP+CAO+OLe4Ao2Ys0A43LhDvX+o2aDPSIcwlLcovem5EdL+uT9JZk4vo2HSgCKnlKI8eoymHGaPPrnZkoWz33we1Hzz+Bnuly+b8BrAO1GYEL2RHSbYj1wsb8uXjWC2P5BWwsiGP4cDqvOoTsAvaNP/l3SV3tHNMSpXgi8AB1+1k0iwegUKCYd/JS80wA0e9RRvr+mIT4nG+vggaHphueIlc8V4wjuWcqrmO3JALB90gQeq5mhGX8cvZJC4wHCSDQABmJMXaFWs60/RU8A3LRREFz09TiVXlFHlHjGNSmIofL458e0LPh1lTLZ4gDXrSfecEKUvm+dmbClWoouWAZOCLN/N0vEqR8/kg/CAJF6gd1a/dkD1VbO1B1QrXPyf3GmlhEXRkOVGwnqgbUAzY8PLCDCiWUm1SdNsramxY5L4OpYGT8mij/TMKTG2wBON8R9m5Vx8UEb42D9NsRGiKBdwFyEp6JrnNay2z5wAN5cYXE6u3wQbLoe+ArScr11l/B7IxEnlCo8kqHZPQQAxienacpm5a4uPnQnYtT+Xk+0vCDvBpD0wUlmzwNVUwBgMJ0d2Dau+q0j6yjIGg6X5DE2mpKZsZARG6VOp5qGAC1XTaheJJlfBqy5VCSkx1FOiEqHJs37mPbpLZsGuI8ATLoxbJEI/I+OfQR4cVViKfakjeEvR1Gr3QHF83NmiQBaW9VNwGYhEs+WCpptOtD8zl5jR3MCS13VTsXhifOhAK0kmX6c5pyZprhsktA9QQiCIFEBKfXcUkl1bm/He+YACdMvz7C2bylNUevkTyVJ7K28ZecF0IwtUzSyqIK20ADBZQO1qa1PVUAwM+JNGrPRfkVWcYg1RiSv5dQzy9WaAK/75++F7a/LIsq+uYIpctKajuet4A4WfLzy7FOSq/8A2UVH1zWwm/LHPfV/XYKxITl0Xljvy7pFknbwFXoOqQBgjAxyaQsZ+pC6LEYfoxvznilZw22WEzrlSw0mn2Z0AMoYKSEH5l2hQoRNXohbKI+fIZWrBbrK++i4MteeMwgANiQDEkEv5OgaNxL3L6eGeY2k/gbSa396rPHrLXcUnQCkRcAAO3gYbizzrJfti+GKqswnItF0vTJS7FlSo49HAABNVwfc5gc680qBgrVCLz4pPVq8U5w9kYaPhys7mVMAS+dohFygCgEbfUZ3tLdUNiH9JX3V2sEfwjSazbgzCgBQJQy91+yAZxOg//5Tm4zYblrYZHOL0EQ/TTr0N++FANcDMpC1veVi7ETauYezJaTBqnaFzS/BIy/6s3zjovAAnfqULpgkDT4X7tXI/pvjwpmdbBATvdPo6Bwt+7kPUQCuvGBqbmo7Qq2PS0NwRMA1sWcVfjWYjkpq266ZPMNXAJiHP74gizP0TiJRAhuTLcxgaL2Ud2oRloR4TIFtE5wAA3uGzaOfRHCDChg/aJc1qUAayiftg8IN8LHh4NPVVgAwi4Dk6VpPbfx4Nzuhfw93qoH4uXBEykPoFKk8+AdUAAax4JGMaqTLyOiSP6Q5Odu3hbkRJpjEf2A/DdwtAeAAPEfSuGSl0LSzL3DtbmTe2dKQUb4mE/YAF9IS/kQLQgC8SR025UvrtE3Jq5xvJey60pXn2km4ePubU+ax4TYnAHRbf2YSqbFKdvO5ZH3C3QcUWxW+zskzUQ6KCYW8YhkA/78Q8Pu6sjnF1yWOkYE4mRmWhnQe81usZHklQwU4ygByvd9qx322+bG/SOPWvT2V6ZQ9q0fSqCP4B0ypFyecAOCRm4IMStAoAVe/uXJqafnISy34jwqA1INXwYq3aWQAniZAGrCi8YWHpyOSmqsVhr6EB9QRkA9EWGalsRYFqAA6iNBWJbkdVL3uaM0TDetEb1aGQFS5yYJU+5AuW3MrAJUD8D4MMW5wmzSDbbBDYy13wftswP+AigGnCiIooWwACBYeAOxiABIvAYRNosCMAfWnsDolWywykSQwO3O9WwDDABoaJpUS+MKMY2T4sykQ4zeqrpB1UXq+t+ALzxjqAJqfQN+eELK3K5+ieZoU2ZJ597caVOFmRbsjZKRGfVsAJIBoXt6Ik3YXj7hxfqAv2RsjzJ/pUAA85Nu97gehvQApEy2Oa+2sl+Zj9raXpFacNRGqwQ6lFZu16+vJbpriABvLqm6aARPCHBzYQKM5FbHbKSbl7W3g7h2Kei4FT+gAHWxtVSCxQpXFy5DBeWbcYxImcMLJ4pAxYfJmz0lKXwC2FAToJkHT38kaRJaojJL5v+vV8YiPq4+iV4mSBVtJAC/buVwjH/h8GSyDYpJ3eZnj0WDV0fMEH5rIv8wL8UIAxcCP543h6xZ0M5W0KbVL9JhdqH7fZGeATcCtPBJlWgAATp8Xw99Q/+KQYZ4JBAhlx0c364sdhOyLsI1w/JnQAIsirz3iAK/T35WpJCaakc6NoRJIX50T9aNY7cgaZaEAHO3BnS2G5sFS9WGz22nGajQEb8gR6lBk1kLOBRZ4/wAQOAPCGFWylvL532t7SlNeavnEJPI7GazcoDAHaEs/AN1HXVlJgRf86ioZxfJ+wZTSMuCUcAmyi9tECOGPO4AAuGV5VMqAKctzrwFoLNyZqmJNKeWooPoAcs5B8Cv8MQDDxIAzEiswYZvb9J/nJKVDrg42s+qVJVHr/L0+V6pQAGjocffdK57fXFX9tB3dvLqxH6XWcdw6s4peDvaciXoAAw6zSxOZnIaOHd7uwAcc/gRC5zgKGk0uvf2ohGsD8QDolsjOWFQV+446DeteVY8xbGtSdqJZxlUhYnWtLn+FAAoPEucY8G5EhAz8xQEZSOfwGKJXi+mYIkmZfa0TIHQAHMmG07Pkcp9Ke17HamgMvT0O5T+ZvHjYYI9XKvan5wDaFuQUgCvwCAcmC49tLzbK1U7kJv9JzC5x4GBgympIAOF5hRl3R7oO1Gl/q9MPOidYl+6iXiWY/kpwcumKWZMACOhYiOi+MrzoqOvaueNLyFEu6WnzeUPFXmJnNlyo6wCwskXeajShdaGACwXrdgx1FLiW6I/WYB+jGovQfsEIAKzu6EnkstIS1os9flNL/3Gkt8+ONGFeEN/qycnmXDMAjh1GDTKVKWOaLxrTcZbkdmm4clW4eaYyQ/0FJPGwzwCQWreDlKj5cXCSGDiqPK5HxuY00I1DiENZiK2j2k5nAFfFdamFsC2OFfXkMWHg7A91oYNNSy3F+SlYQ024aO4AvcqtAKPm0Un7OmtxSgRT6q8L9RVKKVZn6tfqoXdzrgA3TglOrgGmusXz+6lte2TNuxvzN/7ttpUIM1msNhzhAN6R5714x7YiESVYsNdl3LDlQttigB3gX5Eo1PzOv1gAjmcFo+4+g071JtGO55Kar9qqk10uXJ+QSpurbGWcigD5bALJiTf/GzQSwR+k5ZsKg8vvrclaeuAxRbtZ8ePnAAHXnEAObVFzP0ZzP14LpGbUByP2B+MAKklIOrJLW7QAmDRIWI0L3mwNOJYQDId2c5ZPL6pE0XJioPpc0EX8RAABNMF1Bf3sAczoL3dmzyqa7S1jZ1J18pDYBT3K6ai4AGEWdolvxaWjfWptZytCE7oiMdHVrbGBPT5Ax+RuUZ8AGdnsTlhnSG0g9NKPzIqqrJtbGmtwcmYgV7Qcpfy9ZgDgqHRpv6ICQfYRxJCSWCu0D9f1XTQZT0wf8o3vQq/xAD28ZUMRiwafoObBdnGnxK0mfNndPtcZhbk8PbVNz3gAHEoqti/aDPL04lwZATYLURtKwGKsMJcqNKlPAJmisgDNmvwGu8xsAbl8slYHNFBC9b2KFymdPHjgzZZfZIRZAKmGCwrUu2bDk4XY/he4BE8U0rp0JW6dpl973qBdesQAdj6MdcykGLMPEyLMEBH1WOQ+e9GxcCvemNE3CFiCcgDtmjBdL9KZX4sJKAwf7oGKCYhjSnA9TGu8YKc9npffAA0PJ+vJ0Sqwf0EJBLBewnGB6RO3MgPe2HmXI4EY5c8AxIpoZpsDoe/4kQHW3j41Ohg/OjdBJu4JoPql4WnVBQBdvN5pFr4CsQNAGIAYwI4YpmZa/nf5kJW397K/L1yMAHrvGGRCygR7s50lnvWrd4wTBKNdy+NaFhn/71IoiUQALxjvjKU+RvQ/kuf/Tlov4G4aK+tYJhp6xVDq7Cqg8ABp1xsorvWvW/01GrqHB/uQFVfCOWJPOxip1hdAZPsOAMfoC23KG8673N4pQAp5Hm+YQqXZJ2jKh3jMPfD6kvsAb4FTsBRB0Zkvu8wHf+mF1i8vVJOBehhXg2ZIBeOBXAARkylukvqUXnSEJy2dDtg6EqeKi1zsGO4DLpqdDnM+ANpc2RACubmE46fwQ05fM/k0yskuUoI37CqXvdXHSr4ApKxxdI/k5rq9S2LNiN/Scy8vj4aT+2GG6VvmLp4IkADqmghZdl2TbDCGxO5V7J/wnle7oQNn1xj4Ky9H11aQABPhKms1ap735s2PjPDaZfNFs1IhT1b+1QlAwCZ/JJQAqINNcnmBAY2EhSCq9ejbYSjODvJouaWI+TIa0gOY7gCW3OLXED4Aik1MhKW7bTe7HJqt8+UXGooBTvFdqoD1AKgE/AY1T/hdjPlX+pwjy4CIOfZ99rW03r52gDXlCEIAxRJa5K5fEnx49mUEZ2HTyfSvG4A22Uc961kIhAIRbQCbSJaMwGC+KouWiqpUY/Grdv3iXZGyCqeetmW9xmBvAJ+fYH7s5xIWUl0p+jsXL5P7SQFd8GpHL19nrRrKTksArxWuMHi/1GPZZCkpdbORo+NuoB6NySlRgwVstUWZgACdzl3saKuWPcBMr9Izm6njYoROpD96cJg2JqRPoooSAJuygvhHhjpdSpXGy8s8uxcX2WZYFDmXtWz7P31H6ZEAmcBYlSQB3BK2/qQEXyQ0DGs6JSmSRU2uHlrYp8XGOgAXzkGMI94mUy61D5LmdNf6DM51860uFniXNH+K6FqCAHlhB1Hx0VPmhxdDgSeVT8M8uE3pSkbl9ZKEiY/lnqgA9gXqq5UNpfk8hM6GnyJ+Qb3dlK/Q6wmDnPFkTA074gBVgwIwTYM1iZZ26muUX6K7XiWntN4eqT5eUIJNVCIZAOP5AxkBFEtpqd++uy5oz1pfTAOYbVDS9JCmbZe2ANUAfZYuFn4iTr2PeSU9EaPhs3e02D4yLO2KPVdrsY5F/wB/khlXlK6Pt7GtuVjBiZ1ZLJgwV8g/5FQlq6xXGlmoAKpgoRLJLaTXsS9QK1BkgfuIt04UDtVkRRZlNeIDKpcACQqtsZ5QK6RHQIJPq1v53MMUsQlDVIjYfLw1F6ivtgCkkaUjqoEAYfxPXIJBcv7c0qzwGjtKGI65IgNIgK+XANSTUFFnx5uhkl7/DhmM5Em5hIPCoCTilXN7yQ/uDIcAsv32zcJH4N61w33ON2CqvwXmaz8ygJbvt5J7OOh6TwClHRs8FeSEEhwEQ8q+Dk8Xzv1H4s7y0w5JTQ0Z7ny/ALz8IMYk+fdVwlwdggVH/UbrkKy91Z7pu4Wj8qmlTNwAH7dG1D7j3mdLTkS60oUPAWibkeAVFEywViKWOVXS2QDzM5UOPMImRSZoWg8FTtSY4pFvEuh9dr/2cGWk7Fo4AEzM4nDmh8oO+OlpGWNfwtKjRLrdOQ1oTkkNn93TDfgANIqImh2aV4pZCKiTyZ5TUfXoAtK6BUxew5r2dbfucAD5m3XMWHCaookrd3KL0z0+hdM8Ew31zqFmAEjYOB94AI1WzJ3a03a/t1LLO6gW7fk4qwcUJ15TKcuaRgMpyI4A1s2uurUSGQ5Ad+5Ia7FyDPDovoUefbNybsbx/f8DjQBvQ94xJMPVdxwQttQ72VbxR4HSUxh2tLJYGzlNGXXiAEaW1/JQvTKGLGJKCbOvdHQxwlaZa/C1WG61IMFCofkAyOoNA1At8r2sVaViXKXylvhMwxhKyodI795920dbEABLVn71LDCCSQEZNmtNcsj5+edRZ3gafuSodO41S8K1AATj3Pe7ScFeNnv8VeuzqYCT/ltrmkb7WtbZ0g7pOGkAO2tn2luTw0PDISq2dwl0t0CgZWAFL/W2k44EFSkNxABOVUyOHN1QlPLxsjJgS6oXLMcJvdlcrD0SxcAzQ0A5AFuvgg6iEPHmd1l2CnLeweXiMoBFBHtiia7Kq7nYgigABD9K64K1fg0ZkAJh7okxfkhH4Y5fP9HkGDuRZgvNpwDA8s4GgI2IDjZFEfE5PlOv5k45qX71cJApxnOuqN7VAOFvmlzQjMc0E74PdXGrHmvNTtDyHSCDo9dXDXyCaxYAQmPFuoov9eKbDuv2t733L0FG6sY9ubhc+kjB7Dj+CQAMQdQLrMGXV+eAvLZ+bL8xeXRhKXjNnjK4ZWWpCScqAJenlSJSconkzonTiLUQqarYs+8iXE5BGOs5mmUjtJkArMiEfaPFliVH/fECclTTdSSBfcbxOVjUHDkwX6FKFgAydV0K09GvUnQRB9YkUjtJjvpxUEBhGd446FDNhtRdAJZJNONAEIw0u5L8iHRmDsC70mbtGJucX6sXYoPzJt0AXSSgnfi3Y4oR1cUo1M4YtnZi1FYomPVcKrivXZU4YQAy4L0NQOyaV4iTctZRgGFyPEU2IHIGgCNgefBOPG6GAJe2WCLyli8v90GHJKbIrCw51Z41r+NVpOa5pM5fTdoAMymEnLi3O5epygzu0R80j0zTpV13j79xJ1JMsQfwigAeNfGZ/io4nNBP3mBWDYQoUcQxUCmGHWRJr7KKHAk0AExWM7cQDPt5zU+mT4qb+zX/j9xU5Z7QtkJU/WtIrYAA9b9SAGw7GV9tfdDbNmzzwPfOlGqtl25lfHVV+37x/gCFQqrjhYzxZt2riIJp7cjFTVzSqED3XOQdKjYOdpFxAA8E401eh5TBojeJKueqd/vb/CICP/bUKVZJeMF0nHcArk4SY5lZJ1XTUDEKgC+2qn8VKVGFczrbgKZTC4wrkQDE29wrtZ6MghlVP3B36tXLFBhkBFJKYWRV2SeW1AxiABA9HDwd1jcG6QOJZNQzbpiKKgEuvtASAAvl+bg/IhgAeW/MRuv29FWab1omTh3yCsmeSlAZWw0z8OVSlwukKQC8B7DTrJ9SUkPuDbA/Bw7EW+EPjGHJmf91LJK1M+K4AGZUc9RebP+XsKD/7m8kI4m6aEqORDq/GXVglY7xnuYAwi7s+aB3Ay6L0gXw6m3Vr9howw/tmv176tLTkhkjzwBLPtrEUF8QVde17uJwMbqUt3yP2F60bOHqHMcJHvhhABJ2w+eznrjnA9Ty10WR59diSW6wAC2t1vUijPcl5gwAr58cLxcPZsF2tHmih/gat1Z6P08ePWW2yVyseZuS+ACFdKpZKTtlmh1oOsbujouS0gjJx80Xt2Xv9LUn8AHbAI94ixMgktVUblDsUeTehxUfN4WTkqm/Nf44J8CD6FwAJ6ZbHt6mdtQz7nS/Pdy4ni5c/4ZQ8u57PeCyY/jW9QA7lzkKB3KmIlQzeLUCKAineNfwjQyZPyEuQtnBKHmfAGsAcJBiYtAn/bw/0YY5r1wH3op1zQNDIrF/roVMsSoA9Gm7IpAuhSAKDHHMWMqCHHxm8xddChrCcgtGa4Mh7ACIGW0YrER86yacXI5ZzpmKghNxhF2MwD7yxhkbLnH+ANeBSJLMxw6IXObPF/9iaeIgLE+XDKQxZ9PItb4B7c0AMVHcsxx8yFBHUjXqRkFspJwm1fLpRcDaEz7X/AxuQAAk0ed5+xv5W3FMepTfzaUl55Az2EewNmihyiX2uw/FAMc2jkYbGaDfU4MluJZz6isA683v8wUY6/7IfEm/xaUAAp9rg5ycFtnFjDNpOXZGXatToSLeuyeNssKPF9cgEgDlIU7SM3hDrw8DQasM4nBJVGQ6537hbTO3BmZrr8HiAD7JKV0ijdZLfkOudRZrJR8LbGZ3n4zr++IlqXykA/4AP5f6usI8N35/TxGTVWjivLEVAahHWtros+D8pMsS9AAbt/1Tw3jMGfLgP3dxs3OwzVrZm7nRohaMIRTEELs1AFwAE2flBkrz9XMFDYp02QmQflozvNi477/R9u0gwWgAISRPfKo1m/lpHoIoXKtNahc6kkKb9CiUvrH7/V9UywAqrQRnAa8CqfyjFldFiKlH1TvnumBOB0z+8qjpSeNjAIBbE0PLPR33oiTX/jFaimK5e34EFWC1c9hl4nrzoAsABJO+4mNG0LZ91QSamrxndSbSub/PAFB5Ii0y0sRkIwD26iGNO2oaHn6fYDbad0FhAbqmeg+jRL/zj2JbBonqALNmF5y21B7e7rUiXRE+v/DrMQDnBuYZJ9cWoycK9zkAVkueaGaQ6ayjcKXDUyRPqXl8XA75KafpBuI/1w7pEACWRPEZyBf5Y3/Wlf+uvsylSfZKwvlNuzdvwIkZjIvaAF3ZQ8Ca0snA88IEvmZYsjQLQiO3TigOTloYEmIUC64AmilvWGv0r0AztDHsIRMyhwHHdMUIJEm/M5u+swM1LgC4gOarOTNiBqWPdV1aF6EhTU/Eouyre+wDtg6gXkGKAIMDfPZCF7DJyDG6fm36o6IIRO9JmTNShK5IVOGsOosAMP4f9rRHx3rHvffz0VPcK41OhZv2Tq/h71R2dWU5UwCum9tLJmT6d49b68LGn7dVih+WqnaVl0cVM8Hn7lsbAM8Xin3jrFzvp5T9mmPyXw/pTtRjU6deDAD32Wv/Yr8AotjsKwiEyUe5hUYvzQVGd0twUdSWjjj0lV0jxpq6owCoqyBUEcVFy8SiYfFKKQrP+LarrgLH/rBZK7eHEFvdADCAB4rjyKd7lpbZUfAQ51+bZgQwD/HcqaocgADZepMAnADsnO9YEC1WX2jBBgSJv0LrRHxLwR3705HWWcE6PgDKt/Hp3Qk2zF4RNG3j6FsOzU+B9MihKEa5zHBbwDfmAESZfLG6FiU9gas+T4Y/BqLPoph8YNDIjcBjD4qDD+0AHwMnygSr2wAyYgnNnNjx/JjBh3VH5bqKPexx2HSekABf/Pz14CLcKKpM+9O+RzrYeJtoMUHDayGMLU9D2RVsAK4wmzWGsqVX3Om4CElmuiX4k8iugM6KRcmhdJX4cfcASAVvRw13wRrJqF5Ljv0/K+L4pc/qrPrmy1VCiEQoYwD/fw7okG35srjMb6GwxPTS25BJmT7LyNwpWlazCzUsAENTDdU/E/xjb4xiEkuoGdlKfNScF8RG7A/msi5Bq1wAbopYP4df0V+NyI5IZWwjqY+K8c7U+TK+WApz6nmQAwC9/lQpnVCz+3DMq0Pxjdavzwk/Oa4ws7LpE2CFdbobAJCcYU4sjY4qROwr2/sE0JGgHF7VnMPm5tuPvNF+KuoAHHDC+OJkaLx7u+aGda08lfoOOLymTE3+KsctsEIgQQCdfWXGBsr7WK3t8gBaCRW1VGq3xZEKB8IEsOhajk+OADhCp5kBfy8rPxjAyQ3+xpLBWI8L/NsnCIe76aRj+xAAFMWPWC7OYoRkPSNA6F9JHk2yhmrM7reIKVNqQRRZJwAIT4OZtubcCXFIQ80bEtWAt8BnDBS6pIIZCtdNM2fYAGMUbfw/jYYMtQq2IRuDPVdQthnnX7ZPWNLZVRLiviYAH9pnVyGiaYsQzDktEkA2zr7MLi4lQneMznRdFQbuVQDdBUJB3ewCkRsoy5sA2yVjNjKw2cMisGye0JA91hVWAFEDL4ikO0lJgfD0njg3Ewb2TIWkXhZ5TqBm6bnbRfgATbmNEAzLW0/11hOQ+MheRenskQl29+SPLQrdP+u1kwCqLnVXMQnv5lz+8omfxQcFl4xaCOWM3QICLb/PxmbdAC/wDWBLb95d2oMHw2YPJjE7Nc49JnGGvqjjFyJ8MN0AcFaAsTglMHXp15HDFo0elOMkRtmC8wWAtRnbfOt52wABaoG7lgp8WN/49iGqOOAHTDmOOAe+gutNnaZJAGhPAK9g1gsMJST3cZc6HTUcIhYnK+4dhmv5Zc81e7e3eI0AclhnLh8H/mFVNFEZIUH+dMzd+rWsvWr5fN22eOY1BwDtNQFl9ZCGSksgvZsf0xyQyMIdD6g9rvuXWitru0aFAClwV0ooBUmnzinMiKVGiYiYprF7+AEChbvOA7uZuooAA1ia6FZz9uFZOcuvK2kYceFPq0NHa7scaRWc+bb1bAAp4RN6eI9zXnWZUmx+KfiXThNOSEMCVMV7326vnx/GAHAdZIMIJFBY52sxupcXf+1StwzySnjCJhWFtxiD/Z8AsMHjnjsJyGemXSzgw7aQxxyWc42jJUxmiK2MVQCnuwDI8opF0QyHulooiGIwbUHpBxFPxJPHbzQzKY+xpWBAAK2wTiEeP4/xlkTt1mOpnQlwGwAlg2u7cQALI/0aA8EAooXGYnCCdNrmnGvfGBj4+fHufoQ73I0wmP3n4ai7bgBmGhA2C+b85QceVh8A+vzgV+lwG3Yo/77Lxit/eT/3AIFuwcU9Wbq0T8j77TArdlO936JIU6A4URaWbUU1fwQArFsoHDSt+WwtGIGusu4hS5ZpoAqQO/GsT5cTHA7xGgDz9XUWuNLUAWZE1t76NFzZzzIe6WL72JaFKjUnk23RAMczwpkGwH5neWcBMcxmHtZJjiGgS1FVpF7I3bGGjMsABApAnyx1/2b9zvro3XPao6eOgunjsKvSfPts61qYtgCdU9sTD0lqU32kl/X91zcIdkTbri9x5WLUaMbNbWp6AK1tdRzGHsFbN90pvBSTkoGkQMt17V+THZah3GZf0coAPq55WXiW3fUsGAzTmL3J9CHDeDL82bPLA58jaoCYQABc8K//tFIE420eL+jhduvgGqCycTp5LbOpli7QK7OMAG3TCsuWgHqJiix/Nz3iZrtryNK2TlQ3/+BIyQejstoASFfzo0+fDft35cVHPrW+aydWPETLFOMtwvojdcmXtAB63T8xDngBQtMO16pX/ov3mAbWwaKC8ROy6FFA9XNCACMBDsLa86YJH/ZjP0NJmHKmy4QXUy7LMUxD7LtFFwgAVcRKISJLE+YQLkqM5unjFTEyL81EHIE/EZmpLwElTgBuKyDY5diB9w7JiFjrrWyapcYy2nlyodLsIRReU8WtAETWgrDEYbFXW71H4RUhd4JXnS65U3n67zvc8tUN7HMAE7lQ79XhcoqUcCyjDIWA2BD8GFjj+HCKuvoCbTg4WwDDNhELWYrbmSD+RQd2rVth4xcJhZVw66jbfbF4u5ixANkjA74BZV2957b1wrlGiXa20NxkB6tG22c5+Or0r88AlD4ZNh+p1g1D9RhRbHIB/qts0zmYd22gFVXemV9jZQAtu/nyvNNtTAihlwWZuLaliXoiB9CU+6CUACZYlQDsADljfGeDcjPZpIkDTATqnnm95gAhU8zoFEl587v26gAAHiAU0j8x1i/lfSdT1URZJ7uh9Ac+Z4FZJ8i2jMTr3gAfdOTRMce/P1tx3YcnR8NsP98hsjXmd9G26/SYSEkAACNbXzwTQnsmlOD9MiThA3UWaKW8XAZzArttYNydLL4A6DUv5+GkrAw2uTeefiZ680TgjZVf0phZi8Xg7iUsVgAKqCljqpZ9azJhfQTctesTdj4iV/GzFb9Z5osEqNKHADO6IX/RB5fAjcKW0jUCYEeGHQrnpkIl/thzKulufWQAB5XGilMr34t5OM5GGJUtx68YYhc3TJ9oZ0pT+EdVRQAQM8PaemvcT0iKOaQrzgsfEepBD0pV8QepWyqMoRhBACBUBP7aeST1kwBkIYEgSbsjxfMB35+Op3m07gluc3AArwai23aVh1Fw1AFUPzc5u5MhtCVK3Jvlm1ho5zs2sQDZxNPz7sQ5AIiHgI+/EvG6+HjABiEmnTh4IkH7kw64APphIAz2CdDzy0Qj1mxl3Ewg5Zfy2JJS8r6jaH3BOEkA8PlEhSKuQBl6BQt3P2oermoFCFCcw1W0C6gpy4SGiADQjg5FAM1yTJr4C3zRRHu9DOOjTzzHDUH3s9rVitvsAG+nSsq0RP+AigiAXQSg1SXuoQrIpBphPnon/8PwtPYAIfHJu+j+LvZcXx68ERTXamtVe66+SuWh+y9iO2R/zwBuisoNFEfVijaMjZGAlrxx3vOGY8Z5zXkPn3Gdl1neAFwqMyJZYqmL/6fh0QaQueu3jvoyjKyZfan+oFWFqpsAAPW/DsmqNM2M6gCML5Ana9QILWhxSQu7rJ9lfYr7SACy3HDGA/oxT+gmPJh52ASULbv1hXLr67KiYWhhSYk1AEh9MasNZYZXv8HplDbrVCCJSTPMlDT+04Ulx2TtTeUABgvSf+0EDpYZy94ULJRzg67D+Y+E82qEzKiAtaWnngCVm1Sss9kkyxun24rqVJLBnuYhExjlorrRLJU8CdyIACDYEkVvfD6/XR8CV8GvRMZHYdEuu/lNpEvMB2zcQIEAUF8TvdyoL95aRWlfSOsehtAd0ejlI5yCoXZ76QrokwBXZJ96FBd0P/qFBpwoMIO8AiK/VWPO9K3eW062CKqDAP4Xyb2eiwPw8Dt6WBQ5XSwameHthgN/5Lx2MgJVXOkA9fNQqmvlH0TZ1bLPv6nvUQYNwl73e9dk2a+zB/QfowB1kOxQ3Zy/fm2dJNGOM2/SNawRDlIRvLqtGyUFMf5FAKzl3eS2AHNuccaTXAZUzxwzWZTBUF+0ZXqqJXOvE7gAP7SztM3spE/oNW5ImXntexWn3rCurEpBmYzpRNZeVQDu7NvYT0a1QB4X541SbSCJEl+V8rbRAJqvIIu49/z3AL50qKTHvvRge2jTWgQk8K6ELEUVs9MhaZxK867dJtQA9dyAw6UA6z8fLvbts5CgR8cBtpU1rSKvD010vQYoMgBWEzQ2XSxX3cAnLVfXXM8wpHmEefNZNXwMml/4A+BQAJnEjFKMDTsqsLehEkMaJm3sDRrhDN/QBMPY2DNqKHkAhG6zC/A9i9nF4c2pjI5dRdTdBDWzlMlzpb/VJxUT9QDfzNN5nITZcqDHlbV3HfwwffXbJbmSp3nhRjrosuPvAGIZVmvxZOJIcnVRHGgGaM37XDrrpvS7h1y3lL/AGf8Abe/+nkAGKh5/v0EVz4NWD80RVTWxnrZQe528E/GyqAAYCs1v9Jm1iNFMRWKCKIl0pnIHRtDJ87xT/TA/yoXZAIpVZEQcIf5RNZl3PN9hPZ7pC/RfTvQ2o6+rn5wFYsgA9velHUVg3VbricduJXnWvx0eawgeA1PI/s98ymv6gQDFoQFvpJDS+GBXFSOJQm3uKjnZs9X9+JkE/jUzN22gAMhQWHEh7E8+y02JXuTwqVbgzix57Pg5PWpQ28Aoqr0AoGi5aNXIV4qlmV5LccBvNQb3MjZXQbkqMuFQkQUhXwBvdjoWYTIih0RPlw9sF/lpcUEOA7CZ7K0XL5x++nWlAIjwg7d2RogR7rlHgix+rxexatLIqJZXDba62t3lKBQAxRnKY21V3xGCPC+ZBNcz2uUiPkbhc3AfOELQefud3gDnnDeLZ8Rt32OBFUSkz8/ZdQQDhIsZFTZA8+MoxtqBAKVyQoT0pFQXFNl7jRVKE7l2o8KrgrePOCqJ6kuoNXMAecjPlF76gFZROjmqkyDM/JSMVKqh8ohs2V9v4JNENABHCKj8QMICh4Pk73oa6SzHCsg+UGp4YDjenWfCtHTQANc5wlSY6DXLTfwTLRW0wd7yfvchsIR6Scus7+hIWJEAYyIXEpIKTOoFqdY9LCxjc+rCPi8lfC8sMTMvqAaGzwD3ryX41bcMMYIgvyezhp0EEXAqt5YRI6QwLWsGzF5sAF/yZtCdzv5fGLKg7mWnKW+F9t2cmRln+OiZkTLsoUsA7Lp1Q3EzWDbOjLUWfIIAysi2/0HeWLs4LP6Fe7bQkgBXFdudUlFi8e9I2YlUy6HkeUiFx9KwlVwWclKl/25DAKeB62QgefH+RwLb+Ub4t40450tZRgZWCQjIOFfNjAQAXBYJ96FqZXqS4Dg+Tog/Qe+No2cT6W5ZUjsd0C8m0AAegfjMCheQjoibLpL0cPtd1ft6iCAPQDQU9oAEXEM+AER9CLrgsjPjDe6yp8hsUHakz5wnRkrwwneMwCVlR94AeSthg+TgS/cUmdeCieeBmRM7BzeOaqe4w8OMGe/oXwChsLgNog0nqMUjHmZ5HuOipb+fZoaLk2Eu2v+3s9DzAMg7Yqtful4nP1c2auURqlRgLp99HcPLkbtJjs8hIqMAAZd40hObwVK7alsmljibuc4BQZw28babsPPYmmGRlwAFAWIiwt1y7RXPXc/w51ZYPRnhF46m+XN4spm2xUpZAHjzfGzjD1rbGn4hdUoEPRH8Az0vWl/ayh9x8wATa/4Aw6noPNKcrfMwnXQeQO+M+mRo3hWisFKYsHbM2/BBhADPORUGQr7APvALd3L6M8ewFtdYttRSh57ByLcWXuG4ABDneM5WJ3YqtJCphEFVubxUwqh4wFmdzQZ1BSo4I+IAgaENGbsOv1Flo7ag82Sl6FHU5wSHYR1kWKpF7GlipQAlYts5BoLBlaLmOoFDWQIVr65nYTWtEa5gFYKmLd2KANTebjgNuQ5KsNcXJg8q4KJtuJBhELclCGUOVWWw6QwAnJ9nUGNdqXH3SlFXx0VyxL0in3MJUxdbiOoQOxHaNQCNv/OJY1lK0PAeJU7vFF/KKa+JCTJTA+whkx5WWIqtANCLHgJkdzPyZnPO9N3aQBUgLYPU7XSybK9uPmTgun8AQtx16Jhw0Y4tJfw5+IuJNuUuH/+QQe+pP7nLckE+xgBBBUHYI5ORbebXfhe71l+dSDS2ixF6RKvjMCscTRfFAHOiYaaMBeV9HA9d3s08nk4C8b5DAfBZMu8V0/rZTakAL06hjqa+K8icRAtZkIJIE5WPm1jW30Py6cI2DBmsKgAGaVN5nfctwo+xnQm0drQE6+1GfMYCoyPxz0PDpdsPABtzI23zNVQeEaA4+jL81P5+8X88xvaeay+kWT73W2sAb61LdMYZi6CvcQVE+DhGiF1Xeca5EiNC2Lvq1g9XpABCgVcPt/hpP7e5ZJuKm/orWnl9NlrGgj8CZzsEUgm6AJQnRgc5tzUvTjZYPckQ78M4N7I9t3c5hAOI7BJ/IcMAAPLnf3P9T8yfg7eGh9M/Abg6w93EBm6GygAWbfTtTAAhiQ6xc1cyf8pewNh7iKllpE5Ymz9atNMW5jM6milVANAEpUkh6y4I2kuCuGvIHx8tP32GYOv4FzcXyTrp5NwAQiNST5sI/1L+LmfIk6r36OS7HixxNykUsvuyt53W4gCi91mMmjLJSC1Uv+X/JdwmrVktVBL+JxRZhqkJANJNAPnugs+/8Imqj3tHY63li0y3kX9uZKq6S5DSxtSIj3sAd3feqC7ZftoHrOK6UYHFiJsUI/DhDaROo4Hv6jxjqAB2Ii7r7Mf5Ar9tZoVjq3PxKY0C4R87XS3iNoEBZGwzAJ7+EDWkxTL0ErFtZ+e1kaDb2mAp+D8GYiDj+/2d1kgAP6gtlFHEVPoOQGqB0u/kK35+Cy01cZ68EUTQHDYSmAA8f4wJ4RK+m4m+Sv9rKm3nxu8BjmDbLj0IWNVyIHlSAM0wFV8oEgbcZIYkNSzDRd+i4lxmY/9qvPKt/hYSNkMAtrKsCaGLK+8nfGCfvDy8dAOMSWxqYFSm9z/IW8jUjwCumpbTQaq1pOfTI8p/oHq+9q0cgf6/VZGQUXodhvPiAOPCXJz9XHEFnLwibAPf4F2nN/cwzYMUfIjPjZyqBVwAMZaY8QF8BqemA67PfkvKAFU3mW+1G71PSQXHPnkpbAA5b1xU8phXQ6q6A4FBPwXAGp9I02ZXqTV5gVI0ZsjNAKz+9zZdKIDYZnqMOkF9P74VV6CXWV1bZsUphjlMYK4A8UW3onoGTYXkhe1jMwSj9AdmFrw54jMPturXRNFdkAC3PW2Y97wgAggrmSMnkNNjlSQsh8ulKkR0TKoBjFkeAHSiqrTg34TyU9rZ91rr1CXvDQZ12rl4BSx3FLx2/VAALcbd8a2Xg4IsrmHhmPOK87PQhB6b+OyoddoQLibeYQBb/OAPr+jxbf70cgqeUBLOI3smrrwqHhRVqZ4E21/9AL+Dq2tpE7NzhBqV89IFYSlIthLUtOwmcd1QAx/Avq8A74hyjw79JwvgEYpEO9wMErCFdgGKacVLwlRYad42NABRHZObl961LBPVuQqC8HPPSrdZx5DeGPIHtkkO/+2dAP55ceuSvBNPV8dUzm3dRKNDdRN+fyRLNT/eRVSkUqoAEFClLV0v2giZiL1GHHt9hteNcOQ3VkjDbSkCFlc5pgCGvPatb3t46xPSRRn7BlTc/+cBOUrGghaUBCR54Q2pAAUek/ycJ0e9/lPgdMiWac78ZZuyb7nKZpEjseZPHlUA6OzzpT4VXVs4pIKpzqiYvxscHZM28qki3hlMy6rahwA+BqFgnjqiQz2mikvjkTbKPVZEI9nDV+dNSFXQeKZQAOVIGHbgmAQkyGb5+HeQgjV74u37XDC36JR2yqw1/PoAasJqzb98I1ZIDzDmn72tiTr+GPktc/b4yEAk/rrfLQCWpne6tzkTlGei3lxTC0n3I0P+f7gHJfkngpcg5EFbADCGtp8XqHQvxzUuHAyTRGmgcg63h9NzvB+FhPKiJusAovZ47CbF4qutrQITgvrmjvXYXNukpfmpfg7S7C5J8wAJL5TDqsmLidXQmLVY132vGRFRXf/0FBfB0NZ/kkQAAE5FM25qlQLNyEREUJ1FBF0be/E1gPburuS8qJZLhrMAwrbj3Rmw2kWEmDllqgoVq+MUd1Nnpft4wHXbEs1IzwBZ8T8di2PdvfHxE6f+3GzoPFSxyLeRxdNhQKP0GrNlABdCc5ALs75XZSBHY+RvOwsaz33E47lldXjBYNVar1gAWlzVNbJGQe3elOZ+FVpD91E0FekseAGfvalEW/Tf5wAZumcShTMjGNUEIqiMHxYvacxrPHsYdXUCpolQGjP+AN2xJdlaUnQLaDLz4mBtYgIWmipee3cibdJGfDd2QsQAfFsp97Cp0vBNpOuHgnAwQb6OZV0enJUlL/pZGlQBxgAWIP9qrNdZCNYiAyq0TxXibqlu42lPrLNWjqzxikARABdyl+yxB+owJNBAMmlb7tzfC1GlglXKnPaKq8KZvLMAceU3xXeWpcGXtduuD3Rh++zLqHG20z5LJNu/kkAsdQAqWwcns93wo6LO6b/oYr667KkbOXnSBycoKaqN2t2IAN4AVlrfHMsLQfkSEMyjIMUtl0psvycFyjqporrvopYA5Yn8jl6/OEV2pRybKJXsZLek5msnNSemj0ht6R3lmABj+E+JHXgydvtlpHORe/eCmJJmoA8NDrgectlP4F/oAF6laAfhyRwOENAtQ/+jh+AdfFYD2koucA7C4qq8BkIAOZ5Z9KPJM95Kvx3K4SKSd2qwwAe2mF935wKAP9OjVwADDt61yvM7JKnanXoo7f+Mtd8bDsNLR8xi/DHHKUPjAKDAgbOLlBFvrHi1hv2/kczc0WA4V/73J3pG1uYlgaoAZdGIGw+z7TmkmatRBfzUKq6oenjUZZuLw0cJ/H2M7QDS3qCVEjqVeCfoO2IWHgNYG0ese9Q+cx3KFpZH/DX8AILyNdWMwAi09L4gW8d1SxHJ48ZZ903k7MhXJ77HBBAABEKPBzFDoY1gsX/PzhKhKz+QlPOxPYUYdzCiPRMbfgBUHDiaRLt5e7jD8LoIcx77hy9q/GS5zJ8ME9Tr+EJPANa4RPlZoLXpsFt65k6/kQSR2NlagnTIIIiuec4qWLUAuWZwdXz+eJ2n1rprarXAS3lctj4sZzI+lFqBWkCS8wAhTND/sQu31MQBXD9mmV1kQVWpZU/YeUJsNawwt42kAMoviul9BSS8Ja0pWjAsN3yFaTbx8MTxrJMmJl+EjD8AA6J7Oxb8c/A0rDkV2jiDoVR1EATIlWpbRzT2vkfnBgADgFBCwJ+FnRCxpBnK4SBNu02q5CHZRj2XptD4cebNAHyIDsNAfPVtm/8PGlMeR8KdzSozE1J/yLpNbGQJw3YA/8eg1Eam28JEU44GoFm2X+gb6D1+dBG+Y9xo9M+aRACcpUTVibXS5HXSqzHEFGCk2nbpm2Jc1mEpbcPHjBrzAMUeuzJfbg8mn1+IIlXOiudb3HJg7EtNOhSrIWpJynoAbFHbNpXQrWC4YwVMTtqpdiSF0vrW5CuYhIzHkVQhigAY/Z8ycDpo5v8ijsAeTQ1otVPNOfvW24Y10izqrU6hADuQCSiwbpEWCi3d3pFmjUSKO7jPCo0yd/FE1t9gvacAch+WEqjQVCRTzMhJ3Q2v/WpB6Z6cG2nxAJwIpk0kMAAK7Lavh545CBteekQIWOLDwuvATw2knQFp5SM5AdAeALqqUSgLkis14LL27k8SN8bDNVrXGKXy6X91FyOqFEQA5mjMBl+nGPgUm+h+9+bi11Nzj8QMbjOL4mJ1eIDGAgBquFEdfofzNWzziIE7X/GW+7lOABYlnaYAAcgUFuIeALeaHohCrIK+PqruXjNsX2HzIFbW9VTxfW13tjrqD48A2BGZOgbNDdo9cSy12fmHRt/TBv4RzADVm2V9YvThqwDON+xr+p5cgcD6i8Ff0ageHUTEsIcSI7Txijg9jU/4AI01u2i62EZE54/JjxLgA4XK5GX6pmLv3j3UqGRoGXAAWfy5jPh0GBhTcl7EVGw/fty0IHP29JZQIACLlnz2MgDzOMrDBUNTocYm2OUTypC+BsSruwGP1aZVivVfLAjpAFAmG7M/x8vM6bnwhmob/zKbmVHVkXQK6m8vg8Fz9ikA2vLfk7dc6BQsWfArtpa3pMyxwfbVq+NOiu2lFZm9SwAoMaPCdXlV1qcfV7XOoBnnzCJJXdgUfYcgWJ2elutNAExAzN258hBqU8brSG2gZIm9teSFUYz8iKC89paGfkcA4k33VwZ9sMVy/WFia5YbGFe2G4absHf8QUHJV6N3DAAwMOVB3aeKrItKGgz6rigHc4exyTdVbUR/h+warmVWAO09SA6g7kx0TF88azNngoEk4dvRevWCD0XzvUM0mpwAIB6g5z/aB+oVymMAPJ6PIE7auJW8E7+qvjzUgZ2A6QC0YJiCpE3OVx3jovZNBm2Yoc9itLtWrQ5wnjxPM9zzABWSnSHX6DhwTIS7ilf/1TS7xOWFT7GWJFkeXmlJ11AAxRbs/Yf82AiR035nUXxhDUf8dRmVmw19Fg6Mel7pgwAn6u+RgRHQ5Q3m6VOftglKPbDeASWUBYOLenYSkkOPAMvHNI3AHkZHQvz9vkZZJkX1hjSzSGfhkt66F9wEcy4AY4dhvTcqX6XzadFex6v9Or+mv7wxGOHqz6M/onVvyADcGVDVGpkUoMebi/bA6k+RbNQnSltsfOf9akAwq5QPAFHJg6OX7pG30440DnH8hptlkQLGtSTtxkY1KBkX37sA9P4wtkionnujmt8KFJu4JKIt9YUS1GhlGlTM+naUSwA78DRCNpKxaZY083paU8693rVOoK608W+Kfe418MZcACPjKzr2ts23fqSmAD/1HWijkqnI58MHwBrQeJwO82kAojOKXWp3OXUcnkRq9dsrhQNi4oxYkwUbJFuBtc77cgCdlQrsjWNqrupdcA23v5zF5/4sqBBBlue2tW2q1PRHAF7JzZft4kzbaSah/d3qqza/v7gawA+2r3J8Qn9QhnQAmOmcwhsqaD1CTEFT+4SVFJ03HwFS2uQIW4FSFGHVgwDF/ljA5UeibkMvdIAJlpHP4W1RZvd3zT7j9wqYKm0ZAKHXM+oJmuMQOfArX46LVc0K0ZTvWkqU2XnFysBql/8AzFvyXv/RdmH5RprGskRpW9ooMqy0uucGIlAglkpGEQC3X97soY27M0w1olCpRKnVDYpDufpJiva0bQhD697rAL1DElxzeMh01JMcu2K8Fgg2Wl1WvQcMkyvS5yA2F+4AmjhIA5jce6fBvAvzx7nWwc2fsMajaoIB26FfsjAOwQDOzhedC0B8Qtp/dqFh6Xy1lOI99h7UjCQSUe2gmlMtALelknQyiwCkgncPsLTMegHll6/clwhhHuOYAoiBRGEAxF/iroAWgGdkzzp93lvlYBUQcYO2JRq1ACI3IFNQhwA5oQXNvva8wC/+T7tD+n7neu7xQSJmIyidWjdo+g42AFPDQQL3jmrL+HUIX68ZmdoFiNNJqz18jwJk5p97rkYA+y+n5TiwVR8zAqtCn5XPnDgHTGiALuNhndQ5rAvd2AA16AVayuVA+vMnHwQt1fIjblzWCX1giQzL0bhMKhlDACtrBHQNgRnwogIKDH76c4uam2FJrg0yZkJBAZsA3RQAyCHfOKqdJrpx1muvOyCzRscwyX720xyhfhLbJ/RPRQCQiWRi01XwyouOlG7XCoRb3+vpggDm/pDZy+6+3UdPABoQMq9D8lLlBn8lplADJ9jRCY+vqIylyFru3XeiAPYAKVYkNxdR3vLDEvWG2WtLoWbl1Bri3xqtlX+QYS0sXAB5QV7VOrHPA2E/c70xHR3bmLm7qPLm46Z0FSyU9ZJlAMGfy/An+zhS0hUhWs5Fy11xXTRNhhwpD9m7R2kTz/gAcZ+m2FPpW70aZi/+sNe0AkeYmCnZOxUHj7SC1SmZ/QBzW6PJWFjdIP9G89sikHRMr5uDdvECMGqB/bO2fcYeAJ8/3LlpFYNWB83ZaYKnAJbqI9GEzswzJj5wXtvX5hcAklOCphdzhxNJCzKIIuMPvhDLGUE0CSnbBZ8kWLrb4wDuLUTW05Q79FSFdL60oIyjWPfqw7uVSYhgK7G+HwVuAKynPVE/Cc0zoVwdYyhy0aUY7MWU90FDx2xmF00adg8A1KKVX8YaxYpgFt4Zosnc+bM/vRZeGTTnWvnS2e3UEACxeHJvIHZuutSkCyzQDjmS+dU0tIe88pwy9B9lHsZnAPsjQw/4NuyfXAcxRvkE6KeJcKlTHkSrNOfF9OF22OgARXf6PkqQvd+/RlaM3Jc1nK4FS0ebi4LmIMmUXDAhDwDNkC0eGUMYwULqFDkVf7SkT2uVBc1bDmC3lKpwl2+GAKytzJnxwgxmEoBj+DURuMqkmHFrEfPTC7E3ORcCsp8AZT9mRmFv/HB04thy9fgUosedRfDfSWAX2isUKDOuRQD1mgHKUnsNAnBCL5M/WCWQR0qBXWsucCUG+OdG4idXACtTTV3fb683zCvqqPBPumwRsbw9jJA7q+qHvQ3UQCoATsNKeaFrQSKUw1VTWvpPi7x9RHoNRXM23IB1skz0LAAV/2F0aU37wjivR0v7PwepMO2f9GOx4N/1yU3Wmgx3AF7YWo7lftMVWEiDrfUIqsXAExLuE7CKva7CVhT55XEAXozo2AK7g6wPaS7N3LDRnmku5SZa9faEZdRYDmpXUgDG/bh8cJgylyOelHGEMqPdp+ajXSrH+riWBU0WRwMDAAmWA3EhpsjCdf8kml9i4EnybxjZsq1QsIyjVv2zDe4A1cjc99BclZZ0MN07SNFZnaeOgSmxWPXeJdeHlEoFsgDP/pHnElsLFny5L04RpyazlqIFhaonSH5K/0sNh0QxAGFElsyKqRH4RHH2pnxOtW83MpDemygpP5MUiuqO58kAvLfaFZXqCyMAqKPCiJlkN0IA+LE8YEQFcsVIgj987wBlz6Sv5wWMK8MWhUB1SAZdR7IpRAoZE3dq+R249+dYAPK5f8kJdIXNkgkAdl9TT3cysxLo2ytiwiargTNoQhwARwOC5m80Eqglvs+nb8FpPX9py2EIRBXX9d4a86De4gDxyWQp+0QmSsKOh5uVj+xQxThn6qxtAv9EhqpTut0lACgRlABkqDVpVn9qoi5ycfesH5JNgS2oAapfNqkV8mEAuSgmHHprGARJAzJFlmAPGtl+gLvDbI+GnmAlwMZxzwCkJH9+MGwM6lr/18tQtD1GLq5Zrapmq/dKCWCOnAEzAHlI4LYVgqK5bQKut103jMlLvB07WJzrnYE21NukO6MAV95e9A+Buwv88eqthtge5bpdHih7m0uQfx0vKjjwfgCPKx/d/Jxld3VqvMtHJ2I0oMxPPJEHpauwakCXF2zyAOjjpslAAfrZXOYeLOfgg3K3xuRjw+Ll8n9vpoLtGQ0AwgzR7tSiFYaXXW9GjmJL20MWLJioqDeYonSu+DAqKwC0uBznpTyDlYdnpik6xFqsrjbr+PICk4xfZD5lnQMVALoIoLxG/0EIt9xdvo9ut5d1agHoplgN9PjMSNLJf+UAewiJKaGhp+Ggv3NgkWzbzj1ymeXHJRWxuvu2XjPJMwDbIS4LqRPKyPxGPlRTcuTcoYim/FlIsZSvPRmeXY7aAHkBMCdBrqSIgK4ArKeTzo7ci5FBFpIZzRxBpDJA4fYAE2MK95QGod6FTSem8Gf9EP4EU/PcXENqzKCjhWvV4wB7JuniqVPgIjUnznGc8Zuw5si4xvG4y4zMa02zlVPYAFENrXZjFeWiQpqqbtDDJPClSWHZCwlXAC9gRQtthloAFHETDxy7MQmrypUgL2a7QBfYc5HjGwYnXXH54HUuiQBsVTZIaJIP19mPKjS9uZwT8KpK364hTZ9srC6anYXXAI/ktNZ0ByH7xhioA0XcNlgOBC4LlXtNwoC/YKbv2rkA2qKv0T5GzXcShx3hg5UsI48JZ8+H/Sj+OYIo5+1tagDvnV8vggFYqy+v0IfDQcQyf2ZiVCmKtxk8WCL2+RaiAH7egbJDTSobakLzGSDm3q4XPS4noNGvDKC+V9CcBycAM88S4Mc4+CbjK3TR02W3Z3EwN7efch3pWnc/Aqu3kADptrkIgwKYz1fD1SXSP+AJHd0n6quDJ6EILs8UqMzNAKWs2me6XO5YVk7zyUarOEpoKcSqau64UQa+OQD3BdcA4qyoTTB/6uf19hVBQNzIg9wV0ZYKNTknTUrsz+ROigDTChT0pazwy1ChJ+dRJcYAcn4HSzBtnLPVlaeSe3BdAPUgC/V2uFPJjCdCDy211Wim/Ol7UNZ5EU+D3H9Yv7sAIAVXB69KRe7F8pY44vT3w++eIw/XGEO7AphzlKVzzQAdvXxP5/79KjAmWbPumT/TjBOXddI4axm3zv4FsQJGADrKNGy/80px6uksoSrsWiCIqmVFliLcVOpGmdWc51EA1dt2Zl6ywthkdfs5dGwFh9z8GwCAIoId2wib4XPs0wCAl3XN4XlIhMYxHmx7BNAciXb+hsKclYw2r5gKq5WQAEUBUr4JF7Tte+zLekgHZbGNKPJtLRQkjxQFmUxIFNQAvyZGQz7XM1zc4iT7YiAp6ovtr+GZq1T+zEgYY5xsNwAS1W80cFq2+SIqVFCI+8XlQyjvwUKBVyqhkm13oxHvANjVJhkt2hg3503EYT6ogDgGJGDuYQjDI1JsGAsUHisAAI91HK8ruUVETu83dLZbIxpbh2ejO3JmICvWkOvquABBswKLeqNHuSGuED77HgNlMrS/nyCnO++FZFvINZ6rANz1R1VETkHn1Oqox6n6DGEIYBcjCaAs6jfFbtR5O+UAAnw5BvJlyOWB0LDRfHKrEnYog1aAk3cNHzHAlH4uvQDaSeVOlI7d0gzpet1f1vUh7/GkjS7OH7J60BlCBc0FAB10qdoqgqzF5Sy5u9f15Pd00L3SqhFXM3fizm8yPe0AUHNyBRNowA5f470KfXNpWfTOdZ8ST9dr6ACS809TqAAFdObNXsXp/alpeVNs7pkXtksiSxwnQHAM6QIkRTntAA9ge5yBfoFxVZe0dSyeB8Hp5nqXCLZzQZwQmFydoJAA6fSy4hylWUdloFaApV+CKbuJXW5edryQKc7FRISQkwAPAK8AjFWD2mPEeTastsQhYtJiYp3LwOjfcouEsUNQAC6Dz4PJyBLOe8dB4emFlIpIjOYl0B/s/+cjaQzjMxoAfzj6uY9iBfdyb2ISxAESmEtKU0A3s2tuFyubBqvaZwDC5z1NfIDrVuMOnxNml9T/9k2yT6lQzjnlDV3YVU9hAAdA+Nmm6KHUM9vEcv1dVCqlv+LXRu/C9OSWoiKFoCgAZb3uPsCpr95URV8LMA6DGMEHCmIoXO0T2HhQ32FqvQCxROn5JR6aeXpZ+DnsVOx9ii1w/LyxM2Q3AYXcxo9/AKdimgXQ8M4oyYuY6ig/ZDC7iutW+99822KSsLNyTs8AZuJsd/iXo6Fh69KSNjpaY0K2+fW22bD0Nn3BgECS+ADwwrGh/d9Wz/gIGBEXJUNrzrkddEpNIJ5DTgD2339sAIrAcOsUr0jb0S8soNzp1Elfc76gf6mTP2EPHCudzIAAArc3OVB8HYPulUZtPrw55b1Yx0lDS09hjL0ltdEevwCm2g30U0G9BLdDn83g+PPb1spTRXSh7ltOhzkuazusACAxyQZYhcE93pgRLempkH8GizMLUo4PojR2QpUeWMsA0Bv/hud5NdixG1UVQiD7qEqV70kyQ5jOu1lxDwDERgAUBCRB4PPc5VIlX2xdgaMuV+p7QhfMCcQ5Cei4RBgyANhV17TsWmplo+pdofnDsv699DNB2jnWpa+rNNxedf4AXD10ciGMhR/m291fIZ0ce6bP5i6HBXHXswEr9PRr9AAwL8mpic3Ku+Sm8qyNQFwoZ4LY4MOVmPR41vklQ9eBAJKqdgHtfSHfzVfrdKwdR+2zJQraNLuGGPe+LB2wtXQA0bulys1+QsaXUHmEerKNJYTz6+5tX6hQiD0FRiTDbwBRvPOdxJZKPlc506uYT6AeD/2hcYSy/aNPVB3egeZVADR7oTJlBZ7iAqK3CQ3JSqbauHAGzxiTbj2euz7DfskAL8DkTPcyzhOnVKqtqmRiUSAQfZEyff0rJPMhlRFSxQBPzyfS2TVZA5Xt+M9hRjC8ui+s6Qg5rf1XVxExQCWaAJQOkpHmbUXm1c7x9JM+YSLEL6y284g/oy7VvsmTYf0AlGmi7iZEaiRKSHoREIzRrTOCQIOx55mp4ExqCxAYTQDMwdttUGNc5AN4bLF1/aStVhxX1fVNIRpKiZCz6v87ADpyCly65dr12s2tM1OybKtHQ3attgUVJONk2J9eyfcAgmmuY3QsPZ5z2CLm4btLSjdAFp5HoPonMytHmUhYfwALzs6cxLCuqM/sDKSmX3PVEUnuaYBOOtsR8MapSVeNAII+ODhXkavcwQzB4xv8dnEv6yPeEKqeN23TtGqAwy4APpyFKpVrGK1xCmIwxhDCQUJDt2YKefVY3QFjDF/CIgAk7SUIrLkOqutltgsXEKxBc0ZRe8xwTvEZH0hOObh+APDdd5DzlW60AhYlzXnATTamDYYKsvsRe4NxqZXQ5QkAB973dGOVUR1n9nZYjd34ECeyfu024R9eglLyH8Wz+QAAGHETk9uOsvHEIcuEeXvtNiqW+uAuaSiboGYTHdSfALw2+borQeD5+KUYvFSwydP8HPgBngGq+xRKJGRp9IEAB04xbDtXDzLi22efJJRx4SNmla8P9VrT3+BPmAvvnQACIS7s63hF29nhc2IZUW69nMnimwaofwbewlRVpfVWAFqORM8Ff61P0vcFlI90Wtl5ke1gAqa/DIgUS8GmuGYAZ2vM/q9agAanWWk0bwDDDiueZo2UA6wLYReILwKWBwDNGnD6jAeMY9VkFYP/DoQ50NmnELR2HPsgAzvWkFaxACwHIKGNvAkFYPkn1Bj7KHdqqyaKiOx/AkkuDPEm9WMAGX6xgxy5U1f+AJgv/hkmPCd+enV0VTHisTksxCjJmgCZgju2ga54btYTlzMgTLJQZJks4rXj7Mzni18P5HLkAK37eJjCqKsMEG1cHlZG9TctNqZ/fM5g9dyZBoDZKusArR1xa3/YAyTItWlt9f87Sdgax4IMsqRZRGtkFz/vqQBJh1IzPmV7E8UnyI7p11iE9ApM3b3697A2XAEzNOMcAEi4iV2srQ35R85KOBJAhNt449zMalUvQ4qhh7OfxsYAPpI5fsLZHY7mIQMFhSB0UpEY0uyFuSpVjsusWdzxVgBoghRnzj6F5fqG0OklMsOiBdraEMafYyGM2N6osBQ9ALUzVj5p5GuMu/YO8yIt0DVWSKBo+sIqUjNUFiQVC9gAtbdQohj8FZ0AVWAPQyCaxPkaglymX7fQYw6luMX0IwDbPvBUXc+NOpMLcwPpAZGVfa/BlS4yxHmwIhyJV+d2ADAa+0qzFhWSq1aLZrpJGluJQoVe0eL8tTs0pd5Y6AkANZAgns03nr8s5/xGnF2IERBrr5e8uxr+DFhtBJ495wAnlLmb7Ervak5p47RQGawh8JHYxw4XOAxh7vckSNrJALizvB96KVFeMyozjCxlRMx6GVpQVw5qCP5RIflew1wA9l1Nf8kE0bsfSJIv+4pdXPQDteJra8sn7kFUDvyaTQDXwkHePucEcpBzLbYM9fEITpEj1psKnBLTvbENn+ZiALuWZl5ESSvULz8du+OnlDGsyTeU8jmm7XSmYc2zRAAAowNv4WQ6Ch3wayz9R2OwWvIHbcIngu7RaBLwEeCxcQCZ/ylEsXbI00dmj2ZnLFMZ9bfRKChPhBhaqVIYWMJKAJWZFgmKJDneUdute6NKsdcy1RalBUdmzGbqYgO5pxQA5bsSYVR8Hamvk9LRrwtYg603pVVMNG2a4y5wIF3kCQA5t4BC4cgVwMkeAgj5zu+556WlW+yvWLZNaJb9DudrAEzb1D14ea9vLzvCkOVJN3HyZ0cdv2by7BoYJcUxlWQAUeUSmjKQdPqAno4oRcLnColyuHmp+oKQMxfhYyW4PgB5jPPvlzhk41vlEZA9AOijZdoh9KefndDUZYYWeZtWADGc4gt9FKGEAwbrAAf+bdE0IiOFEmOUWVxjjJ3Z/PIAzRKYKGUqNXjF2Pr/iNvxx2gQPY8skxvQM1y3nrpebwBlM5E2TE3WJlYQw7gb/KDBvRWv4O34nU0j3wW6+SqLAFtJ3DD1i78NNGT48YJzUxRWOF9sLmYgR7tdX0IIGlcAMa1dxc3wsfRasF1EMax+Rhcg0VbYPymGoYLNyMzfoADRbtWLToDfKInlcPzyY7kwjk2NnSacGisEnrKl1tr9AIGBP401NzFh0tsnfpcAbapkyuGri0UQX+d9CCX9psUAnlNfRjd83YYZ2Z6f3iOFBLK3l0toqDMeIp9yZcWbGAA9Z9xqfKT5wB9/b0W/SU1utB/9ymvM7ESDRgB/ZTQ6AG1nLtxrWJTa2KB8OkAxQD89dxz7wvsoAykHDmRLzW8ASL31cFkKdDliIyH+PUR5sXyYWq6t/nUbV7BVn6zfKABc01M8ESm4czTkcXxkOgSUWY+jymiVASQcBgIKtYXoAM16IJIJwO7gFbi4+Fydh1AVJjjhNsDBiP7WBnf714cAIj23qtrBpG+Hr0RFZdlXhrVHQJOFLRhsE2/VWxzJNwCVHo4x7p99JG0rU9SatUFtLgcQWxg7L3dEg1tKl0ArABi0ghva9rGwgHHvWnPsEDHUA1A+tbepuWHL/7pEzswAsdCQei7/H6V57aJDNBvXiE4Ua0bBYoYuyZSVdn/WTwB8tbSnQjsOZjYwVHYJ5YbZDy8UEMACxwkUr4A5ZApiALcIMyt9vV+FiaRbD7O/io5cI6i+V5Q+tbUnrFTjUiAAkZDoj3OpgcMJYlpl21LDHsnIzxw0I7SuuCZ7I6S+KQD4CJaQDfqtMC6pxp52tXZdgEXHeIHFaAExyGN2bqh5AIQ2TtjHvpiRH8SqYOYvPxJ/ZdXAWkZMMb1tDjs1Wa4A5L4W5TypIsa1bi3v3Lg7w/PiewVFEIMxDugUfajjTADsTWmGVjqkviGVkfgI95lRt+rC57Cv/hvsK0gQfRTxAKusNCDqh/oAuTRBnfQEfhb+CPoOS6cyHFuyfQNSlxwA/i0165uIf95J9Fc3yca2j0br6w2Gwz/mzuwbHAUwVAClwor42QxaEfnTbHoUMU2wUSEP1DLSwfBc1NxZTIkNAG4VA5IEHUbh+ZmJRP4DRMbe06GCkt9n4hKrbWt+UOAAZOhNJUAZdPL0cTuhNnBl+a1s2a8h3qj5HEJP9W/a4QDA+a9A914lmtrgoFmbXGMhLCH2SHvCHT21v/XuYVeiABo7u13m9soVQtQpu2yxxVOhFy3za/zhPx0eC13R4xsA/KvOGW+T0k+ODNf13LcUuBe3j0ehdDEom4RroBaoHgBuwE2VLrOfixq/6CcIABcnKphHijcnlbUijPbDBHKXANABZEMv5jAGvxY108suI5bNeJ1VjwDr8CNBaNGPyF4A/F5Iph1rGF7WiHmiYMZd//usg4lviiFTWhZZMYC3tACLqbo9LTblkLy76xyzc8oQipmRDFnSphf+ZzYh2C0OABiMzSbOuHnxaCXm3iKKf5SyQtj7IOVdT3DvSQGLR3EA0NOv6BlbL7fJ3r862UQr9HcE1pa/RoBwpIUCUUVDTABOq7pdqSzqq3G9DfWxlyNTRVyqc+XH3thRcxRmtpD7AJ2i++dlVhtZ7fmpkT/bxrFCkOFu224qDCbeKp1B2OoAeVlTeOq6/cliOhZKZJVDRx2zFxbyTU4/v/YTd4u1ZABuxuA6cwN/zl23JZc2blbF/yvznOQhFED2KUl92BE5AMJflEoUIlocSRLnAQ5av88H7Lm8nVNFE/FFwyPxjFUAHu02hS/Hec+DKFmQ2wen3R/0O6J0fKqWHxFatNY8hAD5OPZ/OnOKdXOxNFJBm5Lz3R4hynscKf6uGAcwZvyQAIG7jBP9CPXIFRJyaFjP7qZNXK1X7rqZe55aaAKkXbMAWOcwyf6y/WqLN0IhAbEg6axXSjcThO14wI53Y7FNHQBBSCpMUyCO9Ri1xCoXuC7jC9Mt47s8H4ygPbfv9jLYAK75vUrRv9BKNuPGVZUspZPeV6j3zQd+h/mSgBvD2tIANQ4cxwWmY1m1Qgte2fg7EtFoE5Xmlf+rFAEFhCpDSQDPCZgx8FQpd3uuw0vsNb4nu35Wt0n/I/KMeTO0fZsuADhA5Tf4HC1yr3u84frobszQAmAgvKNRkh5HtotTN/cAoxNLDMXuAnM/c+aHcFDaKzZCfvi8hcbEFSrTJpN3/wCs07RWY8fPUNvrg6+2J1TMD3NDLlM2jU7nV7yMr7OBAJTPKbSIrPY1OklZxeaGc6LZ6GcUcEnfkM/uVpzRYfcAeqe8V9MBfrqYrbVjV3Y6EBmn5cu4g3MemoO+Gs8HJgAEhNipoGwrk7gbhG8G2EnFdbUuz3vqDwqSr4ddyEP+AA7PeWAnl0foiTYPZPQguzrKn5VL12k7Vn0wDtxqn3wAZHRV/n2+AG5qLUpnzC2iikpYRvMncTJn9kNiCj53SwD0cHP7CmUXzzMWwx0/sB+r0W4XC4+mMdrn539j4v9JAAOVaoBR2r/OOdnQNK6wgJzTmIbcIDjXurGniODGtvYASVCXPVEeZm/RJnanKiSGp51Tr1K7DJn21nor/y/zywBXKFlxfEYhQD9qaUtn/MPfby6Iv28Pau8u7DCkjEtjAD5ctvyp/8oaWsE+kci9EnxGP7WTngjJgW2MSJx0e70AftkLc41ozKuqGeO+ZfmljYG17DXsgwrrD1XESDpvigDc42tVdn0yoOXY53ncUd5vDMrQceGosOn5AXRzhK3hADIKjTYU00E5ydj5PZW5r7W37TJafxv9/wJnhi9Wg28ArdJ6o5WCYgbiPAtKgHoN5ZNX+2e+nRpmB0Eoa+O5agBdxIoeVX18Nzi+0nUuFaBwWtj3tRObQyv83yBVUbr4ABr3kzhrLJQp9aYoM/jltFxrRWXQqTY5yPSc0/MPRCoATOqJ1i6i8ODIFTmZVXD704u4MV2Sm7ErVroefaCwCwCF02c3zTrOs/LlgGKLuP3M+jiHdgYpIcVLEVW7Yey/AIexAXWunnVYkQabVDQM1h51SsX7zWesjixCakutuR4AihV1kXk0cIqQnwZEzpcVpq42azj01HMWi5DoJdnNoACuQWrhIoApaOzNs9+EcsKT5OcHvfX8GtiOKPbn6gXyAHWmnhK68SnH3yYJCf0dWlAnTkJ+/De7XXqxq/cFeCoAK4HcRUjAMt+TcdH0bdi82DbJ7MFrbnRHyYTDQcL13wAIBpJe+sj5Cthepa9M+UysfTyT1Rliq/5LRy+h/j95AIquNBIs6A8AUv+o09ZVgb/r5V3LC2Uuw1PB5Upebh0Ax/1POfS84nvHjRFoZI7ojswqz9iaiAD3FfLNgWzPvADIrHpUFZj6nMBtSGj07wainxd4mZxukXhcfgeRaCFfAH+PB9nbzFLbjTxDMicQx1VihxEvf/FCZqaoj7OqD0QATftGyC3o4DrQLytP6rfslAAMPNUA/LZgMjtC/ARyPQBbKUmBexQERRBH2pyebHuUfNBNgloVSRs6htzdJb+XAHOY1sewFmWeJwkM7Ri2zlhWzVdvdZ6PVLNpZjy75OMA1lrZgNDDWJGRxcb2yQ7/YVpZusBuFxhunLq4vllRQwDnE8++3vcUtHIv5K9j9G1aAAFNbR4fFTTrUmEs7x8XAJ0eMvfTpQwPj1yyPslwG7+oxcKPgSCr/jjiM9KqWmAAWBFwKGT5Nw+Pnd/NlJyCXOV9yi6kddy9xUOqmU1M3gAE66EVbnOt/c4py7tFzyRPadY7zGKyymfPhx/CYxt5ALgtM9hiO1FGxYMPw9HXjT44VeZhlwaMOAEJjHnvjDUAArLDiutnaoRi14oXIuctsKhOBe9HfdBl/c/+3BYUuABdXP8q5vjideJ+yk3F3FUdsynvSwvgx096bxH+gvW2AL8EwNjSyfVATq+efWlrP14cesFVcqh2idfK5FWjb+8AZTqvIap5+3Ids3STaDL9+E3GBDUiNWa6ifnZsmB6/ABoXScVo5AhTNvTTxA5sZDzwBMiOzptKjv18RP0wCWrAM/RRNmVlqRehEtCcmAqv77gYyDTlaqqT6igxpHrIk0Ak8JQ/hGltMU6fKNFUTJstgCFwu7YHKNY2sE7oaFNQQDadOso8LAwPm3RJWS1FLpx0Za4qK/Ak5di/P/Waa40AKybVWGmSyu+fReZcWkLO48Gxj2o6wepGFIQr+N1KQoANA/wfFGX9+aGFDPqTuxAafIowa8Zztnwn+iIpG+6JQDpB3OeDXtZcQwXA3rRIzVQ/SheKKpEmmAnl2tCDkWVAO3A44G82CB2qVaGf+9Lu3BMoeVF4vpJdTWQE3SWf04AdyuI4Zs2UnnNtTNi3aw83x3iyCH+KpFgx13rBnE60AC326uqzwH0oC1MaOKpvQFbJGhH7iuTP4lmWi5tA4LQAHVHzW1S7rTRlX0xlstN8rpViQXfM0TOCU5d0B5UiycAPKIaKYU55NXOtOI5DnZlQJDAkb0+RAakrUPKBKSqrgAMwyuv5yz9MQ9VYTaxk+HRH2kpIvcARUlAV8wMdlL5AFGcaSxgxd+QpwyR+ukza+VfaKci6rZFGkfJwn4+JQIATxvLNRaSWMagQMuMFXx6dfbhHTHDIu+6UEVPYcCoTwDSiwFWo7Mn9scu0hCCMKQx03cf4rJt1eK4Lr9KT2vXAI+BCcJ3WKQph1QqCIEPjRb47OdUaivsvzqTxE5MryAAbC5Wu4jsa7od99uZUjAaRW1dyBoqn8dyMfPonEWSKgB5atC5LNnsg8XURiUjEwgSrEpYXA1ei+oXkjadE8VzAC5UTLdwmNSci23uSlmlMDMQ43SvCqgFuGxyiilA554AOnBaZmldPencOxRZ7G3hxNXxbuUrO5zcWI5h8Q5DjwC4hMRm54zlD3oo6v1GtmlJgOtrbfzDATK6VJ8X7KS3AHCib2ckpDxbNRP7mP9piEGqvv6GKNMU2ymGGHkItIQAv/W9V5Rc1GSzzzWtzwNK8/mdPuNVpAT+B6mLKwPlBgDV7wQ897sIWoAndj4+7ZUC5oy7TwPoKuuakRQKdqwZAEQfnZFl0bV/unZu+f/l0emz6c6+2z4hEoNP8Q0+4JgAhanRXbCyDOIfKmwVXPAEQYMpUVDsKnO0EFDOycXqRAAmiJP5K79qzYp8wyTy1Vr5Ex/m4FlfUYxHjr/r3QgCADPPBPZzH3E4SAMlwd5kjAmfG1kmiVxU4ZDGCfTGEPUA7RL+grSJNRXnmP8jGP0ktkI575s8PdPcIw9Z5V6X2gD11+UITybTvCTDeE5r2Gvo09yFdL/Bb6SyJjY+F/OvAKxBpCQgF+EKBygSUUQlT4d/4Niom8d9+HQQPauL7CoAG10lLvawL0UvLT3VQiCtbQ2PVUa9I3dxBXDaZ97QswBnggkB5098slul7bjwj19pegSEwdpVVyQvze/rbnXyAGfxUfrtrStb/kx2T5IleExTIVymQTkXuMvWsQPgaFoAhWjUFwDhHcMpJMXZuHCSSKc5lcV1PW3qQbgc4NQARADfAQEa4UKP4UMQ6b6iyr/OoYjSQlDkJMamewGijQ2RAOn2OUWcEx9d7irV71tULsoSPrEz0Jdr4fOmLVxA7Z4AJApKuZgcpBwIoFoXWoV5H+pEiWVqeoeh3zf0uqiOkgBGebd/cktv1q9vzTKMR2uq+ClEoqSsnOSeBEZLKHYUAE1fGcDWdUzIDwCUqxepVhj/ztYKMiRmtlo4jiTxJ2sAfwVZZso/TIrdQvrK2qKt6ct+nyE46IVfi8MLWI7G+wBTAGCqPX5Y/IKq9eq4gz51zdAjzAhGRiuFBYEBdF6AACcyuUdSdCOkFuwYmQJVX27s6egQFPNOxdPRujNJGLMA7uNDiwyAjznVM6J8NIw8JlG0/3T0uVqOWhmodN4xGQD0YUGTj+XFJBwqUTS6+SCQnCkw24YkhpgJRUC3N89/AP1isZZVhp+v9cVOfLyuMpPsEvqqjqkLh9S0L1zETJIACgTwZvIsxkBLeUwd93lcWz5rAxLWiDHL0pE+cYVdTwCAPMC/arnY9YHKGrXD9hmvoTOOe15E4pv7MpsEU3bHAHxA0YoyM5NaYbH+GGn46bSNgkK97phtv+mm+/BVYlEApdyuggdc/+Gpz+am+E4uXkO3lWDIPp9vQPH7laHvdQCfa1+nOdMzWIcCtF6ymmEDv3SbxHszHNXFxxVi1/quAIEfahxFtnTqMvGWkXvDOWhZeFUGpPd6gw2J3OYUEgYATmA+hPf1SPaunjL0s5F1b/wLZU0HIxPQalPm/u3b/ADORKnoElhqQF+K4M34i8pVtuhW+JH4dAhKr40X45OBAOlF8yVOlyO/LvaQqxZMO8gSoChwxplyZJl7kx6T50EAXBS8ffbgbzPdYRLvOyj6O4W0A8Nom6p9cpC7zohWHwBB1K8fQjFwdki4FNv8+3IuHsok/hhaLOmPuOFoWQM7AN/MJi8KthOT10GaOSH4TkDMFR4H5l0q32AzWPhRwzEARJRXE5PjJ43Yg5r39cAA1iqXIG+1MS4XyQvUuXVe9QCZBX5moG2s/NYVHrZyb0t4IiLc1aJTWxvTMCf/HPuYAApkB/Iix7V6tde9WJFb/6a8sr0zM8pMhEj8qkbFnk0AfVx6ks9gu36bwPfSK+7/DN6WUx9Rk1n3HepWJZzLxgCvb1gNS4M4iCb/k5rOGVui4s7Chco5rAA1+iMxRAXLACiSRdaFT8BTdo/J+tvb6hMBDLhSg1bMQdJeklQp/AMA9SyE1zA/bTbvn4K7UGzQB8uaT90lpL3JjdeGW6CZigAJ+OsMxWvAYiIMlYP0uz7QkIiEXToFac87pHtrGRjVAPBgX5ClVs2vwhFn2EPFN1PNyDOMbrCIGd6iHFeUOG8Ay3U2B2iokOM1ajkrHf1cqZ0IJXyXodfTZ6hVnhtjNACc9u6As94SOSBfpbva4P2XgsnxbiLnSZROOy6gg+KEAAlMVbR0+rpssC93es4FMeMS86pKTywH1BHqKul8E7wAuqFQQ0kxb7NWXzbcmZWkmDTuRQx8PTVr4icOMNIanQCzN78qNkKYfWglznqKtNNhqiYjz4N5ZgY/9dUaAw3HAJ1NttVQHlgqeTG8e8Oe7O3gwOZ0RtqOXYPjweO4Jn8AMjSx+1qd/3V2z3ObHhCgrpS/UAqq2sZDftIpU5xBUQDlm+9Ba312/muX5ogDlSk5n2PQUbwcbts+WG0ytk1WAACbxY4EP64bPy2xFJ/RhxhsFsJgFdfcZw70XYTU0BAAUMmT/MFZIDQPC6sLDqPhW/8OenAvbNFkP0kTgFHXPgCdqV85XWyn75F1DyV0fTdm0fWTJzz+dJM5u31R0kegADxMAn48Z6FmqHTa/UTq2YCygFOJZHcWcxsdxv2nUQsAWF1r02/vHpXBdtHl9zkwnqFSN9JmgFsO2eJTHRIV1wD3bSWgRkVRJ8mKYThmdq5k6r4oRlmOVPR6aaAaJHfOAIhuSjS8ydw8stylSZ2Q91KEx5EP5Op7UJ8/EiFw0W0AmEq/QWyiwuhDjD8D/PK4oCQqhmvnqi6JZ10jKIUGDQCSAXaADpezBnZop00fPm+ICtWY7Q/LdmEw3tmPHQmgAGuHrsQQ6aHhzNqRCSLdTqLbkUv1z45VXSWAV2783aEAdKL4IkaabSi9L6eUIkG8jtfHXEYGCOv4W8kHSIZwcwDVeGf9MzTxTzG3SW30NyJHOtTs4owsonyT1P8LUWGNAHqgb6KweD9dQxSl3xOe4LS4lm36xHJxG/k2w5nBLTEAC6+f1N4en7EFwJ6cXY+AdaF3LBQjLift4IgbmjKYqwA2t8FRYNw4rge8tj26LCp460to6hlDCKxCUPjUbUTSAHjtPMjUBa/TrOgb3vXQLgJfJAJIedrOnPa5/R9luPEAYncenOWT9IAxLy8lOOe65ACqVjVthLdec4Soo6ZPtABfhmal87bftBSdaMAhEKii64lvLZDBEo2CVn7GV8zHAOAuaxaVfiSd5tFbcAiSotvgQ7NnxSK8g3Xi5nlBRVoADE8PyNSGaWJ0X2ULiURUfQ6aEOPcrgZbL2WONkENnwB+U+zsMYv8QxMdm5bXTDfZ4vfl7xfPbDUTLrUPDyrCAPoIBh9ybXoy6YKi56L6hySBFUTAUIEwbvdNTgOd9fYAbpTwKrkn0GrhXP7wVqjZtvKlYTFvWdg8wADQCYnA9ADenlkC75XOftHh9VP/V/A3+xzGU3VDqRkPcegv5sgOAEDTFYD0vRTDrkY4uuPVxcQnvBAizPee4ryXwoA89okAXVSMGTR2pt765WDteyNoVEV55NZicAURbt6DSPHlZABWoAOcQqRuc16kgfV7Mq+P8JBWOKe6oLHAlSu+yZkhAIz+cerOO8DKWfXa5GQwboS7tDW9izem0KF2lZm2owwAbWtVLsrR3wBpt2InFNqpVxmr22RhbyBkHe9lColapwAwM3HFQ6EKqg7EMoGMRDYkq0f4XzpjQWgyDlvgpPQsAPyGOo8kYaiMg1SDhl8fIhjgKzzloeMeA3cKXoZkMW0AokHEH61UQfPHblc7WdsBDFoyDllRX8iqbAyq9I8HmACr48r8j28fnQcaNJChdDetXvG+cfNnkIgYV16ZamCVAGXx/eladW2LTzz2dQ906AprRwKrHbNsZEk2NAnRrX8AKHitk6NiahnWCquNOW3X7H8o2As7I9G9O+q8rmStjACMRP643i+b1BpK++ZrEKo43qDyvyCI2SGqGF6vl5ZqAFmDXy+ivtobDDruq7RwgChhaw4L+vBGQJ6zKpYIA+gAZRIbvZpyjVZcjJtJoQ8HJrFgsJnTAWf5f9Rp752yAABpdD/JgDguc8GNwX664Ha+9lacptVDycmw+yvg9R2IAAFpCrz7h8FfTKasWW+LxkR632XCiEAC1npGLCrzmxsAYWTu5PvQkQZ07qjGZrbioFMPkG6hfdJeSHcdkmpkMgA03GgOZNa8BlnxKOgyx3GQr/daJoWny5yA79uECikrAN5ap2lgQzDTt70eXvfGTfGrtHZZVJrWo37Xopq8AloAXyg0OfIn5vHsgvbGYK0IDHJ6YQUSoA3e3Mth5zXa5ABP7uWdvjUwDrfc4d4oXBeKkVk6X/ecmkfIYhtsSDGPABzOn2v4nRM4RzoDgUynmZEX5MyhfHP0FF/tKqYobJUAXx/cN9sYwqzvqeyoAs6VrT4KjwIHgtGTVy9oJAQJTACQJV+VECWx4TAc34T6GhhNaMDr/MMkKWtZLepUDp9KAEM8KsCLTQhvZrhT0MPqYOeSfaeKKPPsDIAh9WI2QdwArhEYA6uZeOZZ+KLoMz/qONa/PdRrNdppMkQeNZQkXAAbJCHUiNNsE+Vp2wQ0DUUYYkGuw7EiG8+lY3tHbDsjAA42Ag+BfSLxF51iqnzry6gK7N6z+tKzRBTvNJuA8x4AsP6uLMAugStHXdF9A2/a8+BWp6fcI43RXvEyd2n+oADjB5Nl+B9+sHmavSfWkBEfoStwgr6bScGjshBzJaFlAKVZ+JhT9r9oEF10PngStNk5pViOET/1cA8QSAkKQnwAoISLOBMNBHRMYoY9kqcTWbHl+rZwQJeiuSRk5WNC9wCY6y3/RzyUpx5xlYiuiDulr18U3b8nBpoiHzN4M/u6AH2XTxOuJZ9xtKeIaBXJyq0et9TMGkBA3auAzZ92lQwALfjmYIIA2VN+MW7KrVztKCLS82LTPBoz1IIEvHuIowBdIQWm2nprCxrR1n4LR/jhsEf08e73vkFdoAPwZ57MAGse5sQ1PSwmiJP3zX+LKKKLwIDUpnrnhEVAmBa7xn8AySgipxRLZzqegDZtFL1s6GFlkAC7tOyn7JNITen4hgBcljmnZ4VSEl+GUP2tjmETrB06WuwPxWG564WvBa/hAObmFEhkq6Tn0FCywp/At7V97ZQTlBl77etYlFNx2m0A7Ho8frgf6lzDg3NLxj0JI1iJrSWJbXNGn5zLzibtXQADL+6Z2IsRJp5GKCKwUh4Mymd4D34/+lhiAhBoc6w+AH3TlQVzoRCGIrZ3K9mn497IeHuePnEqaes0iTkQFdcAXdWALYmE7Rbl2/TsiWHNNWdxhVUkYQm6lrIiKMA4QAA+dgECeH3+bxUorqGItaU2gofT5w1E8xn0uoc8mIkNAAyhXoMT/zW9Y2te+bBMXmrJl8XI6hdDblFKvq/Gze0AwE6hszumwkKsvK6tKtWvoONOEUnvsRLY2bYY/2kH4gB96q2/wzfDtEnjxKldZZ+Cj1BQoMJNGsofQS6yzuIQAAptDuauYuVcyEBy5FQkiM4ZfMiAeIB/4tkuVujgFgoA6SXxh5cBhS6OJAALg5EYzUhVLffm99ZWAy6AtpfBmgB21DSWxnyoBZHVR+JdMksKwynIVuAXaaPmtjKkv9usAGzhsjz2URVnNq6S0Tbc+oGjFbKbVQXr1TZN8DFLZRgAzLqSJjITijHdZhjiM8IGeTwVFjB59MD+iqAVTh1JEgCGRPw1aZQQzU1FH/+mPsgeM9dUub3WbG/9I5tZ5QsqAOHVmPKP6ZFKjTNTMJC4R3cUoc3gXEYWxGZ/akTujQYAupoehN1T55bbuqHbNS8uREC4vFmGp/gC06vi7+KQoACBTmYM+gbdLOvfjFaywtkXLLy4mlXF6gDZ2w53qXHuANwiDxk5xhEXGCpNDNEzViI56ZSx/2x0iL00Sla5NTwA3LhmxaHZnMSPFBs+GLR74RJTWXrOMvZ2wd6rwPN+MADDFX5rbUwoAF5JfcaTlUSCJfl/tJLUG4XjOwiIt0CCABTCNqf6t5qCtSRBstj4QQ0kCg/84WevX7O/6DhsGf4AHqnwoORGudGCg/K7lo5twr8UDvvZK2BLdvCuQCcj/QC5aI57VseMFEeZcZZW3e6Tck/NIn9/4GbuZ8K0Qw/xALL/p9x+2VwnnQmZEaxlkhEbR8Ds4SMKHfwBcG72/xcAwmlPJivufGgyW0U6GLsrm+faGsYFM2tbTowiaM8AWwAJYq7JGXlEWLUF74+p/oupf2BQf1wLQ6/coREuYo/bAAbfK03YEqg/lbbpJaT5WM4ujVNTHdxUlUwrEP9OL6EAyVWIzyqUMdJ+YXqtBQrkg8R1y0ELeNkFXFBlZIcffgDdXbRmTfAd8Tlmq4gtBsaFQaBRh0BqMKlY3Otbj07OAB06hvgyi9UqFqQz8PW8SG782oTSTwwtuW2Xit2nBi0AZ5m4Dl0zQa7y6knsVqFVp8uvVZIJzeQrdSLDKOkz8QBmA4fGJwS9V8DcBKrtQ5wxuj3ni1AT6+ukpahZPk1nABCeGoKjDHDMFQY1PpPr7DqXyZpOThBPechoHLQyZMsAVKtJNbsezwd5r2iqC5kd5orEJyvX8bnUx77O2Z74sgAYnsG0q1FhpD9oJXVlAbI1W7ejAXYW7fzyXbxbMv7dAKIvBGV1f8i4VDOTqwwLHMFxsS90nY9L4pUVF7UY5HoAkr+yf0/l9bJ9fFiKjuZRlzzxYyWYe0Pn1Ffyp2HJhgAq/hvUQ6Yc7B2s2oQcwFbbfTWesp0JBPj3m8uh1r+4AOI6iEj7B+rMRBODhHVcyARwrN/8uZH63q8xnKO+O3gAMuyLrynFuqQNTRgMS5yH6FI2nGU2qQThUvChrpwiOgAdLVh1eQ4E7rR4yvqucND5Le79hqIUF2xSIKe4XX7xADCES2dcXYgxk27VCu9SWUGJJtnDcOh2Jv9YeKyj9N8ABE5aAeb+pSi/HIVJP8Asxe5Ryv/5oeHhpQRyv6e4PQD9iFThwRCclh4vtFmF8an4nCpGCjXrerlTySvr9EFCABDb0ndJE4L0gGb+w7doQJz2uipMo7P2XR2ZIhW2vZwA4tXZytBl+w8ol0zBO35hrccrvnAKcWwhZW80xldkCQBgiqJmAfmp17CqzxZwIvK4M+aaUjoRTAol0VMqZjVJAN3BNF25wzTVQZWcUcpFPYn3fkoNCwIbMtKYcbNUz8IAHP9zlBrxPxweukcFlFNr0FXM8vwcNHElyu95tJ10kQDNmonof01Hm2f1NsFeslxOMIMD4W/u6cS9OW0DFgKaANO89oztsNWr03ZYNj0Oyjv518HrqtVP24BrBTo8DioA9V1/LOE0UQAmx8uOR30A5APEGLw6SSfKoHKTn08niwD+bQxJgDFlsDU/dOCWu8tQNvyDB7Qw+XKV6RgsjD/fAKRffTN/PR1qL/bu9hXjMAeboNCdlCkWxSDxxIny+xoArCOia7V+hCF5sBWRb039IAdNuCXPaL+qVoICVQ07bABPcT8DGiTQsFPSiEIXENW2lyHavsNoOjILljSOSnepABsezRMl97vmYmOjaACyvvFAzRDf98M/lABKOVoh7YkA06z83bdIxEt5kQxzB3D9uNUarHtNr4VgYy/U61yDUQC8P50vSrJ/fCUF9Dvt6gV3tRKHjAqCm3BmHkBQuGlTALPUzjRErHC8vSWcGHe18lQo0PfsRYf6wUkt3xewj7MAMzZcLRZN6I/ceu68+eH2J7WpcUNE8lNyx7kPD5N5zgAqXozpfTsJJxEWGKO7kfo51ncQyEpaCbLTMfthIsRkAO+Xin5jvr/GD/5nMOBMUDTJ13Q+tVrZ4gqKed44YREASKUcAdubO5hUmEjOq1jmnYY0EushvW36dbujyMBHoQDbBAG/kT/MJiAI1lNQb1YpJmpkprnf5KnIEbvSKWz/AOjGHn7H6B6d+W/uDefG57dQ/aSc6PCph9o+AfJ7E2EA5yff5lBzPtA88gnWJliyaBSc4ivqmrD8BODzdDMeUgBZO3jRAL6SL//kXxNYxKTmhKyE+DWtrFtk9IGepFDZAD/eezuti2NDtWfkSNE7/0cKlUBNScD3P5fxIl2QiW0AQD84NKa3ntBtmQ2pWOwt35WOqvVFb0KHDYVfWnlpXwAJV+0IPVmtpIXHZVqImA+4G3Lt0lv+cKukT+ZVi3LTAJ0kR0YBb//ae4OR6Swn06vgKe3ItupNbMXOcjSRxpgAzcBWDcBLYxaWyLDMfSV2oRMwa+NGuqORelST1GeAvADa4HV4JMBXY3X2C/Wo0u9YMnQ8OSg84bjJkGC0idiPAFocuvHwre3CBbefhYxvUrtz5a2OqCooiFqn8ieIo18A91O423jL1DcLQSEYttztTvyBL/SxELnv9v5WuUhJzwDIz+LxxdUK5VzdxNsw0qsHZXbUzJlz9+mgoRqvRh+uADDDdHiAdWCocZ+Gl1qEUzSWejSTxVmgfAHRTFCera0A9ecYqr2dvmD1NAwaKMYEFzzRQEvtLLxlBvMNZm5umgBxOvY6KmfD4YdXe+8aIo3ONGNRv4gIioevDCBitc62AHRyaSJmNkRGUUnQzko7jFU8fA1sJE/NqxprQVPpaUoA4DXPO26BYKDJxpFHJiW+5wuod+q8vsHqfJkq9ptrMgBKd1b1eUsj88RumquTA5UVVaM9XqkjxV0n3pNAK70DALegzWKjTD5Fv6s4Sg4kYASusr7u1IWOlEDIE2i2UG4ALvIiNJkhbBbdeeoHe+Q1HSkZIc0gwPb6hxBBOBUq7ACFIL/YI8SQOUVRKbNAsDOUAIWyCjOBT7u4i9M+t5v2AGv+wgy6et7WLz/cjAnlVl+4klXN9fi/kX5o/pWqxlAA/mB/YXrsFWdRrIW+354oGNTaRm6Yv2o3z8C1XLjydwDIH+eSEU/KlR1fIVFNDVhfNxvBHYUP7Lx+BEwfeAe1AOhGDZFTH7sztGfKNftEiNrMnQtcFjwfKp+yFmNSsxsAHTJv+Yj4oVPT1qdNjTWtpZC6djc3jrNdy/VaGC92fwBH5gbsM/PZk/TZMbFEWkV94mhZDlfwOwW0+CD9Dl9iAIQGIIk/7JKHAZZrFGTEvHGCKyUblLFxY9yJCNGew8UAchfxQ1MBvFCJT+fnE4bMZqGKcWF57wOiRR8JOGuVGgBGIFvG7i1YwwvpelrtT234bio6tkbPigd/WgV4GwtdAKbxT44AmPMgQR8F9MfynDbG10pEokQxswg/fsHPxO0AR7J/acu1x6p1H9rNOM8eeyiUHvZiPYw3FYk/mdTmvQCsQzx/52q1J4y3XXluZWcXAOmQPMpB1om5uHtszS1uAL2RSKjdVEmm0IpEsfE0QvGZzrEZHB2BX16HNmRU3wUA2ZtgziLnB3ROfJFyjqbEcfMYufqonq6KDPu2PS2xQgBrkmkFrCnVL/pXuLBtaMsayxPFB3OBJ8j19konWhihAAvdJCPj+rXA0ze1L1ppjo/hkAMCjUrjmX2/8uPoAJ4AqNSFNTY8OddcNUf8TP+UEmi79dvBDt58qHxZb6Q/+ABIimQwf+JldBfGMg32tdwkh2fVsPCmR53SX7tHzGAkADsYDrNPrKyg8gjtlXMX5va6zC0UbTRjTTIzTjCVnc4As1j7KSkWHkhUH9wYfGYSrK/SeYL6ETFIYwd5HLZESgAALKMLbJPIOgxMs+qqHwuMytP+zyTmNN5TntH4jLUNAAhe34vE92luPUFjp6jwdZtiIa+Ar7iIpCZ1/SStO6QAGZSrQK3aWxwRbdyC9vllzMX0+smehIXph+tMbTJDbAD7qq8HecMEEyRW8P9ci0KQl7V6M5QE5QXoKmlWvzmBAH2xJ2b2/AJraHHjBfvUgkwIhikXkzSJIDBehoiesUMAmoJMZtv3qlG1xHCxontkdhYSd/LBR0dYmWtxtGpX2AAxYWONgSz+Pgj2gRU2CxOjx/X37SYVO4kXzCFl29ufAASm0/fBWWOyKmL3zogNYbs4jewNaGJlO92+OVXpfL8A6FzLcs5JyKDezwmcCjweS5dhQjjhlEHlcZ4i9luryQB/eOwDudeELc8YyVJrQbTcKYy9sputyWedXTmEjMwLAEXUhN82uQxZGnif48ADuSm1kocLQpj9HThAGuIIUJgAAHMrW0DAozYCP/n0Oa5TUDxUDVHmhw2ZO0xAYrUqFgDrTTSQ0zm2n0pdTEhWB6ZAiHKU1p7ntA8v6lhlgPiPADmBglK5JmJt6Fku80qs5GT8hHor1x/MVqZqYxhcaQ0AawZaXIxzE4BSfC8jpk5Ee/4j/scUTiJJ5TzoLGfJVQBBXwCMD/6osGvxHvIB5tVgA1lTVTvOM5Ahbob2I7jmAK7hyp10JsTa9hVqJd2XflRLHZFJ1DZBrjjCWtM0j44AAVkrIJdesDoOS5B6S385ayuz2AhRq8ZXUaFDHXjfMwB8IrbWrOjQOcMVjLSVVepftHT3jVFjPuAqt2n152bZABcMf3xPlkCMolT8/M1pr+DYIxGvi5T/ocJcfqCG7PUAY759r8DHMd9JAeO+Z8s8Rb2f9AC+yN5lVqXJ5x4VMAA33kTGjlJDcdWmyikQgJd+J1YhqQxUx+L+2FyyMT6+AHP+Gae6Co8Cd/GUPbLmN1Yzf/2TedXaDK6jUox81A0Av5U8ULqtar4wNrbGQ+gB9QmlmhF/GniJkbYxXwDC7wABBNq+BSR1iFpOOOz+K2CR9tLp07+81iOuo9w6FmdfAJXwb30kgDpCPZnm8EQ6fIowLCAWdp4tr8I889STx8EAsIAdMOgVYsvl6NDbzTer9UF/LfzTLUVIw2LzYD4PgwBTz3gcHbaWO5eUwtVhaiY91/9QVae2y7g3vSDfR8ZOAN09zLSRAg6R8Xf2IDqmx1QAVSqYC9JkNvo1rw7QR9kAx0POLQjH9t9g+Gwtr/dgIWhB7tGC38KfxkDHRgOUaQD0qbclvzVoMqw7Ph/JG0uqW7FhaUduBHEds+6Bd9glAA+cvwgm3Ok7sbYamUGuwPTqQAsm6kW7ArIlSxwh0l8A8m+Fhr+0Y5o7CuOy9KZ9SWFfsCweYZlf17aIyxr/hwCaJ6zJz7ej5AM1DppReTnB5PkYzs0grVb85gwU9gd+AP4Zsg/k6brb/py8dO+P+TQ1YZQXHBml8aDZqHxnDwMAIlqImAkTDJN2kWaFPzpq/HsEJfJTEv1UIUAba9K69ACdKNCTDhinbXCGs9YarFX+NJZuq3Obl1ISRDfY4gTCALHJH1YGvjb5vIEYndxurKlr+h7p9C2924uPFUteYmgA4CC1DbZs+SObxOLSW0wAc+V3hQVcNw+dJouTturCTACCBhpZkmZWB/7uH0mxyK95il7fzOkTvn1QSVC2sEdrAAwp0ijk/Z2AsIikSrJ9aOrX+7lFIDatKC1hNxPfpFAA9hLyMs640BtSWw9loMd95YQc2yI3ZjHP0KEtMNOn6QD1/Avv6I2OZV8B1kFpcmN3Bx/LWveXo4guj9+5K7U6AJS1FYebOp2mtTcYz9Z074mz7z5hKsXeCyNMHJgR2xkA7b932kF+2ObcryDMP7LKP34YTXnMOMaDfeOkmbh7bQCewcVfmF0xXkprYbBqCjiqbuLbuh9WY7Tk4569VwDTAJbJXeGKTwfHrUoUFGUEOPgO7AymS33O9DAFBYqotggA0pwMVTilX+OXlWuI6+UJ9H6891POhv5EjHlv3848CgC6/d3fCgSH3Oz5ylTKZDPfpXtoykuE5qOFCPeOE0roADNMjTmJ8xO0a72Tb2ewMumlbCmSeTBNON8xaXORRoQARnfX0eDK4LqlOT0jKm5bH6Y7m0RVtP3Ejf7oNpHgFQAgkNSzn3/SK4R4F+UH27wkFMr475U9UBjQUQqLHmMfAOP5tuDE6+8leDB6bJzdaqE2EwZmDWhFtJtnrU404IYAuyYpeMxoa0zn54f88ctmYZADaT2wkSUNhjNaNPn/wwAqNhLoFdEkr5aJfT7DMkDO/KZ3v3wo0YkCAoGXYQKxACjvlQXxu5WnFkWi3tEjBK5oS7/UXC17drOib7w0bGIAX12ggO+Kz7Ap8rZG4S2I1TXHBi8dn491f8zJN/DCpwB0Jfg/ojPG3A6hX0Y5UWq3izBqj4kNUCzWdLbWctSkAGCtcnjB0zlX/udRVMCzYB0f89U99gxQGtQLyEOYwVQA6/EesaSll5wNEEyVYH9YsoBBhdL4fKLL1Pe2tciDWABTLJoTyhYl6LmJlEwRDNANc5m3Wo+saLtr9ymGrBXAAOWiD85l25wUVgo4U7r+uhNy8IJpl9bd9zhOcLE/0JsAJTG2iaRy1+G1bHvN+CJ5083igkn4hN12QkHHK0NU+AAIbny1FdF26Ey3JPgpfYArEj6useHiWQSaUmQS0EYRAF0BstVZnwxfYadMMecmKjRWfSRqUxoWU/4uoWNAplkAkbXEJQDa0t4W556hRADqk0oh5gb6llep7ZV5DNwnBACaj2JOF14/T95JJMN6cTIcrXRVfYo8gj4j8SQaz9zAAFCsR1MIDywJhxr8ZegHUPQqjHWQNR0L2nz79hmxJP4AAZwK4EYNnvCiy166WLLN58QhT9RXbQlf+/BRE9lqLABBiG/wivOcVlGsBGWtwwl/P9+I/ouzzIIEgWiLms5pAA6+EnVdPhteiyQ2iKIyCLP5bas0O4zDQg08NhM37UkAM3pbN3ILuXzwAwsR1LBMMqpd+9c/zFuIGhdmrQSHBQBtdN+iyOG+6R9cAl1YvoCbC77UtL7njkKv4txbjWNmADHfnRrDVIfuPa0RcnIGaPJ0iOmvk3M0tIg3HsHQzEMAUXG4QqAOwTut9UZfWy1LAG+6xdh8qmEEyhyLg5LDoQANPKxJ62m0bimpIS7LUMSSk1DmnWyEAUDLmDj+DkMoALHRGhRY3Qaoa8HM1xexnCKHGAyikqQWm9n+3I3rnesA9mPxo7V2efXu0eASl3EsoXzEiH0ZbzKmgqs0LBSybgAWsntg5DHdtFj7UWofeSlSgQloewYptaJRfepb38C9AAUyPEJKRpukdEerD5yz0rvPE4qfGIIbQx8iDz37sBwAaxK0VsJSKO6mj6GOZnOPbGrq2OOeItRREvHpML747wDIQ9olEQbMJHco9sR5lku+g7M0M5PLW9/TaRj6DakmAKLnDzspT2YINZW1U5SedejVXSKxYlgQaVZYbofBj7UAHBkq51ACp8iW296P+W9N0UoyqTkcEdqLYq1rAgIt0QCZsX0Ln2cB84u/7ms4JNIzBEBq6lK7Uee8LL3Br4T0ABUM9jh2aXU2o9Uo/So4MV6tWfPTF3qkAxDRBLdKpncApY4BalAiqjTUVczLGorPvSQ9jh0mM+8GYKxSeeOsiAAkn09QJyAfzicF/xj6D6uLL+iYV9XhkKts9hIe7IvMAJ4HN1JJgub6jgAQHJqvkAPogkDLqfvfK3m9xJJFWp4Av3srFyhBbrh1t6n3HXj6nyPS0HxyoqoFSgDL2zZDzgDTkrcR6fYCQk/onVlZJi6LrWQ8G6Hmt7Agmg0nm3t7ANw6oRcCEWRAajGQTux04ZbPEy7cpIiX8WtuTd4yK4MAp9wi4rRkEEkXASnD/YFQgT5iChzxA177K5Pxrp70VwAFS4xbT2AZl2ItarBMl/Gs4xH06XuxMlBjC0tcu7uZAMy7WE+jUfnZRxjEoBHbnk00DXHpraf/+5jHdoVOuR4A1BvtI4M7OHtML4eUX0YVGYCyXPQXhdMKZRDSRkxNJQBXIHAoVa7qYnUEOh6R3cFUy0RdQl870BB7Ka3zxnNSACaeZELINEJ7sjpb4QAZ2vw6uppEuPNktP5SMv2y+pIAnl5W7TUtmrgjZi9JAMaHdPdYhV333ZUbhecZ6XMWUwAFthFhlS2fAADz/FT3BDj02soKRBzTwMiUrAladsJAAOwZQb5yEbzHVOy5XG/VZA4aAaQ/WNq7hvFMT4iqwckAHhUcQE0KVdfXTgjl9Nn5+CmI18XPcahUtQNDoWkHMAA54YKKihlU9W3H3CaLVZnnfta4gW6D2mNj3lZ+LGN8ABx0rJtQIFxf9qPX/pF4fxo2vTksimADnIuonbb2WFwAWJJrxkklxNFM4/MAzIvdHWCmagXMCz9M87pHsQfv+wDLVuV2JGBwcvkXjGChUOCgSaWwZWZBmDCVzxuBiTEuACyca+DzUhqcukEJnTxX/bqMtJbIGL7yiEKBx6HHxRkA27zRu7RULwsSNNDb8iKUWSWKShCP8y4FwL4V2T/1XQCalBpcrFkEZGNzcsNuo2JH8nMoPkCEOWUy2LDf6I3/ALBY3gFcxew6gn41t472W6SPkFEkh6+PSk2Pca4thAcAfvzOYrhpQwY/SfcTo9JKG5Mp/6RIzFiOcQOmwrNrTQCO9F7y4jcJSuchCbYKcdjGTJKbX5s0P8+jOwGExBPqAGm/vcWQq1Fppwbrv3J4NesiZtoHHz2SspuUdo90JccAvrc7zVhwRudiIc8FXxsGRsXYnPeVbvJ62BBJlTKfmwDwzupI8R9sJb9LmsOWaUltOVBYF15p5KCSXiXYTqf2ANq/PfN0UbvAqvbvHUsAhp9e7sCAi9o5FHCIx/wbI88AJWuuq2ODGr6h08wo+6WxnvZo6gYm+guQkhVxES1P1QD0Mh3hnvfsONX6SQBFh7qJ0oHMzezTJeA9ul7Iv2xKAHtGLvJkpXdkcLimTxunChARfDu5vmMjTtait8Qu14gAl00rzJO8djyzB/4dmDZ8RluTP9FU9p4Zugwru1l46QDaHZz48+OTPwBZ5AAO4qpvmW6ltU0rNACHVu7AoYtCAM1DPDVZqGLf6PGT0Ywjx8NV7wtFSLfkgvRce/MA2HkAjbzs/RZBxmoZSCFDyX+7c/TPasEVyN71q8NnlTpCnQBimhcES7j6MLnWRQDYvEEminmbD+Dlaxv/XhiWHvTJAM/Y6ESgmJm9lCRT5FbglNS4Why8EifM/wSCt0iCrzMAjW8sibHbyIwSgNWrsHPGbvXXkxKMWKKgRTvqdyxiNgC9cj8M5MDCceZIlkM3K9zRezEVhhrt35Kis+VxFNgyAEr2vaC4vVz2pkCj+iR+W6TD6xD8S1h/ok4WvWswgesAjDLyDeInUFOxMGVbb5ap3orP0stNFXbftBfFDynTkgCDYZr0v1Z+1PHwuYGPjpHi/RAI9D0O9gZHW//BbppAAJhNTtU//mjWkjKcEDy06VTZCHPyNBblV5aWT4C+CCkApP0ZwUbASZBTtqRt4Mi8fWSY4FK3muI7d5L7wwvn/wCkVnw01vwBHmqEhzdqiVTgKkBiBoAc13sdnUZmYPOBAOcdviXxEhJ/FLSDkkNZmr0Vcl+ixc88X+HAoH+ZhTMAZISgvtTz8ORVKPkrKxG9UsGx+I/oTuexG8bdlqphSQDFMpun07qL+RyskmdOn8RQgsDpW7BagR3LFr8H5X9rANTwLQix+a3JqKNXDdiqn74DxbhU9Kodd/RuVd3cb/EAPEmEencndv8QkQNDhsXaC8xkipo6DcZZCBbiMJi4rABNBi+QKszN5X9+jX0bd+qY1YPHUHUoXt1NbaOt0xzRAIazBR7ICMfitlGVD3BCWFqrJgkdFvhCC3K4/JVK6kcAQczwXUIYesulEXGLMDyzdyzH7/dN2NaH0MKC3HiabgDJ1JSCMlb6of7LlNUDPXQVT4mYMJ+C8mv8jrMVUx/gAMKEbF3x4CmKOkw9IAurFiDAC+X6E0K5KC1vu9Th3YEANPkHmVMO1QNcXsyjHBwkYMqjQhwP2m4xM35+ysJBswD28KoxGQviV5CmPmAMOG/KxfgN7+ap5yuq4YWq+UhwAHVyWneAh2VTmXtGrFBD68TgM6GjC/hNNbk669J0Y1sAw7QlSX0aagmiiqKgXsYmLAP540bF5OgxnrpWgXyrQQCFUZUpM1Hac2OXe9OppfmOP/ha1LgzxPSZeLFJDvb4ALF7Dbihkum940Mk/VAb+qxN5QDMUMLYpQja+PLe4t4AkqANiJ3XNqImHJoD7H48i64DnpEWA3dip7hqFBeaoAAirKTpoHkK589nznnvCFzn8V7I3pjzXA9fHTq45xAoAGtTZHgpduy5c+JQnBXpVKpOeJWbIGvBgGo67jPhX98AjcsX+n4e6+1C4z8Cs+mPKjW0Cx2V3i37JvAZzQ/ZXgAMtLEvVVl4IFexiW+y8BhCcaEBhaO4pvyTjy3oF4gsAImZR9wEr83Li5g/z1AMT2CqdV6ra08YkzxgIp3i8oUAMf6F84PH/7cIkHMVGU3gPx2A6p7ZoeNkuS++kf6kEADCalRHpAU8zTln5/lMTyvzsj6q+NJSLBaLZkai80efAMO1LzkF2SibS5AXosckcdV14KCPNakB/Szs3aWqvjgAqGzi5rbLrnPjtYkX8wu6spbcJWbr5ijH8MHhsl2HFgC+4T3I4AUshr9Mw0nPlPbZ9My8aSN/Fm95lI3rLdl9ACdR8TGqxnhAPns/qC9jPb0Fh0XLoBEGbSz5fRm/5tkA3/lc6/ozn/Dc1xr6CbQmGjo91xgWAHwS/UnOWEZcvACnPR/3gkjf3/cgwlxVXUMmfhy/86l/VIa9oEUIRhuVANaDOtCXSDWBZ5Xd68lKCpAZu2nl2dMVfgJ7Yggu6q0AH6W25iQfzCCbVEbXMSmSrrz51lILHdsqgtfmqeYvJgCyx2qEA9RHx+4RxRZttpEuL/M3Ef1IcLTmBQegHOpTACYM0krxTjTGdXvCMYzAqe/Xw4jU2Q/iWdHP1WZkE/UAD894r5aD6R6/f3EjC0seZbC2suhxxVydQzy2NPINdwAG6VTVKKKBXHCkQmV2jXcvLdIfBPnRSaWieyosWPtSAOylPUHNdlDljoa69VoD5uThg/JkXOroQGOALNi/ScQAQrSVu28niT/Tap9ntUy8Lt8xUsm2q1L35j8Tl0W/tgBFpHrtQzQTTQWA1yA6mwaz2CcPWMrUy7WOQMyqBOTPAA3prpLB5rPS32Rm/gl8xlkSx9jE23cNKvhH9iqZKuUAon+OA2a4wy3CdPNPtBKxhTl29mmyek9BsuFb41I63gBn7B6mzuk0tzXdMzmMGwfELfZ5fNfJiMTEMvCAQKROAFtPHyFC7xHBZcifVjUxqxMR9ov73PqZYPxCYXkKtvgAeoJgE3WIE+bynfVkWzZVcSGUXUnn5osOFguhFtIutwDhJrBlU/o7ncFK5jlN8RgEPtyrZAUDVOnXzLMpBRDCABbxunxXdRpJJqmbmh5DpDlWnKjNlOCganfBlfGdAYsAzqtorErhSpOLTr1hnOqWiAFcwF4CkizjQW6UADnM5AA8e5Z5apZVo2IkckV/AoeFm3o6EWsR6tcI9zI3iGzjAM6Ay1d3kSiJzrHAsIEwB9sAAfv3Zo3zdYofSqR6T14A/IwAXe8iJCa5EC4/Wlgl+ftGx6O1LlvmbF57Ionb+wCR6zkV4GuU5ZhBSnsqwc/8I6WUBytb9+TgCNV0TDk9AFDXXG7FnK91fzCGCxdhPVWah5qMOlLDrIQPg2e8jXgApk3bKuBiTGB5ySWSvq8Ii++F39mwasZDafsyDTmP2QCVfSu/J82d4pKliYMqkCTIwGulbgwsXA4i6NbKpXLHAO85hKK8HtcDuQ2jwxf8yh+gv22xGE1ZPSQb/XctQQ8A2HugEXR7Ao99OxcM6tIMMI54sZiPx/blk/lRYNdtXwCg43NG1XIQheY9u0Q9E6XW0H6OONIwtECmwvo3PQsKAA+rsZv6IqZDwP4in6VuZebCJfV035txSax6brk4C2QADaNVMh19MMW1/0WN2NhIx6zPz9MqmP/4Gmgm9K2mwwAhlUe2HrVfg/LiRwXvz/i/aBteF6lKij/5EVKLJtyVAJw9HNilq8nlf9I7fSnMC0p8DHfCC+AsJCOGYOTBVsAAPE82Y2R3UXzEaoBruH6I+L0W5RoTiVRhDMHYiUQvbACNSNTJbL1z+5O3PjKkeaKojQFIrKuuxMwKNXYtr8OaAIukxPyiyTuD8MqSolz/WU5z7y9BgsE4Ts7heyn8z54A8GTq0vbBMvaY4Bdfdxl0HmngXzkc7ammpcBF7/HNvwBdpGS6GC+YvxcSclsvWHSlFpFDTSitmop2oK0qV95AAKBzWJQF08vdQraRa3XNR/T2H4dvBBfnAftACoprgtoAGvilLKKbf3y7GoTDaAyl25z/1260H2THO5YePTZBrwC8NqFi98zHHHBdUu5WStkF7q4GpTK5I+/5reVg0bN9AKKOzA8QxOPJiiTam0BF3Pnxv1VKaRxynq8VV2aDMkIAvFfIUqTGktJWPIq6Dqq99sCLBvlU6hxAdd6rdEJUYwAjL2QXSUN7Eiu4TOKBJ/gFap/BX/Z04Hq3x+tfKi41AGVmCFOgQ4Jhz6xh4KwLHUh9mrVRvuiZKUdXKBo1LV4AeeBNcDiZMmvrV8+ulHyl0m7fuJpsEgjI2Oaa65N6gQDTKMnwBFS8ivjJjn4LQZ/7fHtmmXmL+1InG/RN3NQnALJNpnJJxf0Rd5QcN2BFKgkaxIsX4e18ut6+Wbjrjn8AxAXFuFVUPEsmJaoipQkHvlNEEvQnjJ0OkJpNkh3AXQBcvUvQG/NYHQBFoyFxdn6Rw7xjHD087dlneiql1tDrAJepl2ZTdCN4yhakiObHqR/dP7HLu74YS9IcLLtgNTQAh7RJXvkr3Qdw2zAffkV9QjM57x4WWkUpGx1CCbA6cwCfMP5Tf3+1AA5rb3ycRR9o4D/ZAbnqg3jzDyDf1N7RAL2290bRyPb1M+JeoIKrXpg/9gb67JOEWEUo2pMCKQcAmKiqzqB03pJowPz7Uka9yZgU6mws0m54V3FgzuyMzwAvftUr3iRjABD1KnuMSCdl8qhPX0qhVJTUyOqC5McCAIOjYbaQqflHFKXPn5NUuH7TmtJngOfinCn48qwDJd0A7CztGwnl6sc607/eukBBlcXxg2I+YQg2NuNW4m98qACBl5+bYBFjxIrhprGcPKJom+2XgFJhmLDQFdH5FqBgAElnrS58N82wEnSzOWnbTr2k6g/SBMZxq/T78jGG6HIA0qn6GdDAycpAv5tWyyUO3XVHFgrvAb9FXt5yrl8HIQDZNxT/VGGeeLvixXr8xihnpo8IEffLoaRrDmNPWh54ANcs1GejY7ZHRhdKFe+2ZLorg6I7EUmymiKSIcY2zjEAlLAIwnd+I52QpmY5+X+yGclSGDQOWIg1IhJhJrb8KwBa3BeWeY+wf3R2cwdlYbhEATIzDpnyUn5N15V9qoMmABIlX/Zw9obJcGzmzfldCwQgOXKvb7CIqWBFa+7SjHAAWbk7z+svQE8E5vXirgpFQzdP/GiTxSgkwynxFcYElwAfj5T9IdZ1QuuftlXFYSp2ho88KkKfdhG1lGE9n6WTAOkv+pQhd8Kj172puSxIfDORpwFtPYvolB68WdRpUXQA5lGiEC29R7kujYNQ8ArrS/QR6Xe8advYPhhMmiFJegA4+4Zp5AZ5X5wGsU8yw5IkXFGSHs1CFGFKtEjTR0kAAGVm8QXRvV5Ku7OO5rsp/bgQiteihFvD4oZ6Had2Nj8APEg8bm8gWp6EEGtWuqcbbmhNMKLCiFExLD276imCwQC0C4eUAPydJ++iBK+PWDZthqWEg0W4QIuDWALFeZzaAL0NHhJYNmmq3QrSlXsI5NamxFdgNCWi9kJ9hyEkZAYA/esIMzXn6aCukwYhExZvGacsv2/lrQU+ZAj4vsCEwgAcMx1B8eSPG/oLC28IIPUWGafjTMHJkBL6hdM87D6pABuVsqqjRYo2PfJyRUYHqw/yKsG5ghTs/ByVSLbBPuYA6nejpYfT3/4WTRKZWkWhNPfWgQBurCVWVnI2PFIK+AAvhHlP3nmnL9Rfm7Uhecs3/PL1nUUjZSzOZeyR7dTiABUkI/TzdX5jSO1rj8sz+sOEfHwrL0e7+xuxtc0kgOsAS7C9jw+z71frVjQHUuKV/KjIsfqJKR6Zz7gRr85MTwBHicQh1XLPbsAnMSoAQLE4l0Z48vvw0Z3H62Ikj5GtAHptLSAXSMZyTuce1bFe4cPeJqK9ET0WkFZE6p0o3QsAMs2YqW97AyRxAkCLcuWA+63Ooa8eTXdcQ+p2Y5r2UgCM7KT5lYPjxrFqRqkj8nwUY67b7gf6aovkdHGnZ8gjADNiD7K/YYjpLKcBcWS3pgi8j9ZSGV7uzlx70bFud+AA/MEC2vBXMBQYD4dQSILAzQ3C6J5qe+RvyJmxgx50CAD8XBgKPKB8gh2Fobw22jqyUo1Nrhw3qORbps0XBEU7ADf3me9uqm19rsf2q2leHdFarHOX0yP4V3vReEtvlGoAZLZFfydkbrff4E9lUb5cPrb8lmVr8tipNd4DSoHzPwAe+wzt7ZD25GG5qugb3zWYKwyYUZfusYWz9vVBo73JABI81g3NGSwnfBAwsZV6T1eG5zqwF2J+f/0Dp6CsqiQASmldTFAVG4XaOgofzpwY8UPN5r8ibcwH8mGGWLuKPAAiWHrFvGsoSXU8fBZw2pTpKiLxFlnVYSi5Jpe6zYY7APtLeaL/MQu1Fbq6HdAYNDr9eogUZr0Runu5qt8G044AnquDyv3K/v20GJQ4qbzNccBKcakWQgCRBPIpRbhJmwCehNsEAyUZ3f84Jbu/JuMYQfNlQVZtWNdZFQdF36+eACd4tAsRfx/S8QKhGZ0B7trTrD1R9O6pTVTwImA7ODoAESsECwfKWfijm1nFG7AfuzhsU/Os3x2ojS2V6dqpRACwAx+8pUibl42RdAWFcARwjZp4lsKmqjUZUHGquKMgAPnLi/rGa4iDolJbcRCwrKUbnsGC9LAR/EhhoPKb0tAAEh3tqrr5qqrg3wHI3FFWWjZCC5HUIVJMzAgUYwTC0gBIn5gmldjOJhwm+NbHlxWZA2PyJfJAPmWkrKkceFheAMrLZDRCh9HReuCRIO8ZRh7TRbd7k74c++Y0jva+I34A1uNiGA/pKwidzgzMtM2XFUZ8rDT6GqoGQC11pRKRfgCu5KYEbcoMOs4nSnIb5KEOzQ8UumvS+fvRa6XkbNHMAI454/KseKjeFA7YykksFWDcJM+qlWStL3aZqYJc7UQA7lLF/BbfaPMCFbng4JG5rRFCAXOdOrlNr4gZoG3QRABEtLJ0uQRXnsgvgcfWJ+ct1DK7uAGECUSt5GyCBE5EAPwjB3RFxZbH14ZPgw+OczD6eSgE4wf5WCfQEf9JpRAAvudwE1TthIuTmkUfd1shXii0wazQvWnnOj8gcN33GAA2FY4N0U+kk7cFyaji0VDKl/ChV7tJ8iv2wBtmSilMAIRdbBaBYtWzC1aDhcQj2zeU1iK2PlqOeGFtUw3Sz3MASjdIkGbIdK80qngRzYG6EJqNPahgsb6xIQol5b22DgD4htlY7EOBFgkZA429Y25D+R0BY5LFjjbTV6c72xJSAPxfRtK0xLZCZZhgjtbJRhEknY6Iz9ahXIZijWNca08AJlhaAe2R2LC1ZJbfBBQugxgQHVtPHczczWJQhlrg3gDqSDw/3AAvwhmbeTWoXZW5R2+zbSHdCIuiMoARYQACAOcW0eSu+GKdeU/KX5oq3rjwjKo3MoC5y+Grld14a10AfX+a7yJf+G/0Y+/vzQ8IN4R6iFj6/0i4cKafYuk7UACE7JaWyhTl4hq3FJVdt6ficAoIxTKPBHgs9xNHTVfBAP4ZfL0wVMOHapOa2SdLjn+hgONwhhkQvOtzFdz2TBMAYNobShzHAh79Zqyj86ig45LLYKQwDV86NKVhkYkvngBkteqkY2sukVxowqQP6Fx60rxtxFA2Z3G5a6oiJtsiAIw9f4PMvfQ4e+NQcDUsYgdC/30AdYhAhkTEaDMMRf4AsYF77tmVT4avpt7xcJRz27wtduiheZulasb7p8n5CQBXv+U4d0PDZs9Zqiw+ULOY+RptXTeSHvoOvf91vmapAIvjIBRCyYK8mrSr54O650rS5Dqw82ddhXllxlz2TJIAKM/gB62ycGXnXlhd+RCCQBV5hv/uJF5wWS/Wxu0vKgB6lAW82oUwFgQp+/Ko/0dzezmVKPxdBnzIr+YOhj9QADlNM39zzE0HY8xvQcXmYZzpljsEIm1XujNkv2BSBGUAUKnR+U9L0aUKNikHVPJCMqrn46ebgHGO8WaOXeeYWwCS4YaqUkAhrL++wBzRVov/av8OSPUgFnpyxU93LezyAOrJtj1lOTTq6tV88xhMdpcDRMJpbExqkknftm+3gekAFG628AE5Y7G82CpPk94Reob6OSOM8G/KaTzmp8u0OgAspsNO9yZAq1WfRpgcnC/Vr1UU0+iPxkHyZHIOyo0KALlhVwseGMaDWfCsuiXpRY1JL7zI3gKQPtbJsVke0U0AE4cUHXct9aDFWcT2gP9lOMwHDChxXKQkUYkeVyk9swB+WjWTnNaCGlimVPcL1/EqAzDNownV4IyTKd1IS6cFAEncMw6ZcFH7q6n9Tku0zGVWWElPrEOhntmpNU30vM4APMONDNjw/46tk318jnqDuPl0L/skDyYM/gbWai4/lgBnBJWfp2aEU3VXJE66h0ka40lkoijzRzFOc8SRNQqnADQkVYl/G1/l2XrlIJXgZCL5eN70hxCvAcumkh4OxQoA1R/w2OOJd3QotHb3EVPUUBRvq5Ah7ANy7UZ4JIdJfwCYCB4XQjEnFDMVZf5jHQYztiOJw6t2XxHydp7eB1bTAF43TpjwMiTDUwRJktrFmOU/luNe+CDdSvtdKRB5cgMA0OwY6Nj1/rjV+ZT2dsFpYvqtxn/tErf0m5KMnLPxCgBrlForP5bop/5uQnqAj8vntOMipVsN3O6kexYfEMF3AGS49k+YasJzsLFzf4j9Ws+6UBgjvW89JlhccOHgxSwAKXYO7Vh7gVo27AEUwG2K1kh7Cxfl3WqptduYVj1BxQBMNjfZQNGCwpSZrVdMtBfg2TewN74C4PabEohjk5a9ALOS1QfAzlkNbNYqUnPpkOfbr5ff4aySLdkrzRttkhYAxNjQjkyaIUuo58AdZTOV5dcQdwUvt6mAhXZSvcgXbABiNSeeGe9BTxvtXSB5F1YUDQQZSanExvflCo45RusgAJ9TXxqUXvvMd6y5+sQ8FXOeiujbR9tr2xHUoVo5xJoAjhNpL8jk0v2fCzGxzjrjx56uVDuwV24Xh4FS3k/5PwCZnoTluKHISX5UxzVHCUIgWHBAEr3XlADKSYk8PkefAOUzvyaFGGv4dP68mVy2ebD+REgRA+CK2PbzRItsFhcAnxLTvnM3twOL87IakTb15mq5BNghcgHASvc3RloPEwAg8kCcfO5CmsoGD3M/Ov0PNgWjCgT4dliNK946sl32ANdBr8v06bjAdJIBg+njLP2hRrWWCg3LHHb8VWyUpc0AI8LG/vD7yJsozrbJljHoPVLA3XJ7C4CsK6bJ6grsowDrrdYNJe5xTCqf9cEUaP2jpcSEnkwMeI7NhcmJPfCGAGOEAjcfNe7LBR+X8dXFRXFzhwgRr6TZax3/VSvB0bMAtIye8ErA4VHGKEFx3LXmbFGYK3J1QEBv1+NToy1xsQCkDt2bT1qNVQfS0FDtDIUlzbGlRVsRMfotcTuBQhScAAlsgoheudl+zVys3RBZ3jpmtLfSGvSXiXJQodvbC70AmKmrczQWrWqQdGLNezsO6Nbngen5QEbj0aLZo9ZNYAAlGqjthl5HSFEkmGG9JTFXixFDSj02Zrx0ZBiqf6/2AEZnlYHpoohuHz+VJlUhBsJaiJ/3z2cV/90Rh6yBil4AeIjVCMeWK3Cot8xXLW7+IUAbseeBhAoQ56gFd3xGLgCChMNmlbjWPMw+V5O3pktaiFf8aGaCbzP6KEwixcyAAHLz4hYSMoJt2xBlRf/AMYRcTbu3MEVEyA7rHjPYhHMAdAM2pxz7VXaHL2i1+yfOk6jU+hQdkhc7/pWwtJYl3QDrWclHHn3tthTC7pi+4yDwlxwah4eUSmCpaQEZ2/+FAKqLRiKsyDgco/gnkTaY0WbdRCtIy3nOW6+/Z/XkePQAxmWMZvTajjVYmvUEb4rFZ4yX3YL6EyJJcrUfKXFnWwAGZYx3DCo27UEhTdp3dZ2q+lj4++uVZ2g7pA146WfxANrCKSmp6fmPiCezmBkzV93+vPhsuTn/pBdNPMnRQTUAdWaE6kZofK6DohyGFyqm7GB+IUP0O38EGlucj806NwACO7oH2Uzsd8hbCUSDLATKBaThmuneEFxj2Hp8JN96ALCaHsts//UfEqct6jVN+NhNfVYh8ulNTCuz87MtVpIA33a6lzGHqzzrPePh2Br5TPAzrrXq/pSYknJZrcknvQBwMoBAB9u/T/+g/T9Vfcv+lMU/aOTSIwC9HrTKEXS4AORe26So/kxhZ11ATor5cMg8XEMsJNOwgtk4pdHcIE4AnBLUzzT1hhvGtd6oc4g57x5B0KONDBRfLn7gIRJk2wDsEu06TAbftuMFciH/Ssx8NVfnHjWWn1rEUJIX9WDhALS73K41dJP5SS1ZQsenJs75miThz3YfKxxjqw5pAQ8ApWwCybAVlc33WZrBjN5XPMz/vuDcLXBX7fHox6A5+wDwNcZn3gK0vM5aGYDARN3Q5Rzy3CHAY+K2tBYTaK4YAJD6ImyY/tiL/9bxue2pG8wUkHYj/XudsQYbYfx5Td0A5jt7ByysDfmkh5KrUnZUYxGDWdrK4XYEpVlUTVrxbACJAdxsrVYledyEjwsqBXwxC65Vn5pSxAswkHR5OIlLAE431t7Gcl4sq2j5dF1hXuqDIn4a0UMBjdiNHdagBhUAIHFm3fMAMeu0ZaYuLIETHNcIOe16cZRepVf//+i3KQA81z6D1ShVYW/dJQHE1Jl6mpQgK7TAgeVgsuc1rj8TAHAhMZjwqu4BdL36EREpMSlI/jC0TvjOORUnQtYjZpcAIzVjZ81fldcLLGHjCxPV2TJ/nJQrhkrvEo9M16VuSgD1WN0BuqA1SHME8wU+dFK8TaByPL3LzuCEU50tbnPRAOzo7gEKkceAzs/e6G3jPVC76uFV+m3hzzx3O9KFIQYAN1Q6ODSwAHanwKImfGOX5pv0JogTAJrbGXvxSXexEAAQU9s91zklzpVYtBFrBJspTAOpgaTIqq7DjYQGhUPsANmBJ0Ywl+WLnTpGGi98Q98H3dJWmFFu1Z5VP9WOSDIA/jGrnzmQehEovBr5jojNsCn+nqTw9avXhlpffp+WNACz6Q7Pc8Da0ZHxENwYIZpDqMobw0D94x/CAqR3xyS/ACs4NN90KD52A2kEfaQiAzzorGh7N33GqqbW9fYHV+4ApHIBSVfkat6EbURFcusZPonPGToTL5Vx41cWSMkdjwAP8A2HsN79I/zJ0Rp9wZypuXonCIA4bSc+E4O1q7NYAM1ti5NsY++vZzHKoLz+7+huama0Ahk50wwpggsmJaAAIj8GM7PQ3fOK/UGml+29odi164X3husy3CFR5HYKlgCYxKReTXIle2ynDUADTqPBaN7VydIP3KsjBYw5HjiHAAb/sQ6fsmCn55PS10rXUD5Ym4FZIwTYpqvmsm+OFcEASwkK0cJgGdLU+4Gr4tjHQHFubn7lkBlN23JO135RAgBFSXetHqj2ogDCEVu+UCEEpF3yV5rv9u4vp6NYgNA/ABt5IvZmFbNPwn8iwM1nzOJxaUac6Cn0O5zjnPUE6UUAfn+Y7Q+VJoByM2JSFYBUnRGpIjqXaCmlabayUUs4xQB4ODiHlLQF2Gvu4F6Hs01Bpswmtao5hjgNTBMqEQF8AMVuBKJfnaJ7Wau/3s6S0mF/KADevX5DwzcGIYPpdmUA3d/BkqdZnRHCwGf4xBoeOcaUwSvAgQcBKz1efsgz8gAaJ4LGikWS9tKwzOyW4dNxmqbUY+EUJ99CqygN9PRgABQfCIugYtfc+AckWLvnUx7hsRJhvdHLXm/+9YrrN0YAS2SRjd1RnG+ROB/volPQI/5EvIM3E+BV2zrEam2YsABW1aJkzU5iAgM7m+Jx44CmL/9nQToIzqPtIDIsItxcAAP5qoCuYVCoHzQdR/ZwWc+ECSK3E1YkfqCwLCHNrmsAT72BDGd856DvsVmw8FfRVWNQp9QRXsrINCcFrabdagBXq4v3K1PB5aLpEkLRU2f6eC3jyGxXE0bGpODYfpbqAKUhGY1vThX7neH0CwvxXtR4WgJzxorF05Snv624rJsAKXiHNlneAAsif2SCVKyg41xVXYAtZ860TEaYCilFEwAiTHpRXtoTWYIDla7ffP509RycqfSuuOFHNAbFp4uTAByVX3rcxeg9oeDqNKlrbDbp4MGIzz0PF478gHuiPO8Aib5azoebIy72hJS/1f7+kPZZZ5+maW+8nNSRmcPdBgA3+y4QbGcKqBI11Ll1HBMY0dlPWrZbfbezkxox7ie2AKjy1nPGtvRgvUhSqdsGb7kgOINJLiy8lAwvc6f1HOIAswoHV5neQ1V6FbPeFAzsD5H5FTcYeW67GdxkCyiorwBsz3jAq/xB7nZQyZIlH4L7tc0h72KKon0Aj8FE7830AB9Dty5vmf7y3S6rvZ/AnO0kDKKOlWyPJDdXMlkP0LwAbHDlAKq0gdK1sMixj7UHj7AGXf9dGnCEYmJbb0JF1gAp6qiEQVJ4kW4+eJjKYYLlqk2lXg0Dx1is2A1Q7WZaAGGBwGOlcsGgy8V7zfNqdxFJDTV3JqLDQmgSJCpbKScAgTGU7/TvGHbe/WfD5hRpx4oSKXe8k0RHD6lankkDVwBPDFk8DeVbv1Hy3OpRrpYcJSoFPn/ok/QQY38fdK8jAEX2GbcUzgA1qypUraFP0DT3oJiZ2JZuIw+3ujj78AEABbpoKJ4I22NjqC8TA3igi8uAfdsmB96AaT4oeO4TPQAskdqanEJatiNoHKV/9L0mBu8JMuSVKP3mEbo2DB6xAPD3U1OiU5qMJtscxipsy8tkm5L4hpjP6EBYLaELCH4Aaer+9g3+Evp4ZHmwwlK5vPZBj2VxrX1gozdylJZFfwC1pst3XJn972eBrHI+/wuDArQhGkWftMOg1TUOzX89AENiW8o05DFo3h3/0Nmx8KqZfmYQPerz92L/KPfnSZEAnP9Z7WwtBhMR431rtT8uj05vKi2dV1pA1uy/OAShTgALzuRWJOLkE58K7T4bs/+CkeR1uDRzpm/vDbXUPbSMAJkLVWfewymqSb6SsOm+jg+mAy76Xj7Y6ChiHv2QvPEAJAz7HNbuje87Smd1GamEXiU2+e/O5PTmK1nsR0VI2AD0g28Z9UlBE+XZGSOrvgt5SOQf2Os0xZ4oW8tdCSlBAEsULHL2u6ErBe8k2QgzHN0FSs20TWLK4cFk92++YT8A7RDBxlo7Z2WI2m1e4hp4tRPrc/6TIMZPVJ9d8XJxKAD7ImhweIwjO3iz9hRksvK/7BvbD9GcOQ6BlU3bT1JtAE5WetPNQBGleANxvLwfcHyY+0HOiL0mRh7wpEzjYZUAZdzGXIMKBpWG3pOohr93UxWRmw6iVt3zKo6DNY8P3gCKoqwcZsNQwHsvajO0cFkg+Qf0aRuaG/bTRsHvyT7EADauQhcQfKBug9tvZ8sYYltxSY+Fl8TW4GfFG1XEQj8AfT3bJ0sboIM/+WxOsI1DdwBrrz0NBwqjqgMNt0HSgAC+m2/DYZQ6zkO++irImdMh/d01WwraggPNodo1U8AQAFBKQypv695PUE6QLXlqM6XRB4V0V7jGThnl7GwP7t0Aw33F/smSl4uaiDss+s1E3RST4l73hpEY5194RbopHQCXGxJCKO416/zFqiOlf6AzkZXdVYKmiofGxsD70pC2ABXEO2U/1JJzrNN6RsW7yrxQaLxXzhsrly/sEg4h0BcAVy8b7t4yiv9mHX7VmAG+TepfJ4CNRmr50yL1Zs//XAB7jvOnEDCHy/StArpb+Reu3ezxkVok9Qc0uDkvsubWANwfPwOXDIWePxUKF+whY9NqdHCYM2pOLMS/lArc+wsAgZuWRKjiih5DNbWzTso1bGAnridktEXmD7jlYY+cqABI0pnHRCTBzhai0d43TQjHKd3CPI+wULm8MGnURfx9AK4qfp/OXBVKxoSJ8Kfhe4xzRphrXgzOUNNTrfZuskIA9i1V4CcT9T3UxNYu4MWQfBEogbSe9scThbNwrLTOkwBRv+47za9+Jxbsy8nqG/5Vs6FfVjtuhrHCifr7tFq2ANOXF/K1hmm7gynmTMwcL+QU62jJentwJeHMEWQeppsAGDzM+qDpfXbLG7N1XbG1GLd9+N1W00aCXQ2nhI3pYQBiCRP+ql6Ueh07JFbJpyQRvgBxiSUDokTknKp9tOSsAL/y8zORNn+FW7YBR0LvOZYXE/qHVW1psEEgyvXxjUQAg7v8Daz4/l56AcKj4P8hCIhZ2/FDa20eUVKzoy1r7ABoouYr2EozAwnPEaiUFPH5n8SfgJET4x9Qcx/7jRZzAK8ix/1h1K2smcdE4HYnbEvtmQYCV1ZXw032RdShNNoArM+gFtNYIFkUd9RPNp3FGGEcx915kV6Dz8za2zu7fQCV0c5z90AUutWvvEUfs4FYyecHuzKaPcil97blOpF5APax4KPIpYOc6fvuw43igICnyDNVEv+IDY81njyEp28Av8WGG6pEP/Q3g4SpPax1xlTe2HP517Rtrk/Q/OENgAA0uymScMwtDhO72eNcQv1vJWZO0VOzDRK7e8KW7C7qADAQ+WgR2OvObg9339Nul1ufpbhG5uGGSiInirj4lGkATNwuDadlIHLI+woWQxaQuCGp3sqfTBS9rwhlxwncPQABNboQLs2u2OQ6WEnqaDm2S41G+mnjMVzh+Bhgq6HfACppiHChsz8rARn5D1DM7iL8SsUreS0PKE5AAkfCqEYAfQm+kphaR3AKZuTuenKcJ62IjQdpczxOds4iPyZ+3wA4X60oN6ROxr+6E7sznym0U2UoJm4QhbuC92UHU3BPAOMcsOp5rvMdSLlO0TbAjIOHANLTV5Rtqb3emEiqOD8A1SdxFo/V8732t33ND3nI5PjaB34UQ2U6VpyCcvoy6gDs8WDb6Bgtngt0r0D9HYmAO+zquLj/XcOPotxFpyPhAHvVXJWCsVUisEdTGgvbMK/l/97YWfoZ80pJhazroAcAfM7QJqfdVPZ30IZmKx8pPM14bphwlz/cUF0R4ELDUQCQPsEL016bkbr29jh1PJnsR+UzQAqIBhOhZHGCDhH7ABuCn8S7ZB7OMgIpzOceVJkMUpuWqmk/HbqdW3d4di8AfDUgk/F5IGlNjytzZl87pzLN7ureMj0MS/HluFiQ1QBcbV+0exJYMxLcJQHSjTRXRlHCTVP5tqXxP9G8u4eTAHKl0TmxjVoo+COqG+GrWXVzLp0Tm4Ex/CmvjzOKxAYAFk9SmJ71rNFC2GPG/q3ofj0GinW/vg6L8FIjcUshTQDYxFxMTOuUBBFJTZV9qoHxIaHfEZUtUh4v1tdlui9EABfpBIL/gnKw9RpQgwA2a7CLJ8pXKkNo6r1x6fAUJSwA0VTBJ5i4fSjF67IsZa6l5/+Af7V4V9sovz97kkAZ6wD3M6KmtAer0EfK7j+00VW4EDSjfTTU8CD+RiT+K1DlANMTk8hKr465bv4sV3F7i61f0mDpYmyuIuAEebNPstsA/yBk3NBkJyDWB3HInyW6pEhu+GuWMyAABau8sEjZ7gBARdkQuG4MV0wCUBL2oIMRVyeKXd39lfRXW8xqOzbUAKvU0TaZBoVDrihTVzrEfpDKWaGeNNtvFULV3/8XN9gA2u+czEGdkXwT+KzHUK4gK/4DlYERqhYqduV/eTSIewCInMXHRCOj7tCAVg14udqnX+W4pbgOyoJrLq2ww3p4AGbtNBJ3nwkKFNNYLv2zwNLAWkc53mNXaNRxYXkG1GQA+X8FEAWuAgvEwXvqQbg4ouuIpGYlVciNQ0fnMiNVwgDw4VJHlMva5WjLQn9SJA0WLt9Nqf82yguP6gVOgRiAAFNwXbpfxflj+taTyCUKGULwYWuXK6d0HQ2ru16vrpMAP/sFxw0CTYZZ12rlggHH2xBdbjThuuPYSEkvOpOFtQBLMOmSGcyoMvcSq+s9qQLope9tqWDW9RFcLyn9tux0AJJSbT06YaY9xcTcfuMLdwYg4KVWWjSJXjuQ4yfK1fcA8rZ7Cc8KHyc5qdgx6NkZyi4pGu3g6QfNfBQwZF3r4wCL8oRiW2AAVBoCW8m6XzA9+ccnPIiwB0w5NGA1Ur1SAAtfiJLq8+mu2GqQSZXoDn3HoiEmAUYk3ENW+ez+L4oAFDsD7IcyhjBf9+5tqo6UhBF/YBsll7B08/h9o/VhlwC/T6o3K/Op5fju2NuAVWk9ymVVJ94QFoFNxWYbQUDJAExXy1TH9MHMmccFJLrF6fP3Qp6VSVBCo7hpJbURUXIASSk+knYbr0hJq6ILYTs91K/N9OzV/WWQARQZdw16zACZtx8CJ0Qv8QjJmpMRcHnIFt+Gsea/XwaZe9rVj1rHAHZ59BEjJ6gD7wotVJUC7EWl9bzDMbmQlKUGZtl6e8kANylxSNxGlZFQ9iWVaJTe3vH6iNFyzMffHb38p4uOLgB53QqZMBTa/rb1uytFez8HIHxjktMj2fjCc/irXs/qAMz89JrnuQDGAuUL0UiLHKIzMkoM4LCZx09ByRYV/84ARaX+vq79X094PJ+AS8KBZoOtI++gGSJXLyaPB+iy1wBicoqNQnq5Sof7SmL2mbFcZRR3pqQt9+NUKEWRxED1APd7pYAtmuivFLXMI/0U7ot71fGirCAVBY+lfMgvrg0AplCwo8vklPpcALspKt/Ty+JF2sy+7yuVkBEwVv3NCgBMTBLjoLOZi7Gah8SnkjqQdDDYE2NMF/R/px2gBfNFAIiTOFPLUrexVqJScTCprSVAjPiVBAwLQ60oRuDXc4cAd8UM5XzGKouVw56s5qSbF/xZeiNi9ChW4Yqe2ZOK5wCtlhXZWWPluQIpUKtN9k7l5AJTo148/z4L1+1vW16LAOtAqkhC6QyKQsB8fl7X+7odhOck6oUGBRBuhF7sjLwAJzyBAD2CF1EFNkjfRWGcCKDnBL7Go6k1kvCy/XPHigCiR0NhWRlGhongcB4gNU6RKpMHjHXvrIwmeWhtA9EOAHdba5oihM5Kipwz6MhbHWvhwUEQ4Y2BRtiMGlxT3qYAKmw9EITAnaUcMQ97MddxhvZ745R8Dtr14XSbep3wbgCNrt7e7d9I7aa/P8Ix86LUyJ0JOwZpMTIbPrKIhQp2ALJ3oeXJVazAqVyk2DghOhkWul+b7entiyNKhslbh4cAS8yVZdZdIO6LUDTm6Pzmo0QBq6bRQj1HmziQxrq9bQC7ynxMuk42oCpYo4sdycQKnoIWXvMqou/qAKnZOtTfAPFk/jArdtZJjGv4n+K5YdR4D5PV0ldi+WGDAZ38pg0A4T2aOVFrun/qDC9pUfrMuZFZRUcByUCecooI+Tb2HwDM1Xubl+7OcZ7uui88RT2K+JBEse4XNNUXyxH7dH5jAK8hgQOtI2Vbcmx6LPhOvuS92/PSRTMoNRmGNZdglB8AlHbVM9GDzEz56C8npCIMIvvxcO+91XcyiKw/eqYK8ADjQHkcDSzUCw/p/XSDldZv+LeAa45O5itus2olFiJxAEpWVaa9opJmpg7YwDtU+xjtcswdzSmA2crTH1JeA1gAeKaaSGYfrSZI86GSTlMydduxkG/kHv/7MBHJVGoCDgCX5urO7IlEGTuXkLFcGHFrLaWpE76hNoak9m9HXEohAOfLtfpgJexzTBTEjTKrdM3jIRxZTq5OZyvGtAoHkLcAislUW2tGmJGhZkXhpQOXEMR6YBg+jqv3CIksA0mxEQDnR4A2EIgD5zQfo7B55AzA9B0DU5K8N4b184Ur37gCAH0sH3ZaOfJxopIwNysmq+GQ12eQia52qoduLf5viJcAFgWn6eGR6qk8c1aAR97I/2mxbcyc74vHjOUKp7kcoAB3QxoSalfwHzLWa/zM+IeeknQ6TMkH2x4PPH0ukt4XAMNiuNTv4MyeP5swep0eRjspnIQvVhojiMppGm8sRN8ATHB1t1eB7W46oO37oAlVe9SHwbPA4NrZQ1Wxu15ErwAfaVRnsGrE/EM0d0oLCZpsAT7akFsNdILT/5fDbzq1AOyjpzoOsMzhzRa3hFsRrYKCeUIQ98oX9JKDH4iTlrkA+k73SuNZZeVbHXg4wrVslM/zB3sy/v38bkWBnW+2CwDUBcO+URPHXrY6ZDr98w7I3y7MlqUWxYFC+iBCi8aVALnBlbJcSfJMP0zs2Tl9GAkujNglh8WcNIX+TQIAN+8AmHiNy3sUlnUV3o5GIT3MOSjni1iy1oqvx0b52BKY3gD2NAvgfMG7yKxDuOGFhhawdbxZHhjC9L0ehB7Q2xbvAJKqINqeEoFXd2xj46HWUGhlctyF89gtHOlKBh9lF9kA9iYVlmXZ8bu9mwe+7qAksmr26d2NvRTyY1gB/fN47gAvpSeCNxCOzmoZKn0S8RJta2+MqZBuSpD0iUs6YJWmAI23MEKvmDauiHGGNNlYszWoom9p5Z/x8Ab1vmFV79kAY5HAn8fxR9so089zs2pwGDJwksAmwArJy1J9GMK2MAANJFC2WcU6X6xk6u87Z7/Zj8w0KYELqBGpIuQF2QLXALREAJB+tQUsY6gKfE7O/e9ThP3/48RSMIK/ayrVUwsAEbdO56rzex/Us2tH+kS3cAuTY4biyyIcoSFitU1tgQAVbKw4y+V8J1d2q7LdpKOTdDYiEfZWpVkGlGDPSg6RAH4vVIInKjDHJLMKd/5YT+nF6PqzBMgmoWmc99yZZPQAoTgsPT5+Q6COBh9TkQ+zy+GmBRRfKMewV85DJhCA1ADdFCboyoLmTsR6XdcA5WVCrJJ0LYgOGiUswNg2DbcWANrq/dPolLIDvOZ5aSgu2H0ITRDdrnvuirmJpqKNpQQA1qf6hRRGB8yq+jajsrLyy/Xa2wTpiofYLw0T6AqKLAAuI21/zlvjjpSZnFq+8yZfyi517Us6Bp7r7zSLlyCPAEalB4wXUPiXtanfDMhhMd8U527HVhmEpMu/nlYaY9IAm52Y2VCb/mF2Ic20mlCdQwMbmDDbEQwP3m9193BdCQCKQgrZI8bGl894I24ye0+gZyM54gR6C6u/fj2U1maJAKWHALO+0BKMUkMU1Bq1YWs3nV3W7pfaCTc1bfEUcMsAqyJcuilNf+UIlTgwn7kbBgf2zAMInFmhmwfLHaIEZgB/iltj6GHpqIt3EVRrBOtey++U0fc2e3iCYxycXUpEAIMQ4fc/tiVP9+6A4nsf3xGoSWoK5GBxth4B7g4PBOUAUAt4ugxMNhbrq9RDY4NNV2BJO+k6GoYqwtVgZrJjHgAmIU3jvjReuQ3tpkWrDnsQwAQAfjgAXqX2z27dlN+fAI1PN9vMUqXgv4kr4WGN6TewDKaYb1pJLuohqbgral8ANkuAYetg08YWy4seTPdxDCLOxaaYCETFT20IdVHE7AAot8jLy+fmolA9Aoa8jIV10MCSUMVal0ifJdc1kR26AItxLGGRV7M1MsUR3BdgKQV2uBYmu27q/eNdIHyFrl0A1If0T3iIKgO7bjI3PN2f4Bx3vQjSZq+tmMT8713uaAD/s1PV6JxbYP9nsyMWEUFsX3gl6DKeqx+9s2y8SxNvAGtJipo6VbjpiGvto8oQ9yhG14y8suyTqNbrOgJgawIAe9X/uscZaHIIV9sUejgCsMVuzUrn3d7P1NQMQ8BwAAD8E4cIIoOaWBobY4cd0CjjUTc89rYqNEZ48qS4kHlwAIS6xAPrJDUUEBM8TUAp+qn7SFNWgzzWARJp/e1P1nQAC7gPz0mzv3Plv5E6DLfCC15xk8whjLFWnJWIhknXiQDObqbQPiK8U5vN2+sI+cIxggbn4Vht8FJIYTo+dIGnAOYV2wYQKnydIFHWQ+CH/API5TmmJMKRjr5ZK0WfS7YAkoofU0EPqcvvXFr7UJYL2zpKGQHsEekQvP9WlPx6agBNNTH+6B2KGpnMCskJeECF6WJNKCKRRZzz6aWTTz2mAG+D+wn3Uvmu1ZOX5bO5SPylhQqAj6zkB1iFVpiALiEAlcnu6AKDSWc9XojE186I32+McOzekdy9kyXsrUKnZABCEuxX5QwMvtDhh1UsX73MNjry8P2szcfa6neLFoqnAMitb/iZGsxuy5UF1eSycwibxUkV6ZJZ8UiR+kbDdcsAj4uOPRe/V1wyODgYcxH7uR5Yigg/kkkHMKqTc6XuXQCLxzThwa4Xo2v+8ZYVMF5YZB6XLEcDAGiQ6rWKt1xAACLXSAyO0Q/hkUG/nH+iGjnYb4XJJqSRdKmEa2SvqWkANLTwHONqf1vW/7321JHYj9NOKtNpCahQZcwSP5WqTACRa6yD+k/WhNYk/HCH19IJsTQ0RIAM6LqAIKsUSiA/AGsVcoNvlUnKjbMd0KjfjbnKDveI6ELN9W7RUmkCjF0AnleZQO4YzFjUaRdiGwX1mw1Z57tjYt29pJcbKOqIeQBGdmKx5wERL5zn1FYORJJLivP8tB0+fqIs8TOdCQRDAGHvNLHZedpSUNiUfkCRmE8lnWaSSzIpnHBY1AdsZh0AvjW179qLO2ELSbSStDJusf5umfeMWcRenCmPIYFT0gDxbQKJ1qnlySLTa2OLiMU4Ou5f8qyv49bjkyxvi7X6ALTC+ApSqqAL+n384YPQ8/BGripw3GD425xyIEDv55YAPyiAFdB3bwCj7XoR11b3iDjM5vRi927cqT+NITpuPAAx3AqEWjrnCGuZDxSvNRmC1nGfnKbY6QoSJvEdVcWqAN2m0DC2jUXHeCALuwWnvIsR72Zxuf3lk9GoTRvZUdoArMBISgm0WHyAmKpNbTUZBmSzdm4PV14m7YcVnVSsQgCsBXGx+XwPsWOM6wat0/BbkGnBwc9HAGipfEf+xvxpAJ91v8fXIvaZySLXtSaBFaDw91421JRMihmIOzcSo0kAxP/hmLwFXsRrXQsr0a9zlVQqrIOseAg2kD7RiagsxADrbFV2txEaVO7JrxrkCU8DFTyNgwbyddoGCQcL5YKZAHaXfSbuMOAplJAKxbGGHlkT7jctVZQjp47YiMxzR10Ag8WOA+5wTp0gHujwFzUMND07iqunRS85HyIKG+3SFwCNr9vukySINbM0qgDBIGmES6NFVJUX258C+MMgXLkzAHlSRj0NssGpPA40hkKHBHPgaXD5UTe79oIh+z28xs4AbNpFJ5wo7JZAw1hDtYWIT0RCusYg0NLwtatZL8FNjACWgbpObUO5Lttqf+7CO40mlGV6B7/Zlm1clMcAO+g1AApXeU5rRYlJ+lHbjiUDn/+QTzhmzi+/dbjXEQ+13KYASs175Gbtj2A3z20Ax/uLx+OF++9/7L21SgDYZ08o6wD3cM+trLXwzL1yMR2PK89C6k4cjDBLY1ZMhm+uXPcmANVJ6n47UDfj9G/CZyGnmYMMEtE6VshkT5lhc0lYfmsABEt2C+Dvf7atnF8wxGU8h3XnWWwDM0SToWb/02voPACkYBw63mgXAtFgdvCgK/OzfXjSflOyZwjJ921ql4xjAI9I2ArhgwMi/ZympMKD25XLLUEgsVN6G9TrSa5VXicAhceLLhnDTRxdiJJGqTe2Uo2Coiy7uGseFkrUKI3UmQD/fEWdYNKhLv9JP3Ou7GWjVobdBaEc2VqKS+OnYyxYAHUL58WgnhQ6hQPGXEA74CxHySA9bYIFIIXuDJeKuUYA0v30ezj/EX787OOt8rPVJGYGroUsMPx2XU4aZGu4swCeSv1DNdM45bnD+hEkXGKKMJmwja6hOmfpbOrEGIGvAEKb5NbomXHYhmPSC535ZiZNJ0NvOTf5og+DGZXeIAoAWq2u88ziP2/GAotcQIdw5rGjvKtQHXmwk2EewiDm6wAdBj2afCWeVIkR/ZgbgzynRGLWEoKV7iRa9ip2itDTAG8kzzppao0ZSnD+xIEnPwCi9n2ShaBo/xzNuLa1mroAlyXmURsr0gvCvek2nY0VkhDB3nZ5/t2afBL0CXpdvgCFSzFfmOawDZRCHrpHbUYEtthJqpTHQ1iXxRixWdp5ALYapbLzOnXvgC0FQSDRvUNkufdfhO3kmxxqyWyaTSoAcSFCaTE14wi9Yv6OKuFmKVmi9sPH4o/I5Yr+WeQ3pwD5Axo7pqkAPlcX4rtvHuyEk4l5SLv62Zn0A3hF7uj9AGqkmYY8PKOF3qw4Fn9mzK/k/XVYFmEBZtHMt7u0TywAHd75hQlLO+IQAH0x6r6AbptchImHFZvKr8ytIEJJVQBq28O8UHOl052/o9oZ1V+aSdTeH4FY21vRJnV1sneOAF3DSIuL8EOtpLhq+uJ6LwlNUhaVZzk0AWEHS+8z7A0Ab6bv2Nq/IEz9DqISL153sZoXK8afuVbcH0wh78WHOADHOOzDIu0QVdLJJzM6r0F09spPpNek7vCtJ1MiDR1RANyH3mdMpJYCdq7W/NX02tVNquy867tc2L+n5nlidB4ADrGdowc8hOhvWY3kp+0cx0IEvUJaQhHV7ajD9AIH4QBXoIyoJCcqhXpJgpy0p5AcP4ce7hY6MFb3qKAMLFMRAE2aDgRllfL0au+C4k9DRFfEYW9tnnwFIWHaKK3Li1AA6MqEVE3ntmtGjnDGtsZDmSr8G8cFUbv+FROUZg1JQAAyjYt0PgMu00KS2AFrlGuEIAp7yYcbglNhEUDdeyWIABuPtVXRkz3pVnSo8B7P4PUdIcAr486cnpoFmYJZeuAAg8K0pvnDFTzDa8mAoiqVsfBrAMBKsVgyXl9N/76bYwCkDsgkq48v1qSNqCqYfHZq4Jf/UtbdapED1rpssP3AAC5mW79kTCx7RE1nMN+X3dq2hqJhMu+XqhmjlIRQSbAAwGdTeWoQsQ1oQI3JpJU6U1g2iRt0qNwY5/dPkLWs4gASh8G7vbsGmNd4RSuzuf29Z0ZN2ub5DdkgLU7s4QMZAFNIKExqq4KPGZUL/qDAIBHBPWmrZZhQfl6KpexJ984AsqPNE6XXVW4tYMv2N7AUB5F9q+sldSBUI0TvgTpimgBnv2M9reNFV62ODWOFf2ttj6UnEv15hIFLAYdVFXJBAEozbfvA1JRiJ18jkOMXtKQt7NJ9YZKsIRBlEVuP6IQApCb+Ll9mAL1TVtOALAqSxF6op7bqMswQPJf/q922TAAfZUy7r2lbRhBb5B2eoaxbxrQbyi+hBaVq3ErLxq03AIkLy4FFd4YdHSMoXcyGKoKejvNZDa3SsDrKayUeLKMAVCEgrxYz3TPl02cuFTwGKhlY9FnAmg6JpIIq9YJNKAC/VwdRyGfVCOd6TjdIzigRIiIvHhoU3etIaBehWzJRADlGUpVYGaSCWpQWYxGkNQgv8RFJmTZ+zbMwFr+uuaEADPdhMcNLsdiAWpArsKzUO+9AYwm2SV1kaPt6Tdh69wAdjWzytJZfJ3qFPDBgPvZUc1CH8/+ygLCIpg9YWQYhAAkM1ckxjoT9t1NU1+feRlEOMSuXzijRxgtfxNt7uP0Az629Aeeeu/8LPVsUCZLkBulY+NUqNJ6CmGt7Xvv75QBz7I06iZbh3Tv3NHO+EsqS0JPw7ylTOhbM9GkIQ0qBAK88mx2D61GajMqhj+Dsrmn3lwjxde95m8VRZqZEPn4AvCeMR6+pUoN2s0csdYVTQqrUhAdCRG5saChfCdzftgCj5KCuHAqNoB4a3FbLm4Dd0Qd2DXSSUijeZaZhGXIUAAt4urnRD3x61nE3LMgWBPejzj1Uij6dIYsyy0Nj+kYApSZabArjYPHEPEBj4Mm7zZ/ssuDVHxVQVrWcZI6ciABQ2gs7dE/cAPlJ+8ZUyWtZkTZGvIWl5hUlTlQuBNpcALCRyYk9nPOfFxiVmsZkjH1ZVAnWHjLa3/M0pvyf7KkAG61Ms9XFRPuOKXxYEkV65zRdZp0q64zmRWgmOoBs4QDoRvsdcvB/tohEc7yjFS3XNTb1VdA597Mx4bNGMLSkADhvq9mIHwkjwkb3r+Z8EY4fks12TkfL87oItgDKHskA9NacJ0neXcZPvt7fuDdsz4LoHnIHoq59JRNh8/582wAcNIyo6eFUoio9dT2P9cXd6dHCmIlXCX6MB68IBjsyAGsQvuwA7obemqyPPf0Kih58PjihmIcELBwZ5kkF/LQANhu4L2uPq0C4Ss8qIlG+BzvbHUw27wvZcKguIXJpIAAkaEZ+YBkOxp4PdjPd/xqVFK/64EQasqYV9OnwVG7/AGJywSorHJQGo7AJoquGKy0Atbluvx+yqb+pwDiPkDMAGUdW/S8k8mP2AQoqMN87sH6cI9fiiP6ptQ77g7rj2ADjzsSPo1zP5wm7IBIoHTMMiIvmejb9ZMO7+UKV0jy9AIspgkisQ8vwurelW0jv+bTcHyk+8FTj62otIiFlZ5kAya8PS/5uPwGMgpRL0X14uQKIXhjDhfcRj97SqGLc0gCxi5861s229y24uYepTU0hp4JEzvbj6UOrrE+PUlicAL7CP9/+P+UHOSol+s3wDTfy5HaO0cePrgDBPBn+uqAAwaUdFvc9wOg+58OJ24wWa52tkyAATKWKNQgHk2zFUwAOybR+EPm2qKQ/hXDMLOMenki+bMKE6+KK09VgukNLALyZ2rwrfDeLGMGO+dow1iIItVzP2MGDADSIDjnB+lgA+rM4Cu4ui4qBC6s2qebhaS/KGYKOwffLZbXYPoNR2QB5WN0804bVMMx8Y1MrtasAE1a1Y+Buv3NhJMlGFcZLAEQIj6LU/io0nt17T0MG4Nx3dzny4wJwpjGeDQr++bIAjM90/pKbI/zHuybl64lhitbkVa86aeo19G7frC3PIAClrG9RBf9TZdrlFU5c4/cqyBB9fZUwzsPqxxXnUywPAGH2cfTOmg04seGE/AorONx/zVJQiGsYtPVy6bu3YAIAXpkAsEDz0Hkp0w8KxDo9kQJA8LOWRzSsdDzPmqcdoQDgEt8O86T3QyKw7RKNKQs0UhX4bYMDHvvQBIiZh1U3AGfj6Xw6huTIuqzB6zmV2B1N3UnRUbOFrj0r8z4XUDsAOk1u085+VCw8bU8A24AvN9etFay/DC63yMLzpIgV5gAPmWdAxtwTsJNAvNzgyF47bvB5NMhifzonN7stYL7cAJLTH1HJAORJ1z8tMc3Ke/gix9KiweFnopMQxnlISMMAw6KLyKJb+VMBkn8cd3ZtABF4xC3FxZaQF2D8MlOmWwCVk2+dy6dhwOqXQEUkVLoQvtiheBXm/4OjtAklaSaFANSnWNLy9gZfjR+kCLbPPEYlVjbFNiwU8g0g74NeUJEAVVHsj85fwueTRpfXbQsf8Qck6/mdw3OmQEP6qkr27wAAsYFzkPCi4kfFwaMoUm/ipY9AvUCBSy8CV9PrVE7+AKWBS0If+6reafSYbuVO1E3pDHf1AUD8MJDXMy8TnDIAVJ3c4OJ6fFLghGPH/l9Vvflh+bKaMs2He81zzYpQSwDsKutE9Al0KlKrS3rGLmXSg+qBaolim93w9roQfMGxAOimy3ysKQqEb+uxTHqp607c7U2ENUMsWcSzKYDeZZgA/etHDvT0jo2Bc9FfG0UWtdKt22WnOaIdKfbHzDaHZgBa/L/ferwDm4BiXBZ7cJM0EkNVbAY+mLTQujDy0nyAAHm8XO7gvRxucbzgrrrOslUBBUQ1fNStSsxtslpw9w8ABKkUxO9FfqakTTz1slu8IJ9XMTRPzB1BDOKEnlFeyQDCIXwmZoQqT5SLVqCN5DZHmt3wslt6de46DZQxz2sqAOH4PlTcVuFbWyqU/53PXQiSRhCWt7m/+9voXIUrd04AQjPDGhHr3Ixgjx8KsPcb/nNzhn2U642KI5fcVqXsxwDXgG+A5psiHdxNdqQcHH6Sb0dL7qX2q5fA3VyN+mUxADeBYQM7SziNSXZnMGPF0LOYpqlkRFnITHGECAxYP6oAOyJtb0hU3gl6O3k7E4QI+m8k0UPfpqWHGqCmpbNCkgDgEjAeNcvmS+BaQiqG6rkw93QkbEW2d1ZhZjXeEX9NANgq/ONPzijhOtzLAm1R0/MZRPwmzUd+Dv0oF1kiK5UAB+nHJmKN5XYSw+QhvYbFZWHqL05k6GTRaCySItfP9gBQCdzVdOWXxS/9SBEPnnipsQ6gXnJrDSi24ZPlnDmbAPk9d7VDvK2J45LkcqOX2UP0kpd324fx/7XtNuRaLP0ABpcECgSU00IjqqSo1rmekcTPYbDnIgbBEl/k0flnLAB7559/LTUQQLl0fA2K34GixEKKqJOVVN2vqyfUmFIkADpa/zN6j39oB3hC6jBK0G4Jr9ePadHCnyEPLwPtspsASDrh3Ks/npPd+Y4AkPGwTpE4167cdyjniktj9GSseABKnrTP2kKviL9+iGyaSA2UKv5tkfuWL+2c+mVHIE7aACAAM9Z4O7Ny1t9Hvs6AuN0+uCKRCv/uxYcqWqb2+ogA8PR4HQB/jvHod4yRXEbkK/z34s2HuqXCeqfdujqJagDA81ROY5oMTzxZCUeoBguPB6HORVH5W3s8WN/50AKgAPdaPNKCvmEQ7l3gDwmbO7twX3wRHZArXqY7nQimNekAV6gCkO2SUJeID2pm2IIRcp16ezq07WVmTFCoy3kRqAAB4ZqaIJeNXWcXwjXbtfaUPT9H18Taty8mqVlWZD7wAAB+B60lbifLQU3dJQsKHpLz7FIMB5oW0Dgux+i1mXEAdGO6LBZwjlk0MDpuHGFtlE+9+fo1lI6BA8pD7xz8NgCsllHF8DHKIOM3HM/FWexELQkTXonsknqcTtkGCygrAOa81lWH7E1pOQUSBXRHwZpJwzBTsY+6TFXPT3Zh/xUAq0Y4ZGV+N4MPBEFSglDhcAV+pLUhlfyxMTBq6YNrEABRYdWAYOiRENsqvfDDhZOO6vhALGx+UReoGMpmkTg0AOaAxsfdvPBpRr2jalyixQGbfrUsaNTe/98Zone9qkYAzI6drAyevKGH72f768VBTlSLgHTrh6lYn+kHUbId5QAY8VYXThQdM0onVPLTaTBpYZqPKsDrWKkYN1DO7ZG8APfibP8NnGLBJ2Hd7VPA+WMXiZ9taf1r6ATzX+G8+zgAyrf5nfQ3EjcwoDLRhvtSmVeg9N8OrBl6fbnJhgSWmAD2Mg0sXKeE2s8zVBvx7hXPZnfGuRe3TPkwfh1IthX0AMNfWlEhd077aNpHq0DXspuQ1zAvZe9BXkTIUsY4bA4ALajTT4uk7Qpg5a/P4agf4NCsKs3/LrSgx2IEX7Xu8wCZwNu9+1Q3yahC5oKbeizNQt+Q6e7Yed4kjh8ZnIsGAAx7mIJ5jsndGo94wQgRwwr4l1XhoRZQ5MrqCXphxJoA9avoseahxbYRnXhbple4+Y5kmzlmq9brW0JO+nqMZABjETtAkerenTTjg0O2+vPmPnM1bpB6RRWhED/M3kILAMY+wAU8XDjiV4PpOPnGVTDa0ieiJRukDZFCSyXKuRMAq5ZtlkbaimhmPdvZtm3jbd/eHcGyfynq5zm8oZfEJgAftBUYhku7wvupEECvbhhKtRv7pRdYulN2B4N3IGHuAAFL/TYu9KCJhI4zKMYHRCxQTTVCxsXlDbfd9525vZYAhplw2UWxXhaut6I9n7NXMcEQckHMm+jJcf9lrC4v2wBMfprK//vIg4KK9abY+DgF0jdAVMhWr1DTpZz6X3wwAE3Bc+uEw2Vpy4h7C4z8adZoXT9h+RzTPQRC40cO7I4AgQBKfLeN0c67KOe8JRt+/PsYnBwT9rq/9uC+DRGT9QCf/aci4+TxJAL7Ggyqx2Uzfe+vZ4Bp6ns8UtYMMa0IAF37H5iLrGQR28lOsHTP7Oe544fWlX9kU7NWNGjm/iMAzHWEpiGeV9TTz/cTHIkHQqnLdwKxpFwsup5RiXasLQCn0qOlg1mhJv7bGcUK00SdIYO4Am9AKPr7tR3jt/tRAMg2Lokp7SJJp8DJ4F99iWszBVaIEeUU42Y6oysGCEMAMgeAaVo4OClqRgWxxzTBr87U1NU/f4L6+Frr4+JO6gD3SIloQJQw+5scgrQoO5dH09pcnbB3XSHXkrWY7SxxAECEFqLcJf4dYkRPhecD/bKk16cxiKXGTqYkltJb2zEAdkcO8UHsqa2DKQ+U9o3Zhc6GdB0Bycp4os6QGGAL1wBLzG8IVTshLwqYcMOA8vbhjx6blnCDuFqAtI5sZkGVAEFb9zxrZ/2RIYO8msLEhPzDqQMRBDygFWRiXv5J4zsAQqfkNT4LZOOu9ZW+Oby9EQPmeHkLleUSbGTw6th3NgD3nC7+qu0N3nYbr3dBez/1C6pEY9I3ciHhceFnyx9fAP3WkXbQyJz9yjCgMoNHF148vpZrVMrWykTeqcZAriAAeHZ+WOg6zVNppJ5UF3FYwDV3XD5vILm3gfJCm0Ec4QCJORDlnCC9BPk7Waa29kgZELrsR2XwDZuJBRIDcOMcAEwMvgvwaC8PEYr8Q6yeKtwVDOISq1qO/Pyb1aMTQ1YAtr2IerTnkU3/h8qBCNh2skrASEjH4kKQlfCFiERRWwBoqmoTtF3GMch8os7R6/49fxzWYA8DO7shD2oRiuacAHSie7J8hq0XAWRtGiJlCAoCOIZwF3dXIK0bb4rZTyIAUv62yIRmJoL78IvNk8ppuarwrHy8QP8etI55Qvk8nQBrdnHalLBZxRUx3B1XM53WNbcpjLvV/5OU3nSn+VptAOqRAbD6XsNfACccA5rueTpvgeXhgRLDR7VOPXGPlBcADMwH+kmCqHh0j5y6oGdTv4D0NgvCu0IAWESmK2RvpgAx0GNdYK6sVgfoUDtMPxB8u2NrmP4Bc4ZJH5nGSi/RAL5SRRVobhC2Cp5EhZvyQCe0md83fmITgAhr53bB4woAF6sjuE591bu6dT3Q0TWUXPydvtDRlpTt0wjx+vHFuwCybUACdiLQMCiH6e/w74ergwrJSkNdTEkY8i2AjHvaAOcuOR24AKxmyUSzOR0J2WQWow4OnOMGQrKyY1IU5woA+uYlcqn1zzEAEr6ZAz/5+HSQ61BIGZtiX2FFxcvPmgAxiqE4Mrs73Ny9hrQCEcWZvEf1S094TO9WWl/usBanAIValEXLm/lmtO9hpIMrESfrJa+1jUJMeHUMnMJcgiUADSK6LFr4UOTLiWvfhDSPHRe0Kj3tI0H/PmpH3ph0/AAXzXI2yv8mIkUwML2w4mPEK/LB35zrr+ZWe5mzqLBhACsZHUB93KS9fyOg94lAI3NEk9wforTi9edpabGNEUUAysY4vvBNgf0m8ZI+hQRwfWUJQYOieisrhA7tfHh5ygC7koIMhmHKgEu9Mg701L4Ku0EvajEHC51cejoom2pzAKUwH1CejDXKoAJbJ50u36f3LdwHYC8qwEdD3B84CZMAfhfDuXyphwl1R4Rf6YbwzlH1G0+vc/CXbnqnulSc8wAcgi0E6XNYpsbgGB9eJze9aCAcLZ3CEG/BFqHp92S5AL6ctFdpGssG10ZjrpBkpcUvx8UR2UrvKFBOPtYn+T0Aj38TgV8Is+AI2sj0XciKecn7hVgaharCGnHEmsfy+AAi4xtQwkKu24HEhyaJg5SlHZY2FMw8ltg2VUYJudSxABdmMsZ8nXlEYNWjXlM8IvymkMJwQmkqb2YyDaARm1YAw/QXfqs5FWkuFHLcImfBSK2Ej7qWYkO/YQED+M7NuAD6o9nPzs4G00ZIojYpVJvf+0JbFwnzrJ4id4WtHzjcAHxy6LUUQZFWtRoBKIfLtU1G383ndBTAXzM/X0mR7vgAw0l8ceYc61rKpgs40Ewoy44geJs4+RVOVBLZs4SiWACDns1qpE4eAefLxAslsM0wZ5DByqx4qSzCvOq/DCr3AFUX0X5EoAoSLWqQnPeU/nyRH25Lte5K9WtLJKjL8NIAoxsMr/ljgLqRm+4fGpYLDuwNpDvF83yXElSH5+cOwgBHekXAJCTFeiO0CrRRJ56fuvTa2cXFzZ90o9QA7Ns+AGvz8xnZfU0N368tDJbaCvYFBx8NT+bXaJr4v8giN6sALpaRXMkrXdmT+uDbvRk/yyUnz7nli8m4qt/HlZa5MQCrnMJDuunHLdT9LXZwfdltGRJW8wlRNNQXr8LNLnZXAIZh4H+O7XmdbtzECpTc8aAho0kJTekhI8ounIWQXVYAvttnxK0lIs5HZCZDKrqQAa5mbWtI2SDt8ltwHRHAwQBzNI6bghSS6KLdAVx3r5x4MNECZw+dTaFcgrQ5QnZiADEgSxFtNgJMfN2pt4mVwu8kbhvkTEm6zGQGFpFK/UoAs/99tBRZLdI7pNFvxZOBeuDylR/Mtsj3sqLWG+/fUgCFnBdV/g4aX1nfMZrreD00HjzCCeyL3zZRmfBo6TeYAPoaLdgiGJ1l45osS+NEwnLKlYyvRTn8FxvJrrBAK9MAA5bxl9hKSImo73nqlkAvKkWDJ4S2K31a9i91+Fc0wgDX4YAxuDAngg2P58TvYmPm6xFSl6h+3uhT0zWZPihIACWkxnTL5U4rMB6YjmKqEzX+jfMb75ZQQZThX8wsB8QAfraSTDHM2gaxVKOSzwpmEQ/hVswJotP5a+cBQERx7gCWq4c4RVuCEGxe3aAr9GgLPirVvMcYnuGM9rS7NPHBAIhxNdUWityvC/pGgBJKUsQfZ9fjdLltrRt21Ctp5DMA8slAuHkTG6ejwfpKmhwsJ33OQ1NK7lSG4alVww7vrQDErDDQ8tFiv1VyRIUveGeua1cuWuYdsSepBtbSp8NuADNQ236hZcUh5XEBfnBod+OchTUFEZtVH/l2CV5cLeQAP23+Zu2K3H7em0DeN6f00waD+57xfpO6lfKgNrawOQBvsAnBl7ZreapV25ZlN+d3AvnHx1GyL1lEJwo/ZmilAPGKycOMO7L2zlRE9kLssERhTXtK04nE/ShTAEENwEkAAyx0u3kOkHK9gZSl5e/jleRQuzCgP0IbtWU2ibCLZAAj7OxNzrYkL6v0a1Dqq178q1JGao5nbjwZvrxx3L//AGxECW5BUy6F7oei6xfPfUjL1/rmLqv0tJwt/P8psUgAZTR2oUZcAR4OMlU+2ETQkSEWYHiAbi2bR7+wkD2prADPglM0s/2d1NnPwQi21e3uluXe/bMnkr84aN1ny6EhAI6/xW3fzjhnCgpbmeHggkj5X4GUX55WBNSfb0/j0qsAdfu4RRfkYpY/iGoKxTRi4Oc99iK9e+sDIG/G3L5NuQC+XZEok7gbTGz8OZc6p802/J2dwCeksFDoW6y6Pj4cAMKcZfYE9aoCtfck137JhU0DDizAhuozjX2BtqZwiDYA/Q13gRUOjjNKOBAG8b7UBY9ymBbKFrFBHWcGdXKcnACO9YiINMPXd4QK8C82wlJnYKWoz80iwYesBzfklHY6AO3YEPGSzgvr4HkUbxVv+n1ZIYRVFdrPQdQEsY3RsRIA0Zj6ZTUyK1qmUBfiLEunkwTN405K5xMBH4M1OT3hGwAUSn4Q+jejnwg8vsna4DSmfFEXadJ/mK5tEJ4ngZIBAGGPh5Ot9YCUNX5V59GsOF5KJDBwdAXzK1ld8wr5Cn0AnwcQa29cvkVDhPfxfd+7J662SdTb8izcGt1anyqDMADHAPB7TNgdxUFlcCC8K5b84XmOV7xakBdUdFj7uS4yADpC/8VVlxGkVqYqsq6RLu1i/SiSYDaMWrCSV1bboLIAaqa7Tzf8buqnRIHpSg5HvXhEB7DNHk6sIXofkiaJrwCnQoCVBCFK8Vcjysw5E8+7TALgOtI48yEhbUlZshmjAOnP9NJRMhG9PI0uQhNVYfWRH5Mh9+G/ZWQy/GcDxbkAenbRaXcTFT9NNRY68QazdQ6jaq5dJWK444ijimvOFAAAVbiYfZXEWdLzOZO38r9iO02HfzxtLdKKmjc+DGL/AEIUnBk7aYd50KBK6te9VZwgjMpf3SveotP9E3zdAZkAr4vXK3EhGSFkJf6GA1poMRrJyYOf4O6353U+yk8E5gB09hjsJ8euGW+tZXRx7ebp/Ss1W1kezzYE//Ud6qVJAM8iLRnRPw09W/APR9zqv38729CNQF7JaX40gZLeKxwATJ/TpYZZ+oHZwxA9FrXBCTZMxSGZ74mqtwxFO2CuWgC2cJ4VFfDrAcIyDK8JHpPcF8Gwlo/sMIJH87nR69zeACTft1yDygKyH8oREa97aMGtSfjwlCc7Y8YP2ecLlycAJGA6A3bK4+g/ABoSdGBPjV+pM2zWXmPj6TB40V70ZQDfKkaTunNiDLX4kYQtYYuI3dH9xwNVzyT76Zav27HtAHhoP0kBkQM9dAsmvOuEOutuhfLqRF0ltP187+3JEMkAcU2FrXIz1ayya4iLBRzoauIR4kuKDu70NkLOXns0cQAl+TtfHuqR1CQQiKZz38BQPe6JUBkUJYsEfhWWZftDAIpz1BNkw9Z9ZJtUyEzU4f7FwPak993Nzkbya9C5B6cABCclLJt/Va2n7f71Ri4nzKDctjeFIyVdMvEGXYgq+QA3GriSeSDwm2XgV2l77zRxVQYwVsXCknvpRHuu/q31AL8IN1PLznuYlQkGkBJE5usPaOHsnTxqYgp43Y/yOpYAZCeZYISbbesoajebuDGNid+mrzgx7+XxsY7SV5bUywCftWXYeMUyW2CqforFH1zBB2K3NscJWWsf+XDkBMixAA8PMejOxQpSDKqj3BPiDiPXtLzgK0QlegVfpxolMGoAJU6kB6jjwafKhPTnRorqXkR1EHChfj6sqlhSfLKGIAAUMfypgCN0g2paBwR9XE11/DHzC/1mF8pEQUR6Yl7zALh5692ws946PYJbEgPSg7H/Rg9oRQEJqC9AFG+qTkkAnzpKDT/CUZKOJvf85S3m9AAb5EGmivmTIUX90V2lAwDqkX+aSB/dPRyTtRZZ32UFOrfL7ZZNn+4zxpj+1Zi6AGTVjcnHXez2Ys+O1iLq8JSn0z5gRG+KCtb9EnDNwRcAzZR5DwI4OwiOHxwMDR9xRhNA42GuI+ZxvnbdoOINIwBF+WFovgk+pAvh+0O3RJQqv5HbjCLDh4qQKoUGJuAVALzMcebtyS/yczKPJAXhu9n2AN1r06K5iaBZi/HRFmMANvsVuUJf2GQRMZ8wRPkUEPWSgo+WuCaqRjLPsvHI6gDGQ94Gzh95IZi0m+XZUGC24Jz18JJYHq/TVIksomL7ALxCKiKKATM4sYz+b1+FBdbJSjPsW1TJ4CFCA3dKSZsAS3/ZzUTyLsH6k6B/MBpMx7cMoQaMZxxbdrdpYquocACI8jzStQZiw4jvalhffcORz0fSDXCdZA62J/07MMUcAPWDCGYPT9zVigc9Ue8ddqjH3AP4J0QPcPVLJ2F2YUIABQtns7KA0HBZZPww4IzXaDCleJn4R1v+JovB4TIiBwAkl79M8wyTgPXD4O3OQk//5gAfJXa2v+ZYaME0XpXbAHhG8V34WgzGgPg5g/FEZhPPPJPjzHodDLrRtpmmGx8Ak29vM6BYZdE4dRMoFtiaGbnp3+TzSrpHIrnDUl1GzQDJPyDiv3qFs5TvNQZqH+F16nYQLkh2YJrHsEDk+LHeAK6gxjGUiBsQdRtq561j9cQn+LVHlACmtkM+2HTlKgsAe/z+oSUvD6uBk33W9j6AXKIXy+DUskwSp4U7M2f4DAD5K0+7hrUjWJSt0oj90T66YtbCtoUEw3gyvbZoN3j7AAX3tWOUq4OQp1RvuzsHfDHBRuGYa5ky5nv4yS2GP7wApcxOFLpJ5OTwmvpkrXOo5r1sAVUgFIDwdQdwoaldOACqvcBJO8TE1SNsRpzBsRmz1E6Jz1Z8D5mgsMJ0/f89ACYvb++MBj/677veIYGjEDbcNlv/9JzSkqm43AxL+ZoAyjGJrVmXyhNvW8DNJ7V9vXxq19Ca5mjJjMsvGfkVggDtniXMgIsjHrertUabzBySGqNIhGETrSMkCI3BzLbYAFeKisTmO/mYFpD/WT2ieUYmkv+yGd66MCL4PMeo+yIATuISzX0q2xsrIA3gUmjL9U16F+enXLM06PaGeJCL2gCPJ255NUwX1BFN4C6+B84myB8axC1CCEOBEc292h21AIJOIypT71STPUAqYU1YHGf4fBALDu0bvH9cdy1orq4Akwh8eiNoxdiSX+C9Bdc2qdlXOwAmRP4dp6Y51FLSrACyb6eGrZ7UWCzYFwWjV/qWBO7rP7d27JXTZ3DAqsUBANjyLlFg/9hhO6iuNpabXetNeWVFsjzbB+gv8bKu63AAXIJNuChpIoFOCehTj2UjeJrMrZUTiXnJ19KTu+nOVwClxb3F4GKGtruKK361r2IgjP3nK1ycVIZVX0nDDKZtAFJEc+9yuCgu9sjYIG57OmTGkEZ4bLIv6J+7+3jDD54AlRZhDQpNZIjd2S9DB+TKptBY2ag/pLMXDMVkhY8O3ABsriJUrWDJjgwIdHN4743Nmo+Cso1jIOnNzemexucnAPdR0ij5odswCIXDSMTcpEaDXZt2yOMjgO6VfrY2gY8A2wglSN8DJFvwfR1/F20a+/VGNTZ7p0h/WjCXS3/9lgBpH+quvbgfkocx+RfvoM2Y7Mkm26A7S4u/34YRQoNfACE4zsXZsG/DhlSYCakMx8p9mYQMrKg3J0u61L92soIAKdqBye7eEg+x28Sn/SWNvk737cMAbvfA/Zj8OmKV9wBkDMHHt5YbEbolJns9eZviVRgzMaKqPL/M6eYkAzVtAKbuzjUwa9Jy47Q4inOK2xL/L0Jrhdimy62/XQoQr4QAZ84B1gTTuHDQHpKFFPElNqjt3fq2whkEOFO1dKC8BADdXQ6ZQA+9bO8UfC6SvEg86dUZIpCGt3SLVhZ0x808AC1r7BtC683SSR7dBj3Cn6xjRmljxHGh03Cwxo9zUokAKQivpRNyqwWFJt9mLpCpGTi2x+Tl/oZqfwUmV6iCIgANr5cGHkZVrWvvWVqXxwUwqZmkUni7cFWpj6bmz1zfAByghX7i1dOEy7HlJkj/1VGPx0r0L0JKeO3KXLrP8zkAt5/4oVXE+n+ErmVhK4WMXLFOoGRJMWTKpTaqPNpsRQDpzLD/Th74RdWBS+ERQu/Z2+kopmhKDbJEU9X40mQLAK/McCtjRBNHJUoNumkHJRvnnqaTJI7pHUpX/Djz1gUAcA7iG+Ad7oRr3//2AL88oLciptSq84ndMPVXjEaRYwCLh2SOE7qJktuAMkxic/DJu4tVyWJ5fgieU8vqFc2UAIUloZsImKZrWtp2Yljxtps33m9rOSN/1/W7bdqpPkUAyVS96eg9m2ZxtwBk74AV1ce4rr8mMlBrar+emKEfvQDDNRjvOHDcvXqgkIwhrSyIAKZ7ZVbCznCn5YGJg60JAFWiWqUIrQWbJgqroBgSm9zeNuYv/GjCe/jGfyd4ZtMAfawX51VtwLZoKiF0cW6o4aQwEbzulDXjeEPjxJDDWgDuf71kFzZSYoJaDg/p1+dIFO0Qr0w/vLwpEWiVyJBFANB1ouf1FUV1BKbwBTo3g38q1Sy4gSScxL3OJtO2f6gAMUl2nbto2xG9dIEcb5tfCWxJ7Aa27sMYnwWEyrg3CACbjd+lZK7Ayp/Hmcb+TH4Nwpdarcf9HX7yuGAzilQWAK2y2A+VDQCVoJdgrnx+T275/5SmFk/FdSKBrDV5seIAPn7fcQWr6v+Ih5a1xXWQHpppq7GRDS5xdQydX3xCTACNL+C6LB3QH2gbGGIRBDudDTQMafiRgO591b5MRe0hALrSbY37dVOjt0z+sUfTMVUWGyYNF8q5orpfLyVyvK4AMQ9c9STgo6mtwqnVcGlEmNozkEcuARLfhfqtHcsP6QC9sryFwO1LX0mAdN0IrefWFPCXoOItbrfGe5qd6l7qAPDfLvB57VdkVTTJKqseDUPtg+Mqm4S6Z4yY0/2RPacAsHgOikRh/fKUnQcULKdH4Vcm6EizUXlvinNMcMGn2QCWHJGgshSTaHv/FwzWi50hX3TXNLHKoMrTdvoPsArUAFeTYiPfUYwMcbEfj4MJmJkICDOWhAhaKyBqTc0wiOkA2vbCQiN+XntbqnqA+v+AHtHeGwz3DS2cPiR4sRJd/gB43vXjCXi2GaFVsW/6FsZECzcTbqo2xHDCnRMVutNAAJ13dpUo5SeK3qFZ5pdONCInLEgbxElZw/ckRuyj2pAAvq30js3iBrZMyW3Izjup98bPFMfEORm9os1xGQJVJAC0g92gZA7EyOfRl9zQzBoGtyJQObg/rPNjTA8b5MjrAGXbGRmopyUqUh/DQFb6/hnZViQ7+/AuZibXhe8e+24ASgZf9PO6MBAxIbz39/Sp47SLF32JofrdJbMSfHw+6QAT6V28/LPPAHUGnprPWYf0NqQeU8NMxdSNM5y91jHMAHs0lMUoQK5D5cZWIve4sFrghRIhzEILOWe8/TQWbHkAfKU/KTPuJfNNdFbQ63lk4uookAJ03hXSMWU5f/EQqQAqlOLbqlQ5D3dPB12ynqK3wiK0be2On5H5+XTw/JBPAAmqrxg5330NCgKs4aUL41FRge6yOomr8w4EWEbuZ1cAFtw0l14O4v6+eDQjp4a+rPOvy5DM55XYl3GlqQeR4gC/nbBSrbMWrLX+FOlyqILDLIIjEKdlfucJRxZAPSNKAG/VVbmoBhNXeLxdVFeqI+2YkOskIIsxk7zovizWBiwA5M5FqMJOeFegBtggKy3Jm1vWAU/S1oT7GQy7I0AbtQD2JTf4ldLb1H8NVhfvbAMBA7h/W1Y+xoQ3/tOzM4xfAHyIBlekE8E7aPwqkTqPL3rvKRuMUzz3fffbd+7WAVAAcPJd6v4EWB0Vp/WUHdhnLtdnW1kdO1FRyzLBmKidmgAhawYguidV7t3OaVK/EQJBYmky04Is5AvpMU0E4bvmABVFHagSdAuUx0IWCnJXjFAM5NRvytxOsRojqW9DaX0A3OQ6LLtJcFal3LZrZDoCP1LiBka1TAKjPyBiJOLenAA7vquI9X6Mb5URJSV66v9+DwcFzVyaGZTXYB6CKhD0APxHU7QM2wjVxPsbcbPxoq8dK75tZSPrFT4SIfD0tikAaP74K9wvavDEjlf//F1ZKnJrUDCLaPZ7urtHuB5VxACLn2gGg/rjk10rqISKlXLT4KWUd7ycDD094g9XwWn7APSgRWfWoauyPwBewxEKp+NoQtAU2gMYKsbjWHZywAQAcPolUw1ea4dVOOgw3mvG8MRVmFWg8JzhRGDOxwGLbQBraf80axnCET/h5+t+GLL4xQECXtSX3dapljYg5x5LAHp67+Oqlz6VLCTlEzBjJj7XsX5oqj5omWk7GASZDggAwugrP6PUx9baQPjfVHo6xK1lB/gS36aPUnk//F70aAD/I3MTppNKMJOSZpc2hZPZAjfu5l9jJN2Vk17CgNLzAA81KgeP2b8yArZlpKxzDGTS5/y8qztxzB+YdQdF/TcA4xvzXNK8bpmrWAR5IH5MP2qKiaTqJWvGgxJ976/MwAAup4+tAfY2XA+z9eJpznoLSIpvcudK/TC/hdOablEaAAu3GoKSjURPKYZBt8GG5Rqd51QHMkY+t1A7tvHdNekAKDYCdm9kGgfrwPATkUH2g9l9Oe7oIu+CwV+LJkppZwCirwYQyfIzQxtDbzLOrJIzC71uES9a8pUx5SF8MDsOAGN8Z857lgjOiKS+WelCPBmOADjp9O+ZupSxPg03v8QAHFvnEAYZinei4a97gck7+l7WwMcjQj+nQ7Et5l8Q7AACDA9zsAZ/fZWLFSibF/gn/YL3Wgj1aN81VwynrbtbANw4lWSgv7nKuocs6rkOxCY+tc1iEDEhqMHhyKCaHjEAaR8uAZLEUDB5XAkfI+WSpSJlqHoHyRbrxTxPc3NSiACJ0Iw7v6DoTzPbDokupc8KyWu5+35oOLs5OdBOQMAOABZgmaqWyD1pv8MB+jDG0MfrehEPFq7Rau+PT5W2wUcAZ5V/lyqUZt8bgEHhf3pAnvfgQYCxJBi3cC+ynOPElQAHwXpxY+1k/FfzwC6LRssXBp/Xlu7AtUHrx+AwdWNfAHoVFcLd9l7rJWmmC3W12OJZK1HMFQ6UdEABEZB8P9QA8uW3w2Or3U1Isseskrv2bNTKvCMIwpNCbeTMidpbSgB0QLT9QsU76WP7iX41o6EXFpMkkbGeYqYNECpNoHm1ADPGjtTnyl0uceqsRqWKOLX8lXn0X+EMNO+eejz+tc4AHyy/ywWjYoBVuxlz+sut326n11nSPjAktETixX1UuwAGQcxIn/POmr3rD6jKsd1jx2/bF0W4TYZiDUNhTsxoAKdeXMZd93Ry3C1vzgCArBPLTh7joLM845prBFXIcm8AFLZ/FEZYeulWZ/zq4T0jq3SzfHIqDtsnXeLTZPXzQgAoP2L9lC1h/07cFfOdDzYFKEX2PNucoxCVQyF2l9iHALczhbIiip86+N9cjpC3zqNiGD/Wtwm5o3nGAzA/raYA2ESWh7lKs9vX54/Cub5wkxt8sNUWhHHfpjDb/CHSKgCRpjLNiINPRWnYT5UMR1TNChxVrdwxQFvaTLVe69QrAO87Ijgg8XhuDW1NUPbweL9YgJPJhr9ulRAnGLFHJtkAod1PidajCMJzw981bnELyS5OryXNy56QUMN4goe4UQBdP44WI9NjfH0mro2YcpSoDtKLl3QjqsBKvI6KTeaTAEZlx5OS62a7Vgetn9V7hn+v1hYo4baw1LywWj/J9H8Au+D6XWCu2IKoC8ihpexfW1cSc41G9oQXbRScescGKAA2qQ1w/F7/yzJFzDrPQqyK9lVNs3vd8k/S31yGrvNJAEBb9fHf2Go5DQXY8OHBvkSGWUSoJxAwRs0bNx7cuhEAWW2E9WQJabph4ce8jVYy75Mzvn+1M4iuLKk71oEU8wDHmC5w2bcOg2vWX2RTUTyqjhJ1QJN3++voHLhkEmRKAIrfEWIRENijF+FonlB71svKs1wTqKn5mFM1rTtUNUIASuHXKMtTAGHRV9931j0WQdUuyxhyH/Vs2OfmEQjsjwDAYMGuz4JEmorkEmYomNlU+Jt7vnKCoxAm1K/4K3AaAIKhpYb4sZSggNWzWa4hqs7qsK6vnLVy8pys3U9s2lkAPrUb4Qmw8VnDms1fy2JStX1fe74qiL3ev0PCHOa2BADQTV6F0Jibx5vc+YZKcjLEjjj5AHanqDzXHvnI6NLRAG/yQ42wjQx6BtabMLl5CR2Dht0W6iRzw170SIiADOAAFk07lRR3/1CbKEeIHhn8v8L+YRiQmlgBV7L0lHQBAwC416psQ/k/gxQicyEemzeEEHs5br/G0Yma/4LzzkfxAFS+Pg0YLUwu431iFvN8grpUqquNaof+ay1j4bRo7MgAN53pjJOjNVOZHKD+07zq/Rg9kHLLIF7dqKvsCDwPOACyWu25dq+0ClDwP4SBBB9pIsMLUV2Pb01bx2XTvUZYABg6drjzTQIml6m9U6ylLSq8SSAG3nqIGrphWyo5/VwA1qYnQ1yD4mIY43wQTPY/ErML3b7q55PWBXa6fizmBgAllIA6uCc0jcSBNzRrtHpAKatNWint9X4wQVMyp4lgABnTHGk4PXw6vdgQrqdMKes1RfiBePayQe1QtWb0UCwAJ22P/LeWzOuxdsKKGxBadOxpsFscba2u4rbolcdgvgBH06SXdcU7rJvi8dODtJnwFvhNSOKLtc521I5EG+H+ANRvEPI4Zes2aZg09MdFbM4m2oc/ft5PJe2ooTCIvnYAyyVxCM0TSeG8kNGw+6rOYBxNJHm41SYa25I955PleQC6ektf1rfP/KrbtQ+YAxuotN3GIPKd0yZOolNRHuwzAH0R60doyZXRSIJWln4fEFbQ62sJz7KnwwUEMtIlKNUAojOIA7HQXwtRVXF4JFnMLYEnLE+nF0pwec+V80tzmQATtKAe2SI/Jq+Isw35N2YOXTaVFI7dYWezz8xMn5+VAGwhL9jxwRM1CIm6kmfNaHQey2aOwEQ8UbJFoUWs4VEAhvpB+Z66uqTuTzUxntd4s/ocq6tFg5DMtyTEYgNBqQA707yYEYLvEjFAysDzPNVynd9f09apnucxhzC14fGvABROvzX6XQkrte+WtPjLGnEkhL/H06/zT7P5x0GNE6kA8fiYVIq6YH7EvEuEmbdm5d95vMgfnm8xJOIY7joTRgCeX7DrK6mgJbhkWGSQbT16ZHysx4aN0frA0O1lRcaGADZFi+JaK7pbmCSzG8s69t88/uy90Ab7e4YISdTeYygApTbQGdLkBiahPmGnTutPe9h4oDTQYoiFkThNMtBtXACaxgNgv/VNikFGUva4aU0tGApAqva929PK+XBhhnFhAJjmD9+JAaDZlyN6Q2LDUv6glIqBQzSp1nnU72D6gJsAz+zTW28GL/53p6pJNJvDbAj9MtFcmA0OCvQJwHbtIgBL36fAKuT77qFh6Vxj731TPQii9TSvRRpmdgilYX54ADDxDq30YoQ0t/rkL9Bh8aYE2+vMNQ86pDCtAhewqMoAUor/XIF9YJeMpcYaiNwoEQMjTapUCamQGKR5EpN3bgD5RVVqrPmnr7gPTbWlm0ByMmA1m7oHGZ27InF1/XwxABYS+84PcKpeW/plumAML7FWuh8jJqPw0RTUY+kpwCMAN5Ned+I+bKocTOpStsOEt1y5VDcWGumuHGydO2eRrQB7Di2bBM2cou/V31EDq9dx2s+DSrWP/XizeKGXyqxMADCCx/BrSvfrb1TeiId1fvxQv4/TrqFpKhpvmHbOxcQAAj+9B4YW55PCvvh40VSynWIsHXmNrqwMNT1WgQ+vuABweofKqN4iBA+TOuuM+Hnr6nNWplivegty503ChYcsAMBKTzPMDoe7GNpu9XyfXBl0oqiTXYWFqXAEOufzgoEA0lbFWKB7nCpPtFCaeRRK3LnJIGPO60ltgytSUhZKPQBCh6qdcyWGPRq+9IlcykLlros1NnEp6XSySOg6ediqAJ3XLiFE8FCPoD98M28PZkg3qxXBNioh4ojrKRPwu4gAgrbMZF+JpbZYjgz9s21IaavTw6H5ojNkxq95oGqlsgCPuL8tu8U7s/353e3tLvAPMC6izpm8EUpDELfdVZCkAM/PqgQAYpdAyKe2l2671MzjQcKvu6HX5l4g/3iL/dcAOOTbXnZFALLN2fr5gyC17Ic2UK6LCFwG2L9fmXAf5QA3awIajwNEbdv34GAqYK4O1S2Q0bBLVE7xYiFykMtpANJMZ25Chcwt5Ni/O2R40touTPgpKArR0RioEDm+bZAAoGg5Bpvc2aaAbI3bnJpmMoq++3M7oXEZCEzu29AEdwBFVcFl+HEAh3TnHCePhF0AUNKSS1PGDYxQgyHAk5dWACRADPojz0jB9lHcM3ko2E0KtfOaB1dRe+Y+x9KWZDAAhH4JjAh6wsWI1JrbQJ945Uv2NbE5ZV92DWB/Na0yYwCADSf9Jq0T06pPdCO/Ke36+z1ewIEVV3OKzhTOlZiRAECyHsVY33ixinEDQErcxcHsc7fu0iyJNP7HCPpDek4AvDSsn2jBX+JxuJtVSpDxkk9yqtvpIYVnu3En3gyJ+wDXpwMwrAX7P33T5FrLVmKfQzpseODbRFzEO6OJUke1AD4vWMYtgFqI0g0kdOojvT12scZm6gnWElBzdGzT0KoApz4R6/HVvhX5g8ZdHkLnGW/ihjOENaO5Izl7k9u+RQBXVDHF8izED1bK35Gzn0oEuzftYITkWm7PvGumcRXyAO88hmroAzRJy+hN/ZId+iJlCyWUIZqPV+nYDIsMKDYAsiUqeP+TDvYgiUTYtRxKsHXsubrtpmlJqGkaOIcNZgDYv+qLYwbAuXIAPdSNlsOzvCTBQGHz4Hgs85D1zbA8AEZK6IpZU4ZvsGKwusC2q9lWRQF4B61hI8dOaKy83foARvIdl/1A+BdXacnvW1nO1xET4MH+Vr0gKDjA1aOoxAAAcaU9/BZezKbA3HQM+e5VpYuGz8LUygF5iaFRCv/ZAKoyWkpA/YNDPVeq/M1LZ3826V3VujMVo/mid/BICqMAJmLXohg3y2NmvUT8CGAZEa8hOiobHcyeyPzf91BnewB0hajBhGa6jY04g7nvaVxGE4WX4AhR+cJmR/0aGCePAOeH/a6p24nY/LqjLGSg0IzirmBpQSlPd+6YpmevBcsAhMyMx/H/f8+7Ad0KIOc3jqr3mR+mrKCesLtzqVyaugDhsEu410B31aRA+K0cgrYMrCa2wIoG6LYR0I/pt5jpAETq8twu3napnbTBoe72imuQq3ee/rPNFYjg3SLN8ecA50ltWf8lC0A6vQmk+kalDCb6z1ISUArmOzAuHGCRSwAzVhZwI0bVfXki9/Pspf3SnW1d2Q90HDI/4W2fwSukAFbWo9Q2/8LT7G7BTg7+AcyIadD52whAAg0FjLcnBB8Akdl0TuoGvbChG3jCo52scE2Mz8NhcLdjOhERNw0+KwCmyLTuzIPmxGRsfOk2fqIEIZh/YDc+JgdAUEP34c1cAHeYYNEfKIYgDMj38he/fZZQinf55TKQbAxXPrxizRgA4/xztOHqCodtt48a8lqpBtbehayw7Ny4W5l8TK6qXACWb52qqDmtnx6ytd3vUzQzKnDVQxaS0LHo+vOl5v6pAF8sxh3wlFskA8/O2HxQ6syNn6GrldPW5diUnN1ubVkAkRCAtSga14Ep2vPdC9VUD/hWAFwDOvbHWxnqJNR8VQBVHfPnbDrYvaYeMte9XGO3TKchjX6l/fr3FoLDMT1WALgQR3O/gHSv0c1jZX63GJNFhrbuuul7oGDEuhdM3ccA8aCnrK5hhX9cCHegd2KJqWITFinkzmie+HNa5Uhb6ADNpy6hmiuZ3voEAI8SfMRn27XBVDljYQZfe0iJNgvzADW5JEqv0RZTjFCDRZJ9blarmfcwoYJpGu5N1l7q2ZUAPNdtGa7zzy47CoPaALhMco1z+47xu/pTwWmpViOfwwA3xJ1bz9LNd8xPWzynWPkMBlseoXrWcJlPDtFndSrIACt4wjb5JyyYtO4DJPaZB1WKl6oOa0u8Rh0PkquE73AA2MjQ7YDVhA+HH5JRxlTMiXCZqgh+swAx3DiGn1Z6bACp+A2qFGHwfp+fJUSsA8Mm6PSHemzhR9aSKXafHaxUAFZ1bVbvmH/RxWetlRXYHBIFI2/8WpJtUSNqLv3A/jcAmxPZ93pGPkLT8R5rIRv1WiPudh2Di5JkGlXRBkMLBwDdyhL0vmiz0FNdyO595pui+2L2VdOW0pdwaaByWsDeAJf5y/anTKni8pqQHbOYhAwFylvwQfSjEBMhhO3kYioAjIEdj66b4J5Fq3nFl6H8zvfqMk6872o18qMlkO8oHQAK3cw8dPu0Jm61fBl3nU2xjpFzs22MdqwgUj/bgTfCAFcEgJLH9zBsyqUWVeCNntnjbz4AKi+5LZ2hkTXgPOkAfwsipv4D633wXhicTVqepNMTNN7q1wh0+xO8oSYYAgDubeZl6WXKQTBYmxmk8D3IM653yEseJiY2uPHQKw8wAI+vDn6YlO0Gtt4s7yWgSsGmY0zACsmdkT/ixPgzPH8A98vAtWd5L3ubrxwLskkSmBppMLo6aOvWJCfDOlxmRwDZ+W0uEHCKcMyZrts8w25bxycNCC2IJGUmssV60/otAKQOiy/qXxKvWchOkzjFpxRi6kBsLU0cmHpWdIsH3qgAxSBiKiwqomAZqdnc1HEUbDOgmoGvYZgL//T/RsenGABFKRPyDEDKy5pknG1uXBCFpY5WXFVEcxxC3K72gg/zAMIiN+72B37QYw69TJuCcHpOHknoujAhVvlszCmxwHEAmv7FSeALvcJz+Am0ldH6FIDdeUtBddMTWuCRtz0GKgBncuKo91fM/bEB8yog4MqAp9UEdl3TMeAVEzvwF+i0AOyZH4jQov/nGLsJ426WMzTFKeDZxX6B7Wex6mRAIL0ARncJsG15ZfgJAQBYSP8pSkMaobGHK4LvxTuzpcFZKwA5y4q7FM84H+nSc/6HgYFl9XGwaf2GV4K9RgS73A3eAHBSHGDPYtEied8zyWhk0aHYnT1k8OUBRP5j0u1zgmwA85M1px6CSh4VDfQo+DxxdBWhpBC5OjR+G9x0Qo20igCvvEJbGBxetM2H9JCxW+A1G0q5LUTX5Wj86WxgTeMLAFKNTDq5yYTKftGCP7eyQ5DOTrmIL5Uk04wAJxQN3wYA8tPKa5LdCuih37MX/yl5ks6LuvNvjSAxm9KiQraaswCMU1WT1bh1xgAcrzMKJzpuTbxp6pd5dUEZ5Kl2GlccAGXLI0GrkpX5szNmrTEEe5OYV0ebsoOpRUJw3cYnoeEARJvfYrwfLPxraZEEzkoAWT7X6OFMLxBYPKZrXmQgaACD5d9VOGmgHH8YU9SAJ2+wCv4JaisErW4KHzRnw4LOAC7j/4zwehwD0PfNVGDdALqeOosZZKmykL1d8vIy2PAAotb0M0qwmc9XZhtD/+QwWH6N8drGoDsS1f6qgAvD1QB7PlbTtXys13oaAoFUgDUBOM36RdVbe53VIeNubV37ANoV0y2wutByk+znL3SoGvWOYA0BbrUqcalhgimZ3HMAYVzdcf5pjIXtBN53MHRIwpQzLf6izx+2r/KiXI+F4ACZVBHP4TKEKcZsD9Rpa+JbtNUC/jiX4nfPvQ5rillbAFUtEXcG+SS8AlkFvefB+ZGpzDtf/vaenmkPaZeGd4EAol3g00Dmr1TGhNBUXD1UI64QVTrqJlg7fIlt8yGBhQCZu0jq4YFv/tszIAbFEj7Prk8terXPNkkFwyqNY0dCAHxdfud91d3CbwbW97RDvTAdtEHGutCiuUbdS0Ozu80ANxB6lndehS8XU9nvZvQKr/OMEKkZzC8TEi29Xtvp9ABzkhs0LhzsmS0f2HGMrMyX4sRRtsAYJlllXKzhawbMAPLVcIEfH2fA7eB0FXb/yN6OJrep9+1ZgmXJDCkU1d0ASVtABrSf7c9GJG4N/iHrOH0+mu7yk/NuYeyLthB5aAC/FQbXfHbBC5aYncew8SeeLeyiztaYbK9aEiwN4vzPANJH41dD/5pv85m88YPt+3ukmYPIoNVAPImM7lei/tQA3SbEr65VrAMJQvXQ8roz5LM2rgnVlZ7zU3RR0HwJIwAVzsBsZIApaoKIT/NQupl80fkboXzWJ2aM67FwzxNMAFyTWbSEVYEI4MpW4y0A084SzR7CnwBX8fiZiEWDD74AFLG2HIP7WyFCNqH7u26+DlvXdYnjSXOB2xpU/DaQVAAK402A537HphsO9y4BGmikxWR6GtMd23ZJjkZkGOl0AHr/R3CKnEffds3mBzJeLBaTMevaIeMt8Pd7HL9TvuQAPuA4rFZR787hPANsDud8SJlHjuqLcGtEUvrGCzNm8gDmvB/jLMASqhbeoV3cGdyFlSMcdPKGP6+93sT6MO0KAE0uIUiNBlnGQawOaKNbuMF0JAE+KrSicNjqKpk7OPgA28tcV07LkZ3Jy3pdxckGaSyvWlVx6ZEMeECPV9Z+RwBbrJEY0R1m0oifyKYlGLGZfko3Ch4UdcQt1uqZRgW7ABSyrKmnAI3wpQdFAGBKJH52RXtRPBDqbVE9D7CtddEAVJragOYzV9kNydPkQcF1GIo45Pe/GAn7zJOkVlqPOQBDFJThNGH+YKiClxeNjVkj9i3E4Q5X0//oqCmsMJFTAHre1d+YEE/alQzbumVE+8FRX4TxsxlTSwXuRTp8OKAAHNRauM/tJT5fm6FCU2UUDqWEAAtMlB2GkQTtVr09iwDbjKrJajVaYkjVz49f8jXgmsRUc64Zt904alZYONWLAMBIggv9FHpCRMBs7rsqnuQbRb7RyG+REypU1Dl+O8oABhHqSr3HCe7Jb0yprTs87R+smDj9+/wy73FzRBWGCwDbHVjYRJyc3gxMLA3BRg+p19ATz2mSBbSsGlnLV/BhAC9YmzKEV0MwnVYKatmv6nh1XC9Rnm964OG6jA7idH8AOLC/x50AaCYS1XJ1WUyopOo1dhZ5/OuJuLVSvcE5SABWE8FOOnJj9xqAxX7vgr5DxvvENc+mdrKbWl0/VRjrAM3OUA/9rbAkt4nIrL7SQIX8Km884eAUb0jxpnYmJN0A5NMFl3ni+QsQNZUmNCHmXsvz51599wyk48C4D80L7gAxOoED3vY38DgQK3oyeW7PQt4eTQ3BoxIShHU/yr6oAHgHo4V6TbCiXHPMYujWn5PzL614U6ap9pt4PCf5sdAABzXXOix1eGJR8TvPhL6u78YUGyuRQXlpRUqFa7esCgAPublYr8ZIKkazFap7iTYri8piIEtasW9/svwjo4KdALCsInvUcyUmkCO4PnvW5fblf6JSVzyL52f2y6f8KA0A5HkIdFqCiv7ZyQrRSIK1wwqsJtZ8+Jwr2+TntF9SEwCVtekYWZvVWXNnonpMv47CH3AtbWnEdKVFkAJYbajGAL8YdqmBwCw/FMtNHCXanOG8XEyO4kKDc93J+rysMQcAvBgyt/Sm6Z8zFVQvv990S+UjqftAH6i6yFwS2ifZmgD8wrLYG/t5P05qMx7qJW0HtIfmLmD0Na48X+d5/0RIABxOh1zuLWwbg+zvJRxzbefYhDZcveXpnWfTfk2jjg4AnJRodHDgg3vp27vO+2qoPL79LbfHeuw3msUR5IC9PQA+TR6+WJSjY7NkAQh53wswTTMQx4N2xwS32/J49z+PAISAOZWgML++Xum20WO+j55KaiTEvFwClzOaOj3iCkoAIHu/tcHnTaNXnjUyPdzScrkBY7UTP1tkDI53sRfrCwDOfA0FIL6OAqnxIOcnAUp16oE1evCMTkokWqytrCT9AKBBpRJlpfNGZhzJQlVakJa+zilJE3FTrrKxryONboEAl3XdjYZk0RCyFy1FWThiDXiDBnVZJrkTjYC+cW87+QC/00AOAwxKcTCUKCd46A98ODyzsV2ftKUAReKx4BR1AH5CO30EkD78Otvr9vQFV8vpQnZUmIRZ+LMZdFaqvZ4AJxKV2xipgFbb+4+6OkNpJnqRv9KVbHSr89pRvwi1UQDgilXvW3agsLJGPAsNtQI0mPDO7JKofT0lUzvXt/YfAL+Sf+jL2R58Wwk/zHWshgDVDPetqgnX8r8dJB0v5WQAtWjpM7SSnln1GXJavvLiOCehJJh/Iwjofc0DjtHs6gBPgYwEwSzspWhScONyzJlUJcncsTdoylC06B4KKdHBAJiCkMwcxecLbH+Zam9+eq5rLdMpANSXV3EeA5is3dQADaNhgLE+R2tOy+uwjUJFUpu9ZpbtWGdDC/Ao82xh0wBJGYqLcFwRlmmcXDwCu36ofE7G3tod+MFX1juvmtDvABYswpTVcNBnuPz9pzEnnqBLGwAfYj9bKc1p0/3IbTMAnKTYtPGdzO2vdbQ+YFGtoYSmNuh0AaGpVc1ZWJTrLQAV+frQhIK0LHXHonrTE//OpVRLhj5TOljxSEEKqsrGAJrnFbPTVnVS2nPNuC67dUZCOBylyquehgKHUJwqRyMAkx5wrtyr7igY8TP0C/obww9TBXklJXi61EzJmQ2/TACw9DB64YP3+8Oz4bZaawYYMlRFotJzaZbI48joPJeFAGZjsmBiB3WT7yhUJ6QDEVSOZ+FDUN9ut41u4Qig7AAAhTIonbcBMBu15PIya1knaBdLc/T5awq4lOfOOyNBoQDstbCVtqLc6grLwrYAQ4NYinpsrwudntd9zTktFwZvAFfkG7G5wjhuEzJHN+FfQvJc74yAKtbMo6eepICpBf0ADp62XpsirytkWDdEs7SqKpJCld33A3nVEdJMdEa5pgDdsjDeJIiL/fIkEm09gSPqLPcfjJLRpzR9KSHVVB8gAKKLRyoMSZhJPpcB2KO49t8xLo/jp5zgJ2B9lkkuHqwA5qAg0IhqPySzHpYDDmr4HxBP7BCJvzXOjAcsmhkS0AAe2xrmvdbMOi9CbsLZUf/HxAArXwlr7JhRVJ6jdnwMACqIippOpWdy956rh42y5PQcanqp17n8f/CyLfKfyJwAnmfMhhgVZy17475B420UuEKcXGI2bjB6viLyRWtQ2QBQasKd2lQ3K7uElu3X1jTlOSSrVzzIMUC5UnJc71l0AMypbNwzW/wYSpzpu3AhrHdETwDxbLNosfdRGUYFdwEA6d+sObSN1wfPNII3Eu8tXf+wrZhLnCdbDnjeqBXgSgAJBc8cqEt+nzSawJQDhOzFYYVFrN0BYNd/bE42u/cTAKz5bBsi6xWGkq5hiV1p3dWfLjVw3obaxhW65JULFdMAv6QRIj2RXo9RjqrtP7NZaOrF6lkb+iE1Wjva6uqCfABW+WlT0EG17tNMyq51uhcvMrJxIvpfEBZr1yjw++Z8AH4TDe0BXEF//Ap46vwPuSdPy1AA//s8XYyiWwQ7yW4AHx53EaG6pDg/3r6z6rYcaxLUCNCdV1Kjakl560hLQADLiBU454YLYXp14n+76YIVuFE/stWqcxcFadqy+N1bADUFb9k+/PQ5xAoHYMOzQ0PB64kq/rWbKwr1gMJKF/gAKP7F3JE6IlmLIbBwLY0MIdBAC5iYMjjsyf0lqIsR6wCuAIlyXL/7Em5Sqco1aG6Wrh6o/m4OUZE4h9OaCYD3AACV/BkP6N31N3WX/4GPRbmK9oT3i1JKrNUwDzwY8zMAzUkVN0Xc+NJIcvUnBnjvnwfVHl+3chyihVnMruS4xQAfspnEyjQjD2iP5rfJIcYStVF4UF3/e+QuTH6H98QDAPJrAQ4bTJe2VpVt2yAW2ONOz1BvUe5vW8ctsJnLZ/oAwgE3MlTDx+MmIE4APdT7spuo1eWpywVHGlVriL7DcAD16Jua9FdGgCSGDsJ3NPsRFxd5dIngCri2/0XnZ+OOAPQLnEPEY92BIp61TZJefjqOPBCdm2crwx2fbSZ5MksAq/1r2Z9oXI64K6DY6N4ff/X61eM/9/u/gHaadiqE9QAG6CXFhCZkHD8lV5wSMZWwxfT7kji2ZNyxgIZO/aA6APG70aHzE34KDtsfVvbw/1N2Gw/sDInIfrCJu3Q5sZcAgR7U1TRV2YP9jGt/H9LpgYmve7kOe8LlyzHkPaF4QgDoI30CwrphUiy6QpTSIIZF0+KNu+ZuFx+5dcnUk1WBAC4ffreMEdgWTGoKNa41vI35tAWVXzp0zB34I39eGxAA4nGtKFnO3Ai/1BoTO/cAOFdRxkW2ca+94xWKGUoL3QDfnLeV6r15X8sqMLQwAmyishegunrrIMzkEo8OXs8uAFmDaxGazGG5xevryWQvH1j/YO+nhR00TqdjxEwXOAMATY/6i28LN2EWxZ9Uq4ixKCbyB4x2E992qdIlgui6LABSOpAB3h7n/u1oGosO/qu8ZauirGvEn7j66jt4lwCGAOhjp/HH/vLOU8/Xac2o8iXO8f87ZQRIipWfr71SyBgA6JBTFoX9j+j9VJOiDnRErta33jtlqhgxstsMyVUqfQBWnB+CnKVNM1Ezj9bq9RrUWDyRcsyy1qgZou/mODZUANid+Ocwd6uzwx0qnfq2y+X5iWnlrbWI3NeBdTgxUfkA46h1QybYvK3FhPt1Rjoqdci4cPMZkl2dhpxmZSYOKgA/RgwNDUszwjoSBzRaBGmnQgETa5vhAOu3uLNVlTNLACgonumqDoJWcuwfW3PUeRef4WMzoEF0k1RahtDybbsAPOs58rtKnfhC/TW9h/jNfxEC8qPaXqi7kn+X9tMKKABwhfBm9ZGRlj3yUtx4g4voZjrmnRNPsSOzP4lfIP8nADNn8mMOLApMY+5zuQHcLleH/4EZPiIEGcWzDf54ADUAlWqCEIL8BN5NNeWm4ZbYL8O185N14HlQi3xfO8ejcwCE/hu10n3S9eCUaZURaE94B9aBPROmzsmKTugqBKYgAMP+w+BaqMeFiU3byynyokKr7OFy402iuNM9gBTfd4AAb2hxxv7epf85zj+8nFMt/xKcyHGyVd32gD9sZOVwSwDDDuRkGM0Zpq2JXSc0h4cBoX2wFSkrzgIzmZizrK27AJBM0YGP9m2x6Caj1BXKiq/1WrteruZOYs6ekdw43qMA9APs2U58oBANpLOwPtxjh92G9v+xf2ahttJQ1rdBrACCOR12rgX9YqzDL8ROMDYE9p3n5xeQFDxzLZ+42ioQAADPQaaEZdTDaBkQSyVEEwkMtiqDW27qgH0Cs4ov4NUAV4YfU4mbEDJAAlUHbXhtv1h4naVqOipg9BHykxTbVABQsLreurPM0jwA4zibQaedg+kfumL+HzdytQXLkRqgAFsNpPAzq10/S0FWLdQFO4oWdD63cIclat8Li6yZtSQAFDmduHGS7IvTPqozY3fMr3C2g69QLRFfA9M7BVzL4wB52PEN1X8ngRrOnOcLklvVZJ1ewhJCbygi4OVUM3rLAJXdC8S+u/Jv/T0z1RaW9pbGmwxZqw+gKNqcLQdRvfkA4QUK5GGtY81/CcTKhfCeL8Fyd2VVg93rIVL2N21EmQBxhRWzQWa7z68e7BkUBWWBZ7DQM9rnAB8B/ixp2ZWOADjZpmUkcaHpAVxuKXC9mBYLk05MqgiTapS+XImWhkwAo6wiWIOKtwt764jtFyhoGKVXD3d57RouWAz4GlvrygBU3BFG5DIHJVwolta2JNSswdNIexCFBDVELPI5MniPAKh/VA7oXGls7S3dDoI/SmQBdFgxhOOQuaB+gZflGgcAo3XRzuCxSvosUjLPZMgwT7RnNQQ47LHedKxDbPos9QCdydb4VN+AlWn54osLNW0eYKGqDMiQTM/5geniV3oGABjkEa1cLo85qwZq+idWnT0gcYG9haLOC9xttZZF4+QAloq3lpaHaL2U/CY6vME1sSzThHPI/y4Un34Eh1446QBuDOUWttKd8MDM+W/o81/eWAQLT+OzrNKGF9BP3Cj+ALGT+PM+ukG3bxZleRYQe2cZpZKBLYcmlCvxEOkqLtUAvTWB0b1OyT7qmwGIMnSGmDlxZmUKlFCw0FMYIDNisgBDxLy+VZH8NJrY+WOV/4dwrSytv+mOnCdJVZZe3yH6ALQdPmQRIF2dcR9NGiqOskmkPaEPEikWM1kTC7OCr18A5/EcPPWvfIgCgLyZcGKgbG7+kraqJiOn0WQ+uBZK3gDvcpWwxTNgtYfUrcljwnrKk0vbmNfNA0fBV8agAK8SAEcgn0o2atE7kANCw1xowEr1PBICjXpBiD0q6fGFoNMAYpovS3hP6itTlaQyxFiyb8cd7PNoczHxTO5epbUJQwBo9ICdBQjUKmoCiUH3O/03R0sanBte3CvGRCKvLcwXAPUVXrgtZXGn8kadFdB+spotmUL1EypiFrexECqiYPQA+uMMGI9h95ZqJ0QuvblgbaBwdgT+7LyVxLhuTxAWbgDEbV0Zd052KyUe+YnrVkzUhdfrVDlMgX/Ad9BuLUi3AAD+ImLu3SzEHKph8NrZ3NR8ppDPioNYNpEsIiJ0WaIAbuSYVc3aqZPf8Sj+yMQvEorEyv69c4/Q5yzWbnEh5AATIAxf2kLsAeEbP9HuYdits3XAcOVPTv0wrb9L7MKmALksoiL9wJqFxOa8H1gyEbY9aI6SfO9U4zYDLtCHXdsAvAjWKTzDMXMo8RU+zGBURhLG+C2HJK5ntLWygYH/UgDgVGlElt+Re4d48FyFkBul/4GK5hJDh3Z+1MpNYBKJAGEltXO0qw+4+MuQJHBDc5Sqv9m7WmXvzSN796nd2bYA+dGcA6S/CpjWwnAlrpCe+ITSCvGBAwe8vJtp8FTzQQA2QOnFKKDDmHZrrmJJnsPxtnLPFt/79EewnEsb0D+wANsj2o+pUdFtLzKGpGpBD0p21tCMd80n9pBykxKRsa4AZ/zHd+qZ/8WF+7sjjDIdU8nB+iTiJf0i/pc2tVkTdADKa3xKzTB7E5tpwYbvMPlzVIHCHGw93fJqtqqBVqKVAPkdHeJSbq8EHYsFyCST5EYPLnBP7LuyhY8Ew6d4ZFwAeyPGxrK/hLyuxLsH/W9tPcN0vyHReRZkBwT8pBmotQAxaZ/1xmNWDgCbHvOIU6G2zcrLIOuzWes2jp0akAROAHedBJ0xF6WITIlV2yLyoEwnu8gzqWaDquQ0W5yBPm4Aww9BlFZPT2WZLVBmIEDgCRBELyHL1khG18glPwInaQCyOkmuMyiHt0z4jkTdQQpgc3yxpw1zbcOtmqxd551RACtuxabyYz0M6Re7hnDUh4oIwy/a57oLhepWQEOmiyYAGLmpdh7q8n7pyicRu2WhfB3+yVJYy0F/6oz7XQYCdwBtPLg0UodSD3ekm0EGeJ6fdyMlMuOoh3HaMLEs6mLgAFInHQPkpzaTL85MTumHj4y3xNlreSwTJCUHkbuRpQ4A9EOQmGg77lJUPv6ZpDatjROT1QHhVX/ONzwwkjOU3QA4wDNHmoxU2kg7P3Zb4gjlsvS4e1c4GM//kV1oredDAFCEvUrZykP1Ycz0GMiSRSKIpG6LJS1qbGARCKTxCqUAFKbYZZaCWaIyh0DcnvBn1O0eFpWU2A9FR3va9VqgCgCaDz9hzOA5A4somC+gJynsrCU0ax8rtomkkFXQBHG9AJjTaD7xApcF1/OaYZirAYNEkiEbj4RJadRqHIn5pKAAoO6LKtNYjTRS30Io1P4lEMoE8CuYVhsg2kSIQ+EVCwAaC8De6nBHX8Rheddiqqjn2JKTK+oYUVIMIjDaVDA6AMrCkWFPIL4O6sJzKlt9Kfo/2N1qt417dy3f5QiE2wsAfrAQrETja994crJh6NRpywSysDj4g3y1Fm9HpOeAZQBZ2FINnGWQZSJHW4eWn1p6nYOYlahxhEYz83HArx5sAOe+f0TprVawyGOATTld0qlcP5W4v01a1jY2OwJfCVEAShaz/OE7Letk79wjVxEzmyqtI19jkIBO+f6wNgDZvwA567L3QukXqu/5f3nYXIGJI/FEXG04D2h4Vd1IR2PLANSccXPS+FFFRImnce16RtJehd2MbJRh0TkgECRCOT4AcXzHg5jQVl8Sw4BVoj8rfHvDoUBCYiGl0LFXGhusbQAMnI/IQ8XSFFJV2hDQdSCip4I2M+4iz2YVu14fQiZsAIjj8BI4bCoKYvSg9Y7Rvc4WTtLXkPasalq9P5k9i2IAPWNh5OCW0xqeUa+VkuXZ9pL6oauH9e93qKVkVOHj0ABRrsfqGOCm3ZZYzhX+KVq85saG+xGdyvQNBQMY10rwACmhwWP2pM8HjIqFyYVjLQoUSnuuA0QBKMc3MpMSrQEA5SH4uO/UUsW7w2sZLwK+42PR2ts1lc2eVlwqfXw4lwAUl3D+Z9h3hwnCVzuFRjsDOn7KJrYp/Lkx/mINxEXcAPF0xeoMnoCjyQs48VHaqHpFM2N/EPzYBSUOe7I4IoAAajpsA/kWEW7F4WJVgFnqayKsJQO5kjVr2PO0bDA5EwD4XcgfOBOTAy+dkXiRpNb/7OEhKZ1EfVgt1qZvmGY/ABNYnih9uOg8j794TRO4ZdMljhJMAyqm3SMkXQR51YcA5T8fNEwqUTBRl5OZd/hMsXp4ncmr4IfvHKNfdmGFngD8rIIrA5XapUy9DtaeJed+IyNmC7wT6YQ/XD8sBht0AFp8XJhQjJujBGYQPYgfnkWsXAchU9Zg9AhHxH9Kyi0A8rM4HOktH1PzryAk0PpgzuQuakQ8fsiM/zMYkrp4ygABKa0iBF44pwMeNTQwOrXx0YTD8vR97iBm77T4B6yQAC79R/JVmCEqIkwmONJ9UG9qokT4/MIv1yX89OQrHocAru7OrRQjkHOVMENpZJ2ktZ9W985PSDZqiGp9sUGIuAAKWHV5cw8ndagZTcn2J8jtnzAnDHUtNT/JZ738gRnyAObRr5ATtR4aX6R6WdY/GBeJkJbwlq9tDie5Efx8GYIArdbcHkO+1n1FFjMzXZscnn+ECfWreV6XKB2+iHCzvACtShiWQ4yH3z/WGiOmnHnirCqpBzOi/3wdeFtYMf0FAJg1PaWIUo+T1cKB/KVSlaFCjfmcSZ0Z6wAXadrHq+8AcSUJQK8sIkPsGckOdI7MJIpiEc0lHxKCXSt9UVSNvABUfq+tFcNj0ODSRO4f61SDUCqVZa3v9fm+basS+YEMAEc3lDqyzJ/AfUbku6EqjqoaMzliENQeFz8LL6uccG8AK9pI08AX+lUJuhkRTqwdUOG8dgHCnavYfZFCXLwjtgDRe341AUkyDKJaJx7bH6m2wJRLhroUwEwQZHQ9Hmt3AN7+dhkNqfwYVojaAmRe3HQMMDCxdMDv8FacmKDZGYAAt6iaRZAgiMmLlecG+5IOB0g/IWQvWbhqfLYPPtcIdQA+99Q+xslpphLX6/1arLrMPtB0nO6UtqHf+UFDFpyiAEHuM1H52Gs86YXe7x2E9QxXwl4POKaLa0m64+unGhIAshK4+Q0+aaGlSPQylU4RbvL94gmtP87EPD9MBGPP1gBN6KY9MTZIUDRexUEih75w/cTWwSpUYGqiEsruCKRcAAspTjNVXHsKP4dmZTA8Zpm8eae+S8QFCme60k4DSCAARt6lsrz/m0GvTV7hFrLLMscZQ4fOLg597ErzMj32dgAp1x4pLIqV7EnBG8GXmeIyTh6RKnt4HW3xCoVX3CmvAKWUAHmOs328a44npfm7YEkRDB0IjWuT/tcyUCjxQnkAOF5BQJbW+Q+YpTzawlTPn0fWyL2botVJn8rMB/67DAB8jNBIwSkyXf46V4ksfD5wf3iPy9vyZG2nrcpvZv/GAGrnQLNoWauOCAO9dXXy8wF2+bhvYLoEmgbYlZyhf5AA4XN7xZpPstmLwwdeYKG5XlkZViqB1dt9E5um/6+r3QCtWhYhi9mWeFt8g6nuPeOJ7pRBdHwqEi8K/J+bPSFRAC0YeRk8wI4jZ4yDGeeND0bTdc4gtGzcIi3qG9RMiB8A98OFjwASvTLr1GHQ/QTsa4rX9ffg9GY7KYHWlBjE5QCcVTv7NrRtZB3fbV/EjuLeCAc702ks03zPD4VpzCEUAMvigOIdVCA0YdM2yNnVMADJAo8tgzwumtbAyT10IaAAVpSrdlo0feBE5IaUE3VJjwVwlQleXUezPyfxH/e+AAARlYQzyjdg8dMKI/5mGzS8wQesEToTXBXBv9oQhTOrACfslCeB7HhfZnpXIPcVHKsTNivpi9mB9PVjyMtAvqsAkgZG/psgx5Xq6bUBPMnVYiFgxVZOPH4T5qOHYLNtNwAPP1xdIO8hAwhc41oMa+Rpv7Z2u5VgF/TZ0KdbLctZAIWuPGKxg/6ofyBsyvgWWS7KncE3MKGSyUQ51OLMFu4AyCRNCDDdn37JTxpctxz3igKc/m1RWEkUn4/41VdMrwA/noTMXOFyawOql5oUX6XbrgRARhVAQg9y8MnZFExCAPq9P4w5Sy3oJ/zypettJedZ7kHoaHG5cuDmY9SfOxcAO0ASy8o0d1kEq17kqb5w/Rd26Q3XOGJuvkdixfmZpgDXza69A2Mg+yAIEmHMhEjypWjFpp6SskcR9nHurSTDAH+IBlYQWDqu/eRi7tF0dwjqmnIqZEL2kamKglyxsQcASAqjfQtVbh4GTS0k1QTzcmorWJvATPSM4f4wtIvR8wBUFN4PMr311IFIz7aUgbzysd9eropRJ9OEtCEc0ULXAJpOf+z48VWeT3NVQQvWlSjAcjLVPg+e+d3xMLIYYxEAA5e8NbrvwB2plwZDVJ5e9gcz83LACSj14rvuBLr0WQBp27mx2ZiYSk5kggedfHR0prnqJyGoJtb+Q50TG34NAOwxjbUnfDpKTnFM6ysZuNtzpcCxZdvM9b34hzF61yoAh9QyP03jJ3fa5pFgGCkNQd2nfy/DxnnqHMiEhysBIwD0lz3aTah7pz0jn1PPZvRbXlcfttjwYkYMFpvGfDtXAN508TQTRLzs0OZoMLY7BEVF7Wc+7RHoCtLHEJ0HRRkAIa6W1oa+cV02PHf3Saby/V2UeLvlrCUd59xY1csElgApZLc72Dl3uZCS3yD0zYU+NapC1Gubxff6FwFvxr28AECTG7CfcWWBY3fpYey4H5NMf+ReKrv8sO20EVjuD+wABpHXqs1jR3APZGW4OTP+vMs5E4+M75b2PWQxDXk8UwCKjt9i8GxvwlInfTN5PggdSGB+/FLhgvMwzh1mP90JADXAW3Q5skoR3m7RIwo63AlmxX13MwcAgZdx9Y+TQ8QAmSKAPiTRi31FddeKynKVkp2sUBcCYXVNC1HPJra7MQApsB+5J8wZOp1oSgT0Zw6BHQ0F/8brsvmlnM5n3gVdAHGCYGhUB5Q+TgbMRT5AXCkxOREeWLnHPfp2LWkxeNAAnDCXQasm9em6+EKnebpNGSQeL8MfnlwRwhjvRN4HJwATehsp9yy2z3/bc6oxbSt7RjKpxYXsnduyTVrqrXP5ADnkUrjLI0z2rvaRQbw1n3OICn5m/Nn6s5H1AlVrM6wAT945x5VE9BzCKWYtN+M59yia9iVJAmeSHa8g+iIeZwCTrx/N1jWk4tvV2rcVyHxMjPrWNYRkCoFlq7FtaUVlALNCyZ/CfZWia1KhVOz8nq3p7/GX+8tJb+m606cgYf0A0Tgl2QfjNAXJKnK4oD8Jg7+oQmV257MpBW3jlpQgHwARL4ohc4f31sLO1hNVAI4PHnxlEaI/Mvqg1/5ui/VRAHp+lJuOI6qho+aOvZMIpdsyeAAzz04/JbH98P57C3YAV4swm8ZH3pMGGz5jrb0BlMSbb8fWOFkxX2YnHoUnvADjKZ6XuRkYYQG6hE3LanMzC0aiXCOOPr3+ZoyiWcJMAD1i1hEoQDeH+sP8T1nHvlrjWfifuoBjyUbiZS9rvjMA0XcKPVZqbwiKFqFBW0XlvT5NaMD6+g8SzTfY9RTi9QACPpP/3n4l8T88utqIHxUQ644xdUFYW4StnEV6dnBEALBI8qbF7EhU+qVaUkKnySXmqS/KyT/pyWetD2z2lgYA7+Z5MmTh7KSYEKPvNOLunlUDtnP5eMNBXqEhPk7XsQD1L2lmtXsqXjJ3MaFYXldfqI6nd/NseXlyEqGydfJYALKLgynGUe8ITi2WNxk+Vug5k8bTtk3U/VqmsN5hih8AEXuLeKKmDKTuvy1f/pgARYCEX18Y67XLCY0Nxd9ixgBU+7LAl6r3fTAb70V22+CA22yEspgg0ondE5maElj/AJAIwTiNT6vpudB9Tdx4TiUwgdWwjmXZ3gj7bDj59tAAKwHBf3Mn0liMBiYpNVI59K0DCiyMlINXzYxRl1NuIACtf3pCugrR076hkdQg7JFVFX8lGYFHSr17IQjSnUFuAH5E7mVPeZKRnrjw6qAX3Y1OE3FszfDTaiLd6k/DZoUAewAq8cUpocytAOpakTXjAmnKeqdUuy1kyg/zJ906OAAUWmtfY5EajY3FRocblDIRuFw3pxGmnG7dr1klhrfDACX6hJXwWOSWZ4WTg4K7HiIyzHCXo+/1p8FhstqhZoQAQpAChKlWrZkhbM6xgd4IUHdnB6zWdjBLHKP3/itX/gCl81qAsW4RJloElWNRtaLMMoMAA9dtXD9JSk6anu1kAObRMZtcIDHCduOuRVma17OzNPQeo/bH6zCllHcW0E4A6KMfGD1uIuq2pDfOrDNv8qyAJLpmeX9tt/9WkP4SsQDH0cIiIzErL0Vvhvk0LY/XI+IUgdfEzNzHxpAg4j/DAIhXuxUJpf607PizV/psqE9O/1ne2DsC4J+9m6C9+KwAcgKLkaT3VMKs7BEXbyd6aU5slQ4Kub99MSBsYYN4UgDBfIhc0QSqn7+G/8SB4sohF38kUwpcRO7S7pz6MTHRANi4wodaNnDU/TS04UigPLL8gXx5dNWYGhF4dvWDkuIAWwN0cqNnX4kmBzGBMjHOqhTjLJiPVUtmTZ2FBleRVQAogWU7cGBBUIFdRN+Smtqzb7NmEKpIXHF9rcjxf39vAAtqSoevK1/4jbkLjqOcG2hYPgVRZwHSG0dk8uc3WwEAPo6y9gxahacCoNKwpNua0WuHzIpVOJrl2qIBlPuINgBbZp/KHuwoU/bYOXSTk52QxKkq3bb2qly3PhZEn9Q6AL+qKRHr0uryfyUfHb5NysFZgu4OGrXAjCLzAcmfR+kAQo/wyRy7BbBN4D8u2Bm6S2uRxZN15QL6QfK1CiOMVwDqAT7VXVvjGLRMzaDmu6uU+WiXqzgxHKXNGfw3UiJ/AHbgaaMFNlDpXt/6cnq9JJR71EJuMxZ9wMlUCSMusiAAnd027//2oQm2NwXiJLd5LCXDb9Z9U9wJJ1qgZMNrowCY1ObfpEhzzMm0LBHUviwaY3dYo8Hunvdep8DnWiW6ANAQTaXwGoYcjZlE+Qa3Dg9LlFOqsX/Awd38Ad9Ed5cA9XsjjFNovgahvwehMTF4lz+yZhEKp/T/9ruKXlS/igACGMaBx9wwyCIkaIgpW8qIy7E1xN8+F0RQSg1mUVhSAEuLdxHDmuSfZwXChaeQe1YORJB5BchBjeV9lQYCWwsA7D9byfMrWzA+1fp6ZeVqQbOOCwcH9SR6HgJSizZZ9QB9RBDR8dxPaEVtgY/6KIh7Zvptd/O8jwD1VJtRaahqACHZWmwy+O/NCAdQbxdq6fwciq3LWDOn0Z+rRz/XGWgAqalB4aTrNxIMchRqewOLnzVrLYlglenI3lDet/AHkwCGj/b5k6pcc9z5v/QhxVVRc+4Xl/cka6M8aBDJeo3WAIMjeeRKrH+GZyX6aTruo2bYCkryYga7BdkIIhXkw+kAfzl/a2gkZFp7Z2XUOAZDuLsp5PVUbkaMoF0cibD60ACD6FWj/aBm9wOY+WiXOu+VFHYNQ1o+DULMsRYc8qweAONingxWWlKL9ffk3rTY2sRrO240kKdJjRXB4myK644AAM8x/4PTfFEoQw2bTGBVw0C2fBCbOaAUHAFL7+WlowCgL26dhlp9BBYNl2DH03CA7LBG1/B1GNF9Z088IrTOAH6aAxRxJLrDDbjkxgCx3Y2vNFPOQHAZLGYrPFsvALsAzS85b9SL0dEUPFmsgXeO9rRFCJ7Qn8oTfYkHQzmd+QBDoJl4Hf2ldmb54alnwxObFophHrKVrMaywf2KnM21AFXQ8X11MFLA7954HfXms2YTAH7H0JWUEDI5MaYLsr0AZwF4GY0cOyV8aPOIM7ZTq0oHu/EkmH+ZsW9hkrtDAQD/J6romQUIay3fiT8J3tooxhsS62uz/xhYkUgRT602AIzbeqLeQwEa9yNWNVn7OJqCMFu6N3yBy8mKFyPgLiAAvkLJvfqJs2LgGyTeWawHv1owZUmnBugQlJBL8jUBjwANeP3rjkMubBSHi43SejvH84vVcVQHLwhR1zrVYjvlAGoAbo777pSYS8okfnNYRjUDzB4gtzoJYj85Op5cxaAAQMONgX23O4+80mI/8wzV/A798QnHIRuKjUHurSw6FACvTwvMiHmtj0TRyzgnqszjBs7k8yGGRWmK/P46ZrxjABsDa49wwE2ul8768Ete95zs2NOzk4gw4VdgBBRyAFkAKgKUrzvE3m0aPwSQaFrxy69I91/TLkV3sBY8kpptHAD1dreLkbT6xCwn/PxhJfPQqcnPM3vJaG8PMXTe5zKVAAzWDTRh/ISzdXP+X1UHoFojzla94lDZF00jrt9LlfYAUgMigJWmlxUmouwRiP9oI3gO3Eg9jZ9EHCTmoOqmqgBe218/6lQPqJEOFKrt96jvlfbFj6lT5UyNFbc8/cCsAKFeICFnbhCFBCbbI8uGzv70K6akCMq0N9EItwdihCUAx6NvGQ7bHjyuJF/F9pMr7KOQooIZvaAcnaUcA96R6gD3mo46/d8BM88G1vdIDFsn+oVj350qvjTuv+DNrpPaAMSSRcg1uK33yTEBGXeOf+Ip+7M3pKMF8/QI8DxDrnUAGUDjazdHYUU/h9eEbKIkugBKw3XbEYCUDiII/taqrQCO0hwDmy2kxmN/5jIKzMeVGtbblfWaM5ppw4zFlqpgACumWm25ec7smK9nGIzkPHgDkdTjqZpY5eJDct2npnIAqLc3YM4m1Gx0Xm41hmjxpw5BuQ9Cpje3EA2TaWgfZAClOqtF6DcbRPHyALp3CX8XDovZ6vHHq7w0f4MDXmL4ADPjox7c+TpypfHjebfyP5EPN4rgvleYRQcrQYuhd0YAr3ZVE5mfLhMZ4TMOOMsxvAm+StFhtJ/nXQkByePnLgCwNUeTDqaJ7xTcmhpMmwvWQ31q1XIAs/+z5Ownzio/AOT9GBYuQOkwMqj8aWZ9WL0qjatCUIi5IbMwJqVw43UAqX2llsxzJa+1phonwUzpxB5DlNOgQ5o6k8C6EkVAdgCWl2q+vI115h5sKdMZ35CoODzF/jjPwuTePhQqfzH+AJKyG6ApaS478vvxA6F0DXblHaNOAkkGIU7eWeQayOIAlTmE76ZDnQjlopFIxKsgUjeM3uwt93W5Qkeu6yXcnwA3z6Ka+DpVKRHAKQBz3UZYK9yMJn8fJOm99+HFTOrRADJnCidFCqY7yPPlqHVORlmT/OPX9j5cjzffDoZzwWcAwzk9KPWBX3rNnwAkWU5Rt8Uufhddgpd6HJeOpHspZQALJUn0Y5uVsBW1tKzui1Eeej/FdWlTFqUpxmYmziGnAIk8/Cutjk88YfcVVYgpufVv0dgksLVrVti7rJydIwQAFKEBD+KTIZyRjpYEE4Y2cIyMy+zJy/yKJ5RpCdI9TAAtEoVtUL4JQ/icG846egIVzTtfQ0J2SHf7ejiKaRohANDNfZ27i6+vkAR23ye30yVqyuIIw6VzSAJe25QeIvYAl2tcfNdwQkFugwyoPGjjqE6Wx4s35JlE0njm6kYP7QBJF/uJwGjjONp5A4dF7TPduqaL4oVtAwiSXORMd6YLAJxMVekRG3ov/hJgKDtWIvXw2q/s0sRjT5ioOpDKb4oAaIfBnftwrZjgMK/L3iShiYXPlyihV8DwEo+mFOVgpQCiMddDt4Glwjw3YN6saJyZXqz1SS6qrfpKt69HZ0GAAHDFLz8rj7WzHz9+RQ5XzSeNB/fLNCDZLppVhjO4lHsAvSF3WItWr9h1ZfVI3Y3r13QycpotlfiUs0sRBKgZnQDGhTpZDDI61/eF7dzKZjlXw1mYy21kFcjNMTrhtfMwAAJxdynLtYFkfFM0HtpFY1LzWDVJCBWGbMDAaatBSGoAIBJP3fFcFK1zFyPTv00L1eKHQnNkRFuOaD8ENyhoyAAYxkFP6SpVZmGCwk/AK/Aw9fHHq0FigncbzvgovLFDAPp7sQmlOOiU/fvRwbRFVwDbpskF4LqyVrUZuucQXUsABbVHjkdOjlFSpGiHQ4WbPlf6euCs6dOU9Fg6utYg5wC1ogCefUM0c2wVdk2xzUv0pvnX4LHY6D2aB+gPDCskAEIzQzffd0HgrxTues9qNTyX4a8n/6kIDlgdMRGJpM0AjVsMmUuB3PiR8LVb6wXv6PYI6G3XHarLv/VxuZnK5wCEcUdYNImp+fEjfnCl25f3UWsEpzv6J6Gz96uu/gdsAF8i6p8ErfOjkLElYCbxHMlxSHHKxjd+JMYX5MXA5BUAKCqS6qdEMrmKTYs43rclZZPZCko6ATJcw7omtNMsNABWGObeulxBCYi/sipQknPY3uRn9KKBA+zrGuEsbCr6AJgIsNQHqDSZPrNxE2oArPcwLL4MIYRuJLi4rKjM2pYA6VYAHRdAZGqaB3EI96lUriBPRs2b7yPra7B5cbDVzgBPmaNulhRcxNjdJH9CjAfvh4Z1gLqvut+LBTG+pfGGAOaoXNYustiKTaMatnjUrEx+R/H9lF9/yAH/fVb+7BQALQJNK9AR+TY6yw4lfhsYlBHjYyuQImTRDJcODoJSPQAE0QKqBQY6iR5yHqUeMWnGJEYmMmKb7pu7lz4bqLxkAATC5r1cOp0RTTwtvDnQTfIy4DoqLX+xnez+A94fkJYAEbBFv1ITPWsmI0PYP3NDVH/oJFqjRUeATqj8H7tYtgC7hjFqUUaeVOcIElBJZQfnDcFSVQFCKUL2fgmM6UTbAJ16zL8IKQoXVBrmPE62zfU7t2HM6gYrJOLNk458qpEANbOG+ZutAU+8f2lRlUFRq8rNh53ChzyhSgdqy3uQCQBEvibIUiqz48D4zXHvsXF2w5GNCCy483N+oeOAyVvpAFbaNDC/tSKgGuK3uYZdfFekE4v9AmDDt3bVwl5GWpIARFhkKVRUIBe8xTgvJJsQZpPPW71Oy7NbCTF3Dy4XiwAT3dRfsEkvn3mFOOy4WzRAP7yp4FdBPMAIMlDxj4MMAPyd8qGZI/+CO8QgbdtWdwMDWN5g87AhGR7pl6J2rV8AxQKshVG/9Ehs1foZ8G9q3MrNAM+QZcRtAebFLXrIegCa3BKGbwjl+xkoeg3ylG1H8T801rFf+ICwKPLTT2cRAJIC0/vbSkydLr99RgAogTPG7qPPUM9sZvYgzg1ZiYUADtJHafJ9gb+kps/TsToVcutO4DzaGNTBL+56pWr6MACHcEmrDSLb/5Ma411aLpV51Vn9bqB1syGjXatMea1rAKCmVEa/xZcYob9y2w+aPT3IH3rtIOn87HToqMDNmVkAsmjb4LozT9hmn7lxcAH3+db6FniLWlqsUZosYmp/JQCWmcoa+bP5/Ckv7qc7pTT4wOGkf6BGluUOmU5FX/DtAE8W8eiTmO9mljJuZs+LsoCks51CKrwkCCsInxzJ9GQA6oE7zgJL+l+mhGQoiFU1Mgdcb5TFkGvQEVkOmR4slgCAidl5+glvRMLqWdJfy+ppr/a02+8e5arxbRHhAIHaACYthVXDzpgLDoev1DpSQoW6A7kJfoiCqNU1no2ssv4AkNP3PprFPW1oxFR29CigbJ/DDbJ4b65nypW/fQ3oDQDEtdk/CMb6cTBzAkL7TnliluG20MhRnrLiyB+kq+hFAM6wpTJJLmJ2c7jNJ2KHaJib1QUjmn8TBNQCNJWo7IEANDABtJbBaRQaLf+eY0OqFrLQyBAsY5q8aR6bIiwbUwCM1wBdONiNDt/18PnGeKTrW6zVPxGvX2rNHoGwaQnNAIBzbbzVYe3FDZs0LuZtNdRN7DXN5u1IhmRiInoXUNIANmip7NHTcuRQsOPNGTtqEj9QBi0EBxqQ4YuEZh8/BwBO1Ri9PdP8go883XD/7BtZEYPJxSDTQ4hZoR8IDwCrAB1wWR2MCqsSnguosLhCxDT79ebrvaJbeX3n4BMvfrwAUA3owcuPCmNAfyG+6p+A73+arma1YgF8Bm4RcNZGsQCH0nJxSK9IPC4Mw2Ywr/B66O+JwKof0oEkRW9+rtLgADO7Tq6wCFL5oQbr1yZKDc86o1uvQthuWijl05KGS+YAOPmg8L/dFfflFYuRwnKA1FiGqOKvqon1pm2MS/qHLwA8sHNXBKIENRDaTht7DcFR2hVt4wePJ++jFmWad0s0ALIfrzobpNe7+8Zr9xduq9yWDX9narzQOY6ZVr74B88ABa0AkwXqKcKBlKod0TTGq6m3jFtWKVWFODJHK/RIKgDAhuXd6c7KLFcKLVtCPU+WHf3k7EfXa8a7WMCQyiUUAI//olI2YMJnu2Z+mzCDd/bGA+GAhvvqLJqCwtXdXgQAXYMC6RuPc5Caytgy5l+WhWdYaJoA1RfIwHjnvihHMQAt8HydF94yXisDUzrvagBoFhWEt4cssjiA0o9qgKBQAKYq9xO69uWQ6fnyMvI8Y2sdIepXjAkbW2QOhxtu/38ACqL43mrJIq1InPVSU3VDKMwmKioxaJEBEITe2fRxIQAyEDAAWchKrz0zPQb291weyDoacrxm6VFXmwvjDUbwABOGDoLmPbyGO8Nud2brh9G+hwENlZ3zhD6+brHxk4cAjcdmPfgV/HuO9rTvVwercRkDD+BDFXfW4p17tDI0agAfLIW2r3CrICb9oyGvZZF2EQ9qrI/n+eUO3AvFV+YoAOG3Lvx7CfvD+xKfV03K/PYUkLhJjCiIR/HcqZgmzRIADUP1L//1nwUYMwIrx1tLgLdPtpqpLLUbCj3TVxX9YQAqHzCtfMkoygJEWaILMkin96JqiWbAR+rL7LfKLrqAAHlIhI55RiQ80Tx8+/tdY91bNA/OSmcpe4vddR9W9VMA7PI9oD3N9Q4wGY7KejckBUgMMmkzNjNipdIeFiU1NQDv8P9KDdm9SSYbgq6ICuEQlf8uvrUwwI3FLRkYeSZ2ABu3gOuPph+5pyQHj/th4Ue5of1nKwCKVNIh9nGslmIA1XkPRxlsGApMYldJu3weE4EZHfgUpo63+kwY2PUArwDwMPFW9oLyEiar6+c4G3V1zg8Pg6l3bnlS42UlrGw1ABb2rzjJzhHUmGTsrPZ27Wyiur4Oto+3A7PQTkn2Q+MAUXZKeIRSgrVJPDbaFMfXx5znFqRnIWTuQIHjhHGirQDMmQyEBaLMZ/7hW0aRQwkCJN94xEUUYNUyaqay3ZqyADMxVDI55Swidk+gOsIL3PlAz482rIj9L6QpIvEfk8UArjjQJFL4LFqtkJURetcnmDUS4Z3EQCVKETI5gkUiKABaOpNWAFRHY4SSC35SxHuWkiWNNDTB80BNbe92xpBxAB78SeUWlMmsN059Md0bmvqeEfbL5rMaBNoEk5/BcnMAQ3YJeghSXKhaN9IVVn0RYzPQ9rfrOCD/APT3i5mHbwDK4q1IXfPtUYhCTjRWxBNJtWAJ0Z4it0/Hd9BYLkCd","commitment":"0x801993070759927b10a856e8fb0301d9230e79a7b8ed30656820d03c134d1b6e281442e4fb118f95c7b0203b57970c62","kzgProofContract":"0xb5241c09f40881bf8117da997a6db57f925034ca9148f7547b9b586159bc37540899f1769a56d8cf4487ea9b885683f5","kzgProofSidecar":"0x98a6d2dcbd2132eff4a5b73d3e71e37f64a18f8631d2de8101346efcc0a8f00c2ec6ee5516586d31b6cff907be6814aa","expectedX":"0xd7223dc0c3d0a341fe1de44522847a502e2aa5774451651e706039a334e649c6","expectedY":"0x001c251f6cb9268b41a305f0499b8526172739f550d3d0ed8683a520ba5af561","snarkHash":"0x09452c230d2cb58729481eed11baa0551e1c35e83cb991e272aa347cd250f9e3","conflationOrder":{"startingBlockNumber":82,"upperBoundaries":[86,89,99,104,114]},"parentStateRootHash":"0xf0f26782f7afb93f926cacb145f55530714f20b1356725e3971dc99e0ef8b591","finalStateRootHash":"0xc09cb8054d47366fbdcc9284f19d41a9485fbd9678d18e3c612863bcbbb4aab4","parentDataHash":"0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618","expectedShnarf":"0x91f7a22e718c16e213fd6d5de1fe25c402e9a2bd5c17a8b687719e8f2809391e","prevShnarf":"0xc9b52248ba020e4f29587e15f18f1ef132656ab90d040c47ae93d82c65e6d022"} +{ + "eip4844Enabled": true, + "dataHash": "0x017b1d49c6c7947f83855cc16063ef19d02369540b97867855427b56cdaea487", + "compressedData": "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", + "commitment": "0x801993070759927b10a856e8fb0301d9230e79a7b8ed30656820d03c134d1b6e281442e4fb118f95c7b0203b57970c62", + "kzgProofContract": "0xb96b2176ade99c17c3db7e087fc4b19462a4bc9aafa3b6e908c0af636666417478bc94e90c243f81fc8b1fdfdc63c0e9", + "kzgProofSidecar": "0x98a6d2dcbd2132eff4a5b73d3e71e37f64a18f8631d2de8101346efcc0a8f00c2ec6ee5516586d31b6cff907be6814aa", + "expectedX": "0xb1ab86e851a7a8ec64fce0122ee87807417dea2443ee96fa7c6678ea30a2bbc2", + "expectedY": "0x191eb029817a223a10542632d265e308eac3a37bf4effc00b94b9111e0819cdb", + "snarkHash": "0x12158e2cffc57475dc89c6d8e61c2a433902307cddf347ff6ff42fe532ffe1e6", + "conflationOrder": { + "startingBlockNumber": 82, + "upperBoundaries": [ + 86, + 89, + 99, + 104, + 114 + ] + }, + "parentStateRootHash": "0xf0f26782f7afb93f926cacb145f55530714f20b1356725e3971dc99e0ef8b591", + "finalStateRootHash": "0xc09cb8054d47366fbdcc9284f19d41a9485fbd9678d18e3c612863bcbbb4aab4", + "parentDataHash": "0x01a142b35ad91719145a4e3bf1d5402e6a73818db67312ade7a73ad5130ac618", + "expectedShnarf": "0x713ee848a009c425ce9721ad48f67720f9ea3831a5f9c08bc7a2a7a0740f5709", + "prevShnarf": "0xfd910670a8da6aaaf2431ce7345a605dc15dc41298b9410065d2f7bb1ba99fea" +} \ No newline at end of file diff --git a/contracts/scripts/testEIP4844/SixInOne/sendBlobTransaction.ts b/contracts/scripts/testEIP4844/SixInOne/sendBlobTransaction.ts index bab9a77f0..2ed8bfcee 100644 --- a/contracts/scripts/testEIP4844/SixInOne/sendBlobTransaction.ts +++ b/contracts/scripts/testEIP4844/SixInOne/sendBlobTransaction.ts @@ -333,7 +333,6 @@ async function sendProof( 0, [ proofFile.parentStateRootHash, - submissionData.shnarf, finalSubmissionData.finalBlockInData, [ finalSubmission.prevShnarf, @@ -357,12 +356,12 @@ async function sendProof( console.log(proofData); const encodedCall = ethers.concat([ - "0xabffac32", + "0x227be0dc", ethers.AbiCoder.defaultAbiCoder().encode( [ "bytes", "uint256", - "tuple(bytes32,bytes32,uint256,tuple(bytes32,bytes32,bytes32,bytes32,bytes32),uint256,uint256,bytes32,bytes32,uint256,uint256,uint256,bytes32[],bytes)", + "tuple(bytes32,uint256,tuple(bytes32,bytes32,bytes32,bytes32,bytes32),uint256,uint256,bytes32,bytes32,uint256,uint256,uint256,bytes32[],bytes)", ], proofData, ), diff --git a/contracts/test/L1MessageService.ts b/contracts/test/L1MessageService.ts index 3a36c907a..417004d1f 100644 --- a/contracts/test/L1MessageService.ts +++ b/contracts/test/L1MessageService.ts @@ -1115,7 +1115,7 @@ describe("L1MessageService", () => { await expectRevertWithCustomError(l1MessageServiceMerkleProof, claimMessageCall, "MessageAlreadyClaimed", [1]); }); - it("Should fail when l2 merkle root does not exist on L1", async () => { + it("Should fail when l2 Merkle root does not exist on L1", async () => { const claimMessageCall = l1MessageServiceMerkleProof.claimMessageWithProof({ proof: VALID_MERKLE_PROOF.proof, messageNumber: 1, diff --git a/contracts/test/LineaRollup.ts b/contracts/test/LineaRollup.ts index a355afaeb..be6600db8 100644 --- a/contracts/test/LineaRollup.ts +++ b/contracts/test/LineaRollup.ts @@ -3,7 +3,7 @@ import { loadFixture, time as networkTime } from "@nomicfoundation/hardhat-netwo import { expect } from "chai"; import { config, ethers, upgrades } from "hardhat"; import { HardhatNetworkHDAccountsConfig } from "hardhat/types"; -import { HDNodeWallet, Transaction, Wallet, ZeroAddress } from "ethers"; +import { BaseContract, HDNodeWallet, Transaction, Wallet, ZeroAddress } from "ethers"; import { TestLineaRollup } from "../typechain-types"; import calldataAggregatedProof1To155 from "./testData/compressedData/aggregatedProof-1-155.json"; import blobAggregatedProof1To155 from "./testData/compressedDataEip4844/aggregatedProof-1-155.json"; @@ -37,8 +37,8 @@ import { UNPAUSE_ALL_ROLE, PAUSE_BLOB_SUBMISSION_ROLE, UNPAUSE_BLOB_SUBMISSION_ROLE, - PAUSE_FINALIZE_WITHPROOF_ROLE, - UNPAUSE_FINALIZE_WITHPROOF_ROLE, + PAUSE_FINALIZATION_ROLE, + UNPAUSE_FINALIZATION_ROLE, DEFAULT_LAST_FINALIZED_TIMESTAMP, SIX_MONTHS_IN_SECONDS, USED_RATE_LIMIT_RESETTER_ROLE, @@ -56,7 +56,6 @@ import { generateRandomBytes, generateCallDataSubmission, generateCallDataSubmissionMultipleProofs, - generateParentSubmissionDataForIndex, generateKeccak256, expectEvent, buildAccessErrorMessage, @@ -70,6 +69,7 @@ import { convertStringToPaddedHexBytes, calculateLastFinalizedState, expectEvents, + expectEventDirectFromReceiptData, } from "./common/helpers"; import { CalldataSubmissionData, ShnarfDataGenerator } from "./common/types"; import aggregatedProof1To81 from "./testData/compressedData/multipleProofs/aggregatedProof-1-81.json"; @@ -430,9 +430,15 @@ describe("Linea Rollup contract", () => { const submitDataCall = lineaRollup .connect(operator) .submitDataAsCalldata(submissionData, prevShnarf, expectedShnarf, { gasLimit: 30_000_000 }); - const eventArgs = [expectedShnarf, 1, 46]; + const eventArgs = [ + submissionData.firstBlockInData, + submissionData.finalBlockInData, + prevShnarf, + expectedShnarf, + submissionData.finalStateRootHash, + ]; - await expectEvent(lineaRollup, submitDataCall, "DataSubmittedV2", eventArgs); + await expectEvent(lineaRollup, submitDataCall, "DataSubmittedV3", eventArgs); }); it("Should fail if the stored shnarf block number + 1 does not match the starting submission number", async () => { @@ -638,7 +644,19 @@ describe("Linea Rollup contract", () => { const signedTx = await operatorHDSigner.signTransaction(transaction); - await ethers.provider.broadcastTransaction(signedTx); + const txResponse = await ethers.provider.broadcastTransaction(signedTx); + const receipt = await ethers.provider.getTransactionReceipt(txResponse.hash); + expect(receipt).is.not.null; + + const expectedEventArgs = [ + blobDataSubmission[0].submissionData.firstBlockInData, + blobDataSubmission[0].submissionData.finalBlockInData, + parentShnarf, + finalShnarf, + blobDataSubmission[blobDataSubmission.length - 1].submissionData.finalStateRootHash, + ]; + + expectEventDirectFromReceiptData(lineaRollup as BaseContract, receipt!, "DataSubmittedV3", expectedEventArgs); const finalBlockNumber = await lineaRollup.shnarfFinalBlockNumbers(finalShnarf); expect(finalBlockNumber).to.equal(blobDataSubmission[0].submissionData.finalBlockInData); @@ -1102,7 +1120,7 @@ describe("Linea Rollup contract", () => { // Submit another 2 blobs await sendBlobTransaction(2, 4); // Finalize 4 blobs - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( blobAggregatedProof1To155, 4, fourthCompressedDataContent.finalStateRootHash, @@ -1177,8 +1195,6 @@ describe("Linea Rollup contract", () => { finalizationData.lastFinalizedL1RollingHash = HASH_ZERO; finalizationData.lastFinalizedL1RollingHashMessageNumber = 0n; - finalizationData.lastFinalizedShnarf = blobAggregatedProof1To155.parentAggregationFinalShnarf; - await lineaRollup.setRollingHash( blobAggregatedProof1To155.l1RollingHashMessageNumber, blobAggregatedProof1To155.l1RollingHash, @@ -1186,12 +1202,9 @@ describe("Linea Rollup contract", () => { const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - blobAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - { gasLimit: 50000 }, - ); + .finalizeBlocks(blobAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData, { + gasLimit: 50000, + }); // there is no reason await expect(finalizeCompressedCall).to.be.reverted; @@ -1220,8 +1233,6 @@ describe("Linea Rollup contract", () => { finalizationData.lastFinalizedL1RollingHash = HASH_ZERO; finalizationData.lastFinalizedL1RollingHashMessageNumber = 0n; - finalizationData.lastFinalizedShnarf = blobAggregatedProof1To155.parentAggregationFinalShnarf; - await lineaRollup.setRollingHash( blobAggregatedProof1To155.l1RollingHashMessageNumber, blobAggregatedProof1To155.l1RollingHash, @@ -1229,12 +1240,9 @@ describe("Linea Rollup contract", () => { const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - blobAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - { gasLimit: 400000 }, - ); + .finalizeBlocks(blobAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData, { + gasLimit: 400000, + }); await expectRevertWithCustomError( lineaRollup, @@ -1276,8 +1284,6 @@ describe("Linea Rollup contract", () => { finalizationData.lastFinalizedL1RollingHash = HASH_ZERO; finalizationData.lastFinalizedL1RollingHashMessageNumber = 0n; - finalizationData.lastFinalizedShnarf = blobAggregatedProof1To155.parentAggregationFinalShnarf; - await lineaRollup.setRollingHash( blobAggregatedProof1To155.l1RollingHashMessageNumber, blobAggregatedProof1To155.l1RollingHash, @@ -1285,12 +1291,9 @@ describe("Linea Rollup contract", () => { const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - blobAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - { gasLimit: 400000 }, - ); + .finalizeBlocks(blobAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData, { + gasLimit: 400000, + }); await expectRevertWithCustomError( lineaRollup, @@ -1307,7 +1310,7 @@ describe("Linea Rollup contract", () => { // Submit another 2 blobs await sendBlobTransaction(2, 4, true); // Finalize first 2 blobs - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( blobMultipleAggregatedProof1To81, 2, secondCompressedDataContent.finalStateRootHash, @@ -1315,7 +1318,7 @@ describe("Linea Rollup contract", () => { true, ); // Finalize last 2 blobs - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( blobMultipleAggregatedProof82To153, 4, fourthMultipleBlobDataContent.finalStateRootHash, @@ -1327,7 +1330,7 @@ describe("Linea Rollup contract", () => { }); }); - describe("Blocks finalization without proof", () => { + describe("Blocks finalization with proof", () => { const messageHash = generateRandomBytes(32); beforeEach(async () => { @@ -1345,14 +1348,11 @@ describe("Linea Rollup contract", () => { const parentStateRootHash = await lineaRollup.stateRootHashes(lastFinalizedBlockNumber); finalizationData.parentStateRootHash = parentStateRootHash; - const currentFinalizedShnarf = await lineaRollup.currentFinalizedShnarf(); - finalizationData.lastFinalizedShnarf = currentFinalizedShnarf; - const proof = calldataAggregatedProof1To155.aggregatedProof; const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError( lineaRollup, @@ -1372,14 +1372,11 @@ describe("Linea Rollup contract", () => { const parentStateRootHash = await lineaRollup.stateRootHashes(lastFinalizedBlockNumber); finalizationData.parentStateRootHash = parentStateRootHash; - const currentFinalizedShnarf = await lineaRollup.currentFinalizedShnarf(); - finalizationData.lastFinalizedShnarf = currentFinalizedShnarf; - const proof = calldataAggregatedProof1To155.aggregatedProof; const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "MissingMessageNumberForRollingHash", [ finalizationData.l1RollingHash, @@ -1403,7 +1400,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "MissingRollingHashForMessageNumber", [ finalizationData.l1RollingHashMessageNumber, @@ -1420,14 +1417,11 @@ describe("Linea Rollup contract", () => { const parentStateRootHash = await lineaRollup.stateRootHashes(lastFinalizedBlockNumber); finalizationData.parentStateRootHash = parentStateRootHash; - const currentFinalizedShnarf = await lineaRollup.currentFinalizedShnarf(); - finalizationData.lastFinalizedShnarf = currentFinalizedShnarf; - const proof = calldataAggregatedProof1To155.aggregatedProof; const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(proof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "L1RollingHashDoesNotExistOnL1", [ finalizationData.l1RollingHashMessageNumber, @@ -1462,8 +1456,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1490,11 +1482,7 @@ describe("Linea Rollup contract", () => { const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCompressedCall, "FinalizationStateIncorrect", [ expectedHashValue, @@ -1529,8 +1517,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1538,73 +1524,13 @@ describe("Linea Rollup contract", () => { const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCompressedCall, "FinalizationInTheFuture", [ finalizationData.finalTimestamp, (await networkTime.latest()) + 1, ]); }); - - it("Should revert if the parent datahash's fingerprint does not match", async () => { - const submissionDataBeforeFinalization = generateCallDataSubmission(0, 4); - let index = 0; - for (const data of submissionDataBeforeFinalization) { - const parentAndExpectedShnarf = generateParentAndExpectedShnarfForIndex(index); - await lineaRollup - .connect(operator) - .submitDataAsCalldata(data, parentAndExpectedShnarf.parentShnarf, parentAndExpectedShnarf.expectedShnarf, { - gasLimit: 30_000_000, - }); - index++; - } - - const finalizationData = await generateFinalizationData({ - l1RollingHash: calculateRollingHash(HASH_ZERO, messageHash), - l1RollingHashMessageNumber: 10n, - lastFinalizedTimestamp: DEFAULT_LAST_FINALIZED_TIMESTAMP, - finalBlockInData: BigInt(calldataAggregatedProof1To155.finalBlockNumber), - parentStateRootHash: calldataAggregatedProof1To155.parentStateRootHash, - finalTimestamp: BigInt(calldataAggregatedProof1To155.finalTimestamp), - l2MerkleRoots: calldataAggregatedProof1To155.l2MerkleRoots, - l2MerkleTreesDepth: BigInt(calldataAggregatedProof1To155.l2MerkleTreesDepth), - l2MessagingBlocksOffsets: calldataAggregatedProof1To155.l2MessagingBlocksOffsets, - aggregatedProof: calldataAggregatedProof1To155.aggregatedProof, - shnarfData: generateParentShnarfData(index), - }); - - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - - await lineaRollup.setRollingHash( - calldataAggregatedProof1To155.l1RollingHashMessageNumber, - calldataAggregatedProof1To155.l1RollingHash, - ); - - // Modify the shnarfData to create a mismatch - finalizationData.shnarfData.parentShnarf = generateRandomBytes(32); - - const finalizeCompressedCall = lineaRollup - .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); - - await expectRevertWithCustomError( - lineaRollup, - finalizeCompressedCall, - "FinalBlockDoesNotMatchShnarfFinalBlock", - [ - finalizationData.finalBlockInData, - await lineaRollup.shnarfFinalBlockNumbers(finalizationData.shnarfData.parentShnarf), - ], - ); - }); }); describe("Without submission data", () => { @@ -1635,8 +1561,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1647,11 +1571,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "FinalBlockStateEqualsZeroHash"); }); @@ -1668,11 +1588,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(nonAuthorizedAccount) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithReason(finalizeCall, buildAccessErrorMessage(nonAuthorizedAccount, OPERATOR_ROLE)); }); @@ -1683,7 +1599,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "IsPaused", [GENERAL_PAUSE_TYPE]); }); @@ -1694,7 +1610,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "IsPaused", [FINALIZATION_PAUSE_TYPE]); }); @@ -1703,7 +1619,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(EMPTY_CALLDATA, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "ProofIsEmpty"); }); @@ -1730,14 +1646,9 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - { - gasLimit: 30_000_000, - }, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData, { + gasLimit: 30_000_000, + }); await expectRevertWithCustomError(lineaRollup, finalizeCall, "StartingRootHashDoesNotMatch"); }); @@ -1755,7 +1666,7 @@ describe("Linea Rollup contract", () => { index++; } - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( calldataAggregatedProof1To155, index, fourthCompressedDataContent.finalStateRootHash, @@ -1763,55 +1674,6 @@ describe("Linea Rollup contract", () => { ); }); - it("Should revert if last finalized shnarf is wrong", async () => { - // Submit 4 sets of compressed data setting the correct shnarf in storage - const submissionDataBeforeFinalization = generateCallDataSubmission(0, 4); - - let index = 0; - for (const data of submissionDataBeforeFinalization) { - const parentAndExpectedShnarf = generateParentAndExpectedShnarfForIndex(index); - await lineaRollup - .connect(operator) - .submitDataAsCalldata(data, parentAndExpectedShnarf.parentShnarf, parentAndExpectedShnarf.expectedShnarf, { - gasLimit: 30_000_000, - }); - index++; - } - - const finalizationData = await generateFinalizationData({ - l1RollingHash: calldataAggregatedProof1To155.l1RollingHash, - l1RollingHashMessageNumber: BigInt(calldataAggregatedProof1To155.l1RollingHashMessageNumber), - lastFinalizedTimestamp: BigInt(calldataAggregatedProof1To155.parentAggregationLastBlockTimestamp), - finalBlockInData: BigInt(calldataAggregatedProof1To155.finalBlockNumber), - parentStateRootHash: calldataAggregatedProof1To155.parentStateRootHash, - finalTimestamp: BigInt(calldataAggregatedProof1To155.finalTimestamp), - l2MerkleRoots: calldataAggregatedProof1To155.l2MerkleRoots, - l2MerkleTreesDepth: BigInt(calldataAggregatedProof1To155.l2MerkleTreesDepth), - l2MessagingBlocksOffsets: calldataAggregatedProof1To155.l2MessagingBlocksOffsets, - aggregatedProof: calldataAggregatedProof1To155.aggregatedProof, - lastFinalizedShnarf: generateRandomBytes(32), - }); - - await lineaRollup.setRollingHash( - calldataAggregatedProof1To155.l1RollingHashMessageNumber, - calldataAggregatedProof1To155.l1RollingHash, - ); - - const initialShnarf = await lineaRollup.currentFinalizedShnarf(); - - const finalizeCall = lineaRollup - .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); - await expectRevertWithCustomError(lineaRollup, finalizeCall, "LastFinalizedShnarfWrong", [ - initialShnarf, - finalizationData.lastFinalizedShnarf, - ]); - }); - it("Should revert when proofType is invalid", async () => { const submissionDataBeforeFinalization = generateCallDataSubmission(0, 4); let index = 0; @@ -1839,8 +1701,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1848,7 +1708,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(calldataAggregatedProof1To155.aggregatedProof, 99, finalizationData); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, 99, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "InvalidProofType"); }); @@ -1879,8 +1739,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1891,11 +1749,7 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "InvalidProofType"); }); @@ -1926,8 +1780,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(index), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(0).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1936,7 +1788,7 @@ describe("Linea Rollup contract", () => { // aggregatedProof1To81.aggregatedProof, wrong proof on purpose const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(aggregatedProof1To81.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + .finalizeBlocks(aggregatedProof1To81.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); await expectRevertWithCustomError(lineaRollup, finalizeCall, "InvalidProof"); }); @@ -1967,8 +1819,6 @@ describe("Linea Rollup contract", () => { shnarfData: generateParentShnarfData(1), }); - finalizationData.lastFinalizedShnarf = generateParentSubmissionDataForIndex(1).shnarf; - await lineaRollup.setRollingHash( calldataAggregatedProof1To155.l1RollingHashMessageNumber, calldataAggregatedProof1To155.l1RollingHash, @@ -1976,15 +1826,8 @@ describe("Linea Rollup contract", () => { const finalizeCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof( - calldataAggregatedProof1To155.aggregatedProof, - TEST_PUBLIC_VERIFIER_INDEX, - finalizationData, - ); - await expectRevertWithCustomError(lineaRollup, finalizeCall, "LastFinalizedShnarfWrong", [ - calldataAggregatedProof1To155.parentAggregationFinalShnarf, - finalizationData.lastFinalizedShnarf, - ]); + .finalizeBlocks(calldataAggregatedProof1To155.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + await expectRevertWithCustomError(lineaRollup, finalizeCall, "InvalidProof"); }); it("Should successfully finalize 1-81 and then 82-153 in two separate finalizations", async () => { @@ -2000,7 +1843,7 @@ describe("Linea Rollup contract", () => { index++; } - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( aggregatedProof1To81, 2, secondCompressedDataContent.finalStateRootHash, @@ -2008,7 +1851,7 @@ describe("Linea Rollup contract", () => { true, ); - await expectSuccessfulFinalizeWithProof( + await expectSuccessfulFinalize( aggregatedProof82To153, 4, fourthMultipleCompressedDataContent.finalStateRootHash, @@ -2208,10 +2051,22 @@ describe("Linea Rollup contract", () => { }); const signedTx = await operatorHDSigner.signTransaction(transaction); - await ethers.provider.broadcastTransaction(signedTx); + const txResponse = await ethers.provider.broadcastTransaction(signedTx); + + const receipt = await ethers.provider.getTransactionReceipt(txResponse.hash); + + const expectedEventArgs = [ + blobSubmission[0].submissionData.firstBlockInData, + blobSubmission[blobSubmission.length - 1].submissionData.finalBlockInData, + parentShnarf, + finalShnarf, + blobSubmission[blobSubmission.length - 1].submissionData.finalStateRootHash, + ]; + + expectEventDirectFromReceiptData(lineaRollup as BaseContract, receipt!, "DataSubmittedV3", expectedEventArgs); } - async function expectSuccessfulFinalizeWithProof( + async function expectSuccessfulFinalize( // eslint-disable-next-line @typescript-eslint/no-explicit-any proofData: any, blobParentShnarfIndex: number, @@ -2237,16 +2092,21 @@ describe("Linea Rollup contract", () => { finalizationData.lastFinalizedL1RollingHash = lastFinalizedRollingHash; finalizationData.lastFinalizedL1RollingHashMessageNumber = lastFinalizedMessageNumber; - finalizationData.lastFinalizedShnarf = proofData.parentAggregationFinalShnarf; - await lineaRollup.setRollingHash(proofData.l1RollingHashMessageNumber, proofData.l1RollingHash); const finalizeCompressedCall = lineaRollup .connect(operator) - .finalizeBlocksWithProof(proofData.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); - const eventArgs = [BigInt(proofData.finalBlockNumber), finalizationData.parentStateRootHash, finalStateRootHash]; + .finalizeBlocks(proofData.aggregatedProof, TEST_PUBLIC_VERIFIER_INDEX, finalizationData); + + const eventArgs = [ + BigInt(proofData.lastFinalizedBlockNumber) + 1n, + finalizationData.finalBlockInData, + proofData.finalShnarf, + finalizationData.parentStateRootHash, + finalStateRootHash, + ]; - await expectEvent(lineaRollup, finalizeCompressedCall, "BlocksVerificationDone", eventArgs); + await expectEvent(lineaRollup, finalizeCompressedCall, "DataFinalizedV3", eventArgs); const [expectedFinalStateRootHash, lastFinalizedBlockNumber, lastFinalizedState] = await Promise.all([ lineaRollup.stateRootHashes(finalizationData.finalBlockInData), @@ -2275,7 +2135,7 @@ describe("Linea Rollup contract", () => { verifier = await plonkVerifier.getAddress(); const lineaRollup = (await deployUpgradableFromFactory( - "contracts/test-contracts/LineaRollupFlattened.sol:LineaRollupFlattened", + "contracts/test-contracts/LineaRollupV5.sol:LineaRollupV5", [ parentStateRootHash, 0, @@ -2309,8 +2169,8 @@ describe("Linea Rollup contract", () => { { addressWithRole: securityCouncilAddress, role: UNPAUSE_L2_L1_ROLE }, { addressWithRole: securityCouncilAddress, role: PAUSE_BLOB_SUBMISSION_ROLE }, { addressWithRole: securityCouncilAddress, role: UNPAUSE_BLOB_SUBMISSION_ROLE }, - { addressWithRole: securityCouncilAddress, role: PAUSE_FINALIZE_WITHPROOF_ROLE }, - { addressWithRole: securityCouncilAddress, role: UNPAUSE_FINALIZE_WITHPROOF_ROLE }, + { addressWithRole: securityCouncilAddress, role: PAUSE_FINALIZATION_ROLE }, + { addressWithRole: securityCouncilAddress, role: UNPAUSE_FINALIZATION_ROLE }, ]; }); diff --git a/contracts/test/PauseManager.ts b/contracts/test/PauseManager.ts index d0c9eacb8..0d0a3ad18 100644 --- a/contracts/test/PauseManager.ts +++ b/contracts/test/PauseManager.ts @@ -15,9 +15,9 @@ import { UNPAUSE_L1_L2_ROLE, PAUSE_L2_L1_ROLE, UNPAUSE_L2_L1_ROLE, - PAUSE_FINALIZE_WITHPROOF_ROLE, + PAUSE_FINALIZATION_ROLE, PAUSE_BLOB_SUBMISSION_ROLE, - UNPAUSE_FINALIZE_WITHPROOF_ROLE, + UNPAUSE_FINALIZATION_ROLE, UNPAUSE_BLOB_SUBMISSION_ROLE, BLOB_SUBMISSION_PAUSE_TYPE, CALLDATA_SUBMISSION_PAUSE_TYPE, @@ -55,8 +55,8 @@ describe("PauseManager", () => { pauseManager.grantRole(UNPAUSE_L2_L1_ROLE, pauseManagerAccount.address), pauseManager.grantRole(PAUSE_BLOB_SUBMISSION_ROLE, pauseManagerAccount.address), pauseManager.grantRole(UNPAUSE_BLOB_SUBMISSION_ROLE, pauseManagerAccount.address), - pauseManager.grantRole(PAUSE_FINALIZE_WITHPROOF_ROLE, pauseManagerAccount.address), - pauseManager.grantRole(UNPAUSE_FINALIZE_WITHPROOF_ROLE, pauseManagerAccount.address), + pauseManager.grantRole(PAUSE_FINALIZATION_ROLE, pauseManagerAccount.address), + pauseManager.grantRole(UNPAUSE_FINALIZATION_ROLE, pauseManagerAccount.address), ]); }); @@ -252,7 +252,7 @@ describe("PauseManager", () => { it("cannot pause the FINALIZATION_PAUSE_TYPE as non-manager", async () => { await expect(pauseByType(FINALIZATION_PAUSE_TYPE, nonManager)).to.be.revertedWith( - buildAccessErrorMessage(nonManager, PAUSE_FINALIZE_WITHPROOF_ROLE), + buildAccessErrorMessage(nonManager, PAUSE_FINALIZATION_ROLE), ); }); @@ -260,7 +260,7 @@ describe("PauseManager", () => { await pauseByType(FINALIZATION_PAUSE_TYPE); await expect(unPauseByType(FINALIZATION_PAUSE_TYPE, nonManager)).to.be.revertedWith( - buildAccessErrorMessage(nonManager, UNPAUSE_FINALIZE_WITHPROOF_ROLE), + buildAccessErrorMessage(nonManager, UNPAUSE_FINALIZATION_ROLE), ); }); }); diff --git a/contracts/test/common/constants/pauseTypes.ts b/contracts/test/common/constants/pauseTypes.ts index a9b2e2201..d08fcf90a 100644 --- a/contracts/test/common/constants/pauseTypes.ts +++ b/contracts/test/common/constants/pauseTypes.ts @@ -7,8 +7,8 @@ import { UNPAUSE_L2_L1_ROLE, PAUSE_BLOB_SUBMISSION_ROLE, UNPAUSE_BLOB_SUBMISSION_ROLE, - PAUSE_FINALIZE_WITHPROOF_ROLE, - UNPAUSE_FINALIZE_WITHPROOF_ROLE, + PAUSE_FINALIZATION_ROLE, + UNPAUSE_FINALIZATION_ROLE, PAUSE_INITIATE_TOKEN_BRIDGING_ROLE, UNPAUSE_INITIATE_TOKEN_BRIDGING_ROLE, PAUSE_COMPLETE_TOKEN_BRIDGING_ROLE, @@ -30,7 +30,7 @@ export const pauseTypeRoles = [ { pauseType: L2_L1_PAUSE_TYPE, role: PAUSE_L2_L1_ROLE }, { pauseType: BLOB_SUBMISSION_PAUSE_TYPE, role: PAUSE_BLOB_SUBMISSION_ROLE }, { pauseType: CALLDATA_SUBMISSION_PAUSE_TYPE, role: PAUSE_BLOB_SUBMISSION_ROLE }, - { pauseType: FINALIZATION_PAUSE_TYPE, role: PAUSE_FINALIZE_WITHPROOF_ROLE }, + { pauseType: FINALIZATION_PAUSE_TYPE, role: PAUSE_FINALIZATION_ROLE }, { pauseType: INITIATE_TOKEN_BRIDGING_PAUSE_TYPE, role: PAUSE_INITIATE_TOKEN_BRIDGING_ROLE }, { pauseType: COMPLETE_TOKEN_BRIDGING_PAUSE_TYPE, role: PAUSE_COMPLETE_TOKEN_BRIDGING_ROLE }, ]; @@ -41,7 +41,7 @@ export const unpauseTypeRoles = [ { pauseType: L2_L1_PAUSE_TYPE, role: UNPAUSE_L2_L1_ROLE }, { pauseType: BLOB_SUBMISSION_PAUSE_TYPE, role: UNPAUSE_BLOB_SUBMISSION_ROLE }, { pauseType: CALLDATA_SUBMISSION_PAUSE_TYPE, role: UNPAUSE_BLOB_SUBMISSION_ROLE }, - { pauseType: FINALIZATION_PAUSE_TYPE, role: UNPAUSE_FINALIZE_WITHPROOF_ROLE }, + { pauseType: FINALIZATION_PAUSE_TYPE, role: UNPAUSE_FINALIZATION_ROLE }, { pauseType: INITIATE_TOKEN_BRIDGING_PAUSE_TYPE, role: UNPAUSE_INITIATE_TOKEN_BRIDGING_ROLE }, { pauseType: COMPLETE_TOKEN_BRIDGING_PAUSE_TYPE, role: UNPAUSE_COMPLETE_TOKEN_BRIDGING_ROLE }, ]; diff --git a/contracts/test/common/constants/roles.ts b/contracts/test/common/constants/roles.ts index fe2a182b9..c885694c4 100644 --- a/contracts/test/common/constants/roles.ts +++ b/contracts/test/common/constants/roles.ts @@ -25,8 +25,8 @@ export const PAUSE_L2_L1_ROLE = generateKeccak256(["string"], ["PAUSE_L2_L1_ROLE export const UNPAUSE_L2_L1_ROLE = generateKeccak256(["string"], ["UNPAUSE_L2_L1_ROLE"], true); export const PAUSE_BLOB_SUBMISSION_ROLE = generateKeccak256(["string"], ["PAUSE_BLOB_SUBMISSION_ROLE"], true); export const UNPAUSE_BLOB_SUBMISSION_ROLE = generateKeccak256(["string"], ["UNPAUSE_BLOB_SUBMISSION_ROLE"], true); -export const PAUSE_FINALIZE_WITHPROOF_ROLE = generateKeccak256(["string"], ["PAUSE_FINALIZE_WITHPROOF_ROLE"], true); -export const UNPAUSE_FINALIZE_WITHPROOF_ROLE = generateKeccak256(["string"], ["UNPAUSE_FINALIZE_WITHPROOF_ROLE"], true); +export const PAUSE_FINALIZATION_ROLE = generateKeccak256(["string"], ["PAUSE_FINALIZATION_ROLE"], true); +export const UNPAUSE_FINALIZATION_ROLE = generateKeccak256(["string"], ["UNPAUSE_FINALIZATION_ROLE"], true); export const MINIMUM_FEE_SETTER_ROLE = generateKeccak256(["string"], ["MINIMUM_FEE_SETTER_ROLE"], true); export const OPERATOR_ROLE = generateKeccak256(["string"], ["OPERATOR_ROLE"], true); export const VERIFIER_SETTER_ROLE = generateKeccak256(["string"], ["VERIFIER_SETTER_ROLE"], true); diff --git a/contracts/test/common/helpers/dataGeneration.ts b/contracts/test/common/helpers/dataGeneration.ts index 11b2c6d1d..47414a19c 100644 --- a/contracts/test/common/helpers/dataGeneration.ts +++ b/contracts/test/common/helpers/dataGeneration.ts @@ -29,7 +29,6 @@ export async function generateFinalizationData(overrides?: Partial( contract: T, @@ -34,3 +34,22 @@ export async function expectEvents( ) { await Promise.all(events.map((event) => expectEvent(contract, asyncCall, event.name, event.args))); } + +export function expectEventDirectFromReceiptData( + contract: BaseContract, + transactionReceipt: TransactionReceipt, + expectedEventName: string, + expectedEventArgs: undefined[] = [], +) { + const logSnippet = { + topics: transactionReceipt?.logs[0].topics as ReadonlyArray, + data: transactionReceipt!.logs[0].data, + }; + + const event = contract.interface.parseLog(logSnippet); + expect(event).is.not.null; + expect(expectedEventName).equal(event!.name); + + // this is cast to array as the readonly is not compatible with deep + expect(event!.args.toArray()).to.have.deep.members(expectedEventArgs); +} diff --git a/contracts/test/common/types.ts b/contracts/test/common/types.ts index 896b3011c..2bd08eb78 100644 --- a/contracts/test/common/types.ts +++ b/contracts/test/common/types.ts @@ -79,7 +79,6 @@ export type SubmissionAndCompressedData = { export type FinalizationData = { aggregatedProof: string; finalBlockInData: bigint; - lastFinalizedShnarf: string; shnarfData: ShnarfData; parentStateRootHash: string; lastFinalizedTimestamp: bigint; From 48e10012dc5f807572adac4d1098f5a17426cef5 Mon Sep 17 00:00:00 2001 From: Arya Tabaie Date: Wed, 16 Oct 2024 07:59:44 -0500 Subject: [PATCH 09/12] Prover: decompression prover input padding and error handling (#187) * fix check for error first, then compare snarkHashes * revert: ProveCheck already runs test engine when needed * revert remove request file --------- Co-authored-by: Arya Tabaie <15056835+Tabaie@users.noreply.github.com> Co-authored-by: Leo Jeong --- prover/backend/blobdecompression/prove.go | 58 +++++++++-------------- 1 file changed, 22 insertions(+), 36 deletions(-) diff --git a/prover/backend/blobdecompression/prove.go b/prover/backend/blobdecompression/prove.go index 143d24fef..c657f1ef4 100644 --- a/prover/backend/blobdecompression/prove.go +++ b/prover/backend/blobdecompression/prove.go @@ -82,10 +82,6 @@ func Prove(cfg *config.Config, req *Request) (*Response, error) { return nil, fmt.Errorf("unsupported blob version: %v", version) } - setup, err := circuits.LoadSetup(cfg, circuitID) - if err != nil { - return nil, fmt.Errorf("could not load the setup: %w", err) - } dictPath := filepath.Join(cfg.PathForSetup(string(circuitID)), config.DictionaryFileName) logrus.Infof("reading the dictionary at %v", dictPath) @@ -95,24 +91,6 @@ func Prove(cfg *config.Config, req *Request) (*Response, error) { return nil, fmt.Errorf("error reading the dictionary: %w", err) } - maxUsableBytes, err := setup.Manifest.GetInt("maxUsableBytes") - if err != nil { - return nil, fmt.Errorf("missing maxUsableBytes in the setup manifest: %w", err) - } - - maxUncompressedBytes, err := setup.Manifest.GetInt("maxUncompressedBytes") - if err != nil { - return nil, fmt.Errorf("missing maxUncompressedBytes in the setup manifest: %w", err) - } - - if maxUsableBytes != expectedMaxUsableBytes { - return nil, fmt.Errorf("invalid maxUsableBytes in the setup manifest: %v, expected %v", maxUsableBytes, expectedMaxUsableBytes) - } - - if maxUncompressedBytes != expectedMaxUncompressedBytes { - return nil, fmt.Errorf("invalid maxUncompressedBytes in the setup manifest: %v, expected %v", maxUncompressedBytes, expectedMaxUncompressedBytes) - } - // This computes the assignment logrus.Infof("computing the circuit's assignment") @@ -123,35 +101,43 @@ func Prove(cfg *config.Config, req *Request) (*Response, error) { } assignment, pubInput, _snarkHash, err := blobdecompression.Assign( - blobBytes, + utils.RightPad(blobBytes, expectedMaxUsableBytes), dict, req.Eip4844Enabled, xBytes, y, ) + if err != nil { + return nil, fmt.Errorf("while generating the assignment: %w", err) + } + if !bytes.Equal(snarkHash, _snarkHash) { return nil, fmt.Errorf("blob checksum does not match the one computed by the assigner") } + setup, err := circuits.LoadSetup(cfg, circuitID) if err != nil { - return nil, fmt.Errorf("while generating the assignment: %w", err) + return nil, fmt.Errorf("could not load the setup: %w", err) + } + + maxUsableBytes, err := setup.Manifest.GetInt("maxUsableBytes") + if err != nil { + return nil, fmt.Errorf("missing maxUsableBytes in the setup manifest: %w", err) } - // Uncomment the following to activate the test.Solver. This is useful to - // debug when the circuit solving does not pass. It provides more useful - // information about what was wrong. + maxUncompressedBytes, err := setup.Manifest.GetInt("maxUncompressedBytes") + if err != nil { + return nil, fmt.Errorf("missing maxUncompressedBytes in the setup manifest: %w", err) + } - // err := test.IsSolved( - // &assignment, - // &assignment, - // ecc.BLS12_377.ScalarField(), - // test.WithBackendProverOptions(emPlonk.GetNativeProverOptions(ecc.BW6_761.ScalarField(), ecc.BLS12_377.ScalarField())), - // ) + if maxUsableBytes != expectedMaxUsableBytes { + return nil, fmt.Errorf("invalid maxUsableBytes in the setup manifest: %v, expected %v", maxUsableBytes, expectedMaxUsableBytes) + } - // if err != nil { - // panic(err) - // } + if maxUncompressedBytes != expectedMaxUncompressedBytes { + return nil, fmt.Errorf("invalid maxUncompressedBytes in the setup manifest: %v, expected %v", maxUncompressedBytes, expectedMaxUncompressedBytes) + } // This section reads the public parameters. This is a time-consuming part // of the process. From 01601f7c063fdd9134882325cef4e323b9aa8b3a Mon Sep 17 00:00:00 2001 From: Pedro Novais <1478752+jpnovais@users.noreply.github.com> Date: Wed, 16 Oct 2024 16:57:58 +0100 Subject: [PATCH 10/12] coordinator: fix integration test smart contract deploy helper (#197) coordinator: fix integration test smart contract deploy helper --- .../MakefileContractDeploymentHelper.kt | 17 +++-- .../MakefileContractDeploymentHelperKtTest.kt | 65 +++++++++++++++++++ 2 files changed, 77 insertions(+), 5 deletions(-) create mode 100644 coordinator/ethereum/test-utils/src/test/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelperKtTest.kt diff --git a/coordinator/ethereum/test-utils/src/main/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelper.kt b/coordinator/ethereum/test-utils/src/main/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelper.kt index 07f80faea..c616b0ea9 100644 --- a/coordinator/ethereum/test-utils/src/main/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelper.kt +++ b/coordinator/ethereum/test-utils/src/main/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelper.kt @@ -74,11 +74,11 @@ fun executeCommand( return futureResult.toSafeFuture() } -private val lineaRollupAddressPattern = Pattern.compile( - "^LineaRollup(?:AlphaV3)? deployed: address=(0x[0-9a-fA-F]{40}) blockNumber=(\\d+)" +internal val lineaRollupAddressPattern = Pattern.compile( + "^LineaRollup(?:.*)? deployed: address=(0x[0-9a-fA-F]{40}) blockNumber=(\\d+)" ) -private val l2MessageServiceAddressPattern = Pattern.compile( - "^L2MessageService deployed: address=(0x[0-9a-fA-F]{40}) blockNumber=(\\d+)" +internal val l2MessageServiceAddressPattern = Pattern.compile( + "^L2MessageService(?:.*)? deployed: address=(0x[0-9a-fA-F]{40}) blockNumber=(\\d+)" ) data class DeployedContract( @@ -91,7 +91,14 @@ fun getDeployedAddress( addressPattern: Pattern ): DeployedContract { val lines = commandResult.stdOut.toList().asReversed() - val matcher: Matcher? = lines + return getDeployedAddress(lines, addressPattern) +} + +fun getDeployedAddress( + cmdStdoutLines: List, + addressPattern: Pattern +): DeployedContract { + val matcher: Matcher? = cmdStdoutLines .firstOrNull { line -> addressPattern.matcher(line).find() } ?.let { addressPattern.matcher(it).also { it.find() } } diff --git a/coordinator/ethereum/test-utils/src/test/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelperKtTest.kt b/coordinator/ethereum/test-utils/src/test/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelperKtTest.kt new file mode 100644 index 000000000..62f8ed1f1 --- /dev/null +++ b/coordinator/ethereum/test-utils/src/test/kotlin/net/consensys/zkevm/ethereum/MakefileContractDeploymentHelperKtTest.kt @@ -0,0 +1,65 @@ +package net.consensys.zkevm.ethereum + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class MakefileContractDeploymentHelperKtTest { + + @Test + fun getDeployedAddress_messageService() { + assertThat( + getDeployedAddress( + listOf( + "L2MessageService artifact has been deployed in 1.2659626659999998s ", + "L2MessageService deployed: address=0xFE48d65B84AA0E23594Fd585c11cAD831F90AcB6 blockNumber=8", + "" + ), + l2MessageServiceAddressPattern + ) + ).isEqualTo( + DeployedContract("0xFE48d65B84AA0E23594Fd585c11cAD831F90AcB6", 8) + ) + + assertThat( + getDeployedAddress( + listOf( + "L2MessageServiceV1.2.3 artifact has been deployed in 1.2659626659999998s ", + "L2MessageServiceV1.2.3 deployed: address=0xFE48d65B84AA0E23594Fd585c11cAD831F90AcB6 blockNumber=8", + "" + ), + l2MessageServiceAddressPattern + ) + ).isEqualTo( + DeployedContract("0xFE48d65B84AA0E23594Fd585c11cAD831F90AcB6", 8) + ) + } + + @Test + fun getDeployedAddress_LineaRollup() { + assertThat( + getDeployedAddress( + listOf( + "LineaRollup artifact has been deployed in 1.855172125s ", + "LineaRollup deployed: address=0x8613180dF1485B8b87DEE3BCf31896659eb1a092 blockNumber=1414", + "" + ), + lineaRollupAddressPattern + ) + ).isEqualTo( + DeployedContract("0x8613180dF1485B8b87DEE3BCf31896659eb1a092", 1414) + ) + + assertThat( + getDeployedAddress( + listOf( + "LineaRollupV5.2.1 artifact has been deployed in 1.855172125s ", + "LineaRollupV5.2.1 deployed: address=0x8613180dF1485B8b87DEE3BCf31896659eb1a092 blockNumber=1414", + "" + ), + lineaRollupAddressPattern + ) + ).isEqualTo( + DeployedContract("0x8613180dF1485B8b87DEE3BCf31896659eb1a092", 1414) + ) + } +} From 946b0ef43c71616abffbb989186a5786442dbdae Mon Sep 17 00:00:00 2001 From: Nadeem Bhati Date: Wed, 16 Oct 2024 21:31:15 +0530 Subject: [PATCH 11/12] enhance TracesFilesManager test coverage (#137) * test: add edge case coverage for TracesFilesManager * remove unused aftereach import --------- Co-authored-by: Victorien Gauch <85494462+VGau@users.noreply.github.com> --- .../blockcreation/TracesFilesManagerTest.kt | 95 ++++++++++++++----- 1 file changed, 72 insertions(+), 23 deletions(-) diff --git a/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt b/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt index c6163c147..e3ea8aa11 100644 --- a/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt +++ b/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt @@ -93,14 +93,14 @@ class TracesFilesManagerTest { } @Test - fun `waitRawTracesGenerationOf - waits until traces file is found`() { - // write file with wrong extension - val inprogressFile = - tracesDir.resolve(Path.of("1-${block1Hash.toHexString()}.inprogress")).createFile() + fun `waitRawTracesGenerationOf waits until traces file is found`() { + val inprogressFile = tracesDir + .resolve(Path.of("1-${block1Hash.toHexString()}.inprogress")) + .createFile() assertThat(inprogressFile).exists() val future = tracesFilesManager.waitRawTracesGenerationOf(1uL, block1Hash) - vertx.setTimer((config.tracesGenerationTimeout.inWholeMilliseconds / 2)) { + vertx.setTimer(config.tracesGenerationTimeout.inWholeMilliseconds / 2) { Files.createFile(block1TracesFile) } @@ -108,22 +108,22 @@ class TracesFilesManagerTest { } @RepeatedTest(10) - fun `waitRawTracesGenerationOf - returns error after timeout`() { + fun `waitRawTracesGenerationOf returns error after timeout`() { val future = tracesFilesManager.waitRawTracesGenerationOf(2uL, block2Hash1) val exception = assertThrows { future.get() } assertThat(exception.cause).isInstanceOf(FileNotFoundException::class.java) - assertThat(exception.message).matches(".* File matching '2-$block2Hash1.* not found .*") + assertThat(exception.message) + .matches(".* File matching '2-$block2Hash1.* not found .*") } @Test - fun `cleanNonCanonicalSiblingsByHeight - returns error when file to keep is not found`() { + fun `cleanNonCanonicalSiblingsByHeight returns error when file to keep is not found`() { val future = tracesFilesManager.cleanNonCanonicalSiblingsByHeight(1uL, block1Hash) - assertThat(future.get()).isEmpty() } @Test - fun `cleanNonCanonicalSiblingsByHeight - removes found siblings`() { + fun `cleanNonCanonicalSiblingsByHeight removes found siblings`() { Files.createFile(block2TracesFile1) Files.createFile(block2TracesFile2) Files.createFile(block20TracesFile) @@ -138,17 +138,66 @@ class TracesFilesManagerTest { assertThat(block20TracesFile).exists() } - // @Test - // @Disabled("This feature is not necessary anymore. Just keeping the test in case we need to revert") - // fun `waitRawTracesGenerationOf - cleans non canonical siblings`() { - // Files.createFile(block2TracesFile1) - // Files.createFile(block2TracesFile2) - // assertThat(block2TracesFile1).exists() - // assertThat(block2TracesFile2).exists() - // - // tracesFilesManager.waitRawTracesGenerationOf(UInt64.valueOf(2), block2Hash1).get() - // - // assertThat(block2TracesFile1).exists() - // assertThat(block2TracesFile2).doesNotExist() - // } + @Test + fun `initialization fails when nonCanonicalTracesDir doesn't exist and creation is disabled`() { + val configWithoutDirCreation = config.copy( + createNonCanonicalTracesDirIfDoesNotExist = false + ) + Files.delete(nonCanonicalBlocksTracesDir) + + assertThrows { + TracesFilesManager(vertx, configWithoutDirCreation) + } + } + + @Test + fun `initialization creates nonCanonicalTracesDir when it doesn't exist and creation is enabled`() { + Files.delete(nonCanonicalBlocksTracesDir) + + TracesFilesManager(vertx, config) + + assertThat(nonCanonicalBlocksTracesDir).exists() + } + + @Test + fun `cleanNonCanonicalSiblingsByHeight moves files to nonCanonicalTracesDir`() { + Files.createFile(block2TracesFile1) + Files.createFile(block2TracesFile2) + + tracesFilesManager.cleanNonCanonicalSiblingsByHeight(2uL, block2Hash1).get() + + val movedFile = nonCanonicalBlocksTracesDir.resolve(block2TracesFile2.fileName) + assertThat(movedFile).exists() + assertThat(block2TracesFile2).doesNotExist() + } + + @Test + fun `cleanNonCanonicalSiblingsByHeight handles case sensitivity correctly`() { + val mixedCaseHash = block2Hash1.toHexString().uppercase() + val tracesFileName = TracesFiles.rawTracesFileNameSupplierV1( + 2uL, + Bytes32.fromHexString(mixedCaseHash), + tracesVersion, + tracesFileExtension + ) + val mixedCaseFile = tracesDir.resolve(Path.of(tracesFileName)) + Files.createFile(mixedCaseFile) + Files.createFile(block2TracesFile2) + + tracesFilesManager.cleanNonCanonicalSiblingsByHeight(2uL, block2Hash1).get() + + assertThat(mixedCaseFile).exists() + assertThat(block2TracesFile2).doesNotExist() + } + + @Test + fun `waitRawTracesGenerationOf handles extremely short polling interval`() { + val configWithShortPolling = config.copy(pollingInterval = 1.milliseconds) + val manager = TracesFilesManager(vertx, configWithShortPolling) + + val future = manager.waitRawTracesGenerationOf(1uL, block1Hash) + vertx.setTimer(50) { Files.createFile(block1TracesFile) } + + assertThat(future.get()).endsWith(block1TracesFile.toString()) + } } From f53e2d11d48d09a0d07075d7fc5c52504dd05dd7 Mon Sep 17 00:00:00 2001 From: Pedro Novais <1478752+jpnovais@users.noreply.github.com> Date: Wed, 16 Oct 2024 18:59:10 +0100 Subject: [PATCH 12/12] fix coordinator local overrides file (#199) * fix coordinator local overrides file * coordinator: removes broken test --- ...oordinator-local-dev.config.overrides.toml | 15 +++++-------- .../blockcreation/TracesFilesManagerTest.kt | 22 ------------------- 2 files changed, 6 insertions(+), 31 deletions(-) diff --git a/config/coordinator/coordinator-local-dev.config.overrides.toml b/config/coordinator/coordinator-local-dev.config.overrides.toml index 9a0a301fe..30ab4b87f 100644 --- a/config/coordinator/coordinator-local-dev.config.overrides.toml +++ b/config/coordinator/coordinator-local-dev.config.overrides.toml @@ -38,15 +38,12 @@ non-canonical-raw-traces-directory = "tmp/local/traces/raw-non-canonical" [state-manager] endpoints=["http://127.0.0.1:8998/"] -[dynamic-gas-price-service] -geth-gas-price-update-recipients=[ - "http://127.0.0.1:8645", - "http://127.0.0.1:8845" -] -besu-gas-price-update-recipients=[ - "http://127.0.0.1:8545/" -] -extra-data-update-recipient="http://127.0.0.1:8545/" +[l2-network-gas-pricing.extra-data-pricing-propagation] +extra-data-update-recipient = "http://127.0.0.1:8545/" + +[l2-network-gas-pricing.json-rpc-pricing-propagation] +geth-gas-price-update-recipients = ["http://127.0.0.1:8845"] +besu-gas-price-update-recipients = [] [l1] rpc-endpoint="http://127.0.0.1:8445" diff --git a/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt b/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt index e3ea8aa11..e74982bac 100644 --- a/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt +++ b/coordinator/app/src/test/kotlin/net/consensys/zkevm/coordinator/blockcreation/TracesFilesManagerTest.kt @@ -15,7 +15,6 @@ import java.nio.file.Files import java.nio.file.Path import java.util.concurrent.ExecutionException import kotlin.io.path.createFile -import kotlin.io.path.exists import kotlin.time.Duration.Companion.milliseconds class TracesFilesManagerTest { @@ -31,8 +30,6 @@ class TracesFilesManagerTest { Bytes32.fromHexString("0x00000000000000000000000000000000000000000000000000000000000000a1") private val block2Hash2 = Bytes32.fromHexString("0x00000000000000000000000000000000000000000000000000000000000000a2") - private val block20Hash = - Bytes32.fromHexString("0x0000000000000000000000000000000000000000000000000000000000000001") private lateinit var block1TracesFile: Path private lateinit var block2TracesFile1: Path private lateinit var block2TracesFile2: Path @@ -171,25 +168,6 @@ class TracesFilesManagerTest { assertThat(block2TracesFile2).doesNotExist() } - @Test - fun `cleanNonCanonicalSiblingsByHeight handles case sensitivity correctly`() { - val mixedCaseHash = block2Hash1.toHexString().uppercase() - val tracesFileName = TracesFiles.rawTracesFileNameSupplierV1( - 2uL, - Bytes32.fromHexString(mixedCaseHash), - tracesVersion, - tracesFileExtension - ) - val mixedCaseFile = tracesDir.resolve(Path.of(tracesFileName)) - Files.createFile(mixedCaseFile) - Files.createFile(block2TracesFile2) - - tracesFilesManager.cleanNonCanonicalSiblingsByHeight(2uL, block2Hash1).get() - - assertThat(mixedCaseFile).exists() - assertThat(block2TracesFile2).doesNotExist() - } - @Test fun `waitRawTracesGenerationOf handles extremely short polling interval`() { val configWithShortPolling = config.copy(pollingInterval = 1.milliseconds)