code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1 value |
|---|---|---|---|---|---|
package types
import (
"bytes"
"encoding/json"
"fmt"
"reflect"
"time"
null "gopkg.in/guregu/null.v3"
)
// NullDecoder converts data with expected type f to a guregu/null value
// of equivalent type t. It returns an error if a type mismatch occurs.
func NullDecoder(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
typeFrom := f.String()
typeTo := t.String()
expectedType := ""
switch typeTo {
case "null.String":
if typeFrom == reflect.String.String() {
return null.StringFrom(data.(string)), nil
}
expectedType = reflect.String.String()
case "null.Bool":
if typeFrom == reflect.Bool.String() {
return null.BoolFrom(data.(bool)), nil
}
expectedType = reflect.Bool.String()
case "null.Int":
if typeFrom == reflect.Int.String() {
return null.IntFrom(int64(data.(int))), nil
}
if typeFrom == reflect.Int32.String() {
return null.IntFrom(int64(data.(int32))), nil
}
if typeFrom == reflect.Int64.String() {
return null.IntFrom(data.(int64)), nil
}
expectedType = reflect.Int.String()
case "null.Float":
if typeFrom == reflect.Float32.String() {
return null.FloatFrom(float64(data.(float32))), nil
}
if typeFrom == reflect.Float64.String() {
return null.FloatFrom(data.(float64)), nil
}
expectedType = reflect.Float32.String() + " or " + reflect.Float64.String()
case "types.NullDuration":
if typeFrom == reflect.String.String() {
var d NullDuration
err := d.UnmarshalText([]byte(data.(string)))
return d, err
}
expectedType = reflect.String.String()
}
if expectedType != "" {
return data, fmt.Errorf("expected '%s', got '%s'", expectedType, typeFrom)
}
return data, nil
}
// Duration is an alias for time.Duration that de/serialises to JSON as human-readable strings.
type Duration time.Duration
func (d Duration) String() string {
return time.Duration(d).String()
}
// UnmarshalText converts text data to Duration
func (d *Duration) UnmarshalText(data []byte) error {
v, err := time.ParseDuration(string(data))
if err != nil {
return err
}
*d = Duration(v)
return nil
}
// UnmarshalJSON converts JSON data to Duration
func (d *Duration) UnmarshalJSON(data []byte) error {
if len(data) > 0 && data[0] == '"' {
var str string
if err := json.Unmarshal(data, &str); err != nil {
return err
}
v, err := time.ParseDuration(str)
if err != nil {
return err
}
*d = Duration(v)
} else {
var v time.Duration
if err := json.Unmarshal(data, &v); err != nil {
return err
}
*d = Duration(v)
}
return nil
}
// MarshalJSON returns the JSON representation of d
func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(d.String())
}
// NullDuration is a nullable Duration, in the same vein as the nullable types provided by
// package gopkg.in/guregu/null.v3.
type NullDuration struct {
Duration
Valid bool
}
// NewNullDuration is a simple helper constructor function
func NewNullDuration(d time.Duration, valid bool) NullDuration {
return NullDuration{Duration(d), valid}
}
// NullDurationFrom returns a new valid NullDuration from a time.Duration.
func NullDurationFrom(d time.Duration) NullDuration {
return NullDuration{Duration(d), true}
}
// UnmarshalText converts text data to a valid NullDuration
func (d *NullDuration) UnmarshalText(data []byte) error {
if len(data) == 0 {
*d = NullDuration{}
return nil
}
if err := d.Duration.UnmarshalText(data); err != nil {
return err
}
d.Valid = true
return nil
}
// UnmarshalJSON converts JSON data to a valid NullDuration
func (d *NullDuration) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte(`null`)) {
d.Valid = false
return nil
}
if err := json.Unmarshal(data, &d.Duration); err != nil {
return err
}
d.Valid = true
return nil
}
// MarshalJSON returns the JSON representation of d
func (d NullDuration) MarshalJSON() ([]byte, error) {
if !d.Valid {
return []byte(`null`), nil
}
return d.Duration.MarshalJSON()
}
// ValueOrZero returns the underlying Duration value of d if valid or
// its zero equivalent otherwise. It matches the existing guregu/null API.
func (d NullDuration) ValueOrZero() Duration {
if !d.Valid {
return Duration(0)
}
return d.Duration
} | k6/lib/types/types.go | 0.716615 | 0.4474 | types.go | starcoder |
package grid
import (
"errors"
"fmt"
"strconv"
"strings"
"github.com/pietrodll/aoc2021/utils/base"
)
type Grid struct {
values [][]int
Height int
Width int
}
// Constructor
func NewGrid(values [][]int) Grid {
height := len(values)
width := len(values[0])
valuesCopy := make([][]int, height)
for i, line := range values {
if len(line) != width {
panic(fmt.Errorf("values are not a grid: length of line %d is %d", i, len(line)))
}
lineCopy := make([]int, width)
copy(lineCopy, line)
valuesCopy[i] = lineCopy
}
return Grid{valuesCopy, height, width}
}
func NewGridFromString(data string, rowSep string, valSep string) Grid {
lines := strings.Split(data, rowSep)
height := len(lines)
width := 0
grid := make([][]int, height)
for i, line := range lines {
strValues := strings.Split(line, valSep)
if i == 0 {
width = len(strValues)
} else if len(strValues) != width {
panic(fmt.Errorf("values are not a grid: length of line %d is %d", i, len(strValues)))
}
row := make([]int, width)
for j, strVal := range strValues {
val, err := strconv.Atoi(strVal)
if err != nil {
panic(err)
}
row[j] = val
}
grid[i] = row
}
return Grid{grid, height, width}
}
// Implement coder interface
func (g *Grid) Encode(point base.Codable) int {
switch point := point.(type) {
case GridPoint:
return point.I*g.Width + point.J
default:
panic(errors.New("a Grid can only encode GridPoint"))
}
}
func (g *Grid) Decode(encoded int) base.Codable {
return GridPoint{encoded / g.Width, encoded % g.Width}
}
// Adjacent points
func (g *Grid) FindAdjacentPoints(point GridPoint) []GridPoint {
i, j := point.I, point.J
points := make([]GridPoint, 0)
if i > 0 {
points = append(points, GridPoint{i - 1, j})
}
if i < g.Height-1 {
points = append(points, GridPoint{i + 1, j})
}
if j > 0 {
points = append(points, GridPoint{i, j - 1})
}
if j < g.Width-1 {
points = append(points, GridPoint{i, j + 1})
}
return points
}
func (g *Grid) FindAdjacentPointsWithDiagonals(point GridPoint) []GridPoint {
i, j := point.I, point.J
points := make([]GridPoint, 0, 4)
if i > 0 {
points = append(points, GridPoint{i - 1, j})
if j > 0 {
points = append(points, GridPoint{i - 1, j - 1})
}
if j < g.Width-1 {
points = append(points, GridPoint{i - 1, j + 1})
}
}
if i < g.Height-1 {
points = append(points, GridPoint{i + 1, j})
if j > 0 {
points = append(points, GridPoint{i + 1, j - 1})
}
if j < g.Width-1 {
points = append(points, GridPoint{i + 1, j + 1})
}
}
if j > 0 {
points = append(points, GridPoint{i, j - 1})
}
if j < g.Width-1 {
points = append(points, GridPoint{i, j + 1})
}
return points
}
func (g *Grid) GetValue(point GridPoint) int {
return g.values[point.I][point.J]
}
func (g *Grid) GetPtr(point GridPoint) *int {
return &g.values[point.I][point.J]
}
func (g *Grid) SetValue(point GridPoint, value int) {
g.values[point.I][point.J] = value
}
func (g *Grid) StreamPoints() chan GridPoint {
stream := make(chan GridPoint)
go func() {
for i, line := range g.values {
for j := range line {
stream <- GridPoint{i, j}
}
}
close(stream)
}()
return stream
}
func (g *Grid) Copy() Grid {
return NewGrid(g.values)
} | advent-of-code-2021/utils/grid/grid.go | 0.71602 | 0.439687 | grid.go | starcoder |
package petstore
import (
"encoding/json"
)
// Whale struct for Whale
type Whale struct {
HasBaleen *bool `json:"hasBaleen,omitempty"`
HasTeeth *bool `json:"hasTeeth,omitempty"`
ClassName string `json:"className"`
}
// NewWhale instantiates a new Whale object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewWhale(className string, ) *Whale {
this := Whale{}
this.ClassName = className
return &this
}
// NewWhaleWithDefaults instantiates a new Whale object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewWhaleWithDefaults() *Whale {
this := Whale{}
return &this
}
// GetHasBaleen returns the HasBaleen field value if set, zero value otherwise.
func (o *Whale) GetHasBaleen() bool {
if o == nil || o.HasBaleen == nil {
var ret bool
return ret
}
return *o.HasBaleen
}
// GetHasBaleenOk returns a tuple with the HasBaleen field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *Whale) GetHasBaleenOk() (*bool, bool) {
if o == nil || o.HasBaleen == nil {
return nil, false
}
return o.HasBaleen, true
}
// HasHasBaleen returns a boolean if a field has been set.
func (o *Whale) HasHasBaleen() bool {
if o != nil && o.HasBaleen != nil {
return true
}
return false
}
// SetHasBaleen gets a reference to the given bool and assigns it to the HasBaleen field.
func (o *Whale) SetHasBaleen(v bool) {
o.HasBaleen = &v
}
// GetHasTeeth returns the HasTeeth field value if set, zero value otherwise.
func (o *Whale) GetHasTeeth() bool {
if o == nil || o.HasTeeth == nil {
var ret bool
return ret
}
return *o.HasTeeth
}
// GetHasTeethOk returns a tuple with the HasTeeth field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *Whale) GetHasTeethOk() (*bool, bool) {
if o == nil || o.HasTeeth == nil {
return nil, false
}
return o.HasTeeth, true
}
// HasHasTeeth returns a boolean if a field has been set.
func (o *Whale) HasHasTeeth() bool {
if o != nil && o.HasTeeth != nil {
return true
}
return false
}
// SetHasTeeth gets a reference to the given bool and assigns it to the HasTeeth field.
func (o *Whale) SetHasTeeth(v bool) {
o.HasTeeth = &v
}
// GetClassName returns the ClassName field value
func (o *Whale) GetClassName() string {
if o == nil {
var ret string
return ret
}
return o.ClassName
}
// GetClassNameOk returns a tuple with the ClassName field value
// and a boolean to check if the value has been set.
func (o *Whale) GetClassNameOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.ClassName, true
}
// SetClassName sets field value
func (o *Whale) SetClassName(v string) {
o.ClassName = v
}
func (o Whale) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.HasBaleen != nil {
toSerialize["hasBaleen"] = o.HasBaleen
}
if o.HasTeeth != nil {
toSerialize["hasTeeth"] = o.HasTeeth
}
if true {
toSerialize["className"] = o.ClassName
}
return json.Marshal(toSerialize)
}
type NullableWhale struct {
value *Whale
isSet bool
}
func (v NullableWhale) Get() *Whale {
return v.value
}
func (v *NullableWhale) Set(val *Whale) {
v.value = val
v.isSet = true
}
func (v NullableWhale) IsSet() bool {
return v.isSet
}
func (v *NullableWhale) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableWhale(val *Whale) *NullableWhale {
return &NullableWhale{value: val, isSet: true}
}
func (v NullableWhale) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableWhale) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
}
<<<<<<< HEAD
=======
>>>>>>> ooof | samples/openapi3/client/petstore/go-experimental/go-petstore/model_whale.go | 0.703448 | 0.427994 | model_whale.go | starcoder |
package intmat
import (
"encoding/json"
"fmt"
"strings"
"github.com/olekukonko/tablewriter"
)
type Vector struct {
mat *Matrix
}
type vector struct {
Mat *Matrix
}
func (vec *Vector) MarshalJSON() ([]byte, error) {
return json.Marshal(vector{
Mat: vec.mat,
})
}
func (vec *Vector) UnmarshalJSON(bytes []byte) error {
var v vector
err := json.Unmarshal(bytes, &v)
if err != nil {
return err
}
vec.mat = v.Mat
return nil
}
func NewVec(length int, values ...int) *Vector {
if len(values) != 0 {
if length != len(values) {
panic("length and number of values must be equal")
}
}
vec := Vector{
mat: NewMat(1, length, values...),
}
return &vec
}
func CopyVec(a *Vector) *Vector {
return &Vector{
mat: Copy(a.mat),
}
}
func (vec *Vector) offset() int {
return vec.mat.colStart
}
//String returns a string representation of this vector.
func (vec *Vector) String() string {
buff := &strings.Builder{}
table := tablewriter.NewWriter(buff)
table.SetBorder(false)
table.SetColumnSeparator("")
table.SetRowSeparator("")
table.SetHeaderLine(false)
row := make([]string, vec.Len())
for i := 0; i < vec.Len(); i++ {
j := i + vec.offset()
row[i] = fmt.Sprint(vec.at(j))
}
table.Append(row)
table.Render()
return buff.String()
}
func (vec *Vector) checkBounds(i int) {
if i < 0 || i >= vec.Len() {
panic(fmt.Sprintf("%v out of range: [0-%v]", i, vec.Len()-1))
}
}
//At returns the value at index i.
func (vec *Vector) At(i int) int {
vec.checkBounds(i)
j := i + vec.offset()
return vec.at(j)
}
func (vec *Vector) at(j int) int {
return vec.mat.rowValues[vec.mat.rowStart][j]
}
//Set sets the value at row index i and column index j to value.
func (vec *Vector) Set(i, value int) {
vec.checkBounds(i)
j := i + vec.offset()
vec.set(j, value)
}
func (vec *Vector) set(j, value int) {
vec.mat.set(vec.mat.rowStart, j, value)
}
//SetVec replaces the values of this vector with the values of from vector a.
func (vec *Vector) SetVec(a *Vector, i int) {
vec.mat.setMatrix(a.mat, vec.mat.rowStart, i+vec.mat.colStart)
}
func (vec *Vector) Len() int {
return vec.mat.cols
}
func (vec *Vector) Dot(a *Vector) int {
m := NewMat(1, 1)
m.Mul(vec.mat, a.mat.T())
return m.at(0, 0)
}
func (vec *Vector) NonzeroValues() (indexToValues map[int]int) {
indexToValues = make(map[int]int)
end := vec.mat.colStart + vec.mat.cols
for c, v := range vec.mat.rowValues[vec.mat.rowStart] {
if c < vec.mat.colStart || end <= c {
continue
}
indexToValues[c] = v
}
return
}
func (vec *Vector) T() *TransposedVector {
return &TransposedVector{
mat: vec.mat.T(),
}
}
//Slice creates a slice of the Vector. The slice will be connected to the original Vector, changes to one
// causes changes in the other.
func (vec *Vector) Slice(i, len int) *Vector {
if len <= 0 {
panic("slice len must >0")
}
vec.checkBounds(i)
j := i + vec.offset()
return &Vector{
mat: vec.mat.slice(0, j, 1, len),
}
}
func (vec *Vector) Add(a, b *Vector) {
if a == nil || b == nil {
panic("addition input was found to be nil")
}
if vec == a || vec == b {
panic("addition self assignment not allowed")
}
if a.Len() != b.Len() {
panic("adding vectors must have the same length")
}
if vec.Len() != a.Len() {
panic("adding vectors, destination must have the same length")
}
vec.mat.add(a.mat, b.mat)
}
func (vec *Vector) Equals(v *Vector) bool {
return vec.mat.Equals(v.mat)
}
func (vec *Vector) Mul(vec2 *Vector, mat *Matrix) {
if vec == nil || mat == nil {
panic("vector multiply input was found to be nil")
}
if vec == vec2 || vec.mat == mat {
panic("vector multiply self assignment not allowed")
}
if vec2.mat.cols != mat.rows {
panic(fmt.Sprintf("multiply shape misalignment can't vector-matrix multiply dims: (%v)x(%v,%v)", vec2.mat.cols, mat.rows, mat.cols))
}
_, matCols := mat.Dims()
if vec.mat.cols != matCols {
panic(fmt.Sprintf("vector not long enough to hold result, actual length:%v required:%v", vec.Len(), mat.cols))
}
vec.mat.mul(vec2.mat, mat)
}
func (vec *Vector) And(a, b *Vector) {
if a == nil || b == nil {
panic("AND input was found to be nil")
}
if vec == a || vec == b {
panic("AND self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("AND shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if vec.Len() != a.Len() {
panic(fmt.Sprintf("vec len:%v does not match expected %v", vec.Len(), a.Len()))
}
vec.mat.and(a.mat, b.mat)
}
func (vec *Vector) Or(a, b *Vector) {
if a == nil || b == nil {
panic("OR input was found to be nil")
}
if vec == a || vec == b {
panic("OR self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("OR shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if vec.Len() != a.Len() {
panic(fmt.Sprintf("vec len:%v does not match expected %v", vec.Len(), a.Len()))
}
vec.mat.or(a.mat, b.mat)
}
func (vec *Vector) XOr(a, b *Vector) {
if a == nil || b == nil {
panic("XOR input was found to be nil")
}
if vec == a || vec == b {
panic("XOR self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("XOR shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if vec.Len() != a.Len() {
panic(fmt.Sprintf("vec len:%v does not match expected %v", vec.Len(), a.Len()))
}
vec.mat.xor(a.mat, b.mat)
}
func (vec *Vector) Negate() {
vec.mat.Negate()
}
type TransposedVector struct {
mat *Matrix
}
type transposedVector struct {
Mat *Matrix
}
func (tvec *TransposedVector) MarshalJSON() ([]byte, error) {
return json.Marshal(transposedVector{
Mat: tvec.mat,
})
}
func (tvec *TransposedVector) UnmarshalJSON(bytes []byte) error {
var v transposedVector
err := json.Unmarshal(bytes, &v)
if err != nil {
return err
}
tvec.mat = v.Mat
return nil
}
func NewTVec(length int, values ...int) *TransposedVector {
if len(values) != 0 {
if length != len(values) {
panic("length and number of values must be equal")
}
}
vec := Vector{
mat: NewMat(1, length, values...),
}
return vec.T()
}
func CopyTVec(a *TransposedVector) *TransposedVector {
return &TransposedVector{
mat: Copy(a.mat),
}
}
func (tvec *TransposedVector) checkBounds(i int) {
if i < 0 || i >= tvec.Len() {
panic(fmt.Sprintf("%v out of range: [0-%v]", i, tvec.Len()-1))
}
}
func (tvec *TransposedVector) offset() int {
return tvec.mat.rowStart
}
func (tvec *TransposedVector) T() *Vector {
return &Vector{
mat: tvec.mat.T(),
}
}
func (tvec *TransposedVector) Len() int {
return tvec.mat.rows
}
func (tvec *TransposedVector) MulVec(a *Matrix, b *TransposedVector) {
if a == nil || b == nil {
panic("multiply input was found to be nil")
}
if tvec == b || tvec.mat == a {
panic("multiply self assignment not allowed")
}
if a.cols != b.mat.rows {
panic(fmt.Sprintf("multiply shape misalignment can't matrix-vector multiply (%v,%v)x(%v,1)", a.rows, a.cols, b.mat.rows))
}
if tvec.Len() != b.Len() {
panic(fmt.Sprintf("transposed vector length (%v) does not match expected (%v)", tvec.Len(), b.Len()))
}
tvec.mat.mul(a, b.mat)
}
func (tvec *TransposedVector) Add(a, b *TransposedVector) {
if a == nil || b == nil {
panic("addition input was found to be nil")
}
if tvec == a || tvec == b {
panic("addition self assignment not allowed")
}
if a.Len() != b.Len() {
panic("adding transposed vectors must have the same length")
}
if tvec.Len() != a.Len() {
panic("adding transposed vectors, destination must have the same length")
}
tvec.mat.add(a.mat, b.mat)
}
//At returns the value at index i.
func (tvec *TransposedVector) At(j int) int {
tvec.checkBounds(j)
i := j + tvec.offset()
return tvec.at(i)
}
func (tvec *TransposedVector) at(i int) int {
return tvec.mat.rowValues[i][tvec.mat.colStart]
}
//Set sets the value at row index i and column index j to value.
func (tvec *TransposedVector) Set(j, value int) {
tvec.checkBounds(j)
i := j + tvec.offset()
tvec.set(i, value)
}
//SetVec replaces the values of this vector with the values of from vector a.
func (tvec *TransposedVector) SetVec(a *TransposedVector, j int) {
tvec.mat.setMatrix(a.mat, j+tvec.mat.rowStart, tvec.mat.colStart)
}
//Slice creates a slice of the TransposedVector. The slice will be connected to the original TransposedVector, changes to one
// causes changes in the other.
func (tvec *TransposedVector) Slice(j, len int) *TransposedVector {
if len <= 0 {
panic("slice len must >0")
}
tvec.checkBounds(j)
i := j + tvec.offset()
return &TransposedVector{
mat: tvec.mat.slice(i, 0, len, 1),
}
}
func (tvec *TransposedVector) set(i, value int) {
tvec.mat.set(i, tvec.mat.colStart, value)
}
func (tvec *TransposedVector) Equals(v *TransposedVector) bool {
return tvec.mat.Equals(v.mat)
}
func (tvec *TransposedVector) NonzeroValues() (indexToValues map[int]int) {
indexToValues = make(map[int]int)
end := tvec.mat.rowStart + tvec.mat.rows
for r, v := range tvec.mat.colValues[tvec.mat.colStart] {
if r < tvec.mat.rowStart || end <= r {
continue
}
indexToValues[r] = v
}
return
}
func (tvec *TransposedVector) String() string {
buff := &strings.Builder{}
table := tablewriter.NewWriter(buff)
table.SetBorder(false)
table.SetColumnSeparator("")
table.SetRowSeparator("")
table.SetHeaderLine(false)
row := make([]string, tvec.Len())
for i := 0; i < tvec.Len(); i++ {
j := i + tvec.offset()
row[i] = fmt.Sprint(tvec.at(j))
}
table.Append(row)
table.Render()
return buff.String()
}
func (tvec *TransposedVector) And(a, b *TransposedVector) {
if a == nil || b == nil {
panic("AND input was found to be nil")
}
if tvec == a || tvec == b {
panic("AND self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("AND shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if tvec.Len() != a.Len() {
panic(fmt.Sprintf("tvec len:%v does not match expected %v", tvec.Len(), a.Len()))
}
tvec.mat.and(a.mat, b.mat)
}
func (tvec *TransposedVector) Or(a, b *TransposedVector) {
if a == nil || b == nil {
panic("OR input was found to be nil")
}
if tvec == a || tvec == b {
panic("OR self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("OR shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if tvec.Len() != a.Len() {
panic(fmt.Sprintf("tvec len:%v does not match expected %v", tvec.Len(), a.Len()))
}
tvec.mat.or(a.mat, b.mat)
}
func (tvec *TransposedVector) XOr(a, b *TransposedVector) {
if a == nil || b == nil {
panic("XOR input was found to be nil")
}
if tvec == a || tvec == b {
panic("XOR self assignment not allowed")
}
if a.Len() != b.Len() {
panic(fmt.Sprintf("XOR shape misalignment both inputs must be equal length found %v and %v", a.Len(), b.Len()))
}
if tvec.Len() != a.Len() {
panic(fmt.Sprintf("tvec len:%v does not match expected %v", tvec.Len(), a.Len()))
}
tvec.mat.xor(a.mat, b.mat)
}
func (tvec *TransposedVector) Negate() {
tvec.mat.Negate()
} | vec.go | 0.778565 | 0.5425 | vec.go | starcoder |
package io
import (
"math/big"
"reflect"
"time"
"unsafe"
"github.com/modern-go/reflect2"
)
// DecodeHandler is an decode handler.
type DecodeHandler func(dec *Decoder, t reflect.Type, p unsafe.Pointer)
func invalidDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
dec.decodeError(t, dec.NextByte())
}
func boolDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*bool)(p) = dec.decodeBool(t, dec.NextByte())
}
func intDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*int)(p) = dec.decodeInt(t, dec.NextByte())
}
func int8Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*int8)(p) = dec.decodeInt8(t, dec.NextByte())
}
func int16Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*int16)(p) = dec.decodeInt16(t, dec.NextByte())
}
func int32Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*int32)(p) = dec.decodeInt32(t, dec.NextByte())
}
func int64Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*int64)(p) = dec.decodeInt64(t, dec.NextByte())
}
func uintDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint)(p) = dec.decodeUint(t, dec.NextByte())
}
func uint8Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint8)(p) = dec.decodeUint8(t, dec.NextByte())
}
func uint16Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint16)(p) = dec.decodeUint16(t, dec.NextByte())
}
func uint32Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint32)(p) = dec.decodeUint32(t, dec.NextByte())
}
func uint64Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint64)(p) = dec.decodeUint64(t, dec.NextByte())
}
func uintptrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uintptr)(p) = dec.decodeUintptr(t, dec.NextByte())
}
func float32Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*float32)(p) = dec.decodeFloat32(t, dec.NextByte())
}
func float64Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*float64)(p) = dec.decodeFloat64(t, dec.NextByte())
}
func complex64Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*complex64)(p) = dec.decodeComplex64(t, dec.NextByte())
}
func complex128Decode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*complex128)(p) = dec.decodeComplex128(t, dec.NextByte())
}
func interfaceDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*interface{})(p) = dec.decodeInterface(dec.NextByte())
}
func stringDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*string)(p) = dec.decodeString(t, dec.NextByte())
}
func bytesDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*[]byte)(p) = dec.decodeBytes(t, dec.NextByte())
}
func timeDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*time.Time)(p) = dec.decodeTime(t, dec.NextByte())
}
func bigIntDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**big.Int)(p) = dec.decodeBigInt(t, dec.NextByte())
}
func bigFloatDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**big.Float)(p) = dec.decodeBigFloat(t, dec.NextByte())
}
func bigRatDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**big.Rat)(p) = dec.decodeBigRat(t, dec.NextByte())
}
func boolPtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**bool)(p) = dec.decodeBoolPtr(t, dec.NextByte())
}
func intPtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**int)(p) = dec.decodeIntPtr(t, dec.NextByte())
}
func int8PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**int8)(p) = dec.decodeInt8Ptr(t, dec.NextByte())
}
func int16PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**int16)(p) = dec.decodeInt16Ptr(t, dec.NextByte())
}
func int32PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**int32)(p) = dec.decodeInt32Ptr(t, dec.NextByte())
}
func int64PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**int64)(p) = dec.decodeInt64Ptr(t, dec.NextByte())
}
func uintPtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**uint)(p) = dec.decodeUintPtr(t, dec.NextByte())
}
func uint8PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**uint8)(p) = dec.decodeUint8Ptr(t, dec.NextByte())
}
func uint16PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**uint16)(p) = dec.decodeUint16Ptr(t, dec.NextByte())
}
func uint32PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(*uint32)(p) = dec.decodeUint32(t, dec.NextByte())
}
func uint64PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**uint64)(p) = dec.decodeUint64Ptr(t, dec.NextByte())
}
func uintptrPtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**uintptr)(p) = dec.decodeUintptrPtr(t, dec.NextByte())
}
func float32PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**float32)(p) = dec.decodeFloat32Ptr(t, dec.NextByte())
}
func float64PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**float64)(p) = dec.decodeFloat64Ptr(t, dec.NextByte())
}
func complex64PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**complex64)(p) = dec.decodeComplex64Ptr(t, dec.NextByte())
}
func complex128PtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**complex128)(p) = dec.decodeComplex128Ptr(t, dec.NextByte())
}
func interfacePtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**interface{})(p) = dec.decodeInterfacePtr(dec.NextByte())
}
func stringPtrDecode(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
*(**string)(p) = dec.decodeStringPtr(t, dec.NextByte())
}
func otherDecode(t reflect.Type) DecodeHandler {
valdec := getValueDecoder(t)
t2 := reflect2.Type2(t)
return func(dec *Decoder, t reflect.Type, p unsafe.Pointer) {
valdec.Decode(dec, t2.PackEFace(p), dec.NextByte())
}
}
// GetDecodeHandler for specified type.
func GetDecodeHandler(t reflect.Type) DecodeHandler {
if getRegisteredValueDecoder(t) == nil {
kind := t.Kind()
if decode := decodeHandlers[kind]; decode != nil {
return decode
}
if kind == reflect.Ptr {
if decode := decodePtrHandlers[t.Elem().Kind()]; decode != nil {
return decode
}
}
}
return otherDecode(t)
}
var (
decodeHandlers []DecodeHandler
decodePtrHandlers []DecodeHandler
)
func init() {
decodeHandlers = []DecodeHandler{
reflect.Invalid: invalidDecode,
reflect.Bool: boolDecode,
reflect.Int: intDecode,
reflect.Int8: int8Decode,
reflect.Int16: int16Decode,
reflect.Int32: int32Decode,
reflect.Int64: int64Decode,
reflect.Uint: uintDecode,
reflect.Uint8: uint8Decode,
reflect.Uint16: uint16Decode,
reflect.Uint32: uint32Decode,
reflect.Uint64: uint64Decode,
reflect.Uintptr: uintptrDecode,
reflect.Float32: float32Decode,
reflect.Float64: float64Decode,
reflect.Complex64: complex64Decode,
reflect.Complex128: complex128Decode,
reflect.Array: nil,
reflect.Chan: invalidDecode,
reflect.Func: invalidDecode,
reflect.Interface: interfaceDecode,
reflect.Map: nil,
reflect.Ptr: nil,
reflect.Slice: nil,
reflect.String: stringDecode,
reflect.Struct: nil,
reflect.UnsafePointer: invalidDecode,
}
decodePtrHandlers = []DecodeHandler{
reflect.Invalid: invalidDecode,
reflect.Bool: boolPtrDecode,
reflect.Int: intPtrDecode,
reflect.Int8: int8PtrDecode,
reflect.Int16: int16PtrDecode,
reflect.Int32: int32PtrDecode,
reflect.Int64: int64PtrDecode,
reflect.Uint: uintPtrDecode,
reflect.Uint8: uint8PtrDecode,
reflect.Uint16: uint16PtrDecode,
reflect.Uint32: uint32PtrDecode,
reflect.Uint64: uint64PtrDecode,
reflect.Uintptr: uintptrPtrDecode,
reflect.Float32: float32PtrDecode,
reflect.Float64: float64PtrDecode,
reflect.Complex64: complex64PtrDecode,
reflect.Complex128: complex128PtrDecode,
reflect.Array: nil,
reflect.Chan: invalidDecode,
reflect.Func: invalidDecode,
reflect.Interface: interfacePtrDecode,
reflect.Map: nil,
reflect.Ptr: nil,
reflect.Slice: nil,
reflect.String: stringPtrDecode,
reflect.Struct: nil,
reflect.UnsafePointer: invalidDecode,
}
} | io/decode_handler.go | 0.637934 | 0.548371 | decode_handler.go | starcoder |
package genetic
import (
"errors"
"sort"
"sync"
)
type facebook struct {
distribution func() float64
quality func(c *Chromosome) (float64, error)
fitness func(population []*Chromosome, q ...float64) error
selection func(population []*Chromosome, size int, d func() float64, fitness func(population []*Chromosome, q ...float64) error) ([]*Chromosome, error)
}
var (
// ErrorInvalidQualityStandardFitness the quality provided is worng
ErrorInvalidQualityStandardFitness = errors.New("the value of the quality parameter for the standard fitness is wrong")
// ErrorInvalidPopulation the provided population for the standard selection is not large enought to perform the selection operation
ErrorInvalidPopulation = errors.New("The population size can't be less than or equal to selection size")
)
// New initialices standard fitness and standard selection genetic algorithm
// to use with facebook data
func New(quality func(c *Chromosome) (float64, error)) Genetic {
return &facebook{
distribution: generateRandom,
quality: quality,
fitness: standardFitness,
selection: standardSelection,
}
}
func (f *facebook) Genesis(c *Chromosome) map[string][]*Gene {
var result = make(map[string][]*Gene)
var queue = []*Gene{c.Root}
for {
if len(queue) == 1 && queue[0] != c.Root {
if queue[0].ID != "" && queue[0].Value == 1 {
result[queue[0].Type] = append(result[queue[0].Type], queue[0])
}
break
}
if queue[0].ID != "" {
if queue[0].Value == 1 {
result[queue[0].Type] = append(result[queue[0].Type], queue[0])
}
}
queue = append(queue, queue[0].Children...)
queue = queue[1:]
}
return result
}
func (f *facebook) Mutate(c *Chromosome, rate float64) {
var wg sync.WaitGroup
go func(wg *sync.WaitGroup) {
wg.Add(1)
binaryMutation(c.Root, f.distribution, rate, wg)
wg.Done()
}(&wg)
wg.Wait()
}
func binaryMutation(gene *Gene, d func() float64, rate float64, wg *sync.WaitGroup) {
// In the facebook Graph only leaf nodes have an id and therefore
// the function can return after finding a leave node.
if gene.ID != "" {
if d() <= rate {
if gene.Value == 1 {
gene.Value = 0
} else {
gene.Value = 1
}
}
}
for i := 0; i < len(gene.Children); i++ {
go func(wg *sync.WaitGroup, i int) {
wg.Add(1)
binaryMutation(gene.Children[i], d, rate, wg)
wg.Done()
}(wg, i)
}
}
func (f *facebook) Fitness(population []*Chromosome) error {
var q float64
for i := 0; i < len(population); i++ {
qi, err := f.quality(population[i])
if err != nil {
return err
}
population[i].Quality = qi
q += qi
}
return f.fitness(population, q)
}
// standardFitness computes the fitness of a chromosome relative to the overall fitness of the population
func standardFitness(population []*Chromosome, q ...float64) error {
if len(q) != 1 {
return ErrorInvalidQualityStandardFitness
}
for i := 0; i < len(population); i++ {
population[i].Fitness = population[i].Quality / q[0]
}
return nil
}
func (f *facebook) Selection(population []*Chromosome, size int) ([]*Chromosome, error) {
return f.selection(population, size, f.distribution, standardFitness)
}
func standardSelection(population []*Chromosome, size int, d func() float64, fitness func(population []*Chromosome, q ...float64) error) ([]*Chromosome, error) {
if len(population) == size {
return population, nil
}
if len(population) < size {
return nil, ErrorInvalidPopulation
}
selected := make([]*Chromosome, size)
for i := 0; i < len(selected); i++ {
f := cumulative(population)
idx := sort.SearchFloat64s(f, d())
selected[i] = population[idx]
if idx == len(population) {
population = population[:idx-1]
} else {
population = append(population[:idx], population[idx+1:]...)
}
err := fitness(population, sumQuality(population))
if err != nil {
return nil, err
}
}
sort.SliceStable(selected, func(i, j int) bool {
return selected[i].Quality > selected[j].Quality
})
return selected, nil
}
func cumulative(population []*Chromosome) []float64 {
var a float64
d := make([]float64, len(population))
for i := 0; i < len(population)-1; i++ {
a += population[i].Fitness
d[i] = a
}
// Fix for floating point error
d[len(d)-1] = 1
return d
}
func sumQuality(population []*Chromosome) float64 {
var q float64
for i := 0; i < len(population); i++ {
q += population[i].Quality
}
return q
} | core/genetic/facebook.go | 0.644561 | 0.417212 | facebook.go | starcoder |
package parser
import "errors"
type mathNode struct {
Item interface{}
Left *mathNode
Right *mathNode
}
func (m *mathNode) Value(ctx SystemContext) (Value, error) {
switch i := m.Item.(type) {
case Valuer:
return i.Value(ctx), nil
case Operator:
var left Value
if m.Left != nil {
var err error
left, err = m.Left.Value(ctx)
if err != nil {
return nil, err
}
}
right, err := m.Right.Value(ctx)
if err != nil {
return nil, err
}
return m.processOperator(i, left, right)
case nil:
return nil, nil
default:
return nil, errors.New("unknown item type")
}
}
func (m *mathNode) processOperator(op Operator, left, right Value) (Value, error) {
if op == OperatorConcatenate {
return NewStringValue(left.String() + right.String()), nil
}
if op&OperatorTypeMask == OperatorTypeCompare {
switch op {
case OperatorNotEqual:
return NewBoolValue(!left.Equal(right)), nil
case OperatorEqual:
return NewBoolValue(left.Equal(right)), nil
case OperatorGreater:
if left.IsBool() || right.IsBool() {
return nil, ErrWrongType
}
return NewBoolValue(left.Greater(right)), nil
case OperatorGreaterOrEqual:
if left.IsBool() || right.IsBool() {
return nil, ErrWrongType
}
return NewBoolValue(left.Greater(right) || left.Equal(right)), nil
case OperatorLess:
if left.IsBool() || right.IsBool() {
return nil, ErrWrongType
}
return NewBoolValue(left.Less(right)), nil
case OperatorLessOrEqual:
if left.IsBool() || right.IsBool() {
return nil, ErrWrongType
}
return NewBoolValue(left.Less(right) || left.Equal(right)), nil
}
}
if op&OperatorTypeMask == OperatorTypeUnary {
switch op {
case OperatorNot:
if !right.IsBool() {
return nil, ErrWrongType
}
return NewBoolValue(!right.Bool()), nil
}
return nil, ErrWrongOperator
}
// Type Addition or Multiply
if !((left == nil || left.IsNumber()) && right.IsNumber()) {
return nil, ErrWrongType
}
switch op {
case OperatorPlus:
if left == nil {
return NewNumberValue(right.Number()), nil
}
return NewNumberValue(left.Number() + right.Number()), nil
case OperatorMinus:
if left == nil {
return NewNumberValue(-right.Number()), nil
}
return NewNumberValue(left.Number() - right.Number()), nil
case OperatorMultiply:
if left == nil {
return nil, errors.New("left expression is nil")
}
return NewNumberValue(left.Number() * right.Number()), nil
case OperatorDivide:
if right.Number() == 0 {
return nil, errors.New("division by zero")
}
if left == nil {
return nil, errors.New("left expression is nil")
}
return NewNumberValue(left.Number() / right.Number()), nil
default:
return nil, errors.New("wrong Operator")
}
}
func (m *mathNode) Add(item interface{}) *mathNode {
switch i := item.(type) {
case Valuer:
if m.Item == nil {
m.Item = item
break
}
if _, ok := m.Item.(Valuer); ok {
m.Item = item
break
}
if m.Right != nil {
m.Right = m.Right.Add(item)
} else {
m.Right = new(mathNode)
m.Right.Item = item
}
case Operator:
if m.Item == nil {
m.Item = item
break
}
if o, ok := m.Item.(Operator); ok {
if i.LessOrEqualThan(o) && o != OperatorNot {
node := new(mathNode)
node.Item = i
node.Left = m
return node
} else {
if m.Right == nil {
m.Right = new(mathNode)
}
m.Right = m.Right.Add(item)
}
} else {
m.Left = new(mathNode)
m.Left.Item = m.Item
m.Item = item
}
}
return m
} | internal/parser/math_node.go | 0.569374 | 0.447641 | math_node.go | starcoder |
package sortutil
import (
"errors"
"sort"
"strings"
"time"
)
// For now, use only for slices < 100 in length for performance.
// To do: more scalable implementation that uses sorting/searching.
func InArrayStringCaseInsensitive(haystack []string, needle string) (string, error) {
needleLower := strings.ToLower(strings.TrimSpace(needle))
for _, canonical := range haystack {
canonicalLower := strings.ToLower(canonical)
if canonicalLower == needleLower {
return canonical, nil
}
}
return "", errors.New("String not found")
}
// Int64Slice attaches the methods of Interface to []int64, sorting in increasing order.
type Int32Slice []int32
func (p Int32Slice) Len() int { return len(p) }
func (p Int32Slice) Less(i, j int) bool { return p[i] < p[j] }
func (p Int32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// Sort is a convenience method.
func (p Int32Slice) Sort() { sort.Sort(p) }
// Int64Slice attaches the methods of Interface to []int64, sorting in increasing order.
type Int64Slice []int64
func (p Int64Slice) Len() int { return len(p) }
func (p Int64Slice) Less(i, j int) bool { return p[i] < p[j] }
func (p Int64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// Sort is a convenience method.
func (p Int64Slice) Sort() { sort.Sort(p) }
// Uint16Slice attaches the methods of Interface to []uint16, sorting in increasing order.
type Uint16Slice []uint16
func (p Uint16Slice) Len() int { return len(p) }
func (p Uint16Slice) Less(i, j int) bool { return p[i] < p[j] }
func (p Uint16Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// Sort is a convenience method.
func (p Uint16Slice) Sort() { sort.Sort(p) }
type TimeSlice []time.Time
func (p TimeSlice) Len() int { return len(p) }
func (p TimeSlice) Less(i, j int) bool { return p[i].Before(p[j]) }
func (p TimeSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p TimeSlice) Sort() { sort.Sort(p) }
// Convenience wrappers for common cases
// Int64s sorts a slice of int64s in increasing order.
func Int32s(a []int32) { sort.Sort(Int32Slice(a)) }
// Int64s sorts a slice of int64s in increasing order.
func Int64s(a []int64) { sort.Sort(Int64Slice(a)) }
// Uint16s sorts a slice of uint16s in increasing order.
func Uint16s(a []uint16) { sort.Sort(Uint16Slice(a)) } | sort/sortutil/sortutil.go | 0.693161 | 0.460653 | sortutil.go | starcoder |
package tago
import (
"fmt"
"math"
)
/*
StandardDeviation returns the standard deviation of the last n values.
# Formula
Where:
* _σ_ - value of standard deviation for N given probes.
* _N_ - number of probes in observation.
* _x<sub>i</sub>_ - i-th observed value from N elements observation.
# Parameters
* _n_ - number of periods (integer greater than 0)
# Example
```
sd, _ := NewStandardDeviation(4)
sd.Next(10.)
sd.Next(20.)
sd.Next(30.)
sd.Next(20.)
sd.Next(10.)
```
*/
type StandardDeviation struct {
// number of periods (must be an integer greater than 0)
n int
// internal parameters for calculations
index int
count int
m float64
m2 float64
// slice of data needed for calculation
data []float64
}
// NewStandardDeviation creates a new StandardDeviation with the given number of periods
// Example: NewStandardDeviation(9)
func NewStandardDeviation(n int) (*StandardDeviation, error) {
if n <= 0 {
return nil, ErrInvalidParameters
}
return &StandardDeviation{
n: n,
index: 0,
count: 0,
m: 0,
m2: 0,
data: make([]float64, n),
}, nil
}
// Next takes the next input and returns the next StandardDeviation value
func (sd *StandardDeviation) Next(input float64) float64 {
// add input to data
sd.index = (sd.index + 1) % sd.n
oldValue := sd.data[sd.index]
sd.data[sd.index] = input
if sd.count < sd.n {
// not enough data for n periods yet
sd.count++
delta := input - sd.m
sd.m += delta / float64(sd.count)
delta2 := input - sd.m
sd.m2 += delta * delta2
} else {
oldM := sd.m
delta := input - oldValue
sd.m += delta / float64(sd.n)
delta2 := input - sd.m + oldValue - oldM
sd.m2 += delta * delta2
}
return math.Sqrt(sd.m2 / float64(sd.count))
}
// Reset resets the indicators to a clean state
func (sd *StandardDeviation) Reset() {
sd.index = 0
sd.count = 0
sd.m = 0
sd.m2 = 0
sd.data = make([]float64, sd.n)
}
func (sd *StandardDeviation) String() string {
return fmt.Sprintf("SD(%d)", sd.n)
} | standard_deviation.go | 0.553505 | 0.757234 | standard_deviation.go | starcoder |
package io
import (
"bytes"
"compress/gzip"
"context"
"errors"
"fmt"
"io"
"mime"
"mime/multipart"
"net/http"
"net/textproto"
"strconv"
"strings"
"sync"
"time"
"github.com/gorilla/mux"
"github.com/gorilla/websocket"
"github.com/benthosdev/benthos/v4/internal/bloblang/field"
"github.com/benthosdev/benthos/v4/internal/bundle"
"github.com/benthosdev/benthos/v4/internal/component"
"github.com/benthosdev/benthos/v4/internal/component/input"
"github.com/benthosdev/benthos/v4/internal/component/input/processors"
"github.com/benthosdev/benthos/v4/internal/component/metrics"
"github.com/benthosdev/benthos/v4/internal/component/ratelimit"
"github.com/benthosdev/benthos/v4/internal/docs"
httpdocs "github.com/benthosdev/benthos/v4/internal/http/docs"
"github.com/benthosdev/benthos/v4/internal/log"
"github.com/benthosdev/benthos/v4/internal/message"
imetadata "github.com/benthosdev/benthos/v4/internal/metadata"
"github.com/benthosdev/benthos/v4/internal/old/util/throttle"
"github.com/benthosdev/benthos/v4/internal/shutdown"
"github.com/benthosdev/benthos/v4/internal/tracing"
"github.com/benthosdev/benthos/v4/internal/transaction"
)
func init() {
corsSpec := httpdocs.ServerCORSFieldSpec()
corsSpec.Description += " Only valid with a custom `address`."
err := bundle.AllInputs.Add(processors.WrapConstructor(newHTTPServerInput), docs.ComponentSpec{
Name: "http_server",
Summary: `Receive messages POSTed over HTTP(S). HTTP 2.0 is supported when using TLS, which is enabled when key and cert files are specified.`,
Description: `
If the ` + "`address`" + ` config field is left blank the [service-wide HTTP server](/docs/components/http/about) will be used.
The field ` + "`rate_limit`" + ` allows you to specify an optional ` + "[`rate_limit` resource](/docs/components/rate_limits/about)" + `, which will be applied to each HTTP request made and each websocket payload received.
When the rate limit is breached HTTP requests will have a 429 response returned with a Retry-After header. Websocket payloads will be dropped and an optional response payload will be sent as per ` + "`ws_rate_limit_message`" + `.
### Responses
It's possible to return a response for each message received using [synchronous responses](/docs/guides/sync_responses). When doing so you can customise headers with the ` + "`sync_response` field `headers`" + `, which can also use [function interpolation](/docs/configuration/interpolation#bloblang-queries) in the value based on the response message contents.
### Endpoints
The following fields specify endpoints that are registered for sending messages, and support path parameters of the form ` + "`/{foo}`" + `, which are added to ingested messages as metadata:
#### ` + "`path` (defaults to `/post`)" + `
This endpoint expects POST requests where the entire request body is consumed as a single message.
If the request contains a multipart ` + "`content-type`" + ` header as per [rfc1341](https://www.w3.org/Protocols/rfc1341/7_2_Multipart.html) then the multiple parts are consumed as a batch of messages, where each body part is a message of the batch.
#### ` + "`ws_path` (defaults to `/post/ws`)" + `
Creates a websocket connection, where payloads received on the socket are passed through the pipeline as a batch of one message.
You may specify an optional ` + "`ws_welcome_message`" + `, which is a static payload to be sent to all clients once a websocket connection is first established.
It's also possible to specify a ` + "`ws_rate_limit_message`" + `, which is a static payload to be sent to clients that have triggered the servers rate limit.
### Metadata
This input adds the following metadata fields to each message:
` + "``` text" + `
- http_server_user_agent
- http_server_request_path
- http_server_verb
- All headers (only first values are taken)
- All query parameters
- All path parameters
- All cookies
` + "```" + `
You can access these metadata fields using [function interpolation](/docs/configuration/interpolation#metadata).`,
Config: docs.FieldComponent().WithChildren(
docs.FieldString("address", "An alternative address to host from. If left empty the service wide address is used."),
docs.FieldString("path", "The endpoint path to listen for POST requests."),
docs.FieldString("ws_path", "The endpoint path to create websocket connections from."),
docs.FieldString("ws_welcome_message", "An optional message to deliver to fresh websocket connections.").Advanced(),
docs.FieldString("ws_rate_limit_message", "An optional message to delivery to websocket connections that are rate limited.").Advanced(),
docs.FieldString("allowed_verbs", "An array of verbs that are allowed for the `path` endpoint.").AtVersion("3.33.0").Array(),
docs.FieldString("timeout", "Timeout for requests. If a consumed messages takes longer than this to be delivered the connection is closed, but the message may still be delivered."),
docs.FieldString("rate_limit", "An optional [rate limit](/docs/components/rate_limits/about) to throttle requests by."),
docs.FieldString("cert_file", "Enable TLS by specifying a certificate and key file. Only valid with a custom `address`.").Advanced(),
docs.FieldString("key_file", "Enable TLS by specifying a certificate and key file. Only valid with a custom `address`.").Advanced(),
corsSpec,
docs.FieldObject("sync_response", "Customise messages returned via [synchronous responses](/docs/guides/sync_responses).").WithChildren(
docs.FieldString(
"status",
"Specify the status code to return with synchronous responses. This is a string value, which allows you to customize it based on resulting payloads and their metadata.",
"200", `${! json("status") }`, `${! meta("status") }`,
).IsInterpolated(),
docs.FieldString("headers", "Specify headers to return with synchronous responses.").
IsInterpolated().Map().
HasDefault(map[string]string{
"Content-Type": "application/octet-stream",
}),
docs.FieldObject("metadata_headers", "Specify criteria for which metadata values are added to the response as headers.").WithChildren(imetadata.IncludeFilterDocs()...),
).Advanced(),
).ChildDefaultAndTypesFromStruct(input.NewHTTPServerConfig()),
Categories: []string{
"Network",
},
})
if err != nil {
panic(err)
}
}
//------------------------------------------------------------------------------
type httpServerInput struct {
conf input.HTTPServerConfig
log log.Modular
mgr bundle.NewManagement
mux *http.ServeMux
server *http.Server
timeout time.Duration
responseStatus *field.Expression
responseHeaders map[string]*field.Expression
metaFilter *imetadata.IncludeFilter
handlerWG sync.WaitGroup
transactions chan message.Transaction
shutSig *shutdown.Signaller
allowedVerbs map[string]struct{}
mPostRcvd metrics.StatCounter
mWSRcvd metrics.StatCounter
mLatency metrics.StatTimer
}
func newHTTPServerInput(conf input.Config, mgr bundle.NewManagement) (input.Streamed, error) {
var mux *http.ServeMux
var server *http.Server
var err error
if len(conf.HTTPServer.Address) > 0 {
mux = http.NewServeMux()
server = &http.Server{Addr: conf.HTTPServer.Address}
if server.Handler, err = conf.HTTPServer.CORS.WrapHandler(mux); err != nil {
return nil, fmt.Errorf("bad CORS configuration: %w", err)
}
}
var timeout time.Duration
if len(conf.HTTPServer.Timeout) > 0 {
if timeout, err = time.ParseDuration(conf.HTTPServer.Timeout); err != nil {
return nil, fmt.Errorf("failed to parse timeout string: %v", err)
}
}
verbs := map[string]struct{}{}
for _, v := range conf.HTTPServer.AllowedVerbs {
verbs[v] = struct{}{}
}
if len(verbs) == 0 {
return nil, errors.New("must provide at least one allowed verb")
}
mRcvd := mgr.Metrics().GetCounterVec("input_received", "endpoint")
h := httpServerInput{
shutSig: shutdown.NewSignaller(),
conf: conf.HTTPServer,
log: mgr.Logger(),
mgr: mgr,
mux: mux,
server: server,
timeout: timeout,
responseHeaders: map[string]*field.Expression{},
transactions: make(chan message.Transaction),
allowedVerbs: verbs,
mLatency: mgr.Metrics().GetTimer("input_latency_ns"),
mWSRcvd: mRcvd.With("websocket"),
mPostRcvd: mRcvd.With("post"),
}
if h.responseStatus, err = mgr.BloblEnvironment().NewField(h.conf.Response.Status); err != nil {
return nil, fmt.Errorf("failed to parse response status expression: %v", err)
}
for k, v := range h.conf.Response.Headers {
if h.responseHeaders[strings.ToLower(k)], err = mgr.BloblEnvironment().NewField(v); err != nil {
return nil, fmt.Errorf("failed to parse response header '%v' expression: %v", k, err)
}
}
if h.metaFilter, err = h.conf.Response.ExtractMetadata.CreateFilter(); err != nil {
return nil, fmt.Errorf("failed to construct metadata filter: %w", err)
}
postHdlr := gzipHandler(h.postHandler)
wsHdlr := gzipHandler(h.wsHandler)
if mux != nil {
if len(h.conf.Path) > 0 {
mux.HandleFunc(h.conf.Path, postHdlr)
}
if len(h.conf.WSPath) > 0 {
mux.HandleFunc(h.conf.WSPath, wsHdlr)
}
} else {
if len(h.conf.Path) > 0 {
mgr.RegisterEndpoint(
h.conf.Path, "Post a message into Benthos.", postHdlr,
)
}
if len(h.conf.WSPath) > 0 {
mgr.RegisterEndpoint(
h.conf.WSPath, "Post messages via websocket into Benthos.", wsHdlr,
)
}
}
if h.conf.RateLimit != "" {
if !h.mgr.ProbeRateLimit(h.conf.RateLimit) {
return nil, fmt.Errorf("rate limit resource '%v' was not found", h.conf.RateLimit)
}
}
go h.loop()
return &h, nil
}
//------------------------------------------------------------------------------
func (h *httpServerInput) extractMessageFromRequest(r *http.Request) (*message.Batch, error) {
msg := message.QuickBatch(nil)
contentType := r.Header.Get("Content-Type")
if contentType == "" {
contentType = "application/octet-stream"
}
mediaType, params, err := mime.ParseMediaType(contentType)
if err != nil {
return nil, err
}
if strings.HasPrefix(mediaType, "multipart/") {
mr := multipart.NewReader(r.Body, params["boundary"])
for {
var p *multipart.Part
if p, err = mr.NextPart(); err != nil {
if err == io.EOF {
break
}
return nil, err
}
var msgBytes []byte
if msgBytes, err = io.ReadAll(p); err != nil {
return nil, err
}
msg.Append(message.NewPart(msgBytes))
}
} else {
var msgBytes []byte
if msgBytes, err = io.ReadAll(r.Body); err != nil {
return nil, err
}
msg.Append(message.NewPart(msgBytes))
}
meta := map[string]string{}
meta["http_server_user_agent"] = r.UserAgent()
meta["http_server_request_path"] = r.URL.Path
meta["http_server_verb"] = r.Method
for k, v := range r.Header {
if len(v) > 0 {
meta[k] = v[0]
}
}
for k, v := range r.URL.Query() {
if len(v) > 0 {
meta[k] = v[0]
}
}
for k, v := range mux.Vars(r) {
meta[k] = v
}
for _, c := range r.Cookies() {
meta[c.Name] = c.Value
}
message.SetAllMetadata(msg, meta)
textMapGeneric := map[string]interface{}{}
for k, vals := range r.Header {
for _, v := range vals {
textMapGeneric[k] = v
}
}
_ = tracing.InitSpansFromParentTextMap("input_http_server_post", textMapGeneric, msg)
return msg, nil
}
func (h *httpServerInput) postHandler(w http.ResponseWriter, r *http.Request) {
h.handlerWG.Add(1)
defer h.handlerWG.Done()
defer r.Body.Close()
if _, exists := h.allowedVerbs[r.Method]; !exists {
http.Error(w, "Incorrect method", http.StatusMethodNotAllowed)
return
}
if h.conf.RateLimit != "" {
var tUntil time.Duration
var err error
if rerr := h.mgr.AccessRateLimit(r.Context(), h.conf.RateLimit, func(rl ratelimit.V1) {
tUntil, err = rl.Access(r.Context())
}); rerr != nil {
http.Error(w, "Server error", http.StatusBadGateway)
h.log.Warnf("Failed to access rate limit: %v\n", rerr)
return
}
if err != nil {
http.Error(w, "Server error", http.StatusBadGateway)
h.log.Warnf("Failed to access rate limit: %v\n", err)
return
} else if tUntil > 0 {
w.Header().Add("Retry-After", strconv.Itoa(int(tUntil.Seconds())))
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
}
msg, err := h.extractMessageFromRequest(r)
if err != nil {
http.Error(w, "Bad request", http.StatusBadRequest)
h.log.Warnf("Request read failed: %v\n", err)
return
}
defer tracing.FinishSpans(msg)
startedAt := time.Now()
store := transaction.NewResultStore()
transaction.AddResultStore(msg, store)
h.mPostRcvd.Incr(int64(msg.Len()))
h.log.Tracef("Consumed %v messages from POST to '%v'.\n", msg.Len(), h.conf.Path)
resChan := make(chan error, 1)
select {
case h.transactions <- message.NewTransaction(msg, resChan):
case <-time.After(h.timeout):
http.Error(w, "Request timed out", http.StatusRequestTimeout)
return
case <-r.Context().Done():
http.Error(w, "Request timed out", http.StatusRequestTimeout)
return
case <-h.shutSig.CloseAtLeisureChan():
http.Error(w, "Server closing", http.StatusServiceUnavailable)
return
}
select {
case res, open := <-resChan:
if !open {
http.Error(w, "Server closing", http.StatusServiceUnavailable)
return
} else if res != nil {
http.Error(w, res.Error(), http.StatusBadGateway)
return
}
tTaken := time.Since(startedAt).Nanoseconds()
h.mLatency.Timing(tTaken)
case <-time.After(h.timeout):
http.Error(w, "Request timed out", http.StatusRequestTimeout)
return
case <-r.Context().Done():
http.Error(w, "Request timed out", http.StatusRequestTimeout)
return
case <-h.shutSig.CloseNowChan():
http.Error(w, "Server closing", http.StatusServiceUnavailable)
return
}
responseMsg := message.QuickBatch(nil)
for _, resMsg := range store.Get() {
_ = resMsg.Iter(func(i int, part *message.Part) error {
responseMsg.Append(part)
return nil
})
}
if responseMsg.Len() > 0 {
for k, v := range h.responseHeaders {
w.Header().Set(k, v.String(0, responseMsg))
}
statusCode := 200
if statusCodeStr := h.responseStatus.String(0, responseMsg); statusCodeStr != "200" {
if statusCode, err = strconv.Atoi(statusCodeStr); err != nil {
h.log.Errorf("Failed to parse sync response status code expression: %v\n", err)
w.WriteHeader(http.StatusBadGateway)
return
}
}
if plen := responseMsg.Len(); plen == 1 {
part := responseMsg.Get(0)
_ = part.MetaIter(func(k, v string) error {
if h.metaFilter.Match(k) {
w.Header().Set(k, v)
return nil
}
return nil
})
payload := part.Get()
if w.Header().Get("Content-Type") == "" {
w.Header().Set("Content-Type", http.DetectContentType(payload))
}
w.WriteHeader(statusCode)
_, _ = w.Write(payload)
} else if plen > 1 {
customContentType, customContentTypeExists := h.responseHeaders["content-type"]
var buf bytes.Buffer
writer := multipart.NewWriter(&buf)
var merr error
for i := 0; i < plen && merr == nil; i++ {
part := responseMsg.Get(i)
_ = part.MetaIter(func(k, v string) error {
if h.metaFilter.Match(k) {
w.Header().Set(k, v)
return nil
}
return nil
})
payload := part.Get()
mimeHeader := textproto.MIMEHeader{}
if customContentTypeExists {
mimeHeader.Set("Content-Type", customContentType.String(i, responseMsg))
} else {
mimeHeader.Set("Content-Type", http.DetectContentType(payload))
}
var partWriter io.Writer
if partWriter, merr = writer.CreatePart(mimeHeader); merr == nil {
_, merr = io.Copy(partWriter, bytes.NewReader(payload))
}
}
merr = writer.Close()
if merr == nil {
w.Header().Del("Content-Type")
w.Header().Add("Content-Type", writer.FormDataContentType())
w.WriteHeader(statusCode)
_, _ = buf.WriteTo(w)
} else {
h.log.Errorf("Failed to return sync response: %v\n", merr)
w.WriteHeader(http.StatusBadGateway)
}
}
}
}
func (h *httpServerInput) wsHandler(w http.ResponseWriter, r *http.Request) {
h.handlerWG.Add(1)
defer h.handlerWG.Done()
var err error
defer func() {
if err != nil {
http.Error(w, "Bad request", http.StatusBadRequest)
h.log.Warnf("Websocket request failed: %v\n", err)
}
}()
upgrader := websocket.Upgrader{}
var ws *websocket.Conn
if ws, err = upgrader.Upgrade(w, r, nil); err != nil {
return
}
defer ws.Close()
resChan := make(chan error, 1)
throt := throttle.New(throttle.OptCloseChan(h.shutSig.CloseAtLeisureChan()))
if welMsg := h.conf.WSWelcomeMessage; len(welMsg) > 0 {
if err = ws.WriteMessage(websocket.BinaryMessage, []byte(welMsg)); err != nil {
h.log.Errorf("Failed to send welcome message: %v\n", err)
}
}
var msgBytes []byte
for !h.shutSig.ShouldCloseAtLeisure() {
if msgBytes == nil {
if _, msgBytes, err = ws.ReadMessage(); err != nil {
return
}
h.mWSRcvd.Incr(1)
}
if h.conf.RateLimit != "" {
var tUntil time.Duration
if rerr := h.mgr.AccessRateLimit(r.Context(), h.conf.RateLimit, func(rl ratelimit.V1) {
tUntil, err = rl.Access(r.Context())
}); rerr != nil {
h.log.Warnf("Failed to access rate limit: %v\n", rerr)
err = rerr
}
if err != nil || tUntil > 0 {
if err != nil {
h.log.Warnf("Failed to access rate limit: %v\n", err)
}
if rlMsg := h.conf.WSRateLimitMessage; len(rlMsg) > 0 {
if err = ws.WriteMessage(websocket.BinaryMessage, []byte(rlMsg)); err != nil {
h.log.Errorf("Failed to send rate limit message: %v\n", err)
}
}
continue
}
}
msg := message.QuickBatch([][]byte{msgBytes})
startedAt := time.Now()
part := msg.Get(0)
part.MetaSet("http_server_user_agent", r.UserAgent())
for k, v := range r.Header {
if len(v) > 0 {
part.MetaSet(k, v[0])
}
}
for k, v := range r.URL.Query() {
if len(v) > 0 {
part.MetaSet(k, v[0])
}
}
for k, v := range mux.Vars(r) {
part.MetaSet(k, v)
}
for _, c := range r.Cookies() {
part.MetaSet(c.Name, c.Value)
}
tracing.InitSpans("input_http_server_websocket", msg)
store := transaction.NewResultStore()
transaction.AddResultStore(msg, store)
select {
case h.transactions <- message.NewTransaction(msg, resChan):
case <-h.shutSig.CloseAtLeisureChan():
return
}
select {
case res, open := <-resChan:
if !open {
return
}
if res != nil {
throt.Retry()
} else {
tTaken := time.Since(startedAt).Nanoseconds()
h.mLatency.Timing(tTaken)
msgBytes = nil
throt.Reset()
}
case <-h.shutSig.CloseNowChan():
return
}
for _, responseMsg := range store.Get() {
if err := responseMsg.Iter(func(i int, part *message.Part) error {
return ws.WriteMessage(websocket.TextMessage, part.Get())
}); err != nil {
h.log.Errorf("Failed to send sync response over websocket: %v\n", err)
}
}
tracing.FinishSpans(msg)
}
}
//------------------------------------------------------------------------------
func (h *httpServerInput) loop() {
defer func() {
if h.server != nil {
if err := h.server.Shutdown(context.Background()); err != nil {
h.log.Errorf("Failed to gracefully terminate http_server: %v\n", err)
}
} else {
if len(h.conf.Path) > 0 {
h.mgr.RegisterEndpoint(h.conf.Path, "Does nothing.", http.NotFound)
}
if len(h.conf.WSPath) > 0 {
h.mgr.RegisterEndpoint(h.conf.WSPath, "Does nothing.", http.NotFound)
}
}
h.handlerWG.Wait()
close(h.transactions)
h.shutSig.ShutdownComplete()
}()
if h.server != nil {
go func() {
if len(h.conf.KeyFile) > 0 || len(h.conf.CertFile) > 0 {
h.log.Infof(
"Receiving HTTPS messages at: https://%s\n",
h.conf.Address+h.conf.Path,
)
if err := h.server.ListenAndServeTLS(
h.conf.CertFile, h.conf.KeyFile,
); err != http.ErrServerClosed {
h.log.Errorf("Server error: %v\n", err)
}
} else {
h.log.Infof(
"Receiving HTTP messages at: http://%s\n",
h.conf.Address+h.conf.Path,
)
if err := h.server.ListenAndServe(); err != http.ErrServerClosed {
h.log.Errorf("Server error: %v\n", err)
}
}
}()
}
<-h.shutSig.CloseAtLeisureChan()
}
// TransactionChan returns a transactions channel for consuming messages from
// this input.
func (h *httpServerInput) TransactionChan() <-chan message.Transaction {
return h.transactions
}
// Connected returns a boolean indicating whether this input is currently
// connected to its target.
func (h *httpServerInput) Connected() bool {
return true
}
// CloseAsync shuts down the HTTPServer input and stops processing requests.
func (h *httpServerInput) CloseAsync() {
h.shutSig.CloseAtLeisure()
}
// WaitForClose blocks until the HTTPServer input has closed down.
func (h *httpServerInput) WaitForClose(timeout time.Duration) error {
go func() {
<-time.After(timeout - time.Second)
h.shutSig.CloseNow()
}()
select {
case <-h.shutSig.HasClosedChan():
case <-time.After(timeout):
return component.ErrTimeout
}
return nil
}
//------------------------------------------------------------------------------
type gzipResponseWriter struct {
io.Writer
http.ResponseWriter
}
func (w gzipResponseWriter) Write(b []byte) (int, error) {
if w.Header().Get("Content-Type") == "" {
// If no content type, apply sniffing algorithm to un-gzipped body.
w.Header().Set("Content-Type", http.DetectContentType(b))
}
return w.Writer.Write(b)
}
func gzipHandler(fn http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
fn(w, r)
return
}
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
gzr := gzipResponseWriter{Writer: gz, ResponseWriter: w}
fn(gzr, r)
}
} | internal/impl/io/input_http_server.go | 0.755366 | 0.453201 | input_http_server.go | starcoder |
package rawv1
import (
"encoding/binary"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
)
// DataRAWv1 is a concrete implementation of AdvertisementData interface
// Data format is described here: https://docs.ruuvi.com/communication/bluetooth-advertisements/data-format-3-rawv1
type DataRAWv1 struct {
rawBytes []byte
}
// NewDataRAWv1 returns pointer to DataRAWv1 wrapping
func NewDataRAWv1(d []byte) (*DataRAWv1, error) {
if determineDataVersion(d) != 3 {
return nil, errors.New("Data is not RAWv1 (3)")
}
if len(d) < 14 {
return nil, errors.New("Data is too short to be valid, expected 14 bytes")
}
return &DataRAWv1{rawBytes: d}, nil
}
func determineDataVersion(d []byte) int8 {
return int8(d[0])
}
func dataNotAvailable(whatData string) error {
return fmt.Errorf("%s is not available with data format RAWv1 (3)", whatData)
}
// Copy copies the raw bytes internally so the AdvertisementData object is safe to use for a longer time.
// Without Copy(), incoming BLE packets can overwrite the bytes
func (d *DataRAWv1) Copy() {
c := make([]byte, len(d.rawBytes))
copy(c[:], d.rawBytes[:])
d.rawBytes = c
}
// DataFormat returns format of underlying data
func (d *DataRAWv1) DataFormat() int8 { return 3 }
// Temperature returns measured temperature in degrees Celsius
func (d *DataRAWv1) Temperature() (float64, error) {
t1 := d.rawBytes[2] & 0b01111111
negative := d.rawBytes[2]&0b10000000 > 0
t2 := d.rawBytes[3]
if t2 > 99 {
return 0, errors.New("Temperature fractional part exceeds maximum value")
}
var mult float64
if negative {
mult = -1.0
} else {
mult = 1.0
}
temp := (float64(t1) + (float64(t2) / 100.0)) * mult
return temp, nil
}
// Humidity returns measured humidity as percentage
func (d *DataRAWv1) Humidity() (float64, error) {
b := d.rawBytes[1]
humidity := float64(b) * 0.5
return humidity, nil
}
// Pressure returns measured atmospheric pressure with unit Pa (pascal)
func (d *DataRAWv1) Pressure() (int, error) {
pb := d.rawBytes[4:6]
pres := binary.BigEndian.Uint16(pb)
return int(pres) + 50000, nil
}
// AccelerationX returns the acceleration in X axis with unit G, if supported by data format
func (d *DataRAWv1) AccelerationX() (float64, error) {
b := d.rawBytes[6:8]
acc := int16(binary.BigEndian.Uint16(b))
gs := float64(acc) / 1000.0
return gs, nil
}
// AccelerationY returns the acceleration in Y axis with unit G, if supported by data format
func (d *DataRAWv1) AccelerationY() (float64, error) {
b := d.rawBytes[8:10]
acc := int16(binary.BigEndian.Uint16(b))
gs := float64(acc) / 1000.0
return gs, nil
}
// AccelerationZ returns the acceleration in Z axis with unit G, if supported by data format
func (d *DataRAWv1) AccelerationZ() (float64, error) {
b := d.rawBytes[10:12]
acc := int16(binary.BigEndian.Uint16(b))
gs := float64(acc) / 1000.0
return gs, nil
}
// BatteryVoltage returns battery voltage with unit V (volt), if supported by data format
func (d *DataRAWv1) BatteryVoltage() (float64, error) {
b := d.rawBytes[12:14]
millivolts := binary.BigEndian.Uint16(b)
return float64(millivolts) / 1000, nil
}
// TransmissionPower returns transmission power with unit dBm, if supported by data format
func (d *DataRAWv1) TransmissionPower() (float64, error) {
return 0, dataNotAvailable("TX power")
}
// MovementCounter returns number of movements detected by accelerometer, if supported by data format
func (d *DataRAWv1) MovementCounter() (int, error) {
return 0, dataNotAvailable("Movement counter")
}
// MeasurementSequenceNumber returns measurement sequence number, if supported by data format
func (d *DataRAWv1) MeasurementSequenceNumber() (int, error) {
return 0, dataNotAvailable("Measurement sequence number")
}
// MACAddress returns MAC address (48 bits / 6 bytes) of broadcasting ruuvitag, if supported by data format
func (d *DataRAWv1) MACAddress() ([]byte, error) {
return nil, dataNotAvailable("MAC address")
}
// RawData returns the raw bytes. Make sure to copy the data, or it may be overwritten by the next broadcast.
func (d *DataRAWv1) RawData() []byte {
return d.rawBytes
}
// MarshalJSON outputs available data as JSON
func (d *DataRAWv1) MarshalJSON() ([]byte, error) {
m := make(map[string]interface{}, 8)
m["raw"] = hex.EncodeToString(d.rawBytes)
m["format"] = d.DataFormat()
if t, err := d.Temperature(); err == nil {
m["temperature"] = t
}
if h, err := d.Humidity(); err == nil {
m["humidity"] = h
}
if p, err := d.Pressure(); err == nil {
m["pressure"] = p
}
if a, err := d.AccelerationX(); err == nil {
m["accel-x"] = a
}
if a, err := d.AccelerationY(); err == nil {
m["accel-y"] = a
}
if a, err := d.AccelerationZ(); err == nil {
m["accel-z"] = a
}
if v, err := d.BatteryVoltage(); err == nil {
m["voltage"] = v
}
return json.Marshal(&m)
} | internal/pkg/rawv1/dataformat.go | 0.812123 | 0.475484 | dataformat.go | starcoder |
package geom
import "image"
// Projector types can be used to project 3D coordinates into 2D. It only
// supports projecting Z into a 2D offset (i.e. not a general projection).
type Projector interface {
// Sign returns a {-1, 0, 1}-valued 2D vector pointing in the direction that
// positive Z values are projected to.
Sign() image.Point
// Project converts a Z coordinate to a 2D offset.
Project(int) image.Point
}
// Project is shorthand for π.Project(p.Z).Add(p.XY()).
func Project(π Projector, p Int3) image.Point {
return π.Project(p.Z).Add(p.XY())
}
// ElevationProjection throws away Z.
type ElevationProjection struct{}
// Sign returns the zero point.
func (ElevationProjection) Sign() image.Point { return image.Point{} }
// Project returns the zero point.
func (ElevationProjection) Project(int) image.Point { return image.Point{} }
// SimpleProjection projects Z onto Y only.
type SimpleProjection struct{}
// Sign returns (0, 1).
func (SimpleProjection) Sign() image.Point { return image.Pt(0, 1) }
// Project returns (0, z).
func (SimpleProjection) Project(z int) image.Point { return image.Pt(0, z) }
// Projection uses two floats to define a custom projection.
type Projection struct{ X, Y float64 }
// Sign returns the componentwise sign of π.
func (π Projection) Sign() image.Point {
return image.Pt(int(FSign(π.X)), int(FSign(π.Y)))
}
// Project returns (z*π.X, z*π.Y).
func (π Projection) Project(z int) image.Point {
return image.Pt(
int(π.X*float64(z)),
int(π.Y*float64(z)),
)
}
// IntProjection uses two integers to define a custom projection.
// It is designed for projecting Z onto X and Y with integer fractions as would
// be used in e.g. a diametric projection (IntProjection{X:0, Y:2}).
type IntProjection image.Point
// Sign returns CSign(π).
func (π IntProjection) Sign() image.Point { return CSign(image.Point(π)) }
// Project returns (z/π.X, z/π.Y), unless π.X or π.Y are 0, in which case that
// component is zero
func (π IntProjection) Project(z int) image.Point {
/*
Dividing is used because there's little reason for an isometric
projection in a game to exaggerate the Z position.
Integers are used to preserve "pixel perfect" calculation in case you
are making the next Celeste.
*/
var q image.Point
if π.X != 0 {
q.X = z / π.X
}
if π.Y != 0 {
q.Y = z / π.Y
}
return q
} | geom/projection.go | 0.873633 | 0.73756 | projection.go | starcoder |
package metrics
import "time"
// Meters count events to produce exponentially-weighted moving average rates
// at one-, five-, and fifteen-minutes and a mean rate.
type Meter interface {
Count() int64
Mark(int64)
Rate1() float64
Rate5() float64
Rate15() float64
RateMean() float64
Snapshot() Meter
}
// GetOrRegisterMeter returns an existing Meter or constructs and registers a
// new StandardMeter.
func GetOrRegisterMeter(name string, r Registry) Meter {
if nil == r {
r = DefaultRegistry
}
return r.GetOrRegister(name, NewMeter()).(Meter)
}
// NewMeter constructs a new StandardMeter and launches a goroutine.
func NewMeter() Meter {
if UseNilMetrics {
return NilMeter{}
}
m := &StandardMeter{
make(chan int64),
make(chan *MeterSnapshot),
time.NewTicker(5e9),
}
go m.arbiter()
return m
}
// NewMeter constructs and registers a new StandardMeter and launches a
// goroutine.
func NewRegisteredMeter(name string, r Registry) Meter {
c := NewMeter()
if nil == r {
r = DefaultRegistry
}
r.Register(name, c)
return c
}
// MeterSnapshot is a read-only copy of another Meter.
type MeterSnapshot struct {
count int64
rate1, rate5, rate15, rateMean float64
}
// Count returns the count of events at the time the snapshot was taken.
func (m *MeterSnapshot) Count() int64 { return m.count }
// Mark panics.
func (*MeterSnapshot) Mark(n int64) {
panic("Mark called on a MeterSnapshot")
}
// Rate1 returns the one-minute moving average rate of events per second at the
// time the snapshot was taken.
func (m *MeterSnapshot) Rate1() float64 { return m.rate1 }
// Rate5 returns the five-minute moving average rate of events per second at
// the time the snapshot was taken.
func (m *MeterSnapshot) Rate5() float64 { return m.rate5 }
// Rate15 returns the fifteen-minute moving average rate of events per second
// at the time the snapshot was taken.
func (m *MeterSnapshot) Rate15() float64 { return m.rate15 }
// RateMean returns the meter's mean rate of events per second at the time the
// snapshot was taken.
func (m *MeterSnapshot) RateMean() float64 { return m.rateMean }
// Snapshot returns the snapshot.
func (m *MeterSnapshot) Snapshot() Meter { return m }
// NilMeter is a no-op Meter.
type NilMeter struct{}
// Count is a no-op.
func (NilMeter) Count() int64 { return 0 }
// Mark is a no-op.
func (NilMeter) Mark(n int64) {}
// Rate1 is a no-op.
func (NilMeter) Rate1() float64 { return 0.0 }
// Rate5 is a no-op.
func (NilMeter) Rate5() float64 { return 0.0 }
// Rate15is a no-op.
func (NilMeter) Rate15() float64 { return 0.0 }
// RateMean is a no-op.
func (NilMeter) RateMean() float64 { return 0.0 }
// Snapshot is a no-op.
func (NilMeter) Snapshot() Meter { return NilMeter{} }
// StandardMeter is the standard implementation of a Meter and uses a
// goroutine to synchronize its calculations and a time.Ticker to pass time.
type StandardMeter struct {
in chan int64
out chan *MeterSnapshot
ticker *time.Ticker
}
// Count returns the number of events recorded.
func (m *StandardMeter) Count() int64 {
return (<-m.out).count
}
// Mark records the occurance of n events.
func (m *StandardMeter) Mark(n int64) {
m.in <- n
}
// Rate1 returns the one-minute moving average rate of events per second.
func (m *StandardMeter) Rate1() float64 {
return (<-m.out).rate1
}
// Rate5 returns the five-minute moving average rate of events per second.
func (m *StandardMeter) Rate5() float64 {
return (<-m.out).rate5
}
// Rate15 returns the fifteen-minute moving average rate of events per second.
func (m *StandardMeter) Rate15() float64 {
return (<-m.out).rate15
}
// RateMean returns the meter's mean rate of events per second.
func (m *StandardMeter) RateMean() float64 {
return (<-m.out).rateMean
}
// Snapshot returns a read-only copy of the meter.
func (m *StandardMeter) Snapshot() Meter {
snapshot := *<-m.out
return &snapshot
}
// arbiter receives inputs and sends outputs. It counts each input and updates
// the various moving averages and the mean rate of events. It sends a copy of
// the meterV as output.
func (m *StandardMeter) arbiter() {
snapshot := &MeterSnapshot{}
a1 := NewEWMA1()
a5 := NewEWMA5()
a15 := NewEWMA15()
t := time.Now()
for {
select {
case n := <-m.in:
snapshot.count += n
a1.Update(n)
a5.Update(n)
a15.Update(n)
snapshot.rate1 = a1.Rate()
snapshot.rate5 = a5.Rate()
snapshot.rate15 = a15.Rate()
snapshot.rateMean = float64(1e9*snapshot.count) / float64(time.Since(t))
case m.out <- snapshot:
case <-m.ticker.C:
a1.Tick()
a5.Tick()
a15.Tick()
snapshot.rate1 = a1.Rate()
snapshot.rate5 = a5.Rate()
snapshot.rate15 = a15.Rate()
snapshot.rateMean = float64(1e9*snapshot.count) / float64(time.Since(t))
}
}
} | Godeps/_workspace/src/github.com/coreos/etcd/third_party/github.com/rcrowley/go-metrics/meter.go | 0.894914 | 0.566318 | meter.go | starcoder |
package main
/*
Procces Description:
===================
A bank employs three tellers and the customers form a queue for all three tellers.
The doors of the bank close after eight hours.
The simulation is ended when the last customer has been served.
Task
====
Execute multiple simulation runs, calculate Average, Standard Deviation,
confidence intervall lower and upper bounds,minimum and Maximum for the
following performance measures:
total elapsed time,
queue length,
queueing time
service time.
Model Features:
===============
1. FIFO Queue
The customer object is placed in the FIFO arrival queue as soon as the customer is created.
2. Parallel Resources
The application constructs Tellers object to model tellers as a set of resources.
The object 'provides' tellers to the customer located in the Queue head and "releases" the teller when customer is serviced.
Maximum 3 tellers can be provided simultaneously.
The interlocking between catching request is performed using godes BooleanControl object.
3. Collection and processing of statistics
While finishing a customer run the application creates data arrays for each measure. At the end of simulation, the application creates StatCollection object and performs descriptive statistical analysis. The following statistical parameters are calculated for each measure array:
#Observ - number of observations
Average - average (mean) value
Std Dev- standard deviation
L-Bound-lower bound of the confidence interval with 95% probability
U-Bound-upper bound of the confidence interval with 95% probability
Minimum- minimum value
Maximum- maximum value
*/
import (
"fmt"
"github.com/bh1cqx/godes"
)
//Input Parameters
const (
ARRIVAL_INTERVAL = 0.5
SERVICE_TIME = 1.3
SHUTDOWN_TIME = 8 * 60.
INDEPENDENT_RUNS = 100
)
// the arrival and service are two random number generators for the exponential distribution
var arrival *godes.ExpDistr = godes.NewExpDistr(true)
var service *godes.ExpDistr = godes.NewExpDistr(true)
// true when any counter is available
var counterSwt *godes.BooleanControl = godes.NewBooleanControl()
// FIFO Queue for the arrived customers
var customerArrivalQueue *godes.FIFOQueue = godes.NewFIFOQueue("0")
var tellers *Tellers
var statistics [][]float64
var replicationStats [][]float64
var titles = []string{
"Elapsed Time",
"Queue Length",
"Queueing Time",
"Service Time",
}
var availableTellers int = 0
// the Tellers is a Passive Object represebting resource
type Tellers struct {
max int
}
func (tellers *Tellers) Catch(customer *Customer) {
for {
counterSwt.Wait(true)
if customerArrivalQueue.GetHead().(*Customer).GetId() == customer.GetId() {
break
} else {
godes.Yield()
}
}
availableTellers++
if availableTellers == tellers.max {
counterSwt.Set(false)
}
}
func (tellers *Tellers) Release() {
availableTellers--
counterSwt.Set(true)
}
// the Customer is a Runner
type Customer struct {
*godes.Runner
id int
}
func (customer *Customer) Run() {
a0 := godes.GetSystemTime()
tellers.Catch(customer)
a1 := godes.GetSystemTime()
customerArrivalQueue.Get()
qlength := float64(customerArrivalQueue.Len())
godes.Advance(service.Get(1. / SERVICE_TIME))
a2 := godes.GetSystemTime()
tellers.Release()
collectionArray := []float64{a2 - a0, qlength, a1 - a0, a2 - a1}
replicationStats = append(replicationStats, collectionArray)
}
func (customer *Customer) GetId() int {
return customer.id
}
func main() {
statistics = [][]float64{}
tellers = &Tellers{3}
for i := 0; i < INDEPENDENT_RUNS; i++ {
replicationStats = [][]float64{}
godes.Run()
counterSwt.Set(true)
customerArrivalQueue.Clear()
count := 0
for {
customer := &Customer{&godes.Runner{}, count}
customerArrivalQueue.Place(customer)
godes.AddRunner(customer)
godes.Advance(arrival.Get(1. / ARRIVAL_INTERVAL))
if godes.GetSystemTime() > SHUTDOWN_TIME {
break
}
count++
}
godes.WaitUntilDone() // waits for all the runners to finish the Run()
godes.Clear()
replicationCollector := godes.NewStatCollector(titles, replicationStats)
collectionArray := []float64{
replicationCollector.GetAverage(0),
replicationCollector.GetAverage(1),
replicationCollector.GetAverage(2),
replicationCollector.GetAverage(3),
}
statistics = append(statistics, collectionArray)
}
collector := godes.NewStatCollector(titles, statistics)
collector.PrintStat()
fmt.Printf("Finished \n")
}
/* OUTPUT
Variable # Average Std Dev L-Bound U-Bound Minimum Maximum
Elapsed Time 100 3.672 1.217 3.433 3.910 1.980 8.722
Queue Length 100 4.684 2.484 4.197 5.171 1.539 14.615
Queueing Time 100 2.368 1.194 2.134 2.602 0.810 7.350
Service Time 100 1.304 0.044 1.295 1.312 1.170 1.432
Finished
*/ | examples/example7/example7.go | 0.67854 | 0.602588 | example7.go | starcoder |
package models
import (
i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e "time"
i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91 "github.com/microsoft/kiota-abstractions-go/serialization"
)
// PlannerTask
type PlannerTask struct {
PlannerDelta
// Number of checklist items with value set to false, representing incomplete items.
activeChecklistItemCount *int32
// The categories to which the task has been applied. See applied Categories for possible values.
appliedCategories PlannerAppliedCategoriesable
// Read-only. Nullable. Used to render the task correctly in the task board view when grouped by assignedTo.
assignedToTaskBoardFormat PlannerAssignedToTaskBoardTaskFormatable
// Hint used to order items of this type in a list view. The format is defined as outlined here.
assigneePriority *string
// The set of assignees the task is assigned to.
assignments PlannerAssignmentsable
// Bucket ID to which the task belongs. The bucket needs to be in the plan that the task is in. It is 28 characters long and case-sensitive. Format validation is done on the service.
bucketId *string
// Read-only. Nullable. Used to render the task correctly in the task board view when grouped by bucket.
bucketTaskBoardFormat PlannerBucketTaskBoardTaskFormatable
// Number of checklist items that are present on the task.
checklistItemCount *int32
// Identity of the user that completed the task.
completedBy IdentitySetable
// Read-only. Date and time at which the 'percentComplete' of the task is set to '100'. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
completedDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Thread ID of the conversation on the task. This is the ID of the conversation thread object created in the group.
conversationThreadId *string
// Identity of the user that created the task.
createdBy IdentitySetable
// Read-only. Date and time at which the task is created. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
createdDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Contains information about the origin of the task.
creationSource PlannerTaskCreationable
// Read-only. Nullable. Additional details about the task.
details PlannerTaskDetailsable
// Date and time at which the task is due. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
dueDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Read-only. Value is true if the details object of the task has a non-empty description and false otherwise.
hasDescription *bool
// Hint used to order items of this type in a list view. The format is defined as outlined here.
orderHint *string
// Percentage of task completion. When set to 100, the task is considered completed.
percentComplete *int32
// Plan ID to which the task belongs.
planId *string
// This sets the type of preview that shows up on the task. Possible values are: automatic, noPreview, checklist, description, reference.
previewType *PlannerPreviewType
// Priority of the task. Valid range of values is between 0 and 10 (inclusive), with increasing value being lower priority (0 has the highest priority and 10 has the lowest priority). Currently, Planner interprets values 0 and 1 as 'urgent', 2 and 3 and 4 as 'important', 5, 6, and 7 as 'medium', and 8, 9, and 10 as 'low'. Currently, Planner sets the value 1 for 'urgent', 3 for 'important', 5 for 'medium', and 9 for 'low'.
priority *int32
// Read-only. Nullable. Used to render the task correctly in the task board view when grouped by progress.
progressTaskBoardFormat PlannerProgressTaskBoardTaskFormatable
// Number of external references that exist on the task.
referenceCount *int32
// Date and time at which the task starts. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
startDateTime *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time
// Title of the task.
title *string
}
// NewPlannerTask instantiates a new plannerTask and sets the default values.
func NewPlannerTask()(*PlannerTask) {
m := &PlannerTask{
PlannerDelta: *NewPlannerDelta(),
}
return m
}
// CreatePlannerTaskFromDiscriminatorValue creates a new instance of the appropriate class based on discriminator value
func CreatePlannerTaskFromDiscriminatorValue(parseNode i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.Parsable, error) {
return NewPlannerTask(), nil
}
// GetActiveChecklistItemCount gets the activeChecklistItemCount property value. Number of checklist items with value set to false, representing incomplete items.
func (m *PlannerTask) GetActiveChecklistItemCount()(*int32) {
if m == nil {
return nil
} else {
return m.activeChecklistItemCount
}
}
// GetAppliedCategories gets the appliedCategories property value. The categories to which the task has been applied. See applied Categories for possible values.
func (m *PlannerTask) GetAppliedCategories()(PlannerAppliedCategoriesable) {
if m == nil {
return nil
} else {
return m.appliedCategories
}
}
// GetAssignedToTaskBoardFormat gets the assignedToTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by assignedTo.
func (m *PlannerTask) GetAssignedToTaskBoardFormat()(PlannerAssignedToTaskBoardTaskFormatable) {
if m == nil {
return nil
} else {
return m.assignedToTaskBoardFormat
}
}
// GetAssigneePriority gets the assigneePriority property value. Hint used to order items of this type in a list view. The format is defined as outlined here.
func (m *PlannerTask) GetAssigneePriority()(*string) {
if m == nil {
return nil
} else {
return m.assigneePriority
}
}
// GetAssignments gets the assignments property value. The set of assignees the task is assigned to.
func (m *PlannerTask) GetAssignments()(PlannerAssignmentsable) {
if m == nil {
return nil
} else {
return m.assignments
}
}
// GetBucketId gets the bucketId property value. Bucket ID to which the task belongs. The bucket needs to be in the plan that the task is in. It is 28 characters long and case-sensitive. Format validation is done on the service.
func (m *PlannerTask) GetBucketId()(*string) {
if m == nil {
return nil
} else {
return m.bucketId
}
}
// GetBucketTaskBoardFormat gets the bucketTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by bucket.
func (m *PlannerTask) GetBucketTaskBoardFormat()(PlannerBucketTaskBoardTaskFormatable) {
if m == nil {
return nil
} else {
return m.bucketTaskBoardFormat
}
}
// GetChecklistItemCount gets the checklistItemCount property value. Number of checklist items that are present on the task.
func (m *PlannerTask) GetChecklistItemCount()(*int32) {
if m == nil {
return nil
} else {
return m.checklistItemCount
}
}
// GetCompletedBy gets the completedBy property value. Identity of the user that completed the task.
func (m *PlannerTask) GetCompletedBy()(IdentitySetable) {
if m == nil {
return nil
} else {
return m.completedBy
}
}
// GetCompletedDateTime gets the completedDateTime property value. Read-only. Date and time at which the 'percentComplete' of the task is set to '100'. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) GetCompletedDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.completedDateTime
}
}
// GetConversationThreadId gets the conversationThreadId property value. Thread ID of the conversation on the task. This is the ID of the conversation thread object created in the group.
func (m *PlannerTask) GetConversationThreadId()(*string) {
if m == nil {
return nil
} else {
return m.conversationThreadId
}
}
// GetCreatedBy gets the createdBy property value. Identity of the user that created the task.
func (m *PlannerTask) GetCreatedBy()(IdentitySetable) {
if m == nil {
return nil
} else {
return m.createdBy
}
}
// GetCreatedDateTime gets the createdDateTime property value. Read-only. Date and time at which the task is created. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) GetCreatedDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.createdDateTime
}
}
// GetCreationSource gets the creationSource property value. Contains information about the origin of the task.
func (m *PlannerTask) GetCreationSource()(PlannerTaskCreationable) {
if m == nil {
return nil
} else {
return m.creationSource
}
}
// GetDetails gets the details property value. Read-only. Nullable. Additional details about the task.
func (m *PlannerTask) GetDetails()(PlannerTaskDetailsable) {
if m == nil {
return nil
} else {
return m.details
}
}
// GetDueDateTime gets the dueDateTime property value. Date and time at which the task is due. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) GetDueDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.dueDateTime
}
}
// GetFieldDeserializers the deserialization information for the current model
func (m *PlannerTask) GetFieldDeserializers()(map[string]func(i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode)(error)) {
res := m.PlannerDelta.GetFieldDeserializers()
res["activeChecklistItemCount"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetInt32Value()
if err != nil {
return err
}
if val != nil {
m.SetActiveChecklistItemCount(val)
}
return nil
}
res["appliedCategories"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerAppliedCategoriesFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetAppliedCategories(val.(PlannerAppliedCategoriesable))
}
return nil
}
res["assignedToTaskBoardFormat"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerAssignedToTaskBoardTaskFormatFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetAssignedToTaskBoardFormat(val.(PlannerAssignedToTaskBoardTaskFormatable))
}
return nil
}
res["assigneePriority"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetAssigneePriority(val)
}
return nil
}
res["assignments"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerAssignmentsFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetAssignments(val.(PlannerAssignmentsable))
}
return nil
}
res["bucketId"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetBucketId(val)
}
return nil
}
res["bucketTaskBoardFormat"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerBucketTaskBoardTaskFormatFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetBucketTaskBoardFormat(val.(PlannerBucketTaskBoardTaskFormatable))
}
return nil
}
res["checklistItemCount"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetInt32Value()
if err != nil {
return err
}
if val != nil {
m.SetChecklistItemCount(val)
}
return nil
}
res["completedBy"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateIdentitySetFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetCompletedBy(val.(IdentitySetable))
}
return nil
}
res["completedDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetCompletedDateTime(val)
}
return nil
}
res["conversationThreadId"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetConversationThreadId(val)
}
return nil
}
res["createdBy"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreateIdentitySetFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetCreatedBy(val.(IdentitySetable))
}
return nil
}
res["createdDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetCreatedDateTime(val)
}
return nil
}
res["creationSource"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerTaskCreationFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetCreationSource(val.(PlannerTaskCreationable))
}
return nil
}
res["details"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerTaskDetailsFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetDetails(val.(PlannerTaskDetailsable))
}
return nil
}
res["dueDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetDueDateTime(val)
}
return nil
}
res["hasDescription"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetBoolValue()
if err != nil {
return err
}
if val != nil {
m.SetHasDescription(val)
}
return nil
}
res["orderHint"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetOrderHint(val)
}
return nil
}
res["percentComplete"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetInt32Value()
if err != nil {
return err
}
if val != nil {
m.SetPercentComplete(val)
}
return nil
}
res["planId"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetPlanId(val)
}
return nil
}
res["previewType"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetEnumValue(ParsePlannerPreviewType)
if err != nil {
return err
}
if val != nil {
m.SetPreviewType(val.(*PlannerPreviewType))
}
return nil
}
res["priority"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetInt32Value()
if err != nil {
return err
}
if val != nil {
m.SetPriority(val)
}
return nil
}
res["progressTaskBoardFormat"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetObjectValue(CreatePlannerProgressTaskBoardTaskFormatFromDiscriminatorValue)
if err != nil {
return err
}
if val != nil {
m.SetProgressTaskBoardFormat(val.(PlannerProgressTaskBoardTaskFormatable))
}
return nil
}
res["referenceCount"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetInt32Value()
if err != nil {
return err
}
if val != nil {
m.SetReferenceCount(val)
}
return nil
}
res["startDateTime"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetTimeValue()
if err != nil {
return err
}
if val != nil {
m.SetStartDateTime(val)
}
return nil
}
res["title"] = func (n i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.ParseNode) error {
val, err := n.GetStringValue()
if err != nil {
return err
}
if val != nil {
m.SetTitle(val)
}
return nil
}
return res
}
// GetHasDescription gets the hasDescription property value. Read-only. Value is true if the details object of the task has a non-empty description and false otherwise.
func (m *PlannerTask) GetHasDescription()(*bool) {
if m == nil {
return nil
} else {
return m.hasDescription
}
}
// GetOrderHint gets the orderHint property value. Hint used to order items of this type in a list view. The format is defined as outlined here.
func (m *PlannerTask) GetOrderHint()(*string) {
if m == nil {
return nil
} else {
return m.orderHint
}
}
// GetPercentComplete gets the percentComplete property value. Percentage of task completion. When set to 100, the task is considered completed.
func (m *PlannerTask) GetPercentComplete()(*int32) {
if m == nil {
return nil
} else {
return m.percentComplete
}
}
// GetPlanId gets the planId property value. Plan ID to which the task belongs.
func (m *PlannerTask) GetPlanId()(*string) {
if m == nil {
return nil
} else {
return m.planId
}
}
// GetPreviewType gets the previewType property value. This sets the type of preview that shows up on the task. Possible values are: automatic, noPreview, checklist, description, reference.
func (m *PlannerTask) GetPreviewType()(*PlannerPreviewType) {
if m == nil {
return nil
} else {
return m.previewType
}
}
// GetPriority gets the priority property value. Priority of the task. Valid range of values is between 0 and 10 (inclusive), with increasing value being lower priority (0 has the highest priority and 10 has the lowest priority). Currently, Planner interprets values 0 and 1 as 'urgent', 2 and 3 and 4 as 'important', 5, 6, and 7 as 'medium', and 8, 9, and 10 as 'low'. Currently, Planner sets the value 1 for 'urgent', 3 for 'important', 5 for 'medium', and 9 for 'low'.
func (m *PlannerTask) GetPriority()(*int32) {
if m == nil {
return nil
} else {
return m.priority
}
}
// GetProgressTaskBoardFormat gets the progressTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by progress.
func (m *PlannerTask) GetProgressTaskBoardFormat()(PlannerProgressTaskBoardTaskFormatable) {
if m == nil {
return nil
} else {
return m.progressTaskBoardFormat
}
}
// GetReferenceCount gets the referenceCount property value. Number of external references that exist on the task.
func (m *PlannerTask) GetReferenceCount()(*int32) {
if m == nil {
return nil
} else {
return m.referenceCount
}
}
// GetStartDateTime gets the startDateTime property value. Date and time at which the task starts. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) GetStartDateTime()(*i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time) {
if m == nil {
return nil
} else {
return m.startDateTime
}
}
// GetTitle gets the title property value. Title of the task.
func (m *PlannerTask) GetTitle()(*string) {
if m == nil {
return nil
} else {
return m.title
}
}
// Serialize serializes information the current object
func (m *PlannerTask) Serialize(writer i878a80d2330e89d26896388a3f487eef27b0a0e6c010c493bf80be1452208f91.SerializationWriter)(error) {
err := m.PlannerDelta.Serialize(writer)
if err != nil {
return err
}
{
err = writer.WriteInt32Value("activeChecklistItemCount", m.GetActiveChecklistItemCount())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("appliedCategories", m.GetAppliedCategories())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("assignedToTaskBoardFormat", m.GetAssignedToTaskBoardFormat())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("assigneePriority", m.GetAssigneePriority())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("assignments", m.GetAssignments())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("bucketId", m.GetBucketId())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("bucketTaskBoardFormat", m.GetBucketTaskBoardFormat())
if err != nil {
return err
}
}
{
err = writer.WriteInt32Value("checklistItemCount", m.GetChecklistItemCount())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("completedBy", m.GetCompletedBy())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("completedDateTime", m.GetCompletedDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("conversationThreadId", m.GetConversationThreadId())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("createdBy", m.GetCreatedBy())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("createdDateTime", m.GetCreatedDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("creationSource", m.GetCreationSource())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("details", m.GetDetails())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("dueDateTime", m.GetDueDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteBoolValue("hasDescription", m.GetHasDescription())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("orderHint", m.GetOrderHint())
if err != nil {
return err
}
}
{
err = writer.WriteInt32Value("percentComplete", m.GetPercentComplete())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("planId", m.GetPlanId())
if err != nil {
return err
}
}
if m.GetPreviewType() != nil {
cast := (*m.GetPreviewType()).String()
err = writer.WriteStringValue("previewType", &cast)
if err != nil {
return err
}
}
{
err = writer.WriteInt32Value("priority", m.GetPriority())
if err != nil {
return err
}
}
{
err = writer.WriteObjectValue("progressTaskBoardFormat", m.GetProgressTaskBoardFormat())
if err != nil {
return err
}
}
{
err = writer.WriteInt32Value("referenceCount", m.GetReferenceCount())
if err != nil {
return err
}
}
{
err = writer.WriteTimeValue("startDateTime", m.GetStartDateTime())
if err != nil {
return err
}
}
{
err = writer.WriteStringValue("title", m.GetTitle())
if err != nil {
return err
}
}
return nil
}
// SetActiveChecklistItemCount sets the activeChecklistItemCount property value. Number of checklist items with value set to false, representing incomplete items.
func (m *PlannerTask) SetActiveChecklistItemCount(value *int32)() {
if m != nil {
m.activeChecklistItemCount = value
}
}
// SetAppliedCategories sets the appliedCategories property value. The categories to which the task has been applied. See applied Categories for possible values.
func (m *PlannerTask) SetAppliedCategories(value PlannerAppliedCategoriesable)() {
if m != nil {
m.appliedCategories = value
}
}
// SetAssignedToTaskBoardFormat sets the assignedToTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by assignedTo.
func (m *PlannerTask) SetAssignedToTaskBoardFormat(value PlannerAssignedToTaskBoardTaskFormatable)() {
if m != nil {
m.assignedToTaskBoardFormat = value
}
}
// SetAssigneePriority sets the assigneePriority property value. Hint used to order items of this type in a list view. The format is defined as outlined here.
func (m *PlannerTask) SetAssigneePriority(value *string)() {
if m != nil {
m.assigneePriority = value
}
}
// SetAssignments sets the assignments property value. The set of assignees the task is assigned to.
func (m *PlannerTask) SetAssignments(value PlannerAssignmentsable)() {
if m != nil {
m.assignments = value
}
}
// SetBucketId sets the bucketId property value. Bucket ID to which the task belongs. The bucket needs to be in the plan that the task is in. It is 28 characters long and case-sensitive. Format validation is done on the service.
func (m *PlannerTask) SetBucketId(value *string)() {
if m != nil {
m.bucketId = value
}
}
// SetBucketTaskBoardFormat sets the bucketTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by bucket.
func (m *PlannerTask) SetBucketTaskBoardFormat(value PlannerBucketTaskBoardTaskFormatable)() {
if m != nil {
m.bucketTaskBoardFormat = value
}
}
// SetChecklistItemCount sets the checklistItemCount property value. Number of checklist items that are present on the task.
func (m *PlannerTask) SetChecklistItemCount(value *int32)() {
if m != nil {
m.checklistItemCount = value
}
}
// SetCompletedBy sets the completedBy property value. Identity of the user that completed the task.
func (m *PlannerTask) SetCompletedBy(value IdentitySetable)() {
if m != nil {
m.completedBy = value
}
}
// SetCompletedDateTime sets the completedDateTime property value. Read-only. Date and time at which the 'percentComplete' of the task is set to '100'. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) SetCompletedDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.completedDateTime = value
}
}
// SetConversationThreadId sets the conversationThreadId property value. Thread ID of the conversation on the task. This is the ID of the conversation thread object created in the group.
func (m *PlannerTask) SetConversationThreadId(value *string)() {
if m != nil {
m.conversationThreadId = value
}
}
// SetCreatedBy sets the createdBy property value. Identity of the user that created the task.
func (m *PlannerTask) SetCreatedBy(value IdentitySetable)() {
if m != nil {
m.createdBy = value
}
}
// SetCreatedDateTime sets the createdDateTime property value. Read-only. Date and time at which the task is created. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) SetCreatedDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.createdDateTime = value
}
}
// SetCreationSource sets the creationSource property value. Contains information about the origin of the task.
func (m *PlannerTask) SetCreationSource(value PlannerTaskCreationable)() {
if m != nil {
m.creationSource = value
}
}
// SetDetails sets the details property value. Read-only. Nullable. Additional details about the task.
func (m *PlannerTask) SetDetails(value PlannerTaskDetailsable)() {
if m != nil {
m.details = value
}
}
// SetDueDateTime sets the dueDateTime property value. Date and time at which the task is due. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) SetDueDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.dueDateTime = value
}
}
// SetHasDescription sets the hasDescription property value. Read-only. Value is true if the details object of the task has a non-empty description and false otherwise.
func (m *PlannerTask) SetHasDescription(value *bool)() {
if m != nil {
m.hasDescription = value
}
}
// SetOrderHint sets the orderHint property value. Hint used to order items of this type in a list view. The format is defined as outlined here.
func (m *PlannerTask) SetOrderHint(value *string)() {
if m != nil {
m.orderHint = value
}
}
// SetPercentComplete sets the percentComplete property value. Percentage of task completion. When set to 100, the task is considered completed.
func (m *PlannerTask) SetPercentComplete(value *int32)() {
if m != nil {
m.percentComplete = value
}
}
// SetPlanId sets the planId property value. Plan ID to which the task belongs.
func (m *PlannerTask) SetPlanId(value *string)() {
if m != nil {
m.planId = value
}
}
// SetPreviewType sets the previewType property value. This sets the type of preview that shows up on the task. Possible values are: automatic, noPreview, checklist, description, reference.
func (m *PlannerTask) SetPreviewType(value *PlannerPreviewType)() {
if m != nil {
m.previewType = value
}
}
// SetPriority sets the priority property value. Priority of the task. Valid range of values is between 0 and 10 (inclusive), with increasing value being lower priority (0 has the highest priority and 10 has the lowest priority). Currently, Planner interprets values 0 and 1 as 'urgent', 2 and 3 and 4 as 'important', 5, 6, and 7 as 'medium', and 8, 9, and 10 as 'low'. Currently, Planner sets the value 1 for 'urgent', 3 for 'important', 5 for 'medium', and 9 for 'low'.
func (m *PlannerTask) SetPriority(value *int32)() {
if m != nil {
m.priority = value
}
}
// SetProgressTaskBoardFormat sets the progressTaskBoardFormat property value. Read-only. Nullable. Used to render the task correctly in the task board view when grouped by progress.
func (m *PlannerTask) SetProgressTaskBoardFormat(value PlannerProgressTaskBoardTaskFormatable)() {
if m != nil {
m.progressTaskBoardFormat = value
}
}
// SetReferenceCount sets the referenceCount property value. Number of external references that exist on the task.
func (m *PlannerTask) SetReferenceCount(value *int32)() {
if m != nil {
m.referenceCount = value
}
}
// SetStartDateTime sets the startDateTime property value. Date and time at which the task starts. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
func (m *PlannerTask) SetStartDateTime(value *i336074805fc853987abe6f7fe3ad97a6a6f3077a16391fec744f671a015fbd7e.Time)() {
if m != nil {
m.startDateTime = value
}
}
// SetTitle sets the title property value. Title of the task.
func (m *PlannerTask) SetTitle(value *string)() {
if m != nil {
m.title = value
}
} | models/planner_task.go | 0.659186 | 0.407009 | planner_task.go | starcoder |
package parser
import (
"github.com/8pockets/hi/ast"
"github.com/8pockets/hi/token"
)
func (p *Parser) parseExpression(precedence int) ast.Expression {
prefix := p.prefixParseFns[p.curToken.Type]
if prefix == nil {
p.noPrefixParseFnError(p.curToken.Type)
return nil
}
leftExp := prefix()
/*
Precedence example:
```
4 + 2 * 5 == 4 + (2 * 5)
```
*/
for !p.peekTokenIs(token.SEMICOLON) && precedence < p.peekPrecedence() {
infix := p.infixParseFns[p.peekToken.Type]
if infix == nil {
return leftExp
}
p.nextToken()
leftExp = infix(leftExp)
}
return leftExp
}
func (p *Parser) parsePrefixExpression() ast.Expression {
expression := &ast.PrefixExpression{
Token: p.curToken,
Operator: p.curToken.Literal,
}
p.nextToken()
expression.Right = p.parseExpression(PREFIX)
return expression
}
func (p *Parser) parseGroupedExpression() ast.Expression {
p.nextToken()
exp := p.parseExpression(LOWEST)
if !p.expectPeek(token.RPAREN) {
return nil
}
return exp
}
func (p *Parser) parseInfixExpression(left ast.Expression) ast.Expression {
expression := &ast.InfixExpression{
Token: p.curToken,
Operator: p.curToken.Literal,
Left: left,
}
precedence := p.curPrecedence()
p.nextToken()
expression.Right = p.parseExpression(precedence)
return expression
}
func (p *Parser) parseIndexExpression(left ast.Expression) ast.Expression {
exp := &ast.IndexExpression{Token: p.curToken, Left: left}
p.nextToken()
exp.Index = p.parseExpression(LOWEST)
if !p.expectPeek(token.RBRACKET) {
return nil
}
return exp
}
func (p *Parser) parseRangeExpression(left ast.Expression) ast.Expression {
expression := &ast.RangeExpression{
Token: p.curToken,
Left: left,
}
p.nextToken()
expression.Right = p.parseExpression(LOWEST)
return expression
}
func (p *Parser) parseIfExpression() ast.Expression {
expression := &ast.IfExpression{Token: p.curToken}
p.nextToken()
expression.Condition = p.parseExpression(LOWEST)
if !p.expectPeek(token.LBRACE) {
return nil
}
expression.Consequence = p.parseBlockStatement()
if p.peekTokenIs(token.ELSE) {
p.nextToken()
if !p.expectPeek(token.LBRACE) {
return nil
}
expression.Alternative = p.parseBlockStatement()
}
return expression
}
func (p *Parser) parseWhileExpression() ast.Expression {
we := &ast.WhileExpression{Token: p.curToken}
p.nextToken()
we.Condition = p.parseExpression(LOWEST)
if !p.expectPeek(token.LBRACE) {
return nil
}
we.Body = p.parseBlockStatement()
return we
}
func (p *Parser) parseForExpression() ast.Expression {
fe := &ast.ForExpression{Token: p.curToken}
if !p.expectPeek(token.IDENT) {
return nil
}
fe.Index = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
if !p.expectPeek(token.COMMA) {
return nil
}
if !p.expectPeek(token.IDENT) {
return nil
}
fe.Value = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
if !p.expectPeek(token.IN) {
return nil
}
p.nextToken()
fe.Range = p.parseExpression(LOWEST)
if !p.expectPeek(token.LBRACE) {
return nil
}
fe.Body = p.parseBlockStatement()
return fe
}
func (p *Parser) parseCallExpression(function ast.Expression) ast.Expression {
exp := &ast.CallExpression{Token: p.curToken, Function: function}
exp.Arguments = p.parseExpressionList(token.RPAREN)
return exp
}
func (p *Parser) parseExpressionList(end token.TokenType) []ast.Expression {
list := []ast.Expression{}
if p.peekTokenIs(end) {
p.nextToken()
return list
}
p.nextToken()
list = append(list, p.parseExpression(LOWEST))
for p.peekTokenIs(token.COMMA) {
p.nextToken()
p.nextToken()
list = append(list, p.parseExpression(LOWEST))
}
if !p.expectPeek(end) {
return nil
}
return list
} | parser/expr_parsing.go | 0.650245 | 0.6852 | expr_parsing.go | starcoder |
package main
const defaultInfoMapping string = `
{
"settings": {
"number_of_shards": 5,
"number_of_replicas": 1
},
"mappings": {
"_doc": {
"dynamic": "strict",
"properties": {
"ip_address": {
"type": "ip_range",
"coerce": false,
"index": true
},
"country_code": {
"type": "keyword",
"index": false
},
"region": {
"type": "keyword",
"index": false
},
"region_code": {
"type": "integer",
"index": false
},
"city": {
"type": "keyword",
"index": false
},
"city_code": {
"type": "integer",
"index": false
},
"conn_speed": {
"type": "keyword",
"index": false
},
"mobile_isp": {
"type": "keyword",
"index": false
},
"mobile_isp_code": {
"type": "integer",
"index": false
},
"proxy_type": {
"type": "keyword",
"index": false
}
}
}
}
}
`
const defaultCountryMapping string = `
{
"settings": {
"number_of_shards": 5,
"number_of_replicas": 1
},
"mappings": {
"_doc": {
"dynamic": "strict",
"properties": {
"title": {
"type": "text",
"index": true,
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
},
"iso": {
"type": "keyword",
"index": true
}
}
}
}
}
`
const defaultRegionsMapping string = `
{
"settings": {
"number_of_shards": 5,
"number_of_replicas": 1
},
"mappings": {
"_doc": {
"dynamic": "strict",
"properties": {
"country_iso": {
"type": "keyword",
"index": true
},
"title": {
"type": "text",
"index": true,
"fields": {
"keyword": {
"type": "keyword"
}
}
},
"code": {
"type": "integer",
"index": true
}
}
}
}
}
` | elasticsearch/cmd/mappings.go | 0.675551 | 0.456591 | mappings.go | starcoder |
package goutil
import (
`database/sql`
`fmt`
`reflect`
`strings`
)
// ObjectDbCols is a convenience method that returns relevant and valid
// database column names for use in constructing SQL statements. Only
// columns representing fields that will not cause a panic are included.
// Columns are further filtered by the tag provided. To be included, the
// tag must exist and must not have a '-' value.
func ObjectDbCols(t interface{}, tid string) (cols []string, err error) {
v := reflect.ValueOf(t).Elem()
if v.Type().Kind() != reflect.Struct {
err = fmt.Errorf(`kind %q is not %q`, v.Type().Kind().String(), `struct`)
return cols, err
}
Outer: for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
t := v.Type().Field(i)
if !f.IsValid() || !f.CanAddr() || !f.CanInterface() {
continue
}
if tag, ok := t.Tag.Lookup(tid); ok {
tval := strings.Split(tag, `,`)
switch {
case tval[0] == `-`:
continue Outer
case tval[0] == ``:
cols = append(cols, t.Name)
default:
cols = append(cols, tval[0])
}
}
}
return cols, err
}
// ObjectDbSQL generates basic SQL statements from struct fields.
func ObjectDbSQL (cmd, tbl string, cols []string) (sql string, err error) {
cmd = strings.ToUpper(cmd)
tbl = strings.ToLower(tbl)
switch cmd {
case `SELECT`:
sql = fmt.Sprintf(`SELECT %s FROM %s`,
strings.Join(cols, `,`), tbl,
)
case `INSERT`:
sql = fmt.Sprintf(`INSERT INTO %s (%s) VALUES (?%s)`,
tbl, strings.Join(cols, `,`),
strings.Repeat(`,?`, len(cols)-1),
)
default:
err = fmt.Errorf(`invalid SQL command %s`, cmd)
}
return sql, err
}
// ObjectDbVals is a convenience method that returns an entire database
// row for simpler insert statements. Only fields that will not cause a
// panic are included. Fields are further filtered by the tag provided.
// To be included, the tag must exist and must not have a '-' value. The
// table or view DDL must have the same columns with the same names in
// the same order or the query will fail. Can be combined with the method
// ObjectDbCols for a less brittle solution.
func ObjectDbVals(t interface{}, tid string) (vals []interface{}, err error) {
v := reflect.ValueOf(t).Elem()
if v.Type().Kind() != reflect.Struct {
err = fmt.Errorf(`kind %q is not %q`, v.Type().Kind().String(), `struct`)
return vals, err
}
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
t := v.Type().Field(i)
if !f.IsValid() || !f.CanAddr() || !f.CanInterface() {
continue
}
if tag, ok := t.Tag.Lookup(tid); ok {
if strings.Split(tag, `,`)[0] == `-` {
continue
}
vals = append(vals, f.Interface())
}
}
return vals, err
}
// ObjectDbValsByCol is a convenience method that returns a database row
// based on the column names provided by the caller, which are ostensibly
// taken from the database table or view. The column names are matched to
// the tag on the struct field. An error is returned if a column is not
// found or if the associated field returns false for the IsValid(),
// CanAddr(), or CanInterface() reflect methods.
func ObjectDbValsByCol(t interface{}, tid string, cols []string) (vals []interface{}, err error) {
v := reflect.ValueOf(t).Elem()
if v.Type().Kind() != reflect.Struct {
err = fmt.Errorf(`kind %q is not %q`, v.Type().Kind().String(), `struct`)
return vals, err
}
Outer: for _, col := range cols {
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
t := v.Type().Field(i)
if !f.IsValid() || !f.CanAddr() || !f.CanInterface() {
continue
}
if tag, ok := t.Tag.Lookup(`db`); ok {
if col == strings.Split(tag, `,`)[0] {
vals = append(vals, f.Interface())
continue Outer
}
}
}
return nil, fmt.Errorf(`no match for column %q`, col)
}
return vals, err
}
// RowToMap converts a database row into a map of string values indexed
// by column name.
func RowToMap(vid, pid, sn string, rows *sql.Rows) (mss map[string]string, err error) {
var cols []string
if cols, err = rows.Columns(); err != nil {
return nil, err
}
for rows.Next() {
vals := make([]interface{}, len(cols))
pvals := make([]interface{}, len(cols))
for i, _ := range vals {
pvals[i] = &vals[i]
}
if err = rows.Scan(pvals...); err != nil {
return nil, err
}
mss = make(map[string]string)
for i, cn := range cols {
if b, ok := vals[i].([]byte); ok {
mss[cn] = string(b)
} else {
mss[cn] = fmt.Sprintf(`%v`, vals[i])
}
}
}
if rows.Err() != nil {
err = rows.Err()
}
return mss, err
} | db.go | 0.665737 | 0.435361 | db.go | starcoder |
package ll
import (
_ "fmt"
)
// Car returns the head of the list.
func Car(x List) interface{} {
if x == nil || x.Head == nil {
return nil
}
l, ok := x.Head.(List)
if ok {
return l
}
return x.Head
}
// Cdr returns the tail of the list.
func Cdr(x List) interface{} {
if x == nil || x.Tail == nil {
return nil
}
l, ok := x.Tail.(List)
if ok {
return l
}
return x.Tail
}
func CxR(s string, x List) interface{} {
var ok bool
var l List
for _, c := range s {
switch c {
case 'a':
//fmt.Printf("x=%#v\n", x)
l, ok = Car(x).(List)
//fmt.Printf("x=%#v, ok=%v\n", l, ok)
if !ok {
return Car(x)
}
case 'd':
l, ok = Cdr(x).(List)
if !ok {
return Cdr(x)
}
default:
panic("C: bad format")
}
}
return l
}
func Caar(x List) interface{} {
return (Car(Car(x).(List)))
}
func Cadr(x List) interface{} {
return (Car(Cdr(x).(List)))
}
func Cddr(x List) interface{} {
return (Cdr(Cdr(x).(List)))
}
func Cdar(x List) interface{} {
return (Cdr(Car(x).(List)))
}
func Caaar(x List) interface{} {
return (Car(Car(Car(x).(List)).(List)))
}
func Caadr(x List) interface{} {
return (Car(Car(Cdr(x).(List)).(List)))
}
func Cadar(x List) interface{} {
return (Car(Cdr(Car(x).(List)).(List)))
}
func Caddr(x List) interface{} {
return (Car(Cdr(Cdr(x).(List)).(List)))
}
func Cdaar(x List) interface{} {
return (Cdr(Car(Car(x).(List)).(List)))
}
func Cdadr(x List) interface{} {
return (Cdr(Car(Cdr(x).(List)).(List)))
}
func Cdddr(x List) interface{} {
return (Cdr(Cdr(Cdr(x).(List)).(List)))
}
func Caaaar(x List) interface{} {
return (Car(Car(Car(Car(x).(List)).(List)).(List)))
}
func Caaadr(x List) interface{} {
return (Car(Car(Car(Cdr(x).(List)).(List)).(List)))
}
func Caadar(x List) interface{} {
return (Car(Car(Cdr(Car(x).(List)).(List)).(List)))
}
func Caaddr(x List) interface{} {
return (Car(Car(Cdr(Cdr(x).(List)).(List)).(List)))
}
func Cadaar(x List) interface{} {
return (Car(Cdr(Car(Car(x).(List)).(List)).(List)))
}
func Cadadr(x List) interface{} {
return (Car(Cdr(Car(Cdr(x).(List)).(List)).(List)))
}
func Caddar(x List) interface{} {
return (Car(Cdr(Cdr(Car(x).(List)).(List)).(List)))
}
func Cadddr(x List) interface{} {
return (Car(Cdr(Cdr(Cdr(x).(List)).(List)).(List)))
}
func Cdaaar(x List) interface{} {
return (Cdr(Car(Car(Car(x).(List)).(List)).(List)))
}
func Cdaadr(x List) interface{} {
return (Cdr(Car(Car(Cdr(x).(List)).(List)).(List)))
}
func Cdadar(x List) interface{} {
return (Cdr(Car(Cdr(Car(x).(List)).(List)).(List)))
}
func Cdaddr(x List) interface{} {
return (Cdr(Car(Cdr(Cdr(x).(List)).(List)).(List)))
}
func Cddaar(x List) interface{} {
return (Cdr(Cdr(Car(Car(x).(List)).(List)).(List)))
}
func Cddadr(x List) interface{} {
return (Cdr(Cdr(Car(Cdr(x).(List)).(List)).(List)))
}
func Cddddr(x List) interface{} {
return (Cdr(Cdr(Cdr(Cdr(x).(List)).(List)).(List)))
} | carcdr.go | 0.706596 | 0.620765 | carcdr.go | starcoder |
package world
import (
"github.com/austingebauer/go-ray-tracer/color"
"github.com/austingebauer/go-ray-tracer/light"
"github.com/austingebauer/go-ray-tracer/material"
"github.com/austingebauer/go-ray-tracer/matrix"
"github.com/austingebauer/go-ray-tracer/point"
"github.com/austingebauer/go-ray-tracer/ray"
"github.com/austingebauer/go-ray-tracer/sphere"
"github.com/austingebauer/go-ray-tracer/vector"
)
// World represents a collection of all Objects that make up a scene.
type World struct {
Objects []*sphere.Sphere
Light *light.PointLight
}
// NewWorld returns a new World.
func NewWorld() *World {
return &World{
Objects: make([]*sphere.Sphere, 0),
Light: nil,
}
}
// NewDefaultWorld returns a new default world, which contains
// two spheres and a point light source.
func NewDefaultWorld() *World {
// Create a default light source
defaultLight := light.NewPointLight(
*point.NewPoint(-10, 10, -10),
*color.NewColor(1, 1, 1))
// Create a default sphere number 1
s1 := sphere.NewUnitSphere("s1")
s1.Material = material.NewMaterial(*color.NewColor(0.8, 0.1, 0.6),
material.DefaultAmbient, 0.7, 0.2, material.DefaultShininess)
// Create a default sphere number 2
s2 := sphere.NewUnitSphere("s2")
s2.Transform = matrix.NewScalingMatrix(0.5, 0.5, 0.5)
return &World{
Objects: []*sphere.Sphere{s1, s2},
Light: defaultLight,
}
}
// RayWorldIntersect intersects the passed ray with the passed world.
func RayWorldIntersect(r *ray.Ray, w *World) []*ray.Intersection {
allObjectIntersections := make([]*ray.Intersection, 0)
for _, sphereObj := range w.Objects {
intersections := ray.RaySphereIntersect(r, sphereObj)
allObjectIntersections = append(allObjectIntersections, intersections...)
}
// Sort the entire collection of intersections
ray.SortIntersectionsAsc(allObjectIntersections)
return allObjectIntersections
}
// ColorAt intersects the given ray with the given world and
// returns the color at the resulting intersection.
func ColorAt(w *World, r *ray.Ray) (*color.Color, error) {
intersections := RayWorldIntersect(r, w)
hit := ray.Hit(intersections)
if hit == nil {
return color.NewColor(0, 0, 0), nil
}
comps, err := ray.PrepareComputations(hit, r)
if err != nil {
return nil, err
}
return ShadeHit(w, comps), nil
}
// ShadeHit returns the color at the intersection encapsulated by
// an intersections computations.
func ShadeHit(w *World, comps *ray.IntersectionComputations) *color.Color {
isShadowed := IsShadowed(w, comps.OverPoint)
return light.Lighting(
comps.Object.Material,
w.Light,
comps.Point,
comps.EyeVec,
comps.NormalVec,
isShadowed)
}
// IsShadowed returns true if the passed point lies in
// the shadow of an object in the passed world.
func IsShadowed(world *World, pt *point.Point) bool {
// Create a ray from the point in question to the light source
vec := point.Subtract(world.Light.Position, *pt)
vecNormal := vector.Normalize(*vec)
shadowRay := ray.NewRay(*pt, *vecNormal)
// Compute the distance from the point in question to the light source
distanceToLight := vec.Magnitude()
// Intersect the shadow ray with the world
intersections := RayWorldIntersect(shadowRay, world)
// Check to see if there way a hit
h := ray.Hit(intersections)
// Return true if there was a hit that's t value is less than the distance to the light
return h != nil && h.T < distanceToLight
} | world/world.go | 0.89434 | 0.42656 | world.go | starcoder |
package action
import "github.com/rsteube/carapace"
func ActionLints() carapace.Action {
return carapace.Batch(
actionLintCategories(),
actionLints(),
).ToA()
}
func actionLintCategories() carapace.Action {
return carapace.ActionValuesDescribed(
"clippy::all", "all lints that are on by default",
"clippy::correctness", "code that is outright wrong or useless",
"clippy::suspicious", "code that is most likely wrong or useless",
"clippy::style", "code that should be written in a more idiomatic way",
"clippy::complexity", "code that does something simple but in a complex way",
"clippy::perf", "code that can be written to run faster",
"clippy::pedantic", "lints which are rather strict or have occasional false positives",
"clippy::nursery", "new lints that are still under development",
"clippy::cargo", "lints for the cargo manifest",
)
}
// curl https://rust-lang.github.io/rust-clippy/master/lints.json | jq --raw-output '.[] | "\"clippy::\(.id)\", \"\(.docs | split("\n")[1]))\","'
func actionLints() carapace.Action {
return carapace.ActionValuesDescribed(
"clippy::absurd_extreme_comparisons", "Checks for comparisons where one side of the relation is)",
"clippy::almost_swapped", "Checks for `foo = bar; bar = foo` sequences.)",
"clippy::approx_constant", "Checks for floating point literals that approximate)",
"clippy::as_conversions", "Checks for usage of `as` conversions.)",
"clippy::assertions_on_constants", "Checks for `assert!(true)` and `assert!(false)` calls.)",
"clippy::assign_op_pattern", "Checks for `a = a op b` or `a = b commutative_op a`)",
"clippy::assign_ops", "Nothing. This lint has been deprecated.)",
"clippy::async_yields_async", "Checks for async blocks that yield values of types)",
"clippy::await_holding_lock", "Checks for calls to await while holding a)",
"clippy::await_holding_refcell_ref", "Checks for calls to await while holding a)",
"clippy::bad_bit_mask", "Checks for incompatible bit masks in comparisons.)",
"clippy::bind_instead_of_map", "Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))` or)",
"clippy::blacklisted_name", "Checks for usage of blacklisted names for variables, such)",
"clippy::blanket_clippy_restriction_lints", "Checks for `warn`/`deny`/`forbid` attributes targeting the whole clippy::restriction category.)",
"clippy::blocks_in_if_conditions", "Checks for `if` conditions that use blocks containing an)",
"clippy::bool_assert_comparison", "This lint warns about boolean comparisons in assert-like macros.)",
"clippy::bool_comparison", "Checks for expressions of the form `x == true`,)",
"clippy::borrow_interior_mutable_const", "Checks if `const` items which is interior mutable (e.g.,)",
"clippy::borrowed_box", "Checks for use of `&Box<T>` anywhere in the code.)",
"clippy::box_collection", "Checks for use of `Box<T>` where T is a collection such as Vec anywhere in the code.)",
"clippy::boxed_local", "Checks for usage of `Box<T>` where an unboxed `T` would)",
"clippy::branches_sharing_code", "Checks if the `if` and `else` block contain shared code that can be)",
"clippy::builtin_type_shadow", "Warns if a generic shadows a built-in type.)",
"clippy::bytes_nth", "Checks for the use of `.bytes().nth()`.)",
"clippy::cargo_common_metadata", "Checks to see if all common metadata is defined in)",
"clippy::case_sensitive_file_extension_comparisons", "Checks for calls to `ends_with` with possible file extensions)",
"clippy::cast_lossless", "Checks for casts between numerical types that may)",
"clippy::cast_possible_truncation", "Checks for casts between numerical types that may)",
"clippy::cast_possible_wrap", "Checks for casts from an unsigned type to a signed type of)",
"clippy::cast_precision_loss", "Checks for casts from any numerical to a float type where)",
"clippy::cast_ptr_alignment", "Checks for casts, using `as` or `pointer::cast`,)",
"clippy::cast_ref_to_mut", "Checks for casts of `&T` to `&mut T` anywhere in the code.)",
"clippy::cast_sign_loss", "Checks for casts from a signed to an unsigned numerical)",
"clippy::char_lit_as_u8", "Checks for expressions where a character literal is cast)",
"clippy::chars_last_cmp", "Checks for usage of `_.chars().last()` or)",
"clippy::chars_next_cmp", "Checks for usage of `.chars().next()` on a `str` to check)",
"clippy::checked_conversions", "Checks for explicit bounds checking when casting.)",
"clippy::clone_double_ref", "Checks for usage of `.clone()` on an `&&T`.)",
"clippy::clone_on_copy", "Checks for usage of `.clone()` on a `Copy` type.)",
"clippy::clone_on_ref_ptr", "Checks for usage of `.clone()` on a ref-counted pointer,)",
"clippy::cloned_instead_of_copied", "Checks for usages of `cloned()` on an `Iterator` or `Option` where)",
"clippy::cmp_nan", "Checks for comparisons to NaN.)",
"clippy::cmp_null", "This lint checks for equality comparisons with `ptr::null`)",
"clippy::cmp_owned", "Checks for conversions to owned values just for the sake)",
"clippy::cognitive_complexity", "Checks for methods with high cognitive complexity.)",
"clippy::collapsible_else_if", "Checks for collapsible `else { if ... }` expressions)",
"clippy::collapsible_if", "Checks for nested `if` statements which can be collapsed)",
"clippy::collapsible_match", "Finds nested `match` or `if let` expressions where the patterns may be \"collapsed\" together)",
"clippy::comparison_chain", "Checks comparison chains written with `if` that can be)",
"clippy::comparison_to_empty", "Checks for comparing to an empty slice such as `\"\"` or `[]`,)",
"clippy::copy_iterator", "Checks for types that implement `Copy` as well as)",
"clippy::create_dir", "Checks usage of `std::fs::create_dir` and suggest using `std::fs::create_dir_all` instead.)",
"clippy::crosspointer_transmute", "Checks for transmutes between a type `T` and `*T`.)",
"clippy::dbg_macro", "Checks for usage of dbg!() macro.)",
"clippy::debug_assert_with_mut_call", "Checks for function/method calls with a mutable)",
"clippy::decimal_literal_representation", "Warns if there is a better representation for a numeric literal.)",
"clippy::declare_interior_mutable_const", "Checks for declaration of `const` items which is interior)",
"clippy::default_numeric_fallback", "Checks for usage of unconstrained numeric literals which may cause default numeric fallback in type)",
"clippy::default_trait_access", "Checks for literal calls to `Default::default()`.)",
"clippy::deprecated_cfg_attr", "Checks for `#[cfg_attr(rustfmt, rustfmt_skip)]` and suggests to replace it)",
"clippy::deprecated_semver", "Checks for `#[deprecated]` annotations with a `since`)",
"clippy::deref_addrof", "Checks for usage of `*&` and `*&mut` in expressions.)",
"clippy::derivable_impls", "Detects manual `std::default::Default` implementations that are identical to a derived implementation.)",
"clippy::derive_hash_xor_eq", "Checks for deriving `Hash` but implementing `PartialEq`)",
"clippy::derive_ord_xor_partial_ord", "Checks for deriving `Ord` but implementing `PartialOrd`)",
"clippy::disallowed_methods", "Denies the configured methods and functions in clippy.toml)",
"clippy::disallowed_script_idents", "Checks for usage of unicode scripts other than those explicitly allowed)",
"clippy::disallowed_types", "Denies the configured types in clippy.toml.)",
"clippy::diverging_sub_expression", "Checks for diverging calls that are not match arms or)",
"clippy::doc_markdown", "Checks for the presence of `_`, `::` or camel-case words)",
"clippy::double_comparisons", "Checks for double comparisons that could be simplified to a single expression.)",
"clippy::double_must_use", "Checks for a `#[must_use]` attribute without)",
"clippy::double_neg", "Detects expressions of the form `--x`.)",
"clippy::double_parens", "Checks for unnecessary double parentheses.)",
"clippy::drop_copy", "Checks for calls to `std::mem::drop` with a value)",
"clippy::drop_ref", "Checks for calls to `std::mem::drop` with a reference)",
"clippy::duplicate_underscore_argument", "Checks for function arguments having the similar names)",
"clippy::duration_subsec", "Checks for calculation of subsecond microseconds or milliseconds)",
"clippy::else_if_without_else", "Checks for usage of if expressions with an `else if` branch,)",
"clippy::empty_enum", "Checks for `enum`s with no variants.)",
"clippy::empty_line_after_outer_attr", "Checks for empty lines after outer attributes)",
"clippy::empty_loop", "Checks for empty `loop` expressions.)",
"clippy::enum_clike_unportable_variant", "Checks for C-like enumerations that are)",
"clippy::enum_glob_use", "Checks for `use Enum::*`.)",
"clippy::enum_variant_names", "Detects enumeration variants that are prefixed or suffixed)",
"clippy::eq_op", "Checks for equal operands to comparison, logical and)",
"clippy::equatable_if_let", "Checks for pattern matchings that can be expressed using equality.)",
"clippy::erasing_op", "Checks for erasing operations, e.g., `x * 0`.)",
"clippy::eval_order_dependence", "Checks for a read and a write to the same variable where)",
"clippy::excessive_precision", "Checks for float literals with a precision greater)",
"clippy::exhaustive_enums", "Warns on any exported `enum`s that are not tagged `#[non_exhaustive]`)",
"clippy::exhaustive_structs", "Warns on any exported `structs`s that are not tagged `#[non_exhaustive]`)",
"clippy::exit", "`exit()` terminates the program and doesn't provide a)",
"clippy::expect_fun_call", "Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,)",
"clippy::expect_used", "Checks for `.expect()` calls on `Option`s and `Result`s.)",
"clippy::expl_impl_clone_on_copy", "Checks for explicit `Clone` implementations for `Copy`)",
"clippy::explicit_counter_loop", "Checks `for` loops over slices with an explicit counter)",
"clippy::explicit_deref_methods", "Checks for explicit `deref()` or `deref_mut()` method calls.)",
"clippy::explicit_into_iter_loop", "Checks for loops on `y.into_iter()` where `y` will do, and)",
"clippy::explicit_iter_loop", "Checks for loops on `x.iter()` where `&x` will do, and)",
"clippy::explicit_write", "Checks for usage of `write!()` / `writeln()!` which can be)",
"clippy::extend_from_slice", "Nothing. This lint has been deprecated.)",
"clippy::extend_with_drain", "Checks for occurrences where one vector gets extended instead of append)",
"clippy::extra_unused_lifetimes", "Checks for lifetimes in generics that are never used)",
"clippy::fallible_impl_from", "Checks for impls of `From<..>` that contain `panic!()` or `unwrap()`)",
"clippy::field_reassign_with_default", "Checks for immediate reassignment of fields initialized)",
"clippy::filetype_is_file", "Checks for `FileType::is_file()`.)",
"clippy::filter_map", "Nothing. This lint has been deprecated.)",
"clippy::filter_map_identity", "Checks for usage of `filter_map(|x| x)`.)",
"clippy::filter_map_next", "Checks for usage of `_.filter_map(_).next()`.)",
"clippy::filter_next", "Checks for usage of `_.filter(_).next()`.)",
"clippy::find_map", "Nothing. This lint has been deprecated.)",
"clippy::flat_map_identity", "Checks for usage of `flat_map(|x| x)`.)",
"clippy::flat_map_option", "Checks for usages of `Iterator::flat_map()` where `filter_map()` could be)",
"clippy::float_arithmetic", "Checks for float arithmetic.)",
"clippy::float_cmp", "Checks for (in-)equality comparisons on floating-point)",
"clippy::float_cmp_const", "Checks for (in-)equality comparisons on floating-point)",
"clippy::float_equality_without_abs", "Checks for statements of the form `(a - b) < f32::EPSILON` or)",
"clippy::fn_address_comparisons", "Checks for comparisons with an address of a function item.)",
"clippy::fn_params_excessive_bools", "Checks for excessive use of)",
"clippy::fn_to_numeric_cast", "Checks for casts of function pointers to something other than usize)",
"clippy::fn_to_numeric_cast_any", "Checks for casts of a function pointer to any integer type.)",
"clippy::fn_to_numeric_cast_with_truncation", "Checks for casts of a function pointer to a numeric type not wide enough to)",
"clippy::for_kv_map", "Checks for iterating a map (`HashMap` or `BTreeMap`) and)",
"clippy::for_loops_over_fallibles", "Checks for `for` loops over `Option` or `Result` values.)",
"clippy::forget_copy", "Checks for calls to `std::mem::forget` with a value that)",
"clippy::forget_ref", "Checks for calls to `std::mem::forget` with a reference)",
"clippy::format_in_format_args", "Detects `format!` within the arguments of another macro that does)",
"clippy::from_iter_instead_of_collect", "Checks for `from_iter()` function calls on types that implement the `FromIterator`)",
"clippy::from_over_into", "Searches for implementations of the `Into<..>` trait and suggests to implement `From<..>` instead.)",
"clippy::from_str_radix_10", ")",
"clippy::future_not_send", "This lint requires Future implementations returned from)",
"clippy::get_last_with_len", "Checks for using `x.get(x.len() - 1)` instead of)",
"clippy::get_unwrap", "Checks for use of `.get().unwrap()` (or)",
"clippy::identity_op", "Checks for identity operations, e.g., `x + 0`.)",
"clippy::if_let_mutex", "Checks for `Mutex::lock` calls in `if let` expression)",
"clippy::if_let_redundant_pattern_matching", "Nothing. This lint has been deprecated.)",
"clippy::if_not_else", "Checks for usage of `!` or `!=` in an if condition with an)",
"clippy::if_same_then_else", "Checks for `if/else` with the same body as the *then* part)",
"clippy::if_then_some_else_none", "Checks for if-else that could be written to `bool::then`.)",
"clippy::ifs_same_cond", "Checks for consecutive `if`s with the same condition.)",
"clippy::implicit_clone", "Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.)",
"clippy::implicit_hasher", "Checks for public `impl` or `fn` missing generalization)",
"clippy::implicit_return", "Checks for missing return statements at the end of a block.)",
"clippy::implicit_saturating_sub", "Checks for implicit saturating subtraction.)",
"clippy::imprecise_flops", "Looks for floating-point expressions that)",
"clippy::inconsistent_digit_grouping", "Warns if an integral or floating-point constant is)",
"clippy::inconsistent_struct_constructor", "Checks for struct constructors where all fields are shorthand and)",
"clippy::index_refutable_slice", "The lint checks for slice bindings in patterns that are only used to)",
"clippy::indexing_slicing", "Checks for usage of indexing or slicing. Arrays are special cases, this lint)",
"clippy::ineffective_bit_mask", "Checks for bit masks in comparisons which can be removed)",
"clippy::inefficient_to_string", "Checks for usage of `.to_string()` on an `&&T` where)",
"clippy::infallible_destructuring_match", "Checks for matches being used to destructure a single-variant enum)",
"clippy::infinite_iter", "Checks for iteration that is guaranteed to be infinite.)",
"clippy::inherent_to_string", "Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`.)",
"clippy::inherent_to_string_shadow_display", "Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait.)",
"clippy::inline_always", "Checks for items annotated with `#[inline(always)]`,)",
"clippy::inline_asm_x86_att_syntax", "Checks for usage of AT&T x86 assembly syntax.)",
"clippy::inline_asm_x86_intel_syntax", "Checks for usage of Intel x86 assembly syntax.)",
"clippy::inline_fn_without_body", "Checks for `#[inline]` on trait methods without bodies)",
"clippy::inspect_for_each", "Checks for usage of `inspect().for_each()`.)",
"clippy::int_plus_one", "Checks for usage of `x >= y + 1` or `x - 1 >= y` (and `<=`) in a block)",
"clippy::integer_arithmetic", "Checks for integer arithmetic operations which could overflow or panic.)",
"clippy::integer_division", "Checks for division of integers)",
"clippy::into_iter_on_ref", "Checks for `into_iter` calls on references which should be replaced by `iter`)",
"clippy::invalid_null_ptr_usage", "This lint checks for invalid usages of `ptr::null`.)",
"clippy::invalid_regex", "Checks [regex](https://crates.io/crates/regex) creation)",
"clippy::invalid_upcast_comparisons", "Checks for comparisons where the relation is always either)",
"clippy::invisible_characters", "Checks for invisible Unicode characters in the code.)",
"clippy::items_after_statements", "Checks for items declared after some statement in a block.)",
"clippy::iter_cloned_collect", "Checks for the use of `.cloned().collect()` on slice to)",
"clippy::iter_count", "Checks for the use of `.iter().count()`.)",
"clippy::iter_next_loop", "Checks for loops on `x.next()`.)",
"clippy::iter_next_slice", "Checks for usage of `iter().next()` on a Slice or an Array)",
"clippy::iter_not_returning_iterator", "Detects methods named `iter` or `iter_mut` that do not have a return type that implements `Iterator`.)",
"clippy::iter_nth", "Checks for use of `.iter().nth()` (and the related)",
"clippy::iter_nth_zero", "Checks for the use of `iter.nth(0)`.)",
"clippy::iter_skip_next", "Checks for use of `.skip(x).next()` on iterators.)",
"clippy::iterator_step_by_zero", "Checks for calling `.step_by(0)` on iterators which panics.)",
"clippy::just_underscores_and_digits", "Checks if you have variables whose name consists of just)",
"clippy::large_const_arrays", "Checks for large `const` arrays that should)",
"clippy::large_digit_groups", "Warns if the digits of an integral or floating-point)",
"clippy::large_enum_variant", "Checks for large size differences between variants on)",
"clippy::large_stack_arrays", "Checks for local arrays that may be too large.)",
"clippy::large_types_passed_by_value", "Checks for functions taking arguments by value, where)",
"clippy::len_without_is_empty", "Checks for items that implement `.len()` but not)",
"clippy::len_zero", "Checks for getting the length of something via `.len()`)",
"clippy::let_and_return", "Checks for `let`-bindings, which are subsequently)",
"clippy::let_underscore_drop", "Checks for `let _ = <expr>`)",
"clippy::let_underscore_lock", "Checks for `let _ = sync_lock`.)",
"clippy::let_underscore_must_use", "Checks for `let _ = <expr>` where expr is `#[must_use]`)",
"clippy::let_unit_value", "Checks for binding a unit value.)",
"clippy::linkedlist", "Checks for usage of any `LinkedList`, suggesting to use a)",
"clippy::logic_bug", "Checks for boolean expressions that contain terminals that)",
"clippy::lossy_float_literal", "Checks for whole number float literals that)",
"clippy::macro_use_imports", "Checks for `#[macro_use] use...`.)",
"clippy::main_recursion", "Checks for recursion using the entrypoint.)",
"clippy::manual_assert", "Detects `if`-then-`panic!` that can be replaced with `assert!`.)",
"clippy::manual_async_fn", "It checks for manual implementations of `async` functions.)",
"clippy::manual_filter_map", "Checks for usage of `_.filter(_).map(_)` that can be written more simply)",
"clippy::manual_find_map", "Checks for usage of `_.find(_).map(_)` that can be written more simply)",
"clippy::manual_flatten", "Check for unnecessary `if let` usage in a for loop)",
"clippy::manual_map", "Checks for usages of `match` which could be implemented using `map`)",
"clippy::manual_memcpy", "Checks for for-loops that manually copy items between)",
"clippy::manual_non_exhaustive", "Checks for manual implementations of the non-exhaustive pattern.)",
"clippy::manual_ok_or", ")",
"clippy::manual_range_contains", "Checks for expressions like `x >= 3 && x < 8` that could)",
"clippy::manual_saturating_arithmetic", "Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.)",
"clippy::manual_split_once", "Checks for usages of `str::splitn(2, _)`)",
"clippy::manual_str_repeat", "Checks for manual implementations of `str::repeat`)",
"clippy::manual_strip", "Suggests using `strip_{prefix,suffix}` over `str::{starts,ends}_with` and slicing using)",
"clippy::manual_swap", "Checks for manual swapping.)",
"clippy::manual_unwrap_or", "Finds patterns that reimplement `Option::unwrap_or` or `Result::unwrap_or`.)",
"clippy::many_single_char_names", "Checks for too many variables whose name consists of a)",
"clippy::map_clone", "Checks for usage of `map(|x| x.clone())` or)",
"clippy::map_collect_result_unit", "Checks for usage of `_.map(_).collect::<Result<(), _>()`.)",
"clippy::map_entry", "Checks for uses of `contains_key` + `insert` on `HashMap`)",
"clippy::map_err_ignore", "Checks for instances of `map_err(|_| Some::Enum)`)",
"clippy::map_flatten", "Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`)",
"clippy::map_identity", "Checks for instances of `map(f)` where `f` is the identity function.)",
"clippy::map_unwrap_or", "Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or)",
"clippy::match_as_ref", "Checks for match which is used to add a reference to an)",
"clippy::match_bool", "Checks for matches where match expression is a `bool`. It)",
"clippy::match_like_matches_macro", "Checks for `match` or `if let` expressions producing a)",
"clippy::match_on_vec_items", "Checks for `match vec[idx]` or `match vec[n..m]`.)",
"clippy::match_overlapping_arm", "Checks for overlapping match arms.)",
"clippy::match_ref_pats", "Checks for matches where all arms match a reference,)",
"clippy::match_result_ok", "Checks for unnecessary `ok()` in `while let`.)",
"clippy::match_same_arms", "Checks for `match` with identical arm bodies.)",
"clippy::match_single_binding", "Checks for useless match that binds to only one value.)",
"clippy::match_str_case_mismatch", "Checks for `match` expressions modifying the case of a string with non-compliant arms)",
"clippy::match_wild_err_arm", "Checks for arm which matches all errors with `Err(_)`)",
"clippy::match_wildcard_for_single_variants", "Checks for wildcard enum matches for a single variant.)",
"clippy::maybe_infinite_iter", "Checks for iteration that may be infinite.)",
"clippy::mem_forget", "Checks for usage of `std::mem::forget(t)` where `t` is)",
"clippy::mem_replace_option_with_none", "Checks for `mem::replace()` on an `Option` with)",
"clippy::mem_replace_with_default", "Checks for `std::mem::replace` on a value of type)",
"clippy::mem_replace_with_uninit", "Checks for `mem::replace(&mut _, mem::uninitialized())`)",
"clippy::min_max", "Checks for expressions where `std::cmp::min` and `max` are)",
"clippy::misaligned_transmute", "Nothing. This lint has been deprecated.)",
"clippy::mismatched_target_os", "Checks for cfg attributes having operating systems used in target family position.)",
"clippy::misrefactored_assign_op", "Checks for `a op= a op b` or `a op= b op a` patterns.)",
"clippy::missing_const_for_fn", "Suggests the use of `const` in functions and methods where possible.)",
"clippy::missing_docs_in_private_items", "Warns if there is missing doc for any documentable item)",
"clippy::missing_enforced_import_renames", "Checks for imports that do not rename the item as specified)",
"clippy::missing_errors_doc", "Checks the doc comments of publicly visible functions that)",
"clippy::missing_inline_in_public_items", "It lints if an exported function, method, trait method with default impl,)",
"clippy::missing_panics_doc", "Checks the doc comments of publicly visible functions that)",
"clippy::missing_safety_doc", "Checks for the doc comments of publicly visible)",
"clippy::mistyped_literal_suffixes", "Warns for mistyped suffix in literals)",
"clippy::mixed_case_hex_literals", "Warns on hexadecimal literals with mixed-case letter)",
"clippy::mod_module_files", "Checks that module layout uses only self named module files, bans mod.rs files.)",
"clippy::module_inception", "Checks for modules that have the same name as their)",
"clippy::module_name_repetitions", "Detects type names that are prefixed or suffixed by the)",
"clippy::modulo_arithmetic", "Checks for modulo arithmetic.)",
"clippy::modulo_one", "Checks for getting the remainder of a division by one or minus)",
"clippy::multiple_crate_versions", "Checks to see if multiple versions of a crate are being)",
"clippy::multiple_inherent_impl", "Checks for multiple inherent implementations of a struct)",
"clippy::must_use_candidate", "Checks for public functions that have no)",
"clippy::must_use_unit", "Checks for a `#[must_use]` attribute on)",
"clippy::mut_from_ref", "This lint checks for functions that take immutable)",
"clippy::mut_mut", "Checks for instances of `mut mut` references.)",
"clippy::mut_mutex_lock", "Checks for `&mut Mutex::lock` calls)",
"clippy::mut_range_bound", "Checks for loops which have a range bound that is a mutable variable)",
"clippy::mutable_key_type", "Checks for sets/maps with mutable key types.)",
"clippy::mutex_atomic", "Checks for usages of `Mutex<X>` where an atomic will do.)",
"clippy::mutex_integer", "Checks for usages of `Mutex<X>` where `X` is an integral)",
"clippy::naive_bytecount", "Checks for naive byte counts)",
"clippy::needless_arbitrary_self_type", "The lint checks for `self` in fn parameters that)",
"clippy::needless_bitwise_bool", "Checks for uses of bitwise and/or operators between booleans, where performance may be improved by using)",
"clippy::needless_bool", "Checks for expressions of the form `if c { true } else {)",
"clippy::needless_borrow", "Checks for address of operations (`&`) that are going to)",
"clippy::needless_borrowed_reference", "Checks for bindings that destructure a reference and borrow the inner)",
"clippy::needless_collect", "Checks for functions collecting an iterator when collect)",
"clippy::needless_continue", "The lint checks for `if`-statements appearing in loops)",
"clippy::needless_doctest_main", "Checks for `fn main() { .. }` in doctests)",
"clippy::needless_for_each", "Checks for usage of `for_each` that would be more simply written as a)",
"clippy::needless_lifetimes", "Checks for lifetime annotations which can be removed by)",
"clippy::needless_option_as_deref", "Checks for no-op uses of Option::{as_deref,as_deref_mut},)",
"clippy::needless_pass_by_value", "Checks for functions taking arguments by value, but not)",
"clippy::needless_question_mark", "Suggests alternatives for useless applications of `?` in terminating expressions)",
"clippy::needless_range_loop", "Checks for looping over the range of `0..len` of some)",
"clippy::needless_return", "Checks for return statements at the end of a block.)",
"clippy::needless_splitn", "Checks for usages of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.)",
"clippy::needless_update", "Checks for needlessly including a base struct on update)",
"clippy::neg_cmp_op_on_partial_ord", "Checks for the usage of negated comparison operators on types which only implement)",
"clippy::neg_multiply", "Checks for multiplication by -1 as a form of negation.)",
"clippy::negative_feature_names", "Checks for negative feature names with prefix `no-` or `not-`)",
"clippy::never_loop", "Checks for loops that will always `break`, `return` or)",
"clippy::new_ret_no_self", "Checks for `new` not returning a type that contains `Self`.)",
"clippy::new_without_default", "Checks for types with a `fn new() -> Self` method and no)",
"clippy::no_effect", "Checks for statements which have no effect.)",
"clippy::no_effect_underscore_binding", "Checks for binding to underscore prefixed variable without side-effects.)",
"clippy::non_ascii_literal", "Checks for non-ASCII characters in string literals.)",
"clippy::non_octal_unix_permissions", "Checks for non-octal values used to set Unix file permissions.)",
"clippy::non_send_fields_in_send_ty", "Warns about fields in struct implementing `Send` that are neither `Send` nor `Copy`.)",
"clippy::nonminimal_bool", "Checks for boolean expressions that can be written more)",
"clippy::nonsensical_open_options", "Checks for duplicate open options as well as combinations)",
"clippy::nonstandard_macro_braces", "Checks that common macros are used with consistent bracing.)",
"clippy::not_unsafe_ptr_arg_deref", "Checks for public functions that dereference raw pointer)",
"clippy::octal_escapes", "Checks for `\\0` escapes in string and byte literals that look like octal)",
"clippy::ok_expect", "Checks for usage of `ok().expect(..)`.)",
"clippy::op_ref", "Checks for arguments to `==` which have their address)",
"clippy::option_as_ref_deref", "Checks for usage of `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).)",
"clippy::option_env_unwrap", "Checks for usage of `option_env!(...).unwrap()` and)",
"clippy::option_filter_map", "Checks for indirect collection of populated `Option`)",
"clippy::option_if_let_else", "Lints usage of `if let Some(v) = ... { y } else { x }` which is more)",
"clippy::option_map_or_none", "Checks for usage of `_.map_or(None, _)`.)",
"clippy::option_map_unit_fn", "Checks for usage of `option.map(f)` where f is a function)",
"clippy::option_option", "Checks for use of `Option<Option<_>>` in function signatures and type)",
"clippy::or_fun_call", "Checks for calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,)",
"clippy::out_of_bounds_indexing", "Checks for out of bounds array indexing with a constant)",
"clippy::overflow_check_conditional", "Detects classic underflow/overflow checks.)",
"clippy::panic", "Checks for usage of `panic!`.)",
"clippy::panic_in_result_fn", "Checks for usage of `panic!`, `unimplemented!`, `todo!`, `unreachable!` or assertions in a function of type result.)",
"clippy::panicking_unwrap", "Checks for calls of `unwrap[_err]()` that will always fail.)",
"clippy::partialeq_ne_impl", "Checks for manual re-implementations of `PartialEq::ne`.)",
"clippy::path_buf_push_overwrite", "* Checks for [push](https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.push))",
"clippy::pattern_type_mismatch", "Checks for patterns that aren't exact representations of the types)",
"clippy::possible_missing_comma", "Checks for possible missing comma in an array. It lints if)",
"clippy::precedence", "Checks for operations where precedence may be unclear)",
"clippy::print_literal", "This lint warns about the use of literals as `print!`/`println!` args.)",
"clippy::print_stderr", "Checks for printing on *stderr*. The purpose of this lint)",
"clippy::print_stdout", "Checks for printing on *stdout*. The purpose of this lint)",
"clippy::print_with_newline", "This lint warns when you use `print!()` with a format)",
"clippy::println_empty_string", "This lint warns when you use `println!(\"\")` to)",
"clippy::ptr_arg", "This lint checks for function arguments of type `&String`)",
"clippy::ptr_as_ptr", "Checks for `as` casts between raw pointers without changing its mutability,)",
"clippy::ptr_eq", "Use `std::ptr::eq` when applicable)",
"clippy::ptr_offset_with_cast", "Checks for usage of the `offset` pointer method with a `usize` casted to an)",
"clippy::pub_enum_variant_names", "Nothing. This lint has been deprecated.)",
"clippy::question_mark", "Checks for expressions that could be replaced by the question mark operator.)",
"clippy::range_minus_one", "Checks for inclusive ranges where 1 is subtracted from)",
"clippy::range_plus_one", "Checks for exclusive ranges where 1 is added to the)",
"clippy::range_step_by_zero", "Nothing. This lint has been deprecated.)",
"clippy::range_zip_with_len", "Checks for zipping a collection with the range of)",
"clippy::rc_buffer", "Checks for `Rc<T>` and `Arc<T>` when `T` is a mutable buffer type such as `String` or `Vec`.)",
"clippy::rc_mutex", "Checks for `Rc<Mutex<T>>`.)",
"clippy::redundant_allocation", "Checks for use of redundant allocations anywhere in the code.)",
"clippy::redundant_clone", "Checks for a redundant `clone()` (and its relatives) which clones an owned)",
"clippy::redundant_closure", "Checks for closures which just call another function where)",
"clippy::redundant_closure_call", "Detects closures called in the same expression where they)",
"clippy::redundant_closure_for_method_calls", "Checks for closures which only invoke a method on the closure)",
"clippy::redundant_else", "Checks for `else` blocks that can be removed without changing semantics.)",
"clippy::redundant_feature_names", "Checks for feature names with prefix `use-`, `with-` or suffix `-support`)",
"clippy::redundant_field_names", "Checks for fields in struct literals where shorthands)",
"clippy::redundant_pattern", "Checks for patterns in the form `name @ _`.)",
"clippy::redundant_pattern_matching", "Lint for redundant pattern matching over `Result`, `Option`,)",
"clippy::redundant_pub_crate", "Checks for items declared `pub(crate)` that are not crate visible because they)",
"clippy::redundant_slicing", "Checks for redundant slicing expressions which use the full range, and)",
"clippy::redundant_static_lifetimes", "Checks for constants and statics with an explicit `'static` lifetime.)",
"clippy::ref_binding_to_reference", "Checks for `ref` bindings which create a reference to a reference.)",
"clippy::ref_in_deref", "Checks for references in expressions that use)",
"clippy::ref_option_ref", "Checks for usage of `&Option<&T>`.)",
"clippy::regex_macro", "Nothing. This lint has been deprecated.)",
"clippy::repeat_once", "Checks for usage of `.repeat(1)` and suggest the following method for each types.)",
"clippy::replace_consts", "Nothing. This lint has been deprecated.)",
"clippy::rest_pat_in_fully_bound_structs", "Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.)",
"clippy::result_map_or_into_option", "Checks for usage of `_.map_or(None, Some)`.)",
"clippy::result_map_unit_fn", "Checks for usage of `result.map(f)` where f is a function)",
"clippy::result_unit_err", "Checks for public functions that return a `Result`)",
"clippy::reversed_empty_ranges", "Checks for range expressions `x..y` where both `x` and `y`)",
"clippy::same_functions_in_if_condition", "Checks for consecutive `if`s with the same function call.)",
"clippy::same_item_push", "Checks whether a for loop is being used to push a constant)",
"clippy::same_name_method", "It lints if a struct has two method with same time:)",
"clippy::search_is_some", "Checks for an iterator or string search (such as `find()`,)",
"clippy::self_assignment", "Checks for explicit self-assignments.)",
"clippy::self_named_constructors", "Warns when constructors have the same name as their types.)",
"clippy::self_named_module_files", "Checks that module layout uses only mod.rs files.)",
"clippy::semicolon_if_nothing_returned", "Looks for blocks of expressions and fires if the last expression returns)",
"clippy::separated_literal_suffix", "Warns if literal suffixes are separated by an underscore.)",
"clippy::serde_api_misuse", "Checks for mis-uses of the serde API.)",
"clippy::shadow_reuse", "Checks for bindings that shadow other bindings already in)",
"clippy::shadow_same", "Checks for bindings that shadow other bindings already in)",
"clippy::shadow_unrelated", "Checks for bindings that shadow other bindings already in)",
"clippy::short_circuit_statement", "Checks for the use of short circuit boolean conditions as)",
"clippy::should_assert_eq", "Nothing. This lint has been deprecated.)",
"clippy::should_implement_trait", "Checks for methods that should live in a trait)",
"clippy::similar_names", "Checks for names that are very similar and thus confusing.)",
"clippy::single_char_add_str", "Warns when using `push_str`/`insert_str` with a single-character string literal)",
"clippy::single_char_pattern", "Checks for string methods that receive a single-character)",
"clippy::single_component_path_imports", "Checking for imports with single component use path.)",
"clippy::single_element_loop", "Checks whether a for loop has a single element.)",
"clippy::single_match", "Checks for matches with a single arm where an `if let`)",
"clippy::single_match_else", "Checks for matches with two arms where an `if let else` will)",
"clippy::size_of_in_element_count", "Detects expressions where)",
"clippy::skip_while_next", "Checks for usage of `_.skip_while(condition).next()`.)",
"clippy::slow_vector_initialization", "Checks slow zero-filled vector initialization)",
"clippy::stable_sort_primitive", "When sorting primitive values (integers, bools, chars, as well)",
"clippy::str_to_string", "This lint checks for `.to_string()` method calls on values of type `&str`.)",
"clippy::string_add", "Checks for all instances of `x + _` where `x` is of type)",
"clippy::string_add_assign", "Checks for string appends of the form `x = x + y` (without)",
"clippy::string_extend_chars", "Checks for the use of `.extend(s.chars())` where s is a)",
"clippy::string_from_utf8_as_bytes", "Check if the string is transformed to byte array and casted back to string.)",
"clippy::string_lit_as_bytes", "Checks for the `as_bytes` method called on string literals)",
"clippy::string_slice", "Checks for slice operations on strings)",
"clippy::string_to_string", "This lint checks for `.to_string()` method calls on values of type `String`.)",
"clippy::strlen_on_c_strings", "Checks for usage of `libc::strlen` on a `CString` or `CStr` value,)",
"clippy::struct_excessive_bools", "Checks for excessive)",
"clippy::suboptimal_flops", "Looks for floating-point expressions that)",
"clippy::suspicious_arithmetic_impl", "Lints for suspicious operations in impls of arithmetic operators, e.g.)",
"clippy::suspicious_assignment_formatting", "Checks for use of the non-existent `=*`, `=!` and `=-`)",
"clippy::suspicious_else_formatting", "Checks for formatting of `else`. It lints if the `else`)",
"clippy::suspicious_map", "Checks for calls to `map` followed by a `count`.)",
"clippy::suspicious_op_assign_impl", "Lints for suspicious operations in impls of OpAssign, e.g.)",
"clippy::suspicious_operation_groupings", "Checks for unlikely usages of binary operators that are almost)",
"clippy::suspicious_splitn", "Checks for calls to [`splitn`])",
"clippy::suspicious_unary_op_formatting", "Checks the formatting of a unary operator on the right hand side)",
"clippy::tabs_in_doc_comments", "Checks doc comments for usage of tab characters.)",
"clippy::temporary_assignment", "Checks for construction of a structure or tuple just to)",
"clippy::to_digit_is_some", "Checks for `.to_digit(..).is_some()` on `char`s.)",
"clippy::to_string_in_display", "Checks for uses of `to_string()` in `Display` traits.)",
"clippy::to_string_in_format_args", "Checks for [`ToString::to_string`](https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string))",
"clippy::todo", "Checks for usage of `todo!`.)",
"clippy::too_many_arguments", "Checks for functions with too many parameters.)",
"clippy::too_many_lines", "Checks for functions with a large amount of lines.)",
"clippy::toplevel_ref_arg", "Checks for function arguments and let bindings denoted as)",
"clippy::trailing_empty_array", "Displays a warning when a struct with a trailing zero-sized array is declared without a `repr` attribute.)",
"clippy::trait_duplication_in_bounds", "Checks for cases where generics are being used and multiple)",
"clippy::transmute_bytes_to_str", "Checks for transmutes from a `&[u8]` to a `&str`.)",
"clippy::transmute_float_to_int", "Checks for transmutes from a float to an integer.)",
"clippy::transmute_int_to_bool", "Checks for transmutes from an integer to a `bool`.)",
"clippy::transmute_int_to_char", "Checks for transmutes from an integer to a `char`.)",
"clippy::transmute_int_to_float", "Checks for transmutes from an integer to a float.)",
"clippy::transmute_num_to_bytes", "Checks for transmutes from a number to an array of `u8`)",
"clippy::transmute_ptr_to_ptr", "Checks for transmutes from a pointer to a pointer, or)",
"clippy::transmute_ptr_to_ref", "Checks for transmutes from a pointer to a reference.)",
"clippy::transmutes_expressible_as_ptr_casts", "Checks for transmutes that could be a pointer cast.)",
"clippy::transmuting_null", "Checks for transmute calls which would receive a null pointer.)",
"clippy::trivial_regex", "Checks for trivial [regex](https://crates.io/crates/regex))",
"clippy::trivially_copy_pass_by_ref", "Checks for functions taking arguments by reference, where)",
"clippy::try_err", "Checks for usages of `Err(x)?`.)",
"clippy::type_complexity", "Checks for types used in structs, parameters and `let`)",
"clippy::type_repetition_in_bounds", "This lint warns about unnecessary type repetitions in trait bounds)",
"clippy::undocumented_unsafe_blocks", "Checks for `unsafe` blocks without a `// Safety: ` comment)",
"clippy::undropped_manually_drops", "Prevents the safe `std::mem::drop` function from being called on `std::mem::ManuallyDrop`.)",
"clippy::unicode_not_nfc", "Checks for string literals that contain Unicode in a form)",
"clippy::unimplemented", "Checks for usage of `unimplemented!`.)",
"clippy::uninit_assumed_init", "Checks for `MaybeUninit::uninit().assume_init()`.)",
"clippy::uninit_vec", "Checks for `set_len()` call that creates `Vec` with uninitialized elements.)",
"clippy::unit_arg", "Checks for passing a unit value as an argument to a function without using a)",
"clippy::unit_cmp", "Checks for comparisons to unit. This includes all binary)",
"clippy::unit_hash", "Detects `().hash(_)`.)",
"clippy::unit_return_expecting_ord", "Checks for functions that expect closures of type)",
"clippy::unnecessary_cast", "Checks for casts to the same type, casts of int literals to integer types)",
"clippy::unnecessary_filter_map", "Checks for `filter_map` calls which could be replaced by `filter` or `map`.)",
"clippy::unnecessary_fold", "Checks for using `fold` when a more succinct alternative exists.)",
"clippy::unnecessary_lazy_evaluations", "As the counterpart to `or_fun_call`, this lint looks for unnecessary)",
"clippy::unnecessary_mut_passed", "Detects passing a mutable reference to a function that only)",
"clippy::unnecessary_operation", "Checks for expression statements that can be reduced to a)",
"clippy::unnecessary_self_imports", "Checks for imports ending in `::{self}`.)",
"clippy::unnecessary_sort_by", "Detects uses of `Vec::sort_by` passing in a closure)",
"clippy::unnecessary_unwrap", "Checks for calls of `unwrap[_err]()` that cannot fail.)",
"clippy::unnecessary_wraps", "Checks for private functions that only return `Ok` or `Some`.)",
"clippy::unneeded_field_pattern", "Checks for structure field patterns bound to wildcards.)",
"clippy::unneeded_wildcard_pattern", "Checks for tuple patterns with a wildcard)",
"clippy::unnested_or_patterns", "Checks for unnested or-patterns, e.g., `Some(0) | Some(2)` and)",
"clippy::unreachable", "Checks for usage of `unreachable!`.)",
"clippy::unreadable_literal", "Warns if a long integral or floating-point constant does)",
"clippy::unsafe_derive_deserialize", "Checks for deriving `serde::Deserialize` on a type that)",
"clippy::unsafe_removed_from_name", "Checks for imports that remove \"unsafe\" from an item's)",
"clippy::unsafe_vector_initialization", "Nothing. This lint has been deprecated.)",
"clippy::unseparated_literal_suffix", "Warns if literal suffixes are not separated by an)",
"clippy::unsound_collection_transmute", "Checks for transmutes between collections whose)",
"clippy::unstable_as_mut_slice", "Nothing. This lint has been deprecated.)",
"clippy::unstable_as_slice", "Nothing. This lint has been deprecated.)",
"clippy::unused_async", "Checks for functions that are declared `async` but have no `.await`s inside of them.)",
"clippy::unused_collect", "Nothing. This lint has been deprecated.)",
"clippy::unused_io_amount", "Checks for unused written/read amount.)",
"clippy::unused_self", "Checks methods that contain a `self` argument but don't use it)",
"clippy::unused_unit", "Checks for unit (`()`) expressions that can be removed.)",
"clippy::unusual_byte_groupings", "Warns if hexadecimal or binary literals are not grouped)",
"clippy::unwrap_in_result", "Checks for functions of type `Result` that contain `expect()` or `unwrap()`)",
"clippy::unwrap_or_else_default", "Checks for usages of `_.unwrap_or_else(Default::default)` on `Option` and)",
"clippy::unwrap_used", "Checks for `.unwrap()` calls on `Option`s and on `Result`s.)",
"clippy::upper_case_acronyms", "Checks for fully capitalized names and optionally names containing a capitalized acronym.)",
"clippy::use_debug", "Checks for use of `Debug` formatting. The purpose of this)",
"clippy::use_self", "Checks for unnecessary repetition of structure name when a)",
"clippy::used_underscore_binding", "Checks for the use of bindings with a single leading)",
"clippy::useless_asref", "Checks for usage of `.as_ref()` or `.as_mut()` where the)",
"clippy::useless_attribute", "Checks for `extern crate` and `use` items annotated with)",
"clippy::useless_conversion", "Checks for `Into`, `TryInto`, `From`, `TryFrom`, or `IntoIter` calls)",
"clippy::useless_format", "Checks for the use of `format!(\"string literal with no)",
"clippy::useless_let_if_seq", "Checks for variable declarations immediately followed by a)",
"clippy::useless_transmute", "Checks for transmutes to the original type of the object)",
"clippy::useless_vec", "Checks for usage of `&vec![..]` when using `&[..]` would)",
"clippy::vec_box", "Checks for use of `Vec<Box<T>>` where T: Sized anywhere in the code.)",
"clippy::vec_init_then_push", "Checks for calls to `push` immediately after creating a new `Vec`.)",
"clippy::vec_resize_to_zero", "Finds occurrences of `Vec::resize(0, an_int)`)",
"clippy::verbose_bit_mask", "Checks for bit masks that can be replaced by a call)",
"clippy::verbose_file_reads", "Checks for use of File::read_to_end and File::read_to_string.)",
"clippy::vtable_address_comparisons", "Checks for comparisons with an address of a trait vtable.)",
"clippy::while_immutable_condition", "Checks whether variables used within while loop condition)",
"clippy::while_let_loop", "Detects `loop + match` combinations that are easier)",
"clippy::while_let_on_iterator", "Checks for `while let` expressions on iterators.)",
"clippy::wildcard_dependencies", "Checks for wildcard dependencies in the `Cargo.toml`.)",
"clippy::wildcard_enum_match_arm", "Checks for wildcard enum matches using `_`.)",
"clippy::wildcard_imports", "Checks for wildcard imports `use _::*`.)",
"clippy::wildcard_in_or_patterns", "Checks for wildcard pattern used with others patterns in same match arm.)",
"clippy::write_literal", "This lint warns about the use of literals as `write!`/`writeln!` args.)",
"clippy::write_with_newline", "This lint warns when you use `write!()` with a format)",
"clippy::writeln_empty_string", "This lint warns when you use `writeln!(buf, \"\")` to)",
"clippy::wrong_pub_self_convention", "Nothing. This lint has been deprecated.)",
"clippy::wrong_self_convention", "Checks for methods with certain name prefixes and which)",
"clippy::wrong_transmute", "Checks for transmutes that can't ever be correct on any)",
"clippy::zero_divided_by_zero", "Checks for `0.0 / 0.0`.)",
"clippy::zero_prefixed_literal", "Warns if an integral constant literal starts with `0`.)",
"clippy::zero_ptr", "Catch casts from `0` to some pointer type)",
"clippy::zero_sized_map_values", "Checks for maps with zero-sized value types anywhere in the code.)",
"clippy::zst_offset", "Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to)",
)
} | completers/cargo_completer/cmd/action/clippy.go | 0.815416 | 0.506347 | clippy.go | starcoder |
package isodates
import (
"errors"
"time"
)
// ParseYearMonth accepts an ISO string such as "2019-04" and returns the individual date
// components for the year and month (e.g. 2019 and time.April). We also support the variant
// where you can prefix the year with either "+" or "-".
func ParseYearMonth(input string) (int, time.Month, error) {
inputLength := len(input)
yearText := ""
monthText := ""
// Must either by "YYYY-MM", "+YYYY-MM", or "-YYYY-MM"
if inputLength < 7 || inputLength > 8 {
return 0, ZeroMonth, invalidFormat("[+-]YYYY-MM", input)
}
// Either "+YYYY-MM" or "-YYYY-MM"
if inputLength == 8 {
if input[5] != '-' {
return 0, ZeroMonth, invalidFormat("[+-]YYYY-MM", input)
}
// For 8-character variant, the first character must be '+' or '-'
switch input[0] {
case '+':
yearText = input[1:5]
monthText = input[6:]
case '-':
yearText = input[0:5]
monthText = input[6:]
default:
return 0, ZeroMonth, invalidFormat("[+-]YYYY-MM", input)
}
}
// "YYYY-MM" format
if inputLength == 7 {
if input[4] != '-' {
return 0, ZeroMonth, invalidFormat("YYYY-MM", input)
}
yearText = input[0:4]
monthText = input[5:]
}
year, err := parseYear(yearText)
if err != nil {
return 0, ZeroMonth, err
}
month, err := parseMonth(monthText)
if err != nil {
return 0, ZeroMonth, err
}
return year, month, nil
}
// ParseYearMonthStart returns the first day of the year/month for the parsed input. The
// resulting date will be at midnight in UTC.
func ParseYearMonthStart(input string) (time.Time, error) {
return ParseYearMonthStartIn(input, time.UTC)
}
// ParseYearMonthStartIn returns the first day of the year/month for the parsed input. The
// resulting date will be at midnight in the specified time zone.
func ParseYearMonthStartIn(input string, loc *time.Location) (time.Time, error) {
if loc == nil {
return ZeroTime, errors.New("parse year month start: nil location")
}
year, month, err := ParseYearMonth(input)
if err != nil {
return ZeroTime, err
}
return Midnight(year, month, 1, loc), nil
}
// ParseYearMonthEnd returns the last day of the year/month for the parsed input. The
// resulting date will be at 11:59:59pm in UTC.
func ParseYearMonthEnd(input string) (time.Time, error) {
return ParseYearMonthEndIn(input, time.UTC)
}
// ParseYearMonthEndIn returns the last day of the year/month for the parsed input. The
// resulting date will be at 11:59:59pm in the specified time zone.
func ParseYearMonthEndIn(input string, loc *time.Location) (time.Time, error) {
if loc == nil {
return ZeroTime, errors.New("parse year month end: nil location")
}
year, month, err := ParseYearMonth(input)
if err != nil {
return ZeroTime, err
}
firstOfMonth := AlmostMidnight(year, month, 1, loc)
return firstOfMonth.AddDate(0, 1, -1), nil
} | year_month.go | 0.731922 | 0.437223 | year_month.go | starcoder |
package godenticon
import (
"errors"
"image"
"image/color"
"image/draw"
)
// Dermines blocky image size and output image multiplication coefficient
const blockSize = 7
const multiplier = 6
const bgOffset = 10
// GenarateImage creates image based on [16]byte hash and color slice
func GenarateImage(hash [16]byte, colorPalette []color.Color) (*image.RGBA, error) {
listLength := len(colorPalette)
if listLength == 0 {
return nil, errors.New("colors list must not be empty")
}
colorNumber := int(hash[0])
colorFromhash := colorPalette[(colorNumber % listLength)]
if colorFromhash == nil {
return nil, errors.New("color must not be nil")
}
blocksFromhash := [blockSize][blockSize]bool{
{hash[0]&1 != 0, hash[0]&128 != 0, hash[1]&64 != 0, hash[2]&32 != 0, hash[1]&64 != 0, hash[0]&128 != 0, hash[0]&1 != 0},
{hash[0]&2 != 0, hash[1]&1 != 0, hash[1]&128 != 0, hash[2]&64 != 0, hash[1]&128 != 0, hash[1]&1 != 0, hash[0]&2 != 0},
{hash[0]&4 != 0, hash[1]&2 != 0, hash[2]&1 != 0, hash[2]&128 != 0, hash[2]&1 != 0, hash[1]&2 != 0, hash[0]&4 != 0},
{hash[0]&8 != 0, hash[1]&4 != 0, hash[2]&2 != 0, hash[3]&1 != 0, hash[2]&2 != 0, hash[1]&4 != 0, hash[0]&8 != 0},
{hash[0]&16 != 0, hash[1]&8 != 0, hash[2]&4 != 0, hash[3]&2 != 0, hash[2]&4 != 0, hash[1]&8 != 0, hash[0]&16 != 0},
{hash[0]&32 != 0, hash[1]&16 != 0, hash[2]&8 != 0, hash[3]&32 != 0, hash[2]&8 != 0, hash[1]&16 != 0, hash[0]&32 != 0},
{hash[0]&64 != 0, hash[1]&32 != 0, hash[2]&16 != 0, hash[3]&64 != 0, hash[2]&16 != 0, hash[1]&32 != 0, hash[0]&64 != 0},
}
imageSize := blockSize * multiplier
img := func() *image.RGBA {
maxPoint := image.Point{imageSize, imageSize}
return image.NewRGBA(image.Rectangle{image.ZP, maxPoint})
}()
for x := 0; x < imageSize; x++ {
for y := 0; y < imageSize; y++ {
if blocksFromhash[int(y/multiplier)][int(x/multiplier)] {
img.Set(x, y, colorFromhash)
} else {
img.Set(x, y, color.White)
}
}
}
bg := func() *image.RGBA {
maxPoint := image.Point{imageSize + bgOffset, imageSize + bgOffset}
return image.NewRGBA(image.Rectangle{image.ZP, maxPoint})
}()
offset := image.Pt(bgOffset/2, bgOffset/2)
draw.Draw(bg, bg.Bounds(), &image.Uniform{color.White}, image.ZP, draw.Src)
draw.Draw(bg, img.Bounds().Add(offset), img, image.ZP, draw.Src)
return bg, nil
}
// Sample color slices collected in palettes
// ColorBlues ...
var ColorBlues = []color.Color{
color.RGBA{0, 0, 32, 0xff},
color.RGBA{0, 32, 64, 0xff},
color.RGBA{0, 64, 96, 0xff},
color.RGBA{0, 96, 128, 0xff},
color.RGBA{0, 112, 144, 0xff},
color.RGBA{63, 104, 150, 0xff},
color.RGBA{106, 151, 193, 0xff},
color.RGBA{138, 173, 221, 0xff},
color.RGBA{32, 67, 116, 0xff},
color.RGBA{143, 185, 255, 0xff},
}
// ColorNeon ...
var ColorNeon = []color.Color{
color.RGBA{2, 254, 0, 0xff},
color.RGBA{0, 224, 0, 0xff},
color.RGBA{0, 192, 0, 0xff},
color.RGBA{0, 192, 0, 0xff},
color.RGBA{0, 160, 0, 0xff},
color.RGBA{0, 128, 0, 0xff},
color.RGBA{126, 255, 0, 0xff},
color.RGBA{70, 195, 76, 0xff},
color.RGBA{71, 159, 120, 0xff},
color.RGBA{207, 255, 177, 0xff},
}
// ColorDiscord ...
var ColorDiscord = []color.Color{
color.RGBA{128, 128, 128, 0xff},
color.RGBA{96, 96, 96, 0xff},
color.RGBA{64, 64, 64, 0xff},
color.RGBA{32, 32, 32, 0xff},
color.RGBA{1, 1, 1, 0xff},
color.RGBA{72, 75, 81, 0xff},
color.RGBA{54, 57, 63, 0xff},
color.RGBA{47, 49, 54, 0xff},
color.RGBA{42, 44, 49, 0xff},
color.RGBA{32, 34, 37, 0xff},
}
// ColorSunny ...
var ColorSunny = []color.Color{
color.RGBA{241, 220, 6, 0xff},
color.RGBA{244, 244, 10, 0xff},
color.RGBA{244, 255, 0, 0xff},
color.RGBA{255, 210, 0, 0xff},
color.RGBA{233, 243, 15, 0xff},
color.RGBA{249, 156, 0, 0xff},
color.RGBA{255, 167, 20, 0xff},
color.RGBA{255, 202, 22, 0xff},
color.RGBA{255, 178, 27, 0xff},
color.RGBA{249, 115, 0, 0xff},
}
// ColorGopher ...
var ColorGopher = []color.Color{
color.RGBA{100, 200, 200, 0xff},
} | godenticon.go | 0.604632 | 0.433682 | godenticon.go | starcoder |
package util
type valueEntry struct {
Index int
Value interface{}
}
type orderedMapIterator struct {
orderedMap *OrderedMap
nextIndex int
}
// OrderedMap is similar implementation of OrderedDict in Python.
type OrderedMap struct {
Keys []string
ValueMap map[string]*valueEntry
}
// NewOrderedMap returns new empty ordered map
func NewOrderedMap() *OrderedMap {
return &OrderedMap{
Keys: []string{},
ValueMap: map[string]*valueEntry{},
}
}
// NewOrderedMapWithKVStrings returns new empty ordered map
func NewOrderedMapWithKVStrings(kvList [][]string) *OrderedMap {
o := &OrderedMap{
Keys: []string{},
ValueMap: map[string]*valueEntry{},
}
for _, pair := range kvList {
if len(pair) != 2 {
return nil
}
o.Set(pair[0], pair[1])
}
return o
}
// Get returns a value corresponding the key
func (o *OrderedMap) Get(key string) (interface{}, bool) {
ve, ok := o.ValueMap[key]
if ve != nil {
return ve.Value, ok
} else {
return nil, false
}
}
// GetString returns a string value corresponding the key
func (o *OrderedMap) GetString(key string) (string, bool) {
ve, ok := o.ValueMap[key]
if ve != nil {
return ve.Value.(string), ok
} else {
return "", false
}
}
// GetStringWithDefault returns a string value corresponding the key if the key is existing.
// Otherwise, the default value is returned.
func (o *OrderedMap) GetStringWithDefault(key string, defaultValue string) string {
if ve, ok := o.ValueMap[key]; ok {
return ve.Value.(string)
} else {
return defaultValue
}
}
// Set append the key and value if the key is not existing on the map
// Otherwise, the value does just replace the old value corresponding to the key.
func (o *OrderedMap) Set(key string, value interface{}) {
if ve, ok := o.ValueMap[key]; !ok {
o.Keys = append(o.Keys, key)
o.ValueMap[key] = &valueEntry{
Index: len(o.Keys) - 1,
Value: value,
}
} else {
ve.Value = value
}
}
// Delete deletes the key and value from the map
func (o *OrderedMap) Delete(key string) {
if ve, ok := o.ValueMap[key]; ok {
delete(o.ValueMap, key)
o.Keys = append(o.Keys[:ve.Index], o.Keys[ve.Index+1:]...)
}
}
// Len returns a size of the ordered map
func (o *OrderedMap) Len() int {
return len(o.Keys)
}
// Iterator creates a iterator object
func (o *OrderedMap) Iterator() *orderedMapIterator {
return &orderedMapIterator{
orderedMap: o,
nextIndex: 0,
}
}
// Next returns key and values on current iterating cursor.
// If the cursor moved over last entry, then the third return value will be false, otherwise true.
func (it *orderedMapIterator) Next() (string, interface{}, bool) {
if it.nextIndex >= it.orderedMap.Len() {
return "", nil, false
}
key := it.orderedMap.Keys[it.nextIndex]
ve := it.orderedMap.ValueMap[key]
it.nextIndex++
return key, ve.Value, true
}
// NextString is the same with Next, but the value is returned as string
func (it *orderedMapIterator) NextString() (string, string, bool) {
key, value, isValid := it.Next()
if isValid {
return key, value.(string), isValid
} else {
return "", "", isValid
}
} | vendor/knative.dev/client/pkg/util/orderedmap.go | 0.757166 | 0.416025 | orderedmap.go | starcoder |
package appkit
// #include "bezier_path.h"
import "C"
import (
"unsafe"
"github.com/hsiafan/cocoa/coregraphics"
"github.com/hsiafan/cocoa/foundation"
"github.com/hsiafan/cocoa/objc"
)
type BezierPath interface {
objc.Object
MoveToPoint(point foundation.Point)
LineToPoint(point foundation.Point)
CurveToPoint_ControlPoint1_ControlPoint2(endPoint foundation.Point, controlPoint1 foundation.Point, controlPoint2 foundation.Point)
ClosePath()
RelativeMoveToPoint(point foundation.Point)
RelativeLineToPoint(point foundation.Point)
RelativeCurveToPoint_ControlPoint1_ControlPoint2(endPoint foundation.Point, controlPoint1 foundation.Point, controlPoint2 foundation.Point)
AppendBezierPath(path BezierPath)
AppendBezierPathWithOvalInRect(rect foundation.Rect)
AppendBezierPathWithArcFromPoint_ToPoint_Radius(point1 foundation.Point, point2 foundation.Point, radius coregraphics.Float)
AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle(center foundation.Point, radius coregraphics.Float, startAngle coregraphics.Float, endAngle coregraphics.Float)
AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle_Clockwise(center foundation.Point, radius coregraphics.Float, startAngle coregraphics.Float, endAngle coregraphics.Float, clockwise bool)
AppendBezierPathWithRect(rect foundation.Rect)
AppendBezierPathWithRoundedRect_XRadius_YRadius(rect foundation.Rect, xRadius coregraphics.Float, yRadius coregraphics.Float)
Stroke()
Fill()
AddClip()
SetClip()
ContainsPoint(point foundation.Point) bool
TransformUsingAffineTransform(transform foundation.AffineTransform)
ElementAtIndex(index int) BezierPathElement
RemoveAllPoints()
BezierPathByFlatteningPath() NSBezierPath
BezierPathByReversingPath() NSBezierPath
WindingRule() WindingRule
SetWindingRule(value WindingRule)
LineCapStyle() LineCapStyle
SetLineCapStyle(value LineCapStyle)
LineJoinStyle() LineJoinStyle
SetLineJoinStyle(value LineJoinStyle)
LineWidth() coregraphics.Float
SetLineWidth(value coregraphics.Float)
MiterLimit() coregraphics.Float
SetMiterLimit(value coregraphics.Float)
Flatness() coregraphics.Float
SetFlatness(value coregraphics.Float)
Bounds() foundation.Rect
ControlPointBounds() foundation.Rect
CurrentPoint() foundation.Point
IsEmpty() bool
ElementCount() int
}
type NSBezierPath struct {
objc.NSObject
}
func MakeBezierPath(ptr unsafe.Pointer) NSBezierPath {
return NSBezierPath{
NSObject: objc.MakeObject(ptr),
}
}
func AllocBezierPath() NSBezierPath {
result_ := C.C_NSBezierPath_AllocBezierPath()
return MakeBezierPath(result_)
}
func (n NSBezierPath) Init() NSBezierPath {
result_ := C.C_NSBezierPath_Init(n.Ptr())
return MakeBezierPath(result_)
}
func NewBezierPath() NSBezierPath {
result_ := C.C_NSBezierPath_NewBezierPath()
return MakeBezierPath(result_)
}
func (n NSBezierPath) Autorelease() NSBezierPath {
result_ := C.C_NSBezierPath_Autorelease(n.Ptr())
return MakeBezierPath(result_)
}
func (n NSBezierPath) Retain() NSBezierPath {
result_ := C.C_NSBezierPath_Retain(n.Ptr())
return MakeBezierPath(result_)
}
func BezierPath_() NSBezierPath {
result_ := C.C_NSBezierPath_BezierPath_()
return MakeBezierPath(result_)
}
func BezierPathWithOvalInRect(rect foundation.Rect) NSBezierPath {
result_ := C.C_NSBezierPath_BezierPathWithOvalInRect(*(*C.CGRect)(unsafe.Pointer(&rect)))
return MakeBezierPath(result_)
}
func BezierPathWithRect(rect foundation.Rect) NSBezierPath {
result_ := C.C_NSBezierPath_BezierPathWithRect(*(*C.CGRect)(unsafe.Pointer(&rect)))
return MakeBezierPath(result_)
}
func BezierPathWithRoundedRect_XRadius_YRadius(rect foundation.Rect, xRadius coregraphics.Float, yRadius coregraphics.Float) NSBezierPath {
result_ := C.C_NSBezierPath_BezierPathWithRoundedRect_XRadius_YRadius(*(*C.CGRect)(unsafe.Pointer(&rect)), C.double(float64(xRadius)), C.double(float64(yRadius)))
return MakeBezierPath(result_)
}
func (n NSBezierPath) MoveToPoint(point foundation.Point) {
C.C_NSBezierPath_MoveToPoint(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point)))
}
func (n NSBezierPath) LineToPoint(point foundation.Point) {
C.C_NSBezierPath_LineToPoint(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point)))
}
func (n NSBezierPath) CurveToPoint_ControlPoint1_ControlPoint2(endPoint foundation.Point, controlPoint1 foundation.Point, controlPoint2 foundation.Point) {
C.C_NSBezierPath_CurveToPoint_ControlPoint1_ControlPoint2(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&endPoint)), *(*C.CGPoint)(unsafe.Pointer(&controlPoint1)), *(*C.CGPoint)(unsafe.Pointer(&controlPoint2)))
}
func (n NSBezierPath) ClosePath() {
C.C_NSBezierPath_ClosePath(n.Ptr())
}
func (n NSBezierPath) RelativeMoveToPoint(point foundation.Point) {
C.C_NSBezierPath_RelativeMoveToPoint(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point)))
}
func (n NSBezierPath) RelativeLineToPoint(point foundation.Point) {
C.C_NSBezierPath_RelativeLineToPoint(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point)))
}
func (n NSBezierPath) RelativeCurveToPoint_ControlPoint1_ControlPoint2(endPoint foundation.Point, controlPoint1 foundation.Point, controlPoint2 foundation.Point) {
C.C_NSBezierPath_RelativeCurveToPoint_ControlPoint1_ControlPoint2(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&endPoint)), *(*C.CGPoint)(unsafe.Pointer(&controlPoint1)), *(*C.CGPoint)(unsafe.Pointer(&controlPoint2)))
}
func (n NSBezierPath) AppendBezierPath(path BezierPath) {
C.C_NSBezierPath_AppendBezierPath(n.Ptr(), objc.ExtractPtr(path))
}
func (n NSBezierPath) AppendBezierPathWithOvalInRect(rect foundation.Rect) {
C.C_NSBezierPath_AppendBezierPathWithOvalInRect(n.Ptr(), *(*C.CGRect)(unsafe.Pointer(&rect)))
}
func (n NSBezierPath) AppendBezierPathWithArcFromPoint_ToPoint_Radius(point1 foundation.Point, point2 foundation.Point, radius coregraphics.Float) {
C.C_NSBezierPath_AppendBezierPathWithArcFromPoint_ToPoint_Radius(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point1)), *(*C.CGPoint)(unsafe.Pointer(&point2)), C.double(float64(radius)))
}
func (n NSBezierPath) AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle(center foundation.Point, radius coregraphics.Float, startAngle coregraphics.Float, endAngle coregraphics.Float) {
C.C_NSBezierPath_AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(¢er)), C.double(float64(radius)), C.double(float64(startAngle)), C.double(float64(endAngle)))
}
func (n NSBezierPath) AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle_Clockwise(center foundation.Point, radius coregraphics.Float, startAngle coregraphics.Float, endAngle coregraphics.Float, clockwise bool) {
C.C_NSBezierPath_AppendBezierPathWithArcWithCenter_Radius_StartAngle_EndAngle_Clockwise(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(¢er)), C.double(float64(radius)), C.double(float64(startAngle)), C.double(float64(endAngle)), C.bool(clockwise))
}
func (n NSBezierPath) AppendBezierPathWithRect(rect foundation.Rect) {
C.C_NSBezierPath_AppendBezierPathWithRect(n.Ptr(), *(*C.CGRect)(unsafe.Pointer(&rect)))
}
func (n NSBezierPath) AppendBezierPathWithRoundedRect_XRadius_YRadius(rect foundation.Rect, xRadius coregraphics.Float, yRadius coregraphics.Float) {
C.C_NSBezierPath_AppendBezierPathWithRoundedRect_XRadius_YRadius(n.Ptr(), *(*C.CGRect)(unsafe.Pointer(&rect)), C.double(float64(xRadius)), C.double(float64(yRadius)))
}
func (n NSBezierPath) Stroke() {
C.C_NSBezierPath_Stroke(n.Ptr())
}
func (n NSBezierPath) Fill() {
C.C_NSBezierPath_Fill(n.Ptr())
}
func BezierPath_FillRect(rect foundation.Rect) {
C.C_NSBezierPath_BezierPath_FillRect(*(*C.CGRect)(unsafe.Pointer(&rect)))
}
func BezierPath_StrokeRect(rect foundation.Rect) {
C.C_NSBezierPath_BezierPath_StrokeRect(*(*C.CGRect)(unsafe.Pointer(&rect)))
}
func BezierPath_StrokeLineFromPoint_ToPoint(point1 foundation.Point, point2 foundation.Point) {
C.C_NSBezierPath_BezierPath_StrokeLineFromPoint_ToPoint(*(*C.CGPoint)(unsafe.Pointer(&point1)), *(*C.CGPoint)(unsafe.Pointer(&point2)))
}
func (n NSBezierPath) AddClip() {
C.C_NSBezierPath_AddClip(n.Ptr())
}
func (n NSBezierPath) SetClip() {
C.C_NSBezierPath_SetClip(n.Ptr())
}
func BezierPath_ClipRect(rect foundation.Rect) {
C.C_NSBezierPath_BezierPath_ClipRect(*(*C.CGRect)(unsafe.Pointer(&rect)))
}
func (n NSBezierPath) ContainsPoint(point foundation.Point) bool {
result_ := C.C_NSBezierPath_ContainsPoint(n.Ptr(), *(*C.CGPoint)(unsafe.Pointer(&point)))
return bool(result_)
}
func (n NSBezierPath) TransformUsingAffineTransform(transform foundation.AffineTransform) {
C.C_NSBezierPath_TransformUsingAffineTransform(n.Ptr(), objc.ExtractPtr(transform))
}
func (n NSBezierPath) ElementAtIndex(index int) BezierPathElement {
result_ := C.C_NSBezierPath_ElementAtIndex(n.Ptr(), C.int(index))
return BezierPathElement(uint(result_))
}
func (n NSBezierPath) RemoveAllPoints() {
C.C_NSBezierPath_RemoveAllPoints(n.Ptr())
}
func (n NSBezierPath) BezierPathByFlatteningPath() NSBezierPath {
result_ := C.C_NSBezierPath_BezierPathByFlatteningPath(n.Ptr())
return MakeBezierPath(result_)
}
func (n NSBezierPath) BezierPathByReversingPath() NSBezierPath {
result_ := C.C_NSBezierPath_BezierPathByReversingPath(n.Ptr())
return MakeBezierPath(result_)
}
func (n NSBezierPath) WindingRule() WindingRule {
result_ := C.C_NSBezierPath_WindingRule(n.Ptr())
return WindingRule(uint(result_))
}
func (n NSBezierPath) SetWindingRule(value WindingRule) {
C.C_NSBezierPath_SetWindingRule(n.Ptr(), C.uint(uint(value)))
}
func (n NSBezierPath) LineCapStyle() LineCapStyle {
result_ := C.C_NSBezierPath_LineCapStyle(n.Ptr())
return LineCapStyle(uint(result_))
}
func (n NSBezierPath) SetLineCapStyle(value LineCapStyle) {
C.C_NSBezierPath_SetLineCapStyle(n.Ptr(), C.uint(uint(value)))
}
func (n NSBezierPath) LineJoinStyle() LineJoinStyle {
result_ := C.C_NSBezierPath_LineJoinStyle(n.Ptr())
return LineJoinStyle(uint(result_))
}
func (n NSBezierPath) SetLineJoinStyle(value LineJoinStyle) {
C.C_NSBezierPath_SetLineJoinStyle(n.Ptr(), C.uint(uint(value)))
}
func (n NSBezierPath) LineWidth() coregraphics.Float {
result_ := C.C_NSBezierPath_LineWidth(n.Ptr())
return coregraphics.Float(float64(result_))
}
func (n NSBezierPath) SetLineWidth(value coregraphics.Float) {
C.C_NSBezierPath_SetLineWidth(n.Ptr(), C.double(float64(value)))
}
func (n NSBezierPath) MiterLimit() coregraphics.Float {
result_ := C.C_NSBezierPath_MiterLimit(n.Ptr())
return coregraphics.Float(float64(result_))
}
func (n NSBezierPath) SetMiterLimit(value coregraphics.Float) {
C.C_NSBezierPath_SetMiterLimit(n.Ptr(), C.double(float64(value)))
}
func (n NSBezierPath) Flatness() coregraphics.Float {
result_ := C.C_NSBezierPath_Flatness(n.Ptr())
return coregraphics.Float(float64(result_))
}
func (n NSBezierPath) SetFlatness(value coregraphics.Float) {
C.C_NSBezierPath_SetFlatness(n.Ptr(), C.double(float64(value)))
}
func BezierPath_DefaultWindingRule() WindingRule {
result_ := C.C_NSBezierPath_BezierPath_DefaultWindingRule()
return WindingRule(uint(result_))
}
func BezierPath_SetDefaultWindingRule(value WindingRule) {
C.C_NSBezierPath_BezierPath_SetDefaultWindingRule(C.uint(uint(value)))
}
func BezierPath_DefaultLineCapStyle() LineCapStyle {
result_ := C.C_NSBezierPath_BezierPath_DefaultLineCapStyle()
return LineCapStyle(uint(result_))
}
func BezierPath_SetDefaultLineCapStyle(value LineCapStyle) {
C.C_NSBezierPath_BezierPath_SetDefaultLineCapStyle(C.uint(uint(value)))
}
func BezierPath_DefaultLineJoinStyle() LineJoinStyle {
result_ := C.C_NSBezierPath_BezierPath_DefaultLineJoinStyle()
return LineJoinStyle(uint(result_))
}
func BezierPath_SetDefaultLineJoinStyle(value LineJoinStyle) {
C.C_NSBezierPath_BezierPath_SetDefaultLineJoinStyle(C.uint(uint(value)))
}
func BezierPath_DefaultLineWidth() coregraphics.Float {
result_ := C.C_NSBezierPath_BezierPath_DefaultLineWidth()
return coregraphics.Float(float64(result_))
}
func BezierPath_SetDefaultLineWidth(value coregraphics.Float) {
C.C_NSBezierPath_BezierPath_SetDefaultLineWidth(C.double(float64(value)))
}
func BezierPath_DefaultMiterLimit() coregraphics.Float {
result_ := C.C_NSBezierPath_BezierPath_DefaultMiterLimit()
return coregraphics.Float(float64(result_))
}
func BezierPath_SetDefaultMiterLimit(value coregraphics.Float) {
C.C_NSBezierPath_BezierPath_SetDefaultMiterLimit(C.double(float64(value)))
}
func BezierPath_DefaultFlatness() coregraphics.Float {
result_ := C.C_NSBezierPath_BezierPath_DefaultFlatness()
return coregraphics.Float(float64(result_))
}
func BezierPath_SetDefaultFlatness(value coregraphics.Float) {
C.C_NSBezierPath_BezierPath_SetDefaultFlatness(C.double(float64(value)))
}
func (n NSBezierPath) Bounds() foundation.Rect {
result_ := C.C_NSBezierPath_Bounds(n.Ptr())
return *((*coregraphics.Rect)(unsafe.Pointer(&result_)))
}
func (n NSBezierPath) ControlPointBounds() foundation.Rect {
result_ := C.C_NSBezierPath_ControlPointBounds(n.Ptr())
return *((*coregraphics.Rect)(unsafe.Pointer(&result_)))
}
func (n NSBezierPath) CurrentPoint() foundation.Point {
result_ := C.C_NSBezierPath_CurrentPoint(n.Ptr())
return *((*coregraphics.Point)(unsafe.Pointer(&result_)))
}
func (n NSBezierPath) IsEmpty() bool {
result_ := C.C_NSBezierPath_IsEmpty(n.Ptr())
return bool(result_)
}
func (n NSBezierPath) ElementCount() int {
result_ := C.C_NSBezierPath_ElementCount(n.Ptr())
return int(result_)
} | appkit/bezier_path.go | 0.716913 | 0.555737 | bezier_path.go | starcoder |
package value
import "math/big"
// domain: [-1, 1] - complex solution outside of domain
// range: (−π/2, π/2)
func asin(c Context, v Value) Value {
x := floatSelf(c, v).(BigFloat).Float
if x.Cmp(floatMinusOne) < 0 || x.Cmp(floatOne) > 0 {
return newComplexReal(v).Asin(c).shrink()
}
return evalFloatFunc(c, v, floatAsin)
}
// domain: [-1, 1] - complex solution outside of domain
// range: (0, π)
func acos(c Context, v Value) Value {
x := floatSelf(c, v).(BigFloat).Float
if x.Cmp(floatMinusOne) < 0 || x.Cmp(floatOne) > 0 {
return newComplexReal(v).Acos(c).shrink()
}
return evalFloatFunc(c, v, floatAcos)
}
// domain: (−∞ ,∞)
// range: (−π/2, π/2)
func atan(c Context, v Value) Value {
return evalFloatFunc(c, v, floatAtan)
}
// floatAsin computes asin(x) using the formula asin(x) = atan(x/sqrt(1-x²)).
func floatAsin(c Context, x *big.Float) *big.Float {
if x.Cmp(floatMinusOne) < 0 {
Errorf("asin of value less than -1")
}
if x.Cmp(floatOne) > 0 {
Errorf("asin of value greater than 1")
}
// The asin Taylor series converges very slowly near ±1, but our
// atan implementation converges well for all values, so we use
// the formula above to compute asin. But be careful when |x|=1.
if x.Cmp(floatOne) == 0 {
z := newFloat(c).Set(floatPi)
return z.Quo(z, floatTwo)
}
if x.Cmp(floatMinusOne) == 0 {
z := newFloat(c).Set(floatPi)
z.Quo(z, floatTwo)
return z.Neg(z)
}
z := newFloat(c)
z.Mul(x, x)
z.Sub(floatOne, z)
z = floatSqrt(c, z)
z.Quo(x, z)
return floatAtan(c, z)
}
// floatAcos computes acos(x) as π/2 - asin(x).
func floatAcos(c Context, x *big.Float) *big.Float {
if x.Cmp(floatMinusOne) < 0 {
Errorf("acos of value less than -1")
}
if x.Cmp(floatOne) > 0 {
Errorf("acos of value greater than 1")
}
// acos(x) = π/2 - asin(x)
z := newFloat(c).Set(floatPi)
z.Quo(z, newFloat(c).SetInt64(2))
return z.Sub(z, floatAsin(c, x))
}
// floatAtan computes atan(x) using a Taylor series. There are two series,
// one for |x| < 1 and one for larger values.
func floatAtan(c Context, x *big.Float) *big.Float {
// atan(-x) == -atan(x). Do this up top to simplify the Euler crossover calculation.
if x.Sign() < 0 {
z := newFloat(c).Set(x)
z = floatAtan(c, z.Neg(z))
return z.Neg(z)
}
// The series converge very slowly near 1. atan 1.00001 takes over a million
// iterations at the default precision. But there is hope, an Euler identity:
// atan(x) = atan(y) + atan((x-y)/(1+xy))
// Note that y is a free variable. If x is near 1, we can use this formula
// to push the computation to values that converge faster. Because
// tan(π/8) = √2 - 1, or equivalently atan(√2 - 1) == π/8
// we choose y = √2 - 1 and then we only need to calculate one atan:
// atan(x) = π/8 + atan((x-y)/(1+xy))
// Where do we cross over? This version converges significantly faster
// even at 0.5, but we must be careful that (x-y)/(1+xy) never approaches 1.
// At x = 0.5, (x-y)/(1+xy) is 0.07; at x=1 it is 0.414214; at x=1.5 it is
// 0.66, which is as big as we dare go. With 256 bits of precision and a
// crossover at 0.5, here are the number of iterations done by
// atan .1*iota 20
// 0.1 39, 0.2 55, 0.3 73, 0.4 96, 0.5 126, 0.6 47, 0.7 59, 0.8 71, 0.9 85, 1.0 99, 1.1 116, 1.2 38, 1.3 44, 1.4 50, 1.5 213, 1.6 183, 1.7 163, 1.8 147, 1.9 135, 2.0 125
tmp := newFloat(c).Set(floatOne)
tmp.Sub(tmp, x)
tmp.Abs(tmp)
if tmp.Cmp(newFloat(c).SetFloat64(0.5)) < 0 {
z := newFloat(c).Set(floatPi)
z.Quo(z, newFloat(c).SetInt64(8))
y := floatSqrt(c, floatTwo)
y.Sub(y, floatOne)
num := newFloat(c).Set(x)
num.Sub(num, y)
den := newFloat(c).Set(x)
den = den.Mul(den, y)
den = den.Add(den, floatOne)
z = z.Add(z, floatAtan(c, num.Quo(num, den)))
return z
}
if x.Cmp(floatOne) > 0 {
return floatAtanLarge(c, x)
}
// This is the series for small values |x| < 1.
// asin(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
// First term to compute in loop will be x
n := newFloat(c)
term := newFloat(c)
xN := newFloat(c).Set(x)
xSquared := newFloat(c).Set(x)
xSquared.Mul(x, x)
z := newFloat(c)
// n goes up by two each loop.
for loop := newLoop(c.Config(), "atan", x, 4); ; {
term.Set(xN)
term.Quo(term, n.SetUint64(2*loop.i+1))
z.Add(z, term)
xN.Neg(xN)
if loop.done(z) {
break
}
// xN *= x², becoming x**(n+2).
xN.Mul(xN, xSquared)
}
return z
}
// floatAtanLarge computes atan(x) for large x using a Taylor series.
// x is known to be > 1.
func floatAtanLarge(c Context, x *big.Float) *big.Float {
// This is the series for larger values |x| >= 1.
// For x > 0, atan(x) = +π/2 - 1/x + 1/3x³ -1/5x⁵ + 1/7x⁷ - ...
// First term to compute in loop will be -1/x
n := newFloat(c)
term := newFloat(c)
xN := newFloat(c).Set(x)
xSquared := newFloat(c).Set(x)
xSquared.Mul(x, x)
z := newFloat(c).Set(floatPi)
z.Quo(z, floatTwo)
// n goes up by two each loop.
for loop := newLoop(c.Config(), "atan", x, 4); ; {
xN.Neg(xN)
term.Set(xN)
term.Mul(term, n.SetUint64(2*loop.i+1))
term.Quo(floatOne, term)
z.Add(z, term)
if loop.done(z) {
break
}
// xN *= x², becoming x**(n+2).
xN.Mul(xN, xSquared)
}
return z
} | value/asin.go | 0.797439 | 0.534309 | asin.go | starcoder |
package zbor
// genericDictionary is a byte slice that contains the result of running the Zstandard training mode
// on the DPS index. This allows zstandard to achieve a better compression ratio, specifically for
// small data.
// See http://facebook.github.io/zstd/#small-data
// See https://github.com/facebook/zstd/blob/master/doc/zstd_compression_format.md#dictionary-format
var genericDictionary = []byte{
0x37, 0xa4, 0x30, 0xec, 0x07, 0x81, 0x4a, 0x29, 0x25, 0x10, 0x30, 0xdd,
0x01, 0xf0, 0x97, 0x3b, 0xff, 0x7f, 0x84, 0xc1, 0x03, 0xeb, 0xd8, 0x20,
0x10, 0x08, 0x63, 0x08, 0x75, 0x34, 0xdd, 0xc1, 0x8f, 0xfb, 0xe1, 0x61,
0x29, 0xa5, 0x94, 0x52, 0x4a, 0x7d, 0x78, 0x76, 0x92, 0x6a, 0xe3, 0x07,
0x00, 0x00, 0x16, 0x40, 0x42, 0x20, 0x86, 0x59, 0x69, 0x18, 0x4a, 0x07,
0x04, 0x80, 0x82, 0xc1, 0x85, 0x0b, 0x8d, 0x8b, 0x82, 0x01, 0x98, 0x0d,
0x82, 0x8e, 0x8a, 0x81, 0x82, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x01,
0xa1, 0x05, 0x00, 0x70, 0x32, 0x08, 0x00, 0x40, 0x11, 0x28, 0x65, 0x48,
0x96, 0xa1, 0xd8, 0x51, 0x00, 0x00, 0x00, 0x44, 0x6d, 0x09, 0x04, 0x28,
0x02, 0x39, 0x06, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08,
0x00, 0x00, 0x00, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x98, 0x19, 0xd8,
0xa4, 0x1a, 0x00, 0x4f, 0x7c, 0x2d, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0x70,
0x0f, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0xff, 0x9c, 0xd8, 0xa4, 0x1a, 0x00,
0x56, 0x28, 0x88, 0xd8, 0xa4, 0x1a, 0x00, 0x40, 0x92, 0xe4, 0xd8, 0xa4,
0x1a, 0x00, 0x3d, 0x8a, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x47, 0x60, 0x0b,
0xd8, 0xa4, 0x1a, 0x00, 0x14, 0xe4, 0xea, 0xd8, 0xa4, 0x1a, 0x00, 0x63,
0xf4, 0xac, 0xd8, 0xa4, 0x1a, 0x00, 0x47, 0x2e, 0x31, 0xd8, 0xa4, 0x1a,
0x00, 0x62, 0x39, 0x5c, 0xd8, 0xa4, 0x1a, 0x00, 0x94, 0x39, 0x3f, 0xd8,
0xa4, 0x1a, 0x00, 0x88, 0x55, 0xc5, 0xd8, 0xa4, 0x1a, 0x00, 0x91, 0xc1,
0x26, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0x57, 0x16, 0xd8, 0xa4, 0x1a, 0x00,
0x46, 0xa7, 0xcb, 0xd8, 0xa4, 0x1a, 0x00, 0x6c, 0x78, 0xc1, 0xd8, 0xa4,
0x1a, 0x00, 0x88, 0x97, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x35, 0x91,
0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0xaf, 0x20, 0xd8, 0xa4, 0x1a, 0x00, 0x53,
0xb7, 0xde, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0xce, 0xd6, 0xd8, 0xa4, 0x1a,
0x00, 0x61, 0xfb, 0xe0, 0xd8, 0xa4, 0x1a, 0x00, 0x9f, 0xab, 0x82, 0xd8,
0xa4, 0x1a, 0x00, 0xb3, 0x16, 0x82, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x7f, 0x63, 0x0f, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91,
0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x31, 0x33,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x35, 0x33, 0x37, 0x31, 0x31, 0x33, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0xca, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x7c, 0x06,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x54, 0x7d, 0x59, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xc9, 0xb8, 0x4b, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x09, 0x18, 0x67,
0xd6, 0x88, 0xff, 0x61, 0x25, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37,
0x35, 0x39, 0x38, 0x37, 0x39, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbe, 0x03, 0xdc, 0x7e, 0x62,
0xe0, 0xff, 0x08, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x34, 0x35,
0x31, 0x39, 0x38, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xc3, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x64, 0x75, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xdc, 0x11, 0x74, 0x04, 0x96, 0xf9, 0xe4, 0x10,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xdc, 0x11, 0x74, 0x04, 0x96, 0xf9, 0xe4, 0x10, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x6e, 0xd4, 0xcf, 0x00, 0x91, 0xa0, 0x6b, 0xb4, 0xa5, 0xeb, 0x03, 0x70,
0x0c, 0xac, 0x4d, 0x90, 0xd6, 0x59, 0x0b, 0x1a, 0xc5, 0xda, 0x37, 0xeb,
0xee, 0xc4, 0xdc, 0x3a, 0x58, 0x31, 0xc0, 0xcb, 0x47, 0xd3, 0xe3, 0x74,
0x4f, 0x6c, 0x1f, 0xce, 0x50, 0xd4, 0x0b, 0x2a, 0xdf, 0xc4, 0x3f, 0x15,
0xa0, 0x22, 0xe5, 0x0b, 0xed, 0x12, 0xd9, 0x62, 0x1a, 0x8f, 0x5d, 0xf6,
0xd1, 0x6a, 0x9c, 0x26, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xf6, 0xea, 0x5b, 0x8a, 0xb7, 0xfc, 0xc6, 0x80, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xf6, 0xea, 0x5b, 0x8a, 0xb7, 0xfc, 0xc6, 0x80, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xe3,
0x4e, 0x20, 0x5e, 0xc8, 0x86, 0x1e, 0x5e, 0xe2, 0xdb, 0x3c, 0x99, 0xa6,
0xe7, 0xad, 0xd7, 0xee, 0x96, 0x03, 0x1c, 0x10, 0xc3, 0xde, 0xe9, 0x83,
0xee, 0x5b, 0x63, 0xd4, 0x1d, 0x92, 0xe1, 0x8f, 0x2d, 0x18, 0x18, 0xd8,
0xdd, 0xc6, 0xaa, 0x8d, 0xc0, 0x65, 0xe7, 0x5b, 0xa6, 0x98, 0x17, 0x7d,
0xbe, 0x0d, 0x19, 0x04, 0xcc, 0xd3, 0xe7, 0xe0, 0x97, 0x80, 0xaf, 0x69,
0x24, 0x38, 0x6d, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xec, 0x52, 0x80, 0x12, 0xd2, 0xcb, 0x34, 0x94, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xec, 0x52, 0x80, 0x12, 0xd2, 0xcb, 0x34, 0x94, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x5b, 0x38,
0xd7, 0x84, 0x12, 0x2a, 0x89, 0x1f, 0x2b, 0x73, 0x65, 0x93, 0x75, 0x94,
0x86, 0x8e, 0x94, 0x7b, 0x0e, 0x47, 0xb4, 0x3c, 0x29, 0x39, 0x91, 0x39,
0xc7, 0x9f, 0x69, 0x06, 0x43, 0xfe, 0xba, 0x01, 0xc7, 0x4f, 0x0a, 0xfd,
0x26, 0xca, 0x7e, 0x43, 0x43, 0xe8, 0x60, 0x8a, 0x5c, 0x51, 0x35, 0xa2,
0x8d, 0xb7, 0xa3, 0x19, 0xd8, 0x90, 0x36, 0x20, 0x4e, 0x2d, 0x89, 0x15,
0x33, 0x37, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xbb, 0x2c, 0x93, 0x78, 0x03, 0x8b, 0xba, 0xbb, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbb,
0x2c, 0x93, 0x78, 0x03, 0x8b, 0xba, 0xbb, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x39, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xe0, 0x09, 0x7f,
0x39, 0x57, 0x6b, 0xc8, 0x5f, 0xd5, 0x78, 0x7c, 0x8b, 0x27, 0xea, 0x92,
0xc0, 0x24, 0x24, 0xb5, 0xe9, 0xd4, 0x3f, 0x80, 0xb9, 0x25, 0xaf, 0x8a,
0x50, 0x8c, 0x6d, 0x24, 0x0d, 0x7d, 0xd7, 0x7b, 0xd8, 0xe7, 0xd7, 0xb5,
0x5e, 0xa9, 0xc5, 0x76, 0x40, 0x41, 0xa8, 0x36, 0x6f, 0xc7, 0xcf, 0x83,
0x3c, 0x91, 0xad, 0x8b, 0x9a, 0x27, 0x8f, 0x20, 0x49, 0x29, 0x1c, 0x8e,
0x1b, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xb8, 0xee, 0x31, 0xd7, 0xe5, 0xab, 0x1f, 0x30, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb8, 0xee,
0x31, 0xd7, 0xe5, 0xab, 0x1f, 0x30, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xf8, 0xf5, 0x82, 0x79,
0x7a, 0x9d, 0x84, 0x39, 0xaf, 0x6c, 0x02, 0x42, 0x75, 0x30, 0x04, 0xf7,
0x2b, 0x4b, 0x9e, 0x70, 0x27, 0x6a, 0xcb, 0x6a, 0x9f, 0x5a, 0xf5, 0x26,
0x41, 0x8f, 0x29, 0x1e, 0xa0, 0x60, 0xd2, 0x51, 0x57, 0xc6, 0x62, 0xf3,
0x99, 0x7e, 0xc4, 0xcc, 0x86, 0xac, 0x5c, 0xef, 0xa5, 0xcc, 0x06, 0xab,
0xb5, 0x7a, 0x1f, 0x03, 0x0b, 0x19, 0xa4, 0xac, 0x58, 0xd8, 0xf7, 0xe7,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1,
0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f,
0x34, 0x32, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x35, 0x31, 0x34, 0x34, 0x32, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02,
0x5b, 0x51, 0x73, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xdd, 0x78,
0xf5, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0xd5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0f, 0x89,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xde, 0x9f, 0xea, 0xe5, 0x62, 0x54, 0x86, 0x01, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65,
0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0b, 0x0e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6f, 0x27,
0xd7, 0xa2, 0xbc, 0x9e, 0x07, 0x6a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6f, 0x27, 0xd7, 0xa2,
0xbc, 0x9e, 0x07, 0x6a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x10, 0x1a, 0x84, 0xb7, 0xa8, 0xe6,
0x4e, 0xb3, 0xf2, 0x3c, 0x60, 0x98, 0x7c, 0x26, 0xe6, 0xaf, 0x1d, 0xa4,
0xdd, 0x4c, 0x3a, 0x8a, 0x3d, 0x73, 0xe7, 0x31, 0x59, 0x76, 0xe0, 0x3d,
0x11, 0x4e, 0xb1, 0x73, 0xc5, 0x3f, 0x75, 0x8c, 0x55, 0x8e, 0xed, 0xd7,
0x20, 0x0d, 0xcd, 0xb9, 0x4c, 0xef, 0x18, 0x26, 0x66, 0x6f, 0x6f, 0x31,
0xaf, 0x9e, 0x08, 0x8d, 0x13, 0x1a, 0x15, 0x8f, 0x38, 0x43, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xde, 0x64, 0xf9,
0xa0, 0x36, 0x7d, 0x5d, 0x2f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0xd8, 0x81, 0x82, 0x98, 0x65, 0xd8, 0xa4, 0x1a, 0x00, 0x27, 0x9e,
0x9e, 0xd8, 0xa4, 0x1a, 0x00, 0x25, 0xb2, 0x87, 0xd8, 0xa4, 0x1a, 0x00,
0x24, 0xd5, 0x47, 0xd8, 0xa4, 0x1a, 0x00, 0x27, 0xdb, 0x5b, 0xd8, 0xa4,
0x1a, 0x00, 0x59, 0xff, 0x6b, 0xd8, 0xa4, 0x1a, 0x00, 0x15, 0xdf, 0xa6,
0xd8, 0xa4, 0x1a, 0x00, 0x2b, 0x76, 0xfd, 0xd8, 0xa4, 0x1a, 0x00, 0x26,
0xbb, 0x91, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0x82, 0x52, 0xd8, 0xa4, 0x1a,
0x00, 0x5a, 0xbc, 0x14, 0xd8, 0xa4, 0x1a, 0x00, 0x40, 0xcc, 0x9a, 0xd8,
0xa4, 0x1a, 0x00, 0x3d, 0x9c, 0xf5, 0xd8, 0xa4, 0x1a, 0x00, 0x59, 0x25,
0xba, 0xd8, 0xa4, 0x1a, 0x00, 0x30, 0x1c, 0xf2, 0xd8, 0xa4, 0x1a, 0x00,
0x33, 0x53, 0x59, 0xd8, 0xa4, 0x1a, 0x00, 0x41, 0x4d, 0x86, 0xd8, 0xa4,
0x1a, 0x00, 0x68, 0x5b, 0x05, 0xd8, 0xa4, 0x1a, 0x00, 0x5e, 0x14, 0x83,
0xd8, 0xa4, 0x1a, 0x00, 0x68, 0x3d, 0xde, 0xd8, 0xa4, 0x1a, 0x00, 0x43,
0xa9, 0x13, 0xd8, 0xa4, 0x1a, 0x00, 0x43, 0xf1, 0x40, 0xd8, 0xa4, 0x1a,
0x00, 0x5d, 0x57, 0xdd, 0xd8, 0xa4, 0x1a, 0x00, 0x6f, 0x5a, 0x15, 0xd8,
0xa4, 0x1a, 0x00, 0x6e, 0x41, 0x3c, 0xd8, 0xa4, 0x1a, 0x00, 0x5d, 0x6a,
0xda, 0xd8, 0xa4, 0x1a, 0x00, 0x68, 0x52, 0x6a, 0xd8, 0xa4, 0x1a, 0x00,
0x5a, 0xc5, 0x14, 0xd8, 0xa4, 0x1a, 0x00, 0x2c, 0x1d, 0x96, 0xd8, 0xa4,
0x1a, 0x00, 0x68, 0x68, 0xd0, 0xd8, 0xa4, 0x1a, 0x00, 0x34, 0x16, 0x6d,
0xd8, 0xa4, 0x1a, 0x00, 0x6f, 0x54, 0x2c, 0xd8, 0xa4, 0x1a, 0x00, 0x78,
0x94, 0xff, 0xd8, 0xa4, 0x1a, 0x00, 0x34, 0x57, 0xf3, 0xd8, 0xa4, 0x1a,
0x00, 0x24, 0xdc, 0xe7, 0xd8, 0xa4, 0x1a, 0x00, 0x78, 0xa4, 0x1d, 0xd8,
0xa4, 0x1a, 0x00, 0x0d, 0x43, 0x9f, 0xd8, 0xa4, 0x1a, 0x00, 0x66, 0xf6,
0x14, 0xd8, 0xa4, 0x1a, 0x00, 0x31, 0x5d, 0x56, 0xd8, 0xa4, 0x1a, 0x00,
0x7d, 0x6c, 0xf9, 0xd8, 0xa4, 0x1a, 0x00, 0x7d, 0xdb, 0x9b, 0xd8, 0xa4,
0x1a, 0x00, 0x6a, 0xac, 0x51, 0xd8, 0xa4, 0x1a, 0x00, 0x78, 0x25, 0x4e,
0xd8, 0xa4, 0x1a, 0x00, 0x79, 0x6f, 0x7a, 0xd8, 0xa4, 0x1a, 0x00, 0x5d,
0x5f, 0x2c, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0x4c, 0xc4, 0xd8, 0xa4, 0x1a,
0x00, 0x80, 0xaa, 0x45, 0xd8, 0xa4, 0x1a, 0x00, 0x78, 0x7a, 0x4c, 0xd8,
0xa4, 0x1a, 0x00, 0x47, 0x8c, 0x89, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x1f,
0x99, 0xd8, 0xa4, 0x1a, 0x00, 0x78, 0xae, 0x0a, 0xd8, 0xa4, 0x1a, 0x00,
0x78, 0x26, 0xb4, 0xd8, 0xa4, 0x1a, 0x00, 0x6e, 0x38, 0xe0, 0xd8, 0xa4,
0x1a, 0x00, 0x79, 0xcc, 0x23, 0xd8, 0xa4, 0x1a, 0x00, 0x73, 0x31, 0x93,
0xd8, 0xa4, 0x1a, 0x00, 0x79, 0x7a, 0x4e, 0xd8, 0xa4, 0x1a, 0x00, 0x68,
0x29, 0x43, 0xd8, 0xa4, 0x1a, 0x00, 0x5d, 0x8e, 0x45, 0xd8, 0xa4, 0x1a,
0x00, 0x6e, 0x33, 0x5a, 0xd8, 0xa4, 0x1a, 0x00, 0x4a, 0x29, 0xa6, 0xd8,
0xa4, 0x1a, 0x00, 0x67, 0xe0, 0xdf, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0xb1,
0x31, 0xd8, 0xa4, 0x1a, 0x00, 0x0f, 0x3f, 0x18, 0xd8, 0xa4, 0x1a, 0x00,
0x18, 0x0c, 0x10, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xd4, 0x55, 0xd8, 0xa4,
0x1a, 0x00, 0x81, 0x14, 0xc8, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x48, 0x65,
0xd8, 0xa4, 0x1a, 0x00, 0x40, 0xe2, 0x50, 0xd8, 0xa4, 0x1a, 0x00, 0x8e,
0xc6, 0x0a, 0xd8, 0xa4, 0x1a, 0x00, 0x09, 0x2e, 0x84, 0xd8, 0xa4, 0x1a,
0x00, 0x49, 0x00, 0x0e, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0x06, 0xff, 0xd8,
0xa4, 0x1a, 0x00, 0x81, 0x0b, 0xec, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x8b,
0xdf, 0xd8, 0xa4, 0x1a, 0x00, 0x74, 0xe1, 0x72, 0xd8, 0xa4, 0x1a, 0x00,
0x3b, 0x23, 0x28, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0xa3, 0x6f, 0xd8, 0xa4,
0x1a, 0x00, 0x6a, 0x1f, 0x42, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x39, 0x81,
0xd8, 0xa4, 0x1a, 0x00, 0x98, 0x95, 0x39, 0xd8, 0xa4, 0x1a, 0x00, 0x7f,
0xa0, 0xf4, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xaf, 0xb8, 0xd8, 0xa4, 0x1a,
0x00, 0x8b, 0x90, 0xe2, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0x5c, 0x1a, 0xd8,
0xa4, 0x1a, 0x00, 0x62, 0x32, 0xdb, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x31,
0x77, 0xd8, 0xa4, 0x1a, 0x00, 0xa8, 0xfa, 0xb2, 0xd8, 0xa4, 0x1a, 0x00,
0x9e, 0x0e, 0x14, 0xd8, 0xa4, 0x1a, 0x00, 0xa2, 0xf3, 0x4e, 0xd8, 0xa4,
0x1a, 0x00, 0x40, 0xce, 0x07, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x4c, 0xbd,
0xd8, 0xa4, 0x1a, 0x00, 0x5f, 0xc3, 0x90, 0xd8, 0xa4, 0x1a, 0x00, 0xae,
0x18, 0xa2, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0x31, 0x9e, 0xd8, 0xa4, 0x1a,
0x00, 0xa9, 0xce, 0x2c, 0xd8, 0xa4, 0x1a, 0x00, 0xa6, 0x0d, 0x6b, 0xd8,
0xa4, 0x1a, 0x00, 0xa5, 0xfd, 0xa7, 0xd8, 0xa4, 0x1a, 0x00, 0x76, 0xa9,
0x27, 0xd8, 0xa4, 0x1a, 0x00, 0x2c, 0x7f, 0x91, 0xd8, 0xa4, 0x1a, 0x00,
0xab, 0x6d, 0x6c, 0xd8, 0xa4, 0x1a, 0x00, 0x4d, 0xdb, 0xe3, 0xd8, 0xa4,
0x1a, 0x00, 0x90, 0x42, 0xa4, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0x1f, 0x87, 0x80, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x28, 0x76, 0x7b, 0x3c, 0xed,
0xa7, 0x97, 0xf5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67, 0x62,
0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x03, 0x30,
0xb8, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x47, 0x9d,
0x8c, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e,
0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa3,
0x06, 0x3d, 0x8b, 0xcc, 0xfc, 0xe4, 0x41, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa3, 0x06, 0x3d,
0x8b, 0xcc, 0xfc, 0xe4, 0x41, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xf9, 0x77, 0xba, 0x13, 0x11,
0x17, 0x44, 0x98, 0xa8, 0x1a, 0xbe, 0x5e, 0xaa, 0x53, 0xd2, 0x82, 0xff,
0xf3, 0xbb, 0xb5, 0x10, 0xcf, 0x81, 0xfc, 0x94, 0xa8, 0x8e, 0x79, 0x93,
0xf8, 0x4b, 0x5e, 0xbd, 0xb1, 0xb2, 0x29, 0x3e, 0xce, 0x3a, 0x27, 0xed,
0x2a, 0xa2, 0xc8, 0xe7, 0xc4, 0xcf, 0x74, 0xcb, 0xe2, 0xf2, 0xfb, 0x99,
0xb9, 0x98, 0xb6, 0x38, 0xe3, 0x4d, 0x97, 0x4a, 0xe3, 0x41, 0xd8, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd6, 0xa6,
0xe3, 0x5c, 0x09, 0x10, 0xa2, 0x07, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x34, 0x38, 0x37, 0x38, 0x31, 0x37, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x03, 0x0a, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x4c, 0x25, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x4a,
0x6f, 0x62, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb3,
0x62, 0x3e, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xca, 0xe7, 0xcb, 0x7b,
0xf5, 0x1c, 0x0a, 0xe6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31,
0x35, 0x38, 0x32, 0x31, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x00,
0x14, 0x80, 0x57, 0xd8, 0xa4, 0x1a, 0x00, 0x17, 0x53, 0x21, 0xd8, 0xa4,
0x1a, 0x00, 0x14, 0x3e, 0xdc, 0xd8, 0xa4, 0x1a, 0x00, 0x12, 0xf2, 0xc2,
0xd8, 0xa4, 0x1a, 0x00, 0x1b, 0xbe, 0xeb, 0xd8, 0xa4, 0x1a, 0x00, 0x13,
0x4c, 0x03, 0xd8, 0xa4, 0x1a, 0x00, 0x10, 0xbd, 0xa5, 0xd8, 0xa4, 0x1a,
0x00, 0x12, 0xcb, 0x33, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0x3a, 0x3d, 0xd8,
0xa4, 0x1a, 0x00, 0x51, 0xb7, 0x42, 0xd8, 0xa4, 0x1a, 0x00, 0x37, 0x40,
0x87, 0xd8, 0xa4, 0x1a, 0x00, 0x31, 0x8d, 0x12, 0xd8, 0xa4, 0x1a, 0x00,
0x2a, 0xc1, 0x6e, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0x83, 0xc1, 0xd8, 0xa4,
0x1a, 0x00, 0x33, 0x4e, 0xbd, 0xd8, 0xa4, 0x1a, 0x00, 0x53, 0x38, 0xea,
0xd8, 0xa4, 0x1a, 0x00, 0x3a, 0x31, 0xd8, 0xd8, 0xa4, 0x1a, 0x00, 0x54,
0xda, 0xc4, 0xd8, 0xa4, 0x1a, 0x00, 0x54, 0x63, 0xdd, 0xd8, 0xa4, 0x1a,
0x00, 0x2c, 0x24, 0xfa, 0xd8, 0xa4, 0x1a, 0x00, 0x46, 0xbb, 0x8b, 0xd8,
0xa4, 0x1a, 0x00, 0x56, 0x73, 0xc0, 0xd8, 0xa4, 0x1a, 0x00, 0x25, 0x8d,
0x55, 0xd8, 0xa4, 0x1a, 0x00, 0x3b, 0x6e, 0xf6, 0xd8, 0xa4, 0x1a, 0x00,
0x51, 0x70, 0xa0, 0xd8, 0xa4, 0x1a, 0x00, 0x67, 0xd2, 0x88, 0xd8, 0xa4,
0x1a, 0x00, 0x4e, 0xc4, 0x01, 0xd8, 0xa4, 0x1a, 0x00, 0x5a, 0x21, 0xc2,
0xd8, 0xa4, 0x1a, 0x00, 0x19, 0x75, 0x30, 0xd8, 0xa4, 0x1a, 0x00, 0x12,
0x7f, 0x5e, 0xd8, 0xa4, 0x1a, 0x00, 0x42, 0x67, 0xd7, 0xd8, 0xa4, 0x1a,
0x00, 0x49, 0xe0, 0x16, 0xd8, 0xa4, 0x1a, 0x00, 0x35, 0x12, 0xd9, 0xd8,
0xa4, 0x1a, 0x00, 0x67, 0x8e, 0x3f, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x90,
0x88, 0xd8, 0xa4, 0x1a, 0x00, 0x74, 0xac, 0x3a, 0xd8, 0xa4, 0x1a, 0x00,
0x24, 0x24, 0xe0, 0xd8, 0xa4, 0x1a, 0x00, 0x50, 0x9c, 0xbf, 0xd8, 0xa4,
0x1a, 0x00, 0x12, 0xf1, 0xbd, 0xd8, 0xa4, 0x1a, 0x00, 0x91, 0xab, 0x0e,
0xd8, 0xa4, 0x1a, 0x00, 0x2a, 0x05, 0x93, 0xd8, 0xa4, 0x1a, 0x00, 0x42,
0x0a, 0xca, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0x07, 0x46, 0xd8, 0xa4, 0x1a,
0x00, 0x3b, 0x03, 0x08, 0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0x0b, 0x7a, 0xd8,
0xa4, 0x1a, 0x00, 0x6c, 0xa7, 0x7a, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x74,
0xb6, 0xd8, 0xa4, 0x1a, 0x00, 0x6d, 0xcd, 0x51, 0xd8, 0xa4, 0x1a, 0x00,
0x51, 0xef, 0x7d, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0x2e, 0xe7, 0xd8, 0xa4,
0x1a, 0x00, 0x7c, 0x59, 0x3c, 0xd8, 0xa4, 0x1a, 0x00, 0x52, 0x36, 0x50,
0xd8, 0xa4, 0x1a, 0x00, 0x7c, 0x21, 0x93, 0xd8, 0xa4, 0x1a, 0x00, 0x7a,
0x6e, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0xd2, 0xde, 0xd8, 0xa4, 0x1a,
0x00, 0x87, 0xae, 0x0d, 0xd8, 0xa4, 0x1a, 0x00, 0x43, 0x4c, 0xad, 0xd8,
0xa4, 0x1a, 0x00, 0x93, 0xcf, 0xd9, 0xd8, 0xa4, 0x1a, 0x00, 0x93, 0x75,
0x8a, 0xd8, 0xa4, 0x1a, 0x00, 0xa1, 0x85, 0xe1, 0xd8, 0xa4, 0x1a, 0x00,
0xa9, 0x82, 0x2f, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xb3, 0x78, 0xd8, 0xa4,
0x1a, 0x00, 0x82, 0xa5, 0x38, 0xd8, 0xa4, 0x1a, 0x00, 0x91, 0xb6, 0x21,
0xd8, 0xa4, 0x1a, 0x00, 0x92, 0xc8, 0xdb, 0xd8, 0xa4, 0x1a, 0x00, 0x91,
0xf8, 0x9f, 0xd8, 0xa4, 0x1a, 0x00, 0x93, 0x0c, 0xb2, 0xd8, 0xa4, 0x1a,
0x00, 0x92, 0x4d, 0xc5, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x90, 0xfa, 0xd8,
0xa4, 0x1a, 0x00, 0x7a, 0xe5, 0x26, 0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0x5e,
0x18, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0xcb, 0xb0, 0xd8, 0xa4, 0x1a, 0x00,
0x7d, 0x95, 0xbd, 0xd8, 0xa4, 0x1a, 0x00, 0xaf, 0xa2, 0xc6, 0xd8, 0xa4,
0x1a, 0x00, 0x51, 0x38, 0x04, 0xd8, 0xa4, 0x1a, 0x00, 0xa7, 0xb0, 0x61,
0xd8, 0xa4, 0x1a, 0x00, 0x94, 0x56, 0x38, 0xd8, 0xa4, 0x1a, 0x00, 0x45,
0xea, 0x37, 0xd8, 0xa4, 0x1a, 0x00, 0x69, 0xb5, 0xf8, 0xd8, 0xa4, 0x1a,
0x00, 0xb4, 0xd1, 0x27, 0xd8, 0xa4, 0x1a, 0x00, 0xb7, 0x88, 0xf2, 0xd8,
0xa4, 0x1a, 0x00, 0xbb, 0x28, 0xc7, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x09,
0xe3, 0xd8, 0xa4, 0x1a, 0x00, 0x2a, 0xca, 0xe6, 0xd8, 0xa4, 0x1a, 0x00,
0x95, 0x02, 0xf9, 0xd8, 0xa4, 0x1a, 0x00, 0x96, 0xf7, 0xf4, 0xd8, 0xa4,
0x1a, 0x00, 0xc8, 0xeb, 0x91, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0x72, 0x1a,
0xd8, 0xa4, 0x1a, 0x00, 0xbf, 0xaf, 0x49, 0xd8, 0xa4, 0x1a, 0x00, 0xc8,
0xfd, 0xb9, 0xd8, 0xa4, 0x1a, 0x00, 0xae, 0x25, 0x8e, 0xd8, 0xa4, 0x1a,
0x00, 0x4f, 0x68, 0x99, 0xd8, 0xa4, 0x1a, 0x00, 0x73, 0xf8, 0xf8, 0xd8,
0xa4, 0x1a, 0x00, 0xc5, 0x97, 0x88, 0xd8, 0xa4, 0x1a, 0x00, 0xd9, 0xa8,
0xfe, 0xd8, 0xa4, 0x1a, 0x00, 0x2d, 0x7b, 0x2a, 0xd8, 0xa4, 0x1a, 0x00,
0xa0, 0x71, 0x8f, 0xd8, 0xa4, 0x1a, 0x00, 0xdf, 0x9d, 0xc5, 0xd8, 0xa4,
0x1a, 0x00, 0xc9, 0xd3, 0xe1, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xa4, 0x25,
0xd8, 0xa4, 0x1a, 0x00, 0xca, 0x16, 0x5a, 0xd8, 0xa4, 0x1a, 0x00, 0xcb,
0xb7, 0xcd, 0xd8, 0xa4, 0x1a, 0x00, 0xcb, 0x2d, 0x15, 0xd8, 0xa4, 0x1a,
0x00, 0xcb, 0x72, 0xd4, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xe6, 0xf9, 0xd8,
0xa4, 0x1a, 0x00, 0xd7, 0x94, 0xa0, 0xd8, 0xa4, 0x1a, 0x00, 0xcc, 0x0b,
0xaa, 0xd8, 0xa4, 0x1a, 0x00, 0x9b, 0xf7, 0x03, 0xd8, 0xa4, 0x1a, 0x00,
0x4b, 0xdf, 0xbe, 0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0x22, 0x3e, 0xd8, 0xa4,
0x1a, 0x00, 0x4b, 0xac, 0x9a, 0xd8, 0xa4, 0x1a, 0x00, 0x28, 0x7b, 0x10,
0xd8, 0xa4, 0x1a, 0x00, 0x28, 0x9a, 0x07, 0xd8, 0xa4, 0x1a, 0x00, 0x28,
0xde, 0x92, 0xd8, 0xa4, 0x1a, 0x00, 0xcc, 0x36, 0x18, 0xd8, 0xa4, 0x1a,
0x00, 0x17, 0x9b, 0x0e, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x6a, 0x00, 0x44, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x59, 0x5d, 0x00, 0x25, 0x31, 0xf4,
0x75, 0x32, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x14, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x91, 0xc9, 0x42, 0xfd, 0x73, 0x0d, 0xaa, 0xbe, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x91, 0xc9, 0x42, 0xfd, 0x73, 0x0d, 0xaa, 0xbe, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xbc,
0x8d, 0x4b, 0x53, 0xc7, 0x0d, 0x78, 0xa6, 0xbd, 0x38, 0x7e, 0x7c, 0x2b,
0xbf, 0xf3, 0x29, 0x16, 0xd4, 0xad, 0x0d, 0x99, 0x54, 0xb8, 0x30, 0x95,
0x53, 0xd8, 0xa8, 0xe5, 0x3d, 0xeb, 0x49, 0x6f, 0x34, 0x45, 0xa2, 0x3b,
0x41, 0xe4, 0x22, 0xc1, 0x63, 0x3c, 0x84, 0x1f, 0xc2, 0xc7, 0xa9, 0x5b,
0xac, 0x51, 0x5a, 0x1b, 0x17, 0x0a, 0x63, 0xfc, 0xc5, 0xfe, 0x38, 0x4d,
0x49, 0x5d, 0x0c, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xb9, 0xd5, 0x8b, 0x4f, 0xff, 0xb6, 0x70, 0x1c, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xb9, 0xd5, 0x8b, 0x4f, 0xff, 0xb6, 0x70, 0x1c, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x57, 0x03,
0xc5, 0x08, 0xbe, 0xd2, 0xff, 0x77, 0x1d, 0x4d, 0x77, 0xf1, 0x20, 0x4b,
0x62, 0xb8, 0x0f, 0x8f, 0x21, 0xcd, 0x5f, 0xad, 0x5a, 0x64, 0x61, 0xcc,
0x61, 0xd7, 0x0c, 0x3c, 0xfc, 0x81, 0x99, 0xe1, 0xe8, 0x47, 0x27, 0x24,
0x42, 0x1a, 0x5d, 0x46, 0x93, 0x2e, 0xa7, 0x76, 0x46, 0x33, 0x92, 0x4b,
0x5e, 0xf4, 0x5a, 0xdc, 0xa0, 0x46, 0xc7, 0xdb, 0xaf, 0xc3, 0xa6, 0xed,
0x64, 0xca, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x07, 0x01, 0x86, 0xc8, 0xad, 0x5b, 0x68, 0xa3, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x30, 0x67, 0xc2,
0x37, 0x8d, 0x05, 0xc9, 0xb2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x4d, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x84, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x38, 0x27,
0x3e, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8,
0x81, 0x82, 0x80, 0x80, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x35, 0x30, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x39, 0x37,
0x33, 0x37, 0x35, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x02, 0x52, 0xc2, 0x4d, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xd5, 0x38, 0xf6, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xc6, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x1c, 0x8a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x36, 0x35, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30,
0x39, 0x36, 0x30, 0x37, 0x36, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x17, 0x5f, 0x6e, 0x80, 0x2f,
0xba, 0x17, 0x2d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x35,
0x30, 0x34, 0x37, 0x30, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x0b, 0x60, 0x81, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xaf, 0x8c, 0x3f, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x89, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x23, 0xcb, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x37, 0x38, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x31, 0x33, 0x31, 0x38, 0x36, 0x32, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x08, 0x6f, 0x35, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xac, 0xb5, 0x64, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04,
0x80, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x5a, 0x30, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbc, 0x3d, 0xcf, 0x4d,
0xb5, 0xc6, 0x5d, 0x37, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbc, 0x3d, 0xcf, 0x4d, 0xb5, 0xc6,
0x5d, 0x37, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xbb, 0xb5, 0x25, 0x32, 0x68, 0xa6, 0x40, 0x9b,
0x8c, 0xdb, 0xee, 0xf8, 0x0e, 0x96, 0x06, 0x8e, 0x5e, 0xcb, 0x31, 0x38,
0xe7, 0x0b, 0x53, 0xc5, 0x14, 0xb4, 0x44, 0xf7, 0xb5, 0x9e, 0x54, 0xf5,
0xe1, 0x7d, 0x50, 0x63, 0x7f, 0xdd, 0xed, 0x8d, 0x02, 0xf9, 0x20, 0xb8,
0x47, 0x3b, 0xca, 0xf8, 0xe0, 0x78, 0x1b, 0x6c, 0xc3, 0x04, 0xed, 0x27,
0xaf, 0x71, 0x57, 0xe0, 0x14, 0x99, 0x98, 0x14, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x04, 0xac, 0x63, 0x38, 0xee,
0x5b, 0x64, 0x01, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x24, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x36, 0x39, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x33,
0x39, 0x36, 0x39, 0x31, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x2d, 0xb6, 0x3c, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xbd, 0x29, 0x77, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xa7, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x6d, 0x43, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9c, 0xdc, 0x57, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0xcf, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26, 0xd2,
0x78, 0x18, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63,
0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x65, 0x72, 0xf6, 0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x01, 0xb3, 0x48,
0x87, 0x65, 0x82, 0x21, 0xf5, 0xd8, 0xc8, 0x82, 0x02, 0x71, 0x66, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4,
0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc,
0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62,
0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e,
0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52,
0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x35, 0x5c, 0x01, 0x78, 0x22, 0x50, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xb5, 0x18, 0x18, 0xfc, 0xf8, 0xb5, 0x8f, 0xa3, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb5,
0x18, 0x18, 0xfc, 0xf8, 0xb5, 0x8f, 0xa3, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e,
0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x61, 0x50, 0x94, 0x4a, 0x56, 0xdf, 0x55, 0xe3, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x59, 0x01,
0xd3, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x98, 0x39, 0xd8,
0xa4, 0x1a, 0x00, 0x11, 0x87, 0x2e, 0xd8, 0xa4, 0x1a, 0x00, 0x0d, 0x1f,
0xd1, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0x07, 0x14, 0xd8, 0xa4, 0x1a, 0x00,
0x0e, 0x4f, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x04, 0xc9, 0x36, 0xd8, 0xa4,
0x19, 0x77, 0x7e, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0x67, 0x55, 0xd8, 0xa4,
0x1a, 0x00, 0x09, 0x90, 0x32, 0xd8, 0xa4, 0x1a, 0x00, 0x18, 0xf4, 0xf2,
0xd8, 0xa4, 0x1a, 0x00, 0x1a, 0x3a, 0x8a, 0xd8, 0xa4, 0x1a, 0x00, 0x07,
0x78, 0x63, 0xd8, 0xa4, 0x1a, 0x00, 0x08, 0x71, 0x63, 0xd8, 0xa4, 0x1a,
0x00, 0x01, 0xe1, 0x18, 0xd8, 0xa4, 0x1a, 0x00, 0x08, 0x2c, 0x66, 0xd8,
0xa4, 0x1a, 0x00, 0x02, 0x0c, 0x56, 0xd8, 0xa4, 0x1a, 0x00, 0x23, 0xa1,
0x6f, 0xd8, 0xa4, 0x1a, 0x00, 0x25, 0x29, 0x77, 0xd8, 0xa4, 0x1a, 0x00,
0x26, 0x56, 0x5c, 0xd8, 0xa4, 0x1a, 0x00, 0x20, 0x18, 0xea, 0xd8, 0xa4,
0x1a, 0x00, 0x08, 0x66, 0xa3, 0xd8, 0xa4, 0x1a, 0x00, 0x05, 0x11, 0x61,
0xd8, 0xa4, 0x19, 0x67, 0x05, 0xd8, 0xa4, 0x1a, 0x00, 0x1c, 0xdc, 0x11,
0xd8, 0xa4, 0x1a, 0x00, 0x09, 0x07, 0x02, 0xd8, 0xa4, 0x1a, 0x00, 0x24,
0xca, 0x0c, 0xd8, 0xa4, 0x1a, 0x00, 0x26, 0x51, 0x2e, 0xd8, 0xa4, 0x1a,
0x00, 0x05, 0xbc, 0xd1, 0xd8, 0xa4, 0x1a, 0x00, 0x03, 0xd4, 0x82, 0xd8,
0xa4, 0x19, 0x6e, 0x64, 0xd8, 0xa4, 0x19, 0x5f, 0x8d, 0xd8, 0xa4, 0x1a,
0x00, 0x1a, 0xee, 0x3f, 0xd8, 0xa4, 0x1a, 0x00, 0x0a, 0xe7, 0x48, 0xd8,
0xa4, 0x1a, 0x00, 0x2b, 0x73, 0x50, 0xd8, 0xa4, 0x1a, 0x00, 0x21, 0xab,
0x7b, 0xd8, 0xa4, 0x19, 0xed, 0xa8, 0xd8, 0xa4, 0x1a, 0x00, 0x08, 0xd0,
0x41, 0xd8, 0xa4, 0x1a, 0x00, 0x07, 0x78, 0x07, 0xd8, 0xa4, 0x1a, 0x00,
0x07, 0x78, 0x22, 0xd8, 0xa4, 0x1a, 0x00, 0x02, 0x48, 0x06, 0xd8, 0xa4,
0x1a, 0x00, 0x10, 0xea, 0x46, 0xd8, 0xa4, 0x1a, 0x00, 0x5f, 0x65, 0x81,
0xd8, 0xa4, 0x1a, 0x00, 0x91, 0x61, 0xcd, 0xd8, 0xa4, 0x1a, 0x00, 0x88,
0xc4, 0x7f, 0xd8, 0xa4, 0x1a, 0x00, 0x07, 0xb4, 0xb2, 0xd8, 0xa4, 0x1a,
0x00, 0x78, 0x10, 0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0x96, 0xf7, 0x48, 0xd8,
0xa4, 0x1a, 0x00, 0x5d, 0xac, 0x8f, 0xd8, 0xa4, 0x1a, 0x00, 0x9f, 0x65,
0x70, 0xd8, 0xa4, 0x1a, 0x00, 0xba, 0xfa, 0x15, 0xd8, 0xa4, 0x1a, 0x00,
0xb2, 0xda, 0x4a, 0xd8, 0xa4, 0x1a, 0x00, 0xd1, 0xa7, 0x1a, 0xd8, 0xa4,
0x1a, 0x00, 0xd6, 0xe0, 0x95, 0xd8, 0xa4, 0x1a, 0x00, 0x9c, 0x7c, 0x43,
0xd8, 0xa4, 0x1a, 0x00, 0xdf, 0x88, 0x9b, 0xd8, 0xa4, 0x1a, 0x00, 0xdd,
0x41, 0xa8, 0xd8, 0xa4, 0x1a, 0x00, 0x15, 0xd4, 0xcd, 0xd8, 0xa4, 0x1a,
0x00, 0x15, 0xd4, 0xc9, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x1c, 0x43, 0x09, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x37, 0x37, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34,
0x35, 0x39, 0x37, 0x36, 0x37, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xea, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2e, 0xd8, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x46, 0x27,
0xad, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xae, 0x9e,
0x72, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb9, 0x5a, 0x4c, 0x92, 0x0d,
0x6a, 0x54, 0xf6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53,
0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x37,
0x39, 0x35, 0x33, 0x31, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x03, 0xc7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x21, 0x0d, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x34, 0xb2,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xa0, 0xec, 0xb1,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xec, 0xdb, 0x34, 0xc3, 0xe1, 0xd1,
0x80, 0xc8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xb6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x5a, 0xe2, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x67, 0xbd,
0x08, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x0d, 0xe0,
0x56, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa9, 0x8e, 0xe0, 0xdc, 0x82,
0x42, 0x46, 0x92, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53,
0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31,
0x36, 0x33, 0x34, 0x35, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9a, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x02, 0xab, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x71, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x30, 0x45, 0x43, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0xe5, 0x86, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x5c, 0xe3, 0xa2, 0x66, 0x58, 0x5f, 0x05,
0x44, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x35, 0x37, 0x38, 0x34,
0x30, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xe5,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x81, 0x11, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x55, 0x1e, 0xa4, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0x68, 0x4e, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xc5, 0x43, 0xde, 0x09, 0x69, 0xc5, 0x1f, 0x29, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x31, 0x39, 0x31, 0x33, 0x31,
0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0xf0, 0x59, 0x9a, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x9b,
0x81, 0xd3, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x23, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x20,
0xdf, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x39, 0x38, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x33, 0x35, 0x38,
0x39, 0x39, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x88, 0xe5, 0xab, 0x7e, 0xb3, 0x90, 0xda, 0xf8,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x88, 0xe5, 0xab, 0x7e, 0xb3, 0x90, 0xda, 0xf8, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40,
0x6f, 0x08, 0x8f, 0x03, 0xea, 0xe1, 0x44, 0xfb, 0x12, 0x55, 0xb8, 0xe2,
0xcc, 0x3c, 0xba, 0x41, 0xf9, 0xd6, 0xca, 0x1f, 0xbe, 0xa4, 0xc0, 0x5f,
0xd9, 0xa7, 0x9c, 0xcb, 0x45, 0x8d, 0x0c, 0xa1, 0xed, 0x18, 0x31, 0x03,
0x9f, 0x2b, 0x28, 0x49, 0x9c, 0x16, 0x51, 0xe0, 0x79, 0xae, 0xac, 0x5a,
0x04, 0xcb, 0xb2, 0xb8, 0xe2, 0x8b, 0x55, 0xa7, 0x0b, 0xce, 0xb3, 0xda,
0xe3, 0x70, 0x99, 0xea, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x01, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x35, 0x33, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31,
0x35, 0x35, 0x33, 0x31, 0x35, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x20, 0x32, 0xd7, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xb0, 0x49, 0x81, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x8b,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x0c, 0x85, 0x72, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xbd, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x15, 0xea, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x31, 0x7f, 0xb4, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xe9, 0x62, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x75, 0x9e, 0x4b, 0xf5, 0x78, 0xa2, 0x5e, 0x66, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x75,
0x9e, 0x4b, 0xf5, 0x78, 0xa2, 0x5e, 0x66, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x1b, 0xee,
0xfd, 0x41, 0xed, 0xfb, 0xe5, 0xa8, 0x57, 0xb9, 0x42, 0x3e, 0x2d, 0xb7,
0x68, 0xea, 0xc2, 0xff, 0x5b, 0x2c, 0x14, 0x60, 0x4d, 0x80, 0xd5, 0x95,
0x0c, 0x96, 0x27, 0x02, 0x16, 0xec, 0x76, 0xdc, 0xa4, 0x2e, 0xae, 0xf6,
0x38, 0x98, 0xe6, 0x8a, 0x8a, 0x5f, 0x2a, 0x75, 0x9d, 0x4a, 0x76, 0x8e,
0x8d, 0x52, 0x6d, 0xab, 0xff, 0x0c, 0x5a, 0x60, 0xbe, 0x29, 0xf2, 0xbd,
0x86, 0xca, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x36, 0x31, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x31, 0x38, 0x36, 0x38, 0x36,
0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xb0, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x7a, 0x9c, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x7c, 0xeb, 0xf2, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x97, 0x78, 0xb5, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x0f, 0xc8, 0x00, 0x63, 0x97, 0x9c, 0xeb, 0x94, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x0f, 0xc8, 0x00, 0x63, 0x97, 0x9c, 0xeb, 0x94, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0xc1, 0xc2,
0x82, 0xee, 0x67, 0x3b, 0x5a, 0x31, 0x03, 0x68, 0xd3, 0xc2, 0xe9, 0x2a,
0x06, 0xee, 0x8d, 0x6f, 0x47, 0x3c, 0x16, 0x58, 0x48, 0xf2, 0x3a, 0x69,
0x86, 0x4d, 0x15, 0x5d, 0x9b, 0xc5, 0xaa, 0xb7, 0xff, 0x96, 0xda, 0xe0,
0x70, 0x2e, 0xd7, 0xea, 0x06, 0x32, 0x8e, 0x56, 0x0a, 0xd0, 0x9b, 0xd8,
0x06, 0x9c, 0x7a, 0x89, 0x18, 0xc5, 0xb8, 0x7f, 0xab, 0xc3, 0xb4, 0xf3,
0x6c, 0x06, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xa0, 0xc8, 0x94, 0x28, 0x32, 0x83, 0xd9, 0x22, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x30, 0x39, 0x33, 0x32, 0x35, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x97, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x51, 0xa9, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x2f, 0x33, 0x03, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0x27, 0x3a, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xaf, 0x60, 0xfd, 0xa2, 0x3b, 0xda, 0x7f, 0x1c, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xaf,
0x60, 0xfd, 0xa2, 0x3b, 0xda, 0x7f, 0x1c, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x3e, 0x47, 0xeb,
0x98, 0xb0, 0x59, 0x93, 0x4f, 0xb8, 0x54, 0x30, 0xc7, 0xe4, 0xeb, 0x84,
0x7c, 0x87, 0x0f, 0x0f, 0x74, 0xdd, 0xc9, 0x64, 0xaa, 0xa5, 0xee, 0xc2,
0xa1, 0xfb, 0x45, 0xce, 0x02, 0x12, 0x07, 0xe0, 0xa9, 0x9f, 0x7f, 0x08,
0x84, 0xe9, 0x8c, 0xaf, 0xca, 0x6b, 0xb7, 0x84, 0x64, 0x49, 0xa6, 0xaf,
0x13, 0xa9, 0xba, 0x45, 0x2c, 0x0e, 0xd9, 0x7c, 0x19, 0xb9, 0x18, 0x5b,
0xb4, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xd5, 0xbb, 0x28, 0x19, 0x4f, 0xdb, 0x66, 0x28, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd5, 0xbb,
0x28, 0x19, 0x4f, 0xdb, 0x66, 0x28, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x85, 0xf6, 0xbc, 0x78,
0xf6, 0x2d, 0xc1, 0x38, 0xfc, 0x71, 0x45, 0xf0, 0x9c, 0xf9, 0x32, 0xe2,
0x2f, 0x1a, 0x94, 0x07, 0x50, 0x26, 0x69, 0xb4, 0x68, 0x8d, 0x4f, 0x8e,
0x09, 0x73, 0x66, 0xb1, 0x1d, 0x08, 0x69, 0x0a, 0xa0, 0xff, 0xe8, 0x25,
0x3a, 0x0e, 0x8e, 0xc3, 0x1e, 0x15, 0xb9, 0x86, 0xdb, 0x6d, 0x81, 0x73,
0x26, 0x58, 0x23, 0x54, 0x25, 0xe3, 0xa2, 0x48, 0xbb, 0xd6, 0xf6, 0xbc,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc6,
0x50, 0x30, 0xbb, 0x88, 0x15, 0x37, 0x21, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc6, 0x50, 0x30,
0xbb, 0x88, 0x15, 0x37, 0x21, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xf5, 0xa2, 0x30, 0x87, 0xec,
0x7d, 0x5d, 0xbc, 0xee, 0x3e, 0xcc, 0xc1, 0xfc, 0x5c, 0x0d, 0x91, 0xce,
0xf7, 0xfe, 0x2c, 0x43, 0x7f, 0x67, 0xf5, 0x3b, 0x10, 0x6f, 0x80, 0x0e,
0xd8, 0x2c, 0x5f, 0xa5, 0x08, 0xa7, 0xd1, 0xa0, 0x4c, 0xea, 0x5b, 0xfa,
0x7f, 0x3a, 0x6a, 0x51, 0x36, 0x2d, 0x92, 0xc2, 0x90, 0xf9, 0xcc, 0xf4,
0x64, 0x57, 0x41, 0xf4, 0x1f, 0x39, 0x20, 0x5f, 0xa9, 0x05, 0x62, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x36, 0x38, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x31, 0x35, 0x33, 0x30, 0x36,
0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x02, 0x55, 0x9b, 0x91, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xd7,
0xf5, 0x6c, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xca, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x68,
0x00, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xb3, 0x39, 0x14, 0x0c, 0x6a, 0x66, 0xd6, 0x62, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xb3, 0x39, 0x14, 0x0c, 0x6a, 0x66, 0xd6, 0x62, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75,
0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x8f, 0x05, 0xd1, 0x7e, 0x03, 0x6e, 0xcb, 0xdf,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x8f, 0x05, 0xd1, 0x7e, 0x03, 0x6e, 0xcb, 0xdf, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40,
0x0f, 0xa2, 0x6d, 0x21, 0x16, 0x48, 0x4d, 0xc4, 0xf9, 0x0d, 0x3a, 0x11,
0xa7, 0xf5, 0xa3, 0x27, 0xbb, 0x17, 0x31, 0x80, 0x0e, 0x72, 0x27, 0xfb,
0xdb, 0x6d, 0xd2, 0xf7, 0x1a, 0x9a, 0x62, 0x78, 0x9c, 0x53, 0x1b, 0x0e,
0xb9, 0x03, 0xc9, 0x9c, 0x4a, 0x26, 0x55, 0x3e, 0x0b, 0xca, 0x03, 0x41,
0xa1, 0x78, 0xf0, 0xe9, 0x1a, 0x41, 0x58, 0xe0, 0xb1, 0x21, 0x31, 0xf4,
0x69, 0x70, 0xc3, 0xcd, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x01, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x6c, 0xbb, 0x10, 0x25, 0x59, 0xa9, 0xf1,
0x0a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2b, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x31, 0x31, 0x36, 0x33,
0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x99, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x09, 0x1a, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x02, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x07, 0xce, 0x97, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x06, 0x9c, 0x70, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x20, 0xbd, 0xe9, 0xe8, 0x6e, 0xf8, 0x6e, 0xcf, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x31, 0x30, 0x38, 0x37, 0x33, 0x39, 0x31, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x04, 0xcd,
0xab, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa9, 0x2e, 0x1f, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0x78, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0b, 0x23, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc0,
0x8c, 0xfe, 0x9b, 0x1f, 0x9f, 0xab, 0xbc, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x23, 0x58, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x75, 0x7f, 0x59, 0xd5,
0x93, 0x3c, 0xdd, 0x60, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x75, 0x7f, 0x59, 0xd5, 0x93, 0x3c,
0xdd, 0x60, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b,
0xf8, 0x49, 0xb8, 0x40, 0xf1, 0xec, 0x10, 0x2e, 0x03, 0xc2, 0xad, 0xf6,
0x66, 0x78, 0x9d, 0x9b, 0x2b, 0xd7, 0x68, 0x9c, 0x89, 0x77, 0xf2, 0x09,
0xd8, 0xb2, 0x29, 0xc3, 0x9e, 0xae, 0xcb, 0x19, 0x1c, 0xcf, 0xd3, 0x16,
0x87, 0x3f, 0x1c, 0xd2, 0xa4, 0x5f, 0x8c, 0xbe, 0x7f, 0x2d, 0x16, 0x35,
0x67, 0x2f, 0x46, 0x6c, 0x6d, 0xdf, 0xc6, 0x7d, 0x00, 0x9e, 0xac, 0x22,
0xf0, 0x66, 0x47, 0x24, 0xc2, 0x9a, 0x92, 0xae, 0x02, 0x03, 0x82, 0x03,
0xe8, 0x01, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xad, 0x75, 0x6f,
0xe5, 0x3e, 0xb2, 0x26, 0xf7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35,
0x31, 0x35, 0x32, 0x39, 0x35, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xf7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x70, 0x02, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34,
0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x36, 0x35, 0x30, 0x34, 0x38, 0x39, 0x31, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x9b, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x83,
0x15, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x63, 0x41, 0xbb, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0x08, 0x20, 0x67, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x34,
0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x31, 0x30, 0x35, 0x31, 0x32, 0x39, 0x37, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x46,
0x06, 0xd6, 0x7a, 0x5d, 0x08, 0xa4, 0x35, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x32, 0x32, 0x34, 0x36, 0x33, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0x2a, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x03, 0xbe,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x22, 0x46, 0xa6, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x32, 0x84, 0x3b, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0,
0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x32,
0x35, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x34, 0x30, 0x33, 0x32, 0x31, 0x37, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x53, 0xb7,
0xde, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xd6, 0x1d, 0x2f, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0xc7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x64, 0x83, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb3,
0x4e, 0xde, 0xab, 0x04, 0x7b, 0x0a, 0x92, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x39, 0x32, 0x34, 0x32, 0x37, 0x32, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0xfb, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1a, 0x55,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x8d, 0x08, 0x62, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0xb5, 0x8a, 0xf2, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc8, 0x65, 0x8b,
0xfb, 0x04, 0x87, 0x55, 0xc2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc8, 0x65, 0x8b, 0xfb, 0x04,
0x87, 0x55, 0xc2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x24, 0xac, 0x34, 0xca, 0x4e, 0xa0, 0x6d,
0xd5, 0xcf, 0x6b, 0x46, 0x57, 0x51, 0xdd, 0xe6, 0x51, 0x5f, 0x83, 0xee,
0xed, 0xcf, 0x08, 0xf5, 0x7d, 0xde, 0xde, 0xeb, 0x8b, 0xab, 0x78, 0x09,
0xe5, 0x2e, 0x0c, 0xa3, 0xd8, 0x47, 0x12, 0xd4, 0x47, 0xcb, 0xf4, 0x04,
0xc0, 0x61, 0x70, 0x0e, 0xf5, 0x75, 0xb4, 0x95, 0x37, 0x3e, 0x56, 0x36,
0x32, 0x0f, 0x64, 0x14, 0xd0, 0x1e, 0x2c, 0xe1, 0xc2, 0x02, 0x03, 0x82,
0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x83, 0x77,
0xdb, 0x2d, 0x1a, 0xdf, 0x1e, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x83, 0x77, 0xdb, 0x2d,
0x1a, 0xdf, 0x1e, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xcb, 0x2b, 0xde, 0x43, 0x2b, 0xa0,
0x5e, 0x87, 0x7b, 0x0b, 0x15, 0xbd, 0x1e, 0x08, 0x72, 0xb3, 0xe7, 0x24,
0x9c, 0xb6, 0xae, 0x9d, 0x64, 0x77, 0x60, 0x1e, 0x88, 0xb4, 0x34, 0x04,
0x19, 0xd9, 0x0a, 0x17, 0x1b, 0x90, 0xa4, 0x3a, 0x01, 0x91, 0x26, 0xd9,
0x49, 0xa8, 0x15, 0xf7, 0xd5, 0xf6, 0x57, 0xf4, 0x26, 0x58, 0xc0, 0xf8,
0x01, 0x29, 0x8c, 0x7d, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x57, 0xdb, 0x0a, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xda, 0x22, 0xa8, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x04, 0xcf, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x62, 0xbc, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe7, 0xc6, 0x82,
0xb3, 0x0c, 0xb4, 0xe6, 0xb2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32,
0x39, 0x31, 0x30, 0x34, 0x34, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0x84, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2c, 0x0d, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2c, 0x68,
0xec, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x2c,
0xd6, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x34, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x39, 0x38, 0x37, 0x38, 0x33, 0x35, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb1, 0x81, 0xd0, 0x28,
0x3e, 0xbc, 0x01, 0x59, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb1, 0x81, 0xd0, 0x28, 0x3e, 0xbc,
0x01, 0x59, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xfd, 0x0e, 0x3a, 0xfb, 0xbe, 0x49, 0x76, 0x1f,
0x06, 0xc2, 0x79, 0x13, 0xa7, 0x53, 0x05, 0x18, 0xcb, 0x48, 0xe4, 0xc1,
0xb3, 0xdb, 0xf4, 0xe6, 0x0e, 0x76, 0xc8, 0xd7, 0x95, 0xe8, 0xee, 0x96,
0xe5, 0x8c, 0xa6, 0xfc, 0x7e, 0x75, 0x23, 0x7a, 0xdd, 0xac, 0x3a, 0x42,
0x0f, 0xcb, 0x32, 0x3f, 0xf8, 0x66, 0xc5, 0xd1, 0x65, 0xa8, 0x1b, 0xbb,
0x6c, 0x0c, 0xa9, 0x77, 0xdf, 0x8d, 0xd0, 0x02, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x33, 0x35, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x39, 0x37, 0x34, 0x31, 0x37, 0x33, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91,
0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x31, 0x34,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x36, 0x37, 0x30, 0x34, 0x32, 0x31, 0x34, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0xb1, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2a, 0x80,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x66, 0x4c, 0x56, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0x0c, 0x29, 0x4f, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x64, 0xe5, 0x09,
0x39, 0x1c, 0x9e, 0x51, 0x29, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x64, 0xe5, 0x09, 0x39, 0x1c,
0x9e, 0x51, 0x29, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x48, 0xf5, 0xf0, 0x8b, 0x87, 0xbb, 0x1f,
0xe7, 0xf2, 0x79, 0x28, 0x70, 0xf9, 0xde, 0xc7, 0x4a, 0x2a, 0x79, 0x3e,
0x47, 0xcd, 0x1c, 0xe2, 0x5c, 0x72, 0xa7, 0x9f, 0x91, 0xa8, 0x3a, 0x4d,
0x03, 0x90, 0xd6, 0xde, 0xe9, 0x96, 0x70, 0x13, 0xe8, 0xf4, 0x32, 0x23,
0xa8, 0x97, 0x2b, 0x3c, 0xa0, 0xcf, 0xe4, 0x7c, 0xf6, 0xf1, 0x8d, 0x09,
0xa9, 0x66, 0x91, 0xdb, 0xd4, 0x66, 0x20, 0xdf, 0xd1, 0x02, 0x03, 0x82,
0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe4, 0x42,
0xf2, 0x48, 0x24, 0x62, 0x6b, 0xc9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x31, 0x30, 0x36, 0x34, 0x39, 0x38, 0x37, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x04, 0x73, 0xa7, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa8, 0xd6, 0x9b, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x80, 0x80, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xf0, 0xac, 0xdc, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xbf, 0xc4, 0x95, 0x0c, 0xbc, 0xfe, 0x84, 0xe4, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf, 0xc4,
0x95, 0x0c, 0xbc, 0xfe, 0x84, 0xe4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xe9, 0x3e, 0x38, 0xdc,
0xbf, 0x90, 0x3f, 0x73, 0x08, 0x46, 0x4f, 0xad, 0x5f, 0xf2, 0xfd, 0xdc,
0xf9, 0x4d, 0x2c, 0x96, 0xd8, 0xf6, 0xcf, 0xa7, 0x82, 0x0e, 0x01, 0x74,
0x23, 0x53, 0xaa, 0x4e, 0xb5, 0xb9, 0x33, 0xea, 0x5f, 0xcf, 0xb9, 0x2b,
0x77, 0x7f, 0xd0, 0xe5, 0x76, 0x21, 0xc1, 0x61, 0x00, 0x98, 0xee, 0x30,
0xb1, 0xd3, 0x54, 0x2f, 0x12, 0x75, 0x7e, 0x8d, 0x96, 0x9f, 0xa7, 0x34,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc0,
0x2d, 0x3b, 0xe9, 0xc0, 0x18, 0x3d, 0x82, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x38, 0x33, 0x36, 0x33, 0x39, 0x35, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0xb9, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x09, 0xaa,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x7f, 0x9f, 0xb0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0x9a, 0x39, 0xfd, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0,
0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x35,
0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x30, 0x38, 0x33, 0x32, 0x31, 0x35, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x00, 0xc1,
0x4d, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x49, 0x1c, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0x6a, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1d, 0xc0, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf9,
0x7f, 0x1b, 0x84, 0x5b, 0xb5, 0xd5, 0x6e, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x33, 0x33, 0x39, 0x30, 0x31, 0x38, 0x39, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0xd6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2a, 0x5b,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x33, 0xba, 0xed, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x91, 0xe1, 0x23, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2f, 0x91, 0xda,
0xe9, 0x7d, 0x59, 0xc1, 0x99, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39,
0x37, 0x33, 0x31, 0x33, 0x33, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xde, 0xde, 0xa9, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x94, 0x7d, 0x05, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x12,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x15, 0x88, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x50, 0xd7, 0x0c, 0x6b, 0xb4,
0x31, 0x55, 0x1a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x50, 0xd7, 0x0c, 0x6b, 0xb4, 0x31, 0x55,
0x1a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x5e, 0x56, 0x16, 0x71, 0xb9, 0x39, 0x6b, 0x95, 0x0a,
0x91, 0x7c, 0x66, 0x0b, 0xe1, 0x62, 0x8b, 0xf2, 0x30, 0x96, 0xda, 0xfe,
0x2a, 0x55, 0x7c, 0xa3, 0x29, 0x3d, 0xa2, 0xea, 0x6f, 0x66, 0xe9, 0x13,
0x89, 0x12, 0x6d, 0x06, 0x30, 0x4d, 0x0a, 0x0c, 0xac, 0x03, 0x29, 0xe7,
0x7e, 0x1e, 0xe1, 0x59, 0xce, 0xb7, 0xd1, 0x9d, 0x6a, 0xec, 0x51, 0x2b,
0x1b, 0xb6, 0x02, 0x2d, 0x97, 0x89, 0xcf, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xe3, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x78, 0xc6, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x5a, 0x1f, 0x69, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcf, 0xa3, 0x30, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xb4, 0x62, 0xaa, 0x1b, 0xba, 0xa8, 0x09, 0x53, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x35, 0x39, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x38, 0x39, 0x37, 0x34, 0x30, 0x39, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x0c, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x35, 0x9c, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x4a, 0xba, 0x81, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xb3, 0xb4, 0xac, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x22,
0x41, 0x04, 0xf1, 0x0d, 0x81, 0x97, 0xec, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x8c, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0xd8, 0x81, 0x82, 0x89, 0xd8, 0xa4, 0x1a, 0x00, 0x54, 0xa7, 0x24,
0xd8, 0xa4, 0x1a, 0x00, 0x4e, 0x6b, 0x3f, 0xd8, 0xa4, 0x1a, 0x00, 0xaa,
0xaa, 0x4c, 0xd8, 0xa4, 0x1a, 0x00, 0x9d, 0x59, 0xc6, 0xd8, 0xa4, 0x1a,
0x00, 0xaa, 0xdf, 0xe0, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0xc8, 0xf1, 0xd8,
0xa4, 0x1a, 0x00, 0xb1, 0x78, 0xf3, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0x51,
0xbf, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0x47, 0xc8, 0x80, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x95, 0x32, 0x80, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33,
0x34, 0x34, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x32, 0x31, 0x35, 0x34, 0x38, 0x34, 0x34, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x29,
0xc4, 0x49, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb9, 0x77, 0xdc,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0x9e, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x22, 0xc0, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x21, 0xc3, 0x71, 0xf3, 0x84, 0xc0, 0xf0, 0xa5, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x21, 0xc3,
0x71, 0xf3, 0x84, 0xc0, 0xf0, 0xa5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x91, 0xa7, 0x5c, 0xbe,
0xb8, 0x20, 0x67, 0x80, 0x88, 0x79, 0xe1, 0xaa, 0xb3, 0x8b, 0x62, 0x99,
0xc4, 0xda, 0x49, 0x7a, 0x26, 0xaa, 0x03, 0x53, 0x9b, 0x1f, 0xcd, 0x02,
0x2c, 0x06, 0xb0, 0xae, 0xb9, 0x0a, 0xe2, 0x27, 0x76, 0xfb, 0x94, 0x1c,
0x6a, 0xa3, 0xb3, 0xf7, 0x78, 0x08, 0x40, 0x53, 0xb2, 0xab, 0x1b, 0x24,
0xbc, 0x25, 0x35, 0xbc, 0xc3, 0x12, 0x9b, 0x86, 0xcf, 0x58, 0xdf, 0x41,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe9,
0xac, 0x83, 0xf6, 0xef, 0x28, 0x2b, 0x5e, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73,
0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c,
0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x37, 0x39, 0x32, 0x30, 0x33, 0x32, 0x34, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xa4, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1e,
0x85, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x78, 0xda, 0xc4, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0x88, 0x41, 0xca, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x11,
0x90, 0x44, 0x00, 0x26, 0x15, 0xf5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x30,
0x33, 0x32, 0x35, 0x33, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x02, 0x8d, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x6e, 0x56, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x4c, 0xca, 0x53,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc0, 0x35, 0xf8,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4a, 0x58, 0x25, 0x10, 0xcb, 0xcf,
0x12, 0x23, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x31, 0x31, 0x38,
0x38, 0x33, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02,
0xe6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x10, 0xdf, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x6c, 0x9f, 0xf5, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x14, 0xbf, 0x0b, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xa4, 0x2a, 0x73, 0x40, 0x2f, 0x8b, 0x3e, 0xb8,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xa4, 0x2a, 0x73, 0x40, 0x2f, 0x8b, 0x3e, 0xb8, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0xdc, 0xfc, 0xab, 0xb9, 0xa2, 0x27, 0xbf, 0x73, 0xd3, 0xaa, 0x1a, 0x14,
0x7a, 0x53, 0x92, 0xf9, 0xdf, 0xae, 0x10, 0xc4, 0xc2, 0x65, 0x4e, 0x5a,
0xee, 0x70, 0x0e, 0xaf, 0x8c, 0x71, 0x80, 0x8e, 0x72, 0x76, 0xd4, 0xf2,
0xf8, 0x53, 0xd6, 0xb9, 0x0c, 0x03, 0x68, 0x36, 0x60, 0x43, 0x05, 0x81,
0x89, 0xba, 0x7e, 0xf3, 0x90, 0x14, 0x47, 0xc7, 0x6e, 0xf4, 0xd5, 0xfd,
0x27, 0x2b, 0x77, 0xe3, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe2, 0x42, 0x70, 0x38, 0x30, 0xb9, 0xea, 0x9b, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x66,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65,
0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67, 0x62, 0x61, 0x6c, 0x61, 0x6e,
0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x4a, 0xde, 0x6e, 0x6f, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x55, 0xfc, 0x66, 0x61,
0x72, 0x95, 0x02, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x55, 0xfc, 0x66, 0x61, 0x72, 0x95,
0x02, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x29, 0xa9, 0x4f, 0xbd, 0xbb, 0x05, 0x75, 0xd9, 0x40,
0xbb, 0x2c, 0xf2, 0x5d, 0x5f, 0x27, 0x4e, 0x48, 0x7f, 0x5d, 0xff, 0x2e,
0xc9, 0x08, 0x6c, 0x4e, 0x5c, 0x77, 0x86, 0xf1, 0x75, 0xf4, 0x91, 0xc8,
0x24, 0x7e, 0x59, 0x37, 0xce, 0xc0, 0xfc, 0x5d, 0x77, 0x27, 0xa9, 0x6c,
0x61, 0x91, 0x6a, 0xf9, 0x61, 0xa6, 0xae, 0x2b, 0x13, 0xfd, 0x04, 0xa0,
0x00, 0x87, 0xe6, 0xd2, 0x9a, 0x5c, 0xb1, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf7, 0x4e, 0x8a, 0x38, 0x7f, 0x02,
0xaf, 0x17, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xf7, 0x4e, 0x8a, 0x38, 0x7f, 0x02, 0xaf, 0x17,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x60, 0xf3, 0x4c, 0x99, 0x17, 0xbe, 0x3e, 0x3e, 0x78, 0x45,
0x6b, 0xfe, 0xed, 0x2a, 0xae, 0xa6, 0x5e, 0x12, 0x0e, 0xbe, 0xd3, 0xfc,
0x84, 0xac, 0x72, 0xe0, 0x8c, 0x4f, 0xdf, 0x16, 0x02, 0x83, 0x3e, 0x2a,
0xb5, 0x46, 0x32, 0xa6, 0x7c, 0xc1, 0x48, 0xcc, 0xf5, 0x26, 0x8f, 0x4e,
0xc6, 0x7b, 0xac, 0xbf, 0x56, 0x86, 0xb2, 0x41, 0x76, 0x1b, 0x7d, 0xd3,
0x3f, 0x10, 0x36, 0x04, 0x75, 0xcd, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc4, 0x70, 0x09, 0x10, 0xa5, 0x2f, 0x84,
0x31, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x36, 0x30, 0x37, 0x33,
0x32, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xea,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x54, 0x8c, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x46, 0x4d, 0x61, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xae, 0xca, 0x04, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x13, 0x3f, 0xa1, 0x6e, 0x04, 0x02, 0x38, 0xf4, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x13, 0x3f, 0xa1, 0x6e, 0x04, 0x02, 0x38, 0xf4, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xdf,
0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xde, 0x6e, 0x6e, 0xb6,
0xaf, 0x29, 0x29, 0x94, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65,
0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67,
0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01,
0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x39,
0x22, 0x57, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x53, 0x2c, 0x0e, 0xdb, 0x39, 0x64, 0x55, 0x78, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x18, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0xaf, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0xd8, 0x81, 0x82, 0x8e, 0xd8, 0xa4, 0x1a, 0x00, 0x33, 0x7d,
0xdb, 0xd8, 0xa4, 0x1a, 0x00, 0x42, 0x34, 0x6c, 0xd8, 0xa4, 0x1a, 0x00,
0x44, 0xc4, 0xf0, 0xd8, 0xa4, 0x1a, 0x00, 0x6d, 0x31, 0xc8, 0xd8, 0xa4,
0x1a, 0x00, 0x64, 0x14, 0xd1, 0xd8, 0xa4, 0x1a, 0x00, 0x2f, 0x63, 0x97,
0xd8, 0xa4, 0x1a, 0x00, 0x69, 0x9f, 0xdf, 0xd8, 0xa4, 0x1a, 0x00, 0x67,
0x6d, 0xa6, 0xd8, 0xa4, 0x1a, 0x00, 0x7a, 0xb3, 0x40, 0xd8, 0xa4, 0x1a,
0x00, 0x7f, 0x82, 0x9b, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0x1e, 0x3e, 0xd8,
0xa4, 0x1a, 0x00, 0x87, 0x46, 0xc3, 0xd8, 0xa4, 0x1a, 0x00, 0x6f, 0x3b,
0xfe, 0xd8, 0xa4, 0x1a, 0x00, 0x68, 0x6f, 0x4a, 0x80, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x22, 0x72, 0x3a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf6, 0x16,
0xe5, 0x10, 0xf8, 0xfc, 0xf7, 0x9b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x35, 0x38, 0x36, 0x35, 0x30, 0x35, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0xcf, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x73, 0xf9, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x59,
0x7e, 0x5c, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xce,
0xfa, 0x43, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc7, 0x9e, 0xbd, 0x6f,
0xd7, 0xcc, 0xe9, 0x63, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65,
0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67,
0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01,
0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xcf,
0xd1, 0xba, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x7b, 0x0a, 0xac, 0x24, 0x0b, 0x2b, 0xac, 0xda, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70,
0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61,
0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x37, 0x33, 0x39, 0x36, 0x32, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x09, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x25, 0xee, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x1a, 0x8b, 0x69, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x2a, 0x76, 0x25, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x46,
0x67, 0x8e, 0xa9, 0x02, 0x97, 0x38, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x35, 0x36, 0x35, 0x38, 0x33, 0x34, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0xdc, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x77, 0x07,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x54, 0xed, 0x8a, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xca, 0x31, 0xb0, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd1, 0x14, 0x19,
0x6f, 0x0f, 0xe5, 0x55, 0x5b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xed, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2c,
0x7a, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x90, 0xf4, 0xdb, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0xb9, 0x84, 0x58, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcb, 0xfc,
0xf4, 0xdd, 0xae, 0x8f, 0x62, 0x07, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcb, 0xfc, 0xf4, 0xdd,
0xae, 0x8f, 0x62, 0x07, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xae, 0x78, 0x55, 0x7e, 0xf6, 0x8c,
0x59, 0xe3, 0x18, 0x60, 0xf6, 0x59, 0x29, 0xa6, 0xf4, 0xc0, 0x64, 0x48,
0xd5, 0x16, 0x66, 0x63, 0xb3, 0x35, 0x67, 0xaa, 0x86, 0x4f, 0x19, 0x0e,
0x7a, 0x8f, 0x9e, 0xef, 0x04, 0x37, 0xac, 0x1b, 0xeb, 0xa2, 0xb1, 0x30,
0xe5, 0x56, 0xfc, 0x27, 0xb7, 0xce, 0x47, 0x03, 0x1a, 0xdc, 0xcd, 0x45,
0x8b, 0x47, 0x59, 0xa2, 0xe1, 0x94, 0x45, 0xef, 0x83, 0x4a, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xee, 0x63, 0x1e,
0x0f, 0x43, 0x30, 0xad, 0x71, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x34, 0x31, 0x34, 0x34, 0x30, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0x98, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x33, 0x0f, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x61, 0xe0,
0x45, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x06, 0x8e,
0xce, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x39, 0x38, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x34, 0x33, 0x38, 0x34, 0x36, 0x34, 0x38, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x59, 0x43, 0x13, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xdb, 0x7e, 0x08, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x04, 0xd1, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x85, 0x9c, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0xaf, 0xd3,
0xef, 0xb8, 0xfc, 0x60, 0x3b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0xaf, 0xd3, 0xef, 0xb8,
0xfc, 0x60, 0x3b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0xb2, 0xda, 0x42, 0x27, 0x30, 0xe0, 0x15,
0x6e, 0x54, 0x24, 0x82, 0x7a, 0x57, 0x9b, 0xe2, 0xff, 0x91, 0x93, 0x61,
0x27, 0xdb, 0x36, 0x4d, 0x85, 0x60, 0x89, 0xcc, 0x16, 0xa0, 0x29, 0x45,
0x91, 0x19, 0xb3, 0x86, 0x1b, 0xd2, 0xda, 0x74, 0x74, 0x4a, 0x17, 0xac,
0x30, 0x7b, 0x2d, 0xbe, 0x1a, 0x73, 0x10, 0xe1, 0x7b, 0x33, 0x13, 0x69,
0xdb, 0x80, 0x36, 0xd4, 0xc3, 0xe4, 0xaf, 0xbe, 0x08, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7e, 0x0f, 0x1f, 0x1d,
0x1f, 0xd9, 0xb7, 0x67, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7e, 0x0f, 0x1f, 0x1d, 0x1f, 0xd9,
0xb7, 0x67, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xbc, 0xf0, 0x6b, 0x7a, 0x62, 0x43, 0xb5, 0x8a,
0xbe, 0x4f, 0x77, 0xdf, 0x8a, 0x90, 0x9b, 0x70, 0x6c, 0xca, 0xd5, 0x49,
0xbc, 0xbb, 0x5a, 0xce, 0xfc, 0x22, 0x9f, 0x6e, 0x6a, 0x02, 0x7b, 0xd5,
0xcb, 0x46, 0x8e, 0xd3, 0x9d, 0x95, 0x07, 0xd0, 0xca, 0x63, 0x82, 0x28,
0x21, 0x04, 0x3d, 0x6e, 0x6a, 0x01, 0x05, 0xfb, 0xe0, 0x51, 0x23, 0xbc,
0x5b, 0x4a, 0x4a, 0xc6, 0x76, 0xff, 0x5e, 0xeb, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc5, 0xfa, 0x96, 0x83, 0x7d,
0x7f, 0xfc, 0xce, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc5, 0xfa, 0x96, 0x83, 0x7d, 0x7f, 0xfc,
0xce, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xd9, 0x83, 0xc3, 0xc7, 0x69, 0xfd, 0xc9, 0x30, 0x6b,
0xc8, 0x96, 0xf7, 0xe1, 0xa9, 0xe1, 0xb8, 0xdf, 0xa7, 0xdc, 0x9b, 0x8a,
0xac, 0x28, 0x84, 0x01, 0x6f, 0x55, 0x42, 0xf2, 0xf1, 0xe0, 0x81, 0x85,
0xbc, 0xd0, 0x20, 0xe7, 0xa2, 0xd5, 0x2d, 0xeb, 0x3a, 0xe9, 0xd0, 0xcc,
0x8a, 0x39, 0x9c, 0x53, 0x75, 0xc4, 0xce, 0x8f, 0x13, 0xf9, 0x96, 0x56,
0x9d, 0xe5, 0x1a, 0xe8, 0x3b, 0x5b, 0x0e, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x33, 0x34, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x31, 0x30, 0x36, 0x39, 0x38, 0x38, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf3, 0x91, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x33, 0x39, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x34, 0x30,
0x30, 0x36, 0x34, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x02, 0x49, 0xa7, 0x82, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xcc, 0x7a, 0x41, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xb4, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x37, 0x75, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x07, 0x8c, 0x55, 0x95, 0xbd, 0x67, 0xe1,
0xbe, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x07, 0x8c, 0x55, 0x95, 0xbd, 0x67, 0xe1, 0xbe, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x0c, 0xda, 0xc6, 0x57, 0x83, 0x71, 0x9d, 0x82, 0xf7, 0x00, 0x81,
0xe1, 0x57, 0xf9, 0x31, 0x40, 0x8a, 0xdb, 0x2a, 0x1c, 0x9f, 0xde, 0x82,
0x67, 0xbe, 0x2f, 0x7a, 0xa7, 0x7c, 0x52, 0xef, 0xdd, 0xb8, 0x3c, 0x97,
0xcf, 0x60, 0x69, 0x6e, 0xce, 0xaa, 0x38, 0xd2, 0xd0, 0x88, 0x62, 0x7b,
0xe9, 0x84, 0x04, 0x9a, 0x1f, 0xaf, 0x82, 0xfa, 0xc3, 0x47, 0x7b, 0x43,
0x0f, 0x6e, 0xcd, 0x5e, 0x4a, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xac, 0x36, 0x93, 0x0a, 0xba, 0x99, 0x28, 0x96,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xac, 0x36, 0x93, 0x0a, 0xba, 0x99, 0x28, 0x96, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0xe9, 0xed, 0x38, 0xbb, 0x6e, 0xce, 0x45, 0xa9, 0xfe, 0xa9, 0x66, 0x98,
0x7b, 0xb7, 0x92, 0x4a, 0xf3, 0x04, 0xb6, 0x06, 0xc6, 0xd6, 0xec, 0x49,
0x6f, 0xe1, 0x35, 0x8f, 0x08, 0x96, 0x16, 0x78, 0x61, 0xa2, 0x7a, 0x9f,
0x3e, 0xde, 0x7f, 0x19, 0x22, 0x4e, 0xaf, 0xc1, 0x0f, 0xc7, 0x06, 0xe7,
0xea, 0xb7, 0x08, 0x16, 0x26, 0x52, 0xd7, 0xb6, 0x06, 0xc9, 0x57, 0x3c,
0xac, 0x97, 0x31, 0x4e, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x35, 0x34, 0x33, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x33, 0x32,
0x35, 0x32, 0x39, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc6, 0xbc, 0x18, 0x52, 0xe1, 0xf6, 0x2a,
0xa9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xc6, 0xbc, 0x18, 0x52, 0xe1, 0xf6, 0x2a, 0xa9, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8,
0x40, 0xc8, 0xe2, 0x0e, 0x56, 0x0f, 0x70, 0x59, 0x74, 0xe2, 0x16, 0x23,
0xfe, 0xca, 0xfb, 0x28, 0xa5, 0xa4, 0xed, 0xe5, 0x97, 0x7a, 0xb2, 0x70,
0x8e, 0x3e, 0x23, 0xc0, 0xee, 0x1d, 0xac, 0xdb, 0xcc, 0xff, 0x56, 0x52,
0x2c, 0x1e, 0x52, 0x5e, 0x17, 0x74, 0xad, 0xfe, 0xa2, 0xdf, 0xd0, 0xed,
0x3e, 0x65, 0xbb, 0x45, 0xbf, 0x18, 0x9f, 0xbd, 0x76, 0x1c, 0x57, 0x17,
0x3e, 0x66, 0xc7, 0x85, 0x64, 0x02, 0x03, 0x82, 0x03, 0xe8, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x15, 0xf5, 0x13, 0xd2, 0x54, 0x31,
0x1e, 0x2d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x82, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x34, 0x34, 0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x32, 0x31,
0x39, 0x39, 0x34, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0xf0, 0xd9, 0x50, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x9b, 0xf1, 0xab, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x24, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x07, 0xff, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x20, 0xa8, 0x8a, 0x4a, 0x8c, 0x27, 0xa6,
0x22, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x20, 0xa8, 0x8a, 0x4a, 0x8c, 0x27, 0xa6, 0x22, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8,
0x40, 0xf6, 0x6c, 0x01, 0x19, 0xc8, 0x49, 0xd5, 0x55, 0x33, 0x96, 0xea,
0xb4, 0xed, 0xd6, 0xaf, 0x52, 0x7b, 0xcf, 0x94, 0x6c, 0xe8, 0xd7, 0xd6,
0xa8, 0x04, 0xad, 0x2f, 0x15, 0x3a, 0x35, 0xf6, 0x93, 0x04, 0x3e, 0xc9,
0x35, 0xca, 0xef, 0x53, 0x59, 0xac, 0xb2, 0x30, 0xb7, 0x26, 0xf1, 0x34,
0x59, 0x5b, 0x54, 0x3c, 0x5a, 0xcf, 0x5e, 0x8b, 0x09, 0xfa, 0x90, 0xeb,
0x76, 0x0a, 0x96, 0xb7, 0x29, 0x02, 0x03, 0x82, 0x03, 0xe8, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x56, 0xca, 0x55, 0xaa, 0xd2, 0xd3,
0x9a, 0xb6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x56, 0xca, 0x55, 0xaa, 0xd2, 0xd3, 0x9a, 0xb6,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49,
0xb8, 0x40, 0xbe, 0x61, 0xe5, 0x96, 0x62, 0xd9, 0x07, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x02, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x23, 0xfe, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x1a, 0x40, 0x39, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x26, 0xa3, 0x20, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd4,
0xcf, 0x6b, 0x65, 0x5a, 0x3a, 0xf8, 0xbf, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd4, 0xcf, 0x6b,
0x65, 0x5a, 0x3a, 0xf8, 0xbf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xab, 0xc8, 0x9f, 0x51, 0xb8,
0x7b, 0xb5, 0x00, 0x1b, 0x76, 0x7e, 0xf5, 0x85, 0x07, 0x01, 0x3e, 0xe1,
0x37, 0xaf, 0x72, 0xbd, 0xf6, 0x66, 0xa0, 0x31, 0xac, 0x26, 0xcb, 0xa9,
0x20, 0xba, 0x26, 0x5b, 0x60, 0xcd, 0x60, 0xde, 0x2c, 0xe7, 0xc4, 0x1c,
0x41, 0xe4, 0x15, 0x81, 0xc8, 0xd4, 0x68, 0xa8, 0xa1, 0xaa, 0xc3, 0xdf,
0x56, 0x65, 0x8c, 0x44, 0xc6, 0x7b, 0x67, 0x36, 0xde, 0xc2, 0xdd, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7f, 0xce,
0xcb, 0x74, 0xad, 0x42, 0x71, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x34, 0x34, 0x32, 0x38, 0x30, 0x36, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0xc8, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x53, 0x88, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x43,
0x91, 0x25, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xab,
0x75, 0x24, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x06, 0x1c, 0xf0, 0x19,
0x6a, 0xaa, 0x49, 0xcc, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x32,
0x32, 0x32, 0x32, 0x38, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x02, 0x82, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x4d, 0xf1, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x5e, 0xf1, 0xcf,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x02, 0xef, 0x76,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa5, 0x56, 0x11, 0x33, 0xd1, 0x68,
0xf7, 0xa7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x35, 0x34,
0x36, 0x33, 0x38, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x36, 0x37, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32,
0x35, 0x36, 0x32, 0x38, 0x36, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x3b, 0xc8, 0x3a, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xbf, 0xb1, 0xb3, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x77,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x95, 0xd2, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x32, 0x32, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x33, 0x39, 0x33, 0x31, 0x32, 0x37, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0x86, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x58, 0xb8, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x3b,
0xfc, 0x88, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0x64, 0x65, 0x64, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x33, 0x34, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x31, 0x37, 0x38, 0x30, 0x33, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x36, 0x37, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x35, 0x36, 0x32, 0x39, 0x32,
0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x6e, 0xfd, 0xdc, 0x7d, 0x6b, 0x5d, 0xe3, 0xe3, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x37, 0x34, 0x35, 0x33, 0x34, 0x39, 0x33, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x04, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x2e, 0xc7, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x71, 0xbb, 0x35, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0x1a, 0xeb, 0xaa, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xd1, 0x29, 0x47, 0xe0, 0x3c, 0x52, 0x1c, 0x68, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd1, 0x29,
0x47, 0xe0, 0x3c, 0x52, 0x1c, 0x68, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xdd, 0xe5, 0x1c, 0x9d,
0xc7, 0xda, 0xd4, 0xf3, 0xea, 0x72, 0x89, 0xde, 0x71, 0x22, 0xa6, 0x3c,
0x74, 0xfd, 0xcf, 0xc0, 0xcf, 0x8f, 0x56, 0x96, 0xce, 0xb4, 0x36, 0x4b,
0x48, 0x28, 0x30, 0x61, 0xa5, 0xf4, 0x16, 0x48, 0x23, 0xce, 0x23, 0x75,
0x87, 0x2e, 0x9b, 0x4a, 0x65, 0xfc, 0xf8, 0x0c, 0x5b, 0x05, 0x24, 0x97,
0xbc, 0xe6, 0xee, 0x91, 0xa5, 0xa4, 0xf7, 0x45, 0x18, 0x4e, 0x5f, 0x43,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x74,
0xde, 0x30, 0xc6, 0x14, 0xfd, 0x75, 0x52, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x31, 0x32, 0x36, 0x36, 0x35, 0x36, 0x30, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x01, 0xec, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0b, 0xcc,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x13, 0x53, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x18, 0xfb, 0x79, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x89, 0x9d, 0x95,
0xfb, 0xde, 0x7f, 0xa6, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x89, 0x9d, 0x95, 0xfb, 0xde,
0x7f, 0xa6, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0xe4, 0x33, 0x0d, 0x7e, 0x84, 0x5e, 0xe7,
0xce, 0x56, 0x9a, 0x07, 0x6e, 0xbd, 0xb5, 0x4c, 0xdc, 0x13, 0x24, 0xcb,
0x99, 0xbd, 0x4f, 0x09, 0xc0, 0x9f, 0xca, 0x1e, 0xee, 0x65, 0xc7, 0x2f,
0x27, 0x9f, 0x66, 0xc5, 0x58, 0x49, 0x9d, 0xcc, 0x97, 0x92, 0xb1, 0x00,
0x98, 0x1a, 0xe3, 0x86, 0x00, 0x86, 0x95, 0x14, 0x6c, 0x0f, 0xe5, 0x4b,
0xdc, 0xa8, 0x4d, 0xbe, 0xdf, 0x11, 0xeb, 0x68, 0x17, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xfe, 0x36, 0x1d, 0x1b,
0x12, 0xdc, 0x52, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xfe, 0x36, 0x1d, 0x1b, 0x12, 0xdc,
0x52, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0x18, 0x04, 0x77, 0xc2, 0xc1, 0xac, 0xda, 0x43,
0x81, 0xd4, 0x80, 0xa5, 0xb8, 0xe2, 0xa2, 0x7d, 0xcc, 0x5a, 0x9a, 0x1f,
0xcb, 0x44, 0x98, 0x12, 0x3e, 0x7d, 0xe2, 0xc1, 0x25, 0x7c, 0x22, 0xf7,
0xb9, 0x79, 0xcb, 0x8f, 0x3c, 0x02, 0x18, 0x54, 0x02, 0x7a, 0x1b, 0x6c,
0xb7, 0xfe, 0xbf, 0x73, 0x0f, 0x5c, 0xed, 0x89, 0xd6, 0x68, 0x52, 0x3e,
0x7b, 0xce, 0xf4, 0xf3, 0xcb, 0x15, 0xa0, 0xb4, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6c, 0x3a, 0xc8, 0x8b, 0x0a,
0xb2, 0x37, 0x05, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2a, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x30, 0x32,
0x39, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x92, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x80, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x18, 0x6e, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x05, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x19, 0x4f, 0x45, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x14,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x03, 0xad, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2e, 0x83, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x20, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x7c, 0x10,
0x7d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x94, 0xd3,
0x81, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6e, 0xee, 0xf7, 0xa9, 0xf8,
0x6e, 0x33, 0x1d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x36, 0x30,
0x39, 0x31, 0x31, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0xd8, 0xd5, 0x6a, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x92, 0x9f, 0x9e, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x25, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x0b, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x20, 0x96, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x30, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x35,
0x31, 0x39, 0x35, 0x32, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x4b, 0x8f, 0x03, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xce, 0x4a, 0xa0, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xb7, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x33, 0x14, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x54, 0xc2, 0xbf, 0x3b, 0x83, 0xc2,
0x85, 0x00, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x54, 0xc2, 0xbf, 0x3b, 0x83, 0xc2, 0x85, 0x00,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x06, 0x20, 0xd0, 0xfd, 0x7c, 0xb9, 0x0e, 0xff, 0x5e, 0xcf,
0x28, 0x89, 0xae, 0x8f, 0xd9, 0x7e, 0x56, 0x95, 0x83, 0xd8, 0x66, 0x38,
0x52, 0xeb, 0x23, 0x00, 0x0e, 0x99, 0xb6, 0x20, 0xf7, 0xd4, 0xba, 0xcf,
0x4f, 0x25, 0x2a, 0x5e, 0x46, 0x3f, 0xeb, 0x99, 0xd8, 0x69, 0xa2, 0x3a,
0x96, 0xeb, 0x90, 0xec, 0xc3, 0x1c, 0x85, 0x47, 0x64, 0xfc, 0x5c, 0x29,
0xb8, 0x68, 0xd5, 0xff, 0xbe, 0x29, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe3, 0xd9, 0xea, 0x84, 0xc4, 0x9e, 0x36,
0x55, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c,
0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x35, 0x35, 0x31,
0x33, 0x33, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03,
0x0d, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x12, 0xd2, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x73, 0x39, 0x68, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x1c, 0xc2, 0x4d, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x30, 0x33, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x37, 0x38,
0x32, 0x32, 0x30, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x20, 0xb8, 0xc8, 0xaa, 0x01, 0x5b, 0xa9,
0x0b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x20, 0xb8, 0xc8, 0xaa, 0x01, 0x5b, 0xa9, 0x0b, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x57, 0xfc, 0x69, 0xfc, 0x5e, 0x32, 0x29, 0x87, 0x5c, 0x46, 0xc5,
0xe4, 0xe7, 0x5d, 0x88, 0xd1, 0x86, 0x75, 0x84, 0xa2, 0x5f, 0xe2, 0xa4,
0xce, 0x28, 0x71, 0xcc, 0x44, 0x25, 0xa0, 0x27, 0x3e, 0xe6, 0xc3, 0x88,
0x35, 0x37, 0xbd, 0x16, 0xfe, 0x83, 0x8d, 0x02, 0xe7, 0x64, 0x12, 0x92,
0xc7, 0xde, 0xb6, 0xe4, 0x91, 0x32, 0xd1, 0x6c, 0x63, 0xd5, 0x98, 0x6b,
0x4e, 0x23, 0xe7, 0xf4, 0xf6, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xfb, 0x3a, 0x6b, 0x7a, 0x31, 0x1f, 0x6a, 0x77,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x2e, 0x34, 0x15, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xbd, 0x9d, 0xfd, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xa8,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x59, 0x11, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x37, 0x32, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x32, 0x39, 0x37, 0x31, 0x34, 0x32, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x42, 0x8b, 0x81, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc5, 0xed, 0x9e, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x03, 0x9c, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x90, 0x2d, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb7, 0x19, 0x0c,
0x4f, 0x2e, 0xbf, 0x3b, 0x79, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb7, 0x19, 0x0c, 0x4f, 0x2e,
0xbf, 0x3b, 0x79, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xb7, 0x9c, 0x92, 0x48, 0x19, 0x9e,
0xb8, 0xfa, 0x36, 0x06, 0xd0, 0xac, 0x0c, 0xb1, 0x1e, 0x0c, 0x29, 0x19,
0xa7, 0x55, 0x6c, 0x6d, 0xbd, 0x7d, 0xf7, 0x49, 0x73, 0x92, 0xcc, 0x67,
0x7c, 0x3e, 0x0d, 0x98, 0x2d, 0xfa, 0x62, 0x31, 0x84, 0xd3, 0xad, 0x22,
0xdf, 0x4d, 0x10, 0xe5, 0xbb, 0x95, 0x4b, 0x97, 0x60, 0x1d, 0x11, 0xf7,
0x92, 0x5a, 0x12, 0x88, 0xa4, 0x79, 0x13, 0x4a, 0x39, 0xc7, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xff, 0x12, 0xf0,
0xaf, 0x0e, 0x72, 0x5e, 0x20, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xff, 0x12, 0xf0, 0xaf, 0x0e,
0x72, 0x5e, 0x20, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x6e, 0x4f, 0x43, 0xf7, 0x9d, 0x3c, 0x1d,
0x8c, 0xac, 0xb3, 0xd5, 0xf3, 0xe7, 0xae, 0xed, 0xb2, 0x9f, 0xea, 0xeb,
0x45, 0x59, 0xfd, 0xb7, 0x1a, 0x97, 0xe2, 0xfd, 0x04, 0x38, 0x56, 0x53,
0x10, 0xe8, 0x76, 0x70, 0x03, 0x5d, 0x83, 0xbc, 0x10, 0xfe, 0x67, 0xfe,
0x31, 0x4d, 0xba, 0x53, 0x63, 0xc8, 0x16, 0x54, 0x59, 0x5d, 0x64, 0x88,
0x4b, 0x1e, 0xca, 0xd1, 0x51, 0x2a, 0x64, 0xe6, 0x5e, 0x02, 0x01, 0x64,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x66, 0x0e, 0x0b, 0xe0,
0xb2, 0xca, 0x9a, 0xec, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x66, 0x0e, 0x0b, 0xe0, 0xb2, 0xca,
0x9a, 0xec, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x82, 0x53, 0x0e, 0x34, 0xcc, 0x4d, 0xc3,
0xd7, 0xaf, 0xce, 0x14, 0xb8, 0x4c, 0x46, 0x03, 0xd4, 0xe2, 0x13, 0x00,
0x3f, 0x32, 0x78, 0x53, 0xc2, 0x1e, 0xcb, 0x2f, 0x23, 0x23, 0xa4, 0x03,
0x52, 0xdd, 0x2e, 0x92, 0x94, 0xd5, 0x32, 0x75, 0xf6, 0xa7, 0x8d, 0x75,
0x23, 0xd8, 0x3b, 0xc3, 0x61, 0x63, 0xdd, 0x0e, 0xc7, 0x41, 0x99, 0xe7,
0x50, 0xbd, 0xf8, 0x47, 0x27, 0xbe, 0xc7, 0xf0, 0xa1, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xfd, 0x66, 0x00, 0xbf,
0x52, 0x59, 0x95, 0x3f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2b, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x38,
0x32, 0x37, 0x30, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9a,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x01, 0xb7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x98, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1d, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0xfe, 0xb0, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x13, 0x26, 0xcb, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x0f, 0xe9, 0x8e, 0x1c, 0x4a, 0xec, 0xe4, 0xfd,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x32, 0x30, 0x30, 0x39, 0x35,
0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xe9, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x5e, 0x23, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x65, 0x3b, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb4, 0xe6, 0x00, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x67, 0x8a, 0x8b, 0xff, 0x90, 0x25, 0xd7, 0x0c, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x38, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x33,
0x30, 0x35, 0x38, 0x32, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x93, 0x51, 0xa1, 0x7e, 0xf6, 0xef,
0xf4, 0x8c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x93, 0x51, 0xa1, 0x7e, 0xf6, 0xef, 0xf4, 0x8c,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49,
0xb8, 0x40, 0x45, 0x54, 0xb3, 0x0d, 0x9b, 0x2e, 0x5c, 0xb9, 0x5e, 0x87,
0x85, 0xf8, 0xeb, 0x36, 0xbf, 0x4c, 0xa9, 0xad, 0x25, 0x82, 0x50, 0x06,
0xba, 0x9a, 0xd7, 0x2a, 0x13, 0x0c, 0x88, 0x8e, 0xf0, 0xf2, 0xc1, 0xd7,
0xea, 0xa8, 0x55, 0xa0, 0x00, 0x38, 0x88, 0x4b, 0x60, 0x09, 0x3d, 0xa6,
0xe6, 0x22, 0xe4, 0x17, 0x36, 0x8f, 0x1f, 0x9d, 0xbd, 0x62, 0x74, 0xa7,
0x3f, 0x83, 0xa6, 0x67, 0xf9, 0xef, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x09, 0x28, 0x38, 0xea, 0x89,
0x1f, 0x3e, 0x3d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2b, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x33, 0x39,
0x30, 0x38, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x99, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x27,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x0b, 0x27, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x02, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x09, 0xc0, 0x6c, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x09, 0x56, 0x6f, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xab, 0x8d, 0xe0, 0xef, 0xb6, 0xa8, 0x5f, 0xbf, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x34, 0x35, 0x34, 0x31, 0x33, 0x32,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02,
0x4a, 0x81, 0x3b, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcd, 0x4b,
0x34, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0xb5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x6c, 0x28,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x33, 0x33, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x35, 0x34, 0x30, 0x33, 0x33,
0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x76, 0x08, 0x83, 0x86, 0xc9, 0xd3, 0x8b, 0x41, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x33, 0x37, 0x31, 0x31, 0x30, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x27, 0x35, 0xac, 0x05, 0x7d, 0x66, 0x99, 0x29, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x27,
0x35, 0xac, 0x05, 0x7d, 0x66, 0x99, 0x29, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x16, 0x85, 0xd2,
0xa8, 0x9d, 0x81, 0x01, 0xb1, 0x6e, 0xd1, 0x41, 0x81, 0xa6, 0x03, 0xb0,
0xe9, 0x60, 0xbe, 0xa6, 0xe6, 0xab, 0x90, 0xdf, 0x22, 0x92, 0x86, 0x41,
0x71, 0x5b, 0x2e, 0x2b, 0xc7, 0xee, 0x01, 0xdb, 0x05, 0x8e, 0x44, 0xf3,
0x21, 0xe9, 0xfb, 0xa1, 0xae, 0x70, 0x47, 0x9a, 0xd1, 0xf6, 0xeb, 0xc6,
0x27, 0x71, 0x32, 0x88, 0xf1, 0x74, 0xb5, 0x72, 0xde, 0xf4, 0xdd, 0xfe,
0xc4, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x28, 0xca, 0x29, 0x71, 0x7d, 0xec, 0xec, 0x89, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x30, 0x30, 0x38, 0x39, 0x33, 0x39, 0x32, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xee, 0x74,
0x06, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x99, 0xf3, 0xb0, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0x20, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2c, 0xe4, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xd0, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x1b, 0x4f, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x44, 0x8d, 0x84, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xac, 0xb6, 0x40, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x31, 0x38, 0xee, 0x28, 0xe7, 0xe9, 0x81, 0x89, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x18, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x66, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xc3, 0xe9, 0xa7, 0x3a, 0x6c, 0xfd, 0x2d, 0x64,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xc3, 0xe9, 0xa7, 0x3a, 0x6c, 0xfd, 0x2d, 0x64, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x40, 0xa2, 0x67, 0x1e, 0x76, 0xe9, 0x21, 0x48, 0x93, 0x77, 0xe9, 0xf9,
0xf6, 0x00, 0x8b, 0xf9, 0x82, 0xbc, 0x9d, 0x98, 0x3c, 0x29, 0xae, 0x1d,
0x81, 0xbc, 0xab, 0xa5, 0xa9, 0x80, 0xb0, 0xc1, 0xf1, 0x95, 0x5f, 0xb9,
0xd2, 0xb2, 0xfc, 0xd0, 0xfa, 0x3c, 0x59, 0x86, 0x50, 0xaf, 0xa7, 0xf3,
0x8f, 0xe4, 0x58, 0x57, 0x84, 0x41, 0xb8, 0x45, 0xa2, 0xd0, 0x73, 0x14,
0x00, 0x7f, 0xcc, 0x7c, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x45, 0xcc, 0x22, 0xd1, 0x86, 0x8d, 0xaa, 0xd5, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x45, 0xcc, 0x22, 0xd1, 0x86, 0x8d, 0xaa, 0xd5, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x5e,
0x12, 0x4d, 0xb1, 0x15, 0xa9, 0x7f, 0x9a, 0x54, 0x05, 0x12, 0x17, 0xf9,
0x4d, 0x7e, 0x52, 0xa5, 0xac, 0xe5, 0x41, 0x20, 0x38, 0xb1, 0x64, 0x5a,
0x8c, 0xc7, 0x66, 0x91, 0xe9, 0xc4, 0xcb, 0x17, 0xb7, 0x69, 0xbf, 0x08,
0xc4, 0xc8, 0xc6, 0x2c, 0xbc, 0x76, 0x3f, 0x44, 0x2e, 0xcf, 0xf1, 0xed,
0x09, 0xe9, 0x47, 0xaf, 0x62, 0xa4, 0x7f, 0xc8, 0xf3, 0xc2, 0x28, 0x9f,
0x30, 0x65, 0x2b, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x0e, 0x5a, 0x8a, 0xea, 0x49, 0xe3, 0xb1, 0x4e, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x37, 0x35, 0x31, 0x32, 0x36, 0x34, 0x33, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x0b, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x04, 0x65, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x72, 0xa2, 0x43, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0x1b, 0xec, 0x70, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76,
0x1f, 0x31, 0x35, 0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x33, 0x31, 0x32, 0x36, 0x35, 0x37,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xc2, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x17, 0x54, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x41, 0xce, 0x51, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xa9, 0x08, 0x8b, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x74, 0x04, 0x96, 0x86, 0x2d, 0x8e, 0x29, 0xb0, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x74,
0x04, 0x96, 0x86, 0x2d, 0x8e, 0x29, 0xb0, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xc9, 0x46,
0x45, 0xa5, 0x99, 0x88, 0xfa, 0xd8, 0x3d, 0x53, 0x0a, 0x9a, 0xab, 0x7f,
0x21, 0x99, 0xfa, 0x0e, 0xa8, 0xae, 0x91, 0xae, 0xb8, 0xc7, 0xf8, 0xa2,
0x4d, 0xe1, 0xaf, 0x71, 0x07, 0x00, 0x63, 0x41, 0xa0, 0x7e, 0xba, 0x88,
0x6b, 0x5c, 0xc7, 0x4c, 0xac, 0x5c, 0xba, 0x47, 0x10, 0x4f, 0x5c, 0xe9,
0x78, 0x73, 0x47, 0x4c, 0xe6, 0x09, 0xba, 0xe9, 0x55, 0xe6, 0x08, 0x15,
0xe1, 0xb4, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe4, 0x2e, 0xdd, 0xdd, 0x29, 0xfb, 0x9b, 0x50, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe4,
0x2e, 0xdd, 0xdd, 0x29, 0xfb, 0x9b, 0x50, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0xe3, 0xbf, 0x4a,
0x95, 0x85, 0xfc, 0x10, 0x59, 0x70, 0xf1, 0x8a, 0x65, 0xa8, 0x06, 0xe6,
0x12, 0xdc, 0x1c, 0xe7, 0x17, 0x8a, 0x18, 0x69, 0xd2, 0x19, 0xe2, 0xa1,
0xd2, 0xd8, 0x12, 0xf3, 0x08, 0x62, 0xc0, 0x58, 0xe0, 0x5f, 0x2a, 0xa9,
0xae, 0x18, 0x4e, 0x63, 0xfe, 0xa2, 0x47, 0x83, 0x34, 0x56, 0xd3, 0xcc,
0x1d, 0x2e, 0x24, 0x54, 0xcc, 0xdf, 0x0d, 0x84, 0x02, 0x60, 0x01, 0x2f,
0xda, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xb2, 0x9f, 0x3f, 0xd6, 0xb6, 0x43, 0xe8, 0x80, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xb2, 0x9f, 0x3f, 0xd6, 0xb6, 0x43, 0xe8, 0x80, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xab, 0x73, 0x3c, 0xff, 0x20,
0x61, 0x6e, 0x2d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x31,
0x32, 0x39, 0x31, 0x33, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xef, 0x43, 0x65, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x9a, 0x8e, 0xf1, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x21, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x3f, 0x6d, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf7, 0x80, 0xe7, 0xfc, 0x1e, 0x10,
0x3b, 0x1f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x39, 0x36, 0x36,
0x39, 0x33, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03,
0xfa, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x04, 0x3a, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xd3, 0x1a, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb1, 0x4a, 0xb3, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x4a, 0xea, 0x24, 0xa0, 0xc7, 0xb6, 0x28, 0x06,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x36, 0x31, 0x38, 0x36, 0x30,
0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xc1, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x3d, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x82, 0x6b, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x9e, 0x2e, 0x95, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x30, 0x33, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x31, 0x31, 0x32,
0x36, 0x35, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x91, 0x37, 0x06, 0x0f, 0x28, 0xd6, 0xcc, 0xd0,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x31, 0x33, 0x39, 0x39,
0x34, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x02, 0x29, 0x88, 0x10, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xb9, 0x3d, 0xac, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x9d, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x71, 0x48, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x9f, 0x97, 0xaf, 0x9b, 0x19, 0xc8, 0x26, 0xb1, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x33, 0x38, 0x38, 0x30, 0x33, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x29, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x1d, 0xf7, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x22, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x52, 0x37, 0x02, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xc6, 0x8a, 0x28, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x32, 0x6e, 0xba, 0x04, 0x60, 0x76, 0xd8, 0xc1, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x32,
0x6e, 0xba, 0x04, 0x60, 0x76, 0xd8, 0xc1, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x51, 0x7f, 0x02,
0x29, 0x6c, 0xfe, 0x45, 0x1a, 0x92, 0x51, 0x7d, 0xda, 0x31, 0x73, 0xae,
0xf0, 0x98, 0x20, 0x49, 0x23, 0xe9, 0x88, 0xce, 0x00, 0x0c, 0x29, 0x48,
0x58, 0xdc, 0x6e, 0xd6, 0xcc, 0x4c, 0x58, 0xae, 0x1a, 0xb7, 0x20, 0x54,
0xf3, 0x41, 0x1c, 0xb3, 0xc4, 0x47, 0x63, 0x96, 0x46, 0x2e, 0x16, 0x8f,
0xfa, 0xa2, 0xd5, 0x38, 0xa3, 0x15, 0x74, 0x5c, 0xa2, 0xb8, 0x84, 0xb4,
0x49, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x6c, 0x60, 0xbc, 0x25, 0x11, 0xaa, 0xf4, 0xd1, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x32, 0x33, 0x34, 0x30, 0x30, 0x33, 0x38, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x2c, 0xca,
0x76, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0x4b, 0x46, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0xa6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x17, 0xca, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xef,
0x5e, 0xa1, 0x6e, 0xf8, 0xba, 0x28, 0x6f, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xef, 0x5e, 0xa1,
0x6e, 0xf8, 0xba, 0x28, 0x6f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xac, 0xa0, 0x5f, 0x25, 0x86,
0x26, 0x60, 0x6c, 0x59, 0xe5, 0xc8, 0xd7, 0x71, 0x71, 0x84, 0x13, 0x72,
0x36, 0xc6, 0x27, 0xc4, 0xbb, 0xef, 0x53, 0xde, 0x5d, 0xfd, 0xbd, 0x13,
0xf0, 0x18, 0x18, 0xf4, 0x9c, 0x8f, 0x39, 0x16, 0xe3, 0x0a, 0x8c, 0xe3,
0xb8, 0x73, 0x69, 0xed, 0xde, 0x31, 0xd7, 0xc0, 0x66, 0x0b, 0x36, 0x39,
0x9c, 0xa9, 0x14, 0xf3, 0x6c, 0x9c, 0xc3, 0x9e, 0xdb, 0xde, 0x81, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x40, 0x37,
0xa3, 0x10, 0xf2, 0x8d, 0x7a, 0x78, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x57, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x60, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb,
0x82, 0xd8, 0xc8, 0x82, 0x01, 0x70, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xd8, 0xdb,
0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x78, 0x1e, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa5,
0xda, 0x1c, 0xbd, 0x1b, 0xbb, 0x04, 0x39, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa5, 0xda, 0x1c,
0xbd, 0x1b, 0xbb, 0x04, 0x39, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0xf8, 0x46, 0xb8, 0x40, 0x74, 0xf1, 0xf9, 0xe5, 0xf1,
0xbc, 0xfc, 0x94, 0xa8, 0xc6, 0x85, 0x18, 0x20, 0xe1, 0x82, 0xae, 0xb8,
0x0f, 0x91, 0x9e, 0x0b, 0x92, 0xad, 0xe6, 0x3e, 0x1e, 0xe1, 0x58, 0x9c,
0xed, 0x73, 0x5a, 0xe4, 0x9e, 0x40, 0xf3, 0x70, 0x1b, 0x2c, 0x41, 0xc1,
0x3f, 0x4a, 0xcf, 0xc0, 0xd1, 0x2d, 0xf3, 0xf0, 0x5d, 0x93, 0x6a, 0x5b,
0xdf, 0xa8, 0x1c, 0xc7, 0xee, 0x26, 0xd3, 0xc6, 0xb1, 0x1a, 0x9e, 0x02,
0x01, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x33, 0xc2, 0x3c,
0x4c, 0x23, 0xdb, 0x9c, 0x5a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38,
0x39, 0x37, 0x36, 0x39, 0x30, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x03, 0xf5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x15, 0xa9, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xfa,
0x05, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb1, 0x72,
0x08, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x20, 0x61, 0xe8, 0x37, 0x3d,
0xd2, 0x81, 0x21, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x3a, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53,
0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31,
0x31, 0x31, 0x32, 0x36, 0x31, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x05, 0x33, 0x4b, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xa9, 0x90, 0xab, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x78,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x6d, 0xaf, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xad, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x64, 0x81, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x65, 0x46, 0x07, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x0a, 0xf3, 0x4e, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xdd, 0x42, 0x68, 0x92, 0x0f, 0x18, 0x6b, 0x9c, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xdd,
0x42, 0x68, 0x92, 0x0f, 0x18, 0x6b, 0x9c, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x8b, 0x5a, 0xf4,
0xbe, 0xe9, 0x0d, 0x25, 0x4a, 0x56, 0xf8, 0xaa, 0xec, 0x5d, 0x43, 0x27,
0x40, 0xcb, 0x33, 0xb2, 0x7e, 0xf4, 0x84, 0xf1, 0x94, 0x71, 0x7d, 0x87,
0x1b, 0x43, 0x15, 0xba, 0x2d, 0xf3, 0x36, 0x2b, 0xb0, 0x78, 0x50, 0xfa,
0x21, 0xe3, 0xa2, 0x53, 0xe4, 0x3d, 0x7a, 0x05, 0x03, 0xe9, 0xd6, 0x28,
0xe0, 0x10, 0x3b, 0xcb, 0xe1, 0x10, 0xe9, 0xf3, 0x45, 0xcb, 0xe2, 0x7b,
0x59, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xd6, 0x68, 0x60, 0x70, 0x9e, 0x39, 0xcc, 0x8d, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd6, 0x68,
0x60, 0x70, 0x9e, 0x39, 0xcc, 0x8d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x76, 0x06, 0xb5,
0x40, 0x29, 0xe3, 0x24, 0xba, 0xdc, 0xaf, 0xd3, 0xd0, 0x6c, 0x2a, 0xf4,
0xf6, 0x1b, 0x28, 0xb0, 0x36, 0xb3, 0x7c, 0x1a, 0x9f, 0x95, 0x1d, 0xc4,
0xed, 0x8e, 0x9c, 0x4d, 0x5f, 0x20, 0xaf, 0xb2, 0x98, 0x83, 0x9b, 0xda,
0x29, 0x1a, 0x61, 0xa5, 0x4d, 0x85, 0xc9, 0xa2, 0x30, 0x5e, 0x7b, 0xfd,
0xec, 0x5d, 0x4c, 0xf9, 0x00, 0xaa, 0xad, 0x54, 0xe4, 0x26, 0xbb, 0x93,
0x88, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xf5, 0x68, 0x15, 0x0d, 0xd5, 0xef, 0xfe, 0x96, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x30, 0x37, 0x37, 0x35, 0x33, 0x32, 0x33, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x41,
0xe7, 0x9d, 0x40, 0x2c, 0xac, 0x64, 0x8e, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x41, 0xe7, 0x9d,
0x40, 0x2c, 0xac, 0x64, 0x8e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x7a, 0xbb, 0x17, 0xc6, 0x9f,
0xc0, 0xc8, 0x64, 0xec, 0xba, 0x61, 0x7d, 0xb3, 0x21, 0xde, 0xb9, 0x13,
0xd0, 0xef, 0xf8, 0x85, 0x2e, 0xa5, 0x3f, 0x5e, 0x90, 0xe1, 0xf9, 0xbc,
0xba, 0x53, 0xd2, 0x7f, 0xee, 0x94, 0x69, 0xb6, 0x62, 0x2b, 0x5c, 0x44,
0x89, 0xac, 0x2a, 0xa6, 0xd8, 0x41, 0x5e, 0xc6, 0x84, 0x63, 0x2c, 0x69,
0x66, 0xa9, 0x84, 0xe1, 0x2f, 0xfb, 0xb5, 0x87, 0x7b, 0xb4, 0xb4, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xce, 0x2d,
0xfe, 0xd7, 0x22, 0xc9, 0xc7, 0xbd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61,
0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02,
0x84, 0x67, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a,
0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x38, 0x26, 0x47, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xb3, 0xe9, 0x24, 0x5b, 0x27, 0xcf, 0xaf, 0xa6, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xb3, 0xe9, 0x24, 0x5b, 0x27, 0xcf, 0xaf, 0xa6, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x79, 0x41,
0x04, 0x2c, 0x63, 0xdd, 0xda, 0x42, 0xf3, 0xcd, 0x35, 0xf5, 0x39, 0xcf,
0x40, 0xe0, 0xea, 0xf3, 0xa0, 0x3a, 0x01, 0xca, 0xf6, 0xb6, 0x9f, 0xa8,
0xd4, 0x6f, 0x99, 0x21, 0x00, 0x23, 0x9e, 0x0a, 0x3b, 0x60, 0x46, 0x5a,
0xd1, 0x19, 0xa0, 0xfd, 0x3a, 0x00, 0xd4, 0x8c, 0xc6, 0xd2, 0x39, 0x74,
0x6e, 0x99, 0x07, 0x19, 0x0b, 0x63, 0x8a, 0x68, 0x6b, 0xe7, 0xfd, 0xae,
0xb2, 0xee, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xea, 0x12, 0x00, 0x5d, 0xef, 0x60, 0x05, 0x23, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x36, 0x39, 0x37, 0x36, 0x35, 0x32, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xd1, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x36, 0xb8, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x6a, 0x74, 0x0e, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x01, 0x12, 0x29, 0xbe, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x28,
0x41, 0x67, 0xc8, 0x5a, 0x2d, 0x0f, 0xa0, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x20,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x70, 0x72, 0x69, 0x76,
0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e,
0x67, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0xcf, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26, 0xd2,
0x78, 0x18, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63,
0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x65, 0x72, 0xf6, 0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x28, 0x41, 0x67,
0xc8, 0x5a, 0x2d, 0x0f, 0xa0, 0xd8, 0xc8, 0x82, 0x02, 0x71, 0x66, 0x6c,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x1d, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x66, 0xe4, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xd7, 0x9c, 0x1e, 0x0b, 0xb2, 0x06, 0x66,
0x33, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x33, 0x39, 0x38, 0x36,
0x38, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xc7,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x42, 0x6c, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x43, 0x1e, 0x61, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xaa, 0xe0, 0xc9, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xb2, 0xad, 0x9b, 0x83, 0x4e, 0xf6, 0xb1, 0x70, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x35, 0x37, 0x38, 0x38, 0x39, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x28, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x2f, 0x07, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x27, 0x59, 0xce, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x46, 0x92, 0x49, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x8d, 0xb8, 0x96, 0x81, 0xa8, 0xa1, 0x55, 0xe4, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x30, 0x37, 0x32, 0x31, 0x30, 0x32, 0x36, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xff,
0x05, 0x3d, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0x97, 0x02,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0x65, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x09, 0xb6, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x99, 0x1f, 0x0a, 0x66, 0x34, 0x9d, 0x9b, 0x1d, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x70, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69,
0x6e, 0x67, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0xcf, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26,
0xd2, 0x78, 0x18, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65,
0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72,
0x64, 0x65, 0x72, 0xf6, 0x02, 0x84, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x02, 0x69, 0xb4, 0x63, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70,
0x69, 0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x99, 0x1f,
0x0a, 0x66, 0x34, 0x9d, 0x9b, 0x1d, 0xd8, 0xc8, 0x82, 0x02, 0x71, 0x66,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65,
0x69, 0x76, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8,
0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33,
0xdc, 0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69,
0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75,
0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e,
0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x78, 0x22, 0x50, 0x72,
0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x46,
0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x34, 0x39, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x30, 0x36, 0x36,
0x39, 0x34, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x78, 0x89, 0x4a, 0x85, 0xd3, 0x86, 0x94, 0xcb,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x78, 0x89, 0x4a, 0x85, 0xd3, 0x86, 0x94, 0xcb, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40,
0xe0, 0xd3, 0xa3, 0x48, 0xc0, 0x17, 0x69, 0x68, 0xd4, 0xb4, 0x0b, 0x68,
0x11, 0xb0, 0xb7, 0xa3, 0x6c, 0x05, 0x35, 0xc3, 0xf6, 0x80, 0xf9, 0xf5,
0x8d, 0x05, 0x06, 0xaf, 0xa5, 0xde, 0x5f, 0x9d, 0x1a, 0x2f, 0xac, 0xa7,
0x93, 0x15, 0xdf, 0x6f, 0x2c, 0xd5, 0x3e, 0xd4, 0x01, 0x33, 0x3d, 0xed,
0x41, 0x21, 0x5b, 0xbf, 0xfd, 0xd2, 0x27, 0x8d, 0x74, 0xd3, 0x59, 0x96,
0x42, 0xa6, 0x45, 0xb1, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x01, 0x80, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0xc5, 0xd4, 0xea, 0xe1, 0x92, 0x64, 0x60,
0x69, 0x70, 0x5a, 0x49, 0x53, 0x1d, 0x53, 0x11, 0xff, 0xb9, 0xa9, 0x9b,
0x02, 0x10, 0x9d, 0xff, 0x18, 0xd4, 0x3a, 0xb6, 0x9c, 0xee, 0xcd, 0xbf,
0x4a, 0x40, 0xcc, 0x86, 0x52, 0x25, 0x8d, 0x40, 0x05, 0xb1, 0x13, 0xf0,
0x00, 0x1e, 0xa2, 0x3d, 0x5e, 0xe0, 0x4c, 0x6b, 0x65, 0x54, 0x50, 0x50,
0x11, 0x80, 0x2c, 0x5c, 0x0e, 0xb7, 0xc0, 0x5e, 0xdf, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc1, 0xe2, 0x69, 0x10,
0xf3, 0xd8, 0x1f, 0x24, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc1, 0xe2, 0x69, 0x10, 0xf3, 0xd8,
0x1f, 0x24, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xe4, 0xd4, 0x00, 0x93, 0xa8, 0x87, 0xec, 0x90,
0x36, 0x7d, 0xd3, 0x2f, 0x9d, 0xea, 0x47, 0xa6, 0xdc, 0x3d, 0x14, 0x10,
0x5a, 0xc2, 0x2d, 0x11, 0xaa, 0x41, 0xee, 0x35, 0x28, 0x91, 0x10, 0xce,
0x5e, 0x6e, 0x87, 0xfe, 0xcb, 0x07, 0xe7, 0x4c, 0xc9, 0x8a, 0x8a, 0x70,
0x09, 0xd3, 0xb5, 0x65, 0x1c, 0x53, 0x45, 0xd6, 0xb0, 0xd4, 0xb5, 0xaf,
0xcf, 0xff, 0x78, 0x9c, 0x56, 0x3c, 0x1a, 0xf9, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x39, 0x30, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x39, 0x31, 0x34, 0x31, 0x36, 0x39, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4c, 0xaf, 0xc8, 0xdd,
0x1e, 0xbd, 0xfb, 0xae, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30,
0x32, 0x37, 0x34, 0x37, 0x38, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xf1, 0xc2, 0x5c, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x9c, 0xc7, 0xdc, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x25,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x55, 0x78, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc1, 0x08, 0x91, 0x92, 0x7d,
0xbd, 0x9a, 0xb9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc1, 0x08, 0x91, 0x92, 0x7d, 0xbd, 0x9a,
0xb9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xe0, 0xf3, 0xaa, 0x15, 0x14, 0x5f, 0x90, 0xad, 0x81,
0xa2, 0x73, 0xa3, 0xd9, 0xab, 0xb2, 0x76, 0x67, 0x88, 0x7e, 0x28, 0x92,
0xc0, 0xdb, 0x11, 0x18, 0xe9, 0x37, 0x39, 0x65, 0x97, 0x14, 0x70, 0xea,
0x48, 0xdc, 0x24, 0x11, 0x2c, 0x79, 0xfd, 0x9d, 0x71, 0x04, 0xac, 0xd0,
0x13, 0xdd, 0x11, 0x1e, 0xdc, 0x30, 0x91, 0xaa, 0x2a, 0x7d, 0x3c, 0x1c,
0x5d, 0x6e, 0x05, 0xbd, 0xbe, 0x8b, 0x46, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb3, 0xfa, 0x0e, 0x71, 0x02, 0x0a,
0xf9, 0x3f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xb3, 0xfa, 0x0e, 0x71, 0x02, 0x0a, 0xf9, 0x3f,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49,
0xb8, 0x40, 0xaa, 0x92, 0xd6, 0x7b, 0x34, 0xae, 0x6e, 0x17, 0xd8, 0xf0,
0x7d, 0xf3, 0xb3, 0xaf, 0x82, 0xa9, 0x49, 0x3a, 0x29, 0xc2, 0x36, 0x07,
0xe7, 0xb7, 0xc3, 0xff, 0xea, 0x04, 0x22, 0x5a, 0x13, 0x53, 0xd1, 0x4c,
0xb5, 0x77, 0xd8, 0xcd, 0xff, 0x0f, 0x39, 0x9b, 0xfc, 0xb8, 0x29, 0x26,
0x49, 0xd2, 0xe2, 0x75, 0x99, 0xc8, 0x08, 0xe9, 0xc3, 0xc9, 0x98, 0x45,
0x2a, 0xec, 0x6e, 0xd4, 0xdd, 0xfc, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x01,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x04, 0x8d, 0x83, 0x04,
0x24, 0xfb, 0x52, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x04, 0x8d, 0x83, 0x04, 0x24, 0xfb,
0x52, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x94, 0xcc, 0x35, 0x08, 0x28, 0xa8, 0x4a, 0xb4, 0x26,
0xe0, 0xcf, 0x38, 0x9e, 0xa1, 0x18, 0xf9, 0x39, 0x73, 0xbf, 0x6b, 0x9c,
0x9b, 0x4f, 0xf7, 0x11, 0x29, 0x88, 0x13, 0xef, 0xc0, 0x56, 0xf0, 0x3a,
0x0d, 0xef, 0x44, 0xb6, 0xaa, 0x1d, 0x11, 0x85, 0x27, 0x62, 0x10, 0x6a,
0x5d, 0xac, 0x5a, 0x75, 0x10, 0x34, 0x16, 0x64, 0x60, 0x7c, 0xcc, 0x88,
0xae, 0x22, 0xdc, 0x8d, 0x44, 0xbe, 0x6c, 0x02, 0x01, 0x80, 0x06, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9c, 0x0f, 0xac, 0x08, 0xa2, 0xe1,
0x32, 0xc9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x9c, 0x0f, 0xac, 0x08, 0xa2, 0xe1, 0x32, 0xc9,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0xf0, 0xa1, 0x83, 0xbd, 0x0a, 0xc5, 0xd9, 0x8e, 0x1a, 0x7a,
0x10, 0xc6, 0xf1, 0x46, 0xc6, 0xed, 0x5c, 0xc1, 0xf2, 0x37, 0x01, 0xb8,
0xbe, 0x6e, 0xcd, 0xe2, 0x41, 0x31, 0xe0, 0x7b, 0x2d, 0x0d, 0x96, 0x94,
0x01, 0xb7, 0x52, 0x05, 0xd3, 0x2c, 0x09, 0xb9, 0x59, 0xc3, 0x44, 0xd7,
0x75, 0x41, 0x10, 0xc2, 0xc3, 0xce, 0x22, 0x1f, 0x80, 0x38, 0xe6, 0x72,
0x88, 0xb8, 0x9a, 0x55, 0x9c, 0xe2, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc3, 0xa0, 0x2d, 0x2d, 0xf9, 0xbf, 0x9b,
0x93, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xc3, 0xa0, 0x2d, 0x2d, 0xf9, 0xbf, 0x9b, 0x93, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x17, 0xd6, 0x69, 0xb5, 0x8c, 0xe8, 0x08, 0xbb, 0x14, 0x35, 0x8a,
0x82, 0x49, 0x09, 0xc9, 0x79, 0x7f, 0x0f, 0x69, 0x60, 0x7a, 0xc8, 0xf3,
0xc1, 0x7f, 0x1b, 0x93, 0x91, 0x27, 0xab, 0xac, 0x7f, 0x27, 0xa2, 0x53,
0x1c, 0x35, 0xe0, 0x54, 0x7e, 0xee, 0x7e, 0xdd, 0xfc, 0x0f, 0x8f, 0xb7,
0x42, 0x04, 0x29, 0x5e, 0x3b, 0x91, 0x18, 0x0c, 0xe8, 0xc4, 0xa0, 0x64,
0x83, 0xa6, 0xde, 0xb7, 0xe7, 0x02, 0x01, 0x80, 0x80, 0x80, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe0, 0xe6,
0xfc, 0x0e, 0x47, 0xb6, 0x2c, 0x06, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe0, 0xe6, 0xfc, 0x0e,
0x47, 0xb6, 0x2c, 0x06, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xea, 0xc0, 0x4e, 0x31, 0x79, 0x2c,
0x2a, 0x62, 0xc7, 0xdb, 0x50, 0xbd, 0x91, 0x60, 0x2b, 0x70, 0x06, 0x48,
0xec, 0x0c, 0x59, 0xec, 0x4d, 0x93, 0xff, 0x2c, 0x92, 0xa3, 0xbb, 0x64,
0x1d, 0x21, 0xcb, 0xd2, 0xd5, 0xa7, 0x85, 0xbd, 0x78, 0x7e, 0x4d, 0x78,
0xa6, 0xfe, 0x7d, 0xe1, 0x56, 0x66, 0x35, 0x12, 0x6f, 0x95, 0x83, 0x99,
0x4b, 0xc9, 0xba, 0xae, 0x4f, 0xb5, 0x62, 0x28, 0x0f, 0xa6, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x04, 0x9c, 0x06,
0x80, 0xe9, 0x67, 0x35, 0xdb, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x04, 0x9c, 0x06, 0x80, 0xe9,
0x67, 0x35, 0xdb, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x95, 0xad, 0x59, 0x83, 0xe0, 0x1d, 0xe9,
0x6b, 0xdd, 0x23, 0x15, 0x93, 0x29, 0x23, 0x1f, 0x5e, 0x41, 0x87, 0x0c,
0x99, 0x1e, 0x79, 0x8d, 0xd0, 0x11, 0x19, 0xaf, 0x98, 0x90, 0x77, 0xd1,
0x1f, 0x88, 0x08, 0x3c, 0x4a, 0xb2, 0xcf, 0x2b, 0xf9, 0x1c, 0xe5, 0x3d,
0x1f, 0x78, 0xda, 0x64, 0xa5, 0x5d, 0xe1, 0x54, 0xb7, 0x4e, 0xb3, 0x8b,
0xaa, 0x22, 0x54, 0xaf, 0x1e, 0xbd, 0x45, 0x85, 0x13, 0x02, 0x01, 0x80,
0x06, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x60, 0xc0, 0x0a, 0xbc,
0x31, 0x38, 0x75, 0x34, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x60, 0xc0, 0x0a, 0xbc, 0x31, 0x38,
0x75, 0x34, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0x2f, 0xa2, 0x55, 0x98, 0xc5, 0x37, 0x67, 0xf7,
0x9c, 0x71, 0x9e, 0xa8, 0x5d, 0xaa, 0x3e, 0x2a, 0x88, 0xce, 0x8c, 0x63,
0xcc, 0xe0, 0x85, 0xde, 0xc1, 0xfa, 0x2d, 0xcf, 0xd4, 0xd7, 0x8d, 0x15,
0x63, 0xd9, 0xea, 0xf4, 0xe7, 0xbe, 0x47, 0xb5, 0x71, 0x64, 0xdf, 0x02,
0xff, 0xa9, 0xf7, 0xda, 0xa4, 0x55, 0x73, 0x34, 0x34, 0x21, 0x46, 0x65,
0xf9, 0xaa, 0x9a, 0xb9, 0x58, 0x3c, 0x33, 0xe7, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x3a, 0x37, 0x78, 0xcd, 0x05,
0x41, 0x3f, 0xa9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x37,
0x38, 0x35, 0x35, 0x33, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x23, 0xef, 0x1f, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xb3, 0xd5, 0x40, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x92, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x35, 0x14, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x15, 0x3b, 0x91, 0x00, 0x75, 0xee,
0xf6, 0xc0, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56,
0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67, 0x62, 0x61,
0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x87, 0x04,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x48, 0x4e, 0x0e,
0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56,
0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe6, 0x0c,
0x86, 0xfc, 0xdd, 0x08, 0x28, 0xc9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe6, 0x0c, 0x86, 0xfc,
0xdd, 0x08, 0x28, 0xc9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x77, 0xb6, 0x57, 0x38, 0x86, 0xc2,
0xed, 0x65, 0xcc, 0x80, 0x80, 0x39, 0xcf, 0xaf, 0xc1, 0x48, 0x03, 0x21,
0xf0, 0xec, 0xcf, 0xe2, 0x53, 0xa2, 0x84, 0xfc, 0x4b, 0xb6, 0x08, 0x30,
0xf9, 0x3a, 0xc9, 0x60, 0x85, 0x0c, 0xb8, 0xa3, 0xf6, 0xed, 0x95, 0x43,
0x32, 0x59, 0x0e, 0x44, 0x42, 0xf0, 0xa6, 0x12, 0x59, 0xa0, 0x74, 0xa1,
0x2e, 0xb3, 0x98, 0xb2, 0xec, 0x3c, 0xb3, 0xf6, 0x58, 0x0f, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbb, 0x26, 0xea,
0x79, 0x37, 0x9c, 0xe3, 0x78, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbb, 0x26, 0xea, 0x79, 0x37,
0x9c, 0xe3, 0x78, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x7c, 0x24, 0x5d, 0xdd, 0x5f, 0x07, 0xce,
0xc7, 0xad, 0xa5, 0x97, 0xf9, 0x3d, 0x80, 0xe6, 0x37, 0x6a, 0x3a, 0x3b,
0x7f, 0x85, 0x16, 0x7e, 0x0e, 0x73, 0x5f, 0xb8, 0x70, 0x6d, 0x15, 0xf0,
0x16, 0x31, 0x5c, 0x1c, 0x54, 0x02, 0xb6, 0x35, 0x96, 0x0a, 0xc9, 0x43,
0x08, 0x0f, 0xea, 0x1f, 0xc2, 0xbd, 0xcd, 0x9d, 0xa1, 0xe2, 0xae, 0xca,
0x83, 0x8c, 0xde, 0xd3, 0xb4, 0x49, 0x6c, 0xda, 0xda, 0x02, 0x03, 0x82,
0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4f, 0xfe,
0x0b, 0xaa, 0x84, 0xd7, 0x46, 0x11, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4f, 0xfe, 0x0b, 0xaa,
0x84, 0xd7, 0x46, 0x11, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x48, 0x6e, 0xc2, 0xbe, 0xb1, 0xfa, 0x95, 0xb3, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46,
0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x56, 0x37, 0xad, 0xfe,
0xd1, 0x56, 0x51, 0x28, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x56, 0x37, 0xad, 0xfe, 0xd1, 0x56,
0x51, 0x28, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0x62, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x6a, 0x18, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x32, 0x38, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x32, 0x35, 0x39, 0x37, 0x37, 0x38,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x05, 0xe4, 0x4f, 0x0e, 0x52, 0x2f, 0xb5, 0xc3, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x05,
0xe4, 0x4f, 0x0e, 0x52, 0x2f, 0xb5, 0xc3, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x76, 0x0c, 0x97,
0xd2, 0x65, 0xd4, 0xe3, 0x01, 0xab, 0x93, 0xea, 0xfa, 0x6e, 0xfc, 0xdd,
0x66, 0xbf, 0xe6, 0xe0, 0xfb, 0x0f, 0x0c, 0x04, 0x2b, 0x44, 0x77, 0xeb,
0xbd, 0x82, 0xa2, 0xa6, 0xd5, 0xfb, 0x24, 0xcd, 0x08, 0x40, 0x66, 0x92,
0x5e, 0xcc, 0x47, 0x74, 0x40, 0x63, 0x1b, 0x06, 0x78, 0xc5, 0x54, 0x5f,
0xda, 0x41, 0x2d, 0xca, 0x2d, 0x2f, 0xc4, 0xa1, 0x54, 0x32, 0x0f, 0x6a,
0x79, 0x02, 0x03, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x32, 0x33, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x33, 0x31, 0x33,
0x32, 0x33, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xcc, 0xc3, 0x7f, 0x2a, 0x28, 0xf0, 0x92, 0x82,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x32, 0x35, 0x38, 0x31, 0x30,
0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xf1, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x4b, 0xab, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0x44, 0x76, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb5, 0xc7, 0xc0, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x45, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x39, 0x30, 0x30, 0x30, 0x30, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x7d, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x4f, 0xd9, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x3b, 0x82, 0x61, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xa1, 0x0c, 0x35, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xea, 0xaa, 0x96, 0x04, 0x21, 0x35, 0x9c, 0x47, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x37, 0x30, 0x36, 0x33, 0x30, 0x33, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x01, 0xee, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x26, 0x18, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x1a, 0x09, 0x3f, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x26, 0x69, 0x94, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4f,
0x97, 0x3e, 0x07, 0x56, 0xc7, 0xf9, 0xe9, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4f, 0x97, 0x3e,
0x07, 0x56, 0xc7, 0xf9, 0xe9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x37, 0xda, 0x57, 0x31, 0xcd,
0x91, 0xd2, 0xba, 0x84, 0xe1, 0xe8, 0x7c, 0xfb, 0x23, 0x26, 0x11, 0x9a,
0xe3, 0x2d, 0xc3, 0x24, 0x40, 0x75, 0xdf, 0x64, 0x2e, 0x3a, 0x3d, 0x69,
0xbd, 0xfa, 0x47, 0x45, 0x11, 0xfd, 0x26, 0xed, 0xe0, 0xe3, 0xcc, 0xd5,
0xd4, 0xcd, 0xd5, 0x5c, 0xe9, 0xd3, 0xb1, 0xd0, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x01, 0x98, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x03, 0xa6, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x0d, 0x10, 0x90, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x10, 0x66, 0x40, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x40, 0x91, 0xbc, 0x49, 0xbb, 0xfc, 0x2d, 0x6a, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74,
0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72,
0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x30, 0x38, 0x35, 0x30, 0x37, 0x39,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x52, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x07, 0x64, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x24, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x5c, 0xd9, 0xd7, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xf6, 0x3e, 0xc8, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xd3, 0x8c, 0xc1, 0x96, 0x3a, 0x2d, 0x83, 0xcc, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd3,
0x8c, 0xc1, 0x96, 0x3a, 0x2d, 0x83, 0xcc, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x37, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x86, 0xa9, 0x5e,
0x49, 0x50, 0x91, 0x22, 0xd7, 0xb9, 0x16, 0x62, 0xb1, 0xc5, 0x21, 0xe7,
0x98, 0xb7, 0x8a, 0x88, 0xbd, 0xc4, 0x08, 0xea, 0x34, 0xb8, 0xfa, 0x67,
0xfd, 0x56, 0xfe, 0x8a, 0xe7, 0x1d, 0x6b, 0x23, 0x94, 0xc6, 0xad, 0x36,
0x0f, 0x47, 0xdf, 0xda, 0xa7, 0x8c, 0x40, 0xd1, 0x26, 0x5a, 0xde, 0xbe,
0x9b, 0x6d, 0x64, 0x13, 0x31, 0x8e, 0x1f, 0x9f, 0x2d, 0x4c, 0x56, 0x7e,
0xa2, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x34, 0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x38, 0x38, 0x37, 0x32, 0x39,
0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x02, 0x25, 0x8b, 0xba, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb5,
0x62, 0xc1, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x95, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x28,
0x6d, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xbd, 0x23, 0x9c, 0x26, 0x51, 0x8d, 0x00, 0x33, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x36, 0x9d,
0xb6, 0x54, 0xfc, 0x4a, 0xb6, 0x12, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x33, 0x39, 0x35, 0x35, 0x34, 0x37, 0x32, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x52, 0x79, 0x01, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xd4, 0xf1, 0x90, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x04, 0xc5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x71, 0x64, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x74, 0x80, 0xf7,
0x88, 0xdc, 0x24, 0x7f, 0x87, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0xeb,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xaf, 0x42, 0x82, 0xf4, 0x6e, 0x8f,
0x2f, 0xa4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xaf, 0x42, 0x82, 0xf4, 0x6e, 0x8f, 0x2f, 0xa4,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x9c, 0x82, 0x8b, 0xd8, 0xc1, 0x7f, 0x93, 0xef, 0x8b, 0x5f,
0x6f, 0xb8, 0xae, 0x23, 0x51, 0x6e, 0x06, 0xd0, 0x34, 0x66, 0x85, 0xa3,
0x1a, 0x37, 0xd5, 0x7f, 0x09, 0xb8, 0xda, 0x7b, 0xd6, 0x59, 0xcc, 0x1c,
0x5b, 0xcf, 0x2f, 0xce, 0x2c, 0x47, 0x20, 0xef, 0x2b, 0xd9, 0x15, 0xf9,
0x5b, 0xe8, 0xfe, 0x7e, 0x96, 0x46, 0x3e, 0xa6, 0x73, 0xe0, 0xd3, 0xb3,
0x1d, 0xed, 0xf0, 0x2e, 0x31, 0x48, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x92, 0x95, 0x54, 0x55, 0x2b, 0xd7, 0xf5,
0x6a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x43, 0xbc, 0x17, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xc7, 0x13, 0x15, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x90, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x90, 0xac, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf, 0x76, 0xae, 0x38, 0xb6, 0x5b,
0xb0, 0x03, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xbf, 0x76, 0xae, 0x38, 0xb6, 0x5b, 0xb0, 0x03,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0xbd, 0x24, 0x32, 0x73, 0x57, 0xa6, 0xd3, 0x2e, 0x44, 0x3e,
0xba, 0x10, 0x75, 0x00, 0x88, 0x92, 0xf3, 0x04, 0x22, 0xb6, 0x46, 0x66,
0xe7, 0x85, 0x47, 0xc0, 0x4e, 0xd6, 0xd9, 0x24, 0x65, 0xa0, 0x19, 0x1d,
0xeb, 0x21, 0x32, 0xab, 0x23, 0xdd, 0xc2, 0xc1, 0x3b, 0x11, 0xfb, 0x46,
0x61, 0xfa, 0xb0, 0x5e, 0xc0, 0xa1, 0x46, 0xaf, 0xd1, 0xd7, 0x4b, 0xb8,
0xc0, 0x19, 0x0f, 0x63, 0xe5, 0xed, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xea, 0x55, 0x7b, 0x2e, 0x76, 0xa6, 0x7c,
0x49, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x36, 0x30, 0x34,
0x32, 0x33, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x02, 0x21, 0x08, 0x40, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0xb1, 0x11, 0x0d, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x8c, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x4b, 0x59, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x35, 0x35, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x32, 0x37,
0x30, 0x33, 0x35, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0xc4, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1b, 0x61, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x31, 0xe6, 0xd3, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x5a, 0x7e, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x38, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x35,
0x38, 0x36, 0x38, 0x33, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbc, 0xe7, 0x87, 0xe5, 0x7a, 0x8e,
0xfb, 0x57, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xbc, 0xe7, 0x87, 0xe5, 0x7a, 0x8e, 0xfb, 0x57,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x98, 0x13, 0x61, 0x02, 0x93, 0x48, 0x0a, 0x2d, 0xab,
0xde, 0x93, 0xcc, 0x98, 0x29, 0x32, 0x6a, 0xa1, 0x7f, 0x95, 0x06, 0x96,
0x72, 0xa8, 0xc1, 0xc6, 0x37, 0x72, 0x03, 0xa6, 0x6d, 0xe9, 0x44, 0x48,
0x05, 0x93, 0x91, 0x10, 0xdf, 0xd0, 0x1d, 0x77, 0x59, 0xf3, 0x64, 0xb0,
0x3c, 0x26, 0xb9, 0x8e, 0x86, 0x3e, 0xca, 0x05, 0xf9, 0xcd, 0xcb, 0x9a,
0x4c, 0x56, 0xf4, 0x27, 0xfa, 0x1b, 0x11, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x91, 0xaa, 0xac, 0xc8, 0x05, 0xbc,
0xc2, 0x41, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61,
0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x34, 0x30,
0x36, 0x35, 0x39, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9a,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x03, 0x02, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x4e, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x71, 0x04, 0x04, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x1a, 0x1f, 0x1f, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe7, 0xf2, 0x6e, 0x6f, 0xde, 0x95, 0x70, 0xab,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0xcd, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x30, 0x2b, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe9, 0x64, 0xd0, 0x4e, 0xc4, 0xff, 0x0a, 0x3b, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe9, 0x64,
0xd0, 0x4e, 0xc4, 0xff, 0x0a, 0x3b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xd7, 0x9c, 0x63, 0xee,
0xb8, 0xb5, 0xc3, 0xb3, 0xec, 0x73, 0xde, 0xc0, 0x90, 0xbc, 0xce, 0x6b,
0x88, 0xb9, 0xae, 0x6d, 0xae, 0xed, 0xb6, 0x77, 0xf1, 0x89, 0x13, 0xbf,
0xca, 0xc8, 0xb6, 0xbf, 0x24, 0xff, 0x1c, 0x67, 0x5f, 0x29, 0xf2, 0xf1,
0x2c, 0xc2, 0xba, 0xfc, 0x27, 0xf9, 0xb7, 0x40, 0x56, 0xc0, 0xd7, 0x00,
0x91, 0x54, 0xd0, 0x48, 0xf5, 0x5e, 0x7e, 0xe6, 0x4e, 0x2d, 0x7d, 0x0d,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x64,
0x0b, 0x96, 0xc8, 0xea, 0xa5, 0x3e, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1a,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x6c, 0x6f, 0x63, 0x6b,
0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67,
0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0xd0, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x8d, 0x0e,
0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x02, 0x8a, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x13, 0x09, 0x1a, 0x65, 0x76,
0x61, 0x75, 0x6c, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x64, 0x0b,
0x96, 0xc8, 0xea, 0xa5, 0x3e, 0x0f, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48,
0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x6a,
0x6e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x72, 0xf6, 0x6d,
0x6e, 0x6f, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f,
0x72, 0xf6, 0x6b, 0x75, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x4c, 0x69, 0x6d,
0x69, 0x74, 0xd8, 0xbc, 0x00, 0x78, 0x1f, 0x4c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x4c, 0x6f, 0x63, 0x6b,
0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67,
0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xaa, 0xec, 0xc1, 0xcf,
0xf7, 0x60, 0x8f, 0xa2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46, 0x65, 0x78, 0x69, 0x73,
0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x03, 0x30, 0xd6, 0x2b, 0x15, 0x8e, 0xd3, 0xa8,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x06, 0xd8, 0xa4, 0x1a, 0x00,
0x96, 0x78, 0x73, 0xd8, 0xa4, 0x1a, 0x00, 0xab, 0xa0, 0x5a, 0xd8, 0xa4,
0x1a, 0x00, 0x08, 0x61, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x0c, 0x5b,
0xd8, 0xa4, 0x1a, 0x00, 0xa2, 0x98, 0x39, 0xd8, 0xa4, 0x1a, 0x00, 0x80,
0x96, 0x7d, 0xd8, 0xa4, 0x1a, 0x00, 0xad, 0xf5, 0x95, 0x89, 0xd8, 0xbc,
0x1b, 0x00, 0x00, 0x00, 0x02, 0x4e, 0x16, 0x03, 0x00, 0xd8, 0xbc, 0x1a,
0x1d, 0xcd, 0x65, 0x00, 0xd8, 0xbc, 0x1a, 0x17, 0xd7, 0x84, 0x00, 0xd8,
0xbc, 0x1a, 0x11, 0xe1, 0xa3, 0x00, 0xd8, 0xbc, 0x1b, 0x00, 0x00, 0x00,
0x01, 0x59, 0xb4, 0xfa, 0x00, 0xd8, 0xbc, 0x1a, 0x11, 0xe1, 0xa3, 0x00,
0xd8, 0xbc, 0x1a, 0x17, 0xd7, 0x84, 0x00, 0xd8, 0xbc, 0x1a, 0x17, 0xd7,
0x84, 0x00, 0xd8, 0xbc, 0x1a, 0x3b, 0x9a, 0xca, 0x00, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb9, 0xbe, 0xc4, 0x75, 0x4d, 0x61,
0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x34, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x33, 0x30, 0x35, 0x33, 0x39,
0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xf8, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x5b, 0xee, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0xfd, 0x2e, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb6, 0x82, 0x7d, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x31, 0xd1, 0xdd, 0xf8, 0xbc, 0x0d, 0x82, 0xfd, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x31, 0xd1, 0xdd, 0xf8, 0xbc, 0x0d, 0x82, 0xfd, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x4d, 0x38,
0xc0, 0xd3, 0x28, 0x69, 0xc2, 0x6e, 0x3f, 0x8b, 0x9c, 0x2e, 0xc7, 0x98,
0x9a, 0x93, 0x96, 0xfe, 0xd4, 0x42, 0x68, 0x2a, 0x57, 0x94, 0xba, 0x27,
0xfa, 0x8e, 0xd5, 0xf4, 0xd8, 0x2b, 0x9f, 0x68, 0x19, 0xe9, 0x0f, 0x65,
0xd0, 0x1a, 0xbe, 0x7a, 0x26, 0x44, 0xc2, 0xc4, 0x5b, 0x8f, 0x6a, 0x04,
0xa7, 0x37, 0x37, 0x91, 0x8d, 0x72, 0x85, 0xe9, 0x99, 0x2d, 0xdd, 0x04,
0x22, 0x4b, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xd2, 0xb9, 0x13, 0x76, 0x57, 0x50, 0xf2, 0xe6, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd2,
0xb9, 0x13, 0x76, 0x57, 0x50, 0xf2, 0xe6, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x40, 0x2e, 0x0f,
0xcb, 0x4c, 0x17, 0x83, 0x23, 0x07, 0x1e, 0xa0, 0x3f, 0xae, 0xbe, 0x32,
0xd0, 0x57, 0xea, 0xf4, 0x32, 0x54, 0x2a, 0xbc, 0xa7, 0x1e, 0x18, 0x18,
0x69, 0xb4, 0x7d, 0x7c, 0x03, 0xc5, 0x04, 0x37, 0x42, 0x8b, 0xe9, 0x89,
0xbd, 0xaf, 0xc8, 0xc7, 0x37, 0x63, 0x90, 0x28, 0x1a, 0xa0, 0xda, 0x07,
0x64, 0x28, 0x64, 0xab, 0x02, 0x6a, 0x4f, 0x09, 0x0a, 0x8b, 0x66, 0x81,
0x84, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x06, 0x88, 0x70, 0x90, 0x30, 0x3c, 0x18, 0x71, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x98,
0xa7, 0xd8, 0xa4, 0x1a, 0x00, 0x03, 0xe1, 0x30, 0xd8, 0xa4, 0x1a, 0x00,
0x3f, 0xb4, 0xe6, 0xd8, 0xa4, 0x1a, 0x00, 0x41, 0xb9, 0x01, 0xd8, 0xa4,
0x1a, 0x00, 0x44, 0x13, 0x7d, 0xd8, 0xa4, 0x1a, 0x00, 0x48, 0x70, 0x04,
0xd8, 0xa4, 0x1a, 0x00, 0x49, 0x34, 0xd3, 0xd8, 0xa4, 0x1a, 0x00, 0x02,
0x6c, 0x24, 0xd8, 0xa4, 0x1a, 0x00, 0x19, 0x79, 0xc8, 0xd8, 0xa4, 0x1a,
0x00, 0x29, 0xf6, 0x9d, 0xd8, 0xa4, 0x1a, 0x00, 0x38, 0x43, 0x87, 0xd8,
0xa4, 0x1a, 0x00, 0x37, 0x1d, 0xa3, 0xd8, 0xa4, 0x1a, 0x00, 0x38, 0xa5,
0x8f, 0xd8, 0xa4, 0x1a, 0x00, 0x4a, 0xe9, 0xd5, 0xd8, 0xa4, 0x1a, 0x00,
0x4b, 0x5e, 0x99, 0xd8, 0xa4, 0x1a, 0x00, 0x34, 0xc8, 0x26, 0xd8, 0xa4,
0x1a, 0x00, 0x4b, 0x24, 0x30, 0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0xd4, 0x5f,
0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0x99, 0x8d, 0xd8, 0xa4, 0x1a, 0x00, 0x0e,
0x16, 0x28, 0xd8, 0xa4, 0x1a, 0x00, 0x10, 0xa1, 0x22, 0xd8, 0xa4, 0x1a,
0x00, 0x0f, 0xd3, 0x3f, 0xd8, 0xa4, 0x1a, 0x00, 0x10, 0x31, 0x61, 0xd8,
0xa4, 0x1a, 0x00, 0x12, 0xdd, 0xb4, 0xd8, 0xa4, 0x1a, 0x00, 0x10, 0x60,
0x85, 0xd8, 0xa4, 0x1a, 0x00, 0x5b, 0xf0, 0x57, 0xd8, 0xa4, 0x1a, 0x00,
0x32, 0x2f, 0x40, 0xd8, 0xa4, 0x1a, 0x00, 0x73, 0xfe, 0x04, 0xd8, 0xa4,
0x1a, 0x00, 0x01, 0x39, 0xcd, 0xd8, 0xa4, 0x1a, 0x00, 0x01, 0x4a, 0x25,
0xd8, 0xa4, 0x1a, 0x00, 0x04, 0x3c, 0x57, 0xd8, 0xa4, 0x1a, 0x00, 0x74,
0x18, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x13, 0x67, 0x28, 0xd8, 0xa4, 0x1a,
0x00, 0x02, 0x10, 0xfb, 0xd8, 0xa4, 0x1a, 0x00, 0x28, 0x9b, 0x1d, 0xd8,
0xa4, 0x1a, 0x00, 0x11, 0xc6, 0x1d, 0xd8, 0xa4, 0x1a, 0x00, 0x02, 0xee,
0x60, 0xd8, 0xa4, 0x1a, 0x00, 0x08, 0x0d, 0x3c, 0xd8, 0xa4, 0x1a, 0x00,
0x60, 0x45, 0xa8, 0xd8, 0xa4, 0x1a, 0x00, 0x6e, 0xb7, 0x34, 0xd8, 0xa4,
0x1a, 0x00, 0x21, 0x91, 0xcd, 0xd8, 0xa4, 0x1a, 0x00, 0x0a, 0x54, 0x68,
0xd8, 0xa4, 0x1a, 0x00, 0x78, 0x57, 0x50, 0xd8, 0xa4, 0x1a, 0x00, 0x11,
0xf3, 0xe0, 0xd8, 0xa4, 0x1a, 0x00, 0x0f, 0x16, 0xfa, 0xd8, 0xa4, 0x1a,
0x00, 0x1b, 0xa3, 0xc8, 0xd8, 0xa4, 0x1a, 0x00, 0x0c, 0xd9, 0x34, 0xd8,
0xa4, 0x1a, 0x00, 0x7b, 0x39, 0x00, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0xbe,
0x88, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0xb5, 0x2c, 0xd8, 0xa4, 0x1a, 0x00,
0x40, 0xeb, 0x33, 0xd8, 0xa4, 0x1a, 0x00, 0x44, 0xf7, 0xfa, 0xd8, 0xa4,
0x1a, 0x00, 0x63, 0x5d, 0x59, 0xd8, 0xa4, 0x1a, 0x00, 0x1f, 0x3b, 0xe8,
0xd8, 0xa4, 0x1a, 0x00, 0x7a, 0xe0, 0xdc, 0xd8, 0xa4, 0x1a, 0x00, 0x22,
0xc3, 0x96, 0xd8, 0xa4, 0x1a, 0x00, 0x5c, 0x5d, 0x96, 0xd8, 0xa4, 0x1a,
0x00, 0x91, 0x7e, 0x28, 0xd8, 0xa4, 0x1a, 0x00, 0x2d, 0xc0, 0x03, 0xd8,
0xa4, 0x1a, 0x00, 0x90, 0xc2, 0xb8, 0xd8, 0xa4, 0x1a, 0x00, 0x49, 0x98,
0x9d, 0xd8, 0xa4, 0x1a, 0x00, 0x0d, 0x7c, 0x43, 0xd8, 0xa4, 0x1a, 0x00,
0x12, 0x81, 0xbf, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0x5e, 0xb7, 0xd8, 0xa4,
0x1a, 0x00, 0x1d, 0x51, 0x53, 0xd8, 0xa4, 0x1a, 0x00, 0x1e, 0x24, 0x96,
0xd8, 0xa4, 0x1a, 0x00, 0x6b, 0x87, 0xec, 0xd8, 0xa4, 0x1a, 0x00, 0x91,
0x98, 0x8a, 0xd8, 0xa4, 0x1a, 0x00, 0x36, 0x0a, 0x63, 0xd8, 0xa4, 0x1a,
0x00, 0x3a, 0xd9, 0xaf, 0xd8, 0xa4, 0x1a, 0x00, 0x2a, 0xd8, 0xd0, 0xd8,
0xa4, 0x1a, 0x00, 0x77, 0x6d, 0xed, 0xd8, 0xa4, 0x1a, 0x00, 0x41, 0xab,
0xb2, 0xd8, 0xa4, 0x1a, 0x00, 0x11, 0xf9, 0xea, 0xd8, 0xa4, 0x1a, 0x00,
0x7e, 0x36, 0xd4, 0xd8, 0xa4, 0x1a, 0x00, 0x03, 0x05, 0x72, 0xd8, 0xa4,
0x1a, 0x00, 0x93, 0x18, 0x4e, 0xd8, 0xa4, 0x1a, 0x00, 0x94, 0x81, 0xbd,
0xd8, 0xa4, 0x1a, 0x00, 0x6a, 0x89, 0xe0, 0xd8, 0xa4, 0x1a, 0x00, 0x97,
0xa2, 0x7e, 0xd8, 0xa4, 0x1a, 0x00, 0x28, 0x86, 0x73, 0xd8, 0xa4, 0x1a,
0x00, 0x91, 0xb3, 0x6b, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0xca, 0x7a, 0xd8,
0xa4, 0x1a, 0x00, 0x92, 0x3b, 0xe6, 0xd8, 0xa4, 0x1a, 0x00, 0x91, 0xf8,
0x3e, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x83, 0xa5, 0xd8, 0xa4, 0x1a, 0x00,
0x93, 0x5b, 0x92, 0xd8, 0xa4, 0x1a, 0x00, 0x93, 0xa0, 0xd9, 0xd8, 0xa4,
0x1a, 0x00, 0x24, 0x4a, 0xc0, 0xd8, 0xa4, 0x1a, 0x00, 0x0f, 0xde, 0xe4,
0xd8, 0xa4, 0x1a, 0x00, 0x11, 0xf0, 0xb4, 0xd8, 0xa4, 0x1a, 0x00, 0xa1,
0x86, 0xd6, 0xd8, 0xa4, 0x1a, 0x00, 0x12, 0x07, 0x43, 0xd8, 0xa4, 0x1a,
0x00, 0x9b, 0x85, 0x39, 0xd8, 0xa4, 0x1a, 0x00, 0xa2, 0x1f, 0x27, 0xd8,
0xa4, 0x1a, 0x00, 0xa8, 0xf5, 0x34, 0xd8, 0xa4, 0x1a, 0x00, 0xac, 0xeb,
0x85, 0xd8, 0xa4, 0x1a, 0x00, 0xaf, 0x6a, 0xc8, 0xd8, 0xa4, 0x1a, 0x00,
0xa4, 0x75, 0xdb, 0xd8, 0xa4, 0x1a, 0x00, 0x14, 0x1c, 0xd5, 0xd8, 0xa4,
0x1a, 0x00, 0xaf, 0xaa, 0xe4, 0xd8, 0xa4, 0x1a, 0x00, 0x9c, 0x71, 0xe9,
0xd8, 0xa4, 0x1a, 0x00, 0xa1, 0xe6, 0x78, 0xd8, 0xa4, 0x1a, 0x00, 0xad,
0xed, 0x14, 0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0x34, 0x2d, 0xd8, 0xa4, 0x1a,
0x00, 0x0c, 0xdc, 0x5e, 0xd8, 0xa4, 0x1a, 0x00, 0x94, 0xe9, 0xa5, 0xd8,
0xa4, 0x1a, 0x00, 0x50, 0xe2, 0x61, 0xd8, 0xa4, 0x1a, 0x00, 0x4f, 0xf8,
0x66, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x8c, 0xf6, 0xd8, 0xa4, 0x1a, 0x00,
0x9e, 0x1d, 0xc2, 0xd8, 0xa4, 0x1a, 0x00, 0xad, 0x4c, 0xc5, 0xd8, 0xa4,
0x1a, 0x00, 0xa4, 0x28, 0x22, 0xd8, 0xa4, 0x1a, 0x00, 0xb9, 0xbe, 0x72,
0xd8, 0xa4, 0x1a, 0x00, 0xb3, 0x97, 0x18, 0xd8, 0xa4, 0x1a, 0x00, 0xa2,
0x37, 0xa9, 0xd8, 0xa4, 0x1a, 0x00, 0xad, 0x09, 0xca, 0xd8, 0xa4, 0x1a,
0x00, 0xa8, 0xb3, 0x2e, 0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0xde, 0x8f, 0xd8,
0xa4, 0x1a, 0x00, 0x66, 0x41, 0x61, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0xdd,
0xb4, 0xd8, 0xa4, 0x1a, 0x00, 0xba, 0x94, 0x39, 0xd8, 0xa4, 0x1a, 0x00,
0xb3, 0x8c, 0x46, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xc2, 0x14, 0xd8, 0xa4,
0x1a, 0x00, 0xa8, 0xb0, 0xbe, 0xd8, 0xa4, 0x1a, 0x00, 0xb9, 0xd5, 0x47,
0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0xd9, 0x91, 0xd8, 0xa4, 0x1a, 0x00, 0xa8,
0xeb, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xf2, 0x8a, 0xd8, 0xa4, 0x1a,
0x00, 0xad, 0xb5, 0xe2, 0xd8, 0xa4, 0x1a, 0x00, 0xa8, 0xb3, 0x75, 0xd8,
0xa4, 0x1a, 0x00, 0xa8, 0xb2, 0x6d, 0xd8, 0xa4, 0x1a, 0x00, 0xb3, 0x84,
0x7c, 0xd8, 0xa4, 0x1a, 0x00, 0xa8, 0xa9, 0x38, 0xd8, 0xa4, 0x1a, 0x00,
0xa6, 0x2f, 0x16, 0xd8, 0xa4, 0x1a, 0x00, 0xa4, 0x98, 0xa3, 0xd8, 0xa4,
0x1a, 0x00, 0xcb, 0xaa, 0x51, 0xd8, 0xa4, 0x1a, 0x00, 0xc0, 0x85, 0x89,
0xd8, 0xa4, 0x1a, 0x00, 0xb1, 0x9d, 0xda, 0xd8, 0xa4, 0x1a, 0x00, 0xcd,
0xe4, 0x8e, 0xd8, 0xa4, 0x1a, 0x00, 0xb7, 0x35, 0xca, 0xd8, 0xa4, 0x1a,
0x00, 0xca, 0x1e, 0x80, 0xd8, 0xa4, 0x1a, 0x00, 0xcb, 0xcd, 0x6d, 0xd8,
0xa4, 0x1a, 0x00, 0xca, 0x63, 0x90, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xfd,
0xcc, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xa9, 0xe3, 0xd8, 0xa4, 0x1a, 0x00,
0xc9, 0xda, 0x81, 0xd8, 0xa4, 0x1a, 0x00, 0xdf, 0xd3, 0x76, 0xd8, 0xa4,
0x1a, 0x00, 0xb6, 0x97, 0xe9, 0xd8, 0xa4, 0x1a, 0x00, 0xa8, 0x21, 0x1c,
0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0x12, 0x16, 0xd8, 0xa4, 0x1a, 0x00, 0xcc,
0x0e, 0x28, 0xd8, 0xa4, 0x1a, 0x00, 0xcb, 0x3f, 0x22, 0xd8, 0xa4, 0x1a,
0x00, 0x41, 0xa8, 0x7d, 0xd8, 0xa4, 0x1a, 0x00, 0xa1, 0x3d, 0x80, 0xd8,
0xa4, 0x1a, 0x00, 0xa1, 0x53, 0xea, 0xd8, 0xa4, 0x1a, 0x00, 0x29, 0x0e,
0xfd, 0xd8, 0xa4, 0x1a, 0x00, 0x29, 0x3c, 0x70, 0xd8, 0xa4, 0x1a, 0x00,
0x29, 0x02, 0x8a, 0xd8, 0xa4, 0x1a, 0x00, 0x17, 0xbb, 0x28, 0xd8, 0xa4,
0x1a, 0x00, 0x17, 0xc5, 0x20, 0xd8, 0xa4, 0x1a, 0x00, 0x17, 0xc5, 0xa6,
0xd8, 0xa4, 0x1a, 0x00, 0x17, 0x8b, 0x97, 0xd8, 0xa4, 0x1a, 0x00, 0x28,
0xfb, 0xc8, 0xd8, 0xa4, 0x1a, 0x00, 0x4c, 0x2e, 0x49, 0xd8, 0xa4, 0x1a,
0x00, 0x17, 0xa6, 0x41, 0xd8, 0xa4, 0x1a, 0x00, 0x39, 0x77, 0xaa, 0xd8,
0xa4, 0x1a, 0x00, 0x10, 0xa8, 0x20, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x01, 0xdb, 0x10, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x01, 0xea, 0xbb, 0x0a,
0xcd, 0x96, 0x10, 0x8e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x30,
0x34, 0x35, 0x35, 0x35, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x03, 0xa9, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x75, 0x5c, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x7a, 0xc3, 0xf3,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x8a, 0x3a, 0xb4,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x08, 0xcc, 0x9d, 0x6d, 0x53, 0xb8, 0x4a, 0x31, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x7a, 0x49, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xb7,
0xcf, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xc0, 0x99, 0xd8, 0xa4, 0x1a, 0x00,
0x80, 0xdd, 0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xe3, 0xc1, 0xd8, 0xa4,
0x1a, 0x00, 0x80, 0xef, 0x79, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xfb, 0x31,
0xd8, 0xa4, 0x1a, 0x00, 0x81, 0x27, 0x23, 0xd8, 0xa4, 0x1a, 0x00, 0x81,
0x56, 0x03, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0x93, 0x89, 0xd8, 0xa4, 0x1a,
0x00, 0x81, 0xa5, 0x1d, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xb6, 0xb1, 0xd8,
0xa4, 0x1a, 0x00, 0x81, 0xb9, 0x9f, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xbf,
0x7b, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xce, 0x21, 0xd8, 0xa4, 0x1a, 0x00,
0x81, 0xdf, 0xb5, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xee, 0x5b, 0xd8, 0xa4,
0x1a, 0x00, 0x81, 0xf4, 0x37, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xf7, 0x25,
0xd8, 0xa4, 0x1a, 0x00, 0x81, 0xfa, 0x13, 0xd8, 0xa4, 0x1a, 0x00, 0x82,
0x1a, 0x4d, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0x20, 0x29, 0xd8, 0xa4, 0x1a,
0x00, 0x82, 0x23, 0x17, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0x2b, 0xe1, 0xd8,
0xa4, 0x1a, 0x00, 0x82, 0x31, 0xbd, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0x40,
0x63, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0x57, 0xd3, 0xd8, 0xa4, 0x1a, 0x00,
0x82, 0x60, 0x9d, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0x63, 0x8b, 0xd8, 0xa4,
0x1a, 0x00, 0x82, 0x75, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0xbe, 0x5d,
0xd8, 0xa4, 0x1a, 0x00, 0x82, 0xc7, 0x27, 0xd8, 0xa4, 0x1a, 0x00, 0x82,
0xcf, 0xf1, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0xd2, 0xdf, 0xd8, 0xa4, 0x1a,
0x00, 0x82, 0xf0, 0x2b, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x19, 0x2f, 0xd8,
0xa4, 0x1a, 0x00, 0x83, 0x36, 0x7b, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x3c,
0x57, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x4d, 0xeb, 0xd8, 0xa4, 0x1a, 0x00,
0x83, 0x6b, 0x37, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0x79, 0xdd, 0xd8, 0xa4,
0x1a, 0x00, 0x83, 0x94, 0x3b, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0xb4, 0x75,
0xd8, 0xa4, 0x1a, 0x00, 0x83, 0xc8, 0xf7, 0xd8, 0xa4, 0x1a, 0x00, 0x83,
0xcb, 0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0x83, 0xda, 0x8b, 0xd8, 0xa4, 0x1a,
0x00, 0x83, 0xe0, 0x67, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0x2f, 0x81, 0xd8,
0xa4, 0x1a, 0x00, 0x84, 0x5e, 0x61, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0x6f,
0xf5, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0x8d, 0x41, 0xd8, 0xa4, 0x1a, 0x00,
0x84, 0x98, 0xf9, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0xa7, 0x9f, 0xd8, 0xa4,
0x1a, 0x00, 0x84, 0xca, 0xc7, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0xd0, 0xa3,
0xd8, 0xa4, 0x1a, 0x00, 0x84, 0xed, 0xef, 0xd8, 0xa4, 0x1a, 0x00, 0x84,
0xf0, 0xdd, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0xf3, 0xcb, 0xd8, 0xa4, 0x1a,
0x00, 0x84, 0xff, 0x83, 0xd8, 0xa4, 0x1a, 0x00, 0x85, 0x16, 0xf3, 0xd8,
0xa4, 0x1a, 0x00, 0x85, 0x19, 0xe1, 0xd8, 0xa4, 0x1a, 0x00, 0x85, 0x2e,
0x63, 0xd8, 0xa4, 0x1a, 0x00, 0x85, 0x51, 0x8b, 0xd8, 0xa4, 0x1a, 0x00,
0x85, 0x63, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x85, 0x71, 0xc5, 0xd8, 0xa4,
0x1a, 0x00, 0x85, 0x91, 0xff, 0xd8, 0xa4, 0x1a, 0x00, 0x85, 0xbd, 0xf1,
0xd8, 0xa4, 0x1a, 0x00, 0x85, 0xdb, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0x86,
0x01, 0x53, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x1e, 0x9f, 0xd8, 0xa4, 0x1a,
0x00, 0x86, 0x27, 0x69, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x3b, 0xeb, 0xd8,
0xa4, 0x1a, 0x00, 0x86, 0x41, 0xc7, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x4a,
0x91, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x4d, 0x7f, 0xd8, 0xa4, 0x1a, 0x00,
0x86, 0x50, 0x6d, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x56, 0x49, 0xd8, 0xa4,
0x1a, 0x00, 0x86, 0x62, 0x01, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x67, 0xdd,
0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x6a, 0xcb, 0xd8, 0xa4, 0x1a, 0x00, 0x86,
0x76, 0x83, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x8d, 0xf3, 0xd8, 0xa4, 0x1a,
0x00, 0x86, 0x90, 0xe1, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x9c, 0x99, 0xd8,
0xa4, 0x1a, 0x00, 0x86, 0xb6, 0xf7, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0xb9,
0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0xbf, 0xc1, 0xd8, 0xa4, 0x1a, 0x00,
0x86, 0xd7, 0x31, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0xf4, 0x7d, 0xd8, 0xa4,
0x1a, 0x00, 0x86, 0xfa, 0x59, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x14, 0xb7,
0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x29, 0x39, 0xd8, 0xa4, 0x1a, 0x00, 0x87,
0x32, 0x03, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x43, 0x97, 0xd8, 0xa4, 0x1a,
0x00, 0x87, 0x49, 0x73, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x58, 0x19, 0xd8,
0xa4, 0x1a, 0x00, 0x87, 0x66, 0xbf, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x72,
0x77, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0x7e, 0x2f, 0xd8, 0xa4, 0x1a, 0x00,
0x87, 0xca, 0x5b, 0xd8, 0xa4, 0x1a, 0x00, 0x87, 0xd6, 0x13, 0xd8, 0xa4,
0x1a, 0x00, 0x87, 0xed, 0x83, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x04, 0xf3,
0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x1c, 0x63, 0xd8, 0xa4, 0x1a, 0x00, 0x88,
0x28, 0x1b, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x2d, 0xf7, 0xd8, 0xa4, 0x1a,
0x00, 0x88, 0x39, 0xaf, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x48, 0x55, 0xd8,
0xa4, 0x1a, 0x00, 0x88, 0x4b, 0x43, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x4e,
0x31, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x56, 0xfb, 0xd8, 0xa4, 0x1a, 0x00,
0x88, 0x74, 0x47, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0x91, 0x93, 0xd8, 0xa4,
0x1a, 0x00, 0x88, 0xba, 0x97, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xbd, 0x85,
0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xc0, 0x73, 0xd8, 0xa4, 0x1a, 0x00, 0x88,
0xc9, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xcc, 0x2b, 0xd8, 0xa4, 0x1a,
0x00, 0x88, 0xdd, 0xbf, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xe9, 0x77, 0xd8,
0xa4, 0x1a, 0x00, 0x88, 0xef, 0x53, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xfd,
0xf9, 0xd8, 0xa4, 0x1a, 0x00, 0x89, 0x2c, 0xd9, 0xd8, 0xa4, 0x1a, 0x00,
0x89, 0x41, 0x5b, 0xd8, 0xa4, 0x1a, 0x00, 0x89, 0x4d, 0x13, 0xd8, 0xa4,
0x1a, 0x00, 0x89, 0x52, 0xef, 0xd8, 0xa4, 0x1a, 0x00, 0x89, 0x73, 0x29,
0xd8, 0xa4, 0x1a, 0x00, 0x89, 0x87, 0xab, 0xd8, 0xa4, 0x1a, 0x00, 0x89,
0xa2, 0x09, 0xd8, 0xa4, 0x1a, 0x00, 0x89, 0xc2, 0x43, 0xd8, 0xa4, 0x1a,
0x00, 0x89, 0xeb, 0x47, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0x02, 0xb7, 0xd8,
0xa4, 0x1a, 0x00, 0x8a, 0x40, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0x43,
0x2b, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0x4e, 0xe3, 0xd8, 0xa4, 0x1a, 0x00,
0x8a, 0x95, 0x33, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xa6, 0xc7, 0xd8, 0xa4,
0x1a, 0x00, 0x8a, 0xaf, 0x91, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xc1, 0x25,
0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xc9, 0xef, 0xd8, 0xa4, 0x1a, 0x00, 0x8a,
0xd5, 0xa7, 0xd8, 0xa4, 0x1a, 0x00, 0x8a, 0xe1, 0x5f, 0xd8, 0xa4, 0x1a,
0x00, 0x8b, 0x27, 0xaf, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0x33, 0x67, 0xd8,
0xa4, 0x1a, 0x00, 0x8b, 0x3c, 0x31, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0x56,
0x8f, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0x5c, 0x6b, 0xd8, 0xa4, 0x1a, 0x00,
0x8b, 0x7f, 0x93, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0x85, 0x6f, 0xd8, 0xa4,
0x1a, 0x00, 0x8b, 0x8b, 0x4b, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0xab, 0x85,
0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0xae, 0x73, 0xd8, 0xa4, 0x1a, 0x00, 0x8b,
0xc8, 0xd1, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0xcb, 0xbf, 0xd8, 0xa4, 0x1a,
0x00, 0x8b, 0xe0, 0x41, 0xd8, 0xa4, 0x1a, 0x00, 0x8b, 0xf7, 0xb1, 0xd8,
0xa4, 0x1a, 0x00, 0x8c, 0x00, 0x7b, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x35,
0x37, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x40, 0xef, 0xd8, 0xa4, 0x1a, 0x00,
0x8c, 0x46, 0xcb, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x4f, 0x95, 0xd8, 0xa4,
0x1a, 0x00, 0x8c, 0x64, 0x17, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x72, 0xbd,
0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x75, 0xab, 0xd8, 0xa4, 0x1a, 0x00, 0x8c,
0x84, 0x51, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x8d, 0x1b, 0xd8, 0xa4, 0x1a,
0x00, 0x8c, 0x92, 0xf7, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0xc7, 0xb3, 0xd8,
0xa4, 0x1a, 0x00, 0x8c, 0xd6, 0x59, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0xdf,
0x23, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0xe2, 0x11, 0xd8, 0xa4, 0x1a, 0x00,
0x8c, 0xe4, 0xff, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0x28, 0x61, 0xd8, 0xa4,
0x1a, 0x00, 0x8d, 0x57, 0x41, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0x68, 0xd5,
0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0x71, 0x9f, 0xd8, 0xa4, 0x1a, 0x00, 0x8d,
0x94, 0xc7, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0xa0, 0x7f, 0xd8, 0xa4, 0x1a,
0x00, 0x8d, 0xa3, 0x6d, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0xa9, 0x49, 0xd8,
0xa4, 0x1a, 0x00, 0x8d, 0xbd, 0xcb, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0xc3,
0xa7, 0xd8, 0xa4, 0x1a, 0x00, 0x8d, 0xc6, 0x95, 0xd8, 0xa4, 0x1a, 0x00,
0x8e, 0x07, 0x09, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x18, 0x9d, 0xd8, 0xa4,
0x1a, 0x00, 0x8e, 0x1e, 0x79, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x21, 0x67,
0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x2d, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x8e,
0x32, 0xfb, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x5b, 0xff, 0xd8, 0xa4, 0x1a,
0x00, 0x8e, 0x64, 0xc9, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x87, 0xf1, 0xd8,
0xa4, 0x1a, 0x00, 0x8e, 0x8a, 0xdf, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0x90,
0xbb, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xa5, 0x3d, 0xd8, 0xa4, 0x1a, 0x00,
0x8e, 0xb0, 0xf5, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xcb, 0x53, 0xd8, 0xa4,
0x1a, 0x00, 0x8e, 0xdf, 0xd5, 0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xf1, 0x69,
0xd8, 0xa4, 0x1a, 0x00, 0x8e, 0xf4, 0x57, 0xd8, 0xa4, 0x1a, 0x00, 0x8f,
0x00, 0x0f, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x05, 0xeb, 0xd8, 0xa4, 0x1a,
0x00, 0x8f, 0x1a, 0x6d, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x3d, 0x95, 0xd8,
0xa4, 0x1a, 0x00, 0x8f, 0x46, 0x5f, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x4c,
0x3b, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x92, 0x8b, 0xd8, 0xa4, 0x1a, 0x00,
0x8f, 0xd8, 0xdb, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0xde, 0xb7, 0xd8, 0xa4,
0x1a, 0x00, 0x8f, 0xe4, 0x93, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x1f, 0x2b,
0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x36, 0x9b, 0xd8, 0xa4, 0x1a, 0x00, 0x90,
0x74, 0x21, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x7c, 0xeb, 0xd8, 0xa4, 0x1a,
0x00, 0x90, 0xb7, 0x83, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0xe0, 0x87, 0xd8,
0xa4, 0x1a, 0x00, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x38, 0x30, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x33, 0x35, 0x38, 0x31, 0x30, 0x38, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2e, 0x4d, 0x00, 0xa3,
0xfb, 0xea, 0x3b, 0x62, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2e, 0x4d, 0x00, 0xa3, 0xfb, 0xea,
0x3b, 0x62, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xe8, 0x11, 0x81, 0x80, 0xff, 0xd0, 0x36, 0x85,
0x7d, 0xac, 0x66, 0xfe, 0xcd, 0x72, 0xae, 0x04, 0x33, 0x4c, 0x67, 0x07,
0x83, 0x92, 0xe9, 0x0e, 0xab, 0x33, 0xd2, 0x93, 0xc2, 0x76, 0x97, 0x66,
0xd3, 0x54, 0x2a, 0x8f, 0x13, 0x4e, 0x93, 0x88, 0x9e, 0x4a, 0x33, 0x03,
0x4c, 0x41, 0x92, 0x9f, 0xfc, 0xe7, 0xfc, 0xc1, 0xeb, 0x88, 0x9c, 0x54,
0x36, 0x77, 0x72, 0xae, 0x92, 0x1f, 0x35, 0xce, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x44, 0x15, 0xd8, 0x27, 0xd9,
0x6b, 0x11, 0x8d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x31, 0x30,
0x36, 0x33, 0x39, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0x1e, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1b, 0x08, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x20, 0x24, 0x1d, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x30, 0x51, 0xaf, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x2c, 0xe8, 0x25, 0x4d, 0x80, 0xad, 0x7b,
0x9f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x2c, 0xe8, 0x25, 0x4d, 0x80, 0xad, 0x7b, 0x9f, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x25, 0x9d, 0xc3, 0xdd, 0x1c, 0x50, 0x8e, 0xd6, 0xd3, 0x5d, 0x25,
0xd6, 0xa0, 0x65, 0x4b, 0x5a, 0xc9, 0x55, 0x3e, 0x2e, 0x33, 0x72, 0xc2,
0xa0, 0x1c, 0xc7, 0xec, 0x13, 0x07, 0x70, 0x28, 0x65, 0xba, 0xcb, 0x37,
0xfe, 0x0d, 0x62, 0x4e, 0x71, 0x36, 0x85, 0x1f, 0xf9, 0x0c, 0xc8, 0xaa,
0x42, 0xe0, 0x5b, 0xf5, 0xb8, 0x62, 0x78, 0xf7, 0xf2, 0x01, 0xf1, 0x1e,
0x3f, 0xa7, 0x9c, 0x13, 0x24, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xb0, 0xd2, 0x55, 0x5d, 0x87, 0xc1, 0x88, 0xb4,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x30, 0x30, 0x35, 0x34, 0x36,
0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x8f, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x4e, 0x93, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2d, 0xdc, 0x15, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x88, 0xa3, 0xbe, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xfc, 0xce, 0x35, 0xe8, 0x99, 0x4d, 0xcf, 0x5f, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x35, 0x39, 0x33, 0x34, 0x36, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02,
0x20, 0xdb, 0xa4, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb0, 0xe6,
0xf8, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0x8c, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x21, 0x44,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x93, 0x7d, 0xb6, 0xaf, 0x8f, 0xa2, 0x6d, 0xc8, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x33, 0x33, 0x30, 0x38, 0x38, 0x30, 0x39, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x47,
0xe4, 0x50, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcb, 0x13, 0x89,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x25, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0xae, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2f, 0xed, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x9a, 0x5a, 0xed, 0x7c, 0xed, 0x23, 0x45, 0x57, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x5d, 0x1f, 0x65,
0x0f, 0x09, 0x08, 0x78, 0x74, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x35, 0x33, 0x38, 0x33, 0x37, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xa0, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x7d, 0x2d, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x63, 0xc4,
0x8b, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x08, 0xb1,
0xd6, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x23, 0x7a, 0x1c, 0x0f, 0xdc,
0x52, 0xa1, 0xfe, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x35, 0x30,
0x37, 0x30, 0x30, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0xe2, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1d, 0xee, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x35, 0x83, 0x40, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x94, 0x37, 0xee, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xa4, 0x9d, 0x24, 0x46, 0xc1, 0x8e, 0xe8,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x34, 0x34, 0x33, 0x30,
0x31, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x01, 0xdd,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x34, 0x5f, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x25, 0x47, 0x04, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x44, 0x72, 0x3d, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xc1, 0xa0, 0x7e, 0xae, 0xd5, 0xc6, 0x53, 0xab, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31, 0x33, 0x32, 0x35, 0x34, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xa1, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x5a, 0x9a, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x2f, 0xcc, 0x7c, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x49, 0x70, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xdf, 0x3d, 0x72, 0xdf, 0x6d, 0xb0, 0x71, 0xe2, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65,
0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0b, 0x0e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7a, 0x03,
0x11, 0x8e, 0xcf, 0xc3, 0x92, 0xa5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7a, 0x03, 0x11, 0x8e,
0xcf, 0xc3, 0x92, 0xa5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xf2, 0xd6, 0x4a, 0x59, 0xb8, 0x38,
0xc5, 0xf0, 0xb4, 0xed, 0x04, 0xef, 0xb7, 0x7d, 0xe5, 0xfb, 0xa1, 0xfe,
0x2b, 0xa1, 0x56, 0x89, 0x63, 0x5b, 0x55, 0x36, 0xd0, 0xb1, 0x28, 0x34,
0x17, 0x14, 0xb1, 0x5d, 0x7c, 0x7a, 0x27, 0x3d, 0x18, 0xa1, 0x09, 0xbd,
0x72, 0x7f, 0xb3, 0x2c, 0xc1, 0x1b, 0x23, 0x0a, 0x1e, 0xbc, 0xe5, 0x9e,
0xc4, 0xc7, 0x78, 0x9c, 0xbe, 0xe5, 0xa5, 0xea, 0x68, 0x54, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x07, 0xdb, 0x1b,
0xf2, 0x24, 0x02, 0xbc, 0xe4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x77, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8,
0x81, 0x82, 0x86, 0xd8, 0xa4, 0x1a, 0x00, 0x72, 0xa6, 0xc7, 0xd8, 0xa4,
0x1a, 0x00, 0x8f, 0x04, 0xb0, 0xd8, 0xa4, 0x1a, 0x00, 0x81, 0x36, 0xf7,
0xd8, 0xa4, 0x1a, 0x00, 0x83, 0xb4, 0x3b, 0xd8, 0xa4, 0x1a, 0x00, 0x97,
0x90, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x38, 0x33, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x30, 0x32, 0x39, 0x33, 0x32, 0x38, 0x33, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xf2, 0x18, 0xc3, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x9d, 0x10, 0x23, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x04, 0x26, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x15, 0x07, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcb, 0x8b, 0xeb,
0x17, 0xdd, 0xfb, 0x1b, 0x2a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x30, 0x37, 0x39, 0x37, 0x34, 0x31, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x00, 0x35, 0xfa, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa4, 0xc1, 0x64, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04,
0x69, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1e, 0xc0, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x79, 0x1b, 0x62, 0x95,
0x9d, 0x4f, 0x40, 0xd5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x79, 0x1b, 0x62, 0x95, 0x9d, 0x4f,
0x40, 0xd5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xce, 0xf2, 0x7f, 0x52, 0x96, 0xa8, 0x47, 0x90,
0x3b, 0xd0, 0x34, 0x0d, 0xf0, 0x52, 0x76, 0xa1, 0xcb, 0x3f, 0xa3, 0x7d,
0x85, 0x0e, 0x02, 0x73, 0x06, 0x7f, 0xaf, 0xaf, 0x55, 0x6f, 0xa8, 0x2f,
0x8b, 0xd4, 0x32, 0x82, 0x99, 0x16, 0x32, 0x06, 0x37, 0x4e, 0xb4, 0x70,
0x02, 0x11, 0x58, 0x48, 0x98, 0x70, 0x92, 0xbc, 0xb3, 0x19, 0x8c, 0xec,
0xc0, 0xfd, 0xc8, 0x2a, 0xa5, 0x79, 0x4e, 0x6d, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x63, 0x0e, 0x4c, 0x09, 0x8f,
0x8a, 0x34, 0xb2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x50, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x92, 0xe7, 0xf2, 0xc0, 0xa1, 0x6a, 0xcb, 0x85,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x92, 0xe7, 0xf2, 0xc0, 0xa1, 0x6a, 0xcb, 0x85, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x3b, 0x73, 0xfb, 0xe2, 0xe6, 0xa0, 0xea, 0xb9, 0xd2, 0x2d, 0xbe, 0x39,
0x92, 0x10, 0x88, 0x61, 0x7b, 0x5e, 0x33, 0x2a, 0x6c, 0x57, 0xe0, 0xc9,
0x0c, 0xef, 0x95, 0x31, 0x9b, 0x70, 0x05, 0x67, 0x37, 0xbd, 0xae, 0x3b,
0x23, 0x99, 0xf9, 0x92, 0x68, 0x13, 0x96, 0x34, 0x15, 0xde, 0x5e, 0x3e,
0x0a, 0xb1, 0xd3, 0x04, 0x76, 0x2a, 0x3c, 0x47, 0x16, 0x72, 0x4a, 0x99,
0x31, 0x6b, 0x8e, 0x06, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xc6, 0x0c, 0x7a, 0x69, 0xd9, 0xc8, 0x41, 0x98, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x38, 0x38, 0x30, 0x38, 0x30, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0xe1, 0xe6, 0xd5, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x96, 0xc4,
0xe0, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0x17, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0b, 0xa3,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x0a, 0x92, 0xe6, 0x49, 0xac, 0xad, 0x23, 0xc3, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x35, 0x38, 0x35, 0x34, 0x34, 0x35, 0x39, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xcc, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x71, 0xa8, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x59, 0x54, 0xfb, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xce, 0xce, 0xf9, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0,
0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x35,
0x35, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x34, 0x32, 0x33, 0x32, 0x34, 0x35, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x56, 0xdb,
0x54, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xd9, 0x2b, 0x87, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0xcd, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x36, 0xbb, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x34,
0x18, 0xf9, 0x92, 0x86, 0x4e, 0x8d, 0xc7, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x39, 0x32, 0x30, 0x35, 0x37, 0x34, 0x39, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0,
0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x34,
0x35, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x38, 0x36, 0x35, 0x32, 0x32, 0x34, 0x35, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33,
0x32, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x34, 0x36, 0x30, 0x39, 0x32, 0x38, 0x32, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x5c, 0xd0,
0x3d, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xde, 0xeb, 0x82, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0xd8, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x88, 0x16, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x22,
0x6e, 0x0c, 0xe1, 0x0a, 0xd2, 0xab, 0xfb, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x39, 0x34, 0x38, 0x32, 0x30, 0x31, 0x35, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0xf3, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x29, 0xa3,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x90, 0xaf, 0x1f, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0xb9, 0x3c, 0x31, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x69, 0xac, 0x6c,
0x9f, 0x02, 0x5b, 0x4e, 0x08, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x31, 0x37, 0x32, 0x33, 0x37, 0x37, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x22, 0xf2, 0xd9, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb2, 0xe3, 0xfe, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04,
0x8f, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x84, 0x22, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xff, 0x13, 0x62, 0xf2,
0xe9, 0x68, 0x87, 0x1f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x38,
0x33, 0x34, 0x37, 0x33, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x24,
0x0a, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0xe6, 0xaf, 0xd8, 0xa4, 0x1a, 0x00,
0x5d, 0xb2, 0x2a, 0xd8, 0xa4, 0x1a, 0x00, 0x2c, 0x9a, 0xc5, 0xd8, 0xa4,
0x1a, 0x00, 0x24, 0x85, 0x45, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x83, 0x8c,
0xd8, 0xa4, 0x1a, 0x00, 0x6d, 0xe8, 0xc2, 0xd8, 0xa4, 0x1a, 0x00, 0x47,
0x26, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0x96, 0x5e, 0xce, 0xd8, 0xa4, 0x1a,
0x00, 0x66, 0x3d, 0x88, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x30, 0x5f, 0xd8,
0xa4, 0x1a, 0x00, 0x91, 0xcf, 0x58, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x75,
0x66, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0xf8, 0xdb, 0xd8, 0xa4, 0x1a, 0x00,
0x93, 0x23, 0x7f, 0xd8, 0xa4, 0x1a, 0x00, 0x93, 0x8e, 0xff, 0xd8, 0xa4,
0x1a, 0x00, 0x93, 0xb4, 0x28, 0xd8, 0xa4, 0x1a, 0x00, 0x9d, 0xf7, 0x40,
0xd8, 0xa4, 0x1a, 0x00, 0x61, 0x91, 0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0xa2,
0x7b, 0x46, 0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0x4a, 0xd4, 0xd8, 0xa4, 0x1a,
0x00, 0x9a, 0x3e, 0x74, 0xd8, 0xa4, 0x1a, 0x00, 0x9b, 0xc8, 0x72, 0xd8,
0xa4, 0x1a, 0x00, 0x57, 0xb3, 0xf0, 0xd8, 0xa4, 0x1a, 0x00, 0x9c, 0x6c,
0xd6, 0xd8, 0xa4, 0x1a, 0x00, 0xa4, 0x6d, 0x45, 0xd8, 0xa4, 0x1a, 0x00,
0xa3, 0x54, 0xfc, 0xd8, 0xa4, 0x1a, 0x00, 0xaf, 0xa6, 0xa2, 0xd8, 0xa4,
0x1a, 0x00, 0xaf, 0x1d, 0xb3, 0xd8, 0xa4, 0x1a, 0x00, 0x9b, 0x1a, 0x7c,
0xd8, 0xa4, 0x1a, 0x00, 0x9a, 0xef, 0x0c, 0xd8, 0xa4, 0x1a, 0x00, 0xa4,
0x09, 0x85, 0xd8, 0xa4, 0x1a, 0x00, 0xaa, 0x92, 0xf2, 0xd8, 0xa4, 0x1a,
0x00, 0x33, 0x62, 0x91, 0xd8, 0xa4, 0x1a, 0x00, 0x9f, 0x39, 0x87, 0xd8,
0xa4, 0x1a, 0x00, 0xb2, 0x4f, 0x39, 0xd8, 0xa4, 0x1a, 0x00, 0xb6, 0xcb,
0xa3, 0xd8, 0xa4, 0x1a, 0x00, 0xb1, 0x80, 0x2e, 0xd8, 0xa4, 0x1a, 0x00,
0xa4, 0x9a, 0x79, 0xd8, 0xa4, 0x1a, 0x00, 0x4f, 0xe4, 0xb8, 0xd8, 0xa4,
0x1a, 0x00, 0x52, 0x45, 0xaf, 0xd8, 0xa4, 0x1a, 0x00, 0x74, 0x3a, 0xc0,
0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0xa1, 0xf7, 0xd8, 0xa4, 0x1a, 0x00, 0x09,
0x11, 0xf7, 0xd8, 0xa4, 0x1a, 0x00, 0x11, 0x3f, 0xcd, 0xd8, 0xa4, 0x1a,
0x00, 0xcb, 0x37, 0xe5, 0xd8, 0xa4, 0x1a, 0x00, 0xd5, 0x9d, 0x6f, 0xd8,
0xa4, 0x1a, 0x00, 0xc3, 0x62, 0x56, 0xd8, 0xa4, 0x1a, 0x00, 0xc8, 0x0b,
0xf3, 0xd8, 0xa4, 0x1a, 0x00, 0xdc, 0x5b, 0xd5, 0xd8, 0xa4, 0x1a, 0x00,
0xdf, 0xd3, 0xd0, 0xd8, 0xa4, 0x1a, 0x00, 0xd9, 0x5e, 0x43, 0xd8, 0xa4,
0x1a, 0x00, 0xb9, 0x02, 0xf0, 0xd8, 0xa4, 0x1a, 0x00, 0xc0, 0x12, 0x5a,
0xd8, 0xa4, 0x1a, 0x00, 0xd5, 0x0b, 0x6f, 0xd8, 0xa4, 0x1a, 0x00, 0xcc,
0x36, 0x3d, 0xd8, 0xa4, 0x1a, 0x00, 0xa3, 0xca, 0xd3, 0xd8, 0xa4, 0x1a,
0x00, 0xbc, 0xdc, 0x83, 0xd8, 0xa4, 0x1a, 0x00, 0x96, 0x12, 0x30, 0xd8,
0xa4, 0x1a, 0x00, 0xd8, 0x0f, 0xd5, 0xd8, 0xa4, 0x1a, 0x00, 0x6e, 0x9e,
0xa7, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x63, 0xf4, 0xd8, 0xa4, 0x1a, 0x00,
0xcd, 0xe2, 0xe3, 0xd8, 0xa4, 0x1a, 0x00, 0xbd, 0x67, 0x08, 0xd8, 0xa4,
0x1a, 0x00, 0xb0, 0x3a, 0xcf, 0xd8, 0xa4, 0x1a, 0x00, 0xae, 0x47, 0xa6,
0xd8, 0xa4, 0x1a, 0x00, 0xdf, 0x74, 0x78, 0xd8, 0xa4, 0x1a, 0x00, 0xa0,
0xcf, 0x55, 0xd8, 0xa4, 0x1a, 0x00, 0x0b, 0x45, 0xf7, 0xd8, 0xa4, 0x1a,
0x00, 0xc9, 0xe2, 0x67, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0x18, 0xfc, 0xd8,
0xa4, 0x1a, 0x00, 0xca, 0x64, 0x82, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xb0,
0x7b, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0xf1, 0x76, 0xd8, 0xa4, 0x1a, 0x00,
0xcb, 0x82, 0x52, 0xd8, 0xa4, 0x1a, 0x00, 0xcb, 0xce, 0xf8, 0xd8, 0xa4,
0x1a, 0x00, 0xdd, 0x14, 0x38, 0xd8, 0xa4, 0x1a, 0x00, 0xda, 0xcd, 0x00,
0xd8, 0xa4, 0x1a, 0x00, 0x34, 0x5b, 0x59, 0x80, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x12, 0x67, 0x4b, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x77, 0x5e,
0xcd, 0xaf, 0xc2, 0x3c, 0xa9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x77, 0x5e, 0xcd, 0xaf,
0xc2, 0x3c, 0xa9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x30, 0x72, 0x87, 0xcb, 0x58, 0x64, 0x17,
0x27, 0xb4, 0xb3, 0x38, 0x38, 0x4e, 0x89, 0xd3, 0x16, 0x2a, 0xaf, 0x7f,
0xd0, 0x4b, 0xc9, 0xdc, 0xb1, 0xbe, 0x83, 0x7b, 0xcc, 0x64, 0xc9, 0xdb,
0xda, 0xf8, 0x72, 0x27, 0x79, 0x47, 0x0c, 0xf1, 0xad, 0x40, 0xd5, 0x40,
0xc6, 0x4e, 0x34, 0x1e, 0x4e, 0xeb, 0xa3, 0x99, 0x81, 0x3a, 0x29, 0x73,
0xf0, 0x31, 0x6a, 0x5e, 0xb2, 0x0e, 0x9b, 0xb9, 0xfd, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91,
0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x46, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x39, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x39, 0x30, 0x37, 0x35, 0x30, 0x34, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x94, 0xbd, 0x05, 0x1f,
0x43, 0x27, 0xd8, 0x9e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x38,
0x34, 0x36, 0x37, 0x38, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x01, 0xd5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2b, 0xd3, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x1c, 0x2e, 0x04,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2c, 0x36, 0x50,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x34, 0x38, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x33, 0x30, 0x34, 0x30, 0x36, 0x39, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x43, 0xa4, 0x26, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc6, 0xfc, 0x3a, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02,
0xb0, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x8d, 0x59, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd1, 0x30, 0xc0, 0xa7,
0xdd, 0x67, 0xe7, 0x72, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x32, 0x31, 0x36, 0x36, 0x37, 0x32, 0x37, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x29,
0xf4, 0x49, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb9, 0xa6, 0x47,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0x9f, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x22, 0x4b, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x5e, 0xa5, 0xcc, 0xa7, 0xfa, 0x1d, 0x99, 0x69, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x39, 0x36, 0x31, 0x33, 0x33, 0x36, 0x35, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xd8, 0xfe, 0xea,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x92, 0xb0, 0x35, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x25, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x04, 0x0b, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x31, 0x2d, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x7b,
0x23, 0xcb, 0x8c, 0xb4, 0x09, 0x3f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x19, 0x70,
0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x5b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8,
0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6,
0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe, 0x0a,
0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c,
0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6d, 0xe9, 0x3d,
0x89, 0x01, 0x12, 0xaf, 0x1a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6d, 0xe9, 0x3d, 0x89, 0x01,
0x12, 0xaf, 0x1a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x76, 0xd4, 0xba, 0xfc, 0x30, 0xba, 0xe1,
0xe2, 0x12, 0xb1, 0x4d, 0x35, 0x62, 0xb1, 0xf1, 0x4b, 0xb0, 0x73, 0x13,
0x7c, 0xeb, 0xbc, 0x6c, 0xe3, 0x50, 0xb1, 0xc8, 0x24, 0xee, 0x43, 0x17,
0xe3, 0x46, 0x6b, 0x94, 0xad, 0x42, 0xb1, 0xd5, 0xc1, 0xa0, 0xb6, 0xab,
0xb3, 0xf9, 0xdd, 0xe5, 0xcb, 0xfa, 0x2d, 0xb4, 0x55, 0xc2, 0xb8, 0xd8,
0x03, 0x8d, 0xd1, 0x16, 0x85, 0x01, 0x25, 0x25, 0x0a, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa3, 0xb3, 0x7e, 0x0d,
0xc0, 0x19, 0x9f, 0x4e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74,
0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x38, 0x39, 0x38, 0x32, 0x38, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xc6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x16, 0x87, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x69, 0x42,
0x6d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x10, 0xa7,
0x86, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2b, 0x27, 0x6d, 0x26, 0x6a,
0xa4, 0x8f, 0x97, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x2b, 0x27, 0x6d, 0x26, 0x6a, 0xa4, 0x8f,
0x97, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xde, 0xae, 0x87, 0x45, 0x14, 0x4a, 0x22, 0x54, 0x90,
0x06, 0x5b, 0x52, 0xb5, 0xc9, 0x9e, 0xba, 0x62, 0xf4, 0x0d, 0xe1, 0xfd,
0x23, 0x9c, 0xfd, 0x17, 0x38, 0xff, 0x9c, 0x0c, 0x4b, 0xe4, 0x1b, 0xec,
0x2c, 0x4c, 0x86, 0x5c, 0xf5, 0xa4, 0x13, 0x81, 0x4b, 0xf7, 0x15, 0x0d,
0xe6, 0x48, 0x19, 0x2d, 0x5d, 0xa6, 0x36, 0x70, 0xfe, 0xd8, 0x8b, 0x7a,
0xb5, 0xce, 0x09, 0x2d, 0xd6, 0xf4, 0x36, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x35, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38,
0x39, 0x33, 0x32, 0x36, 0x31, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x50, 0x9f, 0xb6, 0xb8, 0x56,
0xdf, 0xb4, 0x16, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x50, 0x9f, 0xb6, 0xb8, 0x56, 0xdf, 0xb4,
0x16, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x31, 0x9c, 0x45, 0x13, 0x3f, 0x80, 0x6e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x46, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xa6, 0x5f, 0xff, 0x1a, 0x39, 0xf9, 0x01, 0xe0, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x36, 0x32, 0x35, 0x32, 0x33, 0x34, 0x36, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x88, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x3a,
0xa4, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x5f, 0x67, 0x3a, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0x03, 0x88, 0xd0, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xfa, 0x23,
0xae, 0xb4, 0x7e, 0x57, 0x55, 0xe3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xfa, 0x23, 0xae, 0xb4,
0x7e, 0x57, 0x55, 0xe3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xa7, 0x68, 0x01, 0x16, 0x28, 0xe5,
0xbb, 0xaf, 0x4a, 0x1d, 0x92, 0x40, 0xdc, 0x2e, 0x60, 0x5b, 0x86, 0x9c,
0x89, 0xfb, 0x2d, 0x63, 0x62, 0x37, 0xd2, 0xfa, 0x74, 0x14, 0xbe, 0xf9,
0x40, 0x24, 0x51, 0x1e, 0xd1, 0x00, 0x44, 0xe9, 0xb4, 0x27, 0xd8, 0xef,
0x24, 0x46, 0x11, 0x60, 0xf6, 0x0d, 0x4f, 0xd8, 0xe6, 0x3a, 0x6a, 0x00,
0xad, 0xc0, 0x94, 0x32, 0x39, 0x03, 0x70, 0x2a, 0xe2, 0xf1, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf8, 0xec, 0xec,
0x46, 0x22, 0x1d, 0x2a, 0x6e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46, 0x65, 0x78, 0x69,
0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xb8, 0x21, 0x21, 0xa7, 0x78, 0x16, 0xf9,
0x18, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xb8, 0x21, 0x21, 0xa7, 0x78, 0x16, 0xf9, 0x18, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0xc5, 0xee, 0x03, 0x85, 0x0c, 0xfc, 0x8b, 0x2f, 0x19, 0xcb, 0x1b,
0xf3, 0x3f, 0xc8, 0x3a, 0x73, 0x06, 0x5c, 0xa5, 0x49, 0x61, 0xf7, 0x52,
0xef, 0x24, 0x28, 0x14, 0x9b, 0xd6, 0xc0, 0xdb, 0x87, 0x94, 0x0d, 0x56,
0x02, 0xe5, 0x84, 0xd4, 0x2a, 0xc1, 0x3f, 0x5a, 0x75, 0x0b, 0x19, 0xc0,
0xdb, 0x5f, 0xd8, 0x8e, 0x25, 0x96, 0x92, 0x53, 0x23, 0x1d, 0xf0, 0x79,
0x86, 0xcc, 0x16, 0x65, 0x4f, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x33, 0x90, 0x24, 0x62, 0x03, 0xba, 0xfa, 0x27,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x33, 0x90, 0x24, 0x62, 0x03, 0xba, 0xfa, 0x27, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x37,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x59, 0x67, 0xe8, 0xd1, 0x94, 0x5c, 0x25, 0x57, 0x71, 0x2c, 0xee, 0x0e,
0x02, 0x67, 0xc3, 0xb6, 0x30, 0xdc, 0x95, 0xbb, 0xe4, 0xdf, 0xb3, 0xf8,
0x31, 0xab, 0x4a, 0xa6, 0x57, 0x41, 0x08, 0xc3, 0xfe, 0xac, 0xcb, 0xb9,
0x4b, 0x3d, 0xec, 0xb3, 0xb4, 0x70, 0x8d, 0x04, 0x6d, 0x8d, 0x9a, 0x5a,
0xb1, 0xaf, 0xeb, 0x5f, 0x75, 0x1c, 0x8e, 0xa6, 0x36, 0x19, 0xd6, 0x1a,
0xc8, 0x4c, 0x0b, 0x2a, 0x02, 0x01, 0x80, 0x1b, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x46, 0x54, 0x20, 0xbc, 0x8b, 0x52, 0x38, 0xca, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0xd9,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x94, 0xd8, 0xa4, 0x1a,
0x00, 0x10, 0xd7, 0x1f, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0x6c, 0xa2, 0xd8,
0xa4, 0x1a, 0x00, 0x15, 0xc8, 0xf1, 0xd8, 0xa4, 0x1a, 0x00, 0x16, 0x05,
0x70, 0xd8, 0xa4, 0x1a, 0x00, 0x17, 0xdf, 0xaf, 0xd8, 0xa4, 0x1a, 0x00,
0x20, 0x39, 0x96, 0xd8, 0xa4, 0x1a, 0x00, 0x21, 0x64, 0xeb, 0xd8, 0xa4,
0x1a, 0x00, 0x21, 0x0f, 0x03, 0xd8, 0xa4, 0x1a, 0x00, 0x1a, 0x73, 0xe5,
0xd8, 0xa4, 0x1a, 0x00, 0x28, 0x1b, 0xa9, 0xd8, 0xa4, 0x1a, 0x00, 0x28,
0xcf, 0x33, 0xd8, 0xa4, 0x1a, 0x00, 0x43, 0xfe, 0x2a, 0xd8, 0xa4, 0x1a,
0x00, 0x49, 0x6e, 0x2b, 0xd8, 0xa4, 0x1a, 0x00, 0x41, 0x4f, 0x45, 0xd8,
0xa4, 0x1a, 0x00, 0x93, 0xff, 0x1e, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x50,
0xbf, 0xd8, 0xa4, 0x1a, 0x00, 0xae, 0x45, 0x86, 0xd8, 0xa4, 0x1a, 0x00,
0x94, 0x2b, 0x70, 0xd8, 0xa4, 0x1a, 0x00, 0x9d, 0x0f, 0xca, 0xd8, 0xa4,
0x1a, 0x00, 0x62, 0x88, 0x97, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x35, 0x61, 0x10, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xde, 0x2f, 0xff, 0xd5, 0x8c,
0xcd, 0x11, 0xd3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x32, 0x37,
0x38, 0x36, 0x35, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0xf1, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2f, 0x69, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x6f, 0x10, 0x3f, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x18, 0x01, 0x9f, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x25, 0x12, 0x75, 0x01, 0xc0, 0x76, 0xe5,
0xd7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x37, 0x30, 0x32, 0x36, 0x37, 0x31, 0x37, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0xd2, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x72, 0x0f,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x6b, 0x38, 0x1d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0x13, 0x13, 0x6c, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x36, 0x1a, 0x85,
0xeb, 0xf8, 0xfd, 0x60, 0xad, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f,
0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x38, 0x32, 0x39, 0x36, 0x32, 0x35, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9a, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x03, 0xb7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x1b, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x7e, 0x97,
0x3f, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x99, 0x2d,
0x0a, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x61, 0x6f, 0x21, 0xe3,
0x78, 0xa3, 0x36, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x43, 0x61, 0x6f, 0x21, 0xe3, 0x78, 0xa3,
0x36, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xc0, 0x19, 0x6f, 0xb3, 0x09, 0xcf, 0x3e, 0x41, 0x8e,
0xaa, 0x7a, 0x70, 0x17, 0x9b, 0x40, 0x72, 0xd7, 0xc7, 0x4d, 0x91, 0x89,
0xfb, 0xb9, 0x0f, 0x7d, 0xcf, 0x75, 0x1b, 0x6a, 0x51, 0x0f, 0xae, 0xba,
0x34, 0xc9, 0x13, 0xf4, 0xcc, 0x26, 0x6e, 0xd3, 0x50, 0x17, 0x36, 0x08,
0xb5, 0x7b, 0xb2, 0x41, 0x02, 0x4a, 0x65, 0x03, 0x42, 0x17, 0x7b, 0x5b,
0x62, 0x28, 0x4c, 0x13, 0xc6, 0x0c, 0xbc, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa5, 0x84, 0xac, 0xf8, 0x05, 0xc5,
0xf2, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x57, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x60, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82,
0x01, 0x70, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc,
0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x78, 0x1e, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x75, 0x62, 0x6c, 0x69,
0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9e, 0x0b, 0x3b, 0x60, 0x8b,
0xfe, 0xcf, 0x13, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x9e, 0x0b, 0x3b, 0x60, 0x8b, 0xfe, 0xcf,
0x13, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x4b, 0x16, 0x2b, 0xc8, 0x8d, 0xd0, 0x80, 0x53, 0x69,
0x43, 0x95, 0xc7, 0x45, 0x1e, 0xbc, 0x30, 0xa6, 0x30, 0x7e, 0x54, 0xce,
0x75, 0x06, 0x76, 0xe5, 0xfe, 0x36, 0x08, 0xf6, 0x28, 0x80, 0xfc, 0x83,
0xac, 0xa2, 0xab, 0x86, 0x5f, 0x87, 0x58, 0xa4, 0x18, 0x61, 0xc0, 0xce,
0x2c, 0xad, 0x9a, 0x2f, 0x71, 0xae, 0x77, 0x41, 0x22, 0x2d, 0x05, 0x6a,
0x0b, 0xee, 0x8a, 0xe3, 0x5b, 0x59, 0x9d, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x98, 0x32, 0xf7, 0x18, 0x59, 0x13,
0xc6, 0xd0, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x98, 0x32, 0xf7, 0x18, 0x59, 0x13, 0xc6, 0xd0,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x62, 0x42, 0xd2, 0x0b, 0xbd, 0x7c, 0x26, 0xb0, 0xde, 0x34,
0xc9, 0x26, 0x2f, 0x63, 0x91, 0x98, 0x3f, 0xdf, 0x6e, 0x94, 0x16, 0xed,
0x70, 0x83, 0x2d, 0xe1, 0xd6, 0xd1, 0xe4, 0x87, 0xd3, 0x89, 0xc0, 0x23,
0x6f, 0xa7, 0xcb, 0x85, 0x67, 0x43, 0x70, 0x37, 0xab, 0x3b, 0x2d, 0x7f,
0xf4, 0xe1, 0x35, 0x6d, 0xd0, 0x58, 0x2e, 0x6c, 0x64, 0x9d, 0x9d, 0x84,
0x64, 0x16, 0x83, 0x70, 0x6b, 0x0d, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52,
0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61,
0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x34, 0x34, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x36,
0x39, 0x39, 0x37, 0x34, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa1, 0xe0, 0x3e, 0x1e, 0x0b, 0x87,
0xee, 0x55, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xa1, 0xe0, 0x3e, 0x1e, 0x0b, 0x87, 0xee, 0x55,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xd1, 0xb7, 0x9e, 0x23, 0x41, 0x56, 0xd6, 0x3c, 0x48,
0xb5, 0xdd, 0xdd, 0xdb, 0x1a, 0x5f, 0x36, 0x41, 0x43, 0x52, 0xd5, 0xe5,
0xf4, 0x50, 0x63, 0xef, 0x0b, 0x1c, 0x9a, 0xe1, 0x3f, 0x7b, 0xee, 0x3b,
0x6a, 0x06, 0x00, 0xc2, 0x1c, 0x64, 0xd8, 0x18, 0x94, 0xb3, 0xa6, 0x17,
0xd2, 0x45, 0xd0, 0x75, 0x10, 0x2f, 0xb2, 0xef, 0x32, 0xe0, 0xf1, 0xb7,
0x29, 0x05, 0x26, 0xcb, 0x96, 0xba, 0x6e, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x30, 0x5d, 0x92, 0x00, 0x83, 0xdb,
0x62, 0x17, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x00, 0xc3, 0x39,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x4a, 0xe6, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x04, 0x6a, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1f, 0x8a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x0a, 0xba,
0xe1, 0x1f, 0x20, 0x61, 0x7b, 0x25, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2b, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x39, 0x33, 0x35, 0x38, 0x32, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x01, 0x93, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0d, 0x5e, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x0e, 0x47,
0x8d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x11, 0xa0,
0x07, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xda, 0x00, 0x51, 0xc2, 0x3e,
0xe3, 0x4f, 0xb7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x30,
0x33, 0x37, 0x35, 0x31, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xe4, 0xbb, 0xd3, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x99, 0x29, 0x0c, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x1e, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x1a, 0x27, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd8, 0xf4, 0x3e, 0xb3, 0x90, 0xd8,
0xe9, 0xbf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x37, 0x30, 0x38,
0x39, 0x39, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02,
0x9c, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x83, 0x5f, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x57, 0x1c, 0xc2, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcc, 0x7d, 0x69, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xc9, 0xf0, 0x0f, 0x35, 0xbc, 0xe9, 0x3a, 0x74,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xc9, 0xf0, 0x0f, 0x35, 0xbc, 0xe9, 0x3a, 0x74, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0xd6, 0xb8, 0xd4, 0x00, 0x4c, 0x9e, 0xed, 0x52, 0xc7, 0xbe, 0xd5, 0x39,
0x26, 0x35, 0x1b, 0xa8, 0xd3, 0x5a, 0x85, 0x58, 0x26, 0x28, 0xd6, 0x49,
0x9a, 0x4f, 0x8f, 0xe0, 0x03, 0x69, 0x18, 0xbf, 0xb5, 0x48, 0x04, 0xff,
0x0d, 0xbd, 0x37, 0x6d, 0x27, 0xea, 0x66, 0x7c, 0x7c, 0x36, 0xd0, 0x0f,
0xab, 0x5a, 0xab, 0xc7, 0x4c, 0x6b, 0x43, 0x67, 0x0d, 0xc4, 0x89, 0x7f,
0xdd, 0x95, 0x01, 0x6a, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xdc, 0x0c, 0x36, 0xa9, 0x9f, 0x24, 0x7b, 0x75, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xdc, 0x0c, 0x36, 0xa9, 0x9f, 0x24, 0x7b, 0x75, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0xb8,
0x27, 0x19, 0xde, 0x70, 0x4e, 0x28, 0xd4, 0x34, 0x41, 0x91, 0x42, 0x10,
0x95, 0x5b, 0x95, 0xbe, 0x40, 0xe0, 0x17, 0x25, 0x06, 0xbf, 0x03, 0x3e,
0x86, 0xab, 0x4a, 0xb5, 0x65, 0xff, 0xc9, 0xaa, 0xcd, 0x94, 0x82, 0x7a,
0x22, 0x40, 0x19, 0x4a, 0x7a, 0xfb, 0xcd, 0xa4, 0x3a, 0x9e, 0xa0, 0xe1,
0x48, 0x49, 0x65, 0xa1, 0xba, 0x3d, 0xff, 0xfb, 0xf8, 0x95, 0x59, 0xa2,
0xbe, 0x21, 0x61, 0x02, 0x03, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xc6, 0x13, 0x61, 0xcb, 0xe2, 0x8e, 0x81, 0x2b,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xc6, 0x13, 0x61, 0xcb, 0xe2, 0x8e, 0x81, 0x2b, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0xcd, 0xff, 0x95, 0xba, 0xca, 0xf8, 0xb4, 0x24, 0x18, 0xa4, 0x32, 0x86,
0xb8, 0x05, 0xe0, 0x5d, 0xf2, 0x71, 0x54, 0x10, 0x7d, 0x12, 0x0e, 0x95,
0x0c, 0x71, 0x91, 0x2c, 0xf0, 0xb4, 0xa3, 0x64, 0x57, 0xf7, 0x42, 0xae,
0x52, 0x9e, 0xb0, 0x53, 0xac, 0x20, 0x88, 0x5d, 0x7e, 0x33, 0x18, 0xb1,
0xe3, 0x6b, 0xa3, 0x98, 0xb7, 0x3d, 0xee, 0xbf, 0x6d, 0xdb, 0x9f, 0x4f,
0xe9, 0x6c, 0x68, 0x3a, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x1f, 0xdc, 0x0a, 0x09, 0x73, 0xfe, 0xac, 0xa7, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x32,
0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x32, 0x34, 0x39, 0x33, 0x33, 0x37, 0x37, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x3a, 0xa9,
0x47, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xbe, 0xa2, 0x41, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x03, 0xc5, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x97, 0xd0, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x97,
0x05, 0xf4, 0x46, 0x34, 0x5f, 0xe0, 0x32, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x31, 0x39, 0x39, 0x33, 0x33, 0x34, 0x37, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcf, 0x48, 0xb9,
0x85, 0xf6, 0xd1, 0xac, 0x86, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35,
0x32, 0x36, 0x31, 0x39, 0x30, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x03, 0x1c, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x06, 0x08, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x22, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x50, 0x4a,
0x53, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc4, 0x65,
0xb6, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x81, 0x22, 0x9e, 0x38, 0x2b,
0xae, 0x52, 0xdc, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x81, 0x22, 0x9e, 0x38, 0x2b, 0xae, 0x52,
0xdc, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x26, 0xb4, 0xc7, 0x58, 0xd0, 0xb5, 0xd6, 0x06, 0x51,
0x48, 0x00, 0x5a, 0x4b, 0x75, 0xaf, 0x21, 0xb8, 0xef, 0x88, 0x29, 0xe0,
0xd7, 0x2a, 0x48, 0xae, 0xe7, 0x89, 0x7b, 0x0a, 0x85, 0xfd, 0xb7, 0x0f,
0x3c, 0x49, 0x30, 0x82, 0xe5, 0x21, 0xef, 0x81, 0x0b, 0xee, 0x71, 0x02,
0x39, 0x8c, 0x67, 0x3e, 0x2a, 0x77, 0x9a, 0x59, 0xe0, 0xb5, 0x6d, 0x40,
0x24, 0xda, 0x59, 0x1a, 0x1d, 0x04, 0x39, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb8, 0xc4, 0xf7, 0x93, 0xcd, 0x96,
0x98, 0x06, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xb8, 0xc4, 0xf7, 0x93, 0xcd, 0x96, 0x98, 0x06,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x54, 0x14, 0xb1, 0x2e, 0x02, 0xc0, 0x59, 0xf2, 0x2c, 0xac,
0x3e, 0xbb, 0xda, 0x0b, 0x0d, 0xc1, 0xfb, 0x67, 0x68, 0xde, 0xc2, 0x72,
0xfe, 0x4f, 0xcb, 0x11, 0x9f, 0xd3, 0x64, 0xd3, 0x5a, 0xe3, 0x79, 0x7c,
0xdb, 0x3c, 0x20, 0x64, 0x2d, 0x63, 0x11, 0x1a, 0x3e, 0x71, 0x83, 0x69,
0xac, 0xae, 0x87, 0xf7, 0x72, 0x1c, 0x5c, 0xbe, 0x01, 0x51, 0x5e, 0x1d,
0x73, 0xe3, 0x50, 0x7e, 0x52, 0xf5, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x2a, 0xf8, 0x7d, 0x3f, 0xd4, 0x18, 0xa2,
0x18, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x30, 0x36, 0x34,
0x39, 0x35, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x02, 0x44, 0x06, 0xef, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0xc7, 0x5a, 0xff, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xe2, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x8a, 0x76, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xff, 0xc8, 0x6d, 0x95, 0x87, 0x2b, 0x8a, 0x67,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xff, 0xc8, 0x6d, 0x95, 0x87, 0x2b, 0x8a, 0x67, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0xb7, 0xa8, 0xe8, 0xb3, 0xbf, 0x60, 0x08, 0x26, 0x7b, 0x8d, 0xc3, 0x6e,
0x31, 0x7d, 0x96, 0x4c, 0xfa, 0x7a, 0x41, 0x3a, 0x5a, 0x72, 0xb9, 0xab,
0x43, 0x1a, 0x9d, 0x29, 0x53, 0x45, 0xb9, 0x4e, 0x50, 0xf4, 0xe4, 0xf6,
0xe9, 0x80, 0x51, 0x74, 0x0c, 0x9f, 0xc4, 0x3c, 0xed, 0x45, 0xde, 0xfd,
0x26, 0x08, 0x99, 0x9c, 0x04, 0x87, 0xe6, 0x8a, 0x24, 0xda, 0xa3, 0x27,
0x28, 0x47, 0xc5, 0x8b, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x7c, 0xbd, 0xa3, 0xc6, 0xc9, 0xe2, 0xbf, 0xf8, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x39, 0x38, 0x31, 0x30, 0x39, 0x31,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x26, 0xb1, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x61, 0xa5,
0x07, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x06, 0x49,
0x77, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf6, 0xfc, 0x6b, 0x98, 0x4d,
0xb0, 0xdf, 0x78, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1e, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x1f, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x78, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x78, 0x18,
0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61,
0x72, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x18,
0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26, 0xd2, 0x78, 0x18, 0x50, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xf6, 0x78, 0x22,
0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72,
0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xa8, 0xe3, 0x1e, 0x9c, 0x2b, 0x32, 0xfa, 0x27,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x38, 0x32, 0x37, 0x30, 0x39,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x7c, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x0b, 0x6f, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2b, 0x23, 0x56, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x84, 0x8c, 0xc9, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x53, 0x7e, 0x2c, 0x71, 0x1f, 0xd9, 0x3d, 0xc7, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x56, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65, 0x33,
0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63,
0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x3a, 0x7a, 0x6b, 0x6f, 0x46, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4b, 0xd5, 0x2c, 0x26, 0xb8, 0x9c,
0x08, 0x4c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x4b, 0xd5, 0x2c, 0x26, 0xb8, 0x9c, 0x08, 0x4c,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x99, 0x54, 0x15, 0x4b, 0x42, 0x52, 0xc5, 0xe0, 0x68, 0x83,
0x45, 0x8e, 0x91, 0x98, 0x49, 0x53, 0x86, 0x8d, 0xda, 0x3b, 0xdd, 0x50,
0x95, 0x76, 0xea, 0x42, 0x45, 0xe4, 0x63, 0xe1, 0x7c, 0xcf, 0xd3, 0x7c,
0x81, 0x49, 0xe8, 0x18, 0xd3, 0x22, 0xc5, 0xc1, 0xe4, 0xa6, 0x54, 0x5c,
0x3e, 0xa9, 0x74, 0x5d, 0xf4, 0xa6, 0xa2, 0x02, 0x02, 0x19, 0xf8, 0x2a,
0xb8, 0xf9, 0xc7, 0xe2, 0x61, 0x37, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x79, 0x24, 0xc7, 0x8c, 0x0c, 0xd5, 0xd8,
0xf4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x35, 0x35, 0x33, 0x33,
0x36, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x01, 0xd6, 0xd7, 0x0c, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x91, 0xc5, 0xd4, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x25, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x08, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x19, 0xbc, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xce, 0xe7, 0x82, 0x6a, 0x00, 0xac, 0x14, 0x70, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x31, 0x32, 0x32, 0x34, 0x33, 0x36,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xae, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x1c, 0xf0, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x20, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x7b, 0xf0, 0x44, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x94, 0xb3, 0x02, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xd9, 0xc4, 0x19, 0x82, 0x39, 0x99, 0x7c, 0xeb, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x82, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2b, 0x80, 0xda, 0x59, 0x99,
0x6b, 0xd8, 0x82, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x62, 0xb7, 0x60, 0x00, 0x41, 0xa1, 0x87,
0xb9, 0x5b, 0xfa, 0xb8, 0x7b, 0x77, 0xb3, 0xb4, 0xf9, 0x05, 0xd9, 0xa5,
0x58, 0xff, 0x77, 0xf0, 0x2c, 0xa6, 0x3e, 0x71, 0xd5, 0x92, 0x4b, 0x49,
0x99, 0xa5, 0x66, 0x5c, 0x44, 0x68, 0x8b, 0x07, 0x2c, 0xc8, 0x1a, 0x22,
0xda, 0xa1, 0xa2, 0x30, 0x8c, 0x40, 0xad, 0x36, 0xfd, 0x71, 0x3a, 0x8b,
0x49, 0x05, 0xbf, 0x5d, 0x14, 0x73, 0x04, 0x70, 0x13, 0x02, 0x01, 0x82,
0x03, 0xe8, 0x01, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf2, 0x05,
0x53, 0xb9, 0x6e, 0x98, 0xcd, 0xb3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf2, 0x05, 0x53, 0xb9,
0x6e, 0x98, 0xcd, 0xb3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xd8, 0x28, 0xd0, 0xb0, 0x58, 0x29,
0xbe, 0xb5, 0xd0, 0x7e, 0xba, 0xda, 0x48, 0x31, 0xe4, 0xb2, 0x2a, 0x2b,
0x35, 0xf7, 0xaa, 0xa9, 0x6e, 0x27, 0x9a, 0x28, 0x41, 0xd2, 0x57, 0xf6,
0xff, 0x0a, 0x9f, 0x71, 0x3f, 0xd0, 0x66, 0x81, 0xb5, 0x26, 0xdd, 0x10,
0x09, 0xdc, 0xfb, 0xca, 0x6b, 0x46, 0xa9, 0x2d, 0x11, 0xcc, 0xd8, 0xbd,
0xd3, 0x8e, 0x27, 0xd4, 0xaa, 0x78, 0x00, 0xc1, 0xab, 0x85, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x09, 0x1f, 0x52,
0x14, 0x05, 0xbc, 0x0b, 0x16, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x09, 0x1f, 0x52, 0x14, 0x05,
0xbc, 0x0b, 0x16, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0xb6, 0xff, 0xf6, 0xdf, 0xf3, 0x1a, 0x3f,
0xa6, 0xc0, 0x3e, 0x96, 0x70, 0x44, 0x47, 0x7a, 0x93, 0xd2, 0x5f, 0xcd,
0xea, 0x7b, 0x09, 0xb0, 0x81, 0x2d, 0xfe, 0xba, 0x04, 0x3f, 0x47, 0xcb,
0xbe, 0xc1, 0x76, 0x92, 0x5e, 0xef, 0x74, 0x9a, 0x05, 0x52, 0x61, 0xab,
0x17, 0xfa, 0x9c, 0x8b, 0x76, 0xf4, 0x1e, 0xf0, 0x35, 0x44, 0x48, 0x00,
0x49, 0x16, 0x34, 0xbb, 0x1b, 0xbc, 0x56, 0x7d, 0x7d, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x0a, 0xbc, 0x7c, 0xfb,
0x17, 0x9c, 0x11, 0x11, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74,
0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33,
0x31, 0x33, 0x34, 0x39, 0x39, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xa6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x02, 0x89, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2f, 0xd6,
0x13, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x8c, 0x55,
0x83, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9f, 0x14, 0x62, 0xb4, 0x45,
0xbd, 0x1c, 0xd4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x9f, 0x14, 0x62, 0xb4, 0x45, 0xbd, 0x1c,
0xd4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x0b, 0xba, 0xdb, 0xd7, 0xa2, 0x15, 0x5e, 0x42, 0x59,
0xab, 0xbf, 0x29, 0xe2, 0x07, 0x8d, 0x4c, 0x9a, 0xab, 0x5d, 0xdd, 0xb7,
0xb3, 0xc1, 0xbf, 0x7b, 0x6d, 0xcc, 0xac, 0xb5, 0x7f, 0x60, 0xc0, 0x04,
0xab, 0x2a, 0xc4, 0xf5, 0xcf, 0x3a, 0xcd, 0x3f, 0x9e, 0x8d, 0xb3, 0xe3,
0x79, 0x3f, 0x30, 0xcf, 0x27, 0x87, 0x37, 0x2e, 0xc8, 0xc5, 0x30, 0x62,
0x99, 0xce, 0x3d, 0x92, 0x1f, 0xc6, 0x18, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x84, 0x71, 0x24, 0x56, 0x5c, 0x4a,
0x68, 0xd9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x84, 0x71, 0x24, 0x56, 0x5c, 0x4a, 0x68, 0xd9,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47,
0xb8, 0x40, 0x4c, 0x4c, 0x73, 0xd0, 0x55, 0x95, 0x3a, 0xd8, 0xc1, 0x11,
0xc2, 0xd5, 0x29, 0x17, 0x6b, 0x80, 0xad, 0xc3, 0x29, 0x99, 0x73, 0x5d,
0x11, 0xc9, 0x9b, 0xc2, 0xc3, 0x00, 0x58, 0x0d, 0xad, 0xe7, 0x17, 0x9b,
0x7e, 0xb7, 0x08, 0xa0, 0x98, 0x48, 0xb0, 0x2a, 0xf1, 0x1f, 0x05, 0xfd,
0x3d, 0x3c, 0xf7, 0xe5, 0x25, 0xde, 0xf6, 0xe7, 0x48, 0x1e, 0xb1, 0xb1,
0x3e, 0xbf, 0xd5, 0x34, 0xe7, 0xb9, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x2f, 0x73, 0x75, 0x91, 0x78, 0x6f, 0x69,
0x08, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x24, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x96, 0x28, 0xab, 0xa1, 0xc9, 0x67, 0x33, 0x3b, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x96, 0x28, 0xab, 0xa1, 0xc9, 0x67, 0x33, 0x3b, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xd9, 0x87,
0x8a, 0xf4, 0xfe, 0xe2, 0x81, 0x08, 0xf9, 0x79, 0xf9, 0xc2, 0x25, 0xf2,
0xcd, 0x10, 0xa7, 0x6b, 0x53, 0xa6, 0x96, 0xa6, 0xb6, 0xfd, 0xce, 0x73,
0xd4, 0xdd, 0x6b, 0x86, 0xce, 0xe4, 0x16, 0xeb, 0x2a, 0x22, 0x34, 0x47,
0xb0, 0xe7, 0xe8, 0x3f, 0x0c, 0x7f, 0xd8, 0x11, 0xba, 0xf1, 0x25, 0x4f,
0x35, 0x93, 0x37, 0x39, 0x69, 0xd2, 0x96, 0xfa, 0x57, 0xb3, 0x7d, 0xf3,
0x06, 0x2d, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xc0, 0x8f, 0x0e, 0x4c, 0x21, 0x4c, 0x72, 0x0a, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc0,
0x8f, 0x0e, 0x4c, 0x21, 0x4c, 0x72, 0x0a, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x63, 0xbf, 0xea,
0xb4, 0xc3, 0xe7, 0x24, 0xd7, 0x3f, 0xc3, 0x8c, 0xb8, 0x8c, 0xc2, 0x5b,
0xce, 0x74, 0xad, 0x4e, 0x06, 0x5c, 0xc7, 0xdb, 0xfe, 0xfe, 0x06, 0xe4,
0x78, 0xb8, 0x2e, 0x8b, 0xcd, 0x69, 0x64, 0x9e, 0x69, 0x49, 0x49, 0x44,
0xa3, 0x56, 0xce, 0xa6, 0x5f, 0x23, 0x33, 0xbc, 0xd2, 0x52, 0x13, 0x07,
0x5e, 0x3a, 0x09, 0xe5, 0x99, 0xd6, 0x7a, 0x46, 0xac, 0x07, 0x8c, 0x79,
0xd1, 0x02, 0x01, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x32, 0x37, 0x34, 0x32, 0x39, 0x32, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x3e, 0xee, 0xe7, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc2, 0x71, 0x08, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04,
0x85, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x96, 0x07, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9f, 0xdc, 0x31, 0xf3,
0x35, 0x12, 0xea, 0x4b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x1f, 0x66, 0x75, 0x73, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e,
0x63, 0x65, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x72, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x69, 0x66,
0x75, 0x73, 0x64, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8, 0xdb, 0x82, 0xf4,
0xd8, 0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x3c, 0x59,
0x59, 0xb5, 0x68, 0x89, 0x63, 0x93, 0x64, 0x46, 0x55, 0x53, 0x44, 0xf6,
0x6a, 0x46, 0x55, 0x53, 0x44, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x81,
0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88,
0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x75, 0x46, 0x75, 0x6e, 0x67, 0x69,
0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x42, 0x61, 0x6c,
0x61, 0x6e, 0x63, 0x65, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x46, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x38, 0x30, 0x30, 0x35, 0x35, 0x36, 0x31, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x33, 0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x33, 0x37, 0x34, 0x33, 0x38, 0x38, 0x37, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x01, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x1d, 0x75, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x39, 0x20, 0x8f, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x9c, 0x25, 0x00, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x14,
0x03, 0xdb, 0x4f, 0x51, 0x20, 0x40, 0x5a, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x14, 0x03, 0xdb,
0x4f, 0x51, 0x20, 0x40, 0x5a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x1b, 0x70, 0xb2, 0xe0, 0x5a,
0xe6, 0xe2, 0x91, 0x41, 0x17, 0xe1, 0x93, 0x4d, 0xa6, 0x11, 0x55, 0x41,
0x61, 0x43, 0xdf, 0x3c, 0xd8, 0x68, 0x27, 0x5b, 0x06, 0xaa, 0x57, 0xc6,
0x7b, 0xbe, 0x88, 0x0d, 0xf3, 0x73, 0x39, 0x60, 0x68, 0x50, 0x5e, 0x98,
0xdf, 0x28, 0x19, 0x11, 0x3d, 0xfc, 0x60, 0xd6, 0xe1, 0x8d, 0xcb, 0xc2,
0x0a, 0xe1, 0xc1, 0x70, 0x7a, 0xf5, 0xda, 0x58, 0x15, 0xd3, 0x3c, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x34, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x33, 0x34, 0x37, 0x30, 0x38, 0x39, 0x30, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x4a,
0xc6, 0x1e, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcd, 0x8c, 0xaa,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0xb6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x11, 0x5e, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xba, 0xeb, 0x42, 0xe8, 0x10, 0x87, 0x96, 0xab, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xba, 0xeb,
0x42, 0xe8, 0x10, 0x87, 0x96, 0xab, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x1e, 0x72, 0x48, 0xe3,
0x64, 0xdd, 0x06, 0xdd, 0x9a, 0xce, 0x1a, 0xef, 0x0e, 0x7f, 0x4c, 0xf0,
0xdd, 0xa8, 0x53, 0x74, 0x4a, 0xa5, 0x26, 0x7e, 0x5e, 0xc4, 0x8d, 0xfe,
0xa5, 0x44, 0x7a, 0xf0, 0x93, 0x9f, 0xe7, 0x67, 0xfa, 0xc8, 0x75, 0xa3,
0xfc, 0x2d, 0xd9, 0x5f, 0xe9, 0xe3, 0x61, 0x72, 0x00, 0xfb, 0xd1, 0x41,
0x1d, 0xf9, 0x5d, 0x15, 0x93, 0x03, 0xeb, 0x68, 0xca, 0x2f, 0xad, 0x77,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x78,
0xf4, 0xc2, 0x59, 0x39, 0xa6, 0x99, 0x5d, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48,
0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xb9, 0x5b, 0x7c, 0x56, 0x7a, 0xc6, 0x03,
0x0d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xb9, 0x5b, 0x7c, 0x56, 0x7a, 0xc6, 0x03, 0x0d, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x74, 0x89, 0x02, 0x83, 0x3e, 0xbc, 0xff, 0xc3, 0x95, 0x34, 0xf3,
0xcd, 0x7c, 0x1d, 0x71, 0x97, 0x14, 0xe7, 0x2a, 0x4d, 0x4a, 0x46, 0x9f,
0x20, 0xff, 0xa7, 0x9e, 0xa9, 0xeb, 0x2b, 0x1e, 0x63, 0x58, 0x4c, 0x62,
0xf1, 0x87, 0xd0, 0x53, 0x49, 0x0d, 0xf5, 0xb2, 0x9a, 0x26, 0x97, 0x9a,
0x1d, 0x10, 0xa0, 0x75, 0x21, 0x0d, 0x9e, 0xf8, 0xea, 0xee, 0xd0, 0x64,
0xc2, 0xf3, 0xb7, 0x4c, 0xd4, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xeb, 0xd6, 0x83, 0x7c, 0x09, 0x71, 0xa9, 0xbb,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x35, 0x37, 0x37, 0x37, 0x37,
0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xbe, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x76, 0x56, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x82, 0xe2, 0xec, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x9d, 0x8b, 0x7f, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xec, 0xd3, 0xfb, 0xdb, 0xa7, 0x90, 0xfa, 0x38, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2b, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x32, 0x35, 0x34, 0x35, 0x32, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x99, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x28, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x04,
0xce, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x02, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x03, 0xe2, 0x3d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x01, 0x62, 0xec, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x91, 0x4e, 0x70,
0xbc, 0xc1, 0x4c, 0xfa, 0x66, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36,
0x35, 0x37, 0x34, 0x36, 0x35, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x02, 0xa2, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x82, 0x2c, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x64, 0x52,
0x42, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x09, 0xd9,
0xab, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc5, 0x77, 0xe6, 0x46, 0x10,
0x7b, 0xaa, 0x8a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x44, 0x61, 0x72, 0x6b, 0x43, 0x6f, 0x75, 0x6e,
0x74, 0x72, 0x79, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x5f, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xc8, 0xc3, 0x40,
0xce, 0xbd, 0x11, 0xf6, 0x90, 0x6b, 0x44, 0x61, 0x72, 0x6b, 0x43, 0x6f,
0x75, 0x6e, 0x74, 0x72, 0x79, 0xf6, 0x02, 0x84, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x26, 0x8a, 0x77, 0x69, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x82, 0xd8, 0xa4,
0x19, 0x02, 0xb8, 0xd8, 0xa4, 0x19, 0x02, 0xb9, 0x80, 0x76, 0x44, 0x61,
0x72, 0x6b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x42, 0x9c, 0x01, 0x6f, 0xe5, 0x1f, 0x8f, 0x9c, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31, 0x32, 0x37, 0x33, 0x32, 0x31, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xa1, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x46, 0x37, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x2f, 0xb8, 0x19, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x8c, 0x2e, 0x23, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe7, 0xd5, 0x7d, 0x0b, 0x6f, 0x60, 0xc2, 0x0c, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75,
0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x55, 0x20, 0xca, 0x28, 0xe5, 0x9b, 0xbe, 0xe3,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x37, 0x35, 0x33, 0x30, 0x32,
0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xb2, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x60, 0x74, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x67, 0x0b, 0x02, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x0d, 0x0b, 0x78, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xf6, 0x66, 0x1a, 0x75, 0x1b, 0xa2, 0x41, 0x58, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x1a, 0xb3,
0x0b, 0x41, 0x5d, 0x68, 0x2d, 0xb7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x1a, 0xb3, 0x0b, 0x41,
0x5d, 0x68, 0x2d, 0xb7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x61, 0xe6, 0x2d, 0xa8, 0x19, 0x9b,
0x4c, 0xe4, 0x6c, 0x60, 0xbc, 0x64, 0xc6, 0x8d, 0x2d, 0x86, 0xb9, 0x46,
0x8d, 0x16, 0x11, 0x8a, 0xad, 0x60, 0xc2, 0x91, 0x42, 0x89, 0x6a, 0x1d,
0x97, 0xd7, 0xbf, 0x40, 0x45, 0x77, 0xcd, 0x70, 0xca, 0xf2, 0xce, 0x62,
0x06, 0x09, 0xa0, 0x9b, 0x9a, 0x6a, 0x4e, 0xf1, 0x31, 0x86, 0x0c, 0x68,
0xb7, 0x3d, 0x6d, 0x62, 0x52, 0xe7, 0x34, 0x59, 0x86, 0xd8, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcd, 0xea, 0x93,
0xd2, 0x5d, 0x71, 0x5f, 0x70, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x31, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x45, 0x74, 0x65, 0x72, 0x6e, 0x61,
0x6c, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x38, 0x32, 0x34, 0x33, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x96, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xc3, 0x8a, 0xea, 0x68, 0x3c,
0x0c, 0x4d, 0x38, 0x67, 0x45, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x6c,
0x65, 0x20, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x19, 0x47, 0x43, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xc3, 0x8a,
0xea, 0x68, 0x3c, 0x0c, 0x4d, 0x38, 0x67, 0x45, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x05, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x41, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x18, 0x2b, 0x72, 0x45, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x45, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x41, 0x81, 0x69, 0x4d, 0x85,
0x94, 0x43, 0x10, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x41, 0x81, 0x69, 0x4d, 0x85, 0x94, 0x43,
0x10, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x41, 0x0b, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xca, 0x04, 0x19,
0x48, 0x57, 0xfd, 0x07, 0xad, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xca, 0x04, 0x19, 0x48, 0x57,
0xfd, 0x07, 0xad, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1,
0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x46,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f,
0x34, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x36, 0x38, 0x32, 0x32, 0x39, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xf3, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x25, 0x8b, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x47, 0x72, 0x38, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xb0, 0x17, 0x63, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf8,
0x39, 0x29, 0xc0, 0xab, 0x88, 0xb7, 0xd4, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x38, 0x32, 0x32, 0x38, 0x30, 0x39, 0x35, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x1d, 0xd7, 0x2a,
0x34, 0x41, 0x98, 0xb3, 0x9f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x34, 0x31, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x38,
0x32, 0x35, 0x31, 0x34, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x24, 0x90, 0x0f, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xb4, 0x6f, 0xf5, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x93, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x47, 0x11, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x61, 0x25, 0x9f, 0x00, 0xc7, 0x4b,
0x81, 0x39, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x38, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61,
0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x39,
0x32, 0x33, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x94, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x08, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x02, 0x17, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x02, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x01, 0xd1, 0xc0, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x08, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf, 0x8a, 0x2a,
0x26, 0xff, 0x87, 0x8f, 0xda, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x21, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72,
0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52,
0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x86, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0xe5, 0x44, 0x17, 0x5e, 0xe0, 0x46, 0x1c, 0x4b, 0x6f,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x69, 0x6e, 0x67, 0xf6, 0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70,
0x69, 0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xea, 0xd8,
0x92, 0x08, 0x3b, 0x3e, 0x2c, 0x6c, 0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19,
0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74,
0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
0x72, 0xf6, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc7,
0x8d, 0x4b, 0x78, 0x19, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x46, 0x6f, 0x72, 0x77,
0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1,
0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f,
0x32, 0x37, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x34, 0x38, 0x32, 0x38, 0x30, 0x32, 0x30, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0x06, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x18, 0xbf, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x49, 0xab, 0x74, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xb2, 0x8b, 0x85, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x3b, 0x4e, 0xef, 0x6f, 0x3f, 0x9e, 0x12, 0xc8, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x3b, 0x4e,
0xef, 0x6f, 0x3f, 0x9e, 0x12, 0xc8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x2c, 0xa7, 0xfb, 0x1e,
0x61, 0x0a, 0x90, 0x6e, 0xc4, 0xee, 0xcd, 0x7e, 0x6a, 0xeb, 0xc9, 0xc3,
0x1e, 0x84, 0x88, 0x49, 0x31, 0x86, 0xee, 0x2f, 0x36, 0xdc, 0x37, 0x80,
0xd3, 0xca, 0x1f, 0xd7, 0x4d, 0xd9, 0x89, 0xbd, 0x0f, 0xfd, 0x16, 0x45,
0xd5, 0xa0, 0x78, 0x56, 0x7e, 0x6d, 0x1a, 0x3b, 0x61, 0x52, 0x46, 0xbd,
0x9c, 0xdd, 0xb1, 0x4f, 0x9c, 0x1a, 0xef, 0xe4, 0x16, 0xea, 0xde, 0x97,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x68,
0xa3, 0x99, 0x43, 0xb7, 0x5f, 0x68, 0x64, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x38, 0x36, 0x34, 0x30, 0x35, 0x36, 0x38, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0xc6, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x08, 0xa7,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x83, 0xd8, 0x38, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0x9e, 0x85, 0xac, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd0, 0x4e, 0x63,
0xc6, 0x87, 0x75, 0xf1, 0xbd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xf6, 0xc9, 0x2f, 0x62, 0x25, 0x2f, 0x49, 0x66, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x53,
0x27, 0x4d, 0x00, 0xb6, 0x46, 0x24, 0xa8, 0xfc, 0x47, 0x16, 0x22, 0x4b,
0x3f, 0xe0, 0xde, 0x0b, 0x47, 0xad, 0xb6, 0xce, 0xbe, 0xf2, 0x1e, 0xdc,
0x1c, 0x81, 0x52, 0x72, 0x29, 0x1e, 0x0c, 0x46, 0x35, 0xae, 0xac, 0x7b,
0x4e, 0x0c, 0xbf, 0x10, 0xe6, 0xac, 0x86, 0x67, 0x91, 0x24, 0x00, 0x34,
0xc7, 0x4f, 0x8a, 0x1e, 0xf5, 0x9b, 0x10, 0x61, 0xae, 0xa3, 0x6d, 0x29,
0xb5, 0x4f, 0xac, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xd6, 0xf2, 0x5c, 0x12, 0x18, 0x50, 0xa0, 0x8c, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9d, 0x02,
0xee, 0x33, 0xd3, 0x45, 0xb1, 0xf1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9d, 0x02, 0xee, 0x33,
0xd3, 0x45, 0xb1, 0xf1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xf9, 0x02, 0x98, 0x29, 0x6c, 0x5a,
0x52, 0x49, 0x60, 0xdf, 0x44, 0x25, 0xef, 0x34, 0xc7, 0x80, 0xf5, 0x21,
0xc0, 0x0f, 0x34, 0x13, 0x93, 0x90, 0x5b, 0xbd, 0x5d, 0x3c, 0xa5, 0xa0,
0x57, 0x7e, 0x03, 0xe1, 0xf7, 0xcd, 0x5b, 0xb0, 0xc0, 0xa3, 0x82, 0x06,
0x00, 0xad, 0xd6, 0x5a, 0x4e, 0xa0, 0x8d, 0x4e, 0xb0, 0xf2, 0x9d, 0x5b,
0xd8, 0x70, 0x6c, 0x8d, 0xc2, 0x87, 0x17, 0xa0, 0x07, 0x92, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x34, 0xf6, 0x88,
0x74, 0xdd, 0x36, 0xcf, 0x99, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x34, 0xf6, 0x88, 0x74, 0xdd,
0x36, 0xcf, 0x99, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0xd8, 0xae, 0x1c, 0x64, 0x99, 0x0f, 0x5d,
0xa3, 0xe7, 0x8a, 0x0d, 0x98, 0x8b, 0x47, 0x40, 0x19, 0x48, 0x57, 0xf3,
0x4c, 0xcc, 0x78, 0xf3, 0xd6, 0xcd, 0x81, 0x93, 0x86, 0x8b, 0x7b, 0xa1,
0xfa, 0xea, 0xc0, 0x80, 0x37, 0x77, 0x51, 0x8f, 0x5c, 0x6e, 0x98, 0xd1,
0x7c, 0x8f, 0xe6, 0x89, 0x33, 0xf6, 0x24, 0xbe, 0x9c, 0x7b, 0x16, 0x3d,
0xe5, 0xc2, 0x00, 0x1d, 0xf7, 0x2b, 0xdd, 0xb2, 0x03, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf, 0x75, 0x8b, 0x82,
0x95, 0xe1, 0xcc, 0x68, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x37,
0x35, 0x38, 0x31, 0x34, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x03, 0x9e, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x13, 0x8e, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x76, 0x61, 0x3e,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x85, 0xb9, 0x0c,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x32, 0x39, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x30, 0x36, 0x39, 0x31, 0x39, 0x37, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0x8b, 0x92, 0xc5,
0xa7, 0x6c, 0x85, 0xee, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0x8b, 0x92, 0xc5, 0xa7, 0x6c,
0x85, 0xee, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xa8, 0x9e, 0xe4, 0x6b, 0x07, 0x80, 0xe1, 0xb6,
0xea, 0x74, 0x5b, 0xed, 0x4e, 0xac, 0x62, 0x75, 0x4e, 0x1f, 0xba, 0x91,
0x65, 0x41, 0xd1, 0xf2, 0x5d, 0xdf, 0x62, 0x4c, 0x9f, 0xca, 0x65, 0x2c,
0x08, 0x9f, 0x9a, 0x6d, 0x76, 0x88, 0xb6, 0x32, 0x4b, 0xa8, 0x7e, 0x17,
0xa6, 0x7b, 0xb4, 0x4d, 0x98, 0x2d, 0x93, 0x3d, 0xef, 0xf8, 0x51, 0x4f,
0x35, 0x6d, 0xa7, 0xbe, 0x64, 0xe9, 0xfb, 0xec, 0x02, 0x01, 0x80, 0x04,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc4, 0xd5, 0xaa, 0xef, 0xb4,
0x00, 0x7e, 0xd3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xc4, 0xd5, 0xaa, 0xef, 0xb4, 0x00, 0x7e,
0xd3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0x6d, 0x73, 0x56, 0x61, 0x05, 0x09, 0x32, 0x44, 0x53,
0xcd, 0x39, 0x5b, 0x2a, 0x6d, 0xda, 0x0d, 0x67, 0x9f, 0x25, 0x01, 0xac,
0x17, 0xd0, 0x4f, 0x2f, 0xd7, 0x01, 0x94, 0xbf, 0x2a, 0x2f, 0x87, 0x05,
0x7e, 0xf5, 0x04, 0xf2, 0xe0, 0x36, 0x78, 0xcf, 0x06, 0xc0, 0x96, 0xa8,
0xc8, 0xda, 0x68, 0x31, 0x02, 0x13, 0x74, 0x46, 0xd7, 0x48, 0xa7, 0x80,
0x57, 0x1e, 0x59, 0xca, 0x62, 0xb3, 0x26, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x95, 0x46, 0x54, 0xd3, 0xb9, 0x73,
0xc7, 0x3e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,
0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56,
0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01,
0x6e, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61,
0x75, 0x6c, 0x74, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0,
0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb4, 0x4d, 0x4d, 0x1d, 0xfd,
0x36, 0x49, 0xa1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x6c,
0xeb, 0x10, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x15,
0x19, 0x15, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xad, 0x26, 0x0b, 0x81,
0x54, 0x8a, 0xb4, 0xcd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xad, 0x26, 0x0b, 0x81, 0x54, 0x8a,
0xb4, 0xcd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0x6b, 0xfb, 0x13, 0xae, 0x2c, 0x0a, 0x19, 0xf1,
0x2b, 0x30, 0x96, 0x91, 0x89, 0x17, 0x66, 0x6f, 0xf5, 0x96, 0x3a, 0x7b,
0x86, 0x24, 0x21, 0x21, 0x7b, 0x1e, 0x72, 0x0c, 0x36, 0xf9, 0xff, 0xc9,
0x24, 0xda, 0x5f, 0x9f, 0x4f, 0x7b, 0x9e, 0x16, 0x36, 0x4c, 0xfc, 0x51,
0x6d, 0x7b, 0x63, 0xfa, 0xb3, 0xef, 0xc7, 0x28, 0xbf, 0x52, 0x83, 0xd8,
0x05, 0xd3, 0x25, 0x46, 0xcd, 0x19, 0xea, 0xdb, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x38, 0x31, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x34, 0x30, 0x36, 0x30, 0x30, 0x38, 0x31, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x04, 0x86, 0x9e,
0x06, 0x76, 0x4c, 0x6b, 0x92, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x34, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x6d,
0x6f, 0x6e, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x77, 0x61, 0x72,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x36, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0xbf, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x93, 0x61,
0x5d, 0x25, 0xd1, 0x4f, 0xa3, 0x37, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e,
0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x77, 0x61,
0x72, 0x64, 0x73, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x93, 0x61, 0x5d, 0x25, 0xd1, 0x4f,
0xa3, 0x37, 0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x6d, 0x6f, 0x6e, 0x73,
0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73, 0xf6,
0x01, 0x84, 0x68, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x49, 0x44, 0xd8,
0xa3, 0x04, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x0d, 0x78, 0x1c, 0x43, 0x68, 0x61, 0x69,
0x6e, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65, 0x77,
0x61, 0x72, 0x64, 0x73, 0x2e, 0x4e, 0x46, 0x54, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x18, 0x45, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x3e, 0x21, 0x1d, 0x78, 0x18, 0x43, 0x68, 0x61,
0x69, 0x6e, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x65, 0x72, 0x73, 0x52, 0x65,
0x77, 0x61, 0x72, 0x64, 0x73, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xf8, 0xf8, 0x1d, 0xb9, 0x27, 0xd8, 0x3b, 0xbc, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x35, 0x32, 0x34, 0x33, 0x30,
0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x02, 0x1f, 0xbb, 0x7e, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xaf,
0xd8, 0xcd, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x8a, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x24,
0x89, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x64, 0xbd, 0x1e, 0xe3, 0x68, 0xb9, 0x14, 0x13, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74,
0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72,
0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x34, 0x32, 0x34, 0x39, 0x37, 0x36,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xd9, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x40, 0xf6, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x34, 0x42, 0xd0, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x92, 0x92, 0xd8, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x36, 0x37, 0x35, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x31, 0x38, 0x37, 0x36,
0x37, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x02, 0x56, 0x26, 0xd6, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xd8, 0x7c, 0x9b, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xcc, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x24, 0x0f, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x33,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x32, 0x37, 0x30, 0x39, 0x30, 0x39, 0x33, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0x6f, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x13, 0x19,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x21, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x29, 0x56, 0x65, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x57, 0xcc, 0x21, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x02, 0x8b, 0xc9,
0xa9, 0xa0, 0x27, 0x08, 0xab, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x02, 0x8b, 0xc9, 0xa9, 0xa0,
0x27, 0x08, 0xab, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x8f, 0xf6, 0x79, 0x96, 0x6a, 0x45,
0x7e, 0xb1, 0x6c, 0x46, 0xdf, 0x49, 0x7e, 0xb4, 0x14, 0x58, 0x5a, 0xa7,
0x12, 0xf7, 0x8a, 0xe3, 0x97, 0xa1, 0xb5, 0x8c, 0x32, 0x94, 0xf3, 0x62,
0xa2, 0xd4, 0x49, 0x95, 0xd5, 0x7c, 0x30, 0x29, 0x2a, 0x16, 0x4f, 0xe7,
0x1e, 0x71, 0xd5, 0xf3, 0xaf, 0x76, 0x19, 0xe1, 0x81, 0x9b, 0xf5, 0xf3,
0xd0, 0xde, 0x0d, 0x7a, 0x5d, 0x4b, 0x02, 0x0d, 0xa6, 0xe7, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc8, 0x37, 0xe4,
0xde, 0xf2, 0x41, 0xcf, 0x5c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc8, 0x37, 0xe4, 0xde, 0xf2,
0x41, 0xcf, 0x5c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x35, 0x65, 0x0e, 0xc5, 0xb0, 0xdb, 0x80,
0xf1, 0x5b, 0x4e, 0x47, 0xfe, 0x7c, 0x64, 0x9c, 0x62, 0xad, 0xe5, 0xc7,
0x7c, 0x58, 0x83, 0xb9, 0xb2, 0xfb, 0xd3, 0x72, 0xb0, 0x39, 0x12, 0xa5,
0x01, 0x69, 0x2f, 0x7c, 0x6b, 0x36, 0xcf, 0x25, 0x34, 0xf6, 0xc3, 0xb4,
0x59, 0xca, 0xee, 0x7b, 0xa1, 0x88, 0x39, 0xd2, 0xfc, 0x9b, 0x3b, 0x15,
0x6d, 0x6b, 0xff, 0xa4, 0xa2, 0xdd, 0x2a, 0xe2, 0x69, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7d, 0x99, 0x02, 0x03,
0xb3, 0xc1, 0xc7, 0x9d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x4d, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84,
0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81,
0x82, 0x80, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x87, 0x98, 0x04, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x65, 0xf8, 0x44, 0x6d, 0x30, 0x3d, 0x2f, 0x19,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x65, 0xf8, 0x44, 0x6d, 0x30, 0x3d, 0x2f, 0x19, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63,
0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x01, 0xb9, 0x7c, 0xf6, 0xda, 0x96,
0x5d, 0xed, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x01, 0xb9, 0x7c, 0xf6, 0xda, 0x96, 0x5d, 0xed,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x41, 0x0b, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf4, 0x8d, 0xba, 0xca,
0x7e, 0x38, 0xd3, 0xa3, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x30,
0x36, 0x36, 0x35, 0x30, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x02, 0x1b, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x04, 0x80, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x1f, 0x88, 0x48,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2f, 0xb0, 0xd9,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x51, 0xd0, 0x0c, 0xd4, 0x1a, 0xd0,
0xd0, 0xbe, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x32, 0x37,
0x35, 0x39, 0x37, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x02, 0x07, 0xc4, 0x0d, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xac, 0x0e, 0xcb, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x7f, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x3c, 0x4f, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x78, 0xac, 0x00, 0x11, 0x0b, 0x90, 0xae,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x7d, 0xa8, 0x57, 0x7f, 0xc3, 0x51, 0xc1,
0xbc, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x7d, 0xa8, 0x57, 0x7f, 0xc3, 0x51, 0xc1, 0xbc, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x1b, 0x26, 0x12, 0xa2, 0xb5, 0xed, 0x02, 0xd7, 0x18, 0x2c, 0x5b,
0x69, 0xf8, 0xef, 0xd8, 0x30, 0xdc, 0xe5, 0x55, 0x95, 0xcb, 0x56, 0xa4,
0x7f, 0x30, 0x49, 0x0c, 0x41, 0xe7, 0xf5, 0x88, 0xad, 0xa3, 0x52, 0xe9,
0xa8, 0x49, 0x0b, 0x0f, 0x91, 0x89, 0x48, 0xf4, 0xed, 0x8c, 0x2e, 0x70,
0x81, 0xe9, 0x29, 0xda, 0x19, 0x3b, 0xba, 0x90, 0xb0, 0x62, 0x3a, 0x22,
0x14, 0x2e, 0x45, 0xb2, 0xad, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x94, 0x30, 0x4e, 0x5f, 0xc5, 0x71, 0xd1, 0x85,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x94, 0x30, 0x4e, 0x5f, 0xc5, 0x71, 0xd1, 0x85, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x2b, 0x17, 0xed, 0x41, 0x68, 0x77, 0x37, 0xfa, 0xad, 0x5b, 0x5d, 0x9d,
0xc8, 0x90, 0xde, 0x7a, 0x98, 0x8f, 0x14, 0x3f, 0x8e, 0x42, 0xb9, 0x27,
0x59, 0x77, 0x80, 0xdc, 0x40, 0x59, 0x37, 0x2a, 0x23, 0x70, 0x9d, 0xc9,
0x48, 0xa6, 0xe4, 0x05, 0x06, 0x00, 0x93, 0xe4, 0x92, 0xa8, 0x34, 0x23,
0xfc, 0xfe, 0xdc, 0x6a, 0x80, 0x93, 0x5c, 0x20, 0x8e, 0x6f, 0xae, 0xf0,
0xc9, 0xd4, 0x30, 0x08, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xee, 0xff, 0x6b, 0xe5, 0x02, 0x43, 0x5f, 0x04, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x1d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x59, 0x01, 0x48, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4, 0xf4, 0xc4, 0x25,
0x75, 0x10, 0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0xf6, 0x02, 0x8c,
0x75, 0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x63, 0x69, 0x61, 0x72, 0x79,
0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xd8, 0xc9,
0x83, 0xd8, 0x83, 0x48, 0xfa, 0xf0, 0xcc, 0x52, 0xc6, 0xe3, 0xac, 0xaf,
0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72,
0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52,
0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xf6, 0x6d, 0x63, 0x75, 0x74,
0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0xd8, 0xbc,
0x1a, 0x00, 0x4c, 0x4b, 0x40, 0x67, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c,
0x65, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0xd8, 0x81, 0x82, 0x81, 0xd8, 0xa4, 0x1a, 0x00, 0x8f, 0x8e, 0x18,
0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x38, 0x9b,
0x83, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x6f, 0x77, 0x6e,
0x65, 0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xee, 0xff, 0x6b, 0xe5, 0x02, 0x43,
0x5f, 0x04, 0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19, 0x64, 0x61, 0x70, 0x70,
0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69,
0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xf6, 0x66, 0x70,
0x72, 0x69, 0x63, 0x65, 0x73, 0xd8, 0x81, 0x82, 0x81, 0xd8, 0xa4, 0x1a,
0x00, 0x8f, 0x8e, 0x18, 0x81, 0xd8, 0xbc, 0x1a, 0x35, 0xa4, 0xe9, 0x00,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x38, 0x9b, 0x82,
0x75, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x9b, 0x93, 0xcd, 0x77, 0xa9, 0xd3, 0x71, 0x20,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x9b, 0x93, 0xcd, 0x77, 0xa9, 0xd3, 0x71, 0x20, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x62, 0x42, 0x3d, 0x85, 0x65, 0x94, 0x7b, 0xed, 0xe0, 0x08, 0x84, 0xdf,
0xae, 0x4b, 0xc0, 0xae, 0x53, 0xe6, 0x77, 0x9b, 0x4a, 0xa5, 0xea, 0x69,
0xb1, 0xac, 0xbe, 0xa5, 0xb8, 0x46, 0xc2, 0xf6, 0x00, 0x0d, 0xc8, 0x6a,
0x4b, 0x2e, 0xc5, 0x96, 0xe2, 0x7b, 0xdc, 0xbf, 0xcc, 0x77, 0x7f, 0x69,
0x00, 0xe1, 0x85, 0x24, 0x93, 0x4d, 0xe3, 0xdc, 0x4b, 0x50, 0xfd, 0xff,
0x2d, 0x58, 0x4d, 0xf1, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x32, 0x35, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x31, 0x35, 0x35,
0x32, 0x35, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02,
0xa7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x16, 0x3a, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x3f, 0x67, 0x72, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa5, 0x81, 0x0d, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xab, 0xa3, 0xaf, 0xcf, 0x4b, 0x88, 0x1f, 0x4a,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xab, 0xa3, 0xaf, 0xcf, 0x4b, 0x88, 0x1f, 0x4a, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x32,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x4e, 0xd1, 0x95, 0xba, 0xd7, 0x05, 0x05, 0x8e, 0x92, 0x53, 0x04, 0x00,
0xd9, 0xe3, 0x12, 0x38, 0x3c, 0xfa, 0xcd, 0x00, 0x50, 0xd9, 0xbf, 0x2b,
0xcd, 0x8a, 0xa9, 0x46, 0xc5, 0xf1, 0xc4, 0x41, 0x81, 0x33, 0x8e, 0x80,
0xc5, 0x4b, 0x2e, 0x97, 0xf0, 0x13, 0x64, 0x5f, 0x3d, 0xf2, 0xcd, 0xd5,
0x0d, 0xfa, 0x10, 0xb6, 0x7c, 0x9f, 0x80, 0x96, 0xdd, 0x2f, 0xb0, 0x8e,
0xa9, 0x18, 0xd2, 0x51, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x90, 0xa0, 0x34, 0x27, 0xb9, 0x96, 0x57, 0xaf, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f,
0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x36, 0x32, 0x30, 0x30, 0x39,
0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x76, 0x1f, 0x32, 0x36, 0x34,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x32, 0x33, 0x30, 0x30, 0x35, 0x31, 0x34, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x02, 0x2e, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x1e, 0xe8,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x23, 0x1a, 0x62, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x33, 0x5c, 0xe4, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa5, 0xbe, 0x8b,
0xc4, 0xdd, 0xbc, 0xa5, 0x49, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x41,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6a, 0x17, 0xf5, 0x0c, 0xdd, 0x9a,
0x2f, 0x14, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x33, 0x37, 0x36,
0x30, 0x31, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02,
0xfe, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x11, 0x8d, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x70, 0x8c, 0x8b, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x19, 0x9c, 0xc9, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xca, 0x39, 0x92, 0xaa, 0x79, 0x23, 0xeb, 0x43,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xca, 0x39, 0x92, 0xaa, 0x79, 0x23, 0xeb, 0x43, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x85, 0x54, 0x55, 0xe8, 0xf1, 0xf8, 0x92, 0xe5, 0xb4, 0x8d, 0x5a, 0x08,
0xa4, 0x30, 0x60, 0xaa, 0x7d, 0xb2, 0xe8, 0x8b, 0x3b, 0x2d, 0x89, 0x04,
0x26, 0x03, 0xf6, 0x08, 0xfb, 0x2d, 0x78, 0x3b, 0x8a, 0x35, 0x74, 0xff,
0xd5, 0x53, 0x8d, 0x62, 0xc3, 0x21, 0x1b, 0x20, 0xd8, 0x60, 0x9d, 0xc4,
0x88, 0x03, 0xcc, 0x43, 0x26, 0xa9, 0xc0, 0x70, 0x49, 0xd8, 0x0e, 0x1a,
0x0c, 0x5e, 0x44, 0xb4, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x8b, 0x28, 0x1c, 0x1d, 0xde, 0x7f, 0x13, 0x55, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x8b, 0x28, 0x1c, 0x1d, 0xde, 0x7f, 0x13, 0x55, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x7f,
0x6a, 0x81, 0xf5, 0x1d, 0x73, 0xfd, 0xfa, 0x21, 0x74, 0x4e, 0xd4, 0x70,
0xe4, 0xc2, 0x8c, 0xcb, 0xb6, 0x07, 0x94, 0x7b, 0x6c, 0x23, 0xa9, 0x30,
0x5a, 0x78, 0xfe, 0xd7, 0x6b, 0x16, 0x7c, 0x0d, 0x0e, 0xa2, 0x46, 0xb3,
0x6d, 0x8b, 0x9c, 0xd3, 0xd0, 0x4b, 0xf6, 0x91, 0x74, 0x75, 0x0f, 0x22,
0xaa, 0xd8, 0xc3, 0x93, 0xc7, 0x4a, 0xf5, 0x31, 0xe0, 0xd1, 0x71, 0xc2,
0x0a, 0x68, 0x38, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x35, 0x5b, 0x9c, 0x61, 0x79, 0x81, 0x52, 0x3d, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x36, 0x36, 0x32, 0x39, 0x35, 0x39,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02,
0x5e, 0x0c, 0xd5, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xdf, 0xbd,
0x2f, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x20, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0x5f, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x21, 0x43,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x32, 0x36, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x30, 0x38, 0x39, 0x37,
0x36, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x02, 0x54, 0x9e, 0x36, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xd6, 0xfe, 0x26, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xc9, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x0c, 0xfa, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x0e, 0x46, 0x8e, 0x76, 0x57, 0xc3, 0x03, 0x54, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x6c, 0x75, 0x65, 0x48, 0xc2, 0xd9,
0x80, 0xf4, 0x9e, 0xc4, 0x6f, 0xca, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xc2, 0xd9, 0x80, 0xf4,
0x9e, 0xc4, 0x6f, 0xca, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x12, 0x92, 0x39, 0x47, 0xdc, 0x89,
0x80, 0x15, 0x5b, 0xe6, 0x26, 0xcd, 0x0d, 0x8c, 0xe5, 0xc8, 0xb7, 0x85,
0xbb, 0x39, 0x85, 0xc1, 0x7f, 0xe8, 0x2e, 0x78, 0x78, 0xb0, 0xb1, 0xf5,
0xa6, 0x32, 0x0e, 0x1a, 0xbb, 0x24, 0xfe, 0x84, 0x75, 0x4e, 0xb2, 0x6e,
0xee, 0xde, 0x8e, 0xe0, 0xc6, 0x76, 0x54, 0x88, 0x07, 0x16, 0x00, 0x0e,
0xb5, 0x22, 0x31, 0x14, 0x71, 0x40, 0x24, 0x4c, 0x85, 0xef, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xae, 0x2b, 0xcf,
0xab, 0x4f, 0x46, 0x8d, 0xea, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37,
0x38, 0x34, 0x37, 0x30, 0x34, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61,
0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x03, 0xa0, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x31, 0xf3, 0x65, 0x73,
0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44,
0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x77, 0xbc,
0x88, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x87, 0x19,
0xcb, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x77, 0xe7, 0xba, 0xa9, 0x4d,
0xa6, 0x54, 0xa8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x34, 0x34,
0x32, 0x33, 0x36, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x03, 0xbb, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x39, 0x2f, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x80, 0xd1, 0xff, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x9b, 0x72, 0x05, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xbd, 0x0f, 0x5f, 0x9b, 0xd8, 0x27, 0x6d,
0x37, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x1c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x80, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x75, 0x74, 0x6f, 0x70, 0x73, 0x68,
0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8,
0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4, 0xf4, 0xc4, 0x25,
0x75, 0x10, 0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0xf6, 0x75, 0x4d,
0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x81, 0xd8, 0xd6, 0x83,
0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4, 0xf4, 0xc4, 0x25, 0x75, 0x10,
0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0xf6, 0x71, 0x4d, 0x61, 0x72,
0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x5b, 0xfb, 0x98, 0x93,
0xa4, 0x1b, 0x1e, 0x58, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x5b, 0xfb, 0x98, 0x93, 0xa4, 0x1b,
0x1e, 0x58, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0xff,
0x0b, 0xd2, 0xd1, 0xe2, 0x88, 0x0b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x93, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0xd8, 0x81, 0x82, 0x8a, 0xd8, 0xa4, 0x1a, 0x00, 0x4b, 0xb3, 0x6f, 0xd8,
0xa4, 0x1a, 0x00, 0x2a, 0x0b, 0x5a, 0xd8, 0xa4, 0x1a, 0x00, 0x2e, 0xeb,
0x24, 0xd8, 0xa4, 0x1a, 0x00, 0x30, 0x95, 0x1f, 0xd8, 0xa4, 0x1a, 0x00,
0x36, 0x8b, 0x58, 0xd8, 0xa4, 0x1a, 0x00, 0x65, 0x47, 0x5a, 0xd8, 0xa4,
0x1a, 0x00, 0x70, 0x36, 0x7a, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x19, 0x4c,
0xd8, 0xa4, 0x1a, 0x00, 0x76, 0xbf, 0xd0, 0xd8, 0xa4, 0x1a, 0x00, 0x7b,
0xa8, 0x8d, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xdb, 0x21, 0x39, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x5e, 0xbd, 0x0d, 0x2e, 0x57, 0xad, 0x98, 0xf6,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x66, 0x34, 0x32, 0x36, 0x34, 0x61, 0x63, 0x38, 0x66, 0x33, 0x32,
0x35, 0x36, 0x38, 0x31, 0x38, 0x5f, 0x45, 0x76, 0x6f, 0x6c, 0x75, 0x74,
0x69, 0x6f, 0x6e, 0x5f, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x83, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xf4, 0x26,
0x4a, 0xc8, 0xf3, 0x25, 0x68, 0x18, 0x69, 0x45, 0x76, 0x6f, 0x6c, 0x75,
0x74, 0x69, 0x6f, 0x6e, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x8a, 0xd8, 0xa4, 0x19,
0x0c, 0x23, 0xd8, 0xa4, 0x19, 0x1c, 0x55, 0xd8, 0xa4, 0x19, 0x15, 0x86,
0xd8, 0xa4, 0x19, 0x02, 0xdf, 0xd8, 0xa4, 0x19, 0x13, 0x63, 0xd8, 0xa4,
0x19, 0x06, 0xe5, 0xd8, 0xa4, 0x19, 0x24, 0xfd, 0xd8, 0xa4, 0x19, 0x1a,
0x6c, 0xd8, 0xa4, 0x19, 0x26, 0xe0, 0xd8, 0xa4, 0x19, 0x21, 0xa0, 0x80,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x2c, 0x8b, 0x7e,
0x74, 0x45, 0x76, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xad, 0x56, 0xcf, 0x61, 0x5c, 0x86, 0x5d, 0x51, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x1d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70,
0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x59, 0x01, 0x7e, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4, 0xf4, 0xc4, 0x25, 0x75, 0x10, 0x66,
0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0xf6, 0x02, 0x8c, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x36, 0x63, 0x5a, 0x67, 0x66, 0x6f,
0x72, 0x53, 0x61, 0x6c, 0x65, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x02, 0x36, 0x63, 0x5b, 0x69, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x83, 0xd8, 0xa4, 0x1a,
0x00, 0x4d, 0xdf, 0xbc, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0x3a, 0x0f, 0xd8,
0xa4, 0x1a, 0x00, 0xbc, 0xe2, 0x88, 0x80, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x6f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48,
0xad, 0x56, 0xcf, 0x61, 0x5c, 0x86, 0x5d, 0x51, 0xd8, 0xc8, 0x82, 0x03,
0x78, 0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c,
0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0xf6, 0x75, 0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x63,
0x69, 0x61, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
0x74, 0x79, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xfa, 0xf0, 0xcc, 0x52,
0xc6, 0xe3, 0xac, 0xaf, 0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19, 0x64, 0x61,
0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43,
0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xf6,
0x66, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0xd8, 0x81, 0x82, 0x83, 0xd8,
0xa4, 0x1a, 0x00, 0x4d, 0xdf, 0xbc, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0x3a,
0x0f, 0xd8, 0xa4, 0x1a, 0x00, 0xbc, 0xe2, 0x88, 0x83, 0xd8, 0xbc, 0x1b,
0x00, 0x00, 0x00, 0x04, 0xa8, 0x17, 0xc8, 0x00, 0xd8, 0xbc, 0x1b, 0x00,
0x00, 0x00, 0x01, 0x2a, 0x05, 0xf2, 0x00, 0xd8, 0xbc, 0x1b, 0x00, 0x00,
0x00, 0x01, 0x2a, 0x05, 0xf2, 0x00, 0x6d, 0x63, 0x75, 0x74, 0x50, 0x65,
0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0xd8, 0xbc, 0x1a, 0x00,
0x4c, 0x4b, 0x40, 0x75, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53,
0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xab, 0x9f, 0x62, 0xe3, 0x29,
0xd3, 0x09, 0x21, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x33, 0x34,
0x33, 0x33, 0x39, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x02, 0xc3, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2d, 0xc1, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x42, 0x46, 0x66, 0x64,
0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa9, 0xbb, 0x55, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xdf, 0x14, 0x91, 0x21, 0x66, 0x37, 0x8a,
0xbf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xdf, 0x14, 0x91, 0x21, 0x66, 0x37, 0x8a, 0xbf, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x86, 0xa3, 0x81, 0xcf, 0xaa, 0xeb, 0x73, 0x91, 0xd6, 0xc8, 0xcb,
0xfe, 0xc9, 0x52, 0xf7, 0xff, 0x18, 0x8c, 0x84, 0xeb, 0x65, 0x35, 0xfd,
0x51, 0xb8, 0x80, 0x51, 0x82, 0xb9, 0xa2, 0x08, 0x50, 0x70, 0xd5, 0x8c,
0x4f, 0xcc, 0xdd, 0x29, 0xcb, 0xd5, 0x6e, 0x4d, 0x18, 0x44, 0xf0, 0xce,
0x82, 0x82, 0x53, 0x0b, 0xd1, 0x94, 0xed, 0x43, 0x74, 0xa9, 0xb5, 0xe3,
0xf0, 0x89, 0xa0, 0xce, 0x00, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x46, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x39, 0x32, 0x30,
0x32, 0x37, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x82, 0x69, 0x88, 0xb9, 0xa5, 0xec, 0x94, 0xf1,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x82, 0x69, 0x88, 0xb9, 0xa5, 0xec, 0x94, 0xf1, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x37,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x46, 0xdd, 0xf9, 0x1b, 0xd0, 0x98, 0xf4, 0xd2, 0xd5, 0xa0, 0xa9, 0xd8,
0x5b, 0x9c, 0xc5, 0x24, 0xf3, 0x0a, 0x04, 0x55, 0xef, 0x55, 0x81, 0xf5,
0x56, 0x16, 0xd6, 0xb6, 0xbc, 0x33, 0x39, 0x16, 0x25, 0xf0, 0xed, 0xaa,
0x19, 0x40, 0xbe, 0x1f, 0x6f, 0x66, 0x89, 0x2d, 0x66, 0xf6, 0xd8, 0x17,
0x25, 0xc2, 0x34, 0xe0, 0xd8, 0xd9, 0xd0, 0x51, 0xab, 0x67, 0xa7, 0xc8,
0x89, 0x36, 0xdf, 0x12, 0x02, 0x01, 0x80, 0x07, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x35, 0x39, 0x39, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x35, 0x33,
0x30, 0x35, 0x39, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x10, 0x6e, 0xb6, 0x8a, 0x35, 0xf7, 0xa6,
0xf1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x37, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c,
0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x39, 0x30, 0x38,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x93, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x31, 0x32,
0x33, 0x39, 0x32, 0x36, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x07, 0x30, 0xac, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0xab, 0x7f, 0x61, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x7e, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x35, 0x9d, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x75, 0x29, 0xc9, 0x9e, 0x8b, 0xce,
0x2d, 0x43, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x75, 0x29, 0xc9, 0x9e, 0x8b, 0xce, 0x2d, 0x43,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49,
0xb8, 0x40, 0x1a, 0xb2, 0xfc, 0x7f, 0xd3, 0xa4, 0x90, 0xa2, 0x54, 0x95,
0xcc, 0xb6, 0x57, 0xfa, 0xa8, 0xf1, 0x64, 0x31, 0xc1, 0x3e, 0xd9, 0xef,
0x5b, 0x74, 0x06, 0xd4, 0x22, 0x76, 0x1f, 0xf9, 0x84, 0x54, 0xaa, 0x2e,
0x91, 0xca, 0x5f, 0x5c, 0x8f, 0x2a, 0xd6, 0xda, 0xdd, 0xf6, 0x70, 0x5b,
0x49, 0x34, 0xf9, 0x77, 0x59, 0x60, 0x1b, 0xbf, 0xea, 0xcd, 0x37, 0x43,
0xea, 0x45, 0xe6, 0xde, 0x68, 0x53, 0x02, 0x03, 0x82, 0x03, 0xe8, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x05, 0x25, 0xe3, 0x6a, 0x48,
0x15, 0xb9, 0xad, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x05, 0x25, 0xe3, 0x6a, 0x48, 0x15, 0xb9,
0xad, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xd9, 0xe4, 0xe0, 0x05, 0x8e, 0x3d, 0x33, 0x3b, 0x3f,
0xcf, 0xaa, 0x0b, 0x30, 0x96, 0x4b, 0x09, 0x2f, 0x73, 0x6a, 0x41, 0x73,
0xe3, 0x10, 0x4c, 0x5c, 0xbb, 0xeb, 0x5a, 0x24, 0xe0, 0x0f, 0x0b, 0x78,
0xa7, 0xcf, 0x5b, 0x6f, 0x7f, 0x75, 0xd4, 0x1c, 0x21, 0x16, 0xa7, 0xaa,
0xb7, 0x1f, 0xad, 0x1c, 0xc8, 0x05, 0xa4, 0x06, 0x67, 0x7d, 0x15, 0x98,
0x26, 0x06, 0xec, 0x1e, 0x24, 0xbd, 0x84, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x45, 0x2b, 0xe0, 0x65, 0xd1, 0xed,
0x66, 0x3c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x35, 0x33,
0x39, 0x38, 0x34, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0xf9, 0x8a, 0x56, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xa0, 0xd3, 0x48, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x26, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x46, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x01, 0x8b, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xb7, 0xd8, 0x75, 0xb9, 0x72, 0x94, 0x45,
0x30, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34, 0x32, 0x35, 0x32, 0x30,
0x38, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xb8,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x09, 0x5c, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x40, 0xe1, 0xb1, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa7, 0x9c, 0x6c, 0x6b, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x3e, 0xc0, 0xc6, 0x83, 0xfc, 0x4a, 0x1e, 0x1c, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x57, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x55, 0x53,
0x44, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76,
0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x7a, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x68, 0x55,
0x53, 0x44, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xd8, 0xdb, 0x82, 0xf4, 0xd8,
0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xd0, 0x71, 0x5e,
0x3d, 0xdb, 0xfd, 0x3e, 0x60, 0x68, 0x55, 0x53, 0x44, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0xf6, 0x6e, 0x55, 0x53, 0x44, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0,
0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46,
0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf0, 0x51, 0x50, 0x62, 0x13, 0x6c,
0x7b, 0xe5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x70, 0x72, 0x69, 0x76, 0x61,
0x74, 0x65, 0x1f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x61, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8,
0xc8, 0x82, 0x01, 0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0xd8, 0xdb,
0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x8d, 0x0e, 0x87,
0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x78, 0x1f, 0x4c, 0x6f, 0x63,
0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x4c, 0x6f,
0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e,
0x61, 0x67, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x18, 0xdf,
0xd4, 0x30, 0x5a, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x11,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x08, 0x46, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74,
0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46,
0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x17, 0x56, 0x91, 0xa3, 0x45,
0x2f, 0xed, 0xdc, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x35, 0x38,
0x39, 0x34, 0x35, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x80, 0xf8, 0xd9, 0x96, 0x9a, 0xe0, 0xc2,
0x13, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x20, 0x00, 0xb0, 0xe4, 0x62, 0x4d, 0x1d, 0x17, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x35, 0x30, 0x39, 0x36, 0x37, 0x36, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xce, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x6b, 0x58, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x4d, 0xc5, 0x3d, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0xc1, 0x63, 0xb9, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1,
0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f,
0x32, 0x32, 0x38, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x35, 0x38, 0x38, 0x39, 0x37, 0x38,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02,
0x3c, 0x33, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc0, 0x17,
0xb2, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x04, 0x63, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x9a, 0x29,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x49, 0x55, 0x79, 0x27, 0x46, 0x69, 0xab, 0x02, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f,
0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53,
0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x39, 0x34, 0x32, 0x36, 0x35, 0x39, 0x34, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03, 0xf8, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x76, 0x9b, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x8f, 0xd6, 0xa2, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0xb8, 0x61, 0x40, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x86, 0x24, 0xb5, 0x2f, 0x9d, 0xdc, 0xd0, 0x4a, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x76, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x1f, 0x46, 0x6c,
0x6f, 0x77, 0x49, 0x44, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61,
0x6b, 0x69, 0x6e, 0x67, 0x1f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x1f, 0x76,
0x1f, 0x32, 0x63, 0x66, 0x61, 0x62, 0x37, 0x65, 0x39, 0x31, 0x36, 0x33,
0x34, 0x37, 0x35, 0x32, 0x38, 0x32, 0x66, 0x36, 0x37, 0x31, 0x38, 0x36,
0x62, 0x30, 0x36, 0x63, 0x65, 0x36, 0x65, 0x65, 0x61, 0x37, 0x66, 0x61,
0x30, 0x36, 0x38, 0x37, 0x64, 0x32, 0x35, 0x64, 0x64, 0x39, 0x63, 0x37,
0x61, 0x38, 0x34, 0x35, 0x33, 0x32, 0x66, 0x32, 0x30, 0x31, 0x36, 0x62,
0x63, 0x32, 0x65, 0x35, 0x65, 0x1f, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
0x74, 0x6f, 0x72, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x36, 0x33, 0x38, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x59, 0x02, 0x11, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x86, 0x24, 0xb5, 0x2f,
0x9d, 0xdc, 0xd0, 0x4a, 0x72, 0x46, 0x6c, 0x6f, 0x77, 0x49, 0x44, 0x54,
0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x6b, 0x69, 0x6e, 0x67, 0xf6,
0x02, 0x8e, 0x6f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x43, 0x6f, 0x6d,
0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67, 0x62,
0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x00, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xf3, 0x58, 0x9e, 0x6f, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0x78, 0x18, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x65, 0x64, 0x54, 0x6f, 0x55, 0x6e, 0x73, 0x74,
0x61, 0x6b, 0x65, 0xd8, 0xbc, 0x00, 0x6e, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
0x73, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x65, 0x64, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xf9, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x3f, 0x77, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x48, 0x4b, 0x8c, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0xb1, 0x08, 0xfc, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x68, 0x08, 0x1f, 0xb4, 0x5a, 0x13, 0xa9, 0x5b, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f,
0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53,
0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x36, 0x35, 0x30, 0x38, 0x34, 0x35, 0x38, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x97, 0xa5, 0x77, 0x05, 0xfc, 0x25, 0x5b, 0x73, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x97, 0xa5,
0x77, 0x05, 0xfc, 0x25, 0x5b, 0x73, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x58, 0xbd, 0xc3, 0xd0, 0x7e, 0x83, 0xba, 0x18, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x2b, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x33, 0x31, 0x34, 0x30, 0x34, 0x39, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x98, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0xd4, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x4c,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x02, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x04,
0xca, 0xc1, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x02,
0xb2, 0x4d, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x01, 0x24, 0x02, 0xa2,
0x5c, 0x63, 0x70, 0xc6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46, 0x65, 0x78, 0x69, 0x73,
0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x01, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x70, 0x54, 0x4a, 0x25, 0x61, 0x5b, 0x2d, 0x37,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x35, 0x35, 0x38, 0x30, 0x39,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32,
0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x01, 0xd7, 0x03, 0x8d, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x91,
0xd8, 0x4e, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x25, 0x66, 0x70, 0x6c, 0x61, 0x79,
0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x08, 0x6c, 0x73, 0x65, 0x72, 0x69,
0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x2c,
0x36, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x37, 0x32, 0x30, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x36, 0x35, 0x38, 0x34,
0x37, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9a, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86,
0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xaf,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x18, 0x88, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x65, 0x99, 0xa6, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x0b, 0x55, 0x3b, 0x6b, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x2c, 0x1a, 0xf2, 0xae, 0x55, 0x43, 0x05, 0x1f, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x38, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74,
0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72,
0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x37, 0x39, 0x37, 0x34, 0x33, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x97, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x4b, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x03, 0x4e, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x02, 0x72,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x02, 0xbe, 0x1f, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x19,
0x18, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x5a, 0xf5, 0xc5, 0x69, 0xab,
0xa1, 0x38, 0x33, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x38, 0x38, 0x31,
0x32, 0x30, 0x30, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9a,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19,
0x03, 0xc9, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x18, 0x5c, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1d, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x86, 0x75, 0xe6, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xad, 0xe0, 0x75, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x1b, 0x23, 0xae, 0xcd, 0x8a, 0xa5, 0x85, 0xc5,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x1b, 0x23, 0xae, 0xcd, 0x8a, 0xa5, 0x85, 0xc5, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x72, 0xc8, 0xc8, 0xf1, 0xfd, 0x8f, 0xe4, 0x3a, 0xdd, 0x91, 0x9a, 0x54,
0x95, 0xec, 0xd7, 0x75, 0xe6, 0x2c, 0x11, 0x3a, 0x1e, 0x4f, 0x02, 0x50,
0x96, 0xd2, 0xb4, 0x09, 0xb4, 0xc7, 0xad, 0xb7, 0x04, 0x3c, 0x56, 0x71,
0x8b, 0xd5, 0x6f, 0x65, 0xb8, 0x58, 0xe2, 0x37, 0x6f, 0xfc, 0xed, 0xcc,
0x5f, 0x48, 0xe1, 0xd5, 0xf0, 0x39, 0x46, 0x68, 0x24, 0xae, 0xbd, 0xfc,
0xf2, 0x2f, 0x63, 0xbb, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x86, 0xa5, 0x6d, 0x81, 0xce, 0xc7, 0x16, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x30, 0x39, 0x39, 0x33, 0x38, 0x35,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70,
0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0xde, 0x6c, 0x73,
0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8,
0xa3, 0x19, 0x4d, 0x9b, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d,
0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x00, 0x6c, 0x53, 0xf9, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x14, 0x64, 0xaf, 0x6b, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x49, 0xff, 0x1a, 0x86, 0x9a, 0x98, 0x4f, 0xe1, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f,
0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53,
0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x36, 0x37, 0x38, 0x34, 0x38, 0x37, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x01, 0xd1, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x23, 0xc6, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f,
0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x19, 0x9c, 0x97, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x25, 0xf5, 0xb5, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x32, 0x27, 0x0a, 0x97, 0xf3, 0xe8, 0x60, 0xf4, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x39, 0x37, 0x37, 0x39, 0x35, 0x37, 0x33, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xdf, 0xb0, 0x8f,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x95, 0x39, 0x75, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x04, 0x13, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x49, 0x40, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x33, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x31, 0x32, 0x38, 0x38, 0x31, 0x33, 0x38, 0x36, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc,
0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6,
0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x41,
0x1e, 0x5c, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xc4, 0x8d, 0xea,
0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x04, 0x82, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x2c, 0x5d, 0xf4, 0xb6, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x29, 0x96, 0x57, 0xdf, 0xe2, 0x1d, 0x24, 0x3a, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75,
0x73, 0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0b, 0x70, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xf1, 0x89, 0xa0, 0x2b, 0x66, 0x82, 0x4e, 0x7e, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf1, 0x89,
0xa0, 0x2b, 0x66, 0x82, 0x4e, 0x7e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x2d, 0x25, 0x01, 0x28,
0x10, 0x95, 0xe2, 0xe2, 0xdd, 0x1b, 0xd0, 0xd2, 0xca, 0x13, 0x5d, 0x3f,
0x47, 0x5c, 0xfe, 0x8b, 0x2f, 0xb6, 0xa8, 0xf0, 0xe7, 0xc2, 0x0e, 0x2f,
0x0f, 0xec, 0xe9, 0x92, 0x88, 0x2c, 0xf3, 0x4e, 0x08, 0x8b, 0x54, 0x8c,
0x47, 0xd8, 0xaa, 0x7a, 0x3e, 0x8f, 0xf5, 0x4d, 0x46, 0x03, 0xea, 0x32,
0xd3, 0x56, 0xdb, 0xce, 0xda, 0x3d, 0x8c, 0x43, 0x54, 0xc8, 0x51, 0x7b,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x87,
0xd3, 0xee, 0x11, 0xc9, 0x21, 0xd1, 0x65, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1a,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x6c, 0x6f, 0x63, 0x6b,
0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67,
0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0xd4, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x8d, 0x0e,
0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x02, 0x8a, 0x6d, 0x6e,
0x6f, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72,
0xf6, 0x6a, 0x6e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x72,
0xf6, 0x6b, 0x75, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x4c, 0x69, 0x6d, 0x69,
0x74, 0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x60, 0xc0, 0x1f, 0x65, 0x76, 0x61, 0x75,
0x6c, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x87, 0xd3, 0xee, 0x11,
0xc9, 0x21, 0xd1, 0x65, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8,
0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54,
0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x78, 0x1f, 0x4c,
0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e,
0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d,
0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xa2, 0x3b, 0x6c, 0x02, 0x81, 0x4d, 0x9b, 0xdd, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70,
0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61,
0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x36, 0x34, 0x30, 0x37, 0x39, 0x31, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf,
0x70, 0x09, 0xa7, 0xdc, 0x02, 0x03, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xbf, 0x70, 0x09,
0xa7, 0xdc, 0x02, 0x03, 0x0f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xc8, 0x21, 0xde, 0x48, 0x0e,
0xe1, 0xe0, 0x05, 0xf3, 0x89, 0xa6, 0x68, 0xee, 0xcb, 0x22, 0x93, 0x67,
0x6d, 0xf0, 0x79, 0x96, 0xb7, 0xd5, 0x8f, 0x32, 0x3e, 0x42, 0x00, 0x34,
0xfa, 0x74, 0x5b, 0x3d, 0xa3, 0x7d, 0x68, 0xe1, 0x0c, 0x2b, 0x3c, 0x10,
0xd9, 0xb2, 0xc9, 0xdb, 0x9d, 0x81, 0x8d, 0x34, 0x09, 0x50, 0x88, 0x92,
0x97, 0x89, 0xa9, 0x38, 0x34, 0xd0, 0x1d, 0xf1, 0x47, 0xe7, 0xc4, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x71, 0x0c,
0x87, 0x94, 0x76, 0x13, 0xfb, 0x7f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x38, 0x37, 0x32, 0x36, 0x31, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0x0f, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x27, 0x3d, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x1c,
0x92, 0xea, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x2c,
0x9e, 0x66, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb6, 0x6b, 0x06, 0x44,
0xa7, 0x3c, 0xec, 0x60, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb6, 0x6b, 0x06, 0x44, 0xa7, 0x3c,
0xec, 0x60, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0xc8, 0x55, 0x31, 0x7b, 0xfd, 0x76, 0xc2, 0x33,
0xc1, 0xf3, 0xc2, 0x5e, 0x9c, 0x73, 0xef, 0x50, 0xd4, 0x7d, 0x3c, 0xc4,
0x10, 0x5e, 0x4b, 0x73, 0x0f, 0x83, 0xd5, 0xe7, 0xcb, 0xe1, 0x55, 0xb2,
0x5b, 0x2d, 0x1b, 0xa3, 0x29, 0xab, 0xfd, 0x33, 0x21, 0xbf, 0xfc, 0x28,
0x61, 0x0d, 0x62, 0xe8, 0x91, 0x1a, 0xe3, 0xb3, 0xc9, 0x0a, 0xbc, 0x44,
0x3b, 0xb0, 0x6a, 0x83, 0x0a, 0xd2, 0xbc, 0x87, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7,
0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53,
0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32, 0x33, 0x34, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x33, 0x38, 0x37, 0x34, 0x37, 0x33, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x47, 0xfc, 0xc0, 0x79,
0x06, 0x57, 0x10, 0x8d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x6e,
0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x03, 0x0d, 0x40, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x30, 0xbe, 0x01, 0x6f, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c,
0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xdb, 0xf1, 0xda, 0x68, 0xd6,
0xe0, 0x01, 0x77, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x31,
0x38, 0x37, 0x30, 0x32, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xf0, 0x46, 0x76, 0x62, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x9b, 0x71, 0x13, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66,
0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x23, 0x6c,
0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0xd8, 0xa3, 0x19, 0x10, 0x1f, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe7, 0xc9, 0x35, 0x19, 0x4c, 0xb5,
0xd3, 0xaa, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe7, 0xc9, 0x35, 0x19, 0x4c, 0xb5, 0xd3, 0xaa,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79,
0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe4, 0x26, 0x28, 0x41,
0x69, 0x66, 0xef, 0x62, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65,
0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x67,
0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01,
0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x4a,
0xe4, 0x5c, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x95, 0x96, 0x8b, 0x6d, 0xef, 0x6f, 0x15, 0xe5, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f,
0x76, 0x1f, 0x31, 0x31, 0x39, 0x35, 0x36, 0x32, 0x35, 0x34, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x26, 0xa2,
0xf7, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xb6, 0x70, 0x1e, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8,
0xa3, 0x19, 0x04, 0x97, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x24, 0x5a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xda,
0xd1, 0x27, 0x5b, 0x3f, 0xcf, 0xcc, 0xf6, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xda, 0xd1, 0x27,
0x5b, 0x3f, 0xcf, 0xcc, 0xf6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x5b, 0x0f, 0x0d, 0x83,
0xbe, 0xd5, 0xb8, 0x44, 0xfd, 0x4a, 0xb5, 0xa4, 0x28, 0xb7, 0xdc, 0x0d,
0xcb, 0x4b, 0x13, 0x9b, 0x16, 0xf5, 0x17, 0xae, 0x38, 0x6f, 0x9e, 0x65,
0xdd, 0xc1, 0x95, 0xed, 0xfb, 0x9b, 0x3e, 0x7f, 0x21, 0xa2, 0x03, 0x9f,
0x2f, 0x0e, 0xd6, 0x87, 0x09, 0xb7, 0xeb, 0xe6, 0x4c, 0x17, 0xc0, 0x1c,
0xac, 0xcb, 0xfa, 0xa7, 0xb6, 0x1f, 0xb8, 0x31, 0x1e, 0xb9, 0x6f, 0x93,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x26,
0xda, 0x41, 0xb9, 0x52, 0x8c, 0x65, 0x7a, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x35, 0x32, 0x30, 0x33, 0x33, 0x39, 0x39, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0x15, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0b, 0xdc,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x22, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x4f, 0x65, 0xc7, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0xc3, 0x67, 0xf6, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xc0, 0x04,
0xc4, 0x0f, 0x0e, 0x0b, 0xb5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xc0, 0x04, 0xc4, 0x0f,
0x0e, 0x0b, 0xb5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x4b, 0xf8, 0x49, 0xb8, 0x40, 0xc3, 0x20, 0xbc, 0x0e, 0x6d, 0x52, 0x4c,
0x09, 0x31, 0x3f, 0x1e, 0x3c, 0xe6, 0x45, 0x0d, 0x98, 0xd3, 0x17, 0x27,
0x8e, 0x4f, 0x54, 0xcd, 0xab, 0xfb, 0xa7, 0x23, 0xab, 0x78, 0x21, 0x22,
0xc3, 0x4c, 0x99, 0xaf, 0x89, 0xe7, 0x88, 0x25, 0xad, 0x34, 0xf1, 0x87,
0x11, 0x09, 0x1b, 0x4e, 0x67, 0x41, 0x5b, 0xc7, 0xe1, 0xb5, 0x58, 0xc9,
0x9d, 0x79, 0xc8, 0x2f, 0xe7, 0x34, 0x50, 0x96, 0x71, 0x02, 0x01, 0x82,
0x03, 0xe8, 0x01, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x75, 0xa6,
0x42, 0x32, 0x1f, 0x9f, 0x7d, 0xef, 0xa2, 0x64, 0x54, 0x79, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x32,
0x33, 0x39, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x33, 0x33, 0x35, 0x37, 0x32, 0x33, 0x39, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xed,
0x82, 0x85, 0xc7, 0xe7, 0xb8, 0x75, 0x3d, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xed, 0x82, 0x85,
0xc7, 0xe7, 0xb8, 0x75, 0x3d, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x8d, 0x01, 0x36, 0x6f, 0x1a,
0xa8, 0x01, 0xb6, 0x13, 0x1c, 0x93, 0xa4, 0x9e, 0x04, 0xea, 0x74, 0x8a,
0x09, 0x71, 0x9d, 0x25, 0xb5, 0x5f, 0xd5, 0x1c, 0xce, 0x8a, 0xfd, 0x53,
0x38, 0x9d, 0x69, 0x62, 0xcb, 0x3f, 0x18, 0xbf, 0x8f, 0x28, 0x5f, 0x2a,
0xf4, 0x9a, 0x61, 0xb3, 0x2b, 0x24, 0x66, 0xfd, 0x21, 0x3a, 0xd7, 0xfc,
0xe3, 0x20, 0x11, 0xbb, 0x0f, 0x94, 0x85, 0xb5, 0xc2, 0xf9, 0xeb, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcd, 0xc6,
0xc8, 0x72, 0x42, 0xb1, 0xb2, 0x72, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xcd, 0xc6, 0xc8, 0x72,
0x42, 0xb1, 0xb2, 0x72, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x03, 0x03, 0xba, 0x65, 0x70, 0x67,
0x9f, 0xf9, 0x1d, 0x30, 0x45, 0x23, 0x2f, 0xe3, 0xec, 0xda, 0xd8, 0x77,
0x50, 0xc5, 0x94, 0x5f, 0xea, 0x14, 0x74, 0x7f, 0x95, 0xd6, 0x58, 0x35,
0x0a, 0x97, 0x8f, 0x0b, 0x23, 0xa3, 0xa0, 0x74, 0xf8, 0xe8, 0x74, 0x7d,
0x20, 0x83, 0x06, 0xba, 0x51, 0x7c, 0x1b, 0x07, 0x86, 0x9a, 0xa6, 0xc2,
0x2a, 0xd9, 0x82, 0xdc, 0x1d, 0x37, 0x24, 0x63, 0xa0, 0x3f, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xeb, 0x8e, 0xae,
0xdd, 0x20, 0xf2, 0x35, 0xb9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31,
0x33, 0x32, 0x36, 0x33, 0x30, 0x36, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x47, 0x2c, 0x08, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xca, 0x60, 0xdb, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18,
0x25, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04,
0xab, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x09, 0xdf, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x9c, 0xf0, 0xe3, 0x44,
0x3e, 0xbc, 0x8b, 0xf9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32,
0x36, 0x38, 0x30, 0x38, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x01, 0xea, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x0e, 0x57, 0x65, 0x73, 0x65,
0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61,
0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x13, 0x59, 0x76,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x19, 0x01, 0x83,
0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb,
0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68,
0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x33, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33,
0x31, 0x37, 0x33, 0x38, 0x30, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x0a, 0xc7, 0x69, 0x3c, 0x91,
0x39, 0xa1, 0x49, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x36, 0x38,
0x34, 0x31, 0x31, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x0c, 0x67, 0x68, 0x0f, 0x4d, 0x98, 0x9b,
0x5a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x0c, 0x67, 0x68, 0x0f, 0x4d, 0x98, 0x9b, 0x5a, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0xca, 0xd6, 0xe1, 0x50, 0xa1, 0xf5, 0xa7, 0xc4, 0x31, 0x30, 0xff,
0x10, 0x41, 0xdb, 0xe2, 0x9d, 0x9c, 0xd2, 0xe8, 0xed, 0x9c, 0x1f, 0x05,
0xcc, 0x26, 0xe4, 0x03, 0x3b, 0x99, 0x6c, 0xf7, 0x1b, 0x9c, 0x3b, 0xb2,
0x47, 0xaf, 0x07, 0xf4, 0x8a, 0xba, 0xaf, 0xd4, 0xda, 0x32, 0xe4, 0xb2,
0xc8, 0x85, 0xb9, 0xc5, 0xfa, 0xc9, 0x04, 0x9f, 0x4b, 0x48, 0x9e, 0x2b,
0x38, 0xc4, 0xaf, 0x59, 0x17, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xb0, 0x5d, 0x46, 0xec, 0x85, 0xfa, 0x58, 0x1e,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66,
0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x35, 0x37, 0x30, 0x31,
0x34, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0x6c, 0x74, 0xd8,
0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6,
0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe, 0x0a,
0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c,
0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x5f, 0x35, 0xf0,
0xc8, 0x0d, 0x4c, 0x37, 0x7a, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x0e,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x07, 0x85, 0xab, 0xb7, 0x3a, 0x7c,
0x4a, 0xd2, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x34, 0x36, 0x35,
0x36, 0x38, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x03,
0xf7, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0xd8, 0xa3, 0x19, 0x78, 0xe6, 0x65, 0x73, 0x65, 0x74, 0x49,
0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x90, 0x6f, 0x51, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xb8, 0xfb, 0xb0, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x31, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x33, 0x39,
0x34, 0x33, 0x30, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x86, 0x53, 0xe7, 0x6a, 0x3e, 0xd3, 0x5b,
0x46, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x21, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c,
0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x86, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xe5,
0x44, 0x17, 0x5e, 0xe0, 0x46, 0x1c, 0x4b, 0x6f, 0x54, 0x6f, 0x6b, 0x65,
0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0xf6,
0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74,
0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xea, 0xd8, 0x92, 0x08, 0x3b, 0x3e,
0x2c, 0x6c, 0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19, 0x64, 0x61, 0x70, 0x70,
0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69,
0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xf6, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x56, 0x32, 0x57, 0x78, 0x19,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x69, 0x6e, 0x67, 0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65,
0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x4a, 0x44, 0x5c, 0x27,
0x0c, 0x8a, 0xe8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xe5, 0x4a, 0x44, 0x5c, 0x27, 0x0c, 0x8a,
0xe8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x50, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x41, 0x0b, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x31, 0xa1, 0x19,
0x18, 0xb4, 0x01, 0x6b, 0x61, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f,
0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x31, 0x38, 0x39, 0x31, 0x38, 0x35, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd5, 0x38, 0x7c, 0xd5,
0x33, 0x32, 0x5a, 0x2c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd5, 0x38, 0x7c, 0xd5, 0x33, 0x32,
0x5a, 0x2c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0x59, 0xe5, 0xed, 0x56, 0xe1, 0xa5, 0x82, 0x1a,
0x59, 0xc8, 0x23, 0x70, 0x88, 0xb4, 0x81, 0x09, 0xe3, 0x51, 0x51, 0x80,
0x1b, 0xe2, 0x53, 0x7d, 0xa9, 0xf6, 0x07, 0x0d, 0x65, 0x26, 0xd4, 0xcb,
0x52, 0xda, 0x23, 0x80, 0x4c, 0xdb, 0xde, 0x6f, 0x8f, 0x1e, 0x99, 0x38,
0x62, 0xa2, 0x37, 0x5e, 0x6e, 0x40, 0xec, 0x05, 0x30, 0x81, 0xaa, 0x2b,
0x60, 0xee, 0xf8, 0x5e, 0x83, 0x14, 0xac, 0x92, 0x02, 0x01, 0x80, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x2c, 0xbf, 0xc8, 0x4d, 0x3f,
0x88, 0x2e, 0x66, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x1f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x41, 0x63, 0x63,
0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x98, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82,
0xd8, 0xc8, 0x82, 0x01, 0x6f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4,
0xd8, 0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x8d, 0x0e,
0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x78, 0x18, 0x4c, 0x6f,
0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x81, 0xd8,
0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x8d, 0x0e, 0x87, 0xb6, 0x51, 0x59,
0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x73, 0xf6, 0x78, 0x1e, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x4c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x73, 0x6b, 0x89, 0xc2, 0xff, 0x1a,
0x92, 0xb9, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x74, 0x6f, 0x72, 0xf6,
0x6a, 0x6e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x6b, 0x65, 0x72, 0xf6,
0x6b, 0x75, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x4c, 0x69, 0x6d, 0x69, 0x74,
0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x5c, 0x0f, 0x22, 0x65, 0x76, 0x61, 0x75, 0x6c,
0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0x9f, 0xc4, 0xca, 0x01, 0xc5,
0x06, 0x32, 0xec, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8, 0xdb,
0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65,
0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x78, 0x1f, 0x4c, 0x6f,
0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x4c,
0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61,
0x6e, 0x61, 0x67, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb3,
0xd9, 0x95, 0x70, 0x8b, 0x6c, 0xdd, 0xc6, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xb3, 0xd9, 0x95,
0x70, 0x8b, 0x6c, 0xdd, 0xc6, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x1c, 0xc0, 0xaf, 0xe8, 0x22,
0x8e, 0xae, 0x32, 0x90, 0xd0, 0x7a, 0x5c, 0x69, 0xd0, 0xed, 0x82, 0xf5,
0xa6, 0xf4, 0xd8, 0x3e, 0x3e, 0x97, 0x09, 0x40, 0x0e, 0x1f, 0x6d, 0x12,
0xa8, 0x8a, 0x1f, 0x93, 0x06, 0x86, 0x55, 0x7d, 0xc2, 0xa4, 0xcc, 0x26,
0x56, 0x3e, 0xf9, 0xe7, 0x1d, 0x0b, 0x14, 0x49, 0x8e, 0x8b, 0x8a, 0x85,
0xef, 0x15, 0xbd, 0xcf, 0x8d, 0xbb, 0x1d, 0x19, 0xe8, 0xda, 0xe2, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x11, 0x7d,
0x30, 0xc1, 0x48, 0x74, 0xce, 0x64, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x11, 0x7d, 0x30, 0xc1,
0x48, 0x74, 0xce, 0x64, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x16, 0x39, 0x07, 0xec, 0x33,
0x04, 0x68, 0xa2, 0xe6, 0x1b, 0x4e, 0x0e, 0x5d, 0x1b, 0x1a, 0x44, 0x32,
0xd3, 0x7c, 0xb4, 0x24, 0x10, 0x1a, 0x0b, 0x54, 0x1f, 0x8f, 0x00, 0x03,
0xb3, 0x58, 0x59, 0x6b, 0x25, 0xed, 0x38, 0x13, 0xd8, 0xfe, 0xa9, 0x4b,
0x6b, 0xde, 0x72, 0x3b, 0x25, 0x45, 0xbd, 0x4a, 0x8b, 0xde, 0x75, 0x77,
0x38, 0x0e, 0x5c, 0xcd, 0x75, 0xa1, 0x7b, 0x96, 0x11, 0x74, 0xfa, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x3c, 0x51,
0xda, 0x23, 0x13, 0x3d, 0xba, 0xdf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x3c, 0x51, 0xda, 0x23,
0x13, 0x3d, 0xba, 0xdf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x32, 0xff, 0x4c, 0xe5, 0xd8, 0x8a,
0xac, 0xba, 0xcb, 0x20, 0x88, 0x4f, 0xe8, 0x1e, 0x1c, 0xc1, 0xda, 0xc3,
0x6a, 0xe8, 0x39, 0xb7, 0xf4, 0x66, 0x28, 0x76, 0xf7, 0x02, 0x44, 0xae,
0x6f, 0x5d, 0x49, 0x6c, 0x4b, 0x7b, 0xbb, 0x1b, 0xc4, 0xa6, 0x44, 0xcb,
0x14, 0x7e, 0xa7, 0xc6, 0xff, 0x38, 0x7c, 0xab, 0xfb, 0xab, 0xec, 0xee,
0xa6, 0x4e, 0xc8, 0x33, 0x77, 0x12, 0x4e, 0x22, 0x60, 0x77, 0x02, 0x01,
0x80, 0x01, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x72, 0x18, 0x66,
0x9f, 0x47, 0x24, 0x60, 0x7c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x72, 0x18, 0x66, 0x9f, 0x47,
0x24, 0x60, 0x7c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x36, 0x79, 0xa0, 0x0a, 0xec, 0xfa, 0x74,
0xf4, 0xc7, 0x90, 0x45, 0xfb, 0x21, 0x37, 0x25, 0xa3, 0x01, 0x94, 0xc9,
0x87, 0xbc, 0xe6, 0xe1, 0x44, 0xdb, 0x3e, 0xbf, 0xbd, 0x8e, 0x0c, 0xf2,
0x34, 0x57, 0x5e, 0x4b, 0xc3, 0x1c, 0x20, 0x24, 0x2d, 0x8b, 0x83, 0x63,
0x2c, 0x83, 0x02, 0x4f, 0x47, 0x7e, 0xc8, 0xcc, 0x44, 0x8c, 0xc3, 0x3e,
0x5e, 0x82, 0x85, 0xb8, 0x6f, 0xe6, 0x91, 0xb8, 0xce, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe8, 0x0b, 0x98, 0x17,
0x1f, 0xd9, 0x95, 0xbd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe8, 0x0b, 0x98, 0x17, 0x1f, 0xd9,
0x95, 0xbd, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b,
0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49,
0xf8, 0x47, 0xb8, 0x40, 0x6e, 0x4f, 0x43, 0xf7, 0x9d, 0x3c, 0x1d, 0x8c,
0xac, 0xb3, 0xd5, 0xf3, 0xe7, 0xae, 0xed, 0xb2, 0x9f, 0xea, 0xeb, 0x45,
0x59, 0xfd, 0xb7, 0x1a, 0x97, 0xe2, 0xfd, 0x04, 0x38, 0x56, 0x53, 0x10,
0xe8, 0x76, 0x70, 0x03, 0x5d, 0x83, 0xbc, 0x10, 0xfe, 0x67, 0xfe, 0x31,
0x4d, 0xba, 0x53, 0x63, 0xc8, 0x16, 0x54, 0x59, 0x5d, 0x64, 0x88, 0x4b,
0x1e, 0xca, 0xd1, 0x51, 0x2a, 0x64, 0xe6, 0x5e, 0x02, 0x01, 0x64, 0x80,
0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x52, 0x35, 0x1e, 0x78, 0x6b,
0x45, 0xcf, 0x31, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f,
0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x4d, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82,
0x80, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x58,
0xd0, 0x99, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x83, 0xbb, 0x4d, 0x7f, 0xd9, 0xe0, 0x5b, 0x15, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x83, 0xbb, 0x4d, 0x7f, 0xd9, 0xe0, 0x5b, 0x15, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xb4,
0x7b, 0x97, 0x08, 0x8d, 0xd2, 0x91, 0x49, 0x7b, 0x8f, 0xbd, 0x88, 0x21,
0x7a, 0xae, 0xf3, 0x5d, 0x5f, 0x54, 0xf9, 0x36, 0xc9, 0xc8, 0x8e, 0xce,
0x88, 0x52, 0x57, 0x42, 0x83, 0xbe, 0xb2, 0xc9, 0x45, 0x2b, 0x31, 0x48,
0x78, 0xb6, 0x3f, 0x96, 0x09, 0x1a, 0x96, 0x14, 0x44, 0xf6, 0xe5, 0x79,
0x30, 0xa3, 0x19, 0x1c, 0x96, 0x32, 0x50, 0x1d, 0xeb, 0x7b, 0x57, 0x8d,
0xab, 0x6b, 0x99, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x6c, 0x89, 0x16, 0x16, 0x6a, 0xd2, 0xf1, 0xc4, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x4c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73,
0x65, 0x64, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x03, 0x61, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf5,
0x1d, 0x86, 0x5a, 0xd2, 0x11, 0xaa, 0x4a, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x3a,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x46, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x34, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46,
0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x38, 0x39, 0x34, 0x35, 0x30,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x7b, 0x81, 0x40, 0x04, 0xbc, 0x5c, 0xc1, 0x37, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x7b, 0x81, 0x40, 0x04, 0xbc, 0x5c, 0xc1, 0x37, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x31, 0x84,
0x40, 0xb2, 0xd4, 0x9c, 0x9a, 0x00, 0x9c, 0x42, 0xf1, 0xe1, 0x84, 0x73,
0xff, 0x50, 0xcd, 0x76, 0x8e, 0xf1, 0xfb, 0xe6, 0xb7, 0xef, 0x61, 0xbe,
0xc3, 0x64, 0x02, 0x07, 0x87, 0x9b, 0x82, 0x48, 0x4a, 0xf3, 0x7c, 0x0f,
0xd2, 0x6f, 0x4e, 0x89, 0x47, 0xdd, 0x05, 0x15, 0xfa, 0x73, 0x2d, 0x5a,
0x05, 0x69, 0x3b, 0x4c, 0x77, 0x92, 0xf6, 0xe4, 0x4a, 0x72, 0x9a, 0x1d,
0x16, 0x6b, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x13, 0xb5, 0xe5, 0x97, 0x52, 0xb3, 0x82, 0xe4, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x46, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x88, 0x23, 0xe7,
0xb5, 0x39, 0x80, 0x19, 0x78, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2b, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x34,
0x37, 0x32, 0x30, 0x33, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x99, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74,
0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99,
0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x18, 0xfa, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d,
0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x02, 0x4d, 0x65, 0x73, 0x65, 0x74,
0x49, 0x44, 0xd8, 0xa3, 0x13, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x07, 0x33, 0xe3, 0x64, 0x75,
0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x05, 0x94, 0x8f, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xc5, 0x27, 0xa7, 0x67, 0x02, 0x81, 0x93, 0x21,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x35, 0x34, 0x34, 0x34, 0x31, 0x38,
0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x0e, 0x7e, 0x68, 0x58, 0x2b, 0x4b, 0x8b, 0xc2, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x0e, 0x7e, 0x68, 0x58, 0x2b, 0x4b, 0x8b, 0xc2, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xee,
0xb3, 0xef, 0xc5, 0x28, 0x1e, 0x1d, 0xf2, 0x40, 0xc8, 0x04, 0xf0, 0xfc,
0x5c, 0x4d, 0x5a, 0x9f, 0xf7, 0x9c, 0xf5, 0x5b, 0xbc, 0x4f, 0xff, 0xf2,
0x29, 0x48, 0xbf, 0x0a, 0xe7, 0xbd, 0xd9, 0x5a, 0x3d, 0xbb, 0x0d, 0xfe,
0xa2, 0x74, 0x69, 0x6f, 0xe2, 0x19, 0x4e, 0x9e, 0x93, 0xbe, 0xf0, 0xef,
0xeb, 0x0a, 0x77, 0x65, 0xe2, 0x0d, 0x1b, 0xb3, 0xed, 0x91, 0x63, 0x70,
0xb9, 0x8d, 0xf9, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65,
0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32,
0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x1f, 0x76, 0x1f, 0x32, 0x39, 0x32, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x30, 0x38, 0x30, 0x37,
0x37, 0x39, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x8b, 0x5a, 0xcc, 0x7d, 0x34, 0x93, 0x57, 0x3e,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x8b, 0x5a, 0xcc, 0x7d, 0x34, 0x93, 0x57, 0x3e, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40,
0x77, 0xcb, 0xb7, 0x1e, 0xde, 0x24, 0x38, 0xf2, 0x46, 0x84, 0x54, 0x4e,
0xe6, 0xae, 0xb4, 0xf2, 0x33, 0x83, 0xb8, 0xfa, 0x3f, 0x7f, 0xdf, 0x08,
0xb8, 0xd8, 0x32, 0x35, 0xaa, 0x40, 0x3e, 0x1d, 0x84, 0x24, 0xf6, 0x35,
0x7c, 0xbd, 0x58, 0xc5, 0x06, 0xc3, 0x75, 0x05, 0x86, 0xf0, 0x1f, 0x1e,
0x71, 0xfa, 0x06, 0x58, 0x85, 0xc1, 0xa0, 0x5a, 0xff, 0x27, 0x76, 0xa8,
0x6e, 0xd8, 0x1b, 0x4d, 0x03, 0x03, 0x82, 0x03, 0xe8, 0x80, 0x80, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x0e, 0x66, 0xde, 0x25, 0x0b, 0x24, 0xa1,
0x44, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x0e, 0x66, 0xde, 0x25, 0x0b, 0x24, 0xa1, 0x44, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x14, 0x17, 0x38, 0x53, 0xfe, 0xc2, 0xdf, 0xb0, 0xf1, 0x95, 0x18,
0xd0, 0x08, 0x6a, 0xd3, 0x25, 0xaf, 0x12, 0xc7, 0xd1, 0x09, 0x32, 0xb8,
0x3e, 0xb6, 0x63, 0xbe, 0x11, 0xce, 0x14, 0x5d, 0x4a, 0x6d, 0x0b, 0x1b,
0xb8, 0x96, 0xd1, 0xd1, 0xed, 0x1a, 0x19, 0xab, 0xdd, 0x07, 0x4d, 0xa2,
0xca, 0x05, 0x24, 0x96, 0xd6, 0x5a, 0xe5, 0xd8, 0xab, 0xc5, 0xd6, 0x64,
0xe9, 0x2d, 0x6c, 0x16, 0x7c, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x19, 0xc0, 0x8c, 0xe5, 0x79, 0x05, 0x9f, 0xef,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x19, 0xc0, 0x8c, 0xe5, 0x79, 0x05, 0x9f, 0xef, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40,
0x68, 0xc1, 0x2e, 0xc6, 0x45, 0xf9, 0x94, 0x1f, 0x4d, 0xcd, 0xa5, 0x32,
0x9f, 0xd7, 0x60, 0xc3, 0xc8, 0xf6, 0x10, 0x7d, 0x0d, 0x79, 0xee, 0x5d,
0xc5, 0x25, 0xfb, 0xed, 0x1e, 0xc2, 0x07, 0x95, 0x33, 0x80, 0xe9, 0x07,
0x36, 0x67, 0xc3, 0x1b, 0x06, 0xca, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x37, 0x37, 0x33,
0x37, 0x35, 0x36, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x02, 0x4f, 0x9e, 0x91, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0xd2, 0x2b, 0xbc, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0xc0, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x4b, 0x70, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x1a, 0x7d, 0xfe, 0x98, 0xaa, 0x10, 0x39, 0xb9,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66,
0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x35, 0x39, 0x35, 0x33,
0x30, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x8a, 0x0b, 0x66, 0x0d, 0x84, 0x5c, 0x2c, 0x7b, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x18, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x66,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65,
0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x5f,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01,
0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8,
0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82,
0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75,
0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6,
0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x5e, 0x49, 0xe4, 0xb1, 0xc8, 0x86, 0x53,
0x1b, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x5e, 0x49, 0xe4, 0xb1, 0xc8, 0x86, 0x53, 0x1b, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x57, 0x8c, 0xa8, 0xb3, 0xe1, 0xa1, 0x77, 0x74, 0x39, 0xe3, 0x75,
0xd0, 0x4e, 0x17, 0x9d, 0x20, 0x49, 0xb9, 0xe4, 0xaa, 0xee, 0xf9, 0xc4,
0xa9, 0x77, 0x3c, 0xe7, 0x0d, 0x05, 0x9d, 0xf1, 0xf3, 0xc3, 0xf7, 0x0f,
0x3d, 0x43, 0xa6, 0xe3, 0x64, 0xab, 0xc0, 0x30, 0x80, 0x29, 0xa0, 0xae,
0x96, 0xfa, 0xeb, 0xa0, 0x83, 0x3a, 0x58, 0xc9, 0xd9, 0xe8, 0xda, 0xcb,
0xfd, 0x1b, 0xa6, 0xf9, 0xd5, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x45, 0xee, 0x5d, 0x87, 0xd3, 0xd8, 0xfa, 0x6d,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x19, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65,
0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65,
0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x5b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8,
0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82,
0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2,
0x33, 0xdc, 0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67,
0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46,
0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x2e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x75, 0x6b, 0x47, 0x3c, 0xd6, 0x34, 0xb0, 0x57, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x62,
0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48,
0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70,
0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x83, 0xd8, 0xa4, 0x1a,
0x00, 0x33, 0x5a, 0x90, 0xd8, 0xa4, 0x1a, 0x00, 0x46, 0xf4, 0x40, 0xd8,
0xa4, 0x1a, 0x00, 0x83, 0x36, 0x01, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x19, 0x5e, 0x71, 0x72, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x05, 0x6b, 0x5d, 0xbe,
0xbd, 0x9a, 0x34, 0xf4, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x57, 0x73, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65,
0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0xf6, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x8d, 0x0e, 0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c,
0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
0xf6, 0x02, 0x8a, 0x67, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xd8,
0x83, 0x48, 0xe1, 0x0c, 0xe4, 0x63, 0xac, 0x60, 0x34, 0x2b, 0x72, 0x6e,
0x6f, 0x64, 0x65, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72,
0x50, 0x72, 0x6f, 0x78, 0x79, 0xf6, 0x6f, 0x6e, 0x6f, 0x64, 0x65, 0x53,
0x74, 0x61, 0x6b, 0x65, 0x72, 0x50, 0x72, 0x6f, 0x78, 0x79, 0xf6, 0x6c,
0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72,
0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xe1, 0x0c, 0xe4, 0x63, 0xac, 0x60,
0x34, 0x2b, 0xd8, 0xc8, 0x82, 0x01, 0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65,
0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48,
0x8d, 0x0e, 0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63,
0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x78, 0x1f,
0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
0x2e, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x5b, 0x4b, 0xc1, 0x78, 0x18, 0x4c, 0x6f, 0x63,
0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x2e, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x60, 0xc4, 0x57, 0x4b, 0x4f, 0xba, 0x91, 0x4d, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x60, 0xc4, 0x57, 0x4b, 0x4f, 0xba, 0x91, 0x4d, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x36, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0xd8, 0xa4, 0x1a, 0x01, 0x4b, 0xcf, 0xe0,
0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56,
0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7b, 0xca,
0xa9, 0x67, 0x46, 0x21, 0xf1, 0x2e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x21, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x64, 0x61, 0x70, 0x70, 0x65,
0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e,
0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x86, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0xe5, 0x44, 0x17, 0x5e, 0xe0, 0x46, 0x1c, 0x4b,
0x6f, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72,
0x64, 0x69, 0x6e, 0x67, 0xf6, 0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69,
0x70, 0x69, 0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xea,
0xd8, 0x92, 0x08, 0x3b, 0x3e, 0x2c, 0x6c, 0xd8, 0xc8, 0x82, 0x03, 0x78,
0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69,
0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76,
0x65, 0x72, 0xf6, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0xcf, 0xc2, 0x5b, 0x78, 0x19, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x46, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x24, 0xa6, 0x7e, 0xb1, 0x48, 0xe6, 0xd4, 0x95, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x24, 0xa6,
0x7e, 0xb1, 0x48, 0xe6, 0xd4, 0x95, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x38, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x4b, 0x58, 0x5f, 0x85,
0x87, 0x03, 0x81, 0xf3, 0xdd, 0xbc, 0x64, 0xc3, 0xfb, 0x21, 0x0a, 0xa2,
0xdc, 0x3e, 0x51, 0xf5, 0x1e, 0x77, 0xe9, 0x9c, 0x59, 0x2c, 0x95, 0x4e,
0x3c, 0x35, 0xb4, 0xf6, 0x2f, 0xe8, 0x1f, 0x9d, 0x3f, 0x3d, 0xcb, 0x18,
0x6f, 0xc5, 0x03, 0xc5, 0x3a, 0xe3, 0x77, 0x45, 0x80, 0x68, 0x24, 0x0c,
0xeb, 0x88, 0x43, 0xea, 0x8b, 0x33, 0xe8, 0xc1, 0xb6, 0x78, 0x3d, 0x99,
0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x4f,
0x80, 0x9d, 0x49, 0xa6, 0x1f, 0x68, 0xb3, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x39, 0x33, 0x31, 0x39, 0x37, 0x36, 0x39, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64,
0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49,
0x44, 0xd8, 0xa3, 0x19, 0x03, 0xef, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61,
0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x5d, 0xe6,
0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00,
0x8e, 0x35, 0x59, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01,
0xb6, 0xbb, 0x3f, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x38, 0x36, 0x21,
0x0e, 0x58, 0x48, 0xae, 0xa8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x38, 0x36, 0x21, 0x0e, 0x58,
0x48, 0xae, 0xa8, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f,
0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x49, 0xf8, 0x47, 0xb8, 0x40, 0x35, 0x65, 0x0c, 0xad, 0x27, 0x9f, 0x14,
0xc6, 0x99, 0x5d, 0xc2, 0xc1, 0x97, 0xd2, 0xc4, 0x8e, 0x07, 0xfa, 0x3b,
0x3f, 0x66, 0xc7, 0x73, 0x88, 0x07, 0x1b, 0xf0, 0xea, 0xc6, 0xc3, 0x9c,
0x85, 0x87, 0x34, 0x29, 0x0d, 0x85, 0x38, 0x5b, 0x82, 0x2b, 0x4c, 0xf1,
0x2f, 0xab, 0x1e, 0x33, 0xef, 0x8c, 0x0b, 0x8c, 0xd5, 0xf0, 0xd0, 0x7c,
0xc9, 0xe6, 0x69, 0xa9, 0x97, 0x1a, 0x62, 0xd9, 0x90, 0x02, 0x01, 0x80,
0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x37, 0x4c, 0x83, 0xba,
0xe5, 0xed, 0x77, 0xba, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x39, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74,
0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61, 0x6c, 0x65, 0x1f, 0x6f,
0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x37,
0x34, 0x36, 0x39, 0x31, 0x32, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xf6, 0x50, 0x0d, 0x3f, 0x6b,
0xae, 0x06, 0x53, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xf6, 0x50, 0x0d, 0x3f, 0x6b, 0xae, 0x06,
0x53, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xd3, 0x85, 0x3b, 0x41, 0xe1, 0x8b, 0x61, 0x6e, 0xa0,
0x2b, 0x0d, 0xa2, 0xe2, 0x06, 0xe9, 0xe5, 0x0f, 0x84, 0x56, 0xfa, 0x6e,
0xe0, 0x03, 0xcb, 0xd9, 0xe4, 0xaf, 0x49, 0xb3, 0x9b, 0xe6, 0xe0, 0x24,
0xcb, 0x0b, 0xd5, 0xe5, 0x21, 0x11, 0x11, 0x59, 0x61, 0x58, 0x76, 0xbe,
0xc2, 0xec, 0x47, 0xf9, 0x67, 0x36, 0x44, 0xdd, 0x5f, 0x9a, 0x14, 0xeb,
0x8d, 0xb6, 0x67, 0x90, 0xea, 0x07, 0xc9, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x01, 0x0d, 0x97, 0x56, 0x6c, 0xcd,
0x26, 0xe5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x34, 0x35, 0x32,
0x33, 0x32, 0x32, 0x32, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x60, 0x75, 0xa7, 0x2d, 0x90, 0x9e, 0x23,
0x43, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x4d, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0,
0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x80, 0x80,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0x24, 0x0d, 0x2d,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x1c, 0xf1, 0x3c, 0x16, 0xff, 0x1b, 0x6e, 0xae, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x0f,
0x10, 0x10, 0x3a, 0xdc, 0xb9, 0x94, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x33, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xa7, 0x67, 0x8e,
0xa9, 0xc8, 0x9c, 0x91, 0x71, 0x7b, 0xd0, 0xb5, 0xd3, 0x31, 0x4c, 0x32,
0x59, 0xdf, 0xd5, 0xc7, 0xc9, 0x08, 0xd3, 0x50, 0x03, 0xbf, 0xaa, 0x1e,
0xd8, 0x27, 0xb2, 0x7c, 0xf2, 0xa3, 0x23, 0x70, 0x48, 0x96, 0x29, 0x25,
0x94, 0xbf, 0xcb, 0xe7, 0x63, 0xcf, 0x10, 0x9b, 0xf9, 0x01, 0x82, 0xdc,
0xb9, 0xda, 0x4e, 0x1e, 0xda, 0x0f, 0xc1, 0x67, 0x8f, 0xf7, 0xaf, 0xcf,
0x21, 0x02, 0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xa5, 0xce, 0x39, 0xd1, 0xb5, 0xe1, 0x36, 0x51, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70,
0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61,
0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x36, 0x31, 0x30, 0x32, 0x37, 0x36, 0x32, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02,
0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82,
0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61,
0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x02, 0x7a, 0x6c, 0x73, 0x65, 0x72,
0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19,
0x15, 0x34, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a,
0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d,
0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x00, 0x5d, 0x1e, 0xea, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4,
0x1a, 0x01, 0x00, 0x28, 0xeb, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f,
0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x13,
0xad, 0x52, 0xeb, 0x9f, 0x52, 0xf9, 0xff, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2d,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x31, 0x32, 0x32, 0x39, 0x34, 0x39, 0x36, 0x36, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x2c, 0x11, 0x02,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xbb, 0x9b, 0x36, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x04, 0xa4, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x79, 0x2a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x1a, 0xf8,
0x7b, 0xc1, 0x87, 0x89, 0x1b, 0xcf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x1a, 0xf8, 0x7b, 0xc1,
0x87, 0x89, 0x1b, 0xcf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x31, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x96, 0xdd, 0xbc, 0xdc, 0x7c,
0x24, 0x37, 0x73, 0x16, 0x61, 0x4e, 0x24, 0x9a, 0x1f, 0x26, 0x0c, 0x91,
0x55, 0x81, 0x61, 0x50, 0x22, 0xbe, 0xaf, 0x80, 0xa5, 0x82, 0xbc, 0x5b,
0x30, 0xaf, 0xb2, 0x90, 0x76, 0xe1, 0x5d, 0x1d, 0x07, 0x21, 0x9e, 0x74,
0xcb, 0xaa, 0x76, 0x3c, 0xc6, 0x6b, 0x18, 0x8d, 0x28, 0x7f, 0x52, 0xa7,
0x63, 0x55, 0x36, 0x38, 0xa2, 0xb6, 0x0e, 0xdc, 0x70, 0xc0, 0xef, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x91, 0xbc,
0x72, 0xcd, 0x52, 0xb3, 0xf6, 0xc1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x91, 0xbc, 0x72, 0xcd,
0x52, 0xb3, 0xf6, 0xc1, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0xbc, 0x93, 0xbb, 0x76, 0x30, 0x8a,
0x2b, 0xee, 0x87, 0x8b, 0x58, 0x5f, 0x71, 0x00, 0xd6, 0xc6, 0x9b, 0x9e,
0xe2, 0x4b, 0xe1, 0x4c, 0x53, 0xda, 0x1b, 0xa2, 0xc6, 0x1f, 0x7e, 0xe8,
0x9a, 0x92, 0x95, 0x85, 0x1d, 0x20, 0x94, 0xd6, 0x38, 0xb8, 0x1c, 0xf8,
0x77, 0x77, 0xad, 0xb8, 0x99, 0xba, 0xae, 0xab, 0x17, 0xf2, 0xad, 0x58,
0x3a, 0xaf, 0x58, 0xfd, 0xdf, 0xa5, 0x9e, 0x37, 0xe1, 0x75, 0x02, 0x01,
0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65,
0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x6b, 0x53, 0xd3,
0xc8, 0xcf, 0x47, 0xe0, 0x59, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x18, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x1f, 0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b,
0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x82, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8, 0xdb, 0x82,
0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x16,
0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x81, 0xd8,
0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe,
0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62,
0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65,
0x69, 0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe7, 0x8e,
0x9b, 0xf8, 0x93, 0x62, 0xd8, 0xe7, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x32, 0x36, 0x36, 0x37, 0x34, 0x32, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0x6a, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x07, 0x3c, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x20, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x28,
0xb3, 0xa3, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x53,
0x0c, 0xe9, 0x6b, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x41, 0xf4,
0xb6, 0x94, 0xbf, 0x9f, 0xb4, 0x70, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x57, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x60, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb,
0x82, 0xd8, 0xc8, 0x82, 0x01, 0x70, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xd8, 0xdb,
0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8, 0xd6, 0x83,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x78, 0x1e, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7f,
0x1c, 0xd5, 0xd8, 0x5f, 0xaf, 0x7c, 0x4e, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7f, 0x1c, 0xd5,
0xd8, 0x5f, 0xaf, 0x7c, 0x4e, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69,
0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x34, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8, 0x40, 0x26, 0xfd, 0x15, 0x7b, 0xe1,
0xda, 0x88, 0x28, 0xba, 0xa0, 0xd0, 0xaf, 0x8d, 0x99, 0x27, 0x1d, 0xb1,
0x2b, 0x64, 0x30, 0x3d, 0x28, 0x1d, 0xa2, 0x1e, 0x3a, 0xa7, 0x08, 0x17,
0x8b, 0xb2, 0xca, 0xe5, 0x00, 0xc4, 0x20, 0xc9, 0x4b, 0x14, 0x0b, 0x61,
0x87, 0x97, 0xfe, 0x58, 0x2a, 0xf4, 0x62, 0x43, 0xfd, 0x6d, 0x47, 0x9d,
0x47, 0x8b, 0xcd, 0xe0, 0xe7, 0xd2, 0x49, 0x95, 0xd8, 0x5b, 0xe0, 0x02,
0x01, 0x80, 0x80, 0x80, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xa7, 0x01,
0x0c, 0xd7, 0x64, 0x74, 0x62, 0xc5, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1e, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,
0x65, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x78, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82,
0x01, 0x78, 0x18, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x6f, 0x72,
0x61, 0x67, 0x65, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0,
0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26, 0xd2, 0x78, 0x18,
0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72,
0xf6, 0x78, 0x22, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65,
0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72,
0x64, 0x65, 0x72, 0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65,
0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x88, 0x75, 0x76, 0x00, 0x97,
0x84, 0x6f, 0x3c, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1a, 0x70, 0x72, 0x69, 0x76,
0x61, 0x74, 0x65, 0x1f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f,
0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x61, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x65,
0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65,
0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48,
0x8d, 0x0e, 0x87, 0xb6, 0x51, 0x59, 0xae, 0x63, 0x6c, 0x4c, 0x6f, 0x63,
0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0xf6, 0x78, 0x1f,
0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73,
0x2e, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64,
0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f,
0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f,
0x76, 0x1f, 0x32, 0x37, 0x35, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e,
0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x30, 0x39, 0x35, 0x35,
0x32, 0x35, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b,
0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73,
0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64,
0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x1f, 0x76, 0x1f, 0x31, 0x32, 0x33, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x38, 0x30, 0x30,
0x33, 0x37, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0xe0, 0x2f, 0x23, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a,
0x00, 0x95, 0x8a, 0xb5, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29,
0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c,
0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x19, 0x04, 0x14, 0x6c, 0x73, 0x65,
0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3,
0x19, 0x11, 0xc8, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x6b, 0x54,
0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x47, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x37, 0x1f, 0x6f, 0x77, 0x6e, 0x65,
0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x36, 0x39,
0x34, 0x32, 0x36, 0x37, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72,
0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x26, 0xd1, 0x09, 0x7d, 0xfc, 0xb9, 0x3a,
0xdf, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x48, 0x26, 0xd1, 0x09, 0x7d, 0xfc, 0xb9, 0x3a, 0xdf, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
0x31, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8, 0x47, 0xb8,
0x40, 0x73, 0x37, 0xb0, 0x21, 0xc9, 0xb0, 0xe0, 0x0b, 0xd6, 0x0c, 0x5e,
0x37, 0xcb, 0x99, 0x9a, 0x47, 0xb1, 0xb3, 0x77, 0x5c, 0xc1, 0x0b, 0x90,
0x81, 0x80, 0x6c, 0xd3, 0x00, 0x98, 0x19, 0xf8, 0x6a, 0x35, 0x06, 0xe2,
0x56, 0xe8, 0xc4, 0x2b, 0x2f, 0x82, 0xd6, 0xd1, 0xef, 0x59, 0xda, 0x0a,
0x5e, 0x14, 0x10, 0x8a, 0x68, 0xec, 0x01, 0xb5, 0x05, 0xd6, 0x7c, 0x35,
0x99, 0x3a, 0x2e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x85, 0x36, 0xc9, 0x3f, 0xc0, 0x6e, 0xf6, 0x87,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x1e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f,
0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61,
0x72, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x78, 0x00, 0xca, 0xde, 0x00, 0x04,
0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x78, 0x18, 0x70, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69,
0x6e, 0x67, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0xd8, 0xdb, 0x82,
0xf4, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6,
0xb3, 0xc0, 0x26, 0xd2, 0x78, 0x18, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74,
0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xf6, 0x78, 0x22, 0x50, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x89, 0xa0, 0x25, 0x63, 0x40, 0x8b, 0xc2, 0x48, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x89,
0xa0, 0x25, 0x63, 0x40, 0x8b, 0xc2, 0x48, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x4b, 0xf8, 0x49, 0xb8, 0x40, 0x57, 0xea, 0xc8,
0xd2, 0xdf, 0x23, 0x9f, 0xab, 0x4f, 0xd0, 0xe7, 0xdf, 0xa3, 0xb8, 0x3a,
0x85, 0x2d, 0x2e, 0xbe, 0xa6, 0x80, 0x11, 0x70, 0xc8, 0x0b, 0x5d, 0x13,
0xc0, 0xd6, 0x22, 0x8c, 0x49, 0x7c, 0xba, 0x44, 0xb3, 0xf7, 0x99, 0xe4,
0xeb, 0xa5, 0x79, 0x8b, 0x90, 0x53, 0x9d, 0xde, 0x60, 0x02, 0xdb, 0x09,
0x59, 0x72, 0x6f, 0x2f, 0x11, 0x0f, 0xc2, 0xce, 0x1a, 0x65, 0xc9, 0x02,
0x00, 0x02, 0x01, 0x82, 0x03, 0xe8, 0x01, 0x80, 0xa2, 0x63, 0x4b, 0x65,
0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x48, 0x5a, 0xb7, 0xe8, 0xac, 0xd0, 0x1b, 0xad, 0x84, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x5a, 0xb7, 0xe8, 0xac, 0xd0, 0x1b, 0xad, 0x84, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x70, 0x75,
0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6f, 0x75,
0x6e, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x41, 0x0b, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0x5f, 0xf5, 0xb8, 0xfb, 0xcb, 0x45, 0x4f, 0x55,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x56, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f,
0x66, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75,
0x6c, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c, 0x00, 0xca,
0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54,
0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x02, 0x84, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0xf1, 0x26, 0x38, 0x67, 0x62, 0x61, 0x6c, 0x61,
0x6e, 0x63, 0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x6f, 0x46,
0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75,
0x6c, 0x74, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x7e, 0xeb, 0x61, 0xf0,
0x4b, 0x9f, 0x01, 0x84, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2a, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x43,
0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x6f, 0x77,
0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x39, 0x33,
0x30, 0x36, 0x33, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x95, 0x00,
0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64, 0x61, 0x74, 0x61, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85,
0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x01,
0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x8e,
0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0xd8, 0xa3, 0x19, 0x01, 0xad, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44,
0xd8, 0xa3, 0x02, 0x72, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e,
0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x62, 0x69,
0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x01, 0x6b, 0x87, 0x64, 0x75, 0x75, 0x69,
0x64, 0xd8, 0xa4, 0x01, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2,
0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x47, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37,
0x32, 0x36, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x33, 0x34, 0x39, 0x36, 0x34, 0x37, 0x36, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x92,
0x28, 0x41, 0x28, 0x41, 0xef, 0xf2, 0xf4, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x20,
0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x64, 0x61, 0x70, 0x70, 0x65,
0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e,
0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x9e, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0xcb, 0x82,
0xd8, 0xc8, 0x82, 0x01, 0x78, 0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72,
0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52,
0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8,
0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xea, 0xd8, 0x92,
0x08, 0x3b, 0x3e, 0x2c, 0x6c, 0x71, 0x44, 0x61, 0x70, 0x70, 0x65, 0x72,
0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0xf6,
0x77, 0x44, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69,
0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74,
0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee,
0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c,
0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67,
0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65,
0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0x95, 0xde, 0x92, 0x26, 0x70, 0xb9, 0x2b, 0xb0, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04,
0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0xf6, 0x02, 0x84, 0x67, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8,
0xbc, 0x1a, 0x00, 0x01, 0x86, 0xa0, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x00, 0x4f, 0x47, 0x66, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x39, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70,
0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c,
0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f, 0x66, 0x6f, 0x72, 0x53, 0x61,
0x6c, 0x65, 0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73,
0x1f, 0x76, 0x1f, 0x38, 0x30, 0x35, 0x39, 0x39, 0x34, 0x35, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x8e,
0x16, 0xb8, 0xdc, 0x65, 0x58, 0x08, 0x55, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x19,
0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
0x72, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x5b, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74,
0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4, 0x05, 0x81, 0xd8,
0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee, 0x88, 0xfe,
0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c, 0x65, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62,
0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52, 0x65, 0x63, 0x65,
0x69, 0x76, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd3, 0xbd,
0x0d, 0xf6, 0x31, 0x59, 0x54, 0x76, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4c, 0x73, 0x74,
0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0xfa, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50,
0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xd8, 0x9e, 0x8d, 0xc3, 0x47,
0x32, 0x22, 0x8f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x48, 0xd8, 0x9e, 0x8d, 0xc3, 0x47, 0x32, 0x22,
0x8f, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x4c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x39, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x49, 0xf8,
0x47, 0xb8, 0x40, 0xe6, 0x48, 0x00, 0xd3, 0x47, 0xeb, 0x35, 0xcb, 0x9b,
0x5b, 0xd8, 0x03, 0xa4, 0x9b, 0x70, 0x83, 0x73, 0xce, 0x1f, 0xed, 0x91,
0xca, 0xa8, 0x10, 0x4e, 0x71, 0x5f, 0xbe, 0xb4, 0x0c, 0x46, 0x0b, 0x0e,
0xde, 0x35, 0xf5, 0xdb, 0xe7, 0xc9, 0xa6, 0xff, 0x4d, 0x69, 0x0d, 0xbe,
0x0b, 0xc3, 0xa7, 0x22, 0x6a, 0x26, 0xb7, 0xb1, 0xf5, 0x46, 0xa7, 0xc9,
0x8e, 0x3e, 0xe9, 0xe5, 0x73, 0x96, 0x1b, 0x02, 0x01, 0x80, 0x80, 0x80,
0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61,
0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x78, 0x33, 0x51, 0xbf, 0xdf, 0xaf,
0xa6, 0x39, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1d, 0x73, 0x74, 0x6f, 0x72, 0x61,
0x67, 0x65, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61,
0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x59, 0x01, 0x33, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4,
0xf4, 0xc4, 0x25, 0x75, 0x10, 0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74,
0xf6, 0x02, 0x8c, 0x75, 0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x63, 0x69,
0x61, 0x72, 0x79, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
0x79, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xfa, 0xf0, 0xcc, 0x52, 0xc6,
0xe3, 0xac, 0xaf, 0xd8, 0xc8, 0x82, 0x03, 0x78, 0x19, 0x64, 0x61, 0x70,
0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f,
0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0xf6, 0x6d,
0x63, 0x75, 0x74, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67,
0x65, 0xd8, 0xbc, 0x1a, 0x00, 0x4c, 0x4b, 0x40, 0x67, 0x66, 0x6f, 0x72,
0x53, 0x61, 0x6c, 0x65, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b,
0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53,
0x68, 0x6f, 0x74, 0xf6, 0x02, 0x84, 0x69, 0x6f, 0x77, 0x6e, 0x65, 0x64,
0x4e, 0x46, 0x54, 0x73, 0xd8, 0x81, 0x82, 0x80, 0x80, 0x64, 0x75, 0x75,
0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x01, 0xa6, 0xa3, 0xe0, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x6f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x43, 0x61,
0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0xd8, 0xc9, 0x83, 0xd8,
0x83, 0x48, 0x78, 0x33, 0x51, 0xbf, 0xdf, 0xaf, 0xa6, 0x39, 0xd8, 0xc8,
0x82, 0x03, 0x78, 0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74,
0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63,
0x65, 0x69, 0x76, 0x65, 0x72, 0xf6, 0x66, 0x70, 0x72, 0x69, 0x63, 0x65,
0x73, 0xd8, 0x81, 0x82, 0x80, 0x80, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0xa6, 0xa3, 0xdf, 0x75, 0x4d, 0x61, 0x72, 0x6b, 0x65,
0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x17, 0xa8,
0xa3, 0xa4, 0x7e, 0xa5, 0xf1, 0x36, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x21, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x64, 0x61, 0x70, 0x70, 0x65,
0x72, 0x55, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e,
0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0x86, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0xe5, 0x44, 0x17, 0x5e, 0xe0, 0x46, 0x1c, 0x4b,
0x6f, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72,
0x64, 0x69, 0x6e, 0x67, 0xf6, 0x02, 0x84, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0xee, 0x93, 0x4f, 0x69, 0x72, 0x65, 0x63, 0x69,
0x70, 0x69, 0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xea,
0xd8, 0x92, 0x08, 0x3b, 0x3e, 0x2c, 0x6c, 0xd8, 0xc8, 0x82, 0x03, 0x78,
0x19, 0x64, 0x61, 0x70, 0x70, 0x65, 0x72, 0x55, 0x74, 0x69, 0x6c, 0x69,
0x74, 0x79, 0x43, 0x6f, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76,
0x65, 0x72, 0xf6, 0x78, 0x19, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x2e, 0x46, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1,
0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48,
0xe3, 0x5e, 0xae, 0xcf, 0x4d, 0xf6, 0xcb, 0xf3, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x56,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x66, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0x65, 0x56,
0x61, 0x6c, 0x75, 0x65, 0x58, 0x4c, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8,
0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04,
0x0a, 0x61, 0x69, 0x46, 0x6c, 0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
0xf6, 0x02, 0x84, 0x67, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0xd8,
0xbc, 0x1a, 0x00, 0x04, 0x72, 0xac, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8,
0xa4, 0x1a, 0x01, 0x4b, 0x54, 0x40, 0x6f, 0x46, 0x6c, 0x6f, 0x77, 0x54,
0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xa2, 0x63,
0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74,
0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91, 0xf7, 0xbb, 0x52, 0x45,
0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72,
0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x33, 0x34, 0x38, 0x1f, 0x6f, 0x77, 0x6e,
0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f, 0x31, 0x33, 0x34,
0x32, 0x37, 0x35, 0x39, 0x38, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58,
0x28, 0x28, 0xf1, 0xfd, 0xf5, 0x05, 0x6f, 0x01, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64,
0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x46,
0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x41, 0x01, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0xf2, 0xa0, 0x91,
0xf7, 0xbb, 0x52, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x48, 0x73, 0x74, 0x6f,
0x72, 0x61, 0x67, 0x65, 0x1f, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x53, 0x68, 0x61, 0x72, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x1f, 0x63, 0x6f, 0x6c, 0x6c, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1f, 0x76, 0x1f, 0x37, 0x32, 0x30,
0x1f, 0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76,
0x1f, 0x31, 0x33, 0x35, 0x38, 0x35, 0x34, 0x37, 0x30, 0x65, 0x56, 0x61,
0x6c, 0x75, 0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84,
0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e,
0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86,
0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x02, 0x4c, 0x9c, 0x65,
0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xcf, 0x4c, 0x3e, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x65, 0x73, 0x65, 0x74, 0x49, 0x44, 0xd8,
0xa3, 0x18, 0x1a, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44, 0xd8, 0xa3,
0x19, 0x04, 0xb9, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75,
0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x69, 0x92, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74,
0x2e, 0x4e, 0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b,
0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xe1, 0x64,
0x97, 0xff, 0x69, 0x8d, 0xa6, 0xac, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79,
0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x2c, 0x73,
0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x4d, 0x6f, 0x6d, 0x65, 0x6e,
0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1f,
0x6f, 0x77, 0x6e, 0x65, 0x64, 0x4e, 0x46, 0x54, 0x73, 0x1f, 0x76, 0x1f,
0x33, 0x39, 0x34, 0x36, 0x33, 0x38, 0x30, 0x65, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x58, 0x9b, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85, 0xd8,
0xc0, 0x82, 0x48, 0x0b, 0x2a, 0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67,
0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0xf6, 0x02, 0x86, 0x64, 0x64,
0x61, 0x74, 0x61, 0xd8, 0x84, 0x85, 0xd8, 0xc0, 0x82, 0x48, 0x0b, 0x2a,
0x32, 0x99, 0xcc, 0x85, 0x7e, 0x29, 0x67, 0x54, 0x6f, 0x70, 0x53, 0x68,
0x6f, 0x74, 0xf6, 0x01, 0x86, 0x66, 0x70, 0x6c, 0x61, 0x79, 0x49, 0x44,
0xd8, 0xa3, 0x19, 0x02, 0x87, 0x6c, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c,
0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0xd8, 0xa3, 0x19, 0x32, 0x14, 0x65,
0x73, 0x65, 0x74, 0x49, 0x44, 0xd8, 0xa3, 0x18, 0x1a, 0x72, 0x54, 0x6f,
0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4d, 0x6f, 0x6d, 0x65, 0x6e, 0x74,
0x44, 0x61, 0x74, 0x61, 0x62, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0x3c,
0x37, 0x8c, 0x64, 0x75, 0x75, 0x69, 0x64, 0xd8, 0xa4, 0x1a, 0x00, 0xa1,
0xd7, 0x83, 0x6b, 0x54, 0x6f, 0x70, 0x53, 0x68, 0x6f, 0x74, 0x2e, 0x4e,
0x46, 0x54, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68, 0x4b, 0x65, 0x79,
0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x98, 0x9b, 0xfc, 0x73,
0x2d, 0x5b, 0x7b, 0x83, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65, 0x01, 0x65,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54, 0x79, 0x70, 0x65,
0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x1c, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x1f, 0x74, 0x6f, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x53,
0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x80, 0x00, 0xca, 0xde,
0x00, 0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x75, 0x74, 0x6f,
0x70, 0x73, 0x68, 0x6f, 0x74, 0x53, 0x61, 0x6c, 0x65, 0x43, 0x6f, 0x6c,
0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0xd8, 0xdb, 0x82, 0xf4, 0xd8,
0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4,
0xf4, 0xc4, 0x25, 0x75, 0x10, 0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74,
0xf6, 0x75, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c,
0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x81,
0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xc1, 0xe4, 0xf4, 0xf4, 0xc4,
0x25, 0x75, 0x10, 0x66, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0xf6, 0x71,
0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x2e, 0x53, 0x61, 0x6c, 0x65, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x63, 0xa2, 0x63, 0x4b, 0x65, 0x79, 0xa1, 0x68,
0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0xdb,
0x56, 0xb8, 0x85, 0x63, 0x3e, 0x24, 0x45, 0xa2, 0x64, 0x54, 0x79, 0x70,
0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x20,
0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x1f, 0x70, 0x72, 0x69, 0x76,
0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e,
0x67, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x65, 0x56, 0x61, 0x6c,
0x75, 0x65, 0x58, 0xcf, 0x00, 0xca, 0xde, 0x00, 0x04, 0xd8, 0x84, 0x85,
0xd8, 0xc0, 0x82, 0x48, 0x18, 0xeb, 0x4e, 0xe6, 0xb3, 0xc0, 0x26, 0xd2,
0x78, 0x18, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63,
0x65, 0x69, 0x76, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x65, 0x72, 0xf6, 0x02, 0x84, 0x69, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69,
0x65, 0x6e, 0x74, 0xd8, 0xc9, 0x83, 0xd8, 0x83, 0x48, 0xdb, 0x56, 0xb8,
0x85, 0x63, 0x3e, 0x24, 0x45, 0xd8, 0xc8, 0x82, 0x02, 0x71, 0x66, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69,
0x76, 0x65, 0x72, 0xd8, 0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd4,
0x05, 0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc,
0xee, 0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62,
0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x76, 0x46, 0x75, 0x6e,
0x67, 0x69, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x52,
0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x64, 0x75, 0x75, 0x69, 0x64,
0xd8, 0xa4, 0x1a, 0x01, 0x47, 0xf5, 0x97, 0x78, 0x22, 0x50, 0x72, 0x69,
0x76, 0x61, 0x74, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72,
0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0x2e, 0x46, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x65, 0x72, 0xa2, 0x63, 0x4b, 0x65, 0x79,
0xa1, 0x68, 0x4b, 0x65, 0x79, 0x50, 0x61, 0x72, 0x74, 0x73, 0x83, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x00, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x48, 0x5f, 0x76, 0xa0, 0x46, 0xd1, 0x21, 0x07, 0x17, 0xa2, 0x64, 0x54,
0x79, 0x70, 0x65, 0x01, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x40, 0xa2,
0x64, 0x54, 0x79, 0x70, 0x65, 0x02, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65,
0x57, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x1f, 0x66, 0x6c, 0x6f, 0x77,
0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65,
0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x58, 0x81, 0x00, 0xca, 0xde, 0x00,
0x04, 0xd8, 0xcb, 0x82, 0xd8, 0xc8, 0x82, 0x01, 0x6e, 0x66, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x75, 0x6c, 0x74, 0xd8,
0xdb, 0x82, 0xf4, 0xd8, 0xdc, 0x82, 0xd8, 0xd5, 0x83, 0xd8, 0xc0, 0x82,
0x48, 0x16, 0x54, 0x65, 0x33, 0x99, 0x04, 0x0a, 0x61, 0x69, 0x46, 0x6c,
0x6f, 0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x6f, 0x46, 0x6c, 0x6f,
0x77, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x2e, 0x56, 0x61, 0x75, 0x6c, 0x74,
0x81, 0xd8, 0xd6, 0x83, 0xd8, 0xc0, 0x82, 0x48, 0xf2, 0x33, 0xdc, 0xee,
0x88, 0xfe, 0x0a, 0xbe, 0x6d, 0x46, 0x75, 0x6e, 0x67, 0x69, 0x62, 0x6c,
0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0xf6, 0x75,
} | codec/zbor/generic.go | 0.639511 | 0.627652 | generic.go | starcoder |
package plaid
import (
"encoding/json"
)
// ExternalPaymentScheduleRequest The schedule that the payment will be executed on. If a schedule is provided, the payment is automatically set up as a standing order. If no schedule is specified, the payment will be executed only once.
type ExternalPaymentScheduleRequest struct {
Interval PaymentScheduleInterval `json:"interval"`
// The day of the interval on which to schedule the payment. If the payment interval is weekly, `interval_execution_day` should be an integer from 1 (Monday) to 7 (Sunday). If the payment interval is monthly, `interval_execution_day` should be an integer indicating which day of the month to make the payment on. Integers from 1 to 28 can be used to make a payment on that day of the month. Negative integers from -1 to -5 can be used to make a payment relative to the end of the month. To make a payment on the last day of the month, use -1; to make the payment on the second-to-last day, use -2, and so on.
IntervalExecutionDay int32 `json:"interval_execution_day"`
// A date in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) format (YYYY-MM-DD). Standing order payments will begin on the first `interval_execution_day` on or after the `start_date`. If the first `interval_execution_day` on or after the start date is also the same day that `/payment_initiation/payment/create` was called, the bank *may* make the first payment on that day, but it is not guaranteed to do so.
StartDate string `json:"start_date"`
// A date in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) format (YYYY-MM-DD). Standing order payments will end on the last `interval_execution_day` on or before the `end_date`. If the only `interval_execution_day` between the start date and the end date (inclusive) is also the same day that `/payment_initiation/payment/create` was called, the bank *may* make a payment on that day, but it is not guaranteed to do so.
EndDate NullableString `json:"end_date,omitempty"`
// The start date sent to the bank after adjusting for holidays or weekends. Will be provided in [ISO 8601](https://wikipedia.org/wiki/ISO_8601) format (YYYY-MM-DD). If the start date did not require adjustment, this field will be `null`.
AdjustedStartDate NullableString `json:"adjusted_start_date,omitempty"`
AdditionalProperties map[string]interface{}
}
type _ExternalPaymentScheduleRequest ExternalPaymentScheduleRequest
// NewExternalPaymentScheduleRequest instantiates a new ExternalPaymentScheduleRequest object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewExternalPaymentScheduleRequest(interval PaymentScheduleInterval, intervalExecutionDay int32, startDate string) *ExternalPaymentScheduleRequest {
this := ExternalPaymentScheduleRequest{}
this.Interval = interval
this.IntervalExecutionDay = intervalExecutionDay
this.StartDate = startDate
return &this
}
// NewExternalPaymentScheduleRequestWithDefaults instantiates a new ExternalPaymentScheduleRequest object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewExternalPaymentScheduleRequestWithDefaults() *ExternalPaymentScheduleRequest {
this := ExternalPaymentScheduleRequest{}
return &this
}
// GetInterval returns the Interval field value
func (o *ExternalPaymentScheduleRequest) GetInterval() PaymentScheduleInterval {
if o == nil {
var ret PaymentScheduleInterval
return ret
}
return o.Interval
}
// GetIntervalOk returns a tuple with the Interval field value
// and a boolean to check if the value has been set.
func (o *ExternalPaymentScheduleRequest) GetIntervalOk() (*PaymentScheduleInterval, bool) {
if o == nil {
return nil, false
}
return &o.Interval, true
}
// SetInterval sets field value
func (o *ExternalPaymentScheduleRequest) SetInterval(v PaymentScheduleInterval) {
o.Interval = v
}
// GetIntervalExecutionDay returns the IntervalExecutionDay field value
func (o *ExternalPaymentScheduleRequest) GetIntervalExecutionDay() int32 {
if o == nil {
var ret int32
return ret
}
return o.IntervalExecutionDay
}
// GetIntervalExecutionDayOk returns a tuple with the IntervalExecutionDay field value
// and a boolean to check if the value has been set.
func (o *ExternalPaymentScheduleRequest) GetIntervalExecutionDayOk() (*int32, bool) {
if o == nil {
return nil, false
}
return &o.IntervalExecutionDay, true
}
// SetIntervalExecutionDay sets field value
func (o *ExternalPaymentScheduleRequest) SetIntervalExecutionDay(v int32) {
o.IntervalExecutionDay = v
}
// GetStartDate returns the StartDate field value
func (o *ExternalPaymentScheduleRequest) GetStartDate() string {
if o == nil {
var ret string
return ret
}
return o.StartDate
}
// GetStartDateOk returns a tuple with the StartDate field value
// and a boolean to check if the value has been set.
func (o *ExternalPaymentScheduleRequest) GetStartDateOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.StartDate, true
}
// SetStartDate sets field value
func (o *ExternalPaymentScheduleRequest) SetStartDate(v string) {
o.StartDate = v
}
// GetEndDate returns the EndDate field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *ExternalPaymentScheduleRequest) GetEndDate() string {
if o == nil || o.EndDate.Get() == nil {
var ret string
return ret
}
return *o.EndDate.Get()
}
// GetEndDateOk returns a tuple with the EndDate field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *ExternalPaymentScheduleRequest) GetEndDateOk() (*string, bool) {
if o == nil {
return nil, false
}
return o.EndDate.Get(), o.EndDate.IsSet()
}
// HasEndDate returns a boolean if a field has been set.
func (o *ExternalPaymentScheduleRequest) HasEndDate() bool {
if o != nil && o.EndDate.IsSet() {
return true
}
return false
}
// SetEndDate gets a reference to the given NullableString and assigns it to the EndDate field.
func (o *ExternalPaymentScheduleRequest) SetEndDate(v string) {
o.EndDate.Set(&v)
}
// SetEndDateNil sets the value for EndDate to be an explicit nil
func (o *ExternalPaymentScheduleRequest) SetEndDateNil() {
o.EndDate.Set(nil)
}
// UnsetEndDate ensures that no value is present for EndDate, not even an explicit nil
func (o *ExternalPaymentScheduleRequest) UnsetEndDate() {
o.EndDate.Unset()
}
// GetAdjustedStartDate returns the AdjustedStartDate field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *ExternalPaymentScheduleRequest) GetAdjustedStartDate() string {
if o == nil || o.AdjustedStartDate.Get() == nil {
var ret string
return ret
}
return *o.AdjustedStartDate.Get()
}
// GetAdjustedStartDateOk returns a tuple with the AdjustedStartDate field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *ExternalPaymentScheduleRequest) GetAdjustedStartDateOk() (*string, bool) {
if o == nil {
return nil, false
}
return o.AdjustedStartDate.Get(), o.AdjustedStartDate.IsSet()
}
// HasAdjustedStartDate returns a boolean if a field has been set.
func (o *ExternalPaymentScheduleRequest) HasAdjustedStartDate() bool {
if o != nil && o.AdjustedStartDate.IsSet() {
return true
}
return false
}
// SetAdjustedStartDate gets a reference to the given NullableString and assigns it to the AdjustedStartDate field.
func (o *ExternalPaymentScheduleRequest) SetAdjustedStartDate(v string) {
o.AdjustedStartDate.Set(&v)
}
// SetAdjustedStartDateNil sets the value for AdjustedStartDate to be an explicit nil
func (o *ExternalPaymentScheduleRequest) SetAdjustedStartDateNil() {
o.AdjustedStartDate.Set(nil)
}
// UnsetAdjustedStartDate ensures that no value is present for AdjustedStartDate, not even an explicit nil
func (o *ExternalPaymentScheduleRequest) UnsetAdjustedStartDate() {
o.AdjustedStartDate.Unset()
}
func (o ExternalPaymentScheduleRequest) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if true {
toSerialize["interval"] = o.Interval
}
if true {
toSerialize["interval_execution_day"] = o.IntervalExecutionDay
}
if true {
toSerialize["start_date"] = o.StartDate
}
if o.EndDate.IsSet() {
toSerialize["end_date"] = o.EndDate.Get()
}
if o.AdjustedStartDate.IsSet() {
toSerialize["adjusted_start_date"] = o.AdjustedStartDate.Get()
}
for key, value := range o.AdditionalProperties {
toSerialize[key] = value
}
return json.Marshal(toSerialize)
}
func (o *ExternalPaymentScheduleRequest) UnmarshalJSON(bytes []byte) (err error) {
varExternalPaymentScheduleRequest := _ExternalPaymentScheduleRequest{}
if err = json.Unmarshal(bytes, &varExternalPaymentScheduleRequest); err == nil {
*o = ExternalPaymentScheduleRequest(varExternalPaymentScheduleRequest)
}
additionalProperties := make(map[string]interface{})
if err = json.Unmarshal(bytes, &additionalProperties); err == nil {
delete(additionalProperties, "interval")
delete(additionalProperties, "interval_execution_day")
delete(additionalProperties, "start_date")
delete(additionalProperties, "end_date")
delete(additionalProperties, "adjusted_start_date")
o.AdditionalProperties = additionalProperties
}
return err
}
type NullableExternalPaymentScheduleRequest struct {
value *ExternalPaymentScheduleRequest
isSet bool
}
func (v NullableExternalPaymentScheduleRequest) Get() *ExternalPaymentScheduleRequest {
return v.value
}
func (v *NullableExternalPaymentScheduleRequest) Set(val *ExternalPaymentScheduleRequest) {
v.value = val
v.isSet = true
}
func (v NullableExternalPaymentScheduleRequest) IsSet() bool {
return v.isSet
}
func (v *NullableExternalPaymentScheduleRequest) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableExternalPaymentScheduleRequest(val *ExternalPaymentScheduleRequest) *NullableExternalPaymentScheduleRequest {
return &NullableExternalPaymentScheduleRequest{value: val, isSet: true}
}
func (v NullableExternalPaymentScheduleRequest) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableExternalPaymentScheduleRequest) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | plaid/model_external_payment_schedule_request.go | 0.78108 | 0.572544 | model_external_payment_schedule_request.go | starcoder |
package match
import (
"strings"
"github.com/gingraslab/pep2gene/digestion"
"github.com/gingraslab/pep2gene/helpers"
"github.com/gingraslab/pep2gene/types"
)
// addPeptide intializes a gene entry if it doesn't exist add adds
// a peptide to its matches. If it does exist, it just appends the peptide.
func addPeptide(geneID string, genes types.Genes, peptide string) {
if _, ok := genes[geneID]; ok {
genes[geneID].Peptides = append(genes[geneID].Peptides, peptide)
} else {
genes[geneID] = &types.Gene{
Peptides: []string{peptide},
}
}
}
// filterPeptides Remove speptides with no matches to a gene and removes
// duplicate gene matches from each peptide.
func filterPeptides(peptides types.Peptides, peptide string) {
if len(peptides[peptide].Genes) == 0 {
delete(peptides, peptide)
} else {
peptides[peptide].Genes = helpers.SliceUnique(peptides[peptide].Genes)
if len(peptides[peptide].Genes) == 1 {
peptides[peptide].Unique = true
}
}
}
func fullSequence(peptides types.Peptides, db []types.Protein) (types.Peptides, types.Genes) {
matchedPeptides := make(types.Peptides, len(peptides))
genes := make(types.Genes)
for peptide := range peptides {
matchedPeptides[peptide] = peptides[peptide].Copy()
matchedPeptides[peptide].Genes = make([]string, 0)
for _, entry := range db {
if strings.Contains(entry.Sequence, peptide) {
matchedPeptides[peptide].Genes = append(matchedPeptides[peptide].Genes, entry.GeneID)
addPeptide(entry.GeneID, genes, peptide)
}
}
filterPeptides(matchedPeptides, peptide)
}
// Remove duplicates peptides in genes.
for gene := range genes {
genes[gene].Peptides = helpers.SliceUnique(genes[gene].Peptides)
}
return matchedPeptides, genes
}
func digestedSequence(peptides types.Peptides, db []types.Protein, enzyme string, missed int) (types.Peptides, types.Genes) {
matchedPeptides := make(types.Peptides, len(peptides))
// Allocate peptide map.
for peptide := range peptides {
matchedPeptides[peptide] = peptides[peptide].Copy()
matchedPeptides[peptide].Genes = make([]string, 0)
}
genes := make(types.Genes)
for _, entry := range db {
digested := digestion.Digest(entry.Sequence, enzyme, missed)
for peptide := range peptides {
if _, ok := digested[peptide]; ok {
matchedPeptides[peptide].Genes = append(matchedPeptides[peptide].Genes, entry.GeneID)
addPeptide(entry.GeneID, genes, peptide)
}
}
// Remove duplicate peptides.
if _, ok := genes[entry.GeneID]; ok {
genes[entry.GeneID].Peptides = helpers.SliceUnique(genes[entry.GeneID].Peptides)
}
}
// Remove peptides with no matches to a gene and remove duplicate gene matches.
for peptide := range peptides {
filterPeptides(matchedPeptides, peptide)
}
return matchedPeptides, genes
}
// Peptides finds proteins/genes that match to input peptides
func Peptides(peptides types.Peptides, db []types.Protein, enzyme string, missed int) (types.Peptides, types.Genes) {
if enzyme == "" {
return fullSequence(peptides, db)
}
return digestedSequence(peptides, db, enzyme, missed)
} | match/peptides.go | 0.593609 | 0.410461 | peptides.go | starcoder |
package sixtwo
import (
"fmt"
"github.com/pevans/erc/pkg/data"
)
type decodeMap map[uint8]uint8
type decoder struct {
ls *data.Segment
ps *data.Segment
decMap decodeMap
imageType int
loff int
poff int
}
// Decode returns a new segment that is the six-and-two decoded form
// (translating a physical to a logical data structure), based on a kind
// of input image and segment.
func Decode(imageType int, src *data.Segment) (*data.Segment, error) {
dec := &decoder{
ps: src,
ls: data.NewSegment(DosSize),
imageType: imageType,
decMap: newDecodeMap(),
}
for track := 0; track < NumTracks; track++ {
dec.writeTrack(track)
}
return dec.ls, nil
}
func (d *decoder) writeTrack(track int) {
logTrackOffset := LogTrackLen * track
physTrackOffset := PhysTrackLen * track
for sect := 0; sect < NumSectors; sect++ {
var (
logSect = logicalSector(d.imageType, sect)
physSect = encPhysOrder[sect]
)
// The logical offset is based on logTrackOffset, with the
// sector length times the logical sector we should be copying
d.loff = logTrackOffset + (LogSectorLen * logSect)
// However, the physical offset is based on the physical sector,
// which may need to be encoded in a different order
d.poff = physTrackOffset + (PhysSectorLen * physSect)
d.writeSector(track, sect)
}
}
func newDecodeMap() decodeMap {
m := make(decodeMap)
for i, b := range encGCR62 {
m[b] = uint8(i)
}
return m
}
func (d *decoder) logByte(b uint8) uint8 {
lb, ok := d.decMap[b]
if !ok {
panic(fmt.Errorf("strange byte in decoding: %x", b))
}
return lb
}
func (d *decoder) writeByte(b uint8) {
d.ls.Set(d.loff, b)
d.loff++
}
func (d *decoder) writeSector(track, sect int) {
var (
six = make([]uint8, SixBlock)
two = make([]uint8, TwoBlock)
)
// There's going to be some opening metadata bytes that we will want
// to skip.
d.poff += PhysSectorHeader
checksum := d.logByte(d.ps.Get(d.poff))
two[0] = checksum
for i := 1; i < TwoBlock; i++ {
lb := d.logByte(d.ps.Get(d.poff + i))
checksum ^= lb
two[i] = checksum
}
d.poff += TwoBlock
for i := 0; i < SixBlock; i++ {
lb := d.logByte(d.ps.Get(d.poff + i))
checksum ^= lb
six[i] = checksum
}
d.poff += SixBlock
checksum ^= d.logByte(d.ps.Get(d.poff))
if checksum != 0 {
panic(fmt.Errorf("track %d, sector %d: checksum does not match", track, sect))
}
for i := 0; i < SixBlock; i++ {
var (
div = i / TwoBlock
rem = i % TwoBlock
byt uint8
)
switch div {
case 0:
byt = ((two[rem] & 2) >> 1) | ((two[rem] & 1) << 1)
case 1:
byt = ((two[rem] & 8) >> 3) | ((two[rem] & 4) >> 1)
case 2:
byt = ((two[rem] & 0x20) >> 5) | ((two[rem] & 0x10) >> 3)
}
d.writeByte((six[i] << 2) | byt)
}
} | pkg/sixtwo/decode.go | 0.712532 | 0.422624 | decode.go | starcoder |
package markup
import (
"fmt"
"html"
"strings"
)
// HyphaExists holds function that checks that a hypha is present.
var HyphaExists func(string) bool
// HyphaAccess holds function that accesses a hypha by its name.
var HyphaAccess func(string) (rawText, binaryHtml string, err error)
// HyphaIterate is a function that iterates all hypha names existing.
var HyphaIterate func(func(string))
// GemLexerState is used by markup parser to remember what is going on.
type GemLexerState struct {
// Name of hypha being parsed
name string
where string // "", "list", "pre"
// Line id
id int
buf string
// Temporaries
img *Img
}
type Line struct {
id int
// interface{} may be bad. What I need is a sum of string and Transclusion
contents interface{}
}
func lex(name, content string) (ast []Line) {
var state = GemLexerState{name: name}
for _, line := range append(strings.Split(content, "\n"), "") {
geminiLineToAST(line, &state, &ast)
}
return ast
}
// Lex `line` in markup and save it to `ast` using `state`.
func geminiLineToAST(line string, state *GemLexerState, ast *[]Line) {
addLine := func(text interface{}) {
*ast = append(*ast, Line{id: state.id, contents: text})
}
// Process empty lines depending on the current state
if "" == strings.TrimSpace(line) {
switch state.where {
case "list":
state.where = ""
addLine(state.buf + "</ul>")
case "number":
state.where = ""
addLine(state.buf + "</ol>")
case "pre":
state.buf += "\n"
}
return
}
startsWith := func(token string) bool {
return strings.HasPrefix(line, token)
}
addHeading := func(i int) {
addLine(fmt.Sprintf("<h%d id='%d'>%s</h%d>", i, state.id, ParagraphToHtml(state.name, line[i+1:]), i))
}
// Beware! Usage of goto. Some may say it is considered evil but in this case it helped to make a better-structured code.
switch state.where {
case "img":
goto imgState
case "pre":
goto preformattedState
case "list":
goto listState
case "number":
goto numberState
default:
goto normalState
}
imgState:
if shouldGoBackToNormal := state.img.Process(line); shouldGoBackToNormal {
state.where = ""
addLine(*state.img)
}
return
preformattedState:
switch {
case startsWith("```"):
state.where = ""
state.buf = strings.TrimSuffix(state.buf, "\n")
addLine(state.buf + "</code></pre>")
state.buf = ""
default:
state.buf += html.EscapeString(line) + "\n"
}
return
listState:
switch {
case startsWith("* "):
state.buf += fmt.Sprintf("\t<li>%s</li>\n", ParagraphToHtml(state.name, line[2:]))
case startsWith("```"):
state.where = "pre"
addLine(state.buf + "</ul>")
state.id++
state.buf = fmt.Sprintf("<pre id='%d' alt='%s' class='codeblock'><code>", state.id, strings.TrimPrefix(line, "```"))
default:
state.where = ""
addLine(state.buf + "</ul>")
goto normalState
}
return
numberState:
switch {
case startsWith("*. "):
state.buf += fmt.Sprintf("\t<li>%s</li>\n", ParagraphToHtml(state.name, line[3:]))
case startsWith("```"):
state.where = "pre"
addLine(state.buf + "</ol>")
state.id++
state.buf = fmt.Sprintf("<pre id='%d' alt='%s' class='codeblock'><code>", state.id, strings.TrimPrefix(line, "```"))
default:
state.where = ""
addLine(state.buf + "</ol>")
goto normalState
}
return
normalState:
state.id++
switch {
case startsWith("```"):
state.where = "pre"
state.buf = fmt.Sprintf("<pre id='%d' alt='%s' class='codeblock'><code>", state.id, strings.TrimPrefix(line, "```"))
case startsWith("* "):
state.where = "list"
state.buf = fmt.Sprintf("<ul id='%d'>\n", state.id)
goto listState
case startsWith("*. "):
state.where = "number"
state.buf = fmt.Sprintf("<ol id='%d'>\n", state.id)
goto numberState
case startsWith("###### "):
addHeading(6)
case startsWith("##### "):
addHeading(5)
case startsWith("#### "):
addHeading(4)
case startsWith("### "):
addHeading(3)
case startsWith("## "):
addHeading(2)
case startsWith("# "):
addHeading(1)
case startsWith(">"):
addLine(fmt.Sprintf(
"<blockquote id='%d'>%s</blockquote>", state.id, remover(">")(line)))
case startsWith("=>"):
href, text, class := Rocketlink(line, state.name)
addLine(fmt.Sprintf(
`<p><a id='%d' class='rocketlink %s' href="%s">%s</a></p>`, state.id, class, href, text))
case startsWith("<="):
addLine(parseTransclusion(line, state.name))
case line == "----":
*ast = append(*ast, Line{id: -1, contents: "<hr/>"})
case MatchesImg(line):
img, shouldGoBackToNormal := ImgFromFirstLine(line, state.name)
if shouldGoBackToNormal {
addLine(*img)
} else {
state.where = "img"
state.img = img
}
default:
addLine(fmt.Sprintf("<p id='%d'>%s</p>", state.id, ParagraphToHtml(state.name, line)))
}
} | markup/lexer.go | 0.537527 | 0.432663 | lexer.go | starcoder |
package barycentric
import (
"strconv"
"strings"
"github.com/adamcolton/geom/calc/cmpr"
"github.com/adamcolton/geom/geomerr"
)
// B is a barycentric coordinate
type B struct {
U, V float64
}
// Edge will return true if B is within d of an edge.
func (b B) Edge(d float64) bool {
if b.U < -d || b.V < -d {
return false
}
if b.U < d || b.V < d {
return true
}
sum := 1 - b.U - b.V
return sum < d && sum > -d
}
// Inside returns true if B is inside it's triangle.
func (b B) Inside() bool {
return b.U >= 0 && b.V >= 0 && b.U+b.V <= 1
}
// String fulfills Stringer
func (b B) String() string {
return strings.Join([]string{
"B(",
strconv.FormatFloat(b.U, 'f', 2, 64),
", ",
strconv.FormatFloat(b.V, 'f', 2, 64),
")",
}, "")
}
// BIterator iterates over points inside a triangle. A single iterator can be
// used to map between multiple triangles.
type BIterator struct {
// Origin and U are the indexes to use, V is computed from these.
Origin, U int
Step [2]B
Cur B
// Reset is the point to reset to after one "line scan" completes
Reset B
Idx int
}
// TODO: BIterator needs a significant change. It should always scan the whole
// triangle. The math for this will get a little tricky. It needs to work out
// the orientation of the scan and start in the correct corner and when doing a
// Step[1], it may need to take multiple Step[0] to be inside the triangle.
// V returns the index of the V coordinate
func (bs *BIterator) V() int { return 3 - (bs.Origin ^ bs.U) }
// Next returns the next B and if it is done
func (bs *BIterator) Next() (b B, done bool) {
bs.Idx++
bs.Cur.U += bs.Step[0].U
bs.Cur.V += bs.Step[0].V
if bs.Cur.Inside() {
return bs.Cur, false
}
bs.Reset.U += bs.Step[1].U
bs.Reset.V += bs.Step[1].V
bs.Cur = bs.Reset
return bs.Cur, !bs.Cur.Inside()
}
// Start resets the iterator
func (bs *BIterator) Start() (b B, done bool) {
if bs == nil {
return B{}, true
}
bs.Cur = B{}
bs.Reset = B{}
bs.Idx = 0
return bs.Cur, false
}
// AssertEqual fulfils geomtest.AssertEqualizer
func (b B) AssertEqual(actual interface{}, t cmpr.Tolerance) error {
b2, ok := actual.(B)
if !ok {
return geomerr.TypeMismatch(b, actual)
}
if !t.Zero(b.U-b2.U) || !t.Zero(b.V-b2.V) {
return geomerr.NotEqual(b, b2)
}
return nil
} | barycentric/barycentric.go | 0.698021 | 0.476336 | barycentric.go | starcoder |
package hbase
import (
pb "github.com/golang/protobuf/proto"
"github.com/lazyshot/go-hbase/proto"
"bytes"
)
type Put struct {
key []byte
families [][]byte
qualifiers [][][]byte
values [][][]byte
timestamp [][]int64
}
func CreateNewPut(key []byte) *Put {
return &Put{
key: key,
families: make([][]byte, 0),
qualifiers: make([][][]byte, 0),
values: make([][][]byte, 0),
timestamp: make([][]int64, 0),
}
}
func (this *Put) AddValue(family, column, value []byte) {
this.AddValueTS(family, column, value, 0)
}
// AddValueTS use user specified timestamp
func (this *Put) AddValueTS(family, column, value []byte, ts int64) {
pos := this.posOfFamily(family)
if pos == -1 {
this.families = append(this.families, family)
this.qualifiers = append(this.qualifiers, make([][]byte, 0))
this.values = append(this.values, make([][]byte, 0))
this.timestamp = append(this.timestamp, make([]int64, 0))
pos = this.posOfFamily(family)
}
this.qualifiers[pos] = append(this.qualifiers[pos], column)
this.values[pos] = append(this.values[pos], value)
this.timestamp[pos] = append(this.timestamp[pos], ts)
}
func (this *Put) AddStringValue(family, column, value string) {
this.AddValueTS([]byte(family), []byte(column), []byte(value), 0)
}
// AddStringValueTS use user specified timestamp
func (this *Put) AddStringValueTS(family, column, value string, ts int64) {
this.AddValueTS([]byte(family), []byte(column), []byte(value), ts)
}
func (this *Put) posOfFamily(family []byte) int {
for p, v := range this.families {
if bytes.Equal(family, v) {
return p
}
}
return -1
}
func (this *Put) toProto() pb.Message {
p := &proto.MutationProto{
Row: this.key,
MutateType: proto.MutationProto_PUT.Enum(),
}
for i, family := range this.families {
cv := &proto.MutationProto_ColumnValue{
Family: family,
}
for j, _ := range this.qualifiers[i] {
qv := &proto.MutationProto_ColumnValue_QualifierValue{
Qualifier: this.qualifiers[i][j],
Value: this.values[i][j],
}
if this.timestamp[i][j] > 0 {
qv.Timestamp = pb.Uint64(uint64(this.timestamp[i][j]))
}
cv.QualifierValue = append(cv.QualifierValue, qv)
}
p.ColumnValue = append(p.ColumnValue, cv)
}
return p
} | put.go | 0.566738 | 0.451024 | put.go | starcoder |
package gglm
import (
"fmt"
"math"
)
var _ Swizzle3 = &Vec3{}
var _ fmt.Stringer = &Vec3{}
type Vec3 struct {
Data [3]float32
}
func (v *Vec3) X() float32 {
return v.Data[0]
}
func (v *Vec3) Y() float32 {
return v.Data[1]
}
func (v *Vec3) Z() float32 {
return v.Data[2]
}
func (v *Vec3) R() float32 {
return v.Data[0]
}
func (v *Vec3) G() float32 {
return v.Data[1]
}
func (v *Vec3) B() float32 {
return v.Data[2]
}
func (v *Vec3) SetX(f float32) {
v.Data[0] = f
}
func (v *Vec3) SetR(f float32) {
v.Data[0] = f
}
func (v *Vec3) SetY(f float32) {
v.Data[1] = f
}
func (v *Vec3) SetG(f float32) {
v.Data[1] = f
}
func (v *Vec3) SetZ(f float32) {
v.Data[2] = f
}
func (v *Vec3) SetB(f float32) {
v.Data[2] = f
}
func (v *Vec3) AddX(x float32) {
v.Data[0] += x
}
func (v *Vec3) AddY(y float32) {
v.Data[1] += y
}
func (v *Vec3) AddZ(z float32) {
v.Data[2] += z
}
func (v *Vec3) AddR(r float32) {
v.Data[0] += r
}
func (v *Vec3) AddG(g float32) {
v.Data[1] += g
}
func (v *Vec3) AddB(b float32) {
v.Data[2] += b
}
func (v *Vec3) SetXY(x, y float32) {
v.Data[0] = x
v.Data[1] = y
}
func (v *Vec3) AddXY(x, y float32) {
v.Data[0] += x
v.Data[1] += y
}
func (v *Vec3) SetRG(r, g float32) {
v.Data[0] = r
v.Data[1] = g
}
func (v *Vec3) AddRG(r, g float32) {
v.Data[0] += r
v.Data[1] += g
}
func (v *Vec3) SetXYZ(x, y, z float32) {
v.Data[0] = x
v.Data[1] = y
v.Data[2] = z
}
func (v *Vec3) AddXYZ(x, y, z float32) {
v.Data[0] += x
v.Data[1] += y
v.Data[2] += z
}
func (v *Vec3) SetRGB(r, g, b float32) {
v.Data[0] = r
v.Data[1] = g
v.Data[2] = b
}
func (v *Vec3) AddRGB(r, g, b float32) {
v.Data[0] += r
v.Data[1] += g
v.Data[2] += b
}
func (v *Vec3) String() string {
return fmt.Sprintf("(%f, %f, %f)", v.X(), v.Y(), v.Z())
}
//Scale v *= x (element wise multiplication)
func (v *Vec3) Scale(x float32) *Vec3 {
v.Data[0] *= x
v.Data[1] *= x
v.Data[2] *= x
return v
}
func (v *Vec3) Add(v2 *Vec3) *Vec3 {
v.Data[0] += v2.X()
v.Data[1] += v2.Y()
v.Data[2] += v2.Z()
return v
}
//SubVec3 v -= v2
func (v *Vec3) Sub(v2 *Vec3) *Vec3 {
v.Data[0] -= v2.X()
v.Data[1] -= v2.Y()
v.Data[2] -= v2.Z()
return v
}
//Mag returns the magnitude of the vector
func (v *Vec3) Mag() float32 {
return float32(math.Sqrt(float64(v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z())))
}
//Mag returns the squared magnitude of the vector
func (v *Vec3) SqrMag() float32 {
return v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z()
}
func (v *Vec3) Eq(v2 *Vec3) bool {
return v.Data == v2.Data
}
func (v *Vec3) Set(x, y, z float32) {
v.Data[0] = x
v.Data[1] = y
v.Data[2] = z
}
//Normalize normalizes this vector and returns it (doesn't copy)
func (v *Vec3) Normalize() *Vec3 {
mag := float32(math.Sqrt(float64(v.X()*v.X() + v.Y()*v.Y() + v.Z()*v.Z())))
v.Data[0] /= mag
v.Data[1] /= mag
v.Data[2] /= mag
return v
}
func (v *Vec3) Clone() *Vec3 {
return &Vec3{Data: v.Data}
}
//AsRad returns a new vector with all values converted to Radians (i.e. multiplied by gglm.Deg2Rad)
func (v *Vec3) AsRad() *Vec3 {
return &Vec3{
Data: [3]float32{
v.Data[0] * Deg2Rad,
v.Data[1] * Deg2Rad,
v.Data[2] * Deg2Rad,
},
}
}
//AddVec3 v3 = v1 + v2
func AddVec3(v1, v2 *Vec3) *Vec3 {
return &Vec3{
Data: [3]float32{
v1.X() + v2.X(),
v1.Y() + v2.Y(),
v1.Z() + v2.Z(),
},
}
}
//SubVec3 v3 = v1 - v2
func SubVec3(v1, v2 *Vec3) *Vec3 {
return &Vec3{
Data: [3]float32{
v1.X() - v2.X(),
v1.Y() - v2.Y(),
v1.Z() - v2.Z(),
},
}
}
func NewVec3(x, y, z float32) *Vec3 {
return &Vec3{
[3]float32{
x,
y,
z,
},
}
} | gglm/vec3.go | 0.767254 | 0.406332 | vec3.go | starcoder |
package ent
import (
"fmt"
"opencensus/core/ent/deathrecord"
"strings"
"time"
"entgo.io/ent/dialect/sql"
)
// DeathRecord is the model entity for the DeathRecord schema.
type DeathRecord struct {
config `json:"-"`
// ID of the ent.
ID int `json:"id,omitempty"`
// ReportedDate holds the value of the "reportedDate" field.
ReportedDate time.Time `json:"reportedDate,omitempty"`
// CollectedDate holds the value of the "collectedDate" field.
CollectedDate time.Time `json:"collectedDate,omitempty"`
// SinadefRegisters holds the value of the "sinadefRegisters" field.
SinadefRegisters int `json:"sinadefRegisters,omitempty"`
// MinsaRegisters holds the value of the "minsaRegisters" field.
MinsaRegisters int `json:"minsaRegisters,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the DeathRecordQuery when eager-loading is set.
Edges DeathRecordEdges `json:"edges"`
}
// DeathRecordEdges holds the relations/edges for other nodes in the graph.
type DeathRecordEdges struct {
// Places holds the value of the places edge.
Places []*Place `json:"places,omitempty"`
// loadedTypes holds the information for reporting if a
// type was loaded (or requested) in eager-loading or not.
loadedTypes [1]bool
}
// PlacesOrErr returns the Places value or an error if the edge
// was not loaded in eager-loading.
func (e DeathRecordEdges) PlacesOrErr() ([]*Place, error) {
if e.loadedTypes[0] {
return e.Places, nil
}
return nil, &NotLoadedError{edge: "places"}
}
// scanValues returns the types for scanning values from sql.Rows.
func (*DeathRecord) scanValues(columns []string) ([]interface{}, error) {
values := make([]interface{}, len(columns))
for i := range columns {
switch columns[i] {
case deathrecord.FieldID, deathrecord.FieldSinadefRegisters, deathrecord.FieldMinsaRegisters:
values[i] = &sql.NullInt64{}
case deathrecord.FieldReportedDate, deathrecord.FieldCollectedDate:
values[i] = &sql.NullTime{}
default:
return nil, fmt.Errorf("unexpected column %q for type DeathRecord", columns[i])
}
}
return values, nil
}
// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the DeathRecord fields.
func (dr *DeathRecord) assignValues(columns []string, values []interface{}) error {
if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
for i := range columns {
switch columns[i] {
case deathrecord.FieldID:
value, ok := values[i].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
dr.ID = int(value.Int64)
case deathrecord.FieldReportedDate:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field reportedDate", values[i])
} else if value.Valid {
dr.ReportedDate = value.Time
}
case deathrecord.FieldCollectedDate:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field collectedDate", values[i])
} else if value.Valid {
dr.CollectedDate = value.Time
}
case deathrecord.FieldSinadefRegisters:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field sinadefRegisters", values[i])
} else if value.Valid {
dr.SinadefRegisters = int(value.Int64)
}
case deathrecord.FieldMinsaRegisters:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field minsaRegisters", values[i])
} else if value.Valid {
dr.MinsaRegisters = int(value.Int64)
}
}
}
return nil
}
// QueryPlaces queries the "places" edge of the DeathRecord entity.
func (dr *DeathRecord) QueryPlaces() *PlaceQuery {
return (&DeathRecordClient{config: dr.config}).QueryPlaces(dr)
}
// Update returns a builder for updating this DeathRecord.
// Note that you need to call DeathRecord.Unwrap() before calling this method if this DeathRecord
// was returned from a transaction, and the transaction was committed or rolled back.
func (dr *DeathRecord) Update() *DeathRecordUpdateOne {
return (&DeathRecordClient{config: dr.config}).UpdateOne(dr)
}
// Unwrap unwraps the DeathRecord entity that was returned from a transaction after it was closed,
// so that all future queries will be executed through the driver which created the transaction.
func (dr *DeathRecord) Unwrap() *DeathRecord {
tx, ok := dr.config.driver.(*txDriver)
if !ok {
panic("ent: DeathRecord is not a transactional entity")
}
dr.config.driver = tx.drv
return dr
}
// String implements the fmt.Stringer.
func (dr *DeathRecord) String() string {
var builder strings.Builder
builder.WriteString("DeathRecord(")
builder.WriteString(fmt.Sprintf("id=%v", dr.ID))
builder.WriteString(", reportedDate=")
builder.WriteString(dr.ReportedDate.Format(time.ANSIC))
builder.WriteString(", collectedDate=")
builder.WriteString(dr.CollectedDate.Format(time.ANSIC))
builder.WriteString(", sinadefRegisters=")
builder.WriteString(fmt.Sprintf("%v", dr.SinadefRegisters))
builder.WriteString(", minsaRegisters=")
builder.WriteString(fmt.Sprintf("%v", dr.MinsaRegisters))
builder.WriteByte(')')
return builder.String()
}
// DeathRecords is a parsable slice of DeathRecord.
type DeathRecords []*DeathRecord
func (dr DeathRecords) config(cfg config) {
for _i := range dr {
dr[_i].config = cfg
}
} | ent/deathrecord.go | 0.69233 | 0.440289 | deathrecord.go | starcoder |
package math
import (
"math"
)
type Quaternion struct {
X, Y, Z, W float32
}
func NewQuaternion(x, y, z, w float32) *Quaternion {
return &Quaternion{x, y, z, w}
}
func (q *Quaternion) Set(x, y, z, w float32) *Quaternion {
q.X = x
q.Y = y
q.Z = z
q.W = w
return q
}
func (q *Quaternion) Cpy() *Quaternion {
return NewQuaternion(q.X, q.Y, q.Z, q.W)
}
func (q *Quaternion) Len() float32 {
return Sqrt(q.X*q.X + q.Y*q.Y + q.Z*q.Z + q.W*q.W)
}
// Returns the length of this quaternion without square root
func (q *Quaternion) Len2() float32 {
return q.X*q.X + q.Y*q.Y + q.Z*q.Z + q.W*q.W
}
// Sets the quaternion to the given euler angles.
// Values in radians
func (q *Quaternion) SetEulerAngles(yaw, pitch, roll float32) *Quaternion {
num9 := roll * 0.5
num6 := Sin(num9)
num5 := Cos(num9)
num8 := pitch * 0.5
num4 := Sin(num8)
num3 := Cos(num8)
num7 := yaw * 0.5
num2 := Sin(num7)
num := Cos(num7)
f1 := num * num4
f2 := num2 * num3
f3 := num * num3
f4 := num2 * num4
q.X = (f1 * num5) + (f2 * num6)
q.Y = (f2 * num5) - (f1 * num6)
q.Z = (f3 * num6) - (f4 * num5)
q.W = (f3 * num5) + (f4 * num6)
return q
}
func (q *Quaternion) Nor() *Quaternion {
l := q.Len2()
if l != 0 && Abs(l-1) > NORMALIZATION_TOLERANCE {
l = Sqrt(l)
q.X /= l
q.Y /= l
q.Z /= l
q.W /= l
}
return q
}
// Conjugate the quaternion.
func (q *Quaternion) Conjugate() *Quaternion {
q.X = -q.X
q.Y = -q.Y
q.Z = -q.Z
return q
}
// Multiplies this quaternion with another one
func (q *Quaternion) Mul(quaternion *Quaternion) *Quaternion {
newX := q.W*quaternion.X + q.X*quaternion.W + q.Y*quaternion.Z - q.Z*quaternion.Y
newY := q.W*quaternion.Y + q.Y*quaternion.W + q.Z*quaternion.X - q.X*quaternion.Z
newZ := q.W*quaternion.Z + q.Z*quaternion.W + q.X*quaternion.Y - q.Y*quaternion.X
newW := q.W*quaternion.W - q.X*quaternion.X - q.Y*quaternion.Y - q.Z*quaternion.Z
q.X = newX
q.Y = newY
q.Z = newZ
q.W = newW
return q
}
func (q *Quaternion) Idt() *Quaternion {
return q.Set(0, 0, 0, 1)
}
// Sets the quaternion components from the given axis and angle around that axis.
// Angle in radians
func (q *Quaternion) SetFromAxis(x, y, z, angle float32) *Quaternion {
lSin := Sin(angle / 2)
lCos := Cos(angle / 2)
return q.Set(q.X*lSin, q.Y*lSin, q.Z*lSin, lCos).Nor()
}
func (q *Quaternion) SetFromMatrix(m *Matrix4) *Quaternion {
return q.SetFromAxes(m.M11, m.M12, m.M13, m.M21, m.M22, m.M23, m.M31, m.M32, m.M33)
}
// Sets the Quaternion from the given x-, y- and z-axis which have to be orthonormal.
func (q *Quaternion) SetFromAxes(xx, xy, xz, yx, yy, yz, zx, zy, zz float32) *Quaternion {
m00 := float64(xx)
m01 := float64(xy)
m02 := float64(xz)
m10 := float64(yx)
m11 := float64(yy)
m12 := float64(yz)
m20 := float64(zx)
m21 := float64(zy)
m22 := float64(zz)
t := m00 + m11 + m22
var x, y, z, w float64
if t >= 0 {
s := math.Sqrt(t + 1)
w = 0.5 * s
s = 0.5 / s
x = (m21 - m12) * s
y = (m02 - m20) * s
z = (m10 - m01) * s
} else if m00 > m11 && m00 > m22 {
s := math.Sqrt(1.0 + m00 + m11 - m22)
x = s * 0.5
s = 0.5 / s
y = (m10 + m01) * s
z = (m02 + m20) * s
w = (m21 - m12) * s
} else if m11 > m22 {
s := math.Sqrt(1.0 + m22 - m00 - m11)
z = s * 0.5
s = 0.5 / s
x = (m02 + m20) * s
y = (m21 + m12) * s
w = (m10 - m01) * s
}
return q.Set(float32(x), float32(y), float32(z), float32(w))
}
// Set this quaternion to the rotation between two vectors.
func (q *Quaternion) SetFromCross(v1, v2 Vector3) *Quaternion {
dot := Clampf(v1.Dot(v2), -1.0, 1.0)
angle := ToDegrees(Acos(dot))
return q.SetFromAxis(v1.Y*v2.Z-v1.Z*v2.Y, v1.Z*v2.X-v1.X*v2.Z, v1.X*v2.Y-v1.Y*v2.X, angle)
}
// Spherical linear interpolation between this quaternion and the other quaternion, based on the alpha value in the range [0,1].
func (q *Quaternion) Slerp(end *Quaternion, alpha float32) *Quaternion {
if q.Equals(end) {
return q
}
result := q.Dot(end)
if result < 0 {
end.Scale(-1)
result = -result
}
scale0 := 1 - alpha
scale1 := alpha
if (1 - result) > 0.1 {
theta := Acos(result)
invSinTheta := 1 / Sin(theta)
scale0 = Sin((1-alpha)*theta) * invSinTheta
scale1 = Sin(alpha*theta) * invSinTheta
}
q.X = (scale0 * q.X) + (scale1 * end.X)
q.Y = (scale0 * q.Y) + (scale1 * end.Y)
q.Z = (scale0 * q.Z) + (scale1 * end.Z)
q.W = (scale0 * q.W) + (scale1 * end.W)
return q
}
func (q *Quaternion) Equals(other *Quaternion) bool {
if q == other {
return true
}
return q.X == other.X && q.Y == other.Y && q.Z == other.Z && q.W == other.W
}
// Dot product between this and the other quaternion.
func (q *Quaternion) Dot(other *Quaternion) float32 {
return q.X*other.X + q.Y*other.Y + q.Z*other.Z + q.W*other.W
}
// Multiplies the components of this quaternion with the given scalar.
func (q *Quaternion) Scale(scalar float32) *Quaternion {
q.X *= scalar
q.Y *= scalar
q.Z *= scalar
q.W *= scalar
return q
}
// Fills a 4x4 matrix with the rotation matrix represented by this quaternion.
func (q *Quaternion) Matrix() *Matrix4 {
xx := q.X * q.X
xy := q.X * q.Y
xz := q.X * q.Z
xw := q.X * q.W
yy := q.Y * q.W
yz := q.Y * q.Z
yw := q.Y * q.W
zz := q.Z * q.Z
zw := q.Z * q.W
// Set matrix from quaternion
matrix := NewIdentityMatrix4()
matrix.M11 = 1 - 2*(yy+zz)
matrix.M21 = 2 * (xy - zw)
matrix.M31 = 2 * (xz + yw)
matrix.M41 = 0
matrix.M12 = 2 * (xy + zw)
matrix.M22 = 1 - 2*(xx+zz)
matrix.M32 = 2 * (yz - xw)
matrix.M42 = 0
matrix.M13 = 2 * (xz - yw)
matrix.M23 = 2 * (yz + xw)
matrix.M33 = 1 - 2*(xx+yy)
matrix.M43 = 0
matrix.M14 = 0
matrix.M24 = 0
matrix.M34 = 0
matrix.M44 = 1
return matrix
} | quaternion.go | 0.897031 | 0.651244 | quaternion.go | starcoder |
package accountaggregator
// The formulas used by insurance companies are researched
// over long periods of time by a team of dedicated
// statisticians, I do not know the art of that trade, so
// here, I am mocking the output of the formulas.
// However, in the spirit of completeness, I will provide,
// the datapoints that AA can provide as an input to the
// formulas.
import "time"
func getAgeScore(dob time.Time) float32 {
// Younger people score higher in age score
// which factors in medical and term insurance.
// Datapoints:
// - deposit:profile.holders.holder.dob
return 0.81
}
func getMedicalPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Like it or not, your medical state largely depends on your
// lifestyle, profession and quality of life.
// Datapoints:
// - age score (calculated above)
// - deposit:transactions.transaction.narration+amount (filtered transactions with Hospital, Pharmacy etc)
// - insurance_policies:transactions.transaction.txnDate+amount+type (filtered Medical Claims)
// - deposit:transactions.transaction.type+narration+amount+transactionTimestamp (calculate income and spending)
// - deposit:transactions.transaction.type+narration+amount (check for spending patterns) -- excessive
// /hedonistic would rank lower and family spending patterns higher
// - deposit:profile.holders.holder.address (place of living reflects quality of life, proxymity to
// emergency services, financial security)
// - Health records from other sources to fetch known conditions (eg. medical records)
return 0.85 + float32(sharedDataSources)/50
}
func getWealthPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Knowning about your financial status in the society can indicate a lot about
// many aspects of your life, including the length of it.
// Datapoints:
// - deposit:summary.currentBalance
// - deposit:transactions.transaction.type+narration+amount (check for spending patterns) -- excessive
// /hedonistic would rank lower and family spending patterns higher
// - credit_card:summary.currentDue (Debt can be a good indictor of financial security and maturity)
// - term-deposit|reoccuring-deposits|ppf|nfs:summary.currentValue (Investments indicate
// financial / future security & planning). A good planner is
// likely to be more mature in other aspects of life as well.
// - sip|mutual_funds:summary.currentValue (Investments indicate financial / future security)
return 0.73 + float32(sharedDataSources)/50
}
func getDebtPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Knowning about your financial status in the society can indicate a lot about
// many aspects of your life, including the length of it.
// Datapoints:
// - deposit:summary.currentBalance
// - deposit:transactions.transaction.type+narration+amount+transactionTimestamp (spending patterns
// can indicate the future possibility of debt)
// - credit_card:summary.currentDue (Debt can be a good indictor of financial security and maturity)
return 0.69 + float32(sharedDataSources)/50
}
func getInvestmentScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Knowning about your investments gives insights about the person's future planning and maturity.
// Datapoints:
// - term-deposit|reoccuring-deposits|ppf|nfs:summary.currentValue (Investments indicate
// financial / future security & planning). A good planner is
// likely to be more mature in other aspects of life as well.
// - sip|mutual_funds:summary.currentValue (Investments indicate financial / future security)
return 0.76 + float32(sharedDataSources)/50
}
func getPensionPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// For suggesting the pension we need to know the financial-social situation of the individual.
// Datapoints:
// - age score (calculated above)
// - wealth score (calculated above)
// - debt score (calculated above)
// - term-deposit|reoccuring-deposits|ppf|nfs:summary.currentValue (Investments indicate
// financial / future security & planning). A good planner is
// likely to be more mature in other aspects of life as well.
// - sip|mutual_funds:summary.currentValue (Investments indicate financial / future security)
return 0.71 + float32(sharedDataSources)/50
}
func getFamilyPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Family plan would be very similar to the medical insurance plan calculated above.
// Datapoints:
// - age score (calculated above)
// - wealth score (calculated above)
// - medical plan score (calculated above)
// - debt score (calculated above)
return 0.70 + float32(sharedDataSources)/50
}
func getChildrenPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Children's plan would be very similar to the medical & family insurance plan calculated above.
// Datapoints:
// - age score (calculated above)
// - wealth score (calculated above)
// - medical plan score (calculated above)
// - debt score (calculated above)
// - family score (calculated above)
return 0.81 + float32(sharedDataSources)/50
}
func getMotorPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Children's plan would be very similar to the medical & family insurance plan calculated above.
// Datapoints:
// - wealth score (calculated above) -- will indicate the reasonable amount spend on the vehicle.
// - insurance_policies:transactions.transaction.txnDate+amount+type (filtered for motor claims)
// - deposit:profile.holders.holder.address (can help indicate if the person lives in a place where
// there have been many vehicle theft cases)
return 0
}
func getTermPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Term insurance rates boil down to life expentency, which is affected by your quality of life
// and financial status
// Datapoints:
// - age score (calculated above)
// - wealth score (calculated above)
// - debt score (calculated above)
// - deposit:transactions.transaction.type+narration+amount+transactionTimestamp (calculate income and spending)
// - deposit:transactions.transaction.type+narration+amount (check for spending patterns) -- excessive
// /hedonistic would rank lower and family spending patterns higher
// - deposit:profile.holders.holder.address (place of living, reflects quality of life, proxymity to
// emergency services, financial security)
return 0.6 + float32(sharedDataSources)/50
}
func getTravelPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// Travel plan depends highly on the previous travel experience, frequency of travel,
// country of travel.
// Datapoints:
// - wealth score (calculated above) -- indicates the type of safety / luxury in the trip.
// - deposit:transactions.transaction.type+narration+amount+transactionTimestamp -- indicate country
// or places travelling to in the near future,
// frequency of travel.
return 0.3
}
func getAllPlanScore(allFipData []fipDataCollection, sharedDataSources int16) float32 {
// A plan to cover all plans depends on the factors discussed above.
// Datapoints:
// - Age Score (calculated above)
// - Medical Score (calculated above)
// - Wealth Score (calculated above)
// - Debt Score (calculated above)
// - Investment Score (calculated above)
// - Pension Score (calculated above)
// - Family Score (calculated above)
// - Children Score (calculated above)
// - Motor Score (calculated above)
// - Term Score (calculated above)
// - Travel Score (calculated above)
return 0.79 + float32(sharedDataSources)/50
} | src/server/controllers/accountaggregator/score_calculator.go | 0.659624 | 0.466603 | score_calculator.go | starcoder |
package commandline
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"github.com/ni/systemlink-cli/internal/model"
)
// ValueConverter provides functions to convert between input data
// of the command line and the data types in the model
type ValueConverter struct{}
func (c ValueConverter) convertToIntegerArray(value string) ([]int, error) {
var result []int
for _, v := range strings.Split(value, ",") {
i, err := strconv.Atoi(v)
if err != nil {
return nil, err
}
result = append(result, i)
}
return result, nil
}
func (c ValueConverter) convertToNumberArray(value string) ([]float64, error) {
var result []float64
for _, v := range strings.Split(value, ",") {
f, err := strconv.ParseFloat(v, 64)
if err != nil {
return nil, err
}
result = append(result, f)
}
return result, nil
}
func (c ValueConverter) convertToBooleanArray(value string) ([]bool, error) {
var result []bool
for _, v := range strings.Split(value, ",") {
b, err := c.convertToBoolean(v)
if err != nil {
return nil, err
}
result = append(result, b)
}
return result, nil
}
func (c ValueConverter) convertToBoolean(value string) (bool, error) {
if strings.EqualFold(value, "true") {
return true, nil
} else if strings.EqualFold(value, "false") {
return false, nil
}
return false, fmt.Errorf("Cannot convert %s to boolean", value)
}
func (c ValueConverter) convertToType(value string, typeInfo model.ParameterType) (interface{}, error) {
switch typeInfo {
case model.BooleanType:
return c.convertToBoolean(value)
case model.IntegerType:
return strconv.Atoi(value)
case model.NumberType:
return strconv.ParseFloat(value, 64)
case model.StringArrayType:
return strings.Split(value, ","), nil
case model.IntegerArrayType:
return c.convertToIntegerArray(value)
case model.NumberArrayType:
return c.convertToNumberArray(value)
case model.BooleanArrayType:
return c.convertToBooleanArray(value)
case model.ObjectType, model.ObjectArrayType:
var j interface{}
err := json.Unmarshal([]byte(value), &j)
return j, err
}
return value, nil
}
func (c ValueConverter) findParameters(name string, parameters []model.Parameter) ([]model.Parameter, error) {
var result []model.Parameter
for _, p := range parameters {
if p.Name == name {
result = append(result, p)
}
}
if len(result) == 0 {
return nil, fmt.Errorf("Parameter '%s' not defined in model", name)
}
return result, nil
}
func (c ValueConverter) convertValue(value string, parameters []model.Parameter) ([]model.ParameterValue, error) {
var result []model.ParameterValue
for _, param := range parameters {
convertedValue, convertErr := c.convertToType(value, param.TypeInfo)
if convertErr != nil {
return nil, fmt.Errorf("Invalid value for argument '%s'", param.Name)
}
parameterValue := model.ParameterValue{Parameter: param, Value: convertedValue}
result = append(result, parameterValue)
}
return result, nil
}
// ConvertValues converts the given input parameter strings into to defined types
// of the model parameters
func (c ValueConverter) ConvertValues(values map[string]string, parameters []model.Parameter) ([]model.ParameterValue, error) {
var result []model.ParameterValue
for key, value := range values {
params, err := c.findParameters(key, parameters)
if err != nil {
return nil, err
}
convertedValues, err := c.convertValue(value, params)
if err != nil {
return nil, err
}
result = append(result, convertedValues...)
}
return result, nil
} | internal/commandline/value_converter.go | 0.6488 | 0.420421 | value_converter.go | starcoder |
package cudnn
// #include <cudnn.h>
import "C"
import (
"runtime"
"github.com/pkg/errors"
)
type TensorDescriptor struct {
internal C.cudnnTensorDescriptor_t // ptr to struct
// internal data for fast
format TensorFormat
dataType DataType
shape []int // NCHW format for 4-tensors
strides []int
}
func NewTensorDescriptor(format TensorFormat, dt DataType, shape, strides []int) (*TensorDescriptor, error) {
var internal C.cudnnTensorDescriptor_t
if err := result(C.cudnnCreateTensorDescriptor(&internal)); err != nil {
return nil, err
}
retVal := &TensorDescriptor{
internal: internal,
format: format,
dataType: dt,
shape: shape,
strides: strides,
}
runtime.SetFinalizer(retVal, destroyTensor)
if err := retVal.set(internal); err != nil {
return nil, err
}
return retVal, nil
}
func (t *TensorDescriptor) set(internal C.cudnnTensorDescriptor_t) error {
switch len(t.shape) {
case 4:
N, C, H, W := t.shape[0], t.shape[1], t.shape[2], t.shape[3]
if len(t.strides) == 4 {
// use explicit
NStrides, CStrides, HStrides, WStrides := t.strides[0], t.strides[1], t.strides[2], t.strides[3]
res := C.cudnnSetTensor4dDescriptorEx(internal, t.dataType.C(),
C.int(N), C.int(C), C.int(H), C.int(W),
C.int(NStrides), C.int(CStrides), C.int(HStrides), C.int(WStrides),
)
return result(res)
}
// otherwise the strides will be calculated by cudnn
res := C.cudnnSetTensor4dDescriptor(internal, t.format.C(), t.dataType.C(),
C.int(N), C.int(C), C.int(H), C.int(W),
)
return result(res)
default:
if len(t.strides) > 0 {
dimA, dimAManaged := ints2CIntPtr(t.shape)
defer returnManaged(dimAManaged)
strideA, strideAManaged := ints2CIntPtr(t.strides)
defer returnManaged(strideAManaged)
// NO, there is no confusion here. Ex is used to set tensor without strides. Silly nVidia.
res := C.cudnnSetTensorNdDescriptor(internal, t.dataType.C(),
C.int(len(t.shape)), dimA, strideA)
return result(res)
}
dimA, dimAManaged := ints2CIntPtr(t.shape)
defer returnManaged(dimAManaged)
res := C.cudnnSetTensorNdDescriptorEx(internal, t.format.C(), t.dataType.C(),
C.int(len(t.shape)), dimA)
return result(res)
}
return errors.Errorf(nyi, "set for len == ", len(t.shape))
}
func (t *TensorDescriptor) Format() TensorFormat { return t.format }
func (t *TensorDescriptor) DataType() DataType { return t.dataType }
func (t *TensorDescriptor) Shape() []int { return cloneShape(t.shape) }
func (t *TensorDescriptor) Strides() []int { return cloneShape(t.strides) }
func destroyTensor(obj *TensorDescriptor) { C.cudnnDestroyTensorDescriptor(obj.internal) } | vendor/gorgonia.org/cu/dnn/tensor.go | 0.632503 | 0.421492 | tensor.go | starcoder |
package column
import (
"fmt"
"github.com/kelindar/bitmap"
"github.com/kelindar/column/commit"
)
// --------------------------- Float32s ----------------------------
// float32Column represents a generic column
type float32Column struct {
fill bitmap.Bitmap // The fill-list
data []float32 // The actual values
}
// makeFloat32s creates a new vector for Float32s
func makeFloat32s() Column {
return &float32Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]float32, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *float32Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]float32, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *float32Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Float32()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Float32()
c.data[r.Offset] = value
r.SwapFloat32(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *float32Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *float32Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *float32Column) Value(idx uint32) (v interface{}, ok bool) {
v = float32(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a float32 value at a specified index
func (c *float32Column) load(idx uint32) (v float32, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float32(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *float32Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *float32Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *float32Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *float32Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *float32Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *float32Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *float32Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutFloat32(idx, c.data[idx])
})
}
// float32Reader represens a read-only accessor for float32
type float32Reader struct {
cursor *uint32
reader *float32Column
}
// Get loads the value at the current transaction cursor
func (s float32Reader) Get() (float32, bool) {
return s.reader.load(*s.cursor)
}
// float32ReaderFor creates a new float32 reader
func float32ReaderFor(txn *Txn, columnName string) float32Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*float32Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, float32(0)))
}
return float32Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// float32Writer represents a read-write accessor for float32
type float32Writer struct {
float32Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s float32Writer) Set(value float32) {
s.writer.PutFloat32(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s float32Writer) Add(delta float32) {
s.writer.AddFloat32(*s.cursor, delta)
}
// Float32 returns a read-write accessor for float32 column
func (txn *Txn) Float32(columnName string) float32Writer {
return float32Writer{
float32Reader: float32ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Float64s ----------------------------
// float64Column represents a generic column
type float64Column struct {
fill bitmap.Bitmap // The fill-list
data []float64 // The actual values
}
// makeFloat64s creates a new vector for Float64s
func makeFloat64s() Column {
return &float64Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]float64, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *float64Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]float64, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *float64Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Float64()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Float64()
c.data[r.Offset] = value
r.SwapFloat64(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *float64Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *float64Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *float64Column) Value(idx uint32) (v interface{}, ok bool) {
v = float64(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a float64 value at a specified index
func (c *float64Column) load(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *float64Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *float64Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *float64Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *float64Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *float64Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *float64Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *float64Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutFloat64(idx, c.data[idx])
})
}
// float64Reader represens a read-only accessor for float64
type float64Reader struct {
cursor *uint32
reader *float64Column
}
// Get loads the value at the current transaction cursor
func (s float64Reader) Get() (float64, bool) {
return s.reader.load(*s.cursor)
}
// float64ReaderFor creates a new float64 reader
func float64ReaderFor(txn *Txn, columnName string) float64Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*float64Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, float64(0)))
}
return float64Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// float64Writer represents a read-write accessor for float64
type float64Writer struct {
float64Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s float64Writer) Set(value float64) {
s.writer.PutFloat64(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s float64Writer) Add(delta float64) {
s.writer.AddFloat64(*s.cursor, delta)
}
// Float64 returns a read-write accessor for float64 column
func (txn *Txn) Float64(columnName string) float64Writer {
return float64Writer{
float64Reader: float64ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Ints ----------------------------
// intColumn represents a generic column
type intColumn struct {
fill bitmap.Bitmap // The fill-list
data []int // The actual values
}
// makeInts creates a new vector for Ints
func makeInts() Column {
return &intColumn{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]int, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *intColumn) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]int, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *intColumn) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Int()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Int()
c.data[r.Offset] = value
r.SwapInt(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *intColumn) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *intColumn) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *intColumn) Value(idx uint32) (v interface{}, ok bool) {
v = int(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a int value at a specified index
func (c *intColumn) load(idx uint32) (v int, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *intColumn) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *intColumn) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *intColumn) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *intColumn) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *intColumn) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *intColumn) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *intColumn) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutInt(idx, c.data[idx])
})
}
// intReader represens a read-only accessor for int
type intReader struct {
cursor *uint32
reader *intColumn
}
// Get loads the value at the current transaction cursor
func (s intReader) Get() (int, bool) {
return s.reader.load(*s.cursor)
}
// intReaderFor creates a new int reader
func intReaderFor(txn *Txn, columnName string) intReader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*intColumn)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, int(0)))
}
return intReader{
cursor: &txn.cursor,
reader: reader,
}
}
// intWriter represents a read-write accessor for int
type intWriter struct {
intReader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s intWriter) Set(value int) {
s.writer.PutInt(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s intWriter) Add(delta int) {
s.writer.AddInt(*s.cursor, delta)
}
// Int returns a read-write accessor for int column
func (txn *Txn) Int(columnName string) intWriter {
return intWriter{
intReader: intReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Int16s ----------------------------
// int16Column represents a generic column
type int16Column struct {
fill bitmap.Bitmap // The fill-list
data []int16 // The actual values
}
// makeInt16s creates a new vector for Int16s
func makeInt16s() Column {
return &int16Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]int16, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *int16Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]int16, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *int16Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Int16()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Int16()
c.data[r.Offset] = value
r.SwapInt16(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *int16Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *int16Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *int16Column) Value(idx uint32) (v interface{}, ok bool) {
v = int16(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a int16 value at a specified index
func (c *int16Column) load(idx uint32) (v int16, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int16(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *int16Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *int16Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *int16Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *int16Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *int16Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *int16Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *int16Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutInt16(idx, c.data[idx])
})
}
// int16Reader represens a read-only accessor for int16
type int16Reader struct {
cursor *uint32
reader *int16Column
}
// Get loads the value at the current transaction cursor
func (s int16Reader) Get() (int16, bool) {
return s.reader.load(*s.cursor)
}
// int16ReaderFor creates a new int16 reader
func int16ReaderFor(txn *Txn, columnName string) int16Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*int16Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, int16(0)))
}
return int16Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// int16Writer represents a read-write accessor for int16
type int16Writer struct {
int16Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s int16Writer) Set(value int16) {
s.writer.PutInt16(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s int16Writer) Add(delta int16) {
s.writer.AddInt16(*s.cursor, delta)
}
// Int16 returns a read-write accessor for int16 column
func (txn *Txn) Int16(columnName string) int16Writer {
return int16Writer{
int16Reader: int16ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Int32s ----------------------------
// int32Column represents a generic column
type int32Column struct {
fill bitmap.Bitmap // The fill-list
data []int32 // The actual values
}
// makeInt32s creates a new vector for Int32s
func makeInt32s() Column {
return &int32Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]int32, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *int32Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]int32, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *int32Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Int32()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Int32()
c.data[r.Offset] = value
r.SwapInt32(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *int32Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *int32Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *int32Column) Value(idx uint32) (v interface{}, ok bool) {
v = int32(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a int32 value at a specified index
func (c *int32Column) load(idx uint32) (v int32, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int32(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *int32Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *int32Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *int32Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *int32Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *int32Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *int32Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *int32Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutInt32(idx, c.data[idx])
})
}
// int32Reader represens a read-only accessor for int32
type int32Reader struct {
cursor *uint32
reader *int32Column
}
// Get loads the value at the current transaction cursor
func (s int32Reader) Get() (int32, bool) {
return s.reader.load(*s.cursor)
}
// int32ReaderFor creates a new int32 reader
func int32ReaderFor(txn *Txn, columnName string) int32Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*int32Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, int32(0)))
}
return int32Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// int32Writer represents a read-write accessor for int32
type int32Writer struct {
int32Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s int32Writer) Set(value int32) {
s.writer.PutInt32(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s int32Writer) Add(delta int32) {
s.writer.AddInt32(*s.cursor, delta)
}
// Int32 returns a read-write accessor for int32 column
func (txn *Txn) Int32(columnName string) int32Writer {
return int32Writer{
int32Reader: int32ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Int64s ----------------------------
// int64Column represents a generic column
type int64Column struct {
fill bitmap.Bitmap // The fill-list
data []int64 // The actual values
}
// makeInt64s creates a new vector for Int64s
func makeInt64s() Column {
return &int64Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]int64, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *int64Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]int64, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *int64Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Int64()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Int64()
c.data[r.Offset] = value
r.SwapInt64(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *int64Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *int64Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *int64Column) Value(idx uint32) (v interface{}, ok bool) {
v = int64(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a int64 value at a specified index
func (c *int64Column) load(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *int64Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *int64Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *int64Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *int64Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *int64Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *int64Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *int64Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutInt64(idx, c.data[idx])
})
}
// int64Reader represens a read-only accessor for int64
type int64Reader struct {
cursor *uint32
reader *int64Column
}
// Get loads the value at the current transaction cursor
func (s int64Reader) Get() (int64, bool) {
return s.reader.load(*s.cursor)
}
// int64ReaderFor creates a new int64 reader
func int64ReaderFor(txn *Txn, columnName string) int64Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*int64Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, int64(0)))
}
return int64Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// int64Writer represents a read-write accessor for int64
type int64Writer struct {
int64Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s int64Writer) Set(value int64) {
s.writer.PutInt64(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s int64Writer) Add(delta int64) {
s.writer.AddInt64(*s.cursor, delta)
}
// Int64 returns a read-write accessor for int64 column
func (txn *Txn) Int64(columnName string) int64Writer {
return int64Writer{
int64Reader: int64ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Uints ----------------------------
// uintColumn represents a generic column
type uintColumn struct {
fill bitmap.Bitmap // The fill-list
data []uint // The actual values
}
// makeUints creates a new vector for Uints
func makeUints() Column {
return &uintColumn{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]uint, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *uintColumn) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]uint, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *uintColumn) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Uint()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Uint()
c.data[r.Offset] = value
r.SwapUint(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *uintColumn) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *uintColumn) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *uintColumn) Value(idx uint32) (v interface{}, ok bool) {
v = uint(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a uint value at a specified index
func (c *uintColumn) load(idx uint32) (v uint, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *uintColumn) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *uintColumn) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *uintColumn) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *uintColumn) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *uintColumn) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *uintColumn) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *uintColumn) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutUint(idx, c.data[idx])
})
}
// uintReader represens a read-only accessor for uint
type uintReader struct {
cursor *uint32
reader *uintColumn
}
// Get loads the value at the current transaction cursor
func (s uintReader) Get() (uint, bool) {
return s.reader.load(*s.cursor)
}
// uintReaderFor creates a new uint reader
func uintReaderFor(txn *Txn, columnName string) uintReader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*uintColumn)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, uint(0)))
}
return uintReader{
cursor: &txn.cursor,
reader: reader,
}
}
// uintWriter represents a read-write accessor for uint
type uintWriter struct {
uintReader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s uintWriter) Set(value uint) {
s.writer.PutUint(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s uintWriter) Add(delta uint) {
s.writer.AddUint(*s.cursor, delta)
}
// Uint returns a read-write accessor for uint column
func (txn *Txn) Uint(columnName string) uintWriter {
return uintWriter{
uintReader: uintReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Uint16s ----------------------------
// uint16Column represents a generic column
type uint16Column struct {
fill bitmap.Bitmap // The fill-list
data []uint16 // The actual values
}
// makeUint16s creates a new vector for Uint16s
func makeUint16s() Column {
return &uint16Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]uint16, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *uint16Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]uint16, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *uint16Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Uint16()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Uint16()
c.data[r.Offset] = value
r.SwapUint16(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *uint16Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *uint16Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *uint16Column) Value(idx uint32) (v interface{}, ok bool) {
v = uint16(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a uint16 value at a specified index
func (c *uint16Column) load(idx uint32) (v uint16, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint16(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *uint16Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *uint16Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *uint16Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *uint16Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *uint16Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *uint16Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *uint16Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutUint16(idx, c.data[idx])
})
}
// uint16Reader represens a read-only accessor for uint16
type uint16Reader struct {
cursor *uint32
reader *uint16Column
}
// Get loads the value at the current transaction cursor
func (s uint16Reader) Get() (uint16, bool) {
return s.reader.load(*s.cursor)
}
// uint16ReaderFor creates a new uint16 reader
func uint16ReaderFor(txn *Txn, columnName string) uint16Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*uint16Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, uint16(0)))
}
return uint16Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// uint16Writer represents a read-write accessor for uint16
type uint16Writer struct {
uint16Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s uint16Writer) Set(value uint16) {
s.writer.PutUint16(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s uint16Writer) Add(delta uint16) {
s.writer.AddUint16(*s.cursor, delta)
}
// Uint16 returns a read-write accessor for uint16 column
func (txn *Txn) Uint16(columnName string) uint16Writer {
return uint16Writer{
uint16Reader: uint16ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Uint32s ----------------------------
// uint32Column represents a generic column
type uint32Column struct {
fill bitmap.Bitmap // The fill-list
data []uint32 // The actual values
}
// makeUint32s creates a new vector for Uint32s
func makeUint32s() Column {
return &uint32Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]uint32, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *uint32Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]uint32, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *uint32Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Uint32()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Uint32()
c.data[r.Offset] = value
r.SwapUint32(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *uint32Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *uint32Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *uint32Column) Value(idx uint32) (v interface{}, ok bool) {
v = uint32(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a uint32 value at a specified index
func (c *uint32Column) load(idx uint32) (v uint32, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint32(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *uint32Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *uint32Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *uint32Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *uint32Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *uint32Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *uint32Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *uint32Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutUint32(idx, c.data[idx])
})
}
// uint32Reader represens a read-only accessor for uint32
type uint32Reader struct {
cursor *uint32
reader *uint32Column
}
// Get loads the value at the current transaction cursor
func (s uint32Reader) Get() (uint32, bool) {
return s.reader.load(*s.cursor)
}
// uint32ReaderFor creates a new uint32 reader
func uint32ReaderFor(txn *Txn, columnName string) uint32Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*uint32Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, uint32(0)))
}
return uint32Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// uint32Writer represents a read-write accessor for uint32
type uint32Writer struct {
uint32Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s uint32Writer) Set(value uint32) {
s.writer.PutUint32(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s uint32Writer) Add(delta uint32) {
s.writer.AddUint32(*s.cursor, delta)
}
// Uint32 returns a read-write accessor for uint32 column
func (txn *Txn) Uint32(columnName string) uint32Writer {
return uint32Writer{
uint32Reader: uint32ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
}
// --------------------------- Uint64s ----------------------------
// uint64Column represents a generic column
type uint64Column struct {
fill bitmap.Bitmap // The fill-list
data []uint64 // The actual values
}
// makeUint64s creates a new vector for Uint64s
func makeUint64s() Column {
return &uint64Column{
fill: make(bitmap.Bitmap, 0, 4),
data: make([]uint64, 0, 64),
}
}
// Grow grows the size of the column until we have enough to store
func (c *uint64Column) Grow(idx uint32) {
if idx < uint32(len(c.data)) {
return
}
if idx < uint32(cap(c.data)) {
c.fill.Grow(idx)
c.data = c.data[:idx+1]
return
}
c.fill.Grow(idx)
clone := make([]uint64, idx+1, resize(cap(c.data), idx+1))
copy(clone, c.data)
c.data = clone
}
// Apply applies a set of operations to the column.
func (c *uint64Column) Apply(r *commit.Reader) {
for r.Next() {
switch r.Type {
case commit.Put:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
c.data[r.Offset] = r.Uint64()
// If this is an atomic increment/decrement, we need to change the operation to
// the final value, since after this update an index needs to be recalculated.
case commit.Add:
c.fill[r.Offset>>6] |= 1 << (r.Offset & 0x3f)
value := c.data[r.Offset] + r.Uint64()
c.data[r.Offset] = value
r.SwapUint64(value)
case commit.Delete:
c.fill.Remove(r.Index())
}
}
}
// Contains checks whether the column has a value at a specified index.
func (c *uint64Column) Contains(idx uint32) bool {
return c.fill.Contains(idx)
}
// Index returns the fill list for the column
func (c *uint64Column) Index() *bitmap.Bitmap {
return &c.fill
}
// Value retrieves a value at a specified index
func (c *uint64Column) Value(idx uint32) (v interface{}, ok bool) {
v = uint64(0)
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = c.data[idx], true
}
return
}
// load retrieves a uint64 value at a specified index
func (c *uint64Column) load(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// LoadFloat64 retrieves a float64 value at a specified index
func (c *uint64Column) LoadFloat64(idx uint32) (v float64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = float64(c.data[idx]), true
}
return
}
// LoadInt64 retrieves an int64 value at a specified index
func (c *uint64Column) LoadInt64(idx uint32) (v int64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = int64(c.data[idx]), true
}
return
}
// LoadUint64 retrieves an uint64 value at a specified index
func (c *uint64Column) LoadUint64(idx uint32) (v uint64, ok bool) {
if idx < uint32(len(c.data)) && c.fill.Contains(idx) {
v, ok = uint64(c.data[idx]), true
}
return
}
// FilterFloat64 filters down the values based on the specified predicate.
func (c *uint64Column) FilterFloat64(offset uint32, index bitmap.Bitmap, predicate func(v float64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) bool {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(float64(c.data[idx]))
})
}
// FilterInt64 filters down the values based on the specified predicate.
func (c *uint64Column) FilterInt64(offset uint32, index bitmap.Bitmap, predicate func(v int64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(int64(c.data[idx]))
})
}
// FilterUint64 filters down the values based on the specified predicate.
func (c *uint64Column) FilterUint64(offset uint32, index bitmap.Bitmap, predicate func(v uint64) bool) {
index.And(c.fill[offset>>6 : int(offset>>6)+len(index)])
index.Filter(func(idx uint32) (match bool) {
idx = offset + idx
return idx < uint32(len(c.data)) && predicate(uint64(c.data[idx]))
})
}
// Snapshot writes the entire column into the specified destination buffer
func (c *uint64Column) Snapshot(chunk commit.Chunk, dst *commit.Buffer) {
chunk.Range(c.fill, func(idx uint32) {
dst.PutUint64(idx, c.data[idx])
})
}
// uint64Reader represens a read-only accessor for uint64
type uint64Reader struct {
cursor *uint32
reader *uint64Column
}
// Get loads the value at the current transaction cursor
func (s uint64Reader) Get() (uint64, bool) {
return s.reader.load(*s.cursor)
}
// uint64ReaderFor creates a new uint64 reader
func uint64ReaderFor(txn *Txn, columnName string) uint64Reader {
column, ok := txn.columnAt(columnName)
if !ok {
panic(fmt.Errorf("column: column '%s' does not exist", columnName))
}
reader, ok := column.Column.(*uint64Column)
if !ok {
panic(fmt.Errorf("column: column '%s' is not of type %T", columnName, uint64(0)))
}
return uint64Reader{
cursor: &txn.cursor,
reader: reader,
}
}
// uint64Writer represents a read-write accessor for uint64
type uint64Writer struct {
uint64Reader
writer *commit.Buffer
}
// Set sets the value at the current transaction cursor
func (s uint64Writer) Set(value uint64) {
s.writer.PutUint64(*s.cursor, value)
}
// Add atomically adds a delta to the value at the current transaction cursor
func (s uint64Writer) Add(delta uint64) {
s.writer.AddUint64(*s.cursor, delta)
}
// Uint64 returns a read-write accessor for uint64 column
func (txn *Txn) Uint64(columnName string) uint64Writer {
return uint64Writer{
uint64Reader: uint64ReaderFor(txn, columnName),
writer: txn.bufferFor(columnName),
}
} | column_numbers.go | 0.785185 | 0.497131 | column_numbers.go | starcoder |
package three
import "math"
// NewSphere :
func NewSphere(center Vector3, radius float64) *Sphere {
return &Sphere{center, radius}
}
// Sphere :
type Sphere struct {
Center Vector3
Radius float64
}
// Set :
func (s Sphere) Set(center Vector3, radius float64) *Sphere {
s.Center.Copy(center)
s.Radius = radius
return &s
}
// SetFromPoints :
func (s Sphere) SetFromPoints(points []Vector3, optionalCenter Vector3) *Sphere {
center := s.Center
center.Copy(optionalCenter)
maxRadiusSq := float64(0)
for i, il := 0, len(points); i < il; i++ {
maxRadiusSq = math.Max(maxRadiusSq, center.DistanceToSquared(points[i]))
}
s.Radius = math.Sqrt(maxRadiusSq)
return &s
}
// Clone :
func (s Sphere) Clone() *Sphere {
return NewSphere(s.Center, s.Radius).Copy(s)
}
// Copy :
func (s Sphere) Copy(sphere Sphere) *Sphere {
s.Center.Copy(sphere.Center)
s.Radius = sphere.Radius
return &s
}
// IsEmpty :
func (s Sphere) IsEmpty() bool {
return s.Radius < 0
}
// MakeEmpty :
func (s Sphere) MakeEmpty() *Sphere {
s.Center.Set(0, 0, 0)
s.Radius = -1
return &s
}
// ContainsPoint :
func (s Sphere) ContainsPoint(point Vector3) bool {
return point.DistanceToSquared(s.Center) <= s.Radius*s.Radius
}
// DistanceToPoint :
func (s Sphere) DistanceToPoint(point Vector3) float64 {
return point.DistanceTo(s.Center) - s.Radius
}
// IntersectsSphere :
func (s Sphere) IntersectsSphere(sphere Sphere) bool {
radiusSum := s.Radius + sphere.Radius
return sphere.Center.DistanceToSquared(s.Center) <= radiusSum*radiusSum
}
// IntersectsBox :
func (s Sphere) IntersectsBox(box Box3) bool {
return box.IntersectsSphere(s)
}
// IntersectsPlane :
func (s Sphere) IntersectsPlane(plane Plane) bool {
return math.Abs(plane.DistanceToPoint(s.Center)) <= s.Radius
}
// ClampPoint :
func (s Sphere) ClampPoint(point, target Vector3) *Vector3 {
deltaLengthSq := s.Center.DistanceToSquared(point)
target.Copy(point)
if deltaLengthSq > s.Radius*s.Radius {
target.Sub(s.Center).Normalize()
target.MultiplyScalar(s.Radius).Add(s.Center)
}
return &target
}
// GetBoundingBox :
func (s Sphere) GetBoundingBox(target Box3) *Box3 {
if s.IsEmpty() {
// Empty sphere produces empty bounding box
target.MakeEmpty()
return &target
}
target.Set(s.Center, s.Center)
target.ExpandByScalar(s.Radius)
return &target
}
// ApplyMatrix4 :
func (s Sphere) ApplyMatrix4(matrix Matrix4) *Sphere {
s.Center.ApplyMatrix4(matrix)
s.Radius = s.Radius * matrix.GetMaxScaleOnAxis()
return &s
}
// Translate :
func (s Sphere) Translate(offset Vector3) *Sphere {
s.Center.Add(offset)
return &s
}
// Equals :
func (s Sphere) Equals(sphere Sphere) bool {
return sphere.Center.Equals(s.Center) && sphere.Radius == s.Radius
} | server/three/sphere.go | 0.892522 | 0.559832 | sphere.go | starcoder |
Package serialization contains serialization functions and types for Hazelcast Go client.
Serialization is the process of converting an object into a stream of bytes to store the object in the memory, a file or database, or transmit it through the network.
Its main purpose is to save the state of an object in order to be able to recreate it when needed.
The reverse process is called deserialization.
Hazelcast serializes all your objects before sending them to the server.
The uint8 (byte), bool, int16, uint16, int32, int64, float32, float64 and string types are serialized natively and you cannot override this behavior.
The following table is the conversion of types for Java server side.
Go Java
============ =========
uint8 (byte) Byte
bool Boolean
uint16 Character
int16 Short
int32 Integer
int64 Long
int Long
float32 Float
float64 Double
string String
types.UUID UUID
Slices of the types above are serialized as arrays in the Hazelcast server side and the Hazelcast Java client.
Reference types are not supported for builtin types, e.g., *int64.
Hazelcast Go client supports several serializers apart from the builtin serializer for default types.
They are Identified Data Serializer, Portable Serializer, JSON Serializer.
We will use the following type for all examples in this section:
const factoryID = 1
const employeeClassID = 1
type Employee struct {
Surname string
}
func (e Employee) String() string {
return fmt.Sprintf("Employe: %s", e.Surname)
}
// Common serialization methods
func (e Employee) FactoryID() int32 {
return factoryID
}
func (e Employee) ClassID() int32 {
return employeeClassID
}
Identified Data Serialization
Hazelcast recommends implementing the Identified Data serialization for faster serialization of values.
See https://docs.hazelcast.com/imdg/latest/serialization/implementing-dataserializable.html#identifieddataserializable for details.
In order to be able to serialize/deserialize a custom type using Identified Data serialization, the type has to implement the serialization.IdentifiedDataSerializable interface and a factory which creates values of that type.
The same factory can be used to create values of all Identified Data Serializable types with the same factory ID.
Note that Identified Data Serializable factory returns a reference to the created value.
Also, it is important to use a reference to the value with the Hazelcast Go client API, since otherwise the value wouldn't be implementing serialization.IdentifiedDataSerializable.
That causes the value to be inadvertently serialized by the global serializer.
Here are functions that implement serialization.IdentifiedDataSerializable interface for Employee type.
FactoryID and ClassID were defined before and they are also required:
func (e Employee) WriteData(output serialization.DataOutput) {
output.WriteString(e.Surname)
}
func (e *Employee) ReadData(input serialization.DataInput) {
e.Surname = input.ReadString()
}
Here's an Identified Data Serializable factory that creates Employees:
type IdentifiedFactory struct{}
func (f IdentifiedFactory) FactoryID() int32 {
return factoryID
}
func (f IdentifiedFactory) Create(classID int32) serialization.IdentifiedDataSerializable {
if classID == employeeClassID {
return &Employee{}
}
// given classID was not found in the factory
return nil
}
In order to use the factory, you have to register it:
config := hazelcast.Config{}
config.Serialization.SetIdentifiedDataSerializableFactories(&IdentifiedFactory{})
Portable Serialization
Hazelcast offers portable serialization as an alternative to the existing serialization methods.
Portable serialization has the following advantages: Supports multiple versions of the same object type,
can fetch individual fields without having to rely on the reflection and supports querying and indexing without deserialization and/or reflection.
In order to support these features, a serialized Portable object contains meta information like the version and concrete location of the each field in the binary data.
This way Hazelcast is able to navigate in the binary data and deserialize only the required field without actually deserializing the whole object which improves the query performance.
You can have two members with each one having different versions of the same object by using multiversions.
Hazelcast stores meta information and uses the correct one to serialize and deserialize portable objects depending on the member.
That enables rolling upgrades without shutting down the cluster.
Also note that portable serialization is totally language independent and is used as the binary protocol between Hazelcast server and clients.
See https://docs.hazelcast.com/imdg/latest/serialization/implementing-portable-serialization.html for details.
In order to be able to serialize/deserialize a custom type using Portable serialization, the type has to implement the serialization.Portable interface and a factory which creates values of that type.
The same factory can be used to create values of all Portable types with the same factory ID.
Note that Portable factory returns a reference to the created value.
Also, it is important to use a reference to the value with the Hazelcast Go client API, since otherwise the value wouldn't be implementing serialization.Portable.
That causes the value to be inadvertently serialized by the global serializer.
Here are functions that implement serialization.Portable interface for Employee type:
func (e Employee) WritePortable(writer serialization.PortableWriter) {
writer.WriteString("surname", e.Surname)
}
func (e *Employee) ReadPortable(reader serialization.PortableReader) {
e.Surname = reader.ReadString("surname")
}
Here's a Portable factory that creates Employees:
type PortableFactory struct{}
func (p PortableFactory) FactoryID() int32 {
return factoryID
}
func (f PortableFactory) Create(classID int32) serialization.Portable {
if classID == employeeClassID {
return &Employee{}
}
// given classID was not found in the factory
return nil
}
In order to use the factory, you have to register it:
config := hazelcast.Config{}
config.Serialization.SetPortableFactories(&PortableFactory{})
JSON Serialization
Hazelcast has first class support for JSON.
You can put/get JSON values and use them in queries.
See https://docs.hazelcast.com/imdg/latest/query/how-distributed-query-works.html#querying-json-strings for details.
The data type which is used during serializing/deserializing JSON data is serialization.JSON.
It is in fact defined as []byte, but having a separate type helps the client to use the correct type ID when serializing/deserializing the value.
Note that the client doesn't check the validity of serialized/deserialized JSON data.
In order to use JSON serialized data with Hazelcast Go client, you have to cast a byte array which contains JSON to `serialization.JSON`.
You can use any JSON serializer to convert values to byte arrays, including json.Marshal in Go standard library.
Here is an example:
employee := &Employee{Surname: "Schrute"}
b, err := json.Marshal(employee)
// mark the byte array as JSON, corresponds to HazelcastJsonValue
jsonValue := serialization.JSON(b)
// use jsonValue like any other value you can pass to Hazelcast
err = myHazelcastMap.Set(ctx, "Dwight", jsonValue)
Deserializing JSON values retrieved from Hazelcast is also very easy.
Just make sure the retrieved value is of type serialization.JSON.
v, err := myHazelcastMap.Get(ctx, "Angela")
jsonValue, ok := v.(serialization.JSON)
if !ok {
panic("expected a JSON value")
}
otherEmployee := &Employee{}
err = json.Unmarshal(jsonValue, &otherEmployee)
Custom Serialization
Hazelcast lets you plug a custom serializer to be used for serialization of values.
See https://docs.hazelcast.com/imdg/latest/serialization/custom-serialization.html for details.
In order to use a custom serializer for a type, the type should implement serialization.Serializer interface.
Here is an example:
type EmployeeCustomSerializer struct{}
func (e EmployeeCustomSerializer) ID() (id int32) {
return 45392
}
func (e EmployeeCustomSerializer) Read(input serialization.DataInput) interface{} {
surname := input.ReadString()
return &Employee{Surname: surname}
}
func (e EmployeeCustomSerializer) Write(output serialization.DataOutput, object interface{}) {
employee, ok := object.(*Employee)
if !ok {
panic("can serialize only Employee")
}
output.WriteString(employee.Surname)
}
You should register the serializer in the configuration with the corresponding type:
config := hazelcast.Config{}
config.Serialization.SetCustomSerializer(reflect.TypeOf(&Employee{}), &EmployeeCustomSerializer{})
Global Serializer
If a serializer cannot be found for a value, the global serializer is used.
Values serialized by the global serializer are treated as blobs by Hazelcast, so using them for querying is not possible.
The default global serializer for Hazelcast Go client uses the Gob encoder: https://golang.org/pkg/encoding/gob/
Values serialized by the gob serializer cannot be used by Hazelcast clients in other languages.
You can change the global serializer by implementing the serialization.Serializer interface on a type:
type MyGlobalSerializer struct{}
func (s MyGlobalSerializer) ID() int32 {
return 123456
}
func (s MyGlobalSerializer) Read(input serialization.DataInput) interface{} {
surname := input.ReadString()
return &Employee{Surname: surname}
}
func (s MyGlobalSerializer) Write(output serialization.DataOutput, object interface{}) {
employee, ok := object.(*Employee)
if !ok {
panic("can serialize only Employee")
}
output.WriteString(employee.Surname)
}
And setting it in the serialization configuration:
config := hazelcast.Config{}
config.Serialization.SetGlobalSerializer(&MyGlobalSerializer{})
*/
package serialization | serialization/doc.go | 0.898705 | 0.738822 | doc.go | starcoder |
package collector
import (
"github.com/prometheus/client_golang/prometheus"
)
var (
countStaleConfigErrors = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "count_stale_config_errors_total",
Help: "The total number of times that threads hit stale config exception. Since a stale config exception triggers a refresh of the metadata, this number is roughly proportional to the number of metadata refreshes.",
})
countDonorMoveChunkStarted = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "count_donor_move_chunk_started_total",
Help: "The total number of times that the moveChunk command has started on the shard, of which this node is a member, as part of a chunk migration process. This increasing number does not consider whether the chunk migrations succeed or not.",
})
totalDonorChunkCloneTimeMillis = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "total_donor_chunk_clone_time_milliseconds",
Help: "The cumulative time, in milliseconds, taken by the clone phase of the chunk migrations from this shard, of which this node is a member. Specifically, for each migration from this shard, the tracked time starts with the moveChunk command and ends before the destination shard enters a catch-up phase to apply changes that occurred during the chunk migrations.",
})
totalCriticalSectionCommitTimeMillis = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "total_critical_section_commit_time_milliseconds",
Help: "The cumulative time, in milliseconds, taken by the update metadata phase of the chunk migrations from this shard, of which this node is a member. During the update metadata phase, all operations on the collection are blocked.",
})
totalCriticalSectionTimeMillis = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "total_critical_section_time_milliseconds",
Help: "The cumulative time, in milliseconds, taken by the catch-up phase and the update metadata phase of the chunk migrations from this shard, of which this node is a member.",
})
catalogCacheNumDatabaseEntries = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_num_database_entries",
Help: "The total number of database entries that are currently in the catalog cache.",
})
catalogCacheNumCollectionEntries = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_num_collection_entries",
Help: "The total number of collection entries (across all databases) that are currently in the catalog cache.",
})
catalogCacheContStaleConfigErrors = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_count_stale_config_errors",
Help: "The total number of times that threads hit stale config exception. A stale config exception triggers a refresh of the metadata.",
})
catalogCacheTotalRefreshWaitTime = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_total_refresh_wait_time_microseconds",
Help: "The cumulative time, in microseconds, that threads had to wait for a refresh of the metadata.",
})
catalogCacheNumActiveIncrementalRefreshes = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_num_active_incremental_refreshes",
Help: "The number of incremental catalog cache refreshes that are currently waiting to complete.",
})
catalogCacheCountIncrementalRefreshesStarted = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_count_incremental_refreshes_started",
Help: " The cumulative number of incremental refreshes that have started.",
})
catalogCacheNumActiveFullRefreshes = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_num_active_full_refreshes",
Help: "The number of full catalog cache refreshes that are currently waiting to complete.",
})
catalogCacheCountFullRefreshesStarted = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_count_full_refreshes_started",
Help: "The cumulative number of full refreshes that have started.",
})
catalogCacheCountFailedRefreshes = prometheus.NewGauge(prometheus.GaugeOpts{
Namespace: Namespace,
Subsystem: "sharding_statistics",
Name: "catalog_cache_count_failed_refreshes",
Help: "The cumulative number of full or incremental refreshes that have failed.",
})
)
// Cursors are the cursor metrics
type ShardingStatistics struct {
CountStaleConfigErrors int64 `bson:"countStaleConfigErrors"`
CountDonorMoveChunkStarted int64 `bson:"countDonorMoveChunkStarted"`
TotalDonorChunkCloneTimeMillis int64 `bson:"totalDonorChunkCloneTimeMillis"`
TotalCriticalSectionCommitTimeMillis int64 `bson:"totalCriticalSectionCommitTimeMillis"`
TotalCriticalSectionTimeMillis int64 `bson:"totalCriticalSectionTimeMillis"`
CatalogCache `bson:"catalogCache"`
}
type CatalogCache struct {
NumDatabaseEntries int64 `bson:"numDatabaseEntries"`
NumCollectionEntries int64 `bson:"numCollectionEntries"`
CountStaleConfigErrors int64 `bson:"countStaleConfigErrors"`
TotalRefreshWaitTimeMicros int64 `bson:"totalRefreshWaitTimeMicros"`
NumActiveIncrementalRefreshes int64 `bson:"numActiveIncrementalRefreshes"`
CountIncrementalRefreshesStarted int64 `bson:"countIncrementalRefreshesStarted"`
NumActiveFullRefreshes int64 `bson:"numActiveFullRefreshes"`
CountFullRefreshesStarted int64 `bson:"countFullRefreshesStarted"`
CountFailedRefreshes int64 `bson:"countFailedRefreshes"`
}
// Export exports the data to prometheus.
func (s *ShardingStatistics) Export(ch chan<- prometheus.Metric) {
countStaleConfigErrors.Set(float64(s.CountStaleConfigErrors))
countDonorMoveChunkStarted.Set(float64(s.CountDonorMoveChunkStarted))
totalDonorChunkCloneTimeMillis.Set(float64(s.TotalDonorChunkCloneTimeMillis))
totalCriticalSectionCommitTimeMillis.Set(float64(s.TotalCriticalSectionCommitTimeMillis))
totalCriticalSectionTimeMillis.Set(float64(s.TotalCriticalSectionTimeMillis))
catalogCacheNumDatabaseEntries.Set(float64(s.CatalogCache.NumDatabaseEntries))
catalogCacheNumCollectionEntries.Set(float64(s.CatalogCache.NumCollectionEntries))
catalogCacheContStaleConfigErrors.Set(float64(s.CatalogCache.CountStaleConfigErrors))
catalogCacheTotalRefreshWaitTime.Set(float64(s.CatalogCache.TotalRefreshWaitTimeMicros))
catalogCacheNumActiveIncrementalRefreshes.Set(float64(s.CatalogCache.NumActiveIncrementalRefreshes))
catalogCacheCountIncrementalRefreshesStarted.Set(float64(s.CatalogCache.CountIncrementalRefreshesStarted))
catalogCacheNumActiveFullRefreshes.Set(float64(s.CatalogCache.NumActiveFullRefreshes))
catalogCacheCountFullRefreshesStarted.Set(float64(s.CatalogCache.CountFullRefreshesStarted))
catalogCacheCountFailedRefreshes.Set(float64(s.CatalogCache.CountFailedRefreshes))
countStaleConfigErrors.Collect(ch)
countDonorMoveChunkStarted.Collect(ch)
totalDonorChunkCloneTimeMillis.Collect(ch)
totalCriticalSectionCommitTimeMillis.Collect(ch)
totalCriticalSectionTimeMillis.Collect(ch)
catalogCacheNumDatabaseEntries.Collect(ch)
catalogCacheNumCollectionEntries.Collect(ch)
catalogCacheContStaleConfigErrors.Collect(ch)
catalogCacheTotalRefreshWaitTime.Collect(ch)
catalogCacheNumActiveIncrementalRefreshes.Collect(ch)
catalogCacheCountIncrementalRefreshesStarted.Collect(ch)
catalogCacheNumActiveFullRefreshes.Collect(ch)
catalogCacheCountFullRefreshesStarted.Collect(ch)
catalogCacheCountFailedRefreshes.Collect(ch)
}
// Describe describes the metrics for prometheus
func (s *ShardingStatistics) Describe(ch chan<- *prometheus.Desc) {
countStaleConfigErrors.Describe(ch)
countDonorMoveChunkStarted.Describe(ch)
totalDonorChunkCloneTimeMillis.Describe(ch)
totalCriticalSectionCommitTimeMillis.Describe(ch)
totalCriticalSectionTimeMillis.Describe(ch)
catalogCacheNumDatabaseEntries.Describe(ch)
catalogCacheNumCollectionEntries.Describe(ch)
catalogCacheContStaleConfigErrors.Describe(ch)
catalogCacheTotalRefreshWaitTime.Describe(ch)
catalogCacheNumActiveIncrementalRefreshes.Describe(ch)
catalogCacheCountIncrementalRefreshesStarted.Describe(ch)
catalogCacheNumActiveFullRefreshes.Describe(ch)
catalogCacheCountFullRefreshesStarted.Describe(ch)
catalogCacheCountFailedRefreshes.Describe(ch)
} | collector/sharding_statistics.go | 0.542379 | 0.40392 | sharding_statistics.go | starcoder |
package in_toto
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
)
/*
KeyVal contains the actual values of a key, as opposed to key metadata such as
a key identifier or key type. For RSA keys, the key value is a pair of public
and private keys in PEM format stored as strings. For public keys the Private
field may be an empty string.
*/
type KeyVal struct {
Private string `json:"private"`
Public string `json:"public"`
}
/*
Key represents a generic in-toto key that contains key metadata, such as an
identifier, supported hash algorithms to create the identifier, the key type
and the supported signature scheme, and the actual key value.
*/
type Key struct {
KeyId string `json:"keyid"`
KeyIdHashAlgorithms []string `json:"keyid_hash_algorithms"`
KeyType string `json:"keytype"`
KeyVal KeyVal `json:"keyval"`
Scheme string `json:"scheme"`
}
/*
Signature represents a generic in-toto signature that contains the identifier
of the Key, which was used to create the signature and the signature data. The
used signature scheme is found in the corresponding Key.
*/
type Signature struct {
KeyId string `json:"keyid"`
Sig string `json:"sig"`
}
/*
Link represents the evidence of a supply chain step performed by a functionary.
It should be contained in a generic Metablock object, which provides
functionality for signing and signature verification, and reading from and
writing to disk.
*/
type Link struct {
Type string `json:"_type"`
Name string `json:"name"`
Materials map[string]interface{} `json:"materials"`
Products map[string]interface{} `json:"products"`
ByProducts map[string]interface{} `json:"byproducts"`
Command []string `json:"command"`
Environment map[string]interface{} `json:"environment"`
}
/*
LinkNameFormat represents a format string used to create the filename for a
signed Link (wrapped in a Metablock). It consists of the name of the link and
the first 8 characters of the signing key id. LinkNameFormatShort is for links
that are not signed, e.g.:
fmt.Sprintf(LinkNameFormat, "package",
"2f89b9272acfc8f4a0a0f094d789fdb0ba798b0fe41f2f5f417c12f0085ff498")
// returns "package.2f89b9272.link"
fmt.Sprintf(LinkNameFormatShort, "unsigned")
// returns "unsigned.link"
*/
const LinkNameFormat = "%s.%.8s.link"
const LinkNameFormatShort = "%s.link"
const SublayoutLinkDirFormat = "%s.%.8s"
/*
SupplyChainItem summarizes common fields of the two available supply chain
item types, Inspection and Step.
*/
type SupplyChainItem struct {
Name string `json:"name"`
ExpectedMaterials [][]string `json:"expected_materials"`
ExpectedProducts [][]string `json:"expected_products"`
}
/*
Inspection represents an in-toto supply chain inspection, whose command in the
Run field is executed during final product verification, generating unsigned
link metadata. Materials and products used/produced by the inspection are
constrained by the artifact rules in the inspection's ExpectedMaterials and
ExpectedProducts fields.
*/
type Inspection struct {
Type string `json:"_type"`
Run []string `json:"run"`
SupplyChainItem
}
/*
Step represents an in-toto step of the supply chain performed by a functionary.
During final product verification in-toto looks for corresponding Link
metadata, which is used as signed evidence that the step was performed
according to the supply chain definition. Materials and products used/produced
by the step are constrained by the artifact rules in the step's
ExpectedMaterials and ExpectedProducts fields.
*/
type Step struct {
Type string `json:"_type"`
PubKeys []string `json:"pubkeys"`
ExpectedCommand []string `json:"expected_command"`
Threshold int `json:"threshold"`
SupplyChainItem
}
/*
Layout represents the definition of a software supply chain. It lists the
sequence of steps required in the software supply chain and the functionaries
authorized to perform these steps. Functionaries are identified by their
public keys. In addition, the layout may list a sequence of inspections that
are executed during in-toto supply chain verification. A layout should be
contained in a generic Metablock object, which provides functionality for
signing and signature verification, and reading from and writing to disk.
*/
type Layout struct {
Type string `json:"_type"`
Steps []Step `json:"steps"`
Inspect []Inspection `json:"inspect"`
Keys map[string]Key `json:"keys"`
Expires string `json:"expires"`
Readme string `json:"readme"`
}
// Go does not allow to pass `[]T` (slice with certain type) to a function
// that accepts `[]interface{}` (slice with generic type)
// We have to manually create the interface slice first, see
// https://golang.org/doc/faq#convert_slice_of_interface
// TODO: Is there a better way to do polymorphism for steps and inspections?
func (l *Layout) StepsAsInterfaceSlice() []interface{} {
stepsI := make([]interface{}, len(l.Steps))
for i, v := range l.Steps {
stepsI[i] = v
}
return stepsI
}
func (l *Layout) InspectAsInterfaceSlice() []interface{} {
inspectionsI := make([]interface{}, len(l.Inspect))
for i, v := range l.Inspect {
inspectionsI[i] = v
}
return inspectionsI
}
/*
Metablock is a generic container for signable in-toto objects such as Layout
or Link. It has two fields, one that contains the signable object and one that
contains corresponding signatures. Metablock also provides functionality for
signing and signature verification, and reading from and writing to disk.
*/
type Metablock struct {
// NOTE: Whenever we want to access an attribute of `Signed` we have to
// perform type assertion, e.g. `metablock.Signed.(Layout).Keys`
// Maybe there is a better way to store either Layouts or Links in `Signed`?
// The notary folks seem to have separate container structs:
// https://github.com/theupdateframework/notary/blob/master/tuf/data/root.go#L10-L14
// https://github.com/theupdateframework/notary/blob/master/tuf/data/targets.go#L13-L17
// I implemented it this way, because there will be several functions that
// receive or return a Metablock, where the type of Signed has to be inferred
// on runtime, e.g. when iterating over links for a layout, and a link can
// turn out to be a layout (sublayout)
Signed interface{} `json:"signed"`
Signatures []Signature `json:"signatures"`
}
/*
Load parses JSON formatted metadata at the passed path into the Metablock
object on which it was called. It returns an error if it cannot parse
a valid JSON formatted Metablock that contains a Link or Layout.
*/
func (mb *Metablock) Load(path string) error {
// Open file and close before returning
jsonFile, err := os.Open(path)
defer jsonFile.Close()
if err != nil {
return err
}
// Read entire file
jsonBytes, err := ioutil.ReadAll(jsonFile)
if err != nil {
return err
}
// Unmarshal JSON into a map of raw messages (signed and signatures)
// We can't fully unmarshal immediately, because we need to inspect the
// type (link or layout) to decide which data structure to use
var rawMb map[string]*json.RawMessage
if err := json.Unmarshal(jsonBytes, &rawMb); err != nil {
return err
}
// Error out on missing `signed` or `signatures` field or if
// one of them has a `null` value, which would lead to a nil pointer
// dereference in Unmarshal below.
if rawMb["signed"] == nil || rawMb["signatures"] == nil {
return fmt.Errorf("In-toto metadata requires 'signed' and" +
" 'signatures' parts")
}
// Fully unmarshal signatures part
if err := json.Unmarshal(*rawMb["signatures"], &mb.Signatures); err != nil {
return err
}
// Temporarily copy signed to opaque map to inspect the `_type` of signed
// and create link or layout accordingly
var signed map[string]interface{}
if err := json.Unmarshal(*rawMb["signed"], &signed); err != nil {
return err
}
if signed["_type"] == "link" {
var link Link
if err := json.Unmarshal(*rawMb["signed"], &link); err != nil {
return err
}
mb.Signed = link
} else if signed["_type"] == "layout" {
var layout Layout
if err := json.Unmarshal(*rawMb["signed"], &layout); err != nil {
return err
}
mb.Signed = layout
} else {
return fmt.Errorf("The '_type' field of the 'signed' part of in-toto" +
" metadata must be one of 'link' or 'layout'")
}
return nil
}
/*
Dump JSON serializes and writes the Metablock on which it was called to the
passed path. It returns an error if JSON serialization or writing fails.
*/
func (mb *Metablock) Dump(path string) error {
// JSON encode Metablock formatted with newlines and indentation
// TODO: parametrize format
jsonBytes, err := json.MarshalIndent(mb, "", " ")
if err != nil {
return err
}
// Write JSON bytes to the passed path with permissions (-rw-r--r--)
err = ioutil.WriteFile(path, jsonBytes, 0644)
if err != nil {
return err
}
return nil
}
/*
GetSignableRepresentation returns the canonical JSON representation of the
Signed field of the Metablock on which it was called. If canonicalization
fails the first return value is nil and the second return value is the error.
*/
func (mb *Metablock) GetSignableRepresentation() ([]byte, error) {
return encodeCanonical(mb.Signed)
}
/*
VerifySignature verifies the first signature, corresponding to the passed Key,
that it finds in the Signatures field of the Metablock on which it was called.
It returns an error if Signatures does not contain a Signature corresponding to
the passed Key, the object in Signed cannot be canonicalized, or the Signature
is invalid.
*/
func (mb *Metablock) VerifySignature(key Key) error {
var sig Signature
for _, s := range mb.Signatures {
if s.KeyId == key.KeyId {
sig = s
break
}
}
if sig == (Signature{}) {
return fmt.Errorf("No signature found for key '%s'", key.KeyId)
}
dataCanonical, err := mb.GetSignableRepresentation()
if err != nil {
return err
}
if err := VerifySignature(key, sig, dataCanonical); err != nil {
return err
}
return nil
} | in_toto/model.go | 0.621081 | 0.423398 | model.go | starcoder |
package spn
import (
"crypto/rand"
"github.com/OpenWhiteBox/primitives/encoding"
"github.com/OpenWhiteBox/primitives/matrix"
)
// findIntersections returns the incremental matrix containing only the rowspace that a set of given incremental
// matrices have in common.
func findIntersections(ims []matrix.IncrementalMatrix) matrix.IncrementalMatrix {
out := findIntersection(ims[0], ims[1])
for i := 2; i < len(ims); i++ {
out = findIntersection(out, ims[i])
}
return out
}
// findIntersection returns the incremental matrix containing only the rowspace that the two given incremental matrices
// have in common.
func findIntersection(aT, bT matrix.IncrementalMatrix) matrix.IncrementalMatrix {
a, b := aT.Dup(), bT.Dup()
aM, bM := a.Matrix()[0:a.Len()], b.Matrix()[0:b.Len()]
_, size := bM.Size()
// Concatenate the two matrices and find the nullspace of the concatenated matrix.
m := append(aM, bM...)
basis := m.Transpose().NullSpace()
// The nullspace contains all the linear combinations that cause the two matrices to equal. Extract a basis for these
// vectors for just one matrix.
out := matrix.NewIncrementalMatrix(size)
for _, row := range basis {
v := matrix.NewRow(size)
for i := 0; i < a.Len(); i++ {
if row.GetBit(i) == 1 {
v = v.Add(aM[i])
}
}
out.Add(v)
}
return out
}
// trivialSubspaces generates subspaces by fixing one input and letting the rest vary.
func trivialSubspaces(cipher encoding.Block) (subspaces []matrix.IncrementalMatrix) {
for pos := 0; pos < 16; pos++ {
subspace := matrix.NewIncrementalMatrix(128)
for i := 0; i < 256 && subspace.Len() < 120; i++ {
x, y := [16]byte{}, [16]byte{}
rand.Read(x[:])
rand.Read(y[:])
x[pos], y[pos] = 0x00, 0x00
x, y = cipher.Encode(x), cipher.Encode(y)
subspace.Add(matrix.Row(x[:]).Add(matrix.Row(y[:])))
}
if subspace.Len() != 120 {
panic("Found incorrectly sized subspace!")
}
subspaces = append(subspaces, subspace)
}
return
}
type nextFunc func(int, int, [16]byte, [16]byte) ([16]byte, [16]byte)
// nextByAddition generates subsequent plaintexts by adding a random constant.
func nextByAddition(iteration, marker int, x, y [16]byte) (X, Y [16]byte) {
copy(X[:], x[:])
copy(Y[:], y[:])
c := [16]byte{}
rand.Read(c[:])
encoding.XOR(X[:], X[:], c[:])
encoding.XOR(Y[:], Y[:], c[:])
return X, Y
}
// nextByToggle generates subsequent plaintexts by toggling the value of a position.
func nextByToggle(iteration, marker int, x, y [16]byte) (X, Y [16]byte) {
copy(X[:], x[:])
copy(Y[:], y[:])
X[marker%16], Y[marker%16] = byte(iteration), byte(iteration)
return
}
// lowRankDetectionWith is a wrapper around lowRankDetection which injects the right next function
func lowRankDetectionWith(next nextFunc) func(encoding.Block) []matrix.IncrementalMatrix {
return func(cipher encoding.Block) []matrix.IncrementalMatrix {
return lowRankDetection(cipher, next)
}
}
// lowRankDetection generates subspaces by choosing random pairs of inputs and checking if the linear span of their
// output is the right size.
func lowRankDetection(cipher encoding.Block, next nextFunc) (subspaces []matrix.IncrementalMatrix) {
for attempt := 0; attempt < 4000 && len(subspaces) < 16; attempt++ {
// Generate a random subspace.
x, y := [16]byte{}, [16]byte{}
rand.Read(x[:])
rand.Read(y[:])
subspace := matrix.NewIncrementalMatrix(128)
for i := 0; i < 129 && subspace.Len() <= 120; i++ {
x, y = next(i, attempt, x, y)
X, Y := cipher.Encode(x), cipher.Encode(y)
subspace.Add(matrix.Row(X[:]).Add(matrix.Row(Y[:])))
}
// Discard it if it's the wrong size.
if subspace.Len() != 120 {
continue
}
// Discard it if it overlaps too much with what we already have.
dup := false
for _, cand := range subspaces {
intersection := findIntersection(subspace, cand)
if intersection.Len() != 112 {
dup = true
break
}
}
if dup {
continue
}
// Not discarded, so keep it.
subspaces = append(subspaces, subspace)
}
if len(subspaces) < 16 {
panic("Failed to recover enough subspaces.")
}
return
}
// RecoverAffine finds inputs that cause the internal state of the cipher to collide with something like Low Rank
// Detection and uses them to remove the trailing affine layer.
func RecoverAffine(cipher encoding.Block, generator func(encoding.Block) []matrix.IncrementalMatrix) (last encoding.BlockAffine, rest encoding.Block) {
subspaces := generator(cipher)
// Recover span of each column by intersecting 15 others
m := matrix.Matrix{}
for excluded := 0; excluded < 16; excluded++ {
remaining := []matrix.IncrementalMatrix{}
for i := 0; i < 16; i++ {
if i != excluded {
remaining = append(remaining, subspaces[i])
}
}
intersection := findIntersections(remaining)
for bit := uint(0); bit < 8; bit++ {
m = append(m, intersection.Row(1<<bit))
}
}
last = encoding.NewBlockAffine(m.Transpose(), [16]byte{})
return last, encoding.ComposedBlocks{cipher, encoding.InverseBlock{last}}
} | cryptanalysis/spn/affine.go | 0.843927 | 0.616272 | affine.go | starcoder |
package heap
// Heap is a functional representation of a heap
type Heap interface {
Insert(interface{})
RemoveMin() interface{}
}
// AHeap is a heap implemented with an array
type AHeap struct {
arr []interface{}
isSmaller func(int, int) bool
size int
}
// NewHeap returns a new heap
// A heap can be built from an array in 3 methods:
// - Sort the array i.e. sort.Slice(arr, isSmallerFunc) ==> RUNTIME Θ(n*log(n))
// - for (i:=2; i <= size; i ++) heapifyUp(i) ==> RUNTIME Θ(n*log(n))
// - for (i:=size/2; i>0; i--) heapifyDown(i) ==> RUNTIME Θ(n)
// We will be using the third and most efficient way. Why is it Θ(n)?
// heapifyDown can only take one path down and will be ran n/2 times
// whereas heapifyUp will happen for every leaf and thus is ran n times
func NewHeap(arr []interface{}, isSmallerFunc func(int, int) bool) *AHeap {
h := &AHeap{
arr: arr,
isSmaller: isSmallerFunc,
size: len(arr),
}
// leaves always respect the max or min heap property
// and so we only have to heapify down all nodes which are on the second
// level from the bottom
for i := h.size / 2; i > 0; i-- {
h.heapifyDown(i)
}
return h
}
// Insert inserts an item into the heap
func (h *AHeap) Insert(x interface{}) {
if h.size == len(h.arr) {
h.arr = append(h.arr, make([]interface{}, len(h.arr))...)
}
h.size++
h.arr[h.size] = x
h.heapifyUp(h.size)
}
// RemoveMin removes the minimum element from a heap
func (h *AHeap) RemoveMin() interface{} {
if h.isEmpty() {
return nil
}
// smallest is the root of the heap
min := h.arr[1]
h.size--
h.heapifyDown(1)
return min
}
// IntsIsSmallerFunc is an example isSmallerFunc for integers
func IntsIsSmallerFunc(a, b int) bool {
return a < b
}
// heapifyDown moves the node at index i down to its appropriate spot
func (h *AHeap) heapifyDown(i int) {
smallest := i
left := i * 2
right := left + 1
if (left <= h.size) && h.isSmaller(left, smallest) {
smallest = left
}
if (left <= h.size) && h.isSmaller(right, smallest) {
smallest = right
}
if smallest != i {
h.swap(i, smallest)
// i is now at the index which used to be the smallest's
h.heapifyDown(smallest)
}
}
// heapifyDown moves the node at index i up to its appropriate spot
func (h *AHeap) heapifyUp(i int) {
if i == 1 {
return
}
parent := i / 2
if h.isSmaller(i, parent) {
h.swap(i, parent)
// i is now at the index which used to be the parent's
h.heapifyUp(parent)
}
}
func (h *AHeap) swap(a, b int) {
tmp := h.arr[a]
h.arr[a] = h.arr[b]
h.arr[b] = tmp
}
func (h *AHeap) isEmpty() bool {
return (h.size == 1)
} | datastructures/heap/heap.go | 0.743913 | 0.40295 | heap.go | starcoder |
package geometry
import (
"SimpleTriangleRasterizer/src/api"
"image/color"
)
// Triangle is a single triangle without shared edges.
// It can decompose into two triangles: flat-top and flat-bottom
// Each decompose triangle is made of Edges.
type Triangle struct {
// Indices into the vertex transformation buffer.
x1, y1, x2, y2, x3, y3 int
z1, z2, z3 float32
// Edges used for rasterization.
leftEdge, rightEdge api.IEdge
}
// NewTriRasterizer creates a new rasterizer
func NewTriangle() api.ITriangle {
o := new(Triangle)
o.leftEdge = NewEdge()
o.rightEdge = NewEdge()
return o
}
// Set the vertices of the triangle
func (t *Triangle) Set(x1, y1, x2, y2, x3, y3 int) {
t.x1 = x1
t.y1 = y1
t.x2 = x2
t.y2 = y2
t.x3 = x3
t.y3 = y3
}
// Draw renders an outline
func (t *Triangle) Draw(raster api.IRasterBuffer) {
t.sort()
if t.y2 == t.y3 {
// Case for flat-bottom triangle
raster.DrawLineAmmeraal(t.x1, t.y1, t.x2, t.y2) // Diagonal/Right
raster.DrawLineAmmeraal(t.x2, t.y2, t.x3, t.y3) // Bottom
raster.DrawLineAmmeraal(t.x1, t.y1, t.x3, t.y3) // Left
} else if t.y1 == t.y2 {
// Case for flat-top triangle
raster.DrawLineAmmeraal(t.x1, t.y1, t.x3, t.y3) // Diagonal/Right
raster.DrawLineAmmeraal(t.x1, t.y1, t.x2, t.y2) // Top
raster.DrawLineAmmeraal(t.x2, t.y2, t.x3, t.y3) // Left
} else {
// General case
// split the triangle into two triangles: top-half and bottom-half
x := int(float32(t.x1) + (float32(t.y2-t.y1)/float32(t.y3-t.y1))*float32(t.x3-t.x1))
// Top triangle
// flat-bottom
raster.DrawLineAmmeraal(t.x1, t.y1, t.x2, t.y2) // Right
raster.DrawLineAmmeraal(t.x2, t.y2, x, t.y2) // Bottom
raster.DrawLineAmmeraal(t.x1, t.y1, x, t.y2) // Left
// Bottom triangle
// flat-top
raster.DrawLineAmmeraal(t.x2, t.y2, t.x3, t.y3) // Left
raster.DrawLineAmmeraal(t.x2, t.y2, x, t.y2) // Top
raster.DrawLineAmmeraal(x, t.y2, t.x3, t.y3) // Right
}
}
// Fill renders as filled
func (t *Triangle) Fill(raster api.IRasterBuffer) {
t.sort()
// Draw horizontal lines between left/right edges.
if t.y2 == t.y3 {
// Case for flat-bottom triangle
t.leftEdge.Set(t.x1, t.y1, t.x3, t.y3, t.z1, t.z3)
t.rightEdge.Set(t.x1, t.y1, t.x2, t.y2, t.z1, t.z2)
raster.FillTriangleAmmeraal(t.leftEdge, t.rightEdge, true, false)
// raster.DrawLine(t.x2, t.y2, t.x3, t.y3, 1.0, 1.0) // Bottom <-- overdraw
} else if t.y1 == t.y2 {
// Case for flat-top triangle
t.leftEdge.Set(t.x1, t.y1, t.x3, t.y3, t.z1, t.z3)
t.rightEdge.Set(t.x2, t.y2, t.x3, t.y3, t.z2, t.z3)
raster.FillTriangleAmmeraal(t.leftEdge, t.rightEdge, false, false)
// raster.DrawLine(t.x1, t.y1, t.x2, t.y2, 1.0, 1.0) // Top <-- overdraw
} else {
// General case:
// Split the triangle into two triangles: top-half and bottom-half
x := int(float32(t.x1) + (float32(t.y2-t.y1)/float32(t.y3-t.y1))*float32(t.x3-t.x1)) // x intercept
// --------------------------
// Top triangle flat-bottom
// y2 will always be in the "middle" which means it is always at the bottom of the flat-bottom
// Set the edges for scanning left to right
t.leftEdge.Set(t.x1, t.y1, x, t.y2, 1.0, 1.0)
t.rightEdge.Set(t.x1, t.y1, t.x2, t.y2, 1.0, 1.0)
raster.SetPixelColor(color.RGBA{R: 255, G: 255, B: 255, A: 255})
raster.FillTriangleAmmeraal(t.leftEdge, t.rightEdge, true, false)
// --------------------------
// Bottom triangle flat-top
t.leftEdge.Set(x, t.y2, t.x3, t.y3, 2.0, 2.0)
t.rightEdge.Set(t.x2, t.y2, t.x3, t.y3, 2.0, 2.0)
raster.SetPixelColor(color.RGBA{R: 255, G: 255, B: 255, A: 255})
raster.FillTriangleAmmeraal(t.leftEdge, t.rightEdge, false, false)
}
}
func (t *Triangle) sort() {
x := 0
y := 0
// Make y1 <= y2 if needed
if t.y1 > t.y2 {
x = t.x1
y = t.y1
t.x1 = t.x2
t.y1 = t.y2
t.x2 = x
t.y2 = y
}
// Now y1 <= y2. Make y1 <= y3
if t.y1 > t.y3 {
x = t.x1
y = t.y1
t.x1 = t.x3
t.y1 = t.y3
t.x3 = x
t.y3 = y
}
// Now y1 <= y2 and y1 <= y3. Make y2 <= y3
if t.y2 > t.y3 {
x = t.x2
y = t.y2
t.x2 = t.x3
t.y2 = t.y3
t.x3 = x
t.y3 = y
}
} | src/geometry/triangle.go | 0.727395 | 0.555134 | triangle.go | starcoder |
package hole
import (
"math/rand"
"strconv"
"strings"
)
// a bounding box (bbox) is defined in
// terms of its top-left vertex coordinates
// (x, y) and its width and height (w, h).
type bbox struct{ x, y, w, h int }
// couldn't find a quick way to loop a struct
func strconvbox(box bbox) (out string) {
var outs []string
outs = append(outs, strconv.Itoa(box.x))
outs = append(outs, strconv.Itoa(box.y))
outs = append(outs, strconv.Itoa(box.w))
outs = append(outs, strconv.Itoa(box.h))
return strings.Join(outs, " ")
}
// compute bottom-right (br) bbox coordinates
func unbox(b bbox) (tlx, tly, brx, bry int) {
tlx = b.x
tly = b.y
brx = b.x + b.w
bry = b.y + b.h
return
}
// til that go doesn't have built-in max/min for int
func minint(a, b int) int {
if a < b {
return a
}
return b
}
func maxint(a, b int) int {
if a > b {
return a
}
return b
}
func calculateIntersection(b1, b2 bbox) int {
tlx1, tly1, brx1, bry1 := unbox(b1)
tlx2, tly2, brx2, bry2 := unbox(b2)
// find top-left and bottom-right intersection coordinates
itlx := maxint(tlx1, tlx2) // intersection top left x
itly := maxint(tly1, tly2)
ibrx := minint(brx1, brx2) // intersection bottom right x
ibry := minint(bry1, bry2)
// calculate intersection dimensions
iw := ibrx - itlx
ih := ibry - itly
// intersection is empty if the bboxes do not overlap
if iw < 0 || ih < 0 || iw > b1.w+b2.w || ih > b1.h+b2.h {
return 0
}
return iw * ih
}
// generator of random non-null boxes (i.e. with area != 0)
func boxGen() bbox {
return bbox{
x: rand.Intn(101),
y: rand.Intn(101),
w: rand.Intn(50) + 1,
h: rand.Intn(50) + 1,
}
}
func intersection() (args []string, out string) {
var outs []string
//// default cases
// define two non overlapping 1x1 boxes
b1 := bbox{x: 0, y: 0, h: 1, w: 1}
b2 := bbox{x: 0, y: 0, h: 2, w: 2}
b3 := bbox{x: 3, y: 3, h: 1, w: 2}
b4 := bbox{x: 3, y: 1, h: 3, w: 2}
b5 := bbox{x: 3, y: 1, h: 3, w: 1}
b6 := bbox{x: 0, y: 0, h: 10, w: 10}
b7 := bbox{x: 2, y: 2, h: 2, w: 2}
// b1 and b2 overlap by 1 pixel
args = append(args, strconvbox(b1)+" "+strconvbox(b2))
outs = append(outs, "1")
// b1 and b3 are far away and don't overlap
args = append(args, strconvbox(b1)+" "+strconvbox(b3))
outs = append(outs, "0")
// b3 and b4 overlap on one horizontal side
args = append(args, strconvbox(b3)+" "+strconvbox(b4))
outs = append(outs, "2")
// b4 and b5 overlap on one vertical side
args = append(args, strconvbox(b4)+" "+strconvbox(b5))
outs = append(outs, "3")
// b4 is inside b6
args = append(args, strconvbox(b4)+" "+strconvbox(b6))
outs = append(outs, "6")
// b2 and b7 are side by side but don't overlap
args = append(args, strconvbox(b2)+" "+strconvbox(b7))
outs = append(outs, "0")
//// generate 100 random cases
zeros := 0
nonZeros := 0
for zeros+nonZeros < 100 {
b1 = boxGen()
b2 = boxGen()
intersection := calculateIntersection(b1, b2)
// compute 90 non-zero cases and 10 zero ones
if intersection > 0 && nonZeros < 90 {
args = append(args, strconvbox(b1)+" "+strconvbox(b2))
outs = append(outs, strconv.Itoa(intersection))
nonZeros++
} else if intersection == 0 && zeros < 10 {
args = append(args, strconvbox(b1)+" "+strconvbox(b2))
outs = append(outs, strconv.Itoa(intersection))
zeros++
}
}
// 13x13 default side cases
// - | |
// --| |
// --|- |
// --|---|
// --|---|-
// |- |
// |---|
// |---|-
// | - |
// | --|
// | --|-
// | |-
// | | -
bigbox := bbox{x: 2, y: 2, w: 3, h: 3}
strbigbox := strconvbox(bigbox)
xs := []int{0, 2, 3, 5, 6}
ys := []int{0, 2, 3, 5, 6}
for _, x := range xs {
for _, y := range ys {
for w := 1; w < 7; w++ {
for h := 1; h < 7; h++ {
if (x == 0 && (w == 4 || w > 6)) ||
(x == 2 && (w == 2 || w > 4)) ||
(x == 3 && w > 3) ||
(x == 5 && w > 1) || (x == 6 && w > 1) {
continue
}
if (y == 0 && (h == 4 || h > 6)) ||
(y == 2 && (h == 2 || h > 4)) ||
(y == 3 && h > 3) ||
(y == 5 && h > 1) || (y == 6 && h > 1) {
continue
}
if rand.Float32() > 0.5 { // randomly add test ?
b := bbox{x: x, y: y, w: w, h: h}
if rand.Float32() > 0.5 { // randomly flip input
args = append(args, strconvbox(b)+" "+strbigbox)
} else {
args = append(args, strbigbox+" "+strconvbox(b))
}
outs = append(outs, strconv.Itoa(calculateIntersection(b, bigbox)))
}
}
}
}
}
// shuffle args and outputs in the same way
rand.Shuffle(len(args), func(i, j int) {
args[i], args[j] = args[j], args[i]
outs[i], outs[j] = outs[j], outs[i]
})
out = strings.Join(outs, "\n")
return
} | hole/intersection.go | 0.558207 | 0.420659 | intersection.go | starcoder |
package ezconf
import "reflect"
// Parser provides mechanisms to parse and transform configuration structures.
type Parser struct {
typeTransforms map[FilterType]TransformFunc
keyTransforms map[string]TransformFunc
}
// A Filter determines what parts of a configuration structure should be transformed.
type Filter struct {
// Type indicates that all values matching a type should be parsed.
Type FilterType
// KeyFields indicates names of fields to be parsed.
KeyFields []string
}
// FilterType matches a type of field to parse.
type FilterType int
// Various FilterTypes (just String currently).
const (
_ = iota
String FilterType = iota + 1
)
// TransformFunc is the signature for a function to operate on an input and return an output.
type TransformFunc func(input interface{}) interface{}
// NewParser initializes a new Parser for use.
func NewParser() *Parser {
return &Parser{keyTransforms: make(map[string]TransformFunc), typeTransforms: make(map[FilterType]TransformFunc)}
}
// RegisterTransformer registers a TransformFunc and a Filter to a Parser.
func (p *Parser) RegisterTransformer(f TransformFunc, filter Filter) {
if filter.Type != 0 {
p.typeTransforms[filter.Type] = f
return
}
for i := range filter.KeyFields {
p.keyTransforms[filter.KeyFields[i]] = f
}
}
// Transform the input configuration and return the output.
// The output is a copy of the input.
func (p *Parser) Transform(conf interface{}) interface{} {
original := reflect.ValueOf(conf)
parsed := reflect.New(original.Type()).Elem()
p.transformRecursive(parsed, original, nil)
return parsed.Interface()
}
func (p *Parser) transformRecursive(parsed, original reflect.Value, transformer TransformFunc) {
switch original.Kind() {
case reflect.Ptr:
originalValue := original.Elem()
if !originalValue.IsValid() {
return
}
parsed.Set(reflect.New(originalValue.Type()))
p.transformRecursive(parsed.Elem(), originalValue, nil)
case reflect.Struct:
p.transformStruct(parsed, original, transformer)
case reflect.String:
p.transformString(parsed, original, transformer)
default:
if parsed.CanSet() {
parsed.Set(original)
}
}
}
func (p *Parser) transformStruct(parsed, original reflect.Value, transformer TransformFunc) {
for i := 0; i < original.NumField(); i++ {
key := original.Type().Field(i).Name
if v, ok := p.keyTransforms[key]; ok {
p.transformRecursive(parsed.Field(i), original.Field(i), v)
} else {
p.transformRecursive(parsed.Field(i), original.Field(i), nil)
}
}
}
func (p *Parser) transformString(parsed, original reflect.Value, transformer TransformFunc) {
result := original.Interface().(string)
if transformer != nil {
result = transformer(result).(string)
} else if v, ok := p.typeTransforms[String]; ok {
result = v(result).(string)
}
if parsed.CanSet() {
parsed.SetString(result)
}
} | parser.go | 0.716417 | 0.511839 | parser.go | starcoder |
package amd64
import (
"github.com/tetratelabs/wazero/internal/asm"
)
// Assembler is the interface used by amd64 compiler.
type Assembler interface {
asm.AssemblerBase
// CompileJumpToMemory adds jump-type instruction whose destination is stored in the memory address specified by `baseReg+offset`,
// and returns the corresponding Node in the assembled linked list.
CompileJumpToMemory(jmpInstruction asm.Instruction, baseReg asm.Register, offset asm.ConstantValue)
// CompileRegisterToRegisterWithArg adds an instruction where source and destination
// are `from` and `to` registers.
CompileRegisterToRegisterWithArg(instruction asm.Instruction, from, to asm.Register, arg byte)
// CompileMemoryWithIndexToRegister adds an instruction where source operand is the memory address
// specified as `srcBaseReg + srcOffsetConst + srcIndex*srcScale` and destination is the register `DstReg`.
// Note: sourceScale must be one of 1, 2, 4, 8.
CompileMemoryWithIndexToRegister(
instruction asm.Instruction,
srcBaseReg asm.Register,
srcOffsetConst int64,
srcIndex asm.Register,
srcScale int16,
dstReg asm.Register,
)
// CompileMemoryWithIndexAndArgToRegister is the same as CompileMemoryWithIndexToRegister except that this
// also accepts one argument.
CompileMemoryWithIndexAndArgToRegister(
instruction asm.Instruction,
srcBaseReg asm.Register,
srcOffsetConst int64,
srcIndex asm.Register,
srcScale int16,
dstReg asm.Register,
arg byte,
)
// CompileRegisterToMemoryWithIndex adds an instruction where source operand is the register `SrcReg`,
// and the destination is the memory address specified as `dstBaseReg + dstOffsetConst + dstIndex*dstScale`
// Note: dstScale must be one of 1, 2, 4, 8.
CompileRegisterToMemoryWithIndex(
instruction asm.Instruction,
srcReg asm.Register,
dstBaseReg asm.Register,
dstOffsetConst int64,
dstIndex asm.Register,
dstScale int16,
)
// CompileRegisterToMemoryWithIndexAndArg is the same as CompileRegisterToMemoryWithIndex except that this
// also accepts one argument.
CompileRegisterToMemoryWithIndexAndArg(
instruction asm.Instruction,
srcReg asm.Register,
dstBaseReg asm.Register,
dstOffsetConst int64,
dstIndex asm.Register,
dstScale int16,
arg byte,
)
// CompileRegisterToConst adds an instruction where source operand is the register `srcRegister`,
// and the destination is the const `value`.
CompileRegisterToConst(instruction asm.Instruction, srcRegister asm.Register, value int64) asm.Node
// CompileRegisterToNone adds an instruction where source operand is the register `register`,
// and there's no destination operand.
CompileRegisterToNone(instruction asm.Instruction, register asm.Register)
// CompileNoneToRegister adds an instruction where destination operand is the register `register`,
// and there's no source operand.
CompileNoneToRegister(instruction asm.Instruction, register asm.Register)
// CompileNoneToMemory adds an instruction where destination operand is the memory address specified
// as `baseReg+offset`. and there's no source operand.
CompileNoneToMemory(instruction asm.Instruction, baseReg asm.Register, offset int64)
// CompileConstToMemory adds an instruction where source operand is the constant `value` and
// the destination is the memory address specified as `dstBaseReg+dstOffset`.
CompileConstToMemory(instruction asm.Instruction, value int64, dstBaseReg asm.Register, dstOffset int64) asm.Node
// CompileMemoryToConst adds an instruction where source operand is the memory address, and
// the destination is the constant `value`.
CompileMemoryToConst(instruction asm.Instruction, srcBaseReg asm.Register, srcOffset int64, value int64) asm.Node
// CompileLoadStaticConstToRegister adds an instruction where the source operand is asm.StaticConst located in the
// memory and the destination is the dstReg.
CompileLoadStaticConstToRegister(instruction asm.Instruction, c asm.StaticConst, dstReg asm.Register) error
} | internal/asm/amd64/assembler.go | 0.717012 | 0.500671 | assembler.go | starcoder |
Bit String
A package to operate on bit strings of arbitrary length.
Notes:
The least signifcant bit of the bit string is bit 0.
The transmit order is right to left (as per the string representation).
In the bitstream "head" bits are transmitted before "tail" bits.
That is:
[tail]...[body]...[head] <- Tx First
The bits are stored in bitSets (up to 64 bits) and a slice of bitSets forms
the bit string. The bitSets are stored in the slice head first. A head
operation works on the start of the slice, while a tail operation works on
the end of the slice.
*/
//-----------------------------------------------------------------------------
package bitstr
import (
"fmt"
"math/rand"
"strings"
)
//-----------------------------------------------------------------------------
// min returns the minimum of two integers.
func min(a, b int) int {
if a < b {
return a
}
return b
}
// bytesToUint64 converts an 8-byte slice to a uint64.
func bytesToUint64(b []byte) uint64 {
_ = b[7] // bounds check hint
return uint64(b[0]) |
uint64(b[1])<<8 |
uint64(b[2])<<16 |
uint64(b[3])<<24 |
uint64(b[4])<<32 |
uint64(b[5])<<40 |
uint64(b[6])<<48 |
uint64(b[7])<<56
}
// stringToUint64 converts a 0/1 string to a uint64.
func stringToUint64(s string) uint64 {
var val uint64
for i := range s {
val <<= 1
if s[i] == '1' {
val |= 1
}
}
return val
}
//-----------------------------------------------------------------------------
const setSize = 64
const zeroes = uint64(0)
const ones = uint64((1 << 64) - 1)
// bitSet stores 0 to 64 bits.
type bitSet struct {
val uint64 // bits in this set
n int // number of bits in this set
}
// newBitSet returns a bit set of 0 to 64 bits.
func newBitSet(val uint64, n int) bitSet {
if n > setSize || n < 0 {
panic("")
}
if n < setSize {
val &= uint64((1 << n) - 1)
}
return bitSet{
val: val,
n: n,
}
}
// dropHead drops n-bits from the head of a bit set.
func (bs *bitSet) dropHead(n int) {
if n > setSize || n < 0 {
panic("")
}
bs.val >>= n
bs.n -= n
}
// dropTail drops n-bits from the tail of a bit set.
func (bs *bitSet) dropTail(n int) {
if n > setSize || n < 0 {
panic("")
}
bs.val &= uint64((1 << (bs.n - n)) - 1)
bs.n -= n
}
// feed in a bit set and generate an n-bit uint.
func (bs *bitSet) feed(in bitSet, n int) (uint, bool) {
if in.n == 0 {
// no change
return 0, false
}
if bs.n+in.n >= n {
// generate the uint
val := (bs.val | (in.val << bs.n)) & ((1 << n) - 1)
// store the left over bits
k := n - bs.n
bs.val = in.val >> k
bs.n = in.n - k
return uint(val), true
}
// store the input bits
bs.val |= (in.val << bs.n)
bs.n += in.n
return 0, false
}
// get an n-bit uint from a bit set.
func (bs *bitSet) get(n int) (uint, bool) {
if bs.n < n {
return 0, false
}
val := bs.val & ((1 << n) - 1)
bs.val >>= n
bs.n -= n
return uint(val), true
}
// flush any remaining bits from a bit set.
func (bs *bitSet) flush() (uint, bool) {
if bs.n == 0 {
return 0, false
}
val := bs.val
bs.val = 0
bs.n = 0
return uint(val), true
}
func (bs *bitSet) String() string {
if bs.n == 0 {
return ""
}
fmtX := fmt.Sprintf("%%0%db", bs.n)
return fmt.Sprintf(fmtX, bs.val)
}
//-----------------------------------------------------------------------------
// BitString is a bit string of arbitrary length.
type BitString struct {
set []bitSet // bit sets
n int
}
// NewBitString returns a new 0 length bitstring.
func NewBitString() *BitString {
return &BitString{}
}
// tail adds a bit set to the tail of the bit string.
func (b *BitString) tail(bs bitSet) *BitString {
if bs.n > 0 {
b.set = append(b.set, bs)
b.n += bs.n
}
return b
}
// Tail0 adds zero bits to the tail of the bit string.
func (b *BitString) Tail0(n int) *BitString {
for n > 0 {
k := min(n, setSize)
b.tail(newBitSet(zeroes, k))
n -= k
}
return b
}
// Tail1 adds one bits to the tail of the bit string.
func (b *BitString) Tail1(n int) *BitString {
for n > 0 {
k := min(n, setSize)
b.tail(newBitSet(ones, k))
n -= k
}
return b
}
// DropHead removes n bits from the head of the bit string.
func (b *BitString) DropHead(n int) *BitString {
if n >= b.n {
b.n = 0
b.set = []bitSet{}
return b
}
b.n -= n
for i := range b.set {
bs := &b.set[i]
k := min(n, bs.n)
bs.dropHead(k)
n -= k
if n == 0 {
break
}
}
return b
}
// DropTail removes n bits from the tail of the bit string.
func (b *BitString) DropTail(n int) *BitString {
if n >= b.n {
b.set = []bitSet{}
b.n = 0
return b
}
b.n -= n
for i := len(b.set) - 1; i >= 0; i-- {
bs := &b.set[i]
k := min(n, bs.n)
bs.dropTail(k)
n -= k
if n == 0 {
break
}
}
return b
}
// Copy returns a new copy of the bit string.
func (b *BitString) Copy() *BitString {
x := NewBitString()
for i := range b.set {
x.tail(b.set[i])
}
return x
}
// Head adds a bit string to the head of a bit string.
func (b *BitString) Head(a *BitString) *BitString {
b.set = append(a.set, b.set...)
b.n += a.n
return b
}
// Tail adds a bit string to the tail of a bit string.
func (b *BitString) Tail(a *BitString) *BitString {
b.set = append(b.set, a.set...)
b.n += a.n
return b
}
// GetBytes returns a byte slice for the bit string.
func (b *BitString) GetBytes() []byte {
buf := make([]byte, 0, (b.n+7)>>3)
state := &bitSet{}
for i := range b.set {
val, ok := state.feed(b.set[i], 8)
if !ok {
continue
}
buf = append(buf, byte(val))
for {
val, ok := state.get(8)
if !ok {
break
}
buf = append(buf, byte(val))
}
}
val, ok := state.flush()
if ok {
buf = append(buf, byte(val))
}
return buf
}
// Len returns the length of the bit string.
func (b *BitString) Len() int {
return b.n
}
// Split splits a bit string into []uint using the number of bits in the input slice.
func (b *BitString) Split(in []int) []uint {
x := make([]uint, len(in))
state := &bitSet{}
j := 0
for i := range b.set {
val, ok := state.feed(b.set[i], in[j])
if !ok {
continue
}
x[j] = val
j++
if j == len(in) {
return x
}
for {
val, ok := state.get(in[j])
if !ok {
break
}
x[j] = val
j++
if j == len(in) {
return x
}
}
}
return x
}
// GetTail returns the value of the last bit in a bit string.
func (b *BitString) GetTail() byte {
if b.n == 0 {
panic("0-length bit string")
}
for i := len(b.set) - 1; i >= 0; i-- {
if b.set[i].n > 0 {
return byte((b.set[i].val >> (b.set[i].n - 1)) & 1)
}
}
return 0
}
func (b *BitString) String() string {
s := []string{}
for i := len(b.set) - 1; i >= 0; i-- {
if b.set[i].n > 0 {
s = append(s, b.set[i].String())
}
}
return strings.Join(s, "")
}
// LenBits returns a length/bits string for the bit string.
func (b *BitString) LenBits() string {
return fmt.Sprintf("(%d) %s", b.n, b.String())
}
//-----------------------------------------------------------------------------
// Null returns an empty bit string.
func Null() *BitString {
return NewBitString()
}
// Ones returns a bit string with n-one bits.
func Ones(n int) *BitString {
return NewBitString().Tail1(n)
}
// Zeros returns a bit string with n-zero bits.
func Zeros(n int) *BitString {
return NewBitString().Tail0(n)
}
// FromBytes returns a bit string from a byte slice.
func FromBytes(s []byte, n int) *BitString {
// sanity check
k := len(s)
if n > k*8 {
panic("")
}
b := NewBitString()
i := 0
// 8 bytes at a time
for n >= setSize {
val := bytesToUint64(s[i : i+8])
b.tail(newBitSet(val, setSize))
i += 8
k -= 8
n -= setSize
}
// left over bits
if k > 0 {
var val uint64
for j := 0; j < k; j++ {
val |= uint64(s[i+j]) << (j * 8)
}
b.tail(newBitSet(val, n))
}
return b
}
// FromUint returns a bit string from a uint.
func FromUint(val uint, n int) *BitString {
if n > 64 {
panic("")
}
b := NewBitString()
b.tail(newBitSet(uint64(val), n))
return b
}
// FromString returns a bit string from a 1/0 string.
func FromString(s string) *BitString {
n := len(s)
b := NewBitString()
for n > 0 {
k := min(n, setSize)
val := stringToUint64(s[n-k : n])
b.tail(newBitSet(val, k))
n -= k
}
return b
}
// Random returns a random bit string with n bits.
func Random(n int) *BitString {
b := NewBitString()
for n > 0 {
k := min(n, setSize)
b.tail(newBitSet(rand.Uint64(), k))
n -= k
}
return b
}
//----------------------------------------------------------------------------- | bitstr/bitstr.go | 0.810479 | 0.5867 | bitstr.go | starcoder |
package ndarray
// Transpose
func (this *Array) T() *Array {
r, c := this.Dims()
trans := Zeros(c, r)
for i := 0; i < r; i++ { // i
for j := 0; j < c; j++ { // j
trans.Set(j, i, this.At(i, j))
}
}
return trans
}
// Apply a function over each element of the ndarray
func (this *Array) ForEach(fn func(x float64) float64) *Array {
for i := range this.Data {
this.Data[i] = fn(this.Data[i])
}
return this
}
// Like ForEach but creates and returns a copy
func (this Array) Activate(fn func(x float64) float64) *Array {
ndarr := Zeros(this.Dims())
for i := range ndarr.Data {
ndarr.Data[i] = fn(this.Data[i])
}
return ndarr
}
func (this *Array) Normalize() *Array {
length := this.Distance()
if length > 0 {
return this.Scale(1.0 / length)
}
return Copy(this)
}
func (this *Array) Diagonal() *Array {
arr := Zeros(this.dims.Rows())
for i := 0; i < this.dims.Rows(); i++ {
for j := 0; j < this.dims.Columns(); j++ {
if i == j {
arr.Data[i] = this.At(i, j)
}
}
}
return arr
}
func (this *Array) Eye() *Array {
arr := Zeros(this.Dims())
for i := 0; i < this.dims.Rows(); i++ {
for j := 0; j < this.dims.Columns(); j++ {
if i == j {
arr.Set(i, j, this.At(i, j))
}
}
}
return arr
}
func (this *Array) ArgMax(axis ...int) int {
if len(axis) > 0 {
return 0
}
max := 0.0
index := 0
for i, v := range this.Data {
if v > max {
max = v
index = i
}
}
return index
}
func (this *Array) Flatten(order byte) *Array {
if order == 0 {
order = 'C'
}
switch order {
case 'F':
flat := make([]float64, 0)
for i := 0; i < this.dims.Rows(); i++ {
row := this.Row(i)
flat = append(flat, row...)
}
return NewNdArray(flat, 1, len(this.Data))
case 'C':
flat := make([]float64, 0)
for i := 0; i < this.dims.Columns(); i++ {
col := this.Column(i)
flat = append(flat, col...)
}
return NewNdArray(flat, 1, len(this.Data))
}
// Just return as is (should have same effect as 'F')
return NewNdArray(this.Data, 1, len(this.Data))
} | ndarray_manip.go | 0.76207 | 0.407157 | ndarray_manip.go | starcoder |
package block
import (
"github.com/fxamacker/cbor/v2"
)
const (
BLOCK_TYPE_BYRON_EBB = 0
BLOCK_TYPE_BYRON_MAIN = 1
BLOCK_HEADER_TYPE_BYRON = 0
TX_TYPE_BYRON = 0
)
type ByronMainBlockHeader struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
id string
ProtocolMagic uint32
PrevBlock Blake2b256
BodyProof interface{}
ConsensusData struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
// [slotid, pubkey, difficulty, blocksig]
SlotId struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Epoch uint64
Slot uint16
}
PubKey []byte
Difficulty struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Unknown uint64
}
BlockSig []interface{}
}
ExtraData struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
BlockVersion struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Major uint16
Minor uint16
Unknown uint8
}
SoftwareVersion struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Name string
Unknown uint32
}
Attributes interface{}
ExtraProof Blake2b256
}
}
func (h *ByronMainBlockHeader) Id() string {
return h.id
}
type ByronMainBlockBody struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
TxPayload []interface{}
// We keep this field as raw CBOR, since it contains a map with []byte
// keys, which Go doesn't allow
SscPayload cbor.RawMessage
DlgPayload []interface{}
UpdPayload []interface{}
}
type ByronEpochBoundaryBlockHeader struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
id string
ProtocolMagic uint32
PrevBlock Blake2b256
BodyProof interface{}
ConsensusData struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Epoch uint64
Difficulty struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Value uint64
}
}
ExtraData interface{}
}
func (h *ByronEpochBoundaryBlockHeader) Id() string {
return h.id
}
type ByronMainBlock struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Header ByronMainBlockHeader
Body ByronMainBlockBody
Extra []interface{}
}
func (b *ByronMainBlock) Id() string {
return b.Header.Id()
}
type ByronEpochBoundaryBlock struct {
// Tells the CBOR decoder to convert to/from a struct and a CBOR array
_ struct{} `cbor:",toarray"`
Header ByronEpochBoundaryBlockHeader
Body []Blake2b224
Extra []interface{}
}
func (b *ByronEpochBoundaryBlock) Id() string {
return b.Header.Id()
} | block/byron.go | 0.574156 | 0.438244 | byron.go | starcoder |
package nn
import (
"encoding/json"
"fmt"
tsr "../tensor"
)
// DenseLayer is a fully connected layer for a neural network.
type DenseLayer struct {
inputShape LayerShape
outputShape LayerShape
inputs *tsr.Tensor
outputs *tsr.Tensor
Weights *tsr.Tensor
Bias *tsr.Tensor
PrevUpdate *tsr.Tensor
Activation ActivationFunction
}
// NewDenseLayer creates a new instance of a fully connected layer.
func NewDenseLayer(inputSize int, outputSize int, activation ActivationFunction) *DenseLayer {
inputs := tsr.NewEmptyTensor1D(inputSize)
outputs := tsr.NewEmptyTensor1D(outputSize)
weights := tsr.NewEmptyTensor2D(inputSize, outputSize)
weights.SetRandom(-1.0, 1.0)
bias := tsr.NewEmptyTensor1D(outputSize)
bias.SetRandom(-1.0, 1.0)
prevUpdate := tsr.NewEmptyTensor2D(inputSize, outputSize)
return &DenseLayer{
inputShape: LayerShape{1, inputSize, 1},
outputShape: LayerShape{1, outputSize, 1},
inputs: inputs,
outputs: outputs,
Weights: weights,
Bias: bias,
PrevUpdate: prevUpdate,
Activation: activation,
}
}
// Copy creates a deep copy of the layer.
func (layer *DenseLayer) Copy() Layer {
newLayer := NewDenseLayer(layer.InputShape().Cols, layer.OutputShape().Cols, layer.Activation)
newLayer.Weights.SetTensor(layer.Weights)
newLayer.Bias.SetTensor(layer.Bias)
return newLayer
}
// InputShape returns the rows, columns and frames of the inputs to the layer.
func (layer *DenseLayer) InputShape() LayerShape {
return layer.inputShape
}
// OutputShape returns the rows, columns and frames of outputs from the layer.
func (layer *DenseLayer) OutputShape() LayerShape {
return layer.outputShape
}
// FeedForward computes the outputs of the layer based on the inputs, weights and bias.
func (layer *DenseLayer) FeedForward(inputs *tsr.Tensor) (*tsr.Tensor, error) {
if inputs.Frames != 1 {
return nil, fmt.Errorf("Input shape must have frame length of 1, is: %d", inputs.Frames)
}
layer.inputs.SetTensor(inputs)
_, err := tsr.MatrixMultiply(layer.inputs, layer.Weights, layer.outputs)
if err != nil {
return nil, err
}
err = layer.outputs.AddTensor(layer.Bias)
if err != nil {
return nil, err
}
layer.Activation.Function(layer.outputs)
return layer.outputs, nil
}
// BackPropagate updates the weights and bias of the layer based on a set of deltas and a learning rate.
func (layer *DenseLayer) BackPropagate(outputs *tsr.Tensor, learningRate float32, momentum float32) (*tsr.Tensor, error) {
if outputs.Frames != 1 {
return nil, fmt.Errorf("Input shape must have frame length of 1, is: %d", outputs.Frames)
}
gradient := layer.Activation.Derivative(layer.outputs.Copy())
err := gradient.ScaleTensor(outputs)
if err != nil {
return nil, err
}
gradient.Scale(learningRate)
transposedInputs, _ := tsr.MatrixTranspose(layer.inputs, nil)
weightChange, err := tsr.MatrixMultiply(transposedInputs, gradient, nil)
if err != nil {
return nil, err
}
err = layer.Weights.AddTensor(weightChange)
if err != nil {
return nil, err
}
layer.PrevUpdate.Scale(momentum)
err = layer.Weights.AddTensor(layer.PrevUpdate)
if err != nil {
return nil, err
}
err = layer.PrevUpdate.SetTensor(weightChange)
if err != nil {
return nil, err
}
err = layer.Bias.AddTensor(gradient)
if err != nil {
return nil, err
}
transposedWeights, _ := tsr.MatrixTranspose(layer.Weights, nil)
nextDeltas, err := tsr.MatrixMultiply(outputs, transposedWeights, nil)
if err != nil {
return nil, err
}
return nextDeltas, nil
}
// DenseLayerData represents a serialized layer that can be saved to a file.
type DenseLayerData struct {
Type LayerType `json:"type"`
InputSize int `json:"inputSize"`
OutputSize int `json:"outputSize"`
Weights [][]float32 `json:"weights"`
Bias []float32 `json:"bias"`
Activation ActivationType `json:"activation"`
}
// MarshalJSON converts the layer to JSON.
func (layer *DenseLayer) MarshalJSON() ([]byte, error) {
data := DenseLayerData{
Type: LayerTypeDense,
InputSize: layer.InputShape().Cols,
OutputSize: layer.OutputShape().Cols,
Weights: layer.Weights.GetFrame(0),
Bias: layer.Bias.GetFrame(0)[0],
Activation: layer.Activation.Type,
}
return json.Marshal(data)
}
// UnmarshalJSON creates a new layer from JSON.
func (layer *DenseLayer) UnmarshalJSON(b []byte) error {
data := DenseLayerData{}
err := json.Unmarshal(b, &data)
if err != nil {
return err
}
layer.inputs = tsr.NewEmptyTensor1D(data.InputSize)
layer.outputs = tsr.NewEmptyTensor1D(data.OutputSize)
layer.Weights = tsr.NewValueTensor2D(data.Weights)
layer.Bias = tsr.NewValueTensor1D(data.Bias)
layer.Activation = activationFunctionOfType(data.Activation)
layer.inputShape = LayerShape{1, data.InputSize, 1}
layer.outputShape = LayerShape{1, data.OutputSize, 1}
return nil
} | nn/denseLayer.go | 0.860105 | 0.651812 | denseLayer.go | starcoder |
package engine
import (
"github.com/mumax/3/cuda"
"github.com/mumax/3/data"
"github.com/mumax/3/util"
"reflect"
)
var DU firstDerivative // firstDerivative (unit [m/s])
func init() { DeclLValue("du", &DU, `firstDerivative (unit [m/s])`) }
// Special buffered quantity to store firstDerivative
type firstDerivative struct {
buffer_ *data.Slice
}
func (du *firstDerivative) Mesh() *data.Mesh { return Mesh() }
func (du *firstDerivative) NComp() int { return 3 }
func (du *firstDerivative) Name() string { return "du" }
func (du *firstDerivative) Unit() string { return "m/s" }
func (du *firstDerivative) Buffer() *data.Slice { return du.buffer_ } // todo: rename Gpu()?
func (du *firstDerivative) Comp(c int) ScalarField { return Comp(du, c) }
func (du *firstDerivative) SetValue(v interface{}) { du.SetInShape(nil, v.(Config)) }
func (du *firstDerivative) InputType() reflect.Type { return reflect.TypeOf(Config(nil)) }
func (du *firstDerivative) Type() reflect.Type { return reflect.TypeOf(new(firstDerivative)) }
func (du *firstDerivative) Eval() interface{} { return du }
func (du *firstDerivative) average() []float64 { return sAverageMagnet(du.Buffer()) }
func (du *firstDerivative) Average() data.Vector { return unslice(du.average()) }
//func (du *firstDerivative) normalize() { cuda.Normalize(du.Buffer(), geometry.Gpu()) }
// allocate storage (not done by init, as mesh size may not yet be known then)
func (du *firstDerivative) alloc() {
du.buffer_ = cuda.NewSlice(3, du.Mesh().Size())
du.Set(Uniform(0, 0, 0)) // sane starting config
}
func (b *firstDerivative) SetArray(src *data.Slice) {
if src.Size() != b.Mesh().Size() {
src = data.Resample(src, b.Mesh().Size())
}
data.Copy(b.Buffer(), src)
//b.normalize()
}
func (du *firstDerivative) Set(c Config) {
checkMesh()
du.SetInShape(nil, c)
}
func (du *firstDerivative) LoadFile(fname string) {
du.SetArray(LoadFile(fname))
}
func (du *firstDerivative) Slice() (s *data.Slice, recycle bool) {
return du.Buffer(), false
}
func (du *firstDerivative) EvalTo(dst *data.Slice) {
data.Copy(dst, du.buffer_)
}
func (du *firstDerivative) Region(r int) *vOneReg { return vOneRegion(du, r) }
func (du *firstDerivative) String() string { return util.Sprint(du.Buffer().HostCopy()) }
// Set the value of one cell.
func (du *firstDerivative) SetCell(ix, iy, iz int, v data.Vector) {
for c := 0; c < 3; c++ {
cuda.SetCell(du.Buffer(), c, ix, iy, iz, float32(v[c]))
}
}
// Get the value of one cell.
func (du *firstDerivative) GetCell(ix, iy, iz int) data.Vector {
dux := float64(cuda.GetCell(du.Buffer(), X, ix, iy, iz))
duy := float64(cuda.GetCell(du.Buffer(), Y, ix, iy, iz))
duz := float64(cuda.GetCell(du.Buffer(), Z, ix, iy, iz))
return Vector(dux, duy, duz)
}
func (du *firstDerivative) Quantity() []float64 { return slice(du.Average()) }
// Sets the firstDerivative inside the shape
func (du *firstDerivative) SetInShape(region Shape, conf Config) {
checkMesh()
if region == nil {
region = universe
}
host := du.Buffer().HostCopy()
h := host.Vectors()
n := du.Mesh().Size()
for iz := 0; iz < n[Z]; iz++ {
for iy := 0; iy < n[Y]; iy++ {
for ix := 0; ix < n[X]; ix++ {
r := Index2Coord(ix, iy, iz)
x, y, z := r[X], r[Y], r[Z]
if region(x, y, z) { // inside
du := conf(x, y, z)
h[X][iz][iy][ix] = float32(du[X])
h[Y][iz][iy][ix] = float32(du[Y])
h[Z][iz][iy][ix] = float32(du[Z])
}
}
}
}
du.SetArray(host)
}
// set du to config in region
func (du *firstDerivative) SetRegion(region int, conf Config) {
host := du.Buffer().HostCopy()
h := host.Vectors()
n := du.Mesh().Size()
r := byte(region)
regionsArr := regions.HostArray()
for iz := 0; iz < n[Z]; iz++ {
for iy := 0; iy < n[Y]; iy++ {
for ix := 0; ix < n[X]; ix++ {
pos := Index2Coord(ix, iy, iz)
x, y, z := pos[X], pos[Y], pos[Z]
if regionsArr[iz][iy][ix] == r {
du := conf(x, y, z)
h[X][iz][iy][ix] = float32(du[X])
h[Y][iz][iy][ix] = float32(du[Y])
h[Z][iz][iy][ix] = float32(du[Z])
}
}
}
}
du.SetArray(host)
}
func (du *firstDerivative) resize() {
backup := du.Buffer().HostCopy()
s2 := Mesh().Size()
resized := data.Resample(backup, s2)
du.buffer_.Free()
du.buffer_ = cuda.NewSlice(VECTOR, s2)
data.Copy(du.buffer_, resized)
} | engine/firstDerivative.go | 0.512205 | 0.4231 | firstDerivative.go | starcoder |
package maxflow
import (
"fmt"
"github.com/wangyoucao577/algorithms_practice/bfs"
"github.com/wangyoucao577/algorithms_practice/dfs"
"github.com/wangyoucao577/algorithms_practice/flownetwork"
"github.com/wangyoucao577/algorithms_practice/graph"
)
// residualNetwork has same structure as flownetwork, but will have reverse edges
type residualNetwork struct {
graph.Graph
residualCapacities flownetwork.CapacityStorage
}
// calculateResidualNetwork will calculate residual network with current flow based on flow network
func calculateResidualNetwork(fn *flownetwork.FlowNetwork, flow flowStorage) *residualNetwork {
rn := &residualNetwork{graph.NewAdjacencyListGraph(fn.NodeCount(), fn.Directed()), flownetwork.CapacityStorage{}}
fn.IterateAllNodes(func(u graph.NodeID) {
fn.IterateAdjacencyNodes(u, func(v graph.NodeID) {
edge := graph.EdgeID{From: u, To: v}
edgeFlow := flow[edge]
if edgeFlow > 0 {
if fn.Capacity(edge) > edgeFlow {
rn.AddEdge(u, v)
rn.residualCapacities[edge] = fn.Capacity(edge) - edgeFlow
}
//reverse edge for residual network graph
rn.AddEdge(v, u)
rn.residualCapacities[edge.Reverse()] = edgeFlow
} else {
rn.AddEdge(u, v)
rn.residualCapacities[edge] = fn.Capacity(edge)
}
})
})
return rn
}
// FordFulkerson algorithm for maximum flow problem, with/without EdmondKarp improvement
func FordFulkerson(f *flownetwork.FlowNetwork, edmondsKarp bool) flownetwork.EdgeFlowUnit {
fmt.Printf("FordFulkerson, EmondsKarp %v\n", edmondsKarp)
//initialize flow
currFlow := newFlow(f)
for {
//currFlow.print()
// phase 1, construct residual network based on original flow network and current flow
rn := calculateResidualNetwork(f, currFlow)
// pahse 2, try to find augmenting path in the residual network graph
var augmentingPath graph.Path
if edmondsKarp { //EdmondsKarp use BFS to find a path, better effectiveness
bfs, err := bfs.NewBfs(rn.Graph, f.Source(), func(u graph.NodeID) bfs.SearchControlCondition {
if u == f.Target() {
return bfs.Break
}
return bfs.Continue
})
if err != nil {
//fmt.Println(err)
break // bfs failed
}
_, path, err := bfs.Query(f.Target())
if err != nil {
//fmt.Println(err)
break // no more agumenting path can be found
}
augmentingPath = path
} else {
dfs, _ := dfs.NewControllableDfs(rn.Graph, f.Source(), func(u graph.NodeID) dfs.SearchControlCondition {
if u == f.Target() {
return dfs.Break
}
return dfs.Continue
})
path, err := dfs.Query(f.Source(), f.Target())
if err != nil {
//fmt.Println(err)
break // no more agumenting path can be found
}
augmentingPath = path
}
//fmt.Println(augmentingPath)
// phase 3, generate augmenting flow from augmenting path
augmentingFlow := newAugmentingFlow(rn.residualCapacities, augmentingPath)
// phase 4, current flow - augmenting flow
currFlow.minus(augmentingFlow)
}
return currFlow.value(f.Source())
}
// Dinic algorithm for maximum flow problem
func Dinic(f *flownetwork.FlowNetwork) flownetwork.EdgeFlowUnit {
fmt.Println("Dinic")
//initialize flow
currFlow := newFlow(f)
for {
//currFlow.print()
// phase 1, construct residual network based on original flow network and current flow
rn := calculateResidualNetwork(f, currFlow)
// phase 2, construct level graph from residual network
lg, err := bfs.NewLevelGraph(rn, f.Source(), func(u graph.NodeID) bfs.SearchControlCondition {
if u == f.Target() {
return bfs.Break
}
return bfs.Continue
})
if err != nil {
fmt.Println(err)
break // can not construct a new level graph by BFS
}
ln := newLevelNetwork(lg, rn)
// phase 3, try to find blocking flow on the level graph
// here we use DFS as typical method
blockingFlow := flowStorage{}
for {
dfs, _ := dfs.NewControllableDfs(lg, f.Source(), func(u graph.NodeID) dfs.SearchControlCondition {
if u == f.Target() {
return dfs.Break
}
return dfs.Continue
})
path, err := dfs.Query(f.Source(), f.Target())
if err != nil {
//fmt.Println(err)
break // no more agumenting path can be found
}
augmentingFlow := ln.retrieveAndRemoveFlow(path)
blockingFlow.plus(augmentingFlow)
}
if blockingFlow.empty() {
break // no more blocking flow can be found
}
// phase 4, current flow - augmenting flow (blocking flow)
currFlow.minus(blockingFlow)
}
return currFlow.value(f.Source())
} | maxflow/maxflow.go | 0.632049 | 0.402451 | maxflow.go | starcoder |
package identicon
import (
"image"
"strconv"
)
// Canvas contains what is needed to generate an image. It contains properties
// that could be useful when rendering the image.
// - Having MinY and MaxY allows you to vertically center the figure.
// - VisitedYPoints could be useful to determine whether there is a big empty
// vertical space in the figure.
type Canvas struct {
// Size same value specified in identicon.New(...).
Size int
// PointsMap contains all coordinates and it's values that form the figure.
PointsMap map[int]map[int]int
// MinY is the upper Y-axis that has at least one point drawn.
MinY int
// MaxY is the lower Y-axis that has at least one point drawn.
MaxY int
// VisitedYPoints contains all Y-axis that had been visited. Helpful to
// determine big blank spaces in the resulting figure.
VisitedYPoints map[int]bool
// FilledPoints is the number of points filled at least once.
FilledPoints int
}
// Array generates a two-dimensional array version of the IdentIcon figure.
func (c *Canvas) Array() [][]int {
canvasArray := make([][]int, c.Size)
for i := range canvasArray {
canvasArray[i] = make([]int, c.Size)
}
for y := range c.PointsMap {
for x := range c.PointsMap[y] {
canvasArray[y][x] = c.PointsMap[y][x]
}
}
return canvasArray
}
// ToString generates a string version of the IdentIcon figure.
func (c *Canvas) String(separator string, fillEmptyWith string) string {
tp := c.Size * c.Size
// Total number of characters considering:
strLen := c.Size - 1 // Line Breaks
strLen += (tp - c.Size) * len(separator) // Separators
strLen += c.FilledPoints // Points
strLen += (tp - c.FilledPoints) * len(fillEmptyWith) // Fill Empty
// Concatenating strings with the `+` is slow and uses a lot of memory,
// using `copy` in a slice of bytes has been proved to be a better approach.
bs := make([]byte, strLen)
// Keep track of the length of the bytes array, concatenations will occur
// using `bl` as the right-most index.
bl := 0
for y := 0; y < c.Size; y++ {
if mapY, exists := c.PointsMap[y]; exists {
for x := 0; x < c.Size; x++ {
if value, exists := mapY[x]; exists {
if value > 9 {
value = 9
}
bl += copy(bs[bl:], []byte(strconv.Itoa(value)))
} else {
bl += copy(bs[bl:], []byte(fillEmptyWith))
}
if x < c.Size-1 {
bl += copy(bs[bl:], []byte(separator))
}
}
} else {
// There aren't any values in this row, fill it the row anyway.
for x := 0; x < c.Size; x++ {
bl += copy(bs[bl:], []byte(fillEmptyWith))
if x < c.Size-1 {
bl += copy(bs[bl:], []byte(separator))
}
}
}
if y < c.Size-1 {
// Append a line break except when it's the last line.
bl += copy(bs[bl:], "\n")
}
}
return string(bs)
}
// Points generates an array of points of a two-dimensional plane as [x, y]
// that correspond to all filled points in the IdentIcon figure.
func (c *Canvas) Points() []image.Point {
points := []image.Point{}
for y, value := range c.PointsMap {
for x := range value {
points = append(points, image.Point{X: x, Y: y})
}
}
return points
}
// IntCoordinates generates an array of points of a two-dimensional plane as:
// - [x, y] that correspond to all filled points in the IdentIcon figure.
func (c *Canvas) IntCoordinates() [][]int {
points := [][]int{}
for y, value := range c.PointsMap {
for x := range value {
points = append(points, []int{x, y})
}
}
return points
} | backend/vendor/github.com/nullrocks/identicon/canvas.go | 0.719778 | 0.543893 | canvas.go | starcoder |
package interpreter
import (
"errors"
"github.com/YuriyLisovskiy/borsch-lang/Borsch/builtin/types"
"github.com/YuriyLisovskiy/borsch-lang/Borsch/common"
"github.com/YuriyLisovskiy/borsch-lang/Borsch/util"
)
type Scope map[string]common.Value
func (p *Package) Evaluate(state common.State) (common.Value, error) {
state.GetContext().PushScope(Scope{})
for _, stmt := range p.Stmts {
stmtState := stmt.Evaluate(state, false, false)
if stmtState.Err != nil {
err := stmtState.Err
state.GetInterpreter().Trace(p.Pos, "<пакет>", stmt.String())
return nil, err
}
}
return nil, nil
}
// Evaluate executes block of statements.
// Returns (result value, force stop flag, error)
func (b *BlockStmts) Evaluate(state common.State, inFunction, inLoop bool) StmtResult {
for _, stmt := range b.Stmts {
result := stmt.Evaluate(state, inFunction, inLoop)
if result.Err != nil {
return result
}
switch result.State {
case StmtForceReturn, StmtBreak:
return result
}
}
return StmtResult{Value: types.NewNilInstance()}
}
func (e *Expression) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
if e.LogicalAnd != nil {
return e.LogicalAnd.Evaluate(state, valueToSet)
}
panic("unreachable")
}
func (a *Assignment) Evaluate(state common.State) (common.Value, error) {
if len(a.Next) == 0 {
return a.Expressions[0].Evaluate(state, nil)
}
return unpack(state, a.Expressions, a.Next)
}
// Evaluate executes LogicalAnd operation.
// If `valueToSet` is nil, return variable or value from context,
// set a new value or return an error otherwise.
func (a *LogicalAnd) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.AndOp.Name(), a.LogicalOr, a.Next)
}
func (o *LogicalOr) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.OrOp.Name(), o.LogicalNot, o.Next)
}
func (a *LogicalNot) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
if a.Comparison != nil {
return a.Comparison.Evaluate(state, valueToSet)
}
if a.Next != nil {
value, err := a.Next.Evaluate(state, nil)
if err != nil {
return nil, err
}
opName := common.NotOp.Name()
operatorFunc, err := value.GetOperator(opName)
if err != nil {
return nil, err
}
return types.CallAttribute(state, value, operatorFunc, opName, nil, nil, true)
}
panic("unreachable")
}
func (a *Comparison) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
switch a.Op {
case ">=":
return evalBinaryOperator(state, valueToSet, common.GreaterOrEqualsOp.Name(), a.BitwiseOr, a.Next)
case ">":
return evalBinaryOperator(state, valueToSet, common.GreaterOp.Name(), a.BitwiseOr, a.Next)
case "<=":
return evalBinaryOperator(state, valueToSet, common.LessOrEqualsOp.Name(), a.BitwiseOr, a.Next)
case "<":
return evalBinaryOperator(state, valueToSet, common.LessOp.Name(), a.BitwiseOr, a.Next)
case "==":
return evalBinaryOperator(state, valueToSet, common.EqualsOp.Name(), a.BitwiseOr, a.Next)
case "!=":
return evalBinaryOperator(state, valueToSet, common.NotEqualsOp.Name(), a.BitwiseOr, a.Next)
default:
return a.BitwiseOr.Evaluate(state, valueToSet)
}
}
func (a *BitwiseOr) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.BitwiseOrOp.Name(), a.BitwiseXor, a.Next)
}
func (a *BitwiseXor) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.BitwiseXorOp.Name(), a.BitwiseAnd, a.Next)
}
func (a *BitwiseAnd) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.BitwiseAndOp.Name(), a.BitwiseShift, a.Next)
}
func (a *BitwiseShift) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
switch a.Op {
case "<<":
return evalBinaryOperator(state, valueToSet, common.BitwiseLeftShiftOp.Name(), a.Addition, a.Next)
case ">>":
return evalBinaryOperator(state, valueToSet, common.BitwiseRightShiftOp.Name(), a.Addition, a.Next)
default:
return a.Addition.Evaluate(state, valueToSet)
}
}
func (a *Addition) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
switch a.Op {
case "+":
return evalBinaryOperator(state, valueToSet, common.AddOp.Name(), a.MultiplicationOrMod, a.Next)
case "-":
return evalBinaryOperator(state, valueToSet, common.SubOp.Name(), a.MultiplicationOrMod, a.Next)
default:
return a.MultiplicationOrMod.Evaluate(state, valueToSet)
}
}
func (a *MultiplicationOrMod) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
switch a.Op {
case "/":
return evalBinaryOperator(state, valueToSet, common.DivOp.Name(), a.Unary, a.Next)
case "*":
return evalBinaryOperator(state, valueToSet, common.MulOp.Name(), a.Unary, a.Next)
case "%":
return evalBinaryOperator(state, valueToSet, common.ModuloOp.Name(), a.Unary, a.Next)
default:
return a.Unary.Evaluate(state, valueToSet)
}
}
func (a *Unary) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
switch a.Op {
case "+":
return evalUnaryOperator(state, common.UnaryPlus.Name(), a.Next)
case "-":
return evalUnaryOperator(state, common.UnaryMinus.Name(), a.Next)
case "~":
return evalUnaryOperator(state, common.UnaryBitwiseNotOp.Name(), a.Next)
default:
return a.Exponent.Evaluate(state, valueToSet)
}
}
func (a *Exponent) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
return evalBinaryOperator(state, valueToSet, common.PowOp.Name(), a.Primary, a.Next)
}
func (a *Primary) Evaluate(state common.State, valueToSet common.Value) (common.Value, error) {
if a.SubExpression != nil {
if valueToSet != nil {
// TODO: change to normal description
return nil, errors.New("unable to set to subexpression evaluation")
}
return a.SubExpression.Evaluate(state, valueToSet)
}
if a.Constant != nil {
if valueToSet != nil {
// TODO: change to normal description
return nil, errors.New("unable to set to constant")
}
return a.Constant.Evaluate(state)
}
if a.AttributeAccess != nil {
return a.AttributeAccess.Evaluate(state, valueToSet, nil)
}
if a.LambdaDef != nil {
return a.LambdaDef.Evaluate(state)
}
panic("unreachable")
}
func (c *Constant) Evaluate(state common.State) (common.Value, error) {
if c.Integer != nil {
return types.NewIntegerInstance(*c.Integer), nil
}
if c.Real != nil {
return types.NewRealInstance(*c.Real), nil
}
if c.Bool != nil {
return types.NewBoolInstance(bool(*c.Bool)), nil
}
if c.StringValue != nil {
return types.NewStringInstance(*c.StringValue), nil
}
if c.List != nil {
list := types.NewListInstance()
for _, expr := range c.List {
value, err := expr.Evaluate(state, nil)
if err != nil {
return nil, err
}
list.Values = append(list.Values, value)
}
return list, nil
}
if c.EmptyList {
return types.NewListInstance(), nil
}
if c.Dictionary != nil {
dict := types.NewDictionaryInstance()
for _, entry := range c.Dictionary {
key, value, err := entry.Evaluate(state)
if err != nil {
return nil, err
}
if err := dict.SetElement(key, value); err != nil {
return nil, err
}
}
return dict, nil
}
if c.EmptyDictionary {
return types.NewDictionaryInstance(), nil
}
panic("unreachable")
}
func (d *DictionaryEntry) Evaluate(state common.State) (common.Value, common.Value, error) {
key, err := d.Key.Evaluate(state, nil)
if err != nil {
return nil, nil, err
}
value, err := d.Value.Evaluate(state, nil)
if err != nil {
return nil, nil, err
}
return key, value, nil
}
func (a *AttributeAccess) Evaluate(state common.State, valueToSet, prevValue common.Value) (common.Value, error) {
if a.SlicingOrSubscription == nil {
panic("unreachable")
}
if valueToSet != nil {
// set
var currentValue common.Value
var err error
if a.AttributeAccess != nil {
currentValue, err = a.SlicingOrSubscription.Evaluate(state, nil, prevValue)
if err != nil {
return nil, err
}
currentValue, err = a.AttributeAccess.Evaluate(state, valueToSet, currentValue)
} else {
currentValue, err = a.SlicingOrSubscription.Evaluate(state, valueToSet, prevValue)
}
if err != nil {
return nil, err
}
return currentValue, nil
}
// get
currentValue, err := a.SlicingOrSubscription.Evaluate(state, valueToSet, prevValue)
if err != nil {
return nil, err
}
if a.AttributeAccess != nil {
return a.AttributeAccess.Evaluate(state, valueToSet, currentValue)
}
return currentValue, err
}
func (s *SlicingOrSubscription) Evaluate(
state common.State,
valueToSet common.Value,
prevValue common.Value,
) (common.Value, error) {
if valueToSet != nil {
// set
var variable common.Value
var err error = nil
rangesLen := len(s.Ranges)
if rangesLen != 0 && s.Ranges[rangesLen-1].RightBound != nil {
return nil, util.RuntimeError("неможливо присвоїти значення зрізу")
}
if s.Call != nil {
if len(s.Ranges) == 0 {
return nil, util.RuntimeError("неможливо присвоїти значення виклику функції")
}
variable, err = s.callFunction(state, prevValue)
if err != nil {
return nil, err
}
} else if s.Ident != nil {
if len(s.Ranges) != 0 {
variable, err = getCurrentValue(state.GetContext(), prevValue, *s.Ident)
} else {
variable, err = setCurrentValue(state.GetContext(), prevValue, *s.Ident, valueToSet)
}
if err != nil {
return nil, err
}
} else {
panic("unreachable")
}
if len(s.Ranges) != 0 {
return evalSlicingOperation(state, variable, s.Ranges, valueToSet)
}
return variable, nil
}
// get
var variable common.Value
var err error = nil
if s.Call != nil {
variable, err = s.callFunction(state, prevValue)
if err != nil {
return nil, err
}
} else if s.Ident != nil {
variable, err = getCurrentValue(state.GetContext(), prevValue, *s.Ident)
if err != nil {
return nil, err
}
} else {
panic("unreachable")
}
if len(s.Ranges) != 0 {
return evalSlicingOperation(state, variable, s.Ranges, nil)
}
return variable, nil
}
func (s *SlicingOrSubscription) callFunction(state common.State, prevValue common.Value) (common.Value, error) {
ctx := state.GetContext()
variable, err := getCurrentValue(ctx, prevValue, s.Call.Ident)
if err != nil {
return nil, err
}
isLambda := false
variable, err = s.Call.Evaluate(state, variable, prevValue, &isLambda)
if err != nil {
funcName := s.Call.Ident
if isLambda {
funcName = common.LambdaSignature
}
state.GetInterpreter().Trace(s.Call.Pos, funcName, s.Call.String())
return nil, err
}
return variable, nil
}
func (l *LambdaDef) Evaluate(state common.State) (common.Value, error) {
arguments, err := l.ParametersSet.Evaluate(state)
if err != nil {
return nil, err
}
returnTypes, err := evalReturnTypes(state, l.ReturnTypes)
if err != nil {
return nil, err
}
lambda := types.NewFunctionInstance(
common.LambdaSignature,
arguments,
func(state common.State, _ *[]common.Value, kwargs *map[string]common.Value) (common.Value, error) {
return l.Body.Evaluate(state)
},
returnTypes,
false,
state.GetCurrentPackage().(*types.PackageInstance),
"", // TODO: add doc
)
if l.InstantCall {
return l.evalInstantCall(state, lambda)
}
return lambda, nil
}
func (l *LambdaDef) evalInstantCall(state common.State, function *types.FunctionInstance) (common.Value, error) {
var args []common.Value
if len(l.InstantCallArguments) != 0 {
if err := updateArgs(state, l.InstantCallArguments, &args); err != nil {
return nil, err
}
}
return types.Call(state, function, &args, nil)
} | Borsch/interpreter/eval.go | 0.717111 | 0.486088 | eval.go | starcoder |
package chess
import (
"fmt"
)
// RANKS defines the number of rows on the board
// FILES defines the number of columns on the board
const (
RANKS int = 8
FILES int = 8
)
const (
initWhiteRooks = Bitboard(0x0000000000000081)
initWhiteKnights = Bitboard(0x0000000000000042)
initWhiteBishops = Bitboard(0x0000000000000024)
initWhiteQueen = Bitboard(0x0000000000000008)
initWhiteKing = Bitboard(0x0000000000000010)
initWhitePawns = Bitboard(0x000000000000ff00)
initBlackRooks = Bitboard(0x8100000000000000)
initBlackKnights = Bitboard(0x4200000000000000)
initBlackBishops = Bitboard(0x2400000000000000)
initBlackQueen = Bitboard(0x0800000000000000)
initBlackKing = Bitboard(0x1000000000000000)
initBlackPawns = Bitboard(0x00ff000000000000)
)
// Board is a type of piece-centric representation of a chess board referred to a Bitboard.
// For more information see: https://www.chessprogramming.org/Bitboards
type Board struct {
Positions []Bitboard
Pieces []Piece
Occupied Bitboard // Union of all piece positions gives current occupied squares
}
// NewBoard returns a new instance of the chess board or optionally copies an existing board
// by initializing with a copy of the requested board positions
func NewBoard(positions ...Bitboard) (*Board, error) {
board := Board{Pieces: Pieces}
if len(positions) > 0 && len(positions) != len(board.Pieces) {
err := fmt.Errorf(
"Unable to determine board position, expecting %d bitboards, received %d",
len(board.Pieces), len(positions),
)
return nil, err
} else if len(positions) > 0 {
board.Positions = make([]Bitboard, len(positions))
copy(board.Positions, positions)
} else {
board.Positions = []Bitboard{
initWhiteRooks, initWhiteKnights, initWhiteBishops, initWhiteQueen, initWhiteKing, initWhitePawns,
initBlackRooks, initBlackKnights, initBlackBishops, initBlackQueen, initBlackKing, initBlackPawns,
}
}
board.Occupied = Union(board.Positions...)
return &board, nil
}
// GetSquare gives whether a square is occupied and if so by which piece for a given index 0-63
func (b Board) GetSquare(index int) (bool, *Piece) {
if b.Occupied.GetBit(index) != 0 { // If 0, this square is unoccupied
for i := 0; i < len(b.Positions); i++ {
if b.Positions[i].GetBit(index) != 0 {
return true, &b.Pieces[i]
}
}
}
return false, nil
}
// String displays the current board a simple console-friendly unicode grid
func (b *Board) String() string {
s := "A B C D E F G H\n"
for rank := int(RANKS - 1); rank >= 0; rank-- {
s += fmt.Sprintf("%d", rank+1)
for file := 0; file < FILES; file++ {
index := (rank * FILES) + file
if occupied, piece := b.GetSquare(index); occupied {
s += piece.Unicode()
} else {
s += "-"
}
s += " "
}
s += "\n"
}
return s
}
/******************************************************************************
* Place, Remove, and Move Pieces
******************************************************************************/
// PlacePiece marks the provided position index (0-63) as occupied on the bitboard
// defined by the piece index (i.e. Board.Position[int]) for this board
func (b *Board) PlacePiece(piece, position int) {
b.Positions[piece].SetBit(position)
b.Occupied.SetBit(position)
}
// RemovePiece marks the provided position index (0-63) as unoccupied on the
// bitboard defined by the piece index (i.e. Board.Position[int]) for this board
func (b *Board) RemovePiece(piece, position int) {
b.Positions[piece].ClearBit(position)
b.Occupied.ClearBit(position)
}
// MovePiece updates the bitboard specified at the given piece index to simulate
// a piece having moved (i.e. clears the bit at the first given index and sets the bit
// at the second given index)
func (b *Board) MovePiece(piece, from, to int) {
b.RemovePiece(piece, from)
b.PlacePiece(piece, to)
}
// PlacePieceAlgebraic updates the bitboard specified at the given piece index to
// simulate placing a piece using the letters a through h to mark files and 1
// through 8 to mark ranks
func (b *Board) PlacePieceAlgebraic(piece int, position string) {
b.PlacePiece(piece, AlgebraicToBit(position))
}
// RemovePieceAlgebraic updates the bitboard specified at the given piece index to
// simulate removing a piece from the positions given using the letters a
// through h to mark files and 1 through 8 to mark ranks
func (b *Board) RemovePieceAlgebraic(piece int, position string) {
b.RemovePiece(piece, AlgebraicToBit(position))
}
// MovePieceAlgebraic updates the bitboard specified at the given piece index to
// simulate moving a piece from and to the speicified positions given using the letters a
// through h to mark files and 1 through 8 to mark ranks
func (b *Board) MovePieceAlgebraic(piece int, from, to string) {
b.RemovePieceAlgebraic(piece, from)
b.PlacePieceAlgebraic(piece, to)
}
// PlacePieceCartesian updates the bitboard specified at the given piece index to
// simulate placing a piece at the position given using x and y coordinates 0 through 7
func (b *Board) PlacePieceCartesian(piece, x, y int) {
b.PlacePiece(piece, CartesianToBit(x, y))
}
// RemovePieceCartesian updates the bitboard specified at the given piece index to
// simulate removing a piece at the position given using x and y coordinates 0 through 7
func (b *Board) RemovePieceCartesian(piece, x, y int) {
b.RemovePiece(piece, CartesianToBit(x, y))
}
// MovePieceCartesian updates the bitboard at the given piece index to
// simulate moving a piece from and to the positions given using x and y coordnidates 0 through 7
func (b *Board) MovePieceCartesian(piece, fromX, fromY, toX, toY int) {
b.RemovePiece(piece, CartesianToBit(fromX, fromY))
b.PlacePiece(piece, CartesianToBit(toX, toY))
} | pkg/chess/board.go | 0.750827 | 0.438905 | board.go | starcoder |
package golorp
import (
"fmt"
"github.com/tcolgate/golorp/term"
)
// Cell implements an interface for items that can be stored on the heap
type Cell interface {
IsCell()
fmt.Stringer
}
type CellPtr struct {
Store *[]Cell
Offset int
}
func (c CellPtr) Cell() Cell {
return (*c.Store)[c.Offset]
}
func (c CellPtr) IsSelf() bool {
if r, ok := c.Cell().(RefCell); ok {
return r.Ptr.Store == c.Store && r.Ptr.Offset == c.Offset
}
return false
}
func (cp CellPtr) String() string {
return fmt.Sprintf("PTR %v:%d", cp.Store, cp.Offset)
}
func (cp CellPtr) Deref() Cell {
return (*cp.Store)[cp.Offset]
}
// RefCell is a a heap cell containing a reference to another cell
type RefCell struct {
Ptr CellPtr
}
// IsCell marks RefCell as a valid heap Cell
func (RefCell) IsCell() {
}
func (c RefCell) String() string {
return fmt.Sprintf("REF %p:%d", c.Ptr.Store, c.Ptr.Offset)
}
// StrCell is a structure header cell
type StrCell struct {
Ptr CellPtr
}
// IsCell marks StrCell as a valid heap Cell
func (StrCell) IsCell() {
}
func (c StrCell) String() string {
return fmt.Sprintf("STR %p:%d", c.Ptr.Store, c.Ptr.Offset)
}
// FuncCell is not tagged in WAM-Book, but we need a type
type FuncCell struct {
Atom term.Atom
n int
}
// IsCell marks FuncCell as a valid heap Cell
func (FuncCell) IsCell() {
}
func (c FuncCell) String() string {
return fmt.Sprintf("%s/%d", c.Atom, c.n)
}
// HeapCells is a utility type to format a slice of
// cells as a heap
type HeapCells []Cell
func (cs HeapCells) String() string {
str := ""
for i, c := range cs {
str += fmt.Sprintf("%d %s\n", i, c)
}
return str
}
// RegCells is a utility type to format a slice of
// cells as a X registers
type RegCells []Cell
func (cs RegCells) String() string {
str := ""
for i, c := range cs {
str += fmt.Sprintf("X%d = %s\n", i, c)
}
return str
}
type PDL struct {
cells []CellPtr
}
func (p *PDL) isEmpty() bool {
if len(p.cells) > 0 {
return false
}
return true
}
func (p *PDL) push(a CellPtr) {
p.cells = append(p.cells, a)
}
func (p *PDL) pop() CellPtr {
a := p.cells[len(p.cells)-1]
p.cells = p.cells[:len(p.cells)-1]
return a
}
type CellStore struct {
Name string
Cells []Cell
}
// Machine hods the state of our WAM
type Machine struct {
// We use to stop on failure
Finished bool
Failed bool
// M0
Heap []Cell
XRegisters []Cell
Mode InstructionMode
HReg int
SReg int
PDL PDL
// M1
Code []Cell
Labels map[string]int
PReg int
// M2
AndStack []Environment
EReg int
CPReg int
// M3 - Prolog
OrStack []ChoicePoint
Trail []Cell
BReg int
TRReg int
GBReg int
// Optimisations
}
func NewMachine() *Machine {
return &Machine{
Heap: make([]Cell, 30),
XRegisters: make([]Cell, 10),
PDL: PDL{[]CellPtr{}},
}
}
func (m *Machine) String() string {
str := fmt.Sprintf("Finished %v Failed: %v\n\n", m.Finished, m.Failed)
str += fmt.Sprintf("H: %d S: %d\n", m.HReg, m.SReg)
str += fmt.Sprintf("Mode %v\n", m.Mode)
str += "X Registers:\n"
str += fmt.Sprintf("%s\n", RegCells(m.XRegisters))
str += "Heap:\n"
str += fmt.Sprintf("%s\n", HeapCells(m.Heap))
return str
}
type Environment Cell
type ChoicePoint Cell
type Instruction int
type InstructionMode int
const (
InvalidMode InstructionMode = iota // zero value not sure
Read
Write
)
type machineFunc func(*Machine) (machineFunc, string)
type CodeCell struct {
fn machineFunc
string
}
type CodeCells []CodeCell
func (cs CodeCells) String() string {
str := ""
for _, i := range cs {
str += fmt.Sprintf("%s\n", i.string)
}
return str
}
func (m *Machine) run(cs []CodeCell) {
for _, c := range cs {
fmt.Printf("%s\n", c.string)
c.fn(m)
if m.Finished {
return
}
}
m.Finished = true
}
// I0 - M0 insutrctions for L0
func PutStructure(fn term.Atom, n, xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.Heap[m.HReg] = StrCell{CellPtr{&m.Heap, m.HReg + 1}}
m.Heap[m.HReg+1] = FuncCell{fn, n}
m.XRegisters[xi] = m.Heap[m.HReg]
m.HReg = m.HReg + 2
return nil, ""
}, fmt.Sprintf("put_structure %s/%d X%d", fn, n, xi)
}
func SetVariable(xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.Heap[m.HReg] = RefCell{CellPtr{&m.Heap, m.HReg}}
m.XRegisters[xi] = m.Heap[m.HReg]
m.HReg = m.HReg + 1
return nil, ""
}, fmt.Sprintf("set_variable X%d", xi)
}
func SetValue(xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.Heap[m.HReg] = m.XRegisters[xi]
m.HReg = m.HReg + 1
return nil, ""
}, fmt.Sprintf("set_value X%d", xi)
}
func GetStructure(fn term.Atom, n, xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
cp := m.derefReg(xi)
cc := cp.Deref()
switch c := cc.(type) {
case RefCell:
m.Heap[m.HReg] = StrCell{CellPtr{&m.Heap, m.HReg + 1}}
m.Heap[m.HReg+1] = FuncCell{fn, n}
m.XRegisters[xi] = m.Heap[m.HReg]
m.bind(cp, CellPtr{&m.Heap, m.HReg})
m.HReg = m.HReg + 2
m.Mode = Write
fmt.Printf("IN HERE 0 %#v\n", cp.Deref())
case StrCell:
if tc, ok := m.Heap[c.Ptr.Offset].(FuncCell); ok && tc.Atom == fn && tc.n == n {
fmt.Printf("IN HERE 1 %v %v %v\n", ok, tc, fn)
m.SReg = c.Ptr.Offset + 1
m.Mode = Read
} else {
fmt.Printf("IN HERE 2 %v %v %v\n", ok, tc, fn)
m.Finished = true
m.Failed = true
}
default:
fmt.Printf("IN HERE 3 %#v\n", c)
m.Finished = true
m.Failed = true
}
return nil, ""
}, fmt.Sprintf("get_structure %s/%d X%d", fn, n, xi)
}
func UnifyVariable(xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
switch m.Mode {
case Read:
m.XRegisters[xi] = m.Heap[m.SReg]
case Write:
m.Heap[m.HReg] = RefCell{CellPtr{&m.Heap, m.HReg}}
m.XRegisters[xi] = m.Heap[m.HReg]
m.HReg = m.HReg + 1
default:
panic(fmt.Errorf("invalid read/write mode %v", m.Mode))
}
m.SReg = m.SReg + 1
return nil, ""
}, fmt.Sprintf("unify_variable X%d", xi)
}
func UnifyValue(xi int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
switch m.Mode {
case Read:
m.unify(CellPtr{&m.XRegisters, xi}, CellPtr{&m.Heap, m.SReg})
case Write:
m.Heap[m.HReg] = m.XRegisters[xi]
m.HReg = m.HReg + 1
default:
panic(fmt.Errorf("invalid read/write mode %v", m.Mode))
}
m.SReg = m.SReg + 1
return nil, ""
}, fmt.Sprintf("unify_value X%d", xi)
}
func (m *Machine) derefReg(xi int) CellPtr {
switch c := m.XRegisters[xi].(type) {
case RefCell:
return m.deref(c.Ptr)
default:
return CellPtr{&m.XRegisters, xi}
}
}
func (m *Machine) deref(p CellPtr) CellPtr {
for {
switch c := (*p.Store)[p.Offset].(type) {
case RefCell:
if c.Ptr == p { // Ref Cell points to itself, unbound
return p
}
p = c.Ptr
default:
return p
}
}
}
func (m *Machine) bind(a, b CellPtr) {
fmt.Printf("HEAP: %p\n", &m.Heap)
fmt.Printf("XReg: %p\n", &m.XRegisters)
fmt.Printf("PDL: %p\n", &m.PDL)
fmt.Printf("BIND: %#v %#v\n", a, b)
_, ok1 := (*a.Store)[a.Offset].(RefCell)
_, ok2 := (*b.Store)[b.Offset].(RefCell)
fmt.Printf("C1: %#v\n", (*a.Store)[a.Offset])
fmt.Printf("C2: %#v\n", (*b.Store)[b.Offset])
switch {
case ok1 && ok2:
fmt.Print("arbitrarily bind a to b\n")
(*a.Store)[a.Offset] = (*b.Store)[b.Offset]
case ok1:
fmt.Print("bind a to b\n")
(*a.Store)[a.Offset] = (*b.Store)[b.Offset]
case ok2:
fmt.Print("bind b to a\n")
(*b.Store)[b.Offset] = (*a.Store)[a.Offset]
default:
panic("didn't manage to fix-up bind")
}
}
func (m *Machine) unify(a1, a2 CellPtr) {
m.PDL.push(a1)
m.PDL.push(a2)
for !(m.PDL.isEmpty() || m.Failed) {
p1 := m.deref(m.PDL.pop())
d1 := (*p1.Store)[p1.Offset]
p2 := m.deref(m.PDL.pop())
d2 := (*p2.Store)[p2.Offset]
if d1 != d2 {
_, ok1 := d1.(RefCell)
_, ok2 := d2.(RefCell)
if ok1 || ok2 {
m.bind(p1, p2)
} else {
v1, ok1 := d1.(StrCell)
v2, ok2 := d2.(StrCell)
if !(ok1 && ok2) {
panic("Wrong cell type")
}
f1, ok1 := v1.Ptr.Cell().(FuncCell)
f2, ok2 := v2.Ptr.Cell().(FuncCell)
if !(ok1 && ok2) {
panic("Wrong cell type")
}
if f1.Atom == f2.Atom && f1.n == f2.n {
for i := 0; i < f1.n; i++ {
m.PDL.push(CellPtr{v1.Ptr.Store, v1.Ptr.Offset + i})
m.PDL.push(CellPtr{v2.Ptr.Store, v1.Ptr.Offset + i})
}
} else {
m.Failed = true
}
}
}
}
}
func Call(fn term.Atom) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
loc, ok := m.Labels[fn.String()]
if !ok {
panic(fmt.Errorf("call to unknown label, %s", fn.String()))
}
m.PReg = loc
return nil, ""
}, fmt.Sprintf("call")
}
func Proceeed() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("proceed")
}
func PutVariable(xn, ai int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.Heap[m.HReg] = RefCell{CellPtr{&m.Heap, m.HReg}}
m.XRegisters[xn] = m.Heap[m.HReg]
m.XRegisters[ai] = m.Heap[m.HReg]
m.HReg = m.HReg + 1
return nil, ""
}, fmt.Sprintf("put_variable X%d, A%d", xn, ai)
}
func PutValue(xn, ai int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.XRegisters[ai] = m.XRegisters[xn]
return nil, ""
}, fmt.Sprintf("put_value X%d, A%d", xn, ai)
}
func GetVariable(xn, ai int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.XRegisters[xn] = m.XRegisters[ai]
return nil, ""
}, fmt.Sprintf("get_variable X%d, A%d", xn, ai)
}
func GetValue(xn, ai int) (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
m.unify(CellPtr{&m.XRegisters, xn}, CellPtr{&m.XRegisters, ai})
return nil, ""
}, fmt.Sprintf("get_value X%d, A%d", xn, ai)
}
// L2
func Allocate() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("allocate")
}
func Deallocate() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("deallocate")
}
// L3 - Prolog
func TryMeElse() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("try_me_else")
}
func RetryMeElse() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("retry_me_else")
}
func TrustMe() (machineFunc, string) {
return func(m *Machine) (machineFunc, string) {
return nil, ""
}, fmt.Sprintf("trust_me")
}
// Optimisations | machine.go | 0.664649 | 0.430866 | machine.go | starcoder |
package dst
// Dirichlet distribution. It is the multivariate generalization of the beta distribution.
// Parameters:
// αi > 0 concentration parameters
// Support:
// θi ∈ [0, 1] and Σθi = 1
// DirichletPDF returns the PDF of the Dirichlet distribution.
func DirichletPDF(α []float64) func(θ []float64) float64 {
return func(θ []float64) float64 {
k := len(α)
if len(θ) != k {
return 0
}
l := float64(1.0)
totalα := float64(0)
for i := 0; i < k; i++ {
if θ[i] < 0 || θ[i] > 1 {
return 0
}
l *= pow(θ[i], α[i]-1)
l /= Γ(α[i])
totalα += α[i]
}
l *= Γ(totalα)
return l
}
}
// DirichletLnPDF returns the natural logarithm of the PDF of the Dirichlet distribution.
func DirichletLnPDF(α []float64) func(x []float64) float64 {
return func(x []float64) float64 {
k := len(α)
if len(x) != k {
return negInf
}
l := fZero
totalα := float64(0)
for i := 0; i < k; i++ {
if x[i] < 0 || x[i] > 1 {
return negInf
}
l += (α[i] - 1) * log(x[i])
l -= LnΓ(α[i])
totalα += α[i]
}
l += LnΓ(totalα)
return l
}
}
// DirichletPDFAt returns the value of PDF of Dirichlet distribution at x.
func DirichletPDFAt(α, θ []float64) float64 {
pdf := DirichletPDF(α)
return pdf(θ)
}
// DirichletNext returns random number drawn from the Dirichlet distribution.
func DirichletNext(α []float64) []float64 {
k := len(α)
x := make([]float64, k)
sum := fZero
for i := 0; i < len(α); i++ {
x[i] = GammaNext(α[i], 1.0)
sum += x[i]
}
for i := 0; i < len(α); i++ {
x[i] /= sum
}
return x
}
// Dirichlet returns the random number generator with Dirichlet distribution.
func Dirichlet(α []float64) func() []float64 {
return func() []float64 { return DirichletNext(α) }
}
// DirichletMean returns the mean of the Dirichlet distribution.
func DirichletMean(α []float64) []float64 {
k := len(α)
x := make([]float64, k)
sum := fZero
for i := 0; i < k; i++ {
sum += α[i]
}
for i := 0; i < k; i++ {
x[i] = α[i] / sum
}
return x
}
// DirichletMode returns the mode of the Dirichlet distribution.
func DirichletMode(α []float64) []float64 {
k := len(α)
x := make([]float64, k)
sum := fZero
for i := 0; i < k; i++ {
if α[i] <= 1 { // REVISION and citation NEEDED!
panic("mode not defined")
}
sum += α[i]
}
for i := 0; i < k; i++ {
x[i] = (α[i] - 1) / (sum - float64(k))
}
return x
}
// DirichletVar returns the variance of the Dirichlet distribution.
func DirichletVar(α []float64) []float64 {
k := len(α)
x := make([]float64, k)
sum := fZero
for i := 0; i < k; i++ {
sum += α[i]
}
for i := 0; i < k; i++ {
x[i] = (α[i] * (sum - α[i])) / (sum * sum * (sum + 1))
}
return x
} | dst/dirichlet.go | 0.791338 | 0.468 | dirichlet.go | starcoder |
package chaincfg
import (
"math/big"
"strings"
chainhash "git.parallelcoin.io/dev/pod/pkg/chain/hash"
)
// String returns the hostname of the DNS seed in human-readable form.
func (d DNSSeed) String() string {
return d.Host
}
// Register registers the network parameters for a Bitcoin network. This may error with ErrDuplicateNet if the network is already registered (either due to a previous Register call, or the network being one of the default networks). Network parameters should be registered into this package by a main package as early as possible. Then, library packages may lookup networks or network parameters based on inputs and work regardless of the network being standard or not.
func Register(
params *Params) error {
if _, ok := registeredNets[params.Net]; ok {
return ErrDuplicateNet
}
registeredNets[params.Net] = struct{}{}
pubKeyHashAddrIDs[params.PubKeyHashAddrID] = struct{}{}
scriptHashAddrIDs[params.ScriptHashAddrID] = struct{}{}
hdPrivToPubKeyIDs[params.HDPrivateKeyID] = params.HDPublicKeyID[:]
// A valid Bech32 encoded segwit address always has as prefix the human-readable part for the given net followed by '1'.
bech32SegwitPrefixes[params.Bech32HRPSegwit+"1"] = struct{}{}
return nil
}
// mustRegister performs the same function as Register except it panics if there is an error. This should only be called from package init functions.
func mustRegister(
params *Params) {
if err := Register(params); err != nil {
panic("failed to register network: " + err.Error())
}
}
// IsPubKeyHashAddrID returns whether the id is an identifier known to prefix a pay-to-pubkey-hash address on any default or registered network. This is used when decoding an address string into a specific address type. It is up to the caller to check both this and IsScriptHashAddrID and decide whether an address is a pubkey hash address, script hash address, neither, or undeterminable (if both return true).
func IsPubKeyHashAddrID(
id byte) bool {
_, ok := pubKeyHashAddrIDs[id]
return ok
}
// IsScriptHashAddrID returns whether the id is an identifier known to prefix a pay-to-script-hash address on any default or registered network. This is used when decoding an address string into a specific address type. It is up to the caller to check both this and IsPubKeyHashAddrID and decide whether an address is a pubkey hash address, script hash address, neither, or undeterminable (if both return true).
func IsScriptHashAddrID(
id byte) bool {
_, ok := scriptHashAddrIDs[id]
return ok
}
// IsBech32SegwitPrefix returns whether the prefix is a known prefix for segwit addresses on any default or registered network. This is used when decoding an address string into a specific address type.
func IsBech32SegwitPrefix(
prefix string) bool {
prefix = strings.ToLower(prefix)
_, ok := bech32SegwitPrefixes[prefix]
return ok
}
// HDPrivateKeyToPublicKeyID accepts a private hierarchical deterministic extended key id and returns the associated public key id. When the provided id is not registered, the ErrUnknownHDKeyID error will be returned.
func HDPrivateKeyToPublicKeyID(
id []byte) ([]byte, error) {
if len(id) != 4 {
return nil, ErrUnknownHDKeyID
}
var key [4]byte
copy(key[:], id)
pubBytes, ok := hdPrivToPubKeyIDs[key]
if !ok {
return nil, ErrUnknownHDKeyID
}
return pubBytes, nil
}
// newHashFromStr converts the passed big-endian hex string into a chainhash.Hash. It only differs from the one available in chainhash in that it panics on an error since it will only (and must only) be called with hard-coded, and therefore known good, hashes.
func newHashFromStr(
hexStr string) *chainhash.Hash {
hash, err := chainhash.NewHashFromStr(hexStr)
if err != nil {
// Ordinarily I don't like panics in library code since it can take applications down without them having a chance to recover which is extremely annoying, however an exception is being made in this case because the only way this can panic is if there is an error in the hard-coded hashes. Thus it will only ever potentially panic on init and therefore is 100% predictable.
// loki: Panics are good when the condition should not happen!
panic(err)
}
return hash
}
func init() {
// Register all default networks when the package is initialized.
mustRegister(&MainNetParams)
mustRegister(&TestNet3Params)
mustRegister(&RegressionNetParams)
mustRegister(&SimNetParams)
}
// CompactToBig converts a compact representation of a whole number N to an unsigned 32-bit number. The representation is similar to IEEE754 floating point numbers. Like IEEE754 floating point, there are three basic components: the sign, the exponent, and the mantissa. They are broken out as follows:
// * the most significant 8 bits represent the unsigned base 256 exponent
// * bit 23 (the 24th bit) represents the sign bit
// * the least significant 23 bits represent the mantissa
// -------------------------------------------------
// | Exponent | Sign | Mantissa |
// -------------------------------------------------
// | 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] |
// -------------------------------------------------
// The formula to calculate N is:
// N = (-1^sign) * mantissa * 256^(exponent-3)
// This compact form is only used in bitcoin to encode unsigned 256-bit numbers which represent difficulty targets, thus there really is not a need for a sign bit, but it is implemented here to stay consistent with bitcoind.
func CompactToBig(
compact uint32) *big.Int {
// Extract the mantissa, sign bit, and exponent.
mantissa := compact & 0x007fffff
isNegative := compact&0x00800000 != 0
exponent := uint(compact >> 24)
// Since the base for the exponent is 256, the exponent can be treated as the number of bytes to represent the full 256-bit number. So, treat the exponent as the number of bytes and shift the mantissa right or left accordingly. This is equivalent to: N = mantissa * 256^(exponent-3)
var bn *big.Int
if exponent <= 3 {
mantissa >>= 8 * (3 - exponent)
bn = big.NewInt(int64(mantissa))
} else {
bn = big.NewInt(int64(mantissa))
bn.Lsh(bn, 8*(exponent-3))
}
// Make it negative if the sign bit is set.
if isNegative {
bn = bn.Neg(bn)
}
return bn
}
// BigToCompact converts a whole number N to a compact representation using an unsigned 32-bit number. The compact representation only provides 23 bits of precision, so values larger than (2^23 - 1) only encode the most significant digits of the number. See CompactToBig for details.
func BigToCompact(
n *big.Int) uint32 {
// No need to do any work if it's zero.
if n.Sign() == 0 {
return 0
}
// Since the base for the exponent is 256, the exponent can be treated as the number of bytes. So, shift the number right or left accordingly. This is equivalent to: mantissa = mantissa / 256^(exponent-3)
var mantissa uint32
exponent := uint(len(n.Bytes()))
if exponent <= 3 {
mantissa = uint32(n.Bits()[0])
mantissa <<= 8 * (3 - exponent)
} else {
// Use a copy to avoid modifying the caller's original number.
tn := new(big.Int).Set(n)
mantissa = uint32(tn.Rsh(tn, 8*(exponent-3)).Bits()[0])
}
// When the mantissa already has the sign bit set, the number is too large to fit into the available 23-bits, so divide the number by 256 and increment the exponent accordingly.
if mantissa&0x00800000 != 0 {
mantissa >>= 8
exponent++
}
// Pack the exponent, sign bit, and mantissa into an unsigned 32-bit int and return it.
compact := uint32(exponent<<24) | mantissa
if n.Sign() < 0 {
compact |= 0x00800000
}
return compact
} | pkg/chain/config/params.go | 0.836521 | 0.53437 | params.go | starcoder |
package fpdf
import (
"fmt"
"github.com/jung-kurt/gofpdf"
)
// Describes a grid we're going to plot ov`er, and the location of its top-left corner in PDF space
type BaseGrid struct {
*gofpdf.Fpdf // Embed the thing we're writing to
// Describe the portion of PDF page space the grid will be drawn over (labels go outside of this)
OffsetU float64 // where the origin (top-right) should be, in PDF coords (top-right)
OffsetV float64 // where the origin (top-right) should be, in PDF coords (top-right)
W,H float64 // width and height of the grid, in PDF units (should be mm)
// Control how (x,y) vals are mapped into (u,v) vals
InvertX,InvertY bool // A grid's origin defaults to bottom-left; these bools flip that
MinX,MinY,MaxX,MaxY float64 // the range of values that should be scaled onto the grid.
Clip bool // whether to clip lines to fit inside grid
// How to draw gridlines
NoGridlines bool // No lines at all for this graph
XGridlineEvery, YGridlineEvery float64 // From Min[XY] to Max[XY]
XMinorGridlineEvery, YMinorGridlineEvery float64 // From Min[XY] to Max[XY]
XTickFmt, YTickFmt string // Will be passed a float64 via fmt.Sprintf; blank==none
XTickOtherSide, YTickOtherSide bool // Note that InvertX,Y also affect where ticks go
XOriginTickFmt, YOriginTickFmt string // Tick formats for the zero origin label
// Other formatting
LineColor []int // rgb, each [0,255] - axis labels
}
// {{{ bg.U, V, UV
// the bools are whether the coords are out-of-bounds for the grid.
func (bg BaseGrid)U(x float64) (float64, bool) {
// Scale the X value to [0.0, 1.0], then map into PDF coords
xRatio := (x - bg.MinX) / (bg.MaxX - bg.MinX)
if bg.InvertX { xRatio = 1.0 - xRatio }
u := bg.OffsetU + (xRatio * bg.W)
outOfBounds := xRatio<0 || xRatio>1
return u,outOfBounds
}
// the bool is whether the coords are out-of-bounds for the grid.
func (bg BaseGrid)V(y float64) (float64, bool) {
yRatio := (y - bg.MinY) / (bg.MaxY - bg.MinY)
if bg.InvertY { yRatio = 1.0 - yRatio }
v := bg.OffsetV + (bg.H - (yRatio * bg.H))
outOfBounds := yRatio<0 || yRatio>1
return v,outOfBounds
}
// the bool is whether the coords are out-of-bounds for the grid.
func (bg BaseGrid)UV(x,y float64) (float64, float64, bool) {
u,oobU := bg.U(x)
v,oobV := bg.V(y)
return u, v, (oobU || oobV)
}
// }}}
// {{{ bg.MoveBy, LineBy
func (bg BaseGrid)MoveBy(x,y float64) {
currX,currY := bg.GetXY()
bg.Fpdf.MoveTo(currX+x, currY+y)
}
func (bg BaseGrid)LineBy(x,y float64) {
currX,currY := bg.GetXY()
bg.Fpdf.LineTo(currX+x, currY+y)
}
// }}}
// {{{ bg.MaybeSet{Draw|Text}Color
func (bg BaseGrid)MaybeSetDrawColor() {
if len(bg.LineColor) == 3 {
bg.SetDrawColor(bg.LineColor[0], bg.LineColor[1], bg.LineColor[2])
}
}
func (bg BaseGrid)MaybeSetTextColor() {
if len(bg.LineColor) == 3 {
bg.SetTextColor(bg.LineColor[0], bg.LineColor[1], bg.LineColor[2])
}
}
// }}}
// {{{ bg.MoveTo, LineTo, Line
// We submit coords in gridspace (e.g. x,y), and the grid transforms them into PDFspace.
func (bg BaseGrid)MoveTo(x,y float64) bool {
u,v,oob := bg.UV(x,y)
bg.Fpdf.MoveTo(u,v)
return oob
}
func (bg BaseGrid)LineTo(x,y float64) bool {
u,v,oob := bg.UV(x,y)
bg.Fpdf.LineTo(u,v)
return oob
}
// Only draw the line if both points are inside bounds
func (bg BaseGrid)Line(x1,y1,x2,y2 float64) {
u1,v1,oob1 := bg.UV(x1,y1)
u2,v2,oob2 := bg.UV(x2,y2)
if !bg.Clip || (!oob1 && !oob2) {
bg.MaybeSetDrawColor()
bg.Fpdf.MoveTo(u1,v1)
bg.Fpdf.LineTo(u2,v2)
}
bg.DrawPath("D")
}
// }}}
// {{{ bg.DrawGridlines
func (bg BaseGrid)DrawGridlines() {
bg.SetFont("Arial", "", 8)
dashPattern := []float64{2,2}
bg.SetLineWidth(0.03)
bg.SetDrawColor(0xe0, 0xe0, 0xe0)
for x := bg.MinX; x <= bg.MaxX; x += bg.XGridlineEvery {
if !bg.NoGridlines {
bg.MoveTo(x, bg.MinY)
bg.LineTo(x, bg.MaxY)
}
if bg.XTickFmt != "" {
if bg.XTickOtherSide {
bg.MoveTo(x,bg.MaxY)
bg.MoveBy(-4, -5) // Offset in MM
} else {
bg.MoveTo(x,bg.MinY)
bg.MoveBy(-4, 2) // Offset in MM
}
bg.SetTextColor(0,0,0) // Should maybe be a bit more configurable
tickfmt := bg.XTickFmt
if x == 0 && bg.XOriginTickFmt != "" {
tickfmt = bg.XOriginTickFmt
}
bg.Cell(30, float64(4), fmt.Sprintf(tickfmt, x))
bg.DrawPath("D")
}
}
if !bg.NoGridlines && bg.XMinorGridlineEvery > 0 {
bg.SetLineWidth(0.01)
bg.SetDashPattern(dashPattern, 0.0)
for x := bg.MinX; x <= bg.MaxX; x += bg.XMinorGridlineEvery {
bg.MoveTo(x, bg.MinY)
bg.LineTo(x, bg.MaxY)
}
bg.DrawPath("D")
bg.SetDashPattern([]float64{}, 0.0)
}
bg.SetLineWidth(0.03)
bg.SetDrawColor(0xe0, 0xe0, 0xe0)
for y := bg.MinY; y <= bg.MaxY; y += bg.YGridlineEvery {
if !bg.NoGridlines {
bg.MoveTo(bg.MinX, y)
bg.LineTo(bg.MaxX, y)
}
align := "L"
if bg.YTickFmt != "" {
if bg.YTickOtherSide {
// By default the 'not other' side is on the right
bg.MoveTo(bg.MinX, y)
if bg.InvertX {
bg.MoveBy(0.5, -2)
} else {
bg.MoveBy(-19, -2)
align = "R"
}
} else {
bg.MoveTo(bg.MaxX, y)
if bg.InvertX {
bg.MoveBy(-19, -2)
align = "R"
} else {
bg.MoveBy(0.5, -2)
}
}
bg.MaybeSetTextColor()
bg.CellFormat(18, 4, fmt.Sprintf(bg.YTickFmt, y), "", 0, align, false, 0, "")
bg.DrawPath("D")
}
}
bg.DrawPath("D")
if !bg.NoGridlines && bg.YMinorGridlineEvery > 0 {
bg.SetLineWidth(0.01)
bg.SetDashPattern(dashPattern, 0.0)
for y := bg.MinY; y <= bg.MaxY; y += bg.YMinorGridlineEvery {
bg.MoveTo(bg.MinX, y)
bg.LineTo(bg.MaxX, y)
}
bg.DrawPath("D")
bg.SetDashPattern([]float64{}, 0.0)
}
}
// }}}
// {{{ bg.DrawColorSchemeKey
func (bg BaseGrid)DrawColorSchemeKey() {
/*
if g.ColorScheme == ByPlotKind {
g.SetDrawColor(0,250,0)
g.MoveToNMAlt(g.LengthNM,0)
g.MoveBy(4, -2)
g.LineBy(8, -1)
g.MoveBy(0.5, -5)
g.Cell(30, 10, "Distance from destination")
g.DrawPath("D")
g.SetDrawColor(250,0,0)
g.MoveToNMAlt(g.LengthNM,0)
g.MoveBy(4, -8)
g.LineBy(8, -1)
g.MoveBy(0.5, -5)
g.Cell(30, 10, "Distance along path")
g.DrawPath("D")
}
*/
}
// }}}
// {{{ -------------------------={ E N D }=----------------------------------
// Local variables:
// folded-file: t
// end:
// }}} | fpdf/basegrid.go | 0.783119 | 0.467271 | basegrid.go | starcoder |
package bayesian_filter
import (
"errors"
m "math"
. "github.com/skelterjohn/go.matrix"
)
var (
ClassSet = []int{1, 2, 3, 4, 5}
NA = m.NaN()
)
// returns the matrix of ratings.
func MakeRatingMatrix(ratings []float64, rows, cols int) *DenseMatrix {
return MakeDenseMatrix(ratings, rows, cols)
}
func argmax(args []float64) (index int) {
index = 0
first := 0.0
for idx, val := range args {
if val > first {
index = idx
first = val
}
}
return
}
//returns the product of elements in a vector.
func Prod(values []float64) float64 {
prod := float64(1)
for _, val := range values {
prod *= val
}
return prod
}
// returns the % a value occured in a vector.
func PercentOccurences(row []float64, val float64) (percent float64) {
num := 0
length := 0
for _, x := range row {
if x == val {
num++
}
if !m.IsNaN(x) {
length++
}
}
return float64(num) / float64(length)
}
// returns the # of occurences a value occured in a vector.
func NumOccurences(row []float64, val float64) int {
num := 0
for _, x := range row {
if x == val {
num++
}
}
return num
}
func ToMap(col []float64) map[float64]float64 {
mapping := make(map[float64]float64)
for idx, val := range col {
if !m.IsNaN(val) {
mapping[float64(idx)] = val
}
}
return mapping
}
// Laplace smoother for the bayesian filter.
func LaplaceSmoother(count, countUser int) float64 {
numerator := count + len(ClassSet)
denominator := countUser + 1
return (float64(denominator) / float64(numerator))
}
/// Bayesian filter recommendation returns rating for a given user, item pair.
// Returns predictions, the index of the max prediction and an error if required.
func BayesianFilter(mat *DenseMatrix, user, item int) (preds []float64, max int, err error) {
if user >= mat.Rows() || item > mat.Cols() {
indexErr := errors.New("Check your matrix indices")
return nil, 0, indexErr
}
if mat.Get(user, item) == m.NaN() {
overrideErr := errors.New("You are attempting to predict a value that already exists")
return nil, 0, overrideErr
}
itemCol := mat.ColCopy(item)
userRow := mat.RowCopy(user)
preds = make([]float64, 0)
err = nil
for _, val := range ClassSet {
userProb := PercentOccurences(userRow, float64(val))
num := NumOccurences(userRow, float64(val))
notNan := ToMap(itemCol)
var laplaces []float64
for _, v := range notNan {
if v == float64(val) {
laplaceValue := LaplaceSmoother(num, 1)
laplaces = append(laplaces, laplaceValue)
} else {
laplaceValue := LaplaceSmoother(num, 0)
laplaces = append(laplaces, laplaceValue)
}
}
preds = append(preds, userProb*Prod(laplaces))
}
max = argmax(preds) + 1
return
} | plugins/data/learn/ml-filters-bayesian/bayesian_filter.go | 0.795658 | 0.485722 | bayesian_filter.go | starcoder |
package main
import "math"
// AtomType values are types of atoms that you can find in a nucleotide (P, C1', N1...)
type AtomType uint8
// The various types of atoms that you can find in a nucleotide
const (
P AtomType = iota // Phosphate
OP1 // Phosphate
OP2 // Phosphate
C1P // Ribose
C2P // Ribose
C3P // Ribose
C4P // Ribose
C5P // Ribose
O2P // Ribose
O3P // Ribose
O4P // Ribose
O5P // Ribose
C2 // G base, C base, U base, A base
C4 // G base, C base, U base, A base
C5 // G base, C base, U base, A base
C6 // G base, C base, U base, A base
C8 // G base, A base
O2 // C base, U base
O4 // U base
O6 // G base
N1 // G base, C base, U base, A base
N2 // G base
N3 // G base, C base, U base, A base
N4 // C base
N6 // A base
N7 // G base, A base
N9 // G base, A base
)
// NucleotideType values A, C, G, or U
type NucleotideType uint8
// NucleotideType values A, C, G, or U
const (
A NucleotideType = iota
C
G
U
T
)
// Structure is the base data structure containing information about an RNA conformation
type Structure struct {
nBases uint
nAtoms uint
sequence []NucleotideType
coords []float32
}
func (s *Structure) getAtomCoords(ntPosition uint, a AtomType) []float32 {
var index = 78*(ntPosition-1) + uint(a)
return s.coords[index : index+2]
}
func (s *Structure) setAtomCoords(ntPosition uint, a AtomType, x, y, z float32) {
var index = 78*(ntPosition-1) + uint(a)
s.coords[index] = x
s.coords[index+1] = y
s.coords[index+2] = z
}
func (s *Structure) getNucleotideCenter(pos uint) []float32 {
var xyz []float32
switch nt := s.sequence[pos]; nt {
case A, G: // purines, return N1
xyz = s.getAtomCoords(pos, N1)
case C, U, T: // pyrimidines, return N3
xyz = s.getAtomCoords(pos, N3)
}
return xyz
}
func getAtomDistanceBetween(atom1, atom2 []float32) float64 {
var dx = float64(atom1[0] - atom2[0])
var dy = float64(atom1[1] - atom2[1])
var dz = float64(atom1[2] - atom2[2])
return math.Sqrt(dx*dx + dy*dy + dz*dz)
}
func (s *Structure) getResidueDistanceBetween(pos1, pos2 uint) float64 {
return getAtomDistanceBetween(s.getNucleotideCenter(pos1), s.getNucleotideCenter(pos2))
}
func getCosAngleBetween(atom1, atom2, atom3 []float32) float64 {
// Par le théorème d'<NAME>, une fois développé.
// atom2 should be the angle's tip
var x1 = atom1[0]
var y1 = atom1[1]
var z1 = atom1[2]
var x2 = atom2[0]
var y2 = atom2[1]
var z2 = atom2[2]
var x3 = atom3[0]
var y3 = atom3[1]
var z3 = atom3[2]
var x11 = x1 * x1
var x12 = x1 * x2
var x13 = x1 * x3
var y11 = y1 * y1
var y12 = y1 * y2
var y13 = y1 * y3
var z11 = z1 * z1
var z12 = z1 * z2
var z13 = z1 * z3
var x22 = x2 * x2
var x23 = x2 * x3
var y22 = y2 * y2
var y23 = y2 * y3
var z22 = z2 * z2
var z23 = z2 * z3
var x33 = x3 * x3
var y33 = y3 * y3
var z33 = z3 * z3
var numerator = x22 + y22 + z22 + x13 + y13 + z13 - x12 - y12 - z12 - x23 - y23 - z23
var denominator = (x22 - 2*x12 + x11 + y22 - 2*y12 + y11 + z22 - 2*z12 + z11) * (x33 - 2*x13 + x11 + y33 - 2*y13 + y11 + z33 - 2*z13 + z11)
return float64(numerator) / math.Sqrt(float64(denominator))
}
func getCosTorsionBetween(atom1, atom2, atom3, atom4 []float32) float64 {
// Par le théorème d'<NAME>, une fois développé.
var x1 = atom1[0]
var y1 = atom1[1]
var z1 = atom1[2]
var x2 = atom2[0]
var y2 = atom2[1]
var z2 = atom2[2]
var x3 = atom3[0]
var y3 = atom3[1]
var z3 = atom3[2]
var x4 = atom4[0]
var y4 = atom4[1]
var z4 = atom4[2]
// Normal vector to the plane (atom1,atom2,atom3)
var p1 = []float32{(y2-y1)*(z3-z2) - (z2-z1)*(y3-y2), (z2-z1)*(x3-x2) - (x2-x1)*(z3-z2), (x2-x1)*(y3-y2) - (y2-y1)*(x3-x2)}
// Normal vector to the plane (atom2,atom3,atom4)
var p2 = []float32{(y3-y2)*(z4-z3) - (z3-z2)*(y4-y3), (z3-z2)*(x4-x3) - (x3-x2)*(z4-z3), (x3-x2)*(y4-y3) - (y3-y2)*(x4-x3)}
var numerator = p1[0]*p2[0] + p1[1]*p2[1] + p1[2]*p2[2]
var denominator = (p1[0]*p1[0] + p1[1]*p1[1] + p1[2]*p1[2]) * (p2[0]*p2[0] + p2[1]*p2[1] + p2[2]*p2[2])
return float64(numerator) / math.Sqrt(float64(denominator))
}
var rnaEq = []string{"", ""} | rnaProblem.go | 0.603114 | 0.405213 | rnaProblem.go | starcoder |
package views
import (
goa "goa.design/goa/v3/pkg"
)
// NeatThing is the viewed result type that is projected based on a view.
type NeatThing struct {
// Type to project
Projected *NeatThingView
// View to render
View string
}
// NeatThingView is a type that runs validations on a projected type.
type NeatThingView struct {
// The neat thing
Name *string
// What the neat thing is
Definition *string
// Illustrative link for the neat thing
Link *string
// When this was a neat thing
Date *string
Bibliography []string
}
var (
// NeatThingMap is a map of attribute names in result type NeatThing indexed by
// view name.
NeatThingMap = map[string][]string{
"default": []string{
"name",
"definition",
"link",
},
"full": []string{
"name",
"definition",
"link",
"date",
"bibliography",
},
"name": []string{
"name",
},
"name+definition": []string{
"name",
"definition",
},
"name+link": []string{
"name",
"link",
},
}
)
// ValidateNeatThing runs the validations defined on the viewed result type
// NeatThing.
func ValidateNeatThing(result *NeatThing) (err error) {
switch result.View {
case "default", "":
err = ValidateNeatThingView(result.Projected)
case "full":
err = ValidateNeatThingViewFull(result.Projected)
case "name":
err = ValidateNeatThingViewName(result.Projected)
case "name+definition":
err = ValidateNeatThingViewNameDefinition(result.Projected)
case "name+link":
err = ValidateNeatThingViewNameLink(result.Projected)
default:
err = goa.InvalidEnumValueError("view", result.View, []interface{}{"default", "full", "name", "name+definition", "name+link"})
}
return
}
// ValidateNeatThingView runs the validations defined on NeatThingView using
// the "default" view.
func ValidateNeatThingView(result *NeatThingView) (err error) {
if result.Link != nil {
err = goa.MergeErrors(err, goa.ValidateFormat("result.link", *result.Link, goa.FormatURI))
}
return
}
// ValidateNeatThingViewFull runs the validations defined on NeatThingView
// using the "full" view.
func ValidateNeatThingViewFull(result *NeatThingView) (err error) {
if result.Link != nil {
err = goa.MergeErrors(err, goa.ValidateFormat("result.link", *result.Link, goa.FormatURI))
}
if result.Date != nil {
err = goa.MergeErrors(err, goa.ValidateFormat("result.date", *result.Date, goa.FormatDateTime))
}
return
}
// ValidateNeatThingViewName runs the validations defined on NeatThingView
// using the "name" view.
func ValidateNeatThingViewName(result *NeatThingView) (err error) {
return
}
// ValidateNeatThingViewNameDefinition runs the validations defined on
// NeatThingView using the "name+definition" view.
func ValidateNeatThingViewNameDefinition(result *NeatThingView) (err error) {
return
}
// ValidateNeatThingViewNameLink runs the validations defined on NeatThingView
// using the "name+link" view.
func ValidateNeatThingViewNameLink(result *NeatThingView) (err error) {
if result.Link != nil {
err = goa.MergeErrors(err, goa.ValidateFormat("result.link", *result.Link, goa.FormatURI))
}
return
} | gen/neat_thing/views/view.go | 0.572245 | 0.415017 | view.go | starcoder |
package astutil
import (
"fmt"
"github.com/open2b/scriggo/ast"
)
// CloneTree returns a complete copy of tree.
func CloneTree(tree *ast.Tree) *ast.Tree {
return CloneNode(tree).(*ast.Tree)
}
// CloneNode returns a deep copy of node.
func CloneNode(node ast.Node) ast.Node {
switch n := node.(type) {
case *ast.Assignment:
variables := make([]ast.Expression, len(n.Lhs))
for i, v := range n.Lhs {
variables[i] = CloneExpression(v)
}
values := make([]ast.Expression, len(n.Rhs))
for i, v := range n.Rhs {
variables[i] = CloneExpression(v)
}
return ast.NewAssignment(ClonePosition(n.Position), variables, n.Type, values)
case *ast.Block:
var nodes []ast.Node
if n.Nodes != nil {
nodes = make([]ast.Node, len(n.Nodes))
for i := range n.Nodes {
nodes[i] = CloneNode(n.Nodes[i])
}
}
return ast.NewBlock(ClonePosition(n.Position), nodes)
case *ast.Break:
label := CloneExpression(n.Label).(*ast.Identifier)
return ast.NewBreak(ClonePosition(n.Position), label)
case *ast.Case:
var expressions []ast.Expression
if n.Expressions != nil {
expressions = make([]ast.Expression, len(n.Expressions))
for i, e := range n.Expressions {
expressions[i] = CloneExpression(e)
}
}
var body []ast.Node
if n.Body != nil {
body = make([]ast.Node, len(n.Body))
for i, node := range n.Body {
body[i] = CloneNode(node)
}
}
return ast.NewCase(ClonePosition(n.Position), expressions, body)
case *ast.Comment:
return ast.NewComment(ClonePosition(n.Position), n.Text)
case *ast.Const:
idents := make([]*ast.Identifier, len(n.Lhs))
for i, v := range n.Lhs {
idents[i] = CloneExpression(v).(*ast.Identifier)
}
typ := CloneExpression(n.Type)
values := make([]ast.Expression, len(n.Rhs))
for i, v := range n.Rhs {
values[i] = CloneExpression(v)
}
return ast.NewConst(ClonePosition(n.Position), idents, typ, values, n.Index)
case *ast.Continue:
label := CloneExpression(n.Label).(*ast.Identifier)
return ast.NewContinue(ClonePosition(n.Position), label)
case *ast.Defer:
return ast.NewDefer(ClonePosition(n.Position), CloneExpression(n.Call))
case ast.Expression:
return CloneExpression(n)
case *ast.Extends:
extends := ast.NewExtends(ClonePosition(n.Position), n.Path, n.Format)
if n.Tree != nil {
extends.Tree = CloneTree(n.Tree)
}
return extends
case *ast.Fallthrough:
return ast.NewFallthrough(ClonePosition(n.Position))
case *ast.For:
var body = make([]ast.Node, len(n.Body))
for i, n2 := range n.Body {
body[i] = CloneNode(n2)
}
var init, post ast.Node
if n.Init != nil {
init = CloneNode(n.Init)
}
if n.Post != nil {
post = CloneNode(n.Post)
}
return ast.NewFor(ClonePosition(n.Position), init, CloneExpression(n.Condition), post, body)
case *ast.ForIn:
ident := CloneNode(n.Ident).(*ast.Identifier)
expr := CloneExpression(n.Expr)
var body = make([]ast.Node, len(n.Body))
for i, n2 := range n.Body {
body[i] = CloneNode(n2)
}
return ast.NewForIn(ClonePosition(n.Position), ident, expr, body)
case *ast.ForRange:
var body = make([]ast.Node, len(n.Body))
for i, n2 := range n.Body {
body[i] = CloneNode(n2)
}
assignment := CloneNode(n.Assignment).(*ast.Assignment)
return ast.NewForRange(ClonePosition(n.Position), assignment, body)
case *ast.Func:
var ident *ast.Identifier
if n.Ident != nil {
ident = ast.NewIdentifier(ClonePosition(n.Ident.Position), n.Ident.Name)
}
typ := CloneExpression(n.Type).(*ast.FuncType)
return ast.NewFunc(ClonePosition(n.Position), ident, typ, CloneNode(n.Body).(*ast.Block), n.DistFree, n.Format)
case *ast.Go:
return ast.NewGo(ClonePosition(n.Position), CloneExpression(n.Call))
case *ast.Goto:
return ast.NewGoto(ClonePosition(n.Position), CloneExpression(n.Label).(*ast.Identifier))
case *ast.If:
var init ast.Node
if n.Init != nil {
init = CloneNode(n.Init)
}
var then *ast.Block
if n.Then != nil {
then = CloneNode(n.Then).(*ast.Block)
}
var els ast.Node
if n.Else != nil {
els = CloneNode(n.Else)
}
return ast.NewIf(ClonePosition(n.Position), init, CloneExpression(n.Condition), then, els)
case *ast.Import:
var ident *ast.Identifier
if n.Ident != nil {
ident = ast.NewIdentifier(ClonePosition(n.Ident.Position), n.Ident.Name)
}
var forIdents []*ast.Identifier
if n.For != nil {
forIdents = make([]*ast.Identifier, len(n.For))
for i, ident := range n.For {
forIdents[i] = CloneExpression(ident).(*ast.Identifier)
}
}
imp := ast.NewImport(ClonePosition(n.Position), ident, n.Path, forIdents)
if n.Tree != nil {
imp.Tree = CloneTree(n.Tree)
}
return imp
case *ast.Label:
return ast.NewLabel(ClonePosition(n.Position), CloneExpression(n.Ident).(*ast.Identifier), CloneNode(n.Statement))
case *ast.Package:
var nn = make([]ast.Node, 0, len(n.Declarations))
for _, n := range n.Declarations {
nn = append(nn, CloneNode(n))
}
return ast.NewPackage(ClonePosition(n.Position), n.Name, nn)
case *ast.Raw:
return ast.NewRaw(ClonePosition(n.Position), n.Marker, n.Tag, CloneNode(n.Text).(*ast.Text))
case *ast.Select:
var text *ast.Text
if n.LeadingText != nil {
text = CloneNode(n.LeadingText).(*ast.Text)
}
var cases []*ast.SelectCase
if n.Cases != nil {
cases = make([]*ast.SelectCase, len(n.Cases))
for i, c := range n.Cases {
cases[i] = CloneNode(c).(*ast.SelectCase)
}
}
return ast.NewSelect(ClonePosition(n.Position), text, cases)
case *ast.SelectCase:
var comm ast.Node
if n.Comm != nil {
comm = CloneNode(n.Comm)
}
var body []ast.Node
if n.Body != nil {
body = make([]ast.Node, len(n.Body))
for i, node := range n.Body {
body[i] = CloneNode(node)
}
}
return ast.NewSelectCase(ClonePosition(n.Position), comm, body)
case *ast.Send:
return ast.NewSend(ClonePosition(n.Position), CloneExpression(n.Channel), CloneExpression(n.Value))
case *ast.Show:
expressions := make([]ast.Expression, len(n.Expressions))
for i, expr := range n.Expressions {
expressions[i] = CloneExpression(expr)
}
return ast.NewShow(ClonePosition(n.Position), expressions, n.Context)
case *ast.Statements:
var nodes []ast.Node
if n.Nodes != nil {
nodes = make([]ast.Node, len(n.Nodes))
for i := range n.Nodes {
nodes[i] = CloneNode(n.Nodes[i])
}
}
return ast.NewStatements(ClonePosition(n.Position), nodes)
case *ast.StructType:
var fields []*ast.Field
if n.Fields != nil {
fields = make([]*ast.Field, len(n.Fields))
for i, field := range n.Fields {
var idents []*ast.Identifier
if field.Idents != nil {
idents = make([]*ast.Identifier, len(field.Idents))
for j, ident := range field.Idents {
idents[j] = CloneExpression(ident).(*ast.Identifier)
}
}
var typ ast.Expression
if field.Type != nil {
typ = CloneExpression(field.Type)
}
fields[i] = ast.NewField(idents, typ, field.Tag)
}
}
return ast.NewStructType(ClonePosition(n.Position), fields)
case *ast.Switch:
var init ast.Node
if n.Init != nil {
init = CloneNode(n.Init)
}
var text *ast.Text
if n.LeadingText != nil {
text = CloneNode(n.LeadingText).(*ast.Text)
}
var cases []*ast.Case
if n.Cases != nil {
cases = make([]*ast.Case, len(n.Cases))
for i, c := range n.Cases {
cases[i] = CloneNode(c).(*ast.Case)
}
}
return ast.NewSwitch(ClonePosition(n.Position), init, CloneExpression(n.Expr), text, cases)
case *ast.Text:
var text []byte
if n.Text != nil {
text = make([]byte, len(n.Text))
copy(text, n.Text)
}
return ast.NewText(ClonePosition(n.Position), text, n.Cut)
case *ast.TypeSwitch:
var init ast.Node
if n.Init != nil {
init = CloneNode(n.Init)
}
var assignment *ast.Assignment
if n.Assignment != nil {
assignment = CloneNode(n.Assignment).(*ast.Assignment)
}
var text *ast.Text
if n.LeadingText != nil {
text = CloneNode(n.LeadingText).(*ast.Text)
}
var cases []*ast.Case
if n.Cases != nil {
cases = make([]*ast.Case, len(n.Cases))
for i, c := range n.Cases {
cases[i] = CloneNode(c).(*ast.Case)
}
}
return ast.NewTypeSwitch(ClonePosition(n.Position), init, assignment, text, cases)
case *ast.Tree:
var nn = make([]ast.Node, 0, len(n.Nodes))
for _, n := range n.Nodes {
nn = append(nn, CloneNode(n))
}
return ast.NewTree(n.Path, nn, n.Format)
case *ast.URL:
var value = make([]ast.Node, len(n.Value))
for i, n2 := range n.Value {
value[i] = CloneNode(n2)
}
return ast.NewURL(ClonePosition(n.Position), n.Tag, n.Attribute, value)
case *ast.Using:
var body *ast.Block
if n.Body != nil {
body = CloneNode(n.Body).(*ast.Block)
}
return ast.NewUsing(ClonePosition(n.Position), CloneNode(n.Statement), CloneExpression(n.Type), body, n.Format)
case *ast.Var:
idents := make([]*ast.Identifier, len(n.Lhs))
for i, v := range n.Lhs {
idents[i] = CloneExpression(v).(*ast.Identifier)
}
typ := CloneExpression(n.Type)
values := make([]ast.Expression, len(n.Rhs))
for i, v := range n.Rhs {
values[i] = CloneExpression(v)
}
return ast.NewVar(ClonePosition(n.Position), idents, typ, values)
default:
panic(fmt.Sprintf("unexpected node type %#v", node))
}
}
// CloneExpression returns a complete copy of expression expr.
func CloneExpression(expr ast.Expression) ast.Expression {
if expr == nil {
return nil
}
var expr2 ast.Expression
switch e := expr.(type) {
case *ast.ArrayType:
expr2 = ast.NewArrayType(ClonePosition(e.Pos()), CloneExpression(e.Len), CloneExpression(e.ElementType))
case *ast.BasicLiteral:
expr2 = ast.NewBasicLiteral(ClonePosition(e.Position), e.Type, e.Value)
case *ast.BinaryOperator:
expr2 = ast.NewBinaryOperator(ClonePosition(e.Position), e.Op, CloneExpression(e.Expr1), CloneExpression(e.Expr2))
case *ast.Call:
var args = make([]ast.Expression, len(e.Args))
for i, arg := range e.Args {
args[i] = CloneExpression(arg)
}
expr2 = ast.NewCall(ClonePosition(e.Position), CloneExpression(e.Func), args, e.IsVariadic)
case *ast.ChanType:
expr2 = ast.NewChanType(ClonePosition(e.Pos()), e.Direction, CloneExpression(e.ElementType))
case *ast.CompositeLiteral:
keyValues := make([]ast.KeyValue, len(e.KeyValues))
for i, kv := range e.KeyValues {
keyValues[i].Key = CloneExpression(kv.Key)
keyValues[i].Value = CloneExpression(kv.Value)
}
return ast.NewCompositeLiteral(ClonePosition(e.Pos()), CloneExpression(e.Type), keyValues)
case *ast.Default:
expr2 = ast.NewDefault(ClonePosition(e.Position), CloneExpression(e.Expr1), CloneExpression(e.Expr2))
case *ast.DollarIdentifier:
expr2 = ast.NewDollarIdentifier(ClonePosition(e.Position), CloneExpression(e.Ident).(*ast.Identifier))
case *ast.Func:
var ident *ast.Identifier
if e.Ident != nil {
// Ident must be nil for a function literal, but clone it anyway.
ident = ast.NewIdentifier(ClonePosition(e.Ident.Position), e.Ident.Name)
}
typ := CloneExpression(e.Type).(*ast.FuncType)
expr2 = ast.NewFunc(ClonePosition(e.Position), ident, typ, CloneNode(e.Body).(*ast.Block), false, e.Format)
case *ast.FuncType:
var parameters []*ast.Parameter
if e.Parameters != nil {
parameters = make([]*ast.Parameter, len(e.Parameters))
for i, param := range e.Parameters {
var ident *ast.Identifier
if param.Ident != nil {
ident = ast.NewIdentifier(ClonePosition(param.Ident.Position), param.Ident.Name)
}
parameters[i] = &ast.Parameter{Ident: ident, Type: CloneExpression(param.Type)}
}
}
var result []*ast.Parameter
if e.Result != nil {
result = make([]*ast.Parameter, len(e.Result))
for i, res := range e.Result {
var ident *ast.Identifier
if res.Ident != nil {
ident = ast.NewIdentifier(ClonePosition(res.Ident.Position), res.Ident.Name)
}
result[i] = &ast.Parameter{Ident: ident, Type: CloneExpression(res.Type)}
}
}
expr2 = ast.NewFuncType(ClonePosition(e.Position), e.Macro, parameters, result, e.IsVariadic)
case *ast.Identifier:
expr2 = ast.NewIdentifier(ClonePosition(e.Position), e.Name)
case *ast.Index:
expr2 = ast.NewIndex(ClonePosition(e.Position), CloneExpression(e.Expr), CloneExpression(e.Index))
case *ast.Interface:
expr2 = ast.NewInterface(ClonePosition(e.Pos()))
case *ast.MapType:
expr2 = ast.NewMapType(ClonePosition(e.Pos()), CloneExpression(e.KeyType), CloneExpression(e.ValueType))
case *ast.Render:
n := ast.NewRender(ClonePosition(e.Position), e.Path)
if e.Tree != nil {
n.Tree = CloneTree(e.Tree)
}
expr2 = n
case *ast.Selector:
expr2 = ast.NewSelector(ClonePosition(e.Position), CloneExpression(e.Expr), e.Ident)
case *ast.SliceType:
expr2 = ast.NewSliceType(ClonePosition(e.Pos()), CloneExpression(e.ElementType))
case *ast.Slicing:
expr2 = ast.NewSlicing(ClonePosition(e.Position), CloneExpression(e.Expr), CloneExpression(e.Low),
CloneExpression(e.High), CloneExpression(e.Max), e.IsFull)
case *ast.TypeAssertion:
expr2 = ast.NewTypeAssertion(ClonePosition(e.Position), CloneExpression(e.Expr), CloneExpression(e.Type))
case *ast.UnaryOperator:
expr2 = ast.NewUnaryOperator(ClonePosition(e.Position), e.Op, CloneExpression(e.Expr))
default:
panic(fmt.Sprintf("unexpected node type %#v", expr))
}
expr2.SetParenthesis(expr.Parenthesis())
return expr2
}
// ClonePosition returns a copy of position pos.
func ClonePosition(pos *ast.Position) *ast.Position {
return &ast.Position{Line: pos.Line, Column: pos.Column, Start: pos.Start, End: pos.End}
} | ast/astutil/clone.go | 0.639286 | 0.560914 | clone.go | starcoder |
package czml
// BoundingRectangle holds a bounding rectangle specified by a corner, width and height.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/BoundingRectangle
type BoundingRectangle struct {
BoundingRectangle *BoundingRectangleValue `json:"boundingRectangle,omitempty"`
Reference ReferenceValue `json:"reference,omitempty"`
}
// BoundingRectangleValue is a near-far scalar value specified as four values
// [X, Y, Width, Height]. If the array has four elements, the value is constant. If it has five or
// more elements, they are time-tagged samples arranged as
// [Time, X, Y, Width, Height, Time, X, Y, Width, Height, ...], where Time is an ISO 8601 date and
// time string or seconds since epoch.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/BoundingRectangleValue
type BoundingRectangleValue []interface{}
// Box is a closed rectangular cuboid
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Box
type Box struct {
Show *bool `json:"show,omitempty"`
Dimensions *BoxDimensions `json:"dimensions"`
HeightReference *HeightReference `json:"heightReference"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
}
// BoxDimensions is the width, depth, and height of a box
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/BoxDimensions
type BoxDimensions struct {
Cartesian *Cartesian3Value `json:"cartesian,omitempty"`
Reference ReferenceValue `json:"reference,omitempty"`
}
// CornerType holds the style of a corner
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CornerType
type CornerType struct {
CornerType CornerTypeValue `json:"cornerType,omitempty"`
Reference ReferenceValue `json:"reference,omitempty"`
}
// CornerTypeValue is the style of a corner
// valid values are `ROUNDED`, `MITERED`, `BEVELED`
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CornerTypeValue
type CornerTypeValue string
// Corridor is a shape defined by a centerline and width that conforms to the curvature of the
// globe. It can be placed on the surface or at altitude and can optionally be extruded *into a
// volume.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Corridor
type Corridor struct {
Show *bool `json:"show,omitempty"`
Positions *PositionList `json:"positions,omitempty"`
Width *float64 `json:"width,omitempty"`
Height *float64 `json:"height,omitempty"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
ExtrudedHeight *float64 `json:"extrudedHeight,omitempty"`
ExtrudedHeightReference *HeightReference `json:"extrudedHeightReference,omitempty"`
CornerType *CornerType `json:"cornerType,omitempty"`
Granularity *float64 `json:"granularity,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
ClassificationType ClassificationType `json:"classificationType,omitempty"`
ZIndex *int `json:"zIndex,omitempty"`
}
// Cylinder is a cylinder, truncated cone, or cone defined by a length, top radius, and bottom
// radius.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Cylinder
type Cylinder struct {
Show *bool `json:"show,omitempty"`
Length *float64 `json:"length"`
TopRadius *float64 `json:"topRadius"`
BottomRadius *float64 `json:"bottomRadius"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
NumberOfVerticalLines *int `json:"numberOfVerticalLines,omitempty"`
Slices *int `json:"slices,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
}
// Ellipse is a closed curve on or above the surface of the Earth.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Ellipse
type Ellipse struct {
Show *bool `json:"show,omitempty"`
SemiMajorAxis *float64 `json:"semiMajorAxis"`
SemiMinorAxis *float64 `json:"semiMinorAxis"`
Height *float64 `json:"height,omitempty"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
ExtrudedHeight *float64 `json:"extrudedHeight,omitempty"`
ExtrudedHeightReference *HeightReference `json:"extrudedHeightReference,omitempty"`
Rotation *float64 `json:"rotation,omitempty"`
StRotation *float64 `json:"stRotation,omitempty"`
Granularity *float64 `json:"granularity,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
NumberOfVerticalLines *int `json:"numberOfVerticalLines,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
ClassificationType ClassificationType `json:"classificationType,omitempty"`
ZIndex *int `json:"zIndex,omitempty"`
}
// Ellipsoid is a closed quadric surface that is a three-dimensional analogue of an ellipse.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Ellipsoid
type Ellipsoid struct {
Show *bool `json:"show,omitempty"`
Radii *EllipsoidRadii `json:"radii"`
InnerRadii *EllipsoidRadii `json:"innerRadii,omitempty"`
MinimumClock *float64 `json:"minimumClock,omitempty"`
MaximumClock *float64 `json:"maximumClock,omitempty"`
MinimumCone *float64 `json:"minimumCone,omitempty"`
MaximumCone *float64 `json:"maximumCone,omitempty"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
StackPartitions *int `json:"stackPartitions,omitempty"`
SlicePartitions *int `json:"slicePartitions,omitempty"`
Subdivisions *int `json:"subdivisions,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
}
// EllipsoidRadii is the radii of an ellipsoid
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/EllipsoidRadii
type EllipsoidRadii struct {
Cartesian Cartesian3Value `json:"cartesian,omitempty"`
Reference ReferenceValue `json:"reference,omitempty"`
}
// Point is a viewport-aligned circle.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Point
type Point struct {
Show *bool `json:"show,omitempty"`
PixelSize *float64 `json:"pixelSize,omitempty"`
HeightReference *HeightReference `json:"heightReference"`
Color *Color `json:"color,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
ScaleByDistance *NearFarScaler `json:"scaleByDistance,omitempty"`
TranslucencyByDistance *NearFarScaler `json:"translucencyByDistance,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
DisableDepthTestDistance *float64 `json:"disableDepthTestDistance,omitempty"`
}
// Polygon is a closed figure on the surface of the Earth.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Polygon
type Polygon struct {
Show *bool `json:"show,omitempty"`
Positions *PositionList `json:"positions,omitempty"`
Holes *PositionListOfLists `json:"holes,omitempty"`
ArcType *ArcType `json:"arcType,omitempty"`
Height *float64 `json:"height,omitempty"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
ExtrudedHeight *float64 `json:"extrudedHeight,omitempty"`
ExtrudedHeightReference *HeightReference `json:"extrudedHeightReference,omitempty"`
StRotation *float64 `json:"stRotation,omitempty"`
Granularity *float64 `json:"granularity,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
PerPositionHeight *bool `json:"perPositionHeight,omitempty"`
CloseTop *bool `json:"closeTop,omitempty"`
CloseBottom *bool `json:"closeBottom,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
ClassificationType ClassificationType `json:"classificationType,omitempty"`
ZIndex *int `json:"zIndex,omitempty"`
}
// Shape is a list of two-dimensional positions defining a shape.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Shape
type Shape struct {
Cartesian2 *Cartesian2ListValue `json:"cartesian2"`
}
// Rectangle is a cartographic rectangle, which conforms to the curvature of the globe and can be
// placed on the surface or at altitude and can optionally be extruded into a volume.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Rectangle
type Rectangle struct {
Show *bool `json:"show,omitempty"`
Coordinates *RectangleCoordinates `json:"coordinates"`
Height *float64 `json:"height,omitempty"`
HeightReference *HeightReference `json:"heightReference,omitempty"`
ExtrudedHeight *float64 `json:"extrudedHeight,omitempty"`
ExtrudedHeightReference *HeightReference `json:"extrudedHeightReference,omitempty"`
Rotation *float64 `json:"rotation,omitempty"`
StRotation *float64 `json:"stRotation,omitempty"`
Granularity *float64 `json:"granularity,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
ClassificationType ClassificationType `json:"classificationType,omitempty"`
ZIndex *int `json:"zIndex,omitempty"`
}
// RectangleCoordinates is a set of coordinates describing a cartographic rectangle on the surface
// of the ellipsoid.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/RectangleCoordinates
type RectangleCoordinates struct {
Wsen *CartographicRectangleRadiansValue `json:"wsen,omitempty"`
WsenDegrees *CartographicRectangleDegreesValue `json:"wsenDegrees,omitempty"`
Reference ReferenceValue `json:"reference"`
}
// Tileset is a 3D Tiles tileset
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Tileset
type Tileset struct {
Show *bool `json:"show,omitempty"`
Uri *Uri `json:"uri"`
MaximumScreenSpaceError *float64 `json:"maximumScreenSpaceError,omitempty"`
}
// Wall is a two-dimensional wall defined as a line strip and optional maximum and minimum heights,
// which conforms to the curvature of the globe and can be placed along the surface or at altitude.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Wall
type Wall struct {
Show *bool `json:"show,omitempty"`
Positions *PositionList `json:"positions"`
MinimumHeights *DoubleList `json:"minimumHeights,omitempty"`
MaximumHeights *DoubleList `json:"maximumHeights,omitempty"`
Granularity *float64 `json:"granularity,omitempty"`
Fill *bool `json:"fill,omitempty"`
Material *Material `json:"material,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
Shadows ShadowMode `json:"shadows,omitempty"`
DistanceDisplayCondition *DistanceDisplayCondition `json:"distanceDisplayCondition,omitempty"`
}
// ConicSensor is a conical sensor volume taking into account occlusion of an ellipsoid, i.e.,
// the globe.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/ConicSensor
type ConicSensor struct {
Show *bool `json:"show,omitempty"`
InnerHalfAngle *float64 `json:"innerHalfAngle,omitempty"`
OuterHalfAngle *float64 `json:"outerHalfAngle,omitempty"`
MinimumClockAngle *float64 `json:"minimumClockAngle,omitempty"`
MaximumClockAngle *float64 `json:"maximumClockAngle,omitempty"`
Radius *float64 `json:"radius,omitempty"`
ShowIntersection *bool `json:"showIntersection,omitempty"`
IntersectionColor *Color `json:"intersectionColor,omitempty"`
IntersectionWidth *float64 `json:"intersectionWidth,omitempty"`
ShowLateralSurfaces *bool `json:"showLateralSurfaces,omitempty"`
LateralSurfaceMaterial *Material `json:"lateralSurfaceMaterial,omitempty"`
ShowEllipsoidSurfaces *bool `json:"showEllipsoidSurfaces,omitempty"`
EllipsoidSurfaceMaterial *Material `json:"ellipsoidSurfaceMaterial,omitempty"`
ShowEllipsoidHorizonSurfaces *bool `json:"showEllipsoidHorizonSurfaces,omitempty"`
EllipsoidHorizonSurfaceMaterial *Material `json:"ellipsoidHorizonSurfaceMaterial,omitempty"`
ShowDomeSurfaces *bool `json:"showDomeSurfaces,omitempty"`
DomeSurfaceMaterial *Material `json:"domeSurfaceMaterial,omitempty"`
PortionToDisplay *SensorVolumePortionToDisplay `json:"portionToDisplay"`
EnvironmentConstraint *bool `json:"environmentConstraint,omitempty"`
ShowEnvironmentOcclusion *bool `json:"showEnvironmentOcclusion,omitempty"`
EnvironmentOcclusionMaterial *Material `json:"environmentOcclusionMaterial,omitempty"`
ShowEnvironmentIntersection *bool `json:"showEnvironmentIntersection,omitempty"`
EnvironmentIntersectionColor *Color `json:"environmentIntersectionColor,omitempty"`
EnvironmentIntersectionWidth *float64 `json:"environmentIntersectionWidth,omitempty"`
ShowThroughEllipsoid *bool `json:"showThroughEllipsoid,omitempty"`
ShowViewshed *bool `json:"showViewshed,omitempty"`
ViewshedVisibleColor *Color `json:"viewshedVisibleColor,omitempty"`
ViewshedOccludedColor *Color `json:"viewshedOccludedColor,omitempty"`
ViewshedResolution *int `json:"viewshedResolution,omitempty"`
}
// SensorVolumePortionToDisplay is the part of a sensor that should be displayed
// Valid values are `COMPLETE`, `BELOW_ELLIPSOID_HORIZON`, and `ABOVE_ELLIPSOID_HORIZON`
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/SensorVolumePortionToDisplay
type SensorVolumePortionToDisplay string
// CustomPatternSensor is a custom sensor volume taking into account occlusion of an ellipsoid,
// i.e., the globe.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CustomPatternSensor
type CustomPatternSensor struct {
Show *bool `json:"show,omitempty"`
Directions *DirectionList `json:"directions"`
Radius *float64 `json:"radius,omitempty"`
ShowIntersection *bool `json:"showIntersection,omitempty"`
IntersectionColor *Color `json:"intersectionColor,omitempty"`
IntersectionWidth *float64 `json:"intersectionWidth,omitempty"`
ShowLateralSurfaces *bool `json:"showLateralSurfaces,omitempty"`
LateralSurfaceMaterial *Material `json:"lateralSurfaceMaterial,omitempty"`
ShowEllipsoidSurfaces *bool `json:"showEllipsoidSurfaces,omitempty"`
EllipsoidSurfaceMaterial *Material `json:"ellipsoidSurfaceMaterial,omitempty"`
ShowEllipsoidHorizonSurfaces *bool `json:"showEllipsoidHorizonSurfaces,omitempty"`
EllipsoidHorizonSurfaceMaterial *Material `json:"ellipsoidHorizonSurfaceMaterial,omitempty"`
ShowDomeSurfaces *bool `json:"showDomeSurfaces,omitempty"`
DomeSurfaceMaterial *Material `json:"domeSurfaceMaterial,omitempty"`
PortionToDisplay *SensorVolumePortionToDisplay `json:"portionToDisplay"`
EnvironmentConstraint *bool `json:"environmentConstraint,omitempty"`
ShowEnvironmentOcclusion *bool `json:"showEnvironmentOcclusion,omitempty"`
EnvironmentOcclusionMaterial *Material `json:"environmentOcclusionMaterial,omitempty"`
ShowEnvironmentIntersection *bool `json:"showEnvironmentIntersection,omitempty"`
EnvironmentIntersectionColor *Color `json:"environmentIntersectionColor,omitempty"`
EnvironmentIntersectionWidth *float64 `json:"environmentIntersectionWidth,omitempty"`
ShowThroughEllipsoid *bool `json:"showThroughEllipsoid,omitempty"`
ShowViewshed *bool `json:"showViewshed,omitempty"`
ViewshedVisibleColor *Color `json:"viewshedVisibleColor,omitempty"`
ViewshedOccludedColor *Color `json:"viewshedOccludedColor,omitempty"`
ViewshedResolution *int `json:"viewshedResolution,omitempty"`
}
// RectangularSensor is a rectangular pyramid sensor volume taking into account occlusion of an
// ellipsoid, i.e., the globe.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/RectangularSensor
type RectangularSensor struct {
Show *bool `json:"show,omitempty"`
XHalfAngle *float64 `json:"xHalfAngle,omitempty"`
YHalfAngle *float64 `json:"yHalfAngle,omitempty"`
Radius *float64 `json:"radius,omitempty"`
ShowIntersection *bool `json:"showIntersection,omitempty"`
IntersectionColor *Color `json:"intersectionColor,omitempty"`
IntersectionWidth *float64 `json:"intersectionWidth,omitempty"`
ShowLateralSurfaces *bool `json:"showLateralSurfaces,omitempty"`
LateralSurfaceMaterial *Material `json:"lateralSurfaceMaterial,omitempty"`
ShowEllipsoidSurfaces *bool `json:"showEllipsoidSurfaces,omitempty"`
EllipsoidSurfaceMaterial *Material `json:"ellipsoidSurfaceMaterial,omitempty"`
ShowEllipsoidHorizonSurfaces *bool `json:"showEllipsoidHorizonSurfaces,omitempty"`
EllipsoidHorizonSurfaceMaterial *Material `json:"ellipsoidHorizonSurfaceMaterial,omitempty"`
ShowDomeSurfaces *bool `json:"showDomeSurfaces,omitempty"`
DomeSurfaceMaterial *Material `json:"domeSurfaceMaterial,omitempty"`
PortionToDisplay *SensorVolumePortionToDisplay `json:"portionToDisplay"`
EnvironmentConstraint *bool `json:"environmentConstraint,omitempty"`
ShowEnvironmentOcclusion *bool `json:"showEnvironmentOcclusion,omitempty"`
EnvironmentOcclusionMaterial *Material `json:"environmentOcclusionMaterial,omitempty"`
ShowEnvironmentIntersection *bool `json:"showEnvironmentIntersection,omitempty"`
EnvironmentIntersectionColor *Color `json:"environmentIntersectionColor,omitempty"`
EnvironmentIntersectionWidth *float64 `json:"environmentIntersectionWidth,omitempty"`
ShowThroughEllipsoid *bool `json:"showThroughEllipsoid,omitempty"`
ShowViewshed *bool `json:"showViewshed,omitempty"`
ViewshedVisibleColor *Color `json:"viewshedVisibleColor,omitempty"`
ViewshedOccludedColor *Color `json:"viewshedOccludedColor,omitempty"`
ViewshedResolution *int `json:"viewshedResolution,omitempty"`
}
// Fan starts at a point or apex and extends in a specified list of directions from the apex. Each
// pair of directions forms a face of the fan extending to the specified radius.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Fan
type Fan struct {
Show *bool `json:"show,omitempty"`
Directions *DirectionList `json:"directions"`
Radius *float64 `json:"radius,omitempty"`
PerDirectionRadius *bool `json:"perDirectionRadius,omitempty"`
Material *Material `json:"material,omitempty"`
Fill *bool `json:"fill,omitempty"`
Outline *bool `json:"outline,omitempty"`
OutlineColor *Color `json:"outlineColor,omitempty"`
OutlineWidth *float64 `json:"outlineWidth,omitempty"`
NumberOfRings *int `json:"numberOfRings,omitempty"`
}
// Vector defines a graphical vector that originates at the position property and extends in the
// provided direction for the provided length.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Vector
type Vector struct {
Show *bool `json:"show,omitempty"`
Color *Color `json:"color,omitempty"`
Direction *Direction `json:"direction"`
Length *float64 `json:"length,omitempty"`
MinimumLengthInPixels *float64 `json:"minimumLengthInPixels,omitempty"`
}
// Spherical is a spherical value [Clock, Cone, Magnitude], with angles in radians and magnitude in
// meters. The clock angle is measured in the XY plane from the positive X axis toward the positive
// Y axis. The cone angle is the angle from the positive Z axis toward the negative Z axis. If the
// array has three elements, the value is constant. If it has four or more elements, they are
// time-tagged samples arranged as [Time, Clock, Cone, Magnitude, Time, Clock, Cone, Magnitude, ...]
// where Time is an ISO 8601 date and time string or seconds since epoch.
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/SphericalValue
type SphericalValue []interface{}
// Direction is a unit vector, in world coordinates, that defines a direction
// https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/Direction
type Direction struct {
Spherical *SphericalValue `json:"spherical,omitempty"`
UnitSpherical *UnitSphericalValue `json:"unitSpherical,omitempty"`
Cartesian *Cartesian3Value `json:"cartesian,omitempty"`
UnitCartesian3Value `json:"unitCartesian,omitempty"`
Reference ReferenceValue `json:"reference,omitempty"`
} | shapes.go | 0.924103 | 0.610279 | shapes.go | starcoder |
// F2 illuminant conversion functions
package white
// F2_A functions
func F2_A_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.1108436, 0.0654914, -0.1020770},
{0.0892593, 0.9359084, -0.0362665},
{-0.0166489, 0.0256618, 0.5144475}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_A_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.0383067, 0.1380821, -0.1030329},
{0.0151673, 0.9870182, -0.0030598},
{0.0000000, 0.0000000, 0.5280222}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_A_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.1075152, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 0.5280222}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_B functions
func F2_B_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9773601, -0.0123986, 0.0500263},
{-0.0133935, 1.0023946, 0.0161588},
{0.0104080, -0.0177628, 1.2756066}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_B_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9916737, -0.0300157, 0.0551010},
{-0.0032970, 1.0028226, 0.0006642},
{0.0000000, 0.0000000, 1.2645675}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_B_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9988506, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.2645675}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_C functions
func F2_C_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9301461, -0.0386152, 0.1436063},
{-0.0431066, 1.0113279, 0.0466336},
{0.0295321, -0.0501939, 1.7853816}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_C_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9744947, -0.0919438, 0.1574666},
{-0.0100994, 1.0086458, 0.0020348},
{0.0000000, 0.0000000, 1.7543662}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_C_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9887887, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.7543662}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_D50 functions
func F2_D50_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9628262, -0.0215790, 0.0457172},
{-0.0280310, 1.0172847, 0.0156071},
{0.0083415, -0.0135344, 1.2322804}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D50_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9869554, -0.0470220, 0.0479582},
{-0.0051650, 1.0044210, 0.0010416},
{0.0000000, 0.0000000, 1.2244744}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D50_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9721332, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.2244744}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_D55 functions
func F2_D55_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9460314, -0.0310871, 0.0735630},
{-0.0395027, 1.0224574, 0.0248152},
{0.0138373, -0.0227352, 1.3807080}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D55_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9809382, -0.0687128, 0.0780192},
{-0.0075476, 1.0064606, 0.0015219},
{0.0000000, 0.0000000, 1.3673379}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D55_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9646724, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.3673379}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_D65 functions
func F2_D65_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9212269, -0.0449128, 0.1211620},
{-0.0553723, 1.0277243, 0.0403563},
{0.0235086, -0.0391019, 1.6390644}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D65_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9719399, -0.1011504, 0.1299721},
{-0.0111107, 1.0095107, 0.0022399},
{0.0000000, 0.0000000, 1.6156426}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D65_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9582703, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.6156426}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_D75 functions
func F2_D75_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9038485, -0.0544241, 0.1597390},
{-0.0656239, 1.0294976, 0.0528128},
{0.0315403, -0.0528125, 1.8516893}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D75_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9655456, -0.1242015, 0.1724740},
{-0.0136427, 1.0116783, 0.0027499},
{0.0000000, 0.0000000, 1.8197439}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_D75_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9575142, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.8197439}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_E functions
func F2_E_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9654834, -0.0184347, 0.0902324},
{-0.0181044, 0.9985320, 0.0288236},
{0.0192213, -0.0330731, 1.5046195}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_E_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9870655, -0.0466289, 0.1003043},
{-0.0051218, 1.0043851, 0.0010314},
{0.0000000, 0.0000000, 1.4838336}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_E_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.0082068, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.4838336}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_F7 functions
func F2_F7_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9213533, -0.0448467, 0.1207888},
{-0.0553131, 1.0277453, 0.0402379},
{0.0234280, -0.0389625, 1.6369581}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_F7_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9719880, -0.1009770, 0.1295549},
{-0.0110916, 1.0094944, 0.0022360},
{0.0000000, 0.0000000, 1.6136246}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_F7_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{0.9582098, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 1.6136246}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
// F2_F11 functions
func F2_F11_Bradford(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.0156947, 0.0093992, -0.0106926},
{0.0132620, 0.9895464, -0.0040071},
{-0.0014541, 0.0020196, 0.9539904}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_F11_vonKries(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.0053592, 0.0193178, -0.0101990},
{0.0021219, 0.9981839, -0.0004282},
{0.0000000, 0.0000000, 0.9548469}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
}
func F2_F11_Xyz(xs, ys, zs float64) (xd, yd, zd float64) {
m := [3][3]float64{
{1.0179058, 0.0000000, 0.0000000},
{0.0000000, 1.0000000, 0.0000000},
{0.0000000, 0.0000000, 0.9548469}}
xd = m[0][0]*xs + m[0][1]*ys + m[0][2]*zs
yd = m[1][0]*xs + m[1][1]*ys + m[1][2]*zs
zd = m[2][0]*xs + m[2][1]*ys + m[2][2]*zs
return
} | f64/white/f2.go | 0.505371 | 0.614307 | f2.go | starcoder |
package gotalib
// The Slow Stochastic Oscillator is a momentum indicator that shows the location
// of the close relative to the high-low range over a set number of periods. The
// indicator can range from 0 to 100. The difference between the Slow and Fast
// Stochastic Oscillator is the Slow %K incorporates a %K slowing period of 3 that
// controls the internal smoothing of %K. Setting the smoothing period to 1 is
// equivalent to plotting the Fast Stochastic Oscillator.
// https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/slow-stochastic
type StochSlow struct {
fastKN int64
slowKN int64
slowDN int64
util int64
stochK *StochasticK
slowK *Ma
slowD *Ma
sz int64
}
func NewStochSlow(fastKN int64, kt MaType, slowKN int64, dt MaType, slowDN int64) *StochSlow {
return &StochSlow{
fastKN: fastKN,
slowKN: slowKN,
slowDN: slowDN,
util: fastKN + slowKN + slowDN - 2,
stochK: NewStochasticK(fastKN),
slowK: NewMa(kt, slowKN),
slowD: NewMa(dt, slowDN),
sz: 0,
}
}
func (s *StochSlow) Update(h, l, c float64) (float64, float64) {
s.sz++
fastK := s.stochK.Update(h, l, c)
if s.sz < s.fastKN {
return 0, 0
}
slowK := s.slowK.Update(fastK)
slowD := s.slowD.Update(slowK)
if s.sz < s.util {
return 0, 0
}
return slowK, slowD
}
func (s *StochSlow) InitPeriod() int64 {
return s.util - 1
}
func (s *StochSlow) Valid() bool {
return s.sz > s.InitPeriod()
}
// The Slow Stochastic Oscillator is a momentum indicator that shows the location
// of the close relative to the high-low range over a set number of periods. The
// indicator can range from 0 to 100. The difference between the Slow and Fast
// Stochastic Oscillator is the Slow %K incorporates a %K slowing period of 3 that
// controls the internal smoothing of %K. Setting the smoothing period to 1 is
// equivalent to plotting the Fast Stochastic Oscillator.
// https://www.fidelity.com/learning-center/trading-investing/technical-analysis/technical-indicator-guide/slow-stochastic
func StochSlowArr(h, l, c []float64, fastKN int64, kt MaType, slowKN int64, dt MaType, slowDN int64) ([]float64, []float64) {
k := make([]float64, len(c))
d := make([]float64, len(c))
s := NewStochSlow(fastKN, kt, slowKN, dt, slowDN)
for i := 0; i < len(c); i++ {
k[i], d[i] = s.Update(h[i], l[i], c[i])
}
return k, d
} | stochslow.go | 0.866895 | 0.519399 | stochslow.go | starcoder |
package g5
import (
gl "github.com/chsc/gogl/gl33"
)
type _ColorRect struct {
program *_Program
vao gl.Uint
vbo gl.Uint
}
func newColorRect() *_ColorRect {
r := &_ColorRect{}
r.program = newProgram("github.com/amortaza/go-g5/shader/rgb.vertex.txt", "github.com/amortaza/go-g5/shader/rgb.fragment.txt")
gl.GenVertexArrays(1, &r.vao)
gl.GenBuffers(1, &r.vbo)
return r
}
func (r *_ColorRect) Draw(
left, top, width, height int,
leftTopColor []float32,
rightTopColor []float32,
rightBottomColor []float32,
leftBottomColor []float32,
projection *gl.Float ) {
r.program.Activate()
gl.UniformMatrix4fv(r.program.GetUniformLocation("project"), 1, 0, projection)
gl.BindVertexArray(r.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vbo)
right := left + width
bottom := top + height
vertices := []float32{
float32(left), float32(top), leftTopColor[0], leftTopColor[1], leftTopColor[2], leftTopColor[3],
float32(right), float32(top), rightTopColor[0], rightTopColor[1], rightTopColor[2], rightTopColor[3],
float32(right), float32(bottom), rightBottomColor[0], rightBottomColor[1], rightBottomColor[2], rightBottomColor[3],
float32(left), float32(bottom), leftBottomColor[0], leftBottomColor[1], leftBottomColor[2], leftBottomColor[3] }
colorRect_setVertexData(vertices)
gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
gl.BindVertexArray(0)
}
func (r *_ColorRect) DrawSolid(
left, top, width, height int,
red, green, blue float32,
projection *gl.Float ) {
r.program.Activate()
gl.UniformMatrix4fv(r.program.GetUniformLocation("project"), 1, 0, projection)
gl.BindVertexArray(r.vao)
gl.BindBuffer(gl.ARRAY_BUFFER, r.vbo)
right := left + width
bottom := top + height
vertices := []float32{
float32(left), float32(top), red, green, blue, 1,
float32(right), float32(top), red, green, blue, 1,
float32(right), float32(bottom), red, green, blue, 1,
float32(left), float32(bottom), red, green, blue, 1 }
colorRect_setVertexData(vertices)
gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
gl.BindVertexArray(0)
}
func (r *_ColorRect) Free() {
gl.DeleteVertexArrays(1, &r.vao)
gl.DeleteBuffers(1, &r.vbo)
r.program.Free()
}
func colorRect_setVertexData(data []float32) {
// copy vertices data into VBO (it needs to be bound first)
gl.BufferData(gl.ARRAY_BUFFER, gl.Sizeiptr(len(data)*4), gl.Pointer(glPtr(data)), gl.STATIC_DRAW)
// size of 1 whole vertex (sum of attrib sizes)
var stride int32 = 2 /*posPartCount*/ *4 + 4 /*colorPartCount*/ *4
var offset int = 0
// position
gl.VertexAttribPointer(0, 2 /*posPartCount*/, gl.FLOAT, 0, gl.Sizei(stride), gl.Pointer(glPtrOffset(offset)))
gl.EnableVertexAttribArray(0)
offset += 2 /*posPartCount*/ * 4
// color
gl.VertexAttribPointer(1, 4 /*colorPartCount*/, gl.FLOAT, 0, gl.Sizei(stride), gl.Pointer(glPtrOffset(offset)))
gl.EnableVertexAttribArray(1)
} | color-rect.go | 0.670285 | 0.470068 | color-rect.go | starcoder |
package parse
import (
"fmt"
"sort"
"strings"
)
// Node is an item in the AST.
type Node interface {
String() string // String representation of the Node, for debugging.
Start() Pos // The position of the Node in the source code.
All() []Node // All children of the Node.
}
// A TrimmableNode contains information on whether preceding or trailing whitespace should
// be removed when executing the template.
type TrimmableNode struct {
TrimBefore bool // True if whitespace before the node should be removed.
TrimAfter bool // True if whitespace after the node should be removed.
}
// Pos is used to track line and offset in a given string.
type Pos struct {
Line int
Offset int
}
// Start returns the start position of the node.
func (p Pos) Start() Pos {
return p
}
// String returns a string representation of a pos.
func (p Pos) String() string {
return fmt.Sprintf("%d:%d", p.Line, p.Offset)
}
// ModuleNode represents a root node in the AST.
type ModuleNode struct {
*BodyNode
Parent *ExtendsNode // Parent template reference.
Origin string // The name where this module is originally defined.
}
// NewModuleNode returns a ModuleNode.
func NewModuleNode(name string, nodes ...Node) *ModuleNode {
return &ModuleNode{NewBodyNode(Pos{1, 0}, nodes...), nil, name}
}
// String returns a string representation of a ModuleNode.
func (l *ModuleNode) String() string {
return fmt.Sprintf("Module%s", l.Nodes)
}
// BodyNode represents a list of nodes.
type BodyNode struct {
Pos
Nodes []Node
}
// NewBodyNode returns a BodyNode.
func NewBodyNode(pos Pos, nodes ...Node) *BodyNode {
return &BodyNode{pos, nodes}
}
// Append a Node to the BodyNode.
func (l *BodyNode) Append(n Node) {
l.Nodes = append(l.Nodes, n)
}
// String returns a string representation of a BodyNode.
func (l *BodyNode) String() string {
return fmt.Sprintf("Body%s", l.Nodes)
}
// All returns all the child Nodes in a BodyNode.
func (l *BodyNode) All() []Node {
return l.Nodes
}
// TextNode represents raw, non Stick source code, like plain HTML.
type TextNode struct {
Pos
Data string // Textual data in the node.
}
// NewTextNode returns a TextNode.
func NewTextNode(data string, p Pos) *TextNode {
return &TextNode{p, data}
}
// String returns a string representation of a TextNode.
func (t *TextNode) String() string {
return fmt.Sprintf("Text(%s)", t.Data)
}
// All returns all the child Nodes in a TextNode.
func (t *TextNode) All() []Node {
return []Node{}
}
// CommentNode represents a comment.
type CommentNode struct {
*TextNode
TrimmableNode
}
// NewCommentNode returns a CommentNode.
func NewCommentNode(data string, p Pos) *CommentNode {
return &CommentNode{NewTextNode(data, p), TrimmableNode{}}
}
// PrintNode represents a print statement
type PrintNode struct {
Pos
TrimmableNode
X Expr // Expression to print.
}
// NewPrintNode returns a PrintNode.
func NewPrintNode(exp Expr, p Pos) *PrintNode {
return &PrintNode{p, TrimmableNode{}, exp}
}
// String returns a string representation of a PrintNode.
func (t *PrintNode) String() string {
return fmt.Sprintf("Print(%s)", t.X)
}
// All returns all the child Nodes in a PrintNode.
func (t *PrintNode) All() []Node {
return []Node{t.X}
}
// BlockNode represents a block statement
type BlockNode struct {
Pos
TrimmableNode
Name string // Name of the block.
Body Node // Body of the block.
Origin string // The name where this block is originally defined.
}
// NewBlockNode returns a BlockNode.
func NewBlockNode(name string, body Node, p Pos) *BlockNode {
return &BlockNode{p, TrimmableNode{}, name, body, ""}
}
// String returns a string representation of a BlockNode.
func (t *BlockNode) String() string {
return fmt.Sprintf("Block(%s: %s)", t.Name, t.Body)
}
// All returns all the child Nodes in a BlockNode.
func (t *BlockNode) All() []Node {
return []Node{t.Body}
}
// IfNode represents an if statement
type IfNode struct {
Pos
TrimmableNode
Cond Expr // Condition to test.
Body Node // Body to evaluate if Cond is true.
Else Node // Body if Cond is false.
}
// NewIfNode returns a IfNode.
func NewIfNode(cond Expr, body Node, els Node, p Pos) *IfNode {
return &IfNode{p, TrimmableNode{}, cond, body, els}
}
// String returns a string representation of an IfNode.
func (t *IfNode) String() string {
return fmt.Sprintf("If(%s: %s Else: %s)", t.Cond, t.Body, t.Else)
}
// All returns all the child Nodes in a IfNode.
func (t *IfNode) All() []Node {
return []Node{t.Cond, t.Body, t.Else}
}
// ExtendsNode represents an extends statement
type ExtendsNode struct {
Pos
TrimmableNode
Tpl Expr // Name of the template being extended.
}
// NewExtendsNode returns a ExtendsNode.
func NewExtendsNode(tplRef Expr, p Pos) *ExtendsNode {
return &ExtendsNode{p, TrimmableNode{}, tplRef}
}
// String returns a string representation of an ExtendsNode.
func (t *ExtendsNode) String() string {
return fmt.Sprintf("Extends(%s)", t.Tpl)
}
// All returns all the child Nodes in a ExtendsNode.
func (t *ExtendsNode) All() []Node {
return []Node{t.Tpl}
}
// ForNode represents a for loop construct.
type ForNode struct {
Pos
TrimmableNode
Key string // Name of key variable, or empty string.
Val string // Name of val variable.
X Expr // Expression to iterate over.
Body Node // Body of the for loop.
Else Node // Body of the else section if X is empty.
}
// NewForNode returns a ForNode.
func NewForNode(k, v string, expr Expr, body, els Node, p Pos) *ForNode {
return &ForNode{p, TrimmableNode{}, k, v, expr, body, els}
}
// String returns a string representation of a ForNode.
func (t *ForNode) String() string {
return fmt.Sprintf("For(%s, %s in %s: %s else %s)", t.Key, t.Val, t.X, t.Body, t.Else)
}
// All returns all the child Nodes in a ForNode.
func (t *ForNode) All() []Node {
return []Node{t.X, t.Body, t.Else}
}
// IncludeNode is an include statement.
type IncludeNode struct {
Pos
TrimmableNode
Tpl Expr // Expression evaluating to the name of the template to include.
With Expr // Explicit list of variables to include in the included template.
Only bool // If true, only vars defined in With will be passed.
}
// NewIncludeNode returns a IncludeNode.
func NewIncludeNode(tmpl Expr, with Expr, only bool, pos Pos) *IncludeNode {
return &IncludeNode{pos, TrimmableNode{}, tmpl, with, only}
}
// String returns a string representation of an IncludeNode.
func (t *IncludeNode) String() string {
return fmt.Sprintf("Include(%s with %s %v)", t.Tpl, t.With, t.Only)
}
// All returns all the child Nodes in a IncludeNode.
func (t *IncludeNode) All() []Node {
return []Node{t.Tpl, t.With}
}
// EmbedNode is a special include statement.
type EmbedNode struct {
*IncludeNode
Blocks map[string]*BlockNode // Blocks inside the embed body.
}
// NewEmbedNode returns a EmbedNode.
func NewEmbedNode(tmpl Expr, with Expr, only bool, blocks map[string]*BlockNode, pos Pos) *EmbedNode {
return &EmbedNode{NewIncludeNode(tmpl, with, only, pos), blocks}
}
// String returns a string representation of an EmbedNode.
func (t *EmbedNode) String() string {
return fmt.Sprintf("Embed(%s with %s %v: %v)", t.Tpl, t.With, t.Only, t.Blocks)
}
// All returns all the child Nodes in a EmbedNode.
func (t *EmbedNode) All() []Node {
r := t.IncludeNode.All()
for _, blk := range t.Blocks {
r = append(r, blk)
}
return r
}
// A UseNode represents the inclusion of blocks from another template.
// It is also possible to specify aliases for the imported blocks to avoid naming conflicts.
// {% use '::blocks.html.twig' with main as base_main, left as base_left %}
type UseNode struct {
Pos
TrimmableNode
Tpl Expr // Evaluates to the name of the template to include.
Aliases map[string]string // Aliases for included block names, if any.
}
// NewUseNode returns a UseNode.
func NewUseNode(tpl Expr, aliases map[string]string, pos Pos) *UseNode {
return &UseNode{pos, TrimmableNode{}, tpl, aliases}
}
// String returns a string representation of a UseNode.
func (t *UseNode) String() string {
if l := len(t.Aliases); l > 0 {
keys := make([]string, l)
i := 0
for orig := range t.Aliases {
keys[i] = orig
i++
}
sort.Strings(keys)
res := make([]string, l)
for i, orig := range keys {
res[i] = orig + ": " + t.Aliases[orig]
}
return fmt.Sprintf("Use(%s with %s)", t.Tpl, strings.Join(res, ", "))
}
return fmt.Sprintf("Use(%s)", t.Tpl)
}
// All returns all the child Nodes in a UseNode.
func (t *UseNode) All() []Node {
return []Node{t.Tpl}
}
// SetNode is a set operation on the given varName.
type SetNode struct {
Pos
TrimmableNode
Name string // Name of the var to set.
X Expr // Value of the var.
}
// NewSetNode returns a SetNode.
func NewSetNode(varName string, expr Expr, pos Pos) *SetNode {
return &SetNode{pos, TrimmableNode{}, varName, expr}
}
// String returns a string representation of an SetNode.
func (t *SetNode) String() string {
return fmt.Sprintf("Set(%s = %v)", t.Name, t.X)
}
// All returns all the child Nodes in a SetNode.
func (t *SetNode) All() []Node {
return []Node{t.X}
}
// DoNode simply executes the expression it contains.
type DoNode struct {
Pos
TrimmableNode
X Expr // The expression to evaluate.
}
// NewDoNode returns a DoNode.
func NewDoNode(expr Expr, pos Pos) *DoNode {
return &DoNode{pos, TrimmableNode{}, expr}
}
// String returns a string representation of an DoNode.
func (t *DoNode) String() string {
return fmt.Sprintf("Do(%v)", t.X)
}
// All returns all the child Nodes in a DoNode.
func (t *DoNode) All() []Node {
return []Node{t.X}
}
// FilterNode represents a block of filtered data.
type FilterNode struct {
Pos
TrimmableNode
Filters []string // Filters to apply to Body.
Body Node // Body of the filter tag.
}
// NewFilterNode creates a FilterNode.
func NewFilterNode(filters []string, body Node, p Pos) *FilterNode {
return &FilterNode{p, TrimmableNode{}, filters, body}
}
// String returns a string representation of a FilterNode.
func (t *FilterNode) String() string {
return fmt.Sprintf("Filter (%s): %s", strings.Join(t.Filters, "|"), t.Body)
}
// All returns all the child Nodes in a FilterNode.
func (t *FilterNode) All() []Node {
return []Node{t.Body}
}
// MacroNode represents a reusable macro.
type MacroNode struct {
Pos
TrimmableNode
Name string // Name of the macro.
Args []string // Args the macro receives.
Body *BodyNode // Body of the macro.
Origin string // The name where this macro is originally defined.
}
// NewMacroNode returns a MacroNode.
func NewMacroNode(name string, args []string, body *BodyNode, p Pos) *MacroNode {
return &MacroNode{p, TrimmableNode{}, name, args, body, ""}
}
// String returns a string representation of a MacroNode.
func (t *MacroNode) String() string {
return fmt.Sprintf("Macro %s(%s): %s", t.Name, strings.Join(t.Args, ", "), t.Body)
}
// All returns all the child Nodes in a MacroNode.
func (t *MacroNode) All() []Node {
return []Node{t.Body}
}
// ImportNode represents importing macros from another template.
type ImportNode struct {
Pos
TrimmableNode
Tpl Expr // Evaluates to the name of the template to include.
Alias string // Name of the var to be used as the base for any macros.
}
// NewImportNode returns a ImportNode.
func NewImportNode(tpl Expr, alias string, p Pos) *ImportNode {
return &ImportNode{p, TrimmableNode{}, tpl, alias}
}
// String returns a string representation of a ImportNode.
func (t *ImportNode) String() string {
return fmt.Sprintf("Import (%s as %s)", t.Tpl, t.Alias)
}
// All returns all the child Nodes in a ImportNode.
func (t *ImportNode) All() []Node {
return []Node{t.Tpl}
}
// FromNode represents an alternative form of importing macros.
type FromNode struct {
Pos
TrimmableNode
Tpl Expr // Evaluates to the name of the template to include.
Imports map[string]string // Imports to fetch from the included template.
}
// NewFromNode returns a FromNode.
func NewFromNode(tpl Expr, imports map[string]string, p Pos) *FromNode {
return &FromNode{p, TrimmableNode{}, tpl, imports}
}
// String returns a string representation of a FromNode.
func (t *FromNode) String() string {
keys := make([]string, len(t.Imports))
i := 0
for orig := range t.Imports {
keys[i] = orig
i++
}
sort.Strings(keys)
res := make([]string, len(t.Imports))
for i, orig := range keys {
if orig == t.Imports[orig] {
res[i] = orig
} else {
res[i] = orig + " as " + t.Imports[orig]
}
}
return fmt.Sprintf("From %s import %s", t.Tpl, strings.Join(res, ", "))
}
// All returns all the child Nodes in a FromNode.
func (t *FromNode) All() []Node {
return []Node{t.Tpl}
} | parse/node.go | 0.759047 | 0.569733 | node.go | starcoder |
package steven
import (
"math"
"github.com/thinkofdeath/steven/protocol"
"github.com/thinkofdeath/steven/type/vmath"
)
// Network
type networkComponent struct {
NetworkID int
entityID int
}
func (n *networkComponent) SetEntityID(id int) { n.entityID = id }
func (n *networkComponent) EntityID() int { return n.entityID }
type NetworkComponent interface {
SetEntityID(id int)
EntityID() int
}
// Position
type positionComponent struct {
CX, CZ int
X, Y, Z float64
}
func (p *positionComponent) Position() (x, y, z float64) {
return p.X, p.Y, p.Z
}
func (p *positionComponent) SetPosition(x, y, z float64) {
p.X, p.Y, p.Z = x, y, z
}
type PositionComponent interface {
Position() (x, y, z float64)
SetPosition(x, y, z float64)
}
// Target Position
type targetPositionComponent struct {
X, Y, Z float64
time float64
stillTime float64
pX, pY, pZ float64
sX, sY, sZ float64
}
func (p *targetPositionComponent) TargetPosition() (x, y, z float64) {
return p.X, p.Y, p.Z
}
func (p *targetPositionComponent) SetTargetPosition(x, y, z float64) {
p.X, p.Y, p.Z = x, y, z
}
type TargetPositionComponent interface {
TargetPosition() (x, y, z float64)
SetTargetPosition(x, y, z float64)
}
// Rotation
type rotationComponent struct {
yaw, pitch float64
}
func (r *rotationComponent) Yaw() float64 { return r.yaw }
func (r *rotationComponent) SetYaw(y float64) {
r.yaw = math.Mod(math.Pi*2+y, math.Pi*2)
}
func (r *rotationComponent) Pitch() float64 { return r.pitch }
func (r *rotationComponent) SetPitch(p float64) {
r.pitch = math.Mod(math.Pi*2+p, math.Pi*2)
}
type RotationComponent interface {
Yaw() float64
SetYaw(y float64)
Pitch() float64
SetPitch(p float64)
}
// Target Rotation
type targetRotationComponent struct {
yaw, pitch float64
time float64
pYaw, pPitch float64
sYaw, sPitch float64
}
func (r *targetRotationComponent) TargetYaw() float64 { return r.yaw }
func (r *targetRotationComponent) SetTargetYaw(y float64) {
r.yaw = math.Mod(math.Pi*2+y, math.Pi*2)
}
func (r *targetRotationComponent) TargetPitch() float64 { return r.pitch }
func (r *targetRotationComponent) SetTargetPitch(p float64) {
r.pitch = math.Mod(math.Pi*2+p, math.Pi*2)
}
type TargetRotationComponent interface {
TargetYaw() float64
SetTargetYaw(y float64)
TargetPitch() float64
SetTargetPitch(p float64)
}
// Size
type sizeComponent struct {
bounds vmath.AABB
}
func (s sizeComponent) Bounds() vmath.AABB { return s.bounds }
type SizeComponent interface {
Bounds() vmath.AABB
}
// Player
type playerComponent struct {
uuid protocol.UUID
}
func (p *playerComponent) SetUUID(u protocol.UUID) {
p.uuid = u
}
func (p *playerComponent) UUID() protocol.UUID {
return p.uuid
}
type PlayerComponent interface {
SetUUID(protocol.UUID)
UUID() protocol.UUID
}
// Debug
type debugComponent struct {
R, G, B byte
}
func (d debugComponent) DebugColor() (r, g, b byte) {
return d.R, d.G, d.B
}
type DebugComponent interface {
DebugColor() (r, g, b byte)
} | entityparts.go | 0.801276 | 0.405684 | entityparts.go | starcoder |
package array
import "reflect"
// ArrStr struct
type ArrStr string
// InArray check is in array
func (s ArrStr) InArray(val string, array []string) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrStr) Remove(array []string, value string) []string {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// Array Unique filtered
func (s ArrStr) Unique(intSlice []string) []string {
keys := make(map[string]bool)
list := []string{}
for _, entry := range intSlice {
if _, value := keys[entry]; !value {
keys[entry] = true
list = append(list, entry)
}
}
return list
}
// ArrUint struct
type ArrUint uint
// InArray check is in array
func (s ArrUint) InArray(val uint, array []uint) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrUint) Remove(array []uint, value uint) []uint {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// ArrUint32 struct
type ArrUint32 uint32
// InArray check is in array
func (s ArrUint32) InArray(val uint32, array []uint32) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrUint32) Remove(array []uint32, value uint32) []uint32 {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// ArrUint64 struct
type ArrUint64 uint64
// InArray check is in array
func (s ArrUint64) InArray(val uint64, array []uint64) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrUint64) Remove(array []uint64, value uint64) []uint64 {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// ArrInt64 struct
type ArrInt64 int64
// InArray check is in array
func (s ArrInt64) InArray(val int64, array []int64) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrInt64) Remove(array []int64, value int64) []int64 {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// ArrUint32 struct
type ArrInt32 int32
// InArray check is in array
func (s ArrInt32) InArray(val int32, array []int32) (exists bool, index int) {
exists = false
index = -1
for i, s := range array {
if s == val {
exists = true
index = i
return
}
}
return
}
// Remove member array
func (s ArrInt32) Remove(array []int32, value int32) []int32 {
isExist, index := s.InArray(value, array)
if isExist {
array = append(array[:index], array[(index+1):]...)
}
return array
}
// InArray check is in array
func InArray(val interface{}, array interface{}) (exists bool, index int) {
exists = false
index = -1
switch reflect.TypeOf(array).Kind() {
case reflect.Slice:
s := reflect.ValueOf(array)
for i := 0; i < s.Len(); i++ {
if reflect.DeepEqual(val, s.Index(i).Interface()) == true {
index = i
exists = true
return
}
}
}
return
}
// Remove member array
func Remove(array interface{}, value interface{}) interface{} {
switch reflect.TypeOf(array).Kind() {
case reflect.Slice:
isExist, index := InArray(value, array)
if isExist {
switch reflect.TypeOf(reflect.ValueOf(array).Index(0).Interface()).Kind() {
case reflect.Bool:
array = append(array.([]bool)[:index], array.([]bool)[(index+1):]...)
case reflect.Int:
array = append(array.([]int)[:index], array.([]int)[(index+1):]...)
case reflect.Int8:
array = append(array.([]int8)[:index], array.([]int8)[(index+1):]...)
case reflect.Int16:
array = append(array.([]int16)[:index], array.([]int16)[(index+1):]...)
case reflect.Int32:
array = append(array.([]int32)[:index], array.([]int32)[(index+1):]...)
case reflect.Int64:
array = append(array.([]int64)[:index], array.([]int64)[(index+1):]...)
case reflect.Uint:
array = append(array.([]uint)[:index], array.([]uint)[(index+1):]...)
case reflect.Uint8:
array = append(array.([]uint8)[:index], array.([]uint8)[(index+1):]...)
case reflect.Uint16:
array = append(array.([]uint16)[:index], array.([]uint16)[(index+1):]...)
case reflect.Uint32:
array = append(array.([]uint32)[:index], array.([]uint32)[(index+1):]...)
case reflect.Uint64:
array = append(array.([]uint64)[:index], array.([]uint64)[(index+1):]...)
case reflect.Float32:
array = append(array.([]float32)[:index], array.([]float32)[(index+1):]...)
case reflect.Float64:
array = append(array.([]float64)[:index], array.([]float64)[(index+1):]...)
case reflect.String:
array = append(array.([]string)[:index], array.([]string)[(index+1):]...)
}
}
}
return array
}
// Array Unique filtered
func (s ArrInt32) Unique(intSlice []int32) []int32 {
keys := make(map[int32]bool)
list := []int32{}
for _, entry := range intSlice {
if _, value := keys[entry]; !value {
keys[entry] = true
list = append(list, entry)
}
}
return list
} | lib/array/array.go | 0.515132 | 0.570152 | array.go | starcoder |
package click
import (
"github.com/barkimedes/go-deepcopy"
"github.com/chewxy/math32"
"sort"
)
// EvaluateRegression evaluates factorization machines in regression task.
func EvaluateRegression(estimator FactorizationMachine, testSet *Dataset) Score {
sum := float32(0)
// For all UserFeedback
for i := 0; i < testSet.Count(); i++ {
features, values, target := testSet.Get(i)
prediction := estimator.InternalPredict(features, values)
sum += (target - prediction) * (target - prediction)
}
if 0 == testSet.Count() {
return Score{
Task: FMRegression,
RMSE: 0,
}
}
return Score{
Task: FMRegression,
RMSE: math32.Sqrt(sum / float32(testSet.Count())),
}
}
// EvaluateClassification evaluates factorization machines in classification task.
func EvaluateClassification(estimator FactorizationMachine, testSet *Dataset) Score {
// For all UserFeedback
var posPrediction, negPrediction []float32
for i := 0; i < testSet.Count(); i++ {
features, values, target := testSet.Get(i)
prediction := estimator.InternalPredict(features, values)
if target > 0 {
posPrediction = append(posPrediction, prediction)
} else {
negPrediction = append(negPrediction, prediction)
}
}
if 0 == testSet.Count() {
return Score{
Task: FMClassification,
Precision: 0,
}
}
return Score{
Task: FMClassification,
Precision: Precision(posPrediction, negPrediction),
Recall: Recall(posPrediction, negPrediction),
Accuracy: Accuracy(posPrediction, negPrediction),
AUC: AUC(posPrediction, negPrediction),
}
}
func Precision(posPrediction, negPrediction []float32) float32 {
var tp, fp float32
for _, p := range posPrediction {
if p > 0 { // true positive
tp++
}
}
for _, p := range negPrediction {
if p > 0 { // false positive
fp++
}
}
if tp+fp == 0 {
return 0
}
return tp / (tp + fp)
}
func Recall(posPrediction, _ []float32) float32 {
var tp, fn float32
for _, p := range posPrediction {
if p > 0 { // true positive
tp++
} else { // false negative
fn++
}
}
if tp+fn == 0 {
return 0
}
return tp / (tp + fn)
}
func Accuracy(posPrediction, negPrediction []float32) float32 {
var correct float32
for _, p := range posPrediction {
if p > 0 {
correct++
}
}
for _, p := range negPrediction {
if p < 0 {
correct++
}
}
if len(posPrediction)+len(negPrediction) == 0 {
return 0
}
return correct / float32(len(posPrediction)+len(negPrediction))
}
func AUC(posPrediction, negPrediction []float32) float32 {
sort.Slice(posPrediction, func(i, j int) bool { return posPrediction[i] < posPrediction[j] })
sort.Slice(negPrediction, func(i, j int) bool { return negPrediction[i] < negPrediction[j] })
var sum float32
var nPos int
for pPos := range posPrediction {
// find the negative sample with the greatest prediction less than current positive sample
for nPos < len(negPrediction) && negPrediction[nPos] < posPrediction[pPos] {
nPos++
}
// add the number of negative samples have less prediction than current positive sample
sum += float32(nPos)
}
if len(posPrediction)*len(negPrediction) == 0 {
return 0
}
return sum / float32(len(posPrediction)*len(negPrediction))
}
// SnapshotManger manages the best snapshot.
type SnapshotManger struct {
BestWeights []interface{}
BestScore Score
}
// AddSnapshot adds a copied snapshot.
func (sm *SnapshotManger) AddSnapshot(score Score, weights ...interface{}) {
if sm.BestWeights == nil || score.BetterThan(sm.BestScore) {
sm.BestScore = score
if temp, err := deepcopy.Anything(weights); err != nil {
panic(err)
} else {
sm.BestWeights = temp.([]interface{})
}
}
} | model/click/evaluator.go | 0.665193 | 0.567637 | evaluator.go | starcoder |
package qoi
import (
"bufio"
"image"
"image/color"
"io"
)
type opRGB color.NRGBA
func newOpRGB(r *imageReader, previous color.NRGBA) chunk {
if r.c.A != previous.A {
return nil
}
defer r.next()
return &opRGB{R: r.c.R, G: r.c.G, B: r.c.B}
}
func (op *opRGB) decode(r *bufio.Reader) error {
var buf [4]uint8
_, err := io.ReadFull(r, buf[:])
*op = opRGB{R: buf[1], G: buf[2], B: buf[3]}
return err
}
func (op opRGB) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
op.A = previous.A
return opRGBA(op).set(img, x, y, cc, previous)
}
func (op opRGB) encode(w *bufio.Writer) {
w.Write([]byte{byte(opTagRGB), op.R, op.G, op.B})
}
type opRGBA color.NRGBA
func newOpRGBA(r *imageReader) chunk {
defer r.next()
return (*opRGBA)(r.c)
}
func (op *opRGBA) decode(r *bufio.Reader) error {
var buf [5]uint8
_, err := io.ReadFull(r, buf[:])
*op = opRGBA{R: buf[1], G: buf[2], B: buf[3], A: buf[4]}
return err
}
func (op opRGBA) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
n = 1
c = color.NRGBA(op)
img.SetNRGBA(x, y, c)
return
}
func (op opRGBA) encode(w *bufio.Writer) {
w.Write([]byte{byte(opTagRGBA), op.R, op.G, op.B, op.A})
}
type opIndex uint8
func newOpIndex(r *imageReader, cc *colorCache) chunk {
idx := cc.get(*r.c)
if idx < 0 {
return nil
}
r.next()
op := opIndex(idx)
return &op
}
func (op *opIndex) decode(r *bufio.Reader) error {
buf, err := r.ReadByte()
buf &= 0b00111111
*op = opIndex(buf)
return err
}
func (op opIndex) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
n = 1
c = cc[op]
img.SetNRGBA(x, y, c)
return
}
func (op opIndex) encode(w *bufio.Writer) {
w.WriteByte(byte(opTagIndex) | byte(op))
}
type opDiff struct {
dr, dg, db int8
}
func newOpDiff(r *imageReader, previous color.NRGBA) chunk {
if r.c.A != previous.A {
return nil
}
var op opDiff
op.dr = int8(r.c.R - previous.R)
op.dg = int8(r.c.G - previous.G)
op.db = int8(r.c.B - previous.B)
if op.dr < -2 || op.dr > 1 {
return nil
}
if op.dg < -2 || op.dg > 1 {
return nil
}
if op.db < -2 || op.db > 1 {
return nil
}
r.next()
return &op
}
func (op *opDiff) decode(r *bufio.Reader) error {
buf, err := r.ReadByte()
op.dr = int8((buf&0b00110000)>>4) - 2
op.dg = int8((buf&0b00001100)>>2) - 2
op.db = int8((buf&0b00000011)>>0) - 2
return err
}
func (op opDiff) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
n = 1
c.R = uint8(int8(previous.R) + op.dr)
c.G = uint8(int8(previous.G) + op.dg)
c.B = uint8(int8(previous.B) + op.db)
c.A = previous.A
img.SetNRGBA(x, y, c)
return
}
func (op opDiff) encode(w *bufio.Writer) {
w.WriteByte(byte(opTagDiff) | (byte(op.dr+2) << 4) | (byte(op.dg+2) << 2) | byte(op.db+2))
}
type opLuma struct {
dg int8
drdg int8
dbdg int8
}
func newOpLuma(r *imageReader, previous color.NRGBA) chunk {
if r.c.A != previous.A {
return nil
}
var op opLuma
op.dg = int8(r.c.G - previous.G)
op.drdg = int8(r.c.R-previous.R) - op.dg
op.dbdg = int8(r.c.B-previous.B) - op.dg
if op.dg < -32 || op.dg > 31 {
return nil
}
if op.drdg < -8 || op.drdg > 7 {
return nil
}
if op.dbdg < -8 || op.dbdg > 7 {
return nil
}
r.next()
return &op
}
func (op *opLuma) decode(r *bufio.Reader) error {
var buf [2]uint8
_, err := io.ReadFull(r, buf[:])
*op = opLuma{
dg: int8(buf[0]&0b00111111) - 32,
drdg: int8(buf[1]&0b11110000>>4) - 8,
dbdg: int8(buf[1]&0b00001111>>0) - 8,
}
return err
}
func (op opLuma) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
n = 1
c.R = uint8(int8(previous.R) + op.dg + op.drdg)
c.G = uint8(int8(previous.G) + op.dg)
c.B = uint8(int8(previous.B) + op.dg + op.dbdg)
c.A = previous.A
img.SetNRGBA(x, y, c)
return
}
func (op opLuma) encode(w *bufio.Writer) {
w.WriteByte(byte(opTagLuma) | byte(op.dg+32))
w.WriteByte((byte(op.drdg+8) << 4) | byte(op.dbdg+8))
}
type opRun uint8
func newOpRun(r *imageReader, previous color.NRGBA) chunk {
var run uint8
for r.c != nil && *r.c == previous && run < 62 {
run++
r.next()
}
if run == 0 {
return nil
}
return (*opRun)(&run)
}
func (op *opRun) decode(r *bufio.Reader) error {
buf, err := r.ReadByte()
buf &= 0b00111111
buf++
*op = opRun(buf)
return err
}
func (op opRun) set(img *image.NRGBA, x, y int, cc *colorCache, previous color.NRGBA) (n int, c color.NRGBA) {
n = int(op)
c = previous
for i := 1; i <= n; i++ {
j := img.PixOffset(x, y)
if j+4 > len(img.Pix) {
return i, c
}
s := img.Pix[j : j+4 : j+4]
s[0] = c.R
s[1] = c.G
s[2] = c.B
s[3] = c.A
x++
}
return
}
func (op opRun) encode(w *bufio.Writer) {
w.WriteByte(byte(opTagRun) | byte(op-1))
} | ops.go | 0.664323 | 0.51623 | ops.go | starcoder |
package ecs
const MaxFlagCapacity = 256
// Flag is a 256 bit binary flag
type Flag [4]uint64
// Clone returns a new flag with identical data
func (f Flag) Clone() Flag {
return Flag{f[0], f[1], f[2], f[3]}
}
// Equals checs if g contains the same bits
func (f Flag) Equals(g Flag) bool {
return f[0] == g[0] && f[1] == g[1] && f[2] == g[2] && f[3] == g[3]
}
// Xor bitwise (f ^ g)
func (f Flag) Xor(g Flag) Flag {
return Flag{f[0] ^ g[0], f[1] ^ g[1], f[2] ^ g[2], f[3] ^ g[3]}
}
// And bitwise (f & g)
func (f Flag) And(g Flag) Flag {
return Flag{f[0] & g[0], f[1] & g[1], f[2] & g[2], f[3] & g[3]}
}
// Or bitwise (f | g)
func (f Flag) Or(g Flag) Flag {
return Flag{f[0] | g[0], f[1] | g[1], f[2] | g[2], f[3] | g[3]}
}
// Contains tests if (f & g == g)
func (f Flag) Contains(g Flag) bool {
return f.And(g).Equals(g)
}
// ContainsAny tests if f contains at least one bit of g
func (f Flag) ContainsAny(g Flag) bool {
return !f.And(g).IsZero()
}
// IsZero returns true if all bits are zero
func (f Flag) IsZero() bool {
return f[0] == 0 && f[1] == 0 && f[2] == 0 && f[3] == 0
}
// Lowest bit position (set to 1)
func (f Flag) Lowest() uint8 {
ff := uint64(0xffffffffffffffff)
if f[0]&ff > 0 {
v, _ := ubit(f[0])
return v
}
if f[1]&ff > 0 {
v, _ := ubit(f[1])
return v + 64
}
if f[2]&ff > 0 {
v, _ := ubit(f[2])
return v + 128
}
if f[3]&ff > 0 {
v, _ := ubit(f[3])
return v + 192
}
return 0
}
func ubit(v uint64) (uint8, bool) {
for i := 0; i < 64; i++ {
if v&(uint64(1<<i)) == (uint64(1 << i)) {
return uint8(i), true
}
}
return 0, false
}
// NewFlagRaw creates a new flag
func NewFlagRaw(a, b, c, d uint64) Flag {
return Flag{a, b, c, d}
}
// NewFlag creates a new flag
func NewFlag(bit uint8) Flag {
var a, b, c, d uint64
if bit >= 192 {
d = 1 << (bit - 192)
} else if bit >= 128 {
c = 1 << (bit - 128)
} else if bit >= 64 {
b = 1 << (bit - 64)
} else {
a = 1 << bit
}
return Flag{a, b, c, d}
}
// MergeFlags performs an OR operation to return a single flag
func MergeFlags(f ...Flag) Flag {
out := Flag{}
for _, v := range f {
out = out.Or(v)
}
return out
} | flag.go | 0.702836 | 0.428712 | flag.go | starcoder |
package main
// Shapable provides the basic geometry of a primitive shape
type Shapable interface {
Bounds() Box
LocalNormalAt(Tuple) Tuple
LocalIntersect(Ray) []float64
NormalAtHit(Tuple, *IntersectionInfo) Tuple
}
// Shape is an higher level object that represents a geometric primitive,
// it uses the Shapable interface for anything related to the shape geometry
type Shape struct {
Namer
Grouper
material *Material
shapable Shapable
shadow bool
Locked bool
}
func NewShape(kind string, shapable Shapable) *Shape {
s := &Shape{}
s.material = NewMaterial()
s.shapable = shapable
s.shadow = true
s.SetNameForKind(kind)
s.SetTransform()
return s
}
func (s *Shape) Clone() Groupable {
o := NewShape("", s.shapable)
o.material = s.material
o.shadow = s.shadow
o.SetName("shape_from_" + s.Name())
o.SetTransform(s.Transform())
return o
}
func (s *Shape) Material() *Material {
return s.material
}
func (s *Shape) SetMaterial(m *Material) {
if !s.Locked {
s.material = m
}
}
func (s *Shape) SetLocked(f bool) {
s.Locked = f // Used for testing and for special objects like bounding boxes: disallows setting some shape properties
}
func (s *Shape) SetShadow(f bool) {
s.shadow = f
}
func (s *Shape) Parent() Container {
return s.parent
}
func (s *Shape) Intersect(ray Ray) *Intersections { // Self-contained but slow: currently used only for testing
xs := NewIntersections()
s.AddIntersections(ray, xs)
return xs
}
func (s *Shape) AddIntersections(ray Ray, xs *Intersections) {
// If looking for shadows and this shape does not cast one, exit now
if xs.shadows && !s.shadow {
return
}
ray = ray.Transform(s.Tinverse)
localxs := s.shapable.LocalIntersect(ray)
xs.Add(s, localxs...)
}
// NormalAt returns the normal at the specified point on this shape,
// it has been replaced by NormalAtHit() and now used only for tests.
func (s *Shape) NormalAt(point Tuple) Tuple {
ii := IntersectionInfo{Point: point}
return s.NormalAtHit(&ii, nil)
}
// NormalAtHit returns the normal at an intersection point on this shape,
// it may also fill other information in the IntersectionInfo (e.g. the u,v surface coords)
func (s *Shape) NormalAtHit(ii *IntersectionInfo, xs *Intersections) Tuple {
// Convert the point into object space, so it can be handled by the simple primitive
point := s.WorldToObject(ii.Point)
// Get the normal in object space, may fill other info as well
normal := s.shapable.NormalAtHit(point, ii)
if ii.HasSurfNormalv {
ii.SurfNormalv = s.NormalToWorld(ii.SurfNormalv)
}
// Return the normal in world space
return s.NormalToWorld(normal)
}
// Make a shape a Shapable object itself
func (s *Shape) Bounds() Box {
return s.shapable.Bounds()
}
func (s *Shape) LocalNormalAt(point Tuple) Tuple {
return s.NormalAt(point)
}
func (s *Shape) LocalIntersect(ray Ray) []float64 {
ray = ray.Transform(s.Tinverse)
return s.shapable.LocalIntersect(ray)
} | shape.go | 0.901781 | 0.620449 | shape.go | starcoder |
package onshape
import (
"encoding/json"
)
// BTPStatementLoopForIn279AllOf struct for BTPStatementLoopForIn279AllOf
type BTPStatementLoopForIn279AllOf struct {
BtType *string `json:"btType,omitempty"`
Container *BTPExpression9 `json:"container,omitempty"`
IsVarDeclaredHere *bool `json:"isVarDeclaredHere,omitempty"`
Name *BTPIdentifier8 `json:"name,omitempty"`
SpaceBeforeVar *BTPSpace10 `json:"spaceBeforeVar,omitempty"`
StandardType *string `json:"standardType,omitempty"`
TypeName *string `json:"typeName,omitempty"`
Var *BTPIdentifier8 `json:"var,omitempty"`
}
// NewBTPStatementLoopForIn279AllOf instantiates a new BTPStatementLoopForIn279AllOf object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewBTPStatementLoopForIn279AllOf() *BTPStatementLoopForIn279AllOf {
this := BTPStatementLoopForIn279AllOf{}
return &this
}
// NewBTPStatementLoopForIn279AllOfWithDefaults instantiates a new BTPStatementLoopForIn279AllOf object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewBTPStatementLoopForIn279AllOfWithDefaults() *BTPStatementLoopForIn279AllOf {
this := BTPStatementLoopForIn279AllOf{}
return &this
}
// GetBtType returns the BtType field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetBtType() string {
if o == nil || o.BtType == nil {
var ret string
return ret
}
return *o.BtType
}
// GetBtTypeOk returns a tuple with the BtType field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetBtTypeOk() (*string, bool) {
if o == nil || o.BtType == nil {
return nil, false
}
return o.BtType, true
}
// HasBtType returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasBtType() bool {
if o != nil && o.BtType != nil {
return true
}
return false
}
// SetBtType gets a reference to the given string and assigns it to the BtType field.
func (o *BTPStatementLoopForIn279AllOf) SetBtType(v string) {
o.BtType = &v
}
// GetContainer returns the Container field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetContainer() BTPExpression9 {
if o == nil || o.Container == nil {
var ret BTPExpression9
return ret
}
return *o.Container
}
// GetContainerOk returns a tuple with the Container field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetContainerOk() (*BTPExpression9, bool) {
if o == nil || o.Container == nil {
return nil, false
}
return o.Container, true
}
// HasContainer returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasContainer() bool {
if o != nil && o.Container != nil {
return true
}
return false
}
// SetContainer gets a reference to the given BTPExpression9 and assigns it to the Container field.
func (o *BTPStatementLoopForIn279AllOf) SetContainer(v BTPExpression9) {
o.Container = &v
}
// GetIsVarDeclaredHere returns the IsVarDeclaredHere field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetIsVarDeclaredHere() bool {
if o == nil || o.IsVarDeclaredHere == nil {
var ret bool
return ret
}
return *o.IsVarDeclaredHere
}
// GetIsVarDeclaredHereOk returns a tuple with the IsVarDeclaredHere field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetIsVarDeclaredHereOk() (*bool, bool) {
if o == nil || o.IsVarDeclaredHere == nil {
return nil, false
}
return o.IsVarDeclaredHere, true
}
// HasIsVarDeclaredHere returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasIsVarDeclaredHere() bool {
if o != nil && o.IsVarDeclaredHere != nil {
return true
}
return false
}
// SetIsVarDeclaredHere gets a reference to the given bool and assigns it to the IsVarDeclaredHere field.
func (o *BTPStatementLoopForIn279AllOf) SetIsVarDeclaredHere(v bool) {
o.IsVarDeclaredHere = &v
}
// GetName returns the Name field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetName() BTPIdentifier8 {
if o == nil || o.Name == nil {
var ret BTPIdentifier8
return ret
}
return *o.Name
}
// GetNameOk returns a tuple with the Name field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetNameOk() (*BTPIdentifier8, bool) {
if o == nil || o.Name == nil {
return nil, false
}
return o.Name, true
}
// HasName returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasName() bool {
if o != nil && o.Name != nil {
return true
}
return false
}
// SetName gets a reference to the given BTPIdentifier8 and assigns it to the Name field.
func (o *BTPStatementLoopForIn279AllOf) SetName(v BTPIdentifier8) {
o.Name = &v
}
// GetSpaceBeforeVar returns the SpaceBeforeVar field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetSpaceBeforeVar() BTPSpace10 {
if o == nil || o.SpaceBeforeVar == nil {
var ret BTPSpace10
return ret
}
return *o.SpaceBeforeVar
}
// GetSpaceBeforeVarOk returns a tuple with the SpaceBeforeVar field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetSpaceBeforeVarOk() (*BTPSpace10, bool) {
if o == nil || o.SpaceBeforeVar == nil {
return nil, false
}
return o.SpaceBeforeVar, true
}
// HasSpaceBeforeVar returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasSpaceBeforeVar() bool {
if o != nil && o.SpaceBeforeVar != nil {
return true
}
return false
}
// SetSpaceBeforeVar gets a reference to the given BTPSpace10 and assigns it to the SpaceBeforeVar field.
func (o *BTPStatementLoopForIn279AllOf) SetSpaceBeforeVar(v BTPSpace10) {
o.SpaceBeforeVar = &v
}
// GetStandardType returns the StandardType field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetStandardType() string {
if o == nil || o.StandardType == nil {
var ret string
return ret
}
return *o.StandardType
}
// GetStandardTypeOk returns a tuple with the StandardType field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetStandardTypeOk() (*string, bool) {
if o == nil || o.StandardType == nil {
return nil, false
}
return o.StandardType, true
}
// HasStandardType returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasStandardType() bool {
if o != nil && o.StandardType != nil {
return true
}
return false
}
// SetStandardType gets a reference to the given string and assigns it to the StandardType field.
func (o *BTPStatementLoopForIn279AllOf) SetStandardType(v string) {
o.StandardType = &v
}
// GetTypeName returns the TypeName field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetTypeName() string {
if o == nil || o.TypeName == nil {
var ret string
return ret
}
return *o.TypeName
}
// GetTypeNameOk returns a tuple with the TypeName field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetTypeNameOk() (*string, bool) {
if o == nil || o.TypeName == nil {
return nil, false
}
return o.TypeName, true
}
// HasTypeName returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasTypeName() bool {
if o != nil && o.TypeName != nil {
return true
}
return false
}
// SetTypeName gets a reference to the given string and assigns it to the TypeName field.
func (o *BTPStatementLoopForIn279AllOf) SetTypeName(v string) {
o.TypeName = &v
}
// GetVar returns the Var field value if set, zero value otherwise.
func (o *BTPStatementLoopForIn279AllOf) GetVar() BTPIdentifier8 {
if o == nil || o.Var == nil {
var ret BTPIdentifier8
return ret
}
return *o.Var
}
// GetVarOk returns a tuple with the Var field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *BTPStatementLoopForIn279AllOf) GetVarOk() (*BTPIdentifier8, bool) {
if o == nil || o.Var == nil {
return nil, false
}
return o.Var, true
}
// HasVar returns a boolean if a field has been set.
func (o *BTPStatementLoopForIn279AllOf) HasVar() bool {
if o != nil && o.Var != nil {
return true
}
return false
}
// SetVar gets a reference to the given BTPIdentifier8 and assigns it to the Var field.
func (o *BTPStatementLoopForIn279AllOf) SetVar(v BTPIdentifier8) {
o.Var = &v
}
func (o BTPStatementLoopForIn279AllOf) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if o.BtType != nil {
toSerialize["btType"] = o.BtType
}
if o.Container != nil {
toSerialize["container"] = o.Container
}
if o.IsVarDeclaredHere != nil {
toSerialize["isVarDeclaredHere"] = o.IsVarDeclaredHere
}
if o.Name != nil {
toSerialize["name"] = o.Name
}
if o.SpaceBeforeVar != nil {
toSerialize["spaceBeforeVar"] = o.SpaceBeforeVar
}
if o.StandardType != nil {
toSerialize["standardType"] = o.StandardType
}
if o.TypeName != nil {
toSerialize["typeName"] = o.TypeName
}
if o.Var != nil {
toSerialize["var"] = o.Var
}
return json.Marshal(toSerialize)
}
type NullableBTPStatementLoopForIn279AllOf struct {
value *BTPStatementLoopForIn279AllOf
isSet bool
}
func (v NullableBTPStatementLoopForIn279AllOf) Get() *BTPStatementLoopForIn279AllOf {
return v.value
}
func (v *NullableBTPStatementLoopForIn279AllOf) Set(val *BTPStatementLoopForIn279AllOf) {
v.value = val
v.isSet = true
}
func (v NullableBTPStatementLoopForIn279AllOf) IsSet() bool {
return v.isSet
}
func (v *NullableBTPStatementLoopForIn279AllOf) Unset() {
v.value = nil
v.isSet = false
}
func NewNullableBTPStatementLoopForIn279AllOf(val *BTPStatementLoopForIn279AllOf) *NullableBTPStatementLoopForIn279AllOf {
return &NullableBTPStatementLoopForIn279AllOf{value: val, isSet: true}
}
func (v NullableBTPStatementLoopForIn279AllOf) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullableBTPStatementLoopForIn279AllOf) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | onshape/model_btp_statement_loop_for_in_279_all_of.go | 0.685423 | 0.461381 | model_btp_statement_loop_for_in_279_all_of.go | starcoder |
// Advent of Code 2017 Day 10 Part 2 hash function.
package hashaoc17;
// In-place reverse a subsequence of the circular buffer
// ring starting at posn and with length length.
func circularReverse(ring *[256]uint8, posn int, length uint8) {
// Swap start position within the reversal.
i := 0
// Loop until the indices meet/cross, which
// will mean that everything has been reversed.
for {
// Swap end position within the reversal.
j := int(length) - 1 - i
// If the end has met/crossed the start,
// get out.
if j <= i {
break
}
// Swap start and end position within the
// ring.
pi := (posn + i) % 256
pj := (posn + j) % 256
// Make the swap.
ring[pi], ring[pj] = ring[pj], ring[pi]
// Advance the position.
i++
}
}
// The hash function from Advent of Code Day 2017 Day 10
// Part 2. Given an input byte slice, return a 16-byte
// "cryptographic" hash of that input.
func HashAoC17(input []uint8) [16]uint8 {
// The ring.
var ring [256]uint8
for i := range ring {
ring[i] = uint8(i)
}
// Position in ring.
posn := 0
// Skip count in ring.
skip := 0
// Treat the input as ASCII (Unicode)
// characters.
// "Extra" characters to stick on the end.
extras := []uint8 {17, 31, 73, 47, 23}
// Build the lengths array as specified.
lengths := make([]uint8, len(input) + len(extras))
for i, v := range input {
lengths[i] = v
}
for i, v := range extras {
lengths[len(input) + i] = v
}
// Run the rounds.
for i := 0; i < 64; i++ {
// Run a round.
for _, length := range lengths {
// Do the reversal.
circularReverse(&ring, posn, length)
// Advance the position.
posn = (posn + int(length) + skip) % 256
// Increment the skip.
skip++
}
}
// Set up the result.
var result [16]uint8
nb := 0
// Get the checksum for each block.
for b := 0; b < 256; b += 16 {
// Can start with 0 since x ^ 0 == x.
h := uint8(0)
// Xor in all the characters.
for i := 0; i < 16; i++ {
h = h ^ ring[b + i]
}
// Store the block
result[nb] = h
nb++
}
// Return the checksum.
return result
} | src/hashaoc17/hashaoc17.go | 0.617859 | 0.411702 | hashaoc17.go | starcoder |
package alt
// #include <stdlib.h>
// #include "Module.h"
import "C"
import (
"unsafe"
"github.com/shockdev04/altv-go-pkg/internal/module"
)
type ColShape struct {
WorldObject
}
func NewColShape(c unsafe.Pointer) *ColShape {
colShape := &ColShape{}
colShape.Ptr = c
colShape.Type = ColshapeObject
return colShape
}
func CreateColShapeCircle(x float32, y float32, z float32, radius float32) *ColShape {
ptr := C.core_create_col_shape_circle(C.float(x), C.float(y), C.float(z), C.float(radius))
return NewColShape(ptr)
}
func CreateColShapeCube(x1 float32, y1 float32, z1 float32, x2 float32, y2 float32, z2 float32) *ColShape {
ptr := C.core_create_col_shape_cube(C.float(x1), C.float(y1), C.float(z1), C.float(x2), C.float(y2), C.float(z2))
return NewColShape(ptr)
}
func CreateColShapeCylinder(x float32, y float32, z float32, radius float32, height float32) *ColShape {
ptr := C.core_create_col_shape_cylinder(C.float(x), C.float(y), C.float(z),C.float(radius), C.float(height))
return NewColShape(ptr)
}
func CreateColShapeRectangle(x1 float32, y1 float32, x2 float32, y2 float32, z float32) *ColShape {
ptr := C.core_create_col_shape_rectangle(C.float(x1), C.float(y1), C.float(x2), C.float(y2), C.float(z))
return NewColShape(ptr)
}
func CreateColShapeSphere(x float32, y float32, z float32, radius float32) *ColShape {
ptr := C.core_create_col_shape_sphere(C.float(x), C.float(y), C.float(z), C.float(radius))
return NewColShape(ptr)
}
func (c ColShape) IsPlayersOnly() bool {
if c.Type == ColshapeObject {
return int(C.col_shape_is_players_only(c.Ptr)) == 1
} else if c.Type == CheckpointObject {
return int(C.checkpoint_is_players_only(c.Ptr)) == 1
}
return false
}
func (c ColShape) SetPlayersOnly(state bool) {
if c.Type == ColshapeObject {
C.col_shape_set_players_only(c.Ptr, C.int(module.Bool2int(state)))
} else if c.Type == CheckpointObject {
C.checkpoint_set_players_only(c.Ptr, C.int(module.Bool2int(state)))
}
}
func (c ColShape) IsPointIn(pos Vector3) bool {
if c.Type == ColshapeObject {
return int(C.col_shape_is_point_in(c.Ptr, C.float(pos.X), C.float(pos.Y), C.float(pos.Z))) == 1
} else if c.Type == CheckpointObject {
return int(C.checkpoint_is_point_in(c.Ptr, C.float(pos.X), C.float(pos.Y), C.float(pos.Z))) == 1
}
return false
}
func (c ColShape) IsEntityIn(entity *Entity) bool {
if c.Type == ColshapeObject {
return int(C.col_shape_is_entity_in(c.Ptr, entity.Ptr)) == 1
} else if c.Type == CheckpointObject {
return int(C.checkpoint_is_entity_in(c.Ptr, entity.Ptr)) == 1
}
return false
}
func (c ColShape) ColShapeType() int8 {
if c.Type == ColshapeObject {
return int8(C.col_shape_get_col_shape_type(c.Ptr))
} else if c.Type == CheckpointObject {
return int8(C.checkpoint_get_col_shape_type(c.Ptr))
}
return 0
} | alt/colshape.go | 0.521715 | 0.585338 | colshape.go | starcoder |
package ai
import (
"math"
"math/rand"
"time"
"github.com/lukechampine/tenten/game"
)
const monteC = 1.414 // uct tradeoff parameter; low = choose high value nodes, high = choose unexplored nodes
type Move struct {
Piece game.Piece
X, Y int
}
func BestMoves(b *game.Board, bag [3]game.Piece, timeLimit time.Duration) ([3]Move, int) {
perms := [][3]game.Piece{
{bag[0], bag[1], bag[2]},
{bag[0], bag[2], bag[1]},
{bag[1], bag[0], bag[2]},
{bag[1], bag[2], bag[0]},
{bag[2], bag[0], bag[1]},
{bag[2], bag[1], bag[0]},
}
trees := make([]*tree, len(perms))
for i, perm := range perms {
trees[i] = newTree(b, perm)
}
start := time.Now()
for time.Since(start) < timeLimit {
for _, tree := range trees {
tree.expand()
}
}
bestTree := trees[0]
movesEvaluated := trees[0].root.N
for _, tree := range trees[1:] {
if tree.root.W > bestTree.root.W {
bestTree = tree
}
movesEvaluated += tree.root.N
}
return bestTree.bestMoves(), movesEvaluated
}
type tree struct {
origBoard *game.Board
expandBoard *game.Board
root *treeNode
leaves []*treeNode
}
func (t *tree) expand() {
// locate node with best UCT, applying each move as we descend
t.origBoard.Copy(t.expandBoard)
toExpand := t.root
for len(toExpand.leaves) > 0 {
toExpand = toExpand.highestUCTChild()
t.expandBoard.Place(toExpand.move.Piece, toExpand.move.X, toExpand.move.Y)
}
toExpand.expand(t.expandBoard)
}
func (t *tree) bestMoves() [3]Move {
t1 := t.root.highestValueChild()
t2 := t1.highestValueChild()
t3 := t2.highestValueChild()
return [3]Move{t1.move, t2.move, t3.move}
}
func newTree(b *game.Board, bag [3]game.Piece) *tree {
t := &tree{
origBoard: b,
expandBoard: new(game.Board),
root: &treeNode{leaves: make([]*treeNode, 0, 100)},
}
// first move
for x0 := 0; x0 <= 10-bag[0].Width(); x0++ {
for y0 := 0; y0 <= 10-bag[0].Height(); y0++ {
b.Copy(t.expandBoard)
if t.expandBoard.Place(bag[0], x0, y0) == 0 {
continue
}
move0 := &treeNode{
move: Move{bag[0], x0, y0},
parent: t.root,
leaves: make([]*treeNode, 0, 100),
}
score := rollout(t.expandBoard)
move0.propagate(score)
t.root.leaves = append(t.root.leaves, move0)
// second move
for x1 := 0; x1 <= 10-bag[1].Width(); x1++ {
for y1 := 0; y1 <= 10-bag[1].Height(); y1++ {
b.Copy(t.expandBoard)
t.expandBoard.Place(bag[0], x0, y0)
if t.expandBoard.Place(bag[1], x1, y1) == 0 {
continue
}
move1 := &treeNode{
move: Move{bag[1], x1, y1},
parent: move0,
leaves: make([]*treeNode, 0, 100),
}
score := rollout(t.expandBoard)
move1.propagate(score)
move0.leaves = append(move0.leaves, move1)
// third move
for x2 := 0; x2 <= 10-bag[2].Width(); x2++ {
for y2 := 0; y2 <= 10-bag[2].Height(); y2++ {
b.Copy(t.expandBoard)
t.expandBoard.Place(bag[0], x0, y0)
t.expandBoard.Place(bag[1], x1, y1)
if t.expandBoard.Place(bag[2], x2, y2) == 0 {
continue
}
move2 := &treeNode{
move: Move{bag[2], x2, y2},
parent: move1,
leaves: make([]*treeNode, 0, 100),
}
score := rollout(t.expandBoard)
move2.propagate(score)
move1.leaves = append(move1.leaves, move2)
}
}
}
}
}
}
return t
}
type treeNode struct {
move Move
N int // number of rollouts
W int // accumulated value
parent *treeNode
leaves []*treeNode
}
func (t *treeNode) highestUCTChild() *treeNode {
if len(t.leaves) == 0 {
panic("no children")
}
bestUCT := math.Inf(-1)
var bestChild *treeNode
for _, l := range t.leaves {
uct := (float64(l.W) / float64(l.N)) + monteC*math.Sqrt(math.Log(float64(t.N))/float64(l.N))
if uct > bestUCT {
bestChild = l
bestUCT = uct
}
}
return bestChild
}
func (t *treeNode) highestValueChild() *treeNode {
if len(t.leaves) == 0 {
panic("no children")
}
bestChild := t.leaves[0]
for _, l := range t.leaves[1:] {
if l.W > bestChild.W {
bestChild = l
}
}
return bestChild
}
var rng = rand.New(rand.NewSource(0))
func (t *treeNode) expand(b *game.Board) {
if len(t.leaves) != 0 {
panic("node already expanded")
}
rolloutBoard := new(game.Board)
for _, p := range game.Pieces {
for x := 0; x <= 10-p.Width(); x++ {
for y := 0; y <= 10-p.Height(); y++ {
b.Copy(rolloutBoard)
if rolloutBoard.Place(p, x, y) == 0 {
continue
}
m := &treeNode{
move: Move{p, x, y},
parent: t,
leaves: make([]*treeNode, 0, 100),
}
score := rollout(rolloutBoard)
m.propagate(score)
t.leaves = append(t.leaves, m)
}
}
}
}
func rollout(b *game.Board) int {
score := 0
for {
p := game.Pieces[rng.Intn(game.NumPieces)]
for i := 0; i < 100; i++ {
x := rng.Intn(11 - p.Width())
y := rng.Intn(11 - p.Height())
if b.Place(p, x, y) > 0 {
break
} else if i == 99 {
// give up
return score
}
}
score++
}
}
func (t *treeNode) propagate(score int) {
t.W += score
t.N++
if t.parent != nil {
t.parent.propagate(score)
}
} | ai/ai.go | 0.50708 | 0.550728 | ai.go | starcoder |
package layer
import tf "github.com/galeone/tensorflow/tensorflow/go"
type LTextVectorization struct {
dtype DataType
inputs []Layer
maxTokens interface{}
name string
ngrams interface{}
outputMode string
outputSequenceLength interface{}
padToMaxTokens bool
shape tf.Shape
split string
standardize string
trainable bool
vocabulary interface{}
layerWeights []*tf.Tensor
}
func TextVectorization() *LTextVectorization {
return <extVectorization{
dtype: String,
maxTokens: nil,
name: UniqueName("text_vectorization"),
ngrams: nil,
outputMode: "int",
outputSequenceLength: nil,
padToMaxTokens: false,
split: "whitespace",
standardize: "lower_and_strip_punctuation",
trainable: true,
vocabulary: nil,
}
}
func (l *LTextVectorization) SetDtype(dtype DataType) *LTextVectorization {
l.dtype = dtype
return l
}
func (l *LTextVectorization) SetMaxTokens(maxTokens interface{}) *LTextVectorization {
l.maxTokens = maxTokens
return l
}
func (l *LTextVectorization) SetName(name string) *LTextVectorization {
l.name = name
return l
}
func (l *LTextVectorization) SetNgrams(ngrams interface{}) *LTextVectorization {
l.ngrams = ngrams
return l
}
func (l *LTextVectorization) SetOutputMode(outputMode string) *LTextVectorization {
l.outputMode = outputMode
return l
}
func (l *LTextVectorization) SetOutputSequenceLength(outputSequenceLength interface{}) *LTextVectorization {
l.outputSequenceLength = outputSequenceLength
return l
}
func (l *LTextVectorization) SetPadToMaxTokens(padToMaxTokens bool) *LTextVectorization {
l.padToMaxTokens = padToMaxTokens
return l
}
func (l *LTextVectorization) SetShape(shape tf.Shape) *LTextVectorization {
l.shape = shape
return l
}
func (l *LTextVectorization) SetSplit(split string) *LTextVectorization {
l.split = split
return l
}
func (l *LTextVectorization) SetStandardize(standardize string) *LTextVectorization {
l.standardize = standardize
return l
}
func (l *LTextVectorization) SetTrainable(trainable bool) *LTextVectorization {
l.trainable = trainable
return l
}
func (l *LTextVectorization) SetVocabulary(vocabulary interface{}) *LTextVectorization {
l.vocabulary = vocabulary
return l
}
func (l *LTextVectorization) SetLayerWeights(layerWeights []*tf.Tensor) *LTextVectorization {
l.layerWeights = layerWeights
return l
}
func (l *LTextVectorization) GetShape() tf.Shape {
return l.shape
}
func (l *LTextVectorization) GetDtype() DataType {
return l.dtype
}
func (l *LTextVectorization) SetInputs(inputs ...Layer) Layer {
l.inputs = inputs
return l
}
func (l *LTextVectorization) GetInputs() []Layer {
return l.inputs
}
func (l *LTextVectorization) GetName() string {
return l.name
}
func (l *LTextVectorization) GetLayerWeights() []*tf.Tensor {
return l.layerWeights
}
type jsonConfigLTextVectorization struct {
ClassName string `json:"class_name"`
Name string `json:"name"`
Config map[string]interface{} `json:"config"`
InboundNodes [][][]interface{} `json:"inbound_nodes"`
}
func (l *LTextVectorization) GetKerasLayerConfig() interface{} {
inboundNodes := [][][]interface{}{
{},
}
for _, input := range l.inputs {
inboundNodes[0] = append(inboundNodes[0], []interface{}{
input.GetName(),
0,
0,
map[string]bool{},
})
}
return jsonConfigLTextVectorization{
ClassName: "TextVectorization",
Name: l.name,
Config: map[string]interface{}{
"dtype": l.dtype.String(),
"max_tokens": l.maxTokens,
"name": l.name,
"ngrams": l.ngrams,
"output_mode": l.outputMode,
"output_sequence_length": l.outputSequenceLength,
"pad_to_max_tokens": l.padToMaxTokens,
"split": l.split,
"standardize": l.standardize,
"trainable": l.trainable,
"vocabulary": l.vocabulary,
},
InboundNodes: inboundNodes,
}
}
func (l *LTextVectorization) GetCustomLayerDefinition() string {
return ``
} | layer/TextVectorization.go | 0.633297 | 0.463201 | TextVectorization.go | starcoder |
package adsbtype
import (
"fmt"
)
// ATS is the altitude type subfield.
type ATS uint64
// Altitude Type Subfield values.
const (
ATS0 ATS = 0 // Barometric altitude
ATS1 ATS = 1 // Navigation-derived altitude
)
var mATS = map[ATS]string{
ATS0: "Barometric altitude",
ATS1: "Navigation-derived altitude",
}
// String representation of ATS.
func (c ATS) String() string {
if str, ok := mATS[c]; ok {
return str
}
return fmt.Sprintf("Unknown value %d", c)
}
// BDS is the Comm-B data selector.
type BDS uint64
// Comm-B Data Selector values.
const (
BDS02 BDS = 0x02 // Linked Comm-B, segment 2
BDS03 BDS = 0x03 // Linked Comm-B, segment 3
BDS04 BDS = 0x04 // Linked Comm-B, segment 4
BDS05 BDS = 0x05 // Extended squitter airborne position
BDS06 BDS = 0x06 // Extended squitter surface position
BDS07 BDS = 0x07 // Extended squitter status
BDS08 BDS = 0x08 // Extended squitter identification and category
BDS09 BDS = 0x09 // Extended squitter airborne velocity
BDS0A BDS = 0x0A // Extended squitter event-driven information
BDS0B BDS = 0x0B // Air / air information 1 (aircraft state)
BDS0C BDS = 0x0C // Air / air information 2 (aircraft intent)
BDS10 BDS = 0x10 // Data link capability report
BDS17 BDS = 0x17 // Common usage GICB capability report
BDS20 BDS = 0x20 // Aircraft identification
BDS21 BDS = 0x21 // Aircraft and airline registration markings
BDS22 BDS = 0x22 // Antenna positions
BDS25 BDS = 0x25 // Aircraft type
BDS30 BDS = 0x30 // ACAS active resolution advisory
BDS40 BDS = 0x40 // Selected vertical intention
BDS41 BDS = 0x41 // Next waypoint identifier
BDS42 BDS = 0x42 // Next waypoint position
BDS43 BDS = 0x43 // Next waypoint information
BDS44 BDS = 0x44 // Meteorological routine air report
BDS45 BDS = 0x45 // Meteorological hazard report
BDS48 BDS = 0x48 // VHF channel report
BDS50 BDS = 0x50 // Track and turn report
BDS51 BDS = 0x51 // Position report coarse
BDS52 BDS = 0x52 // Position report fine
BDS53 BDS = 0x53 // Air-referenced state vector
BDS54 BDS = 0x54 // Waypoint 1
BDS55 BDS = 0x55 // Waypoint 2
BDS56 BDS = 0x56 // Waypoint 3
BDS5F BDS = 0x5F // Quasi-static parameter monitoring
BDS60 BDS = 0x60 // Heading and speed report
BDS61 BDS = 0x61 // Extended squitter emergency / priority status
BDS65 BDS = 0x65 // Extended squitter aircraft operational status
BDSE3 BDS = 0xE3 // Transponder type / part number
BDSE4 BDS = 0xE4 // Transponder software revision number
BDSE5 BDS = 0xE5 // ACAS unit part number
BDSE6 BDS = 0xE6 // ACAS unit software revision number
BDSE7 BDS = 0xE7 // Transponder status and diagnostics
BDSEA BDS = 0xEA // Vendor specific status and diagnostics
BDSF1 BDS = 0xF1 // Military applications (F1)
BDSF2 BDS = 0xF2 // Military applications (F2)
)
var mBDS = map[BDS]string{
BDS02: "Linked Comm-B, segment 2",
BDS03: "Linked Comm-B, segment 3",
BDS04: "Linked Comm-B, segment 4",
BDS05: "Extended squitter airborne position",
BDS06: "Extended squitter surface position",
BDS07: "Extended squitter status",
BDS08: "Extended squitter identification and category",
BDS09: "Extended squitter airborne velocity",
BDS0A: "Extended squitter event-driven information",
BDS0B: "Air / air information 1 (aircraft state)",
BDS0C: "Air / air information 2 (aircraft intent)",
BDS10: "Data link capability report",
BDS17: "Common usage GICB capability report",
BDS20: "Aircraft identification",
BDS21: "Aircraft and airline registration markings",
BDS22: "Antenna positions",
BDS25: "Aircraft type",
BDS30: "ACAS active resolution advisory",
BDS40: "Selected vertical intention",
BDS41: "Next waypoint identifier",
BDS42: "Next waypoint position",
BDS43: "Next waypoint information",
BDS44: "Meteorological routine air report",
BDS45: "Meteorological hazard report",
BDS48: "VHF channel report",
BDS50: "Track and turn report",
BDS51: "Position report coarse",
BDS52: "Position report fine",
BDS53: "Air-referenced state vector",
BDS54: "Waypoint 1",
BDS55: "Waypoint 2",
BDS56: "Waypoint 3",
BDS5F: "Quasi-static parameter monitoring",
BDS60: "Heading and speed report",
BDS61: "Extended squitter emergency / priority status",
BDS65: "Extended squitter aircraft operational status",
BDSE3: "Transponder type / part number",
BDSE4: "Transponder software revision number",
BDSE5: "ACAS unit part number",
BDSE6: "ACAS unit software revision number",
BDSE7: "Transponder status and diagnostics",
BDSEA: "Vendor specific status and diagnostics",
BDSF1: "Military applications (F1)",
BDSF2: "Military applications (F2)",
}
// String representation of BDS.
func (c BDS) String() string {
if str, ok := mBDS[c]; ok {
return str
}
return fmt.Sprintf("Unknown value %02x", uint64(c))
}
// SSS is the surveillance status subfield.
type SSS uint64
// Surveillance Status Subfield values.
const (
SSS0 SSS = 0 // No condition information
SSS1 SSS = 1 // Permanent alert (emergency)
SSS2 SSS = 2 // Temporary alert (ident change)
SSS3 SSS = 3 // SPI
)
var mSSS = map[SSS]string{
SSS0: "No condition information",
SSS1: "Permanent alert (emergency)",
SSS2: "Temporary alert (ident change)",
SSS3: "SPI",
}
// String representation of SSS.
func (c SSS) String() string {
if str, ok := mSSS[c]; ok {
return str
}
return fmt.Sprintf("Unknown value %d", c)
}
// TRS is the transmission rate subfield.
type TRS uint64
// Transmission Rate Subfield values.
const (
TRS0 TRS = 0 // No capability
TRS1 TRS = 1 // High surface squitter rate
TRS2 TRS = 2 // Low surface squitter rate
)
var mTRS = map[TRS]string{
TRS0: "No capability",
TRS1: "High surface squitter rate",
TRS2: "Low surface squitter rate",
}
// String representation of TRS.
func (c TRS) String() string {
if str, ok := mTRS[c]; ok {
return str
}
return fmt.Sprintf("Unknown value %d", c)
} | adsbtype/commb.go | 0.683314 | 0.535706 | commb.go | starcoder |
package service
// Task describes a service task.
type Task struct {
// Key is the key of task.
Key string `hash:"name:1"`
// Name is the name of task.
Name string `hash:"name:2"`
// Description is the description of task.
Description string `hash:"name:3"`
// Inputs are the definition of the execution inputs of task.
Inputs []*Parameter `hash:"name:4"`
// Outputs are the definition of the execution results of task.
Outputs []*Output `hash:"name:5"`
// serviceName is the task's service's name.
serviceName string `hash:"-"`
}
// Output describes task output.
type Output struct {
// Key is the key of output.
Key string `hash:"name:1"`
// Name is the name of task output.
Name string `hash:"name:2"`
// Description is the description of task output.
Description string `hash:"name:3"`
// Data holds the output parameters of a task output.
Data []*Parameter `hash:"name:4"`
// taskKey is the output's task's key.
taskKey string `hash:"-"`
// serviceName is the output's service's name.
serviceName string `hash:"-"`
}
// GetTask returns task taskKey of service.
func (s *Service) GetTask(taskKey string) (*Task, error) {
for _, task := range s.Tasks {
if task.Key == taskKey {
task.serviceName = s.Name
return task, nil
}
}
return nil, &TaskNotFoundError{
TaskKey: taskKey,
ServiceName: s.Name,
}
}
// GetInputParameter returns input inputKey parameter of task.
func (t *Task) GetInputParameter(inputKey string) (*Parameter, error) {
for _, input := range t.Inputs {
if input.Key == inputKey {
return input, nil
}
}
return nil, &TaskInputNotFoundError{
TaskKey: t.Key,
TaskInputKey: inputKey,
ServiceName: t.serviceName,
}
}
// ValidateInputs produces warnings for task inputs that doesn't satisfy their parameter schemas.
func (t *Task) ValidateInputs(taskInputs map[string]interface{}) []*ParameterWarning {
return validateParametersSchema(t.Inputs, taskInputs)
}
// RequireInputs requires task inputs to be matched with parameter schemas.
func (t *Task) RequireInputs(taskInputs map[string]interface{}) error {
warnings := t.ValidateInputs(taskInputs)
if len(warnings) > 0 {
return &InvalidTaskInputError{
TaskKey: t.Key,
ServiceName: t.serviceName,
Warnings: warnings,
}
}
return nil
}
// GetOutput returns output outputKey of task.
func (t *Task) GetOutput(outputKey string) (*Output, error) {
for _, output := range t.Outputs {
if output.Key == outputKey {
output.taskKey = t.Key
output.serviceName = t.serviceName
return output, nil
}
}
return nil, &TaskOutputNotFoundError{
TaskKey: t.Key,
TaskOutputKey: outputKey,
ServiceName: t.serviceName,
}
}
// ValidateData produces warnings for task outputs that doesn't satisfy their parameter schemas.
func (o *Output) ValidateData(outputData map[string]interface{}) []*ParameterWarning {
return validateParametersSchema(o.Data, outputData)
}
// RequireData requires task outputs to be matched with parameter schemas.
func (o *Output) RequireData(outputData map[string]interface{}) error {
warnings := o.ValidateData(outputData)
if len(warnings) > 0 {
return &InvalidTaskOutputError{
TaskKey: o.taskKey,
TaskOutputKey: o.Key,
ServiceName: o.serviceName,
Warnings: warnings,
}
}
return nil
} | service/task.go | 0.718496 | 0.444625 | task.go | starcoder |
package recurrence
import (
"encoding/json"
"fmt"
"time"
)
// A TimeRange represents a range of time, with a start and an end.
type TimeRange struct {
Start time.Time
End time.Time
}
// IsOccurring implements the Schedule interface.
func (tr TimeRange) IsOccurring(t time.Time) bool {
return !(t.Before(tr.Start) || t.After(tr.End))
}
// Occurrences implements the Schedule interface.
func (tr TimeRange) Occurrences(other TimeRange) chan time.Time {
return occurrencesFor(tr, other)
}
func (tr TimeRange) nextAfter(t time.Time) (time.Time, error) {
if t.Before(tr.Start) {
return tr.Start, nil
}
if t.Before(tr.End) {
return t.AddDate(0, 0, 1), nil
}
var zeroTime time.Time
return zeroTime, fmt.Errorf("no more occurrences after %s", t)
}
// UnmarshalJSON implements the json.Unmarshaler interface.
func (tr *TimeRange) UnmarshalJSON(b []byte) error {
var mixed interface{}
var err error
json.Unmarshal(b, &mixed)
value, _ := mixed.(map[string]interface{})["start"]
t, _ := time.Parse("2006-01-02", value.(string))
tr.Start = t
value, _ = mixed.(map[string]interface{})["end"]
t, _ = time.Parse("2006-01-02", value.(string))
tr.End = t
return err
}
// NewTimeRange let's you create a new TimeRange from the time format "2006-01-02"
func NewTimeRange(start, end string) TimeRange {
tStart, err := time.Parse("2006-01-02", start)
if err != nil {
panic(`NewDate(string) requires format "2006-01-02"`)
}
tEnd, err := time.Parse("2006-01-02", end)
if err != nil {
panic(`NewDate(string) requires format "2006-01-02"`)
}
return TimeRange{tStart, tEnd}
}
// YearRange generates a TimeRange representing the entire year.
func YearRange(y int) TimeRange {
return TimeRange{
time.Date(y, time.January, 1, 0, 0, 0, 0, time.UTC),
time.Date(y+1, time.January, 0, 0, 0, 0, 0, time.UTC),
}
}
// MonthRange generates a TimeRange representing a specific month.
func MonthRange(month interface{}, year int) TimeRange {
var m time.Month
switch t := month.(type) {
case int:
m = time.Month(t)
case Month:
m = time.Month(t)
case time.Month:
m = t
default:
panic(fmt.Sprintf("MonthRange can't use %T", month))
}
return TimeRange{
time.Date(year, m, 1, 0, 0, 0, 0, time.UTC),
time.Date(year, m+1, 0, 0, 0, 0, 0, time.UTC),
}
}
func beginningOfDay(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
}
func (tr TimeRange) eachDate() chan time.Time {
c := make(chan time.Time)
go func() {
for t := beginningOfDay(tr.Start); !t.After(tr.End); t = t.AddDate(0, 0, 1) {
c <- t
}
close(c)
}()
return c
} | time_range.go | 0.795301 | 0.483892 | time_range.go | starcoder |
package timeseries
import (
"math"
"sync"
"github.com/toolsparty/regression"
)
// TrendType type
type TrendType int
// TrendType enum
const (
TrendTypeDecreasing TrendType = -1
TrendTypeNeutral TrendType = 0
TrendTypeIncreasing TrendType = 1
)
// DataPoint struct
type DataPoint struct {
Time int64 `json:"time"`
Value float64 `json:"value"`
}
// Timeseries struct
type Timeseries struct {
*sync.RWMutex
size int
times []int64
values []float64
}
// New Timeseries
func New(size int) *Timeseries {
return &Timeseries{
RWMutex: &sync.RWMutex{},
times: []int64{},
values: []float64{},
size: size,
}
}
// Size of timeseries
func (ts *Timeseries) Size() int {
return len(ts.values)
}
// Add DataPoint to Timeseries
func (ts *Timeseries) Add(t int64, v float64) {
ts.Lock()
ts.times = append(ts.times, t)
ts.values = append(ts.values, v)
length := len(ts.times)
if length > ts.size {
ts.times = ts.times[length-ts.size:]
ts.values = ts.values[length-ts.size:]
}
ts.Unlock()
}
// Keys slice
func (ts Timeseries) Keys() []int64 {
keys := []int64{}
ts.RLock()
for _, k := range ts.times {
keys = append(keys, k)
}
ts.RUnlock()
return keys
}
// Values slice
func (ts Timeseries) Values() []float64 {
values := []float64{}
ts.RLock()
for _, v := range ts.values {
values = append(values, v)
}
ts.RUnlock()
return values
}
// MaxValue of Timeseries
func (ts Timeseries) MaxValue() float64 {
max := float64(0)
ts.RLock()
for _, v := range ts.values {
max = math.Max(max, v)
}
ts.RUnlock()
return max
}
// All DataPoint in Timeseries
func (ts Timeseries) All() []*DataPoint {
datas := []*DataPoint{}
ts.RLock()
for i, v := range ts.values {
t := ts.times[i]
datas = append(datas, &DataPoint{
Time: t,
Value: v,
})
}
ts.RUnlock()
return datas
}
// GetLatestValues by size
func (ts Timeseries) GetLatestValues(size int) []float64 {
length := len(ts.values)
if length < size {
return ts.Values()
}
ts.RLock()
values := ts.values[length-size:]
ts.RUnlock()
return values
}
// GetTrending for timeseries
func (ts Timeseries) GetTrending(size int) (TrendType, error) {
reg, err := regression.NewLinear([]float64{}, ts.GetLatestValues(size))
if err != nil {
return TrendTypeNeutral, err
}
slope := reg.GetK()
if slope > 0 {
return TrendTypeIncreasing, nil
} else if slope < 0 {
return TrendTypeDecreasing, nil
}
return TrendTypeNeutral, nil
} | timeseries/timeseries.go | 0.661595 | 0.507202 | timeseries.go | starcoder |
package byteslice
import (
"errors"
"math"
)
// Reverse change the order of the byte slice.
func Reverse(data []byte) []byte {
if len(data) < 2 {
return data
}
sliceLength := len(data)
sliceHalfLength := int(float64(sliceLength / 2))
reversedSlice := make([]byte, sliceLength)
for i := 0; i <= sliceHalfLength; i++ {
reversedSlice[i] = data[sliceLength-1-i]
reversedSlice[sliceLength-1-i] = data[i]
}
return reversedSlice
}
// LShift apply left shift operation to an byte slice.
func LShift(data []byte, shift uint64) []byte {
if shift == 0 {
return data
}
dataLength := len(data)
result := make([]byte, dataLength)
if shift > maxBitsLength {
copy(result, data[1:])
result = LShift(result, shift-maxBitsLength)
} else {
for i := dataLength - 1; i >= 0; i-- {
if i > 0 {
result[i-1] = data[i] >> (maxBitsLength - shift)
}
result[i] = result[i] | (data[i] << shift)
}
}
return result
}
// RShift apply right shift operation to an byte slice.
func RShift(data []byte, shift uint64) []byte {
if shift == 0 {
return data
}
dataLength := len(data)
result := make([]byte, dataLength)
if shift > maxBitsLength {
shiftedData := append(make([]byte, 1), data[:dataLength-1]...)
result = RShift(shiftedData, shift-maxBitsLength)
} else {
for i := 0; i < dataLength; i++ {
if i < dataLength-1 {
result[i+1] = data[i] << (maxBitsLength - shift)
}
result[i] = result[i] | (data[i] >> shift)
}
}
return result
}
// LPad pads the left-side of a byte slice with a filler byte.
func LPad(data []byte, length int, filler byte) []byte {
dataLength := len(data)
if length < 1 || length <= dataLength {
return data
}
result := make([]byte, length-dataLength)
for i := range result {
result[i] = filler
}
result = append(result, data...)
return result
}
// RPad pads the right-side of a byte slice with a filler byte.
func RPad(data []byte, length int, filler byte) []byte {
dataLength := len(data)
if length < 1 || length <= dataLength {
return data
}
result := make([]byte, length-dataLength)
for i := range result {
result[i] = filler
}
result = append(data, result...)
return result
}
// Unset apply AND operation on a byte slice with an "unset" byte slice (must have the same size).
func Unset(data, unsetData []byte) ([]byte, error) {
var dataLength = len(data)
var unsetDataLength = len(unsetData)
if dataLength != unsetDataLength {
return nil, errors.New("data and unsetData must have the same size")
}
result := make([]byte, dataLength)
for i := 0; i < dataLength; i++ {
result[i] = data[i] & unsetData[i]
}
return result, nil
}
// Set apply OR operation on a byte slice with an "set" byte slice (must have the same size).
func Set(data, setData []byte) ([]byte, error) {
dataLength := len(data)
setDataLength := len(setData)
if dataLength != setDataLength {
return nil, errors.New("data and setData must have the same size")
}
result := make([]byte, dataLength)
for i := 0; i < dataLength; i++ {
result[i] = data[i] | setData[i]
}
return result, nil
}
// Toggle apply XOR operation on a byte slice with an "toggle" byte slice (must have the same size).
func Toggle(data, toggleData []byte) ([]byte, error) {
dataLength := len(data)
toggleDataLength := len(toggleData)
if dataLength != toggleDataLength {
return nil, errors.New("data and toggleData must have the same size")
}
result := make([]byte, dataLength)
for i := 0; i < dataLength; i++ {
result[i] = data[i] ^ toggleData[i]
}
return result, nil
}
// Flip apply NOT operation to a byte slice to flip it.
func Flip(data []byte) []byte {
dataLength := len(data)
result := make([]byte, dataLength)
for i := 0; i < dataLength; i++ {
result[i] = ^data[i]
}
return result
}
func computeSize(leastSignificantBit, mostSignificantBit uint64) uint64 {
count := float64(mostSignificantBit-leastSignificantBit) / float64(maxBitsLength)
return uint64(math.Ceil(count))
} | byteslice.go | 0.737158 | 0.590779 | byteslice.go | starcoder |
package importer
import (
"fmt"
"github.com/mescanne/goledger/cmd/utils"
"github.com/mescanne/goledger/script"
)
var ImportUsage = `Import Detailed Help
============================
Format
------
The format for the import configuration:
type:key=value[,key=value,...]
Configuration file uses "configType" for the type and a
params subsection for key-value.
Import type *csv*
CSV import reads the file as newline-delimited records and
comma-separated (configurable) fields.
Parameters:
header - true or false if there is a header (default is false)
if there is a header, structure is a dictionary instead of an array
delim - delimiter for CSV file (default is ,)
Import type *json*
JSON import reads the entire file as a single JSON structure. No parameters.
Code
----
There needs to be code written in Starlark. This is a subset of Python that is suitable
for embedded script.
Specification can be found [here](https://github.com/google/starlark-go/blob/master/doc/spec.md).
The data structures are loaded into Python-equivalent. JSON is a series of number, string, lists,
and dictionaries. CSV is a list of lists (no header) or list of dictdionaries (with header).
There are four globals in the execution:
* data. This the parsed data structure.
* file. The filename that the data came from.
* error(msg=msg). This function, if called, aborts all operation and reports the err msg.
* print(...). This function is the same as the normal Python3 print and can be used for debugging.
It prints out with a semi-colon at the beginning, so is appropriate for adding text to the
ledger file.
* add(). See below.
Add is the method used for adding new postings:
add(date, desc,
amt, ccy=ccy, denom=1, account=account,
amt2=None, ccy2="", denom2=1, account2=None,
caccount=caccount, note="", lnote="")
Parameters:
* date. The date as string of the transaction. Expecting YYYY-MM-DD or YYYY/MM/DD.
* desc. The payee or description of the transaction.
* amt. The amount of the transaction. This can be a float, integer, or string.
* ccy. Optional. The currency of the transaction (otherwise use default).
* denom. Optional. The denominator of the amount (otherwise 1). (Eg for cents it is denom=100).
* account. Optional. The account for transactions (otherwise use default).
* amt2, ccy2, denom2, account2. Optional. As primary accounts, but as a secondary posting if needed.
* caccount. Optional. The counteraccount for all postings (otherwuse use default).
* note. Optional. The transaction note.
* lnote. Optional. The posting note.
Example CSV parsing:
--code "[add(date=r['Date'], desc=r['Description'], amt=r['Amount']) for r in data]"
`
func NewBookImporterByConfig(cfg *utils.CLIConfig) (script.StarlarkReader, error) {
if cfg.ConfigType == "" {
return nil, fmt.Errorf("missing import type")
} else if cfg.ConfigType == "csv" {
return NewCSVBookImporter(cfg)
} else if cfg.ConfigType == "json" {
return script.ReadJSON, nil
} else {
return nil, fmt.Errorf("invalid import type: %s", cfg.ConfigType)
}
}
func NewCSVBookImporter(cfg *utils.CLIConfig) (script.StarlarkReader, error) {
delim := cfg.GetStringDefault("delim", ",")
if len([]rune(delim)) != 1 {
return nil, fmt.Errorf("invalid delimiter '%s': length not one character", delim)
}
header, err := cfg.GetBoolDefault("header", false)
if err != nil {
return nil, fmt.Errorf("invalid header config: %v", err)
}
return script.GetReadCSV(delim, header), nil
} | cmd/importer/import_op.go | 0.7917 | 0.431045 | import_op.go | starcoder |
package ast
// These are the available root node types. In JSON it will either be an
// object or an array at the base.
const (
ObjectRoot RootNodeType = iota
ArrayRoot
)
// RootNodeType is a type alias for an int
type RootNodeType int
// RootNode is what starts every parsed AST. There is a `Type` field so that
// you can ask which root node type starts the tree.
type RootNode struct {
RootValue *Value
Type RootNodeType
}
// Available ast value types
const (
ObjectType Type = iota
ArrayType
LiteralType
PropertyType
IdentifierType
)
// Type is a type alias for int. Represents a values type.
type Type int
// Object represents a JSON object. It holds a slice of Property as its children,
// a Type ("Object"), and start & end code points for displaying.
type Object struct {
Type Type
Children []Property
Start int
End int
}
// Array represents a JSON array It holds a slice of Value as its children,
// a Type ("Array"), and start & end code points for displaying.
type Array struct {
Type Type
Children []Value
Start int
End int
}
// Literal represents a JSON literal value. It holds a Type ("Literal") and the actual value.
type Literal struct {
Type Type
Value Value
}
// Property holds a Type ("Property") as well as a `Key` and `Value`. The Key is an Identifier
// and the value is any Value.
type Property struct {
Type Type
Key Identifier
Value Value
}
// Identifier represents a JSON object property key
type Identifier struct {
Type Type
Value string // "key1"
}
// Value will eventually have some methods that all Values must implement. For now
// it represents any JSON value (object | array | boolean | string | number | null)
type Value interface{}
// state is a type alias for int and used to create the available value states below
type state int
// Available states for each type used in parsing
const (
// Object states
ObjStart state = iota
ObjOpen
ObjProperty
ObjComma
// Property states
PropertyStart
PropertyKey
PropertyColon
// Array states
ArrayStart
ArrayOpen
ArrayValue
ArrayComma
// String states
StringStart
StringQuoteOrChar
Escape
// Number states
NumberStart
NumberMinus
NumberZero
NumberDigit
NumberPoint
NumberDigitFraction
NumberExp
NumberExpDigitOrSign
) | pkg/ast/ast.go | 0.72086 | 0.549036 | ast.go | starcoder |
package evolution
import (
"fmt"
"strings"
)
// EquationPairing refers to a set dependent and independent values for a given equation.
// For example the equation x^2 + 1 has an equation pairing of {1, 0}, {2, 1}, {5,
// 2} for dependent and independent pairs respectively
type EquationPairing struct {
Independents IndependentVariableMap
Dependent float64
ProtagonistThreshold float64
AntagonistThreshold float64
// AntagonistPenalization value to give the antagonist if it creates an invalid tree evaluation e.g. DivideByZero
AntagonistPenalization float64
// ProtagonistPenalization value to give the protagonist if it creates an invalid tree evaluation e.g. DivideByZero
ProtagonistPenalization float64
DivideByZeroPenalty float64
}
type IndependentVariableMap map[string]float64
func (e *EquationPairing) ToString() string {
return fmt.Sprintf(" %#v \t %.2f \n", e.Independents, e.Dependent)
}
// SpecMulti is the underlying data structre that contains the spec as well as threshold information
type SpecMulti []EquationPairing
// GenerateSpecSimple assumes a single independent variable x with an unlimited count.
func GenerateSpecSimple(specParam SpecParam, fitnessStrategy FitnessStrategy) (SpecMulti,
error) {
if specParam.Expression == "" {
return nil, fmt.Errorf("GenerateSpec | cannot containe empty mathematical expression")
}
if specParam.Range < 1 {
return nil, fmt.Errorf("GenerateSpec | specParam.Range cannot be less than 0")
}
if fitnessStrategy.AntagonistThresholdMultiplier < 1 {
fitnessStrategy.AntagonistThresholdMultiplier = 1
}
if fitnessStrategy.ProtagonistThresholdMultiplier < 1 {
fitnessStrategy.ProtagonistThresholdMultiplier = 1
}
spec := make([]EquationPairing, specParam.Range)
for i := range spec {
spec[i].Independents = map[string]float64{}
spec[i].Independents["x"] = float64(i + specParam.Seed)
dependentVariable, err := EvaluateMathematicalExpression(specParam.Expression,
spec[i].Independents)
if err != nil {
return nil, err
}
spec[i].Dependent = dependentVariable
spec[i].AntagonistThreshold = dependentVariable * fitnessStrategy.AntagonistThresholdMultiplier
spec[i].ProtagonistThreshold = dependentVariable * fitnessStrategy.ProtagonistThresholdMultiplier
spec[i].DivideByZeroPenalty = specParam.DivideByZeroPenalty
}
return spec, nil
}
func (spec SpecMulti) ToString() string {
sb := strings.Builder{}
if spec == nil {
return sb.String()
}
sb.WriteString(" x :\t f(x) \n")
for i := range spec {
s := spec[i].ToString()
sb.WriteString(s)
}
return sb.String()
} | evolution/spec.go | 0.805288 | 0.610686 | spec.go | starcoder |
package transforms
// Copyright 2017 The goimagehash Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
import (
"math"
"sync"
)
// DCT1D function returns result of DCT-II.
// DCT type II, unscaled. Algorithm by <NAME>, 1984.
func DCT1D(input []float64) []float64 {
temp := make([]float64, len(input))
forwardTransform(input, temp, len(input))
return input
}
func forwardTransform(input, temp []float64, Len int) {
if Len == 1 {
return
}
halfLen := Len / 2
for i := 0; i < halfLen; i++ {
x, y := input[i], input[Len-1-i]
temp[i] = x + y
temp[i+halfLen] = (x - y) / (math.Cos((float64(i)+0.5)*math.Pi/float64(Len)) * 2)
}
forwardTransform(temp, input, halfLen)
forwardTransform(temp[halfLen:], input, halfLen)
for i := 0; i < halfLen-1; i++ {
input[i*2+0] = temp[i]
input[i*2+1] = temp[i+halfLen] + temp[i+halfLen+1]
}
input[Len-2], input[Len-1] = temp[halfLen-1], temp[Len-1]
}
// DCT2D function returns a result of DCT2D by using the seperable property.
func DCT2D(input [][]float64, w int, h int) [][]float64 {
output := make([][]float64, h)
for i := range output {
output[i] = make([]float64, w)
}
wg := new(sync.WaitGroup)
for i := 0; i < h; i++ {
wg.Add(1)
go func(i int) {
output[i] = DCT1D(input[i])
wg.Done()
}(i)
}
wg.Wait()
for i := 0; i < w; i++ {
wg.Add(1)
in := make([]float64, h)
go func(i int) {
for j := 0; j < h; j++ {
in[j] = output[j][i]
}
rows := DCT1D(in)
for j := 0; j < len(rows); j++ {
output[j][i] = rows[j]
}
wg.Done()
}(i)
}
wg.Wait()
return output
}
// pHashSize is PHash Bitsize
const pHashSize = 64
// DCT2DFast function returns a result of DCT2D by using the seperable property.
// Fast version only works with pHashSize 64 will panic if another since is given.
func DCT2DFast(input *[]float64) {
if len(*input) != 4096 {
panic("Incorrect forward transform size")
}
for i := 0; i < pHashSize; i++ { // height
DCT1DFast64((*input)[i*pHashSize : (i*pHashSize)+pHashSize])
}
for i := 0; i < pHashSize; i++ { // width
row := [pHashSize]float64{}
for j := 0; j < pHashSize; j++ {
row[j] = (*input)[i+((j)*pHashSize)]
}
DCT1DFast64(row[:])
for j := 0; j < len(row); j++ {
(*input)[i+(j*pHashSize)] = row[j]
}
}
}
// DCT1DFast function returns result of DCT-II.
// DCT type II, unscaled. Algorithm by <NAME>, 1984.
func DCT1DFast(input []float64) []float64 {
temp := make([]float64, len(input))
forwardTransform(input, temp, len(input))
return input
}
func forwardTransformFast(input, temp []float64, Len int) {
if Len == 1 {
return
}
halfLen := Len / 2
t := dctTables[halfLen>>1]
for i := 0; i < halfLen; i++ {
x, y := input[i], input[Len-1-i]
temp[i] = x + y
temp[i+halfLen] = (x - y) / t[i]
}
forwardTransformFast(temp, input, halfLen)
forwardTransformFast(temp[halfLen:], input, halfLen)
for i := 0; i < halfLen-1; i++ {
input[i*2+0] = temp[i]
input[i*2+1] = temp[i+halfLen] + temp[i+halfLen+1]
}
input[Len-2], input[Len-1] = temp[halfLen-1], temp[Len-1]
}
// DCT Tables
var (
dctTables = [][]float64{
dct2[:], //0
dct4[:], //1
dct8[:], //2
nil, //3
dct16[:], //4
nil, //5
nil, //6
nil, //7
dct32[:], //8
nil, //9
nil, //10
nil, //11
nil, //12
nil, //13
nil, //14
nil, //15
dct64[:], //16
}
dct64 = [32]float64{
(math.Cos((float64(0)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(1)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(2)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(3)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(4)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(5)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(6)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(7)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(8)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(9)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(10)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(11)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(12)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(13)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(14)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(15)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(16)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(17)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(18)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(19)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(20)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(21)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(22)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(23)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(24)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(25)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(26)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(27)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(28)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(29)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(30)+0.5)*math.Pi/64) * 2),
(math.Cos((float64(31)+0.5)*math.Pi/64) * 2),
}
dct32 = [16]float64{
(math.Cos((float64(0)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(1)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(2)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(3)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(4)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(5)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(6)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(7)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(8)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(9)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(10)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(11)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(12)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(13)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(14)+0.5)*math.Pi/32) * 2),
(math.Cos((float64(15)+0.5)*math.Pi/32) * 2),
}
dct16 = [8]float64{
(math.Cos((float64(0)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(1)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(2)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(3)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(4)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(5)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(6)+0.5)*math.Pi/16) * 2),
(math.Cos((float64(7)+0.5)*math.Pi/16) * 2),
}
dct8 = [4]float64{
(math.Cos((float64(0)+0.5)*math.Pi/8) * 2),
(math.Cos((float64(1)+0.5)*math.Pi/8) * 2),
(math.Cos((float64(2)+0.5)*math.Pi/8) * 2),
(math.Cos((float64(3)+0.5)*math.Pi/8) * 2),
}
dct4 = [2]float64{
(math.Cos((float64(0)+0.5)*math.Pi/4) * 2),
(math.Cos((float64(1)+0.5)*math.Pi/4) * 2),
}
dct2 = [1]float64{
(math.Cos((float64(0)+0.5)*math.Pi/2) * 2),
}
) | imagehash/transforms/dct.go | 0.682574 | 0.465205 | dct.go | starcoder |
package bip38
import (
"golang.org/x/crypto/scrypt"
"crypto/aes"
"crypto/rand"
"conseweb.com/wallet/icebox/common/address"
"github.com/sour-is/koblitz/kelliptic"
)
type BIP38Key struct {
Flag byte
Hash [4]byte
Data [32]byte
}
func Encrypt(p *address.PrivateKey, passphrase string) string {
bip38 := new(BIP38Key)
ah := address.DHash256(p.AddressBytes())[:4]
dh, _ := scrypt.Key([]byte(passphrase), ah, 16384, 8, 8, 64)
bip38.Flag = byte(0xC0)
copy(bip38.Hash[:], ah)
copy(bip38.Data[:], encrypt(p.Bytes(), dh[:32], dh[32:]))
return bip38.String()
}
func Decrypt(b38 string, passphrase string) (priv *address.PrivateKey, err error) {
b, err := address.FromBase58(b38)
if err != nil {
return nil, err
}
bip38 := new(BIP38Key)
bip38.Flag = b[2]
copy(bip38.Hash[:], b[3:7])
copy(bip38.Data[:], b[7:])
dh, _ := scrypt.Key([]byte(passphrase), bip38.Hash[:], 16384, 8, 8, 64)
priv = new(address.PrivateKey)
p := decrypt(bip38.Data[:], dh[:32], dh[32:])
priv.SetBytes(p)
return
}
func (bip BIP38Key) String() string {
return address.ToBase58(bip.Bytes(), 58)
}
func (bip BIP38Key) Bytes() []byte {
dst := make([]byte, 39)
dst[0] = byte(0x01)
dst[1] = byte(0x42)
dst[2] = bip.Flag
copy(dst[3:], bip.Hash[:])
copy(dst[7:], bip.Data[:])
return dst
}
func encrypt(pk, dh1, dh2 []byte) (dst []byte) {
c, _ := aes.NewCipher(dh2)
for i, _ := range dh1 {
dh1[i] ^= pk[i]
}
dst = make([]byte, 48)
c.Encrypt(dst, dh1[:16])
c.Encrypt(dst[16:], dh1[16:])
dst = dst[:32]
return
}
func decrypt(src, dh1, dh2 []byte) (dst []byte) {
c, _ := aes.NewCipher(dh2)
dst = make([]byte, 48)
c.Decrypt(dst, src[:16])
c.Decrypt(dst[16:], src[16:])
dst = dst[:32]
for i := range dst {
dst[i] ^= dh1[i]
}
return
}
// Intermediate Code Generation
func NewIntermediate(p string) (string, error) {
in := make([]byte, 49)
copy(in, []byte{0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2, 0x53})
rand.Read(in[8:16])
sc, _ := scrypt.Key([]byte(p), in[8:16], 16384, 8, 8, 32)
s256 := kelliptic.S256()
x, y := s256.ScalarBaseMult(sc)
cp := s256.CompressPoint(x, y)
copy(in[16:], cp)
return address.ToBase58(in, 72), nil
}
/*
func NewIntermediateLot(p string, lot, seq int) (string, error) {
if lot < 0 || lot > 4096 {
return "", errors.New("BIP38: lot out of range")
}
if seq < 0 || seq > 1048575 {
return "", errors.New("BIP38: sequence out of range")
}
lotseq := make([]byte, 8)
n := binary.PutVarint(lotseq, int64(lot*4096+seq))
salt := make([]byte, 16)
rand.Read(salt[8:12])
copy(salt[12-n:16], lotseq[:4])
sc, _ := scrypt.Key([]byte(p), salt[8:16], 16384, 8, 8, 32)
copy(salt[:8], sc)
// copy(in, []byte{0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2, 0x53})
return "", nil
}
func DecodeIntermediate(p string) error {
in, err := FromBase58(p)
if err != nil {
return err
}
s256 := kelliptic.S256()
x, y, err := s256.DecompressPoint(in[16:])
if err != nil {
return err
}
fmt.Printf("End X: %x Y: %x\n", x, y)
return nil
}
*/ | bip38/bip38.go | 0.591841 | 0.421909 | bip38.go | starcoder |
package v1alpha1
import (
v1alpha1 "kubeform.dev/kubeform/apis/google/v1alpha1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/client-go/tools/cache"
)
// BigqueryDatasetLister helps list BigqueryDatasets.
type BigqueryDatasetLister interface {
// List lists all BigqueryDatasets in the indexer.
List(selector labels.Selector) (ret []*v1alpha1.BigqueryDataset, err error)
// BigqueryDatasets returns an object that can list and get BigqueryDatasets.
BigqueryDatasets(namespace string) BigqueryDatasetNamespaceLister
BigqueryDatasetListerExpansion
}
// bigqueryDatasetLister implements the BigqueryDatasetLister interface.
type bigqueryDatasetLister struct {
indexer cache.Indexer
}
// NewBigqueryDatasetLister returns a new BigqueryDatasetLister.
func NewBigqueryDatasetLister(indexer cache.Indexer) BigqueryDatasetLister {
return &bigqueryDatasetLister{indexer: indexer}
}
// List lists all BigqueryDatasets in the indexer.
func (s *bigqueryDatasetLister) List(selector labels.Selector) (ret []*v1alpha1.BigqueryDataset, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.BigqueryDataset))
})
return ret, err
}
// BigqueryDatasets returns an object that can list and get BigqueryDatasets.
func (s *bigqueryDatasetLister) BigqueryDatasets(namespace string) BigqueryDatasetNamespaceLister {
return bigqueryDatasetNamespaceLister{indexer: s.indexer, namespace: namespace}
}
// BigqueryDatasetNamespaceLister helps list and get BigqueryDatasets.
type BigqueryDatasetNamespaceLister interface {
// List lists all BigqueryDatasets in the indexer for a given namespace.
List(selector labels.Selector) (ret []*v1alpha1.BigqueryDataset, err error)
// Get retrieves the BigqueryDataset from the indexer for a given namespace and name.
Get(name string) (*v1alpha1.BigqueryDataset, error)
BigqueryDatasetNamespaceListerExpansion
}
// bigqueryDatasetNamespaceLister implements the BigqueryDatasetNamespaceLister
// interface.
type bigqueryDatasetNamespaceLister struct {
indexer cache.Indexer
namespace string
}
// List lists all BigqueryDatasets in the indexer for a given namespace.
func (s bigqueryDatasetNamespaceLister) List(selector labels.Selector) (ret []*v1alpha1.BigqueryDataset, err error) {
err = cache.ListAllByNamespace(s.indexer, s.namespace, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.BigqueryDataset))
})
return ret, err
}
// Get retrieves the BigqueryDataset from the indexer for a given namespace and name.
func (s bigqueryDatasetNamespaceLister) Get(name string) (*v1alpha1.BigqueryDataset, error) {
obj, exists, err := s.indexer.GetByKey(s.namespace + "/" + name)
if err != nil {
return nil, err
}
if !exists {
return nil, errors.NewNotFound(v1alpha1.Resource("bigquerydataset"), name)
}
return obj.(*v1alpha1.BigqueryDataset), nil
} | client/listers/google/v1alpha1/bigquerydataset.go | 0.627267 | 0.435841 | bigquerydataset.go | starcoder |
package BronKerbosch
type VertexVisitor interface {
visit(Vertex)
Close()
}
type SimpleVertexVisitor struct {
vertices []Vertex
}
type ChannelVertexVisitor struct {
vertices chan<- Vertex
}
func (g *SimpleVertexVisitor) visit(v Vertex) {
g.vertices = append(g.vertices, v)
}
func (g *SimpleVertexVisitor) Close() {
}
func (g *ChannelVertexVisitor) visit(v Vertex) {
g.vertices <- v
}
func (g *ChannelVertexVisitor) Close() {
close(g.vertices)
}
func degeneracyOrdering(graph *UndirectedGraph, visitor VertexVisitor, drop int) {
if drop > 0 {
panic("expecting negative drop value")
}
defer func() { visitor.Close() }()
order := graph.Order()
// Possible values of priorityPerNode:
// -1: when yielded
// 0..maxDegree: candidates still queued with priority (degree - #of yielded neighbours)
priorityPerNode := make([]int, order)
maxDegree := 0
numLeftToVisit := 0
for c := 0; c < order; c++ {
degree := graph.degree(Vertex(c))
if degree > 0 {
priorityPerNode[Vertex(c)] = degree
if maxDegree < degree {
maxDegree = degree
}
numLeftToVisit++
}
}
numLeftToVisit += drop
if numLeftToVisit <= 0 {
return
}
var q priorityQueue[Vertex]
q.init(maxDegree)
for c, p := range priorityPerNode {
if p > 0 {
q.put(p, Vertex(c))
}
}
for {
i := q.pop()
for priorityPerNode[i] == -1 {
// was requeued with a more urgent priority and therefore already visited
i = q.pop()
}
visitor.visit(i)
numLeftToVisit--
if numLeftToVisit == 0 {
return
}
priorityPerNode[i] = -1
for v := range graph.neighbours(i) {
p := priorityPerNode[v]
if p != -1 {
// Requeue with a more urgent priority, but don't bother to remove
// the original entry - it will be skipped if it's reached at all.
priorityPerNode[v] = p - 1
q.put(p-1, v)
}
}
}
}
type priorityQueue [T interface{}] struct {
stackPerPriority [][]T
}
func (q *priorityQueue[T]) init(maxPriority int) {
q.stackPerPriority = make([][]T, maxPriority+1)
}
func (q *priorityQueue[T]) put(priority int, element T) {
q.stackPerPriority[priority] = append(q.stackPerPriority[priority], element)
}
func (q *priorityQueue[T]) pop() T {
for p := 0; ; p++ {
l := len(q.stackPerPriority[p])
if l > 0 {
last := q.stackPerPriority[p][l-1]
q.stackPerPriority[p] = q.stackPerPriority[p][:l-1]
return last
}
}
} | go/lib/graph_degeneracy.go | 0.568416 | 0.482612 | graph_degeneracy.go | starcoder |
package moves
import (
"github.com/jkomoros/boardgame"
)
//Optional returns a MoveProgressionGroup that matches the provided group
//either 0 or 1 times. Equivalent to Repeat() with a count of Between(0, 1).
func Optional(group MoveProgressionGroup) MoveProgressionGroup {
return Repeat(CountBetween(0, 1), group)
}
//Repeat returns a MoveProgressionGroup that repeats the provided group the
//number of times count is looking for, in serial. Assumes that the
//ValidCounter has a single range of legal count values, where before it they
//are illegal, during the range they are legal, and after it they are illegal
//agin, and will read as many times from the tape as it can within that legal
//range. All ValidCounter methods in this package satisfy this. It is
//conceptually equivalent to duplicating a given group within a parent Serial
//count times.
func Repeat(count ValidCounter, group MoveProgressionGroup) MoveProgressionGroup {
return repeat{
count,
group,
}
}
type repeat struct {
Count ValidCounter
Child MoveProgressionGroup
}
func (r repeat) MoveConfigs() []boardgame.MoveConfig {
return r.Child.MoveConfigs()
}
func (r repeat) Satisfied(tape *MoveGroupHistoryItem) (*MoveGroupHistoryItem, error) {
tapeHead := tape
//we assume that there is precisely one continguous bound that is legal.
//We want to go up until we enter the lower bound, then any error we run
//into within that bound is OK (just return last known good tape position
//and ignore the group that errored), and then when we reach the upper
//limit we end.
lowerBoundReached := false
//Check if we start within the lower bound (for example, a count.AtMost()
//will start within the legal lower bound.z)
if err := r.Count(0, 1); err == nil {
lowerBoundReached = true
}
//The count happens after the group has been consumed each time, so by the
//time we look at this the first time it will have already been one group.
count := 1
for {
//If we ever reach the tape end without having found an error then it's
//legal.
if tapeHead == nil {
return nil, nil
}
rest, err := r.Child.Satisfied(tapeHead)
if err != nil {
if lowerBoundReached {
//We're between the lower and upper bound of legal counts, so
//errors are not a big deal, just return the last known good
//state.
return tapeHead, nil
}
//Otherwise, we haven't yet gotten the smallest legal amount so we
//should stop.
return nil, err
}
boundErr := r.Count(count, 1)
if lowerBoundReached {
//As soon as we find the first non-nil count afer we've passed the
//lower bound we're done, because we've passed outside of the
//legal bound.
if boundErr != nil {
break
}
} else {
//Is this the transition into the lower legal bound?
if boundErr == nil {
lowerBoundReached = true
}
}
count++
tapeHead = rest
}
return tapeHead, nil
} | moves/group_repeat.go | 0.808408 | 0.494385 | group_repeat.go | starcoder |
package extstorage
import "context"
// Interface is the ganeti-extstorage interface according to
// https://docs.ganeti.org/docs/ganeti/3.0/html/man-ganeti-extstorage-interface.html#executable-scripts
type Interface interface {
/*
The create command is used for creating a new volume inside the external storage. The VOL_NAME denotes the volume’s name, which should be unique. After creation, Ganeti will refer to this volume by this name for all other actions.
Ganeti produces this name dynamically and ensures its uniqueness inside the Ganeti context. Therefore, you should make sure not to provision manually additional volumes inside the external storage with this type of name, because this will lead to conflicts and possible loss of data.
The VOL_SIZE variable denotes the size of the new volume to be created in mebibytes.
If the script ends successfully, a new volume of size VOL_SIZE should exist inside the external storage. e.g:: a lun inside a NAS appliance.
The script returns 0 on success.
*/
Create(context.Context, *VolumeInfo) error
/*
This command is used in order to make an already created volume visible to the physical node which will host the instance. This is done by mapping the already provisioned volume to a block device inside the host node.
The VOL_NAME variable denotes the volume to be mapped.
After successful attachment the script returns to its stdout a string, which is the full path of the block device to which the volume is mapped. e.g:: /dev/dummy1
When attach returns, this path should be a valid block device on the host node.
The attach script should be idempotent if the volume is already mapped. If the requested volume is already mapped, then the script should just return to its stdout the path which is already mapped to.
In case the storage technology supports userspace access to volumes as well, e.g. the QEMU Hypervisor can see an RBD volume using its embedded driver for the RBD protocol, then the provider can return extra lines denoting the available userspace access URIs per hypervisor. The URI should be in the following format: <hypervisor>:<uri>. For example, a RADOS provider should return kvm:rbd:<pool>/<volume name> in the second line of stdout after the local block device path (e.g. /dev/rbd1).
So, if the access disk parameter is userspace for the ext disk template, then the QEMU command will end up having file=<URI> in the -drive option.
In case the storage technology supports only userspace access to volumes, then the first line of stdout should be an empty line, denoting that a local block device is not available. If neither a block device nor a URI is returned, then Ganeti will complain.
*/
Attach(context.Context, *VolumeInfo) error
/*
This command is used in order to unmap an already mapped volume from the host node. Detach undoes everything attach did. This is done by unmapping the requested volume from the block device it is mapped to.
The VOL_NAME variable denotes the volume to be unmapped.
detach doesn’t affect the volume itself. It just unmaps it from the host node. The volume continues to exist inside the external storage. It’s just not accessible by the node anymore. This script doesn’t return anything to its stdout.
The detach script should be idempotent if the volume is already unmapped. If the volume is not mapped, the script doesn’t perform any action at all.
The script returns 0 on success.
*/
Detach(context.Context, *VolumeInfo) error
/*
This command is used to remove an existing volume from the external storage. The volume is permanently removed from inside the external storage along with all its data.
The VOL_NAME variable denotes the volume to be removed.
The script returns 0 on success.
*/
Remove(context.Context, *VolumeInfo) error
/*
This command is used to grow an existing volume of the external storage.
The VOL_NAME variable denotes the volume to grow.
The VOL_SIZE variable denotes the current volume’s size (in mebibytes). The VOL_NEW_SIZE variable denotes the final size after the volume has been grown (in mebibytes).
The amount of grow can be easily calculated by the script and is:
grow_amount = VOL_NEW_SIZE - VOL_SIZE (in mebibytes)
Ganeti ensures that: VOL_NEW_SIZE > VOL_SIZE
If the script returns successfully, then the volume inside the external storage will have a new size of VOL_NEW_SIZE. This isn’t immediately reflected to the instance’s disk. See gnt-instance grow for more details on when the running instance becomes aware of its grown disk.
The script returns 0 on success.
*/
Grow(context.Context, *VolumeInfo) error
/*
This script is used to add metadata to an existing volume. It is helpful when we need to keep an external, Ganeti-independent mapping between instances and volumes; primarily for recovery reasons. This is provider specific and the author of the provider chooses whether/how to implement this. You can just exit with 0, if you do not want to implement this feature, without harming the overall functionality of the provider.
The VOL_METADATA variable contains the metadata of the volume.
Currently, Ganeti sets this value to originstname+X where X is the instance’s name.
The script returns 0 on success.
*/
Setinfo(context.Context, *VolumeInfo) error
/*
The verify script is used to verify consistency of the external parameters (ext-params) (see below). The command should take one or more arguments denoting what checks should be performed, and return a proper exit code depending on whether the validation failed or succeeded.
Currently, the script is not invoked by Ganeti, but should be present for future use and consistency with gnt-os-interface’s verify script.
The script should return 0 on success.
*/
Verify(context.Context, *VolumeInfo) error
// Close closes the driver
Close(context.Context) error
} | pkg/ganeti/extstorage/interface.go | 0.580233 | 0.487612 | interface.go | starcoder |
package set1
import (
"encoding/hex"
)
/**
* Cryptopal Set 1
* Challenge 3 - Single Byte Xor Cipher
* https://cryptopals.com/sets/1/challenges/3
*/
// SingleByteXorCrackFromByte tries to decrypt a cipher xor'd against a single character
func SingleByteXorCrackFromByte(cipher []byte) (bestScore int, bestKey byte, plaintext string) {
bestScore = -1
bestKey = 0
var probablePlaintext []byte
// Brute force the key
var i byte
for i = 0; i < 255; i++ {
// Create the key [k, k, k, ..., k]
key := make([]byte, len(cipher))
for j := 0; j < len(cipher); j++ {
key[j] = i
}
// cipher XOR key = plaintext
plaintext, _ := XOR(key, cipher)
frequencyAnalysis, _ := FrequencyAnalysis(plaintext)
score := scoreFrequencyAnalysis(frequencyAnalysis)
if score > bestScore {
bestScore = score
probablePlaintext = plaintext
bestKey = i
}
}
return bestScore, bestKey, string(probablePlaintext)
}
// SingleByteXorCrack tries to decrypt a cipher xor'd against a single character
func SingleByteXorCrack(s string) (bestScore int, plaintext string) {
cipher, _ := hex.DecodeString(s)
bestScore, _, plaintext = SingleByteXorCrackFromByte(cipher)
return bestScore, plaintext
}
// IndexOf find the index of a byte in a byte array
func IndexOf(arr []byte, candidate byte) int {
for index, c := range arr {
if c == candidate {
return index
}
}
return -1
}
func scoreFrequencyAnalysis(frequencies map[byte]float32) int {
// https://en.wikipedia.org/wiki/Letter_frequency
// englishFrequency := map[byte]float32{
// ' ': 0.13,
// 'e': 0.12702, 't': 0.9056, 'a': 0.8167, 'o': 0.7507,
// 'i': 0.6966, 'n': 0.6749, 's': 0.6327, 'h': 0.6094,
// 'r': 0.5987, 'd': 0.4253, 'l': 0.4025, 'c': 0.2782,
// 'u': 0.2758, 'm': 0.2406, 'w': 0.2360, 'f': 0.2228,
// 'g': 0.2015, 'y': 0.1974, 'p': 0.1929, 'b': 0.1492,
// 'v': 0.0978, 'k': 0.0772, 'j': 0.0153, 'x': 0.0150,
// 'q': 0.0095, 'z': 0.0074,
// }
// https://www.mdickens.me/typing/letter_frequency.html
characterOrder := []byte{
' ', 'e', 't', 'a', 'o', 'i', 'n', 's', 'h', 'r', 'd', 'l',
'c', 'u', 'm', 'w', 'f', 'g', 'y', 'p', 'b', 'v', 'k', 'j',
'x', 'q', 'z',
}
// To score the frequency analysis against the english frequency
// we determine how close we are to the expected order of characters
score := 0
for char, freq := range frequencies {
index := IndexOf(characterOrder, char)
if index != -1 {
// Check the expected relative frequency to other characters
for j := 0; j < index; j++ {
otherChar := characterOrder[j]
if freq < frequencies[otherChar] {
score++
}
}
for j := index; j < len(characterOrder); j++ {
otherChar := characterOrder[j]
if freq > frequencies[otherChar] {
score++
}
}
}
}
return score
}
// FrequencyAnalysis performs a frequency analysis of each byte in an array
func FrequencyAnalysis(bytes []byte) (map[byte]float32, []byte) {
length := len(bytes)
// Count the occurence of each byte
counter := make(map[byte]int)
for i := 0; i < len(bytes); i++ {
counter[bytes[i]]++
}
// Get bytes used in the array
j := 0
keys := make([]byte, len(counter))
for k := range counter {
keys[j] = k
j++
}
// Compute frequency
freq := make(map[byte]float32, len(keys))
for i := 0; i < len(keys); i++ {
freq[keys[i]] = float32(counter[keys[i]]) / float32(length)
}
// Sort keys according to frequencies in descending order (insertion sort)
for i := 0; i < len(keys); i++ {
j := i
for j > 0 && freq[keys[j-1]] < freq[keys[j]] {
keys[j-1], keys[j] = keys[j], keys[j-1]
j--
}
}
return freq, keys
} | set1/single-byte-xor-cipher.go | 0.724773 | 0.420064 | single-byte-xor-cipher.go | starcoder |
package lib
import (
"errors"
"gopkg.in/yaml.v2"
"io/ioutil"
"log"
)
type card struct {
name string
}
func Card(name string) card {
return card{name: name}
}
func (self *card) Pretty() string {
return GetCardData(self.name).Pretty
}
func (self *card) ToJSON() string {
var t tag
if self.IsLand() {
t = Tag("land", self.Pretty(), self.Target())
} else {
t = Tag("spell", self.Pretty(), self.Target())
}
return t.ToJSON()
}
func (self *card) TapsFor() mana {
return GetCardData(self.name).TapsFor
}
func (self *card) CastingCost() mana {
return GetCardData(self.name).CastingCost
}
func (self *card) CanBeTitan() bool {
// Most common fail case is that we can't find Primeval Titan. Let's try to
// identify those situations sooner.
return GetCardData(self.name).CanBeTitan
}
func (self *card) AlwaysCast() bool {
return GetCardData(self.name).AlwaysCast
}
func (self *card) IsLand() bool {
return GetCardData(self.name).Type == "land"
}
func (self *card) IsBounceLand() bool {
return self.name == "<NAME>"
}
func (self *card) IsCreature() bool {
return GetCardData(self.name).Type == "creature"
}
func (self *card) IsColorless() bool {
return GetCardData(self.name).Type == "land" || self.name == "Amulet of Vigor"
}
func (self *card) HasAbility() bool {
return GetCardData(self.name).ActivationCost.Total != 0
}
func (self *card) ActivationCost() mana {
return GetCardData(self.name).ActivationCost
}
func (self *card) EntersTapped() bool {
return GetCardData(self.name).EntersTapped
}
func (self *card) Target() string {
ret := GetCardData(self.name).Target
if ret == "" {
ret = self.name
}
return ret
}
type cardData struct {
// No need to duplicate card metadata over and over. Cache it by card name
// and look it up as needed.
Name string `yaml:"name"`
ActivationCost mana `yaml:"activation_cost"`
CastingCost mana `yaml:"casting_cost"`
EntersTapped bool `yaml:"enters_tapped"`
Pretty string `yaml:"pretty"`
Target string `yaml:"target"`
Type string `yaml:"type"`
TapsFor mana `yaml:"taps_for"`
CanBeTitan bool `yaml:"can_be_titan"`
AlwaysCast bool `yaml:"always_cast"`
}
// Cache card data by name so we don't re-read the file repeatedly
var cardCache = make(map[string]cardData)
func InitCardDataCache() {
cardDataRaw := []cardData{}
textBytes, err := ioutil.ReadFile("carddata.yaml")
if err != nil {
log.Fatal(err)
}
err = yaml.Unmarshal(textBytes, &cardDataRaw)
if err != nil {
log.Fatal(err)
}
log.Println("loading carddata.yaml")
for _, cd := range cardDataRaw {
// Pre-compute this since it gets used a lot
if cd.Pretty == "" {
cd.Pretty = slug(cd.Name)
}
cardCache[cd.Name] = cd
}
}
func GetCardData(cardName string) cardData {
if len(cardCache) == 0 {
InitCardDataCache()
}
return cardCache[cardName]
}
func EnsureCardData(cardNames []string) error {
if len(cardCache) == 0 {
InitCardDataCache()
}
for _, cardName := range cardNames {
_, ok := cardCache[cardName]
if !ok {
return errors.New("no data for: " + cardName)
}
}
return nil
} | lib/card.go | 0.726523 | 0.403684 | card.go | starcoder |
package storage
import (
"encoding"
"encoding/json"
"fmt"
"reflect"
"strconv"
"github.com/fatih/structs"
)
// StringStringMapDecoder is used to decode a map[string]string to a struct
type StringStringMapDecoder func(input map[string]string) (interface{}, error)
func decodeToType(typ reflect.Kind, value string) interface{} {
switch typ {
case reflect.String:
return value
case reflect.Bool:
v, _ := strconv.ParseBool(value)
return v
case reflect.Int:
v, _ := strconv.ParseInt(value, 10, 64)
return int(v)
case reflect.Int8:
return int8(decodeToType(reflect.Int, value).(int))
case reflect.Int16:
return int16(decodeToType(reflect.Int, value).(int))
case reflect.Int32:
return int32(decodeToType(reflect.Int, value).(int))
case reflect.Int64:
return int64(decodeToType(reflect.Int, value).(int))
case reflect.Uint:
v, _ := strconv.ParseUint(value, 10, 64)
return uint(v)
case reflect.Uint8:
return uint8(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint16:
return uint16(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint32:
return uint32(decodeToType(reflect.Uint, value).(uint))
case reflect.Uint64:
return uint64(decodeToType(reflect.Uint, value).(uint))
case reflect.Float64:
v, _ := strconv.ParseFloat(value, 64)
return v
case reflect.Float32:
return float32(decodeToType(reflect.Float64, value).(float64))
}
return nil
}
func unmarshalToType(typ reflect.Type, value string) (val interface{}, err error) {
// If we get a pointer in, we'll return a pointer out
if typ.Kind() == reflect.Ptr {
val = reflect.New(typ.Elem()).Interface()
} else {
val = reflect.New(typ).Interface()
}
defer func() {
if err == nil && typ.Kind() != reflect.Ptr {
val = reflect.Indirect(reflect.ValueOf(val)).Interface()
}
}()
// If we can just assign the value, return the value
if typ.AssignableTo(reflect.TypeOf(value)) {
return value, nil
}
// Try Unmarshalers
if um, ok := val.(encoding.TextUnmarshaler); ok {
if err = um.UnmarshalText([]byte(value)); err == nil {
return val, nil
}
}
if um, ok := val.(json.Unmarshaler); ok {
if err = um.UnmarshalJSON([]byte(value)); err == nil {
return val, nil
}
}
// Try conversion
if typ.ConvertibleTo(reflect.TypeOf(value)) {
return reflect.ValueOf(value).Convert(typ).Interface(), nil
}
// Try JSON
if err = json.Unmarshal([]byte(value), val); err == nil {
return val, nil
}
// Return error if we have one
if err != nil {
return nil, err
}
return val, fmt.Errorf("No way to unmarshal \"%s\" to %s", value, typ.Name())
}
// buildDefaultStructDecoder is used by the RedisMapStore
func buildDefaultStructDecoder(base interface{}, tagName string) StringStringMapDecoder {
if tagName == "" {
tagName = defaultTagName
}
return func(input map[string]string) (output interface{}, err error) {
baseType := reflect.TypeOf(base)
// If we get a pointer in, we'll return a pointer out
if baseType.Kind() == reflect.Ptr {
output = reflect.New(baseType.Elem()).Interface()
} else {
output = reflect.New(baseType).Interface()
}
defer func() {
if err == nil && baseType.Kind() != reflect.Ptr {
output = reflect.Indirect(reflect.ValueOf(output)).Interface()
}
}()
s := structs.New(output)
for _, field := range s.Fields() {
if !field.IsExported() {
continue
}
tagName, _ := parseTag(field.Tag(tagName))
if tagName == "" || tagName == "-" {
continue
}
if str, ok := input[tagName]; ok {
baseField, _ := baseType.FieldByName(field.Name())
if str == "" {
continue
}
var val interface{}
switch field.Kind() {
case reflect.Ptr:
if str == "null" {
continue
}
fallthrough
case reflect.Struct, reflect.Array, reflect.Interface, reflect.Slice:
var err error
val, err = unmarshalToType(baseField.Type, str)
if err != nil {
return nil, err
}
default:
val = decodeToType(field.Kind(), str)
}
if val == nil {
continue
}
if !baseField.Type.AssignableTo(reflect.TypeOf(val)) && baseField.Type.ConvertibleTo(reflect.TypeOf(val)) {
val = reflect.ValueOf(val).Convert(baseField.Type).Interface()
}
if err := field.Set(val); err != nil {
return nil, err
}
}
}
return output, nil
}
} | core/storage/decoder.go | 0.646572 | 0.476884 | decoder.go | starcoder |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.