Project showcase
Magic Wandddddddd

Magic Wandddddddd

"Magic wand" gesture recognition by running CNN on Arduino.

  • 1,994 views
  • 0 comments
  • 4 respects

Components and supplies

Apps and online services

About this project

In this complex world, some data can be easily analyzed by our brains, but some can not. Sometimes, in order to really understand a bunch of data, you need very specific domain knowledge and programming/statistics expertise, which both are not fast to acquire. However, by using machine learning to train models on those complex data, we might be able to recognize the signals without the requirements mentioned above. Therefore, we would like to build a "Magic Wand". In this story, we will discuss what we are really building in machine learning terms, what the architecture is, several tests we have gone through and how you can deploy it.

What we are building

It's actually pretty simple. In the Harry Potter world, people wave their magic wands in different shapes and the wands can understand what to do based on the shapes. Therefore, we want to make our Arduino board the wand, and the first step of this "wand" is to recognize the shapes people wave in.

In this project, we have three classes: Wing, Ring, Slope.

The data set to train the model is people's motion through 3D space, acquired by Arduino's accelerometer. This accelerometer can measure the degree of acceleration that the device is currently experiencing, and the Arduino board can measure it in three dimensions!

And the job of this model is to classify! Based on the 3D data, the model needs to infer its corresponding shape and outputs the name.

Application architecture

The main loop: running multiple per seconds

  • Accelerometer handler (Input data): the amount of acceleration on x, y, z-axes, directly gained from the accelerometer
  • TF Lite interpreter (Model): a CNN around 20 KB. Takes 128 sets of xyz at once, which is around 5 seconds' data. Trained by numerous people on Wing, Ring, Slope and "unknown" gestures. Inference with a probability score over 0.8 is considered confident.
  • Gesture predictor: takes the output from the model and decides if a gesture has been detected (confidence threshold & number of consecutive positive predictions)
  • Output handler (Output data): lights the LED and prints out the names if detected

Tests of main components

The tests are about magic wand (model), accelerometer handler, gesture predictor and output handler.

  • magic wand: feed the data into model's input, run the inference, compare the results with the expected (highest score on the expected shape)
  • accelerometer handler: tests the one-time set up the accelerometer needs; tests that only if 384 bytes are available, the inference begins to work
  • gesture predictor: tests that this function returns an "unknown" when confidence threshold (probability of single inference) has been strongly matched but the number of consecutive positives is still insufficient and returns the matched one when the number becomes sufficient; tests that this function returns an "unknown" when an insufficient number of strongly matched inference suddenly followed by another strongly matched inference; tests that this function returns an "unknown" even if the number of consecutive inference is sufficient, but the value itself does not meet the threshold (required probability)
  • output handler: tests that after getting the results from gesture predictor, it can display all four results correctly

Deploying to Arduino

We are using Arduino Nano 33 BLE Sense which has 3-axis accelerometer. https://store.arduino.cc/usa/nano-33-ble-sense-with-headers

Note: Our target rate is 25Hz, but for our board, its sampling rate is 119Hz. Our solution is to drop some samples to maintain 25Hz.

1. Install Arduino IDE.

Download and install Arduino IDE to your system. https://www.arduino.cc/en/main/software

2. Add TensorFLowLite library.

Tool --> Manage Libraries --> In the window that appears, search for and install the library named Arduino_TensorFlowLite.

3. Add and modify LSM9DS3 library.

Tool --> Manage Libraries --> In the window that appears, search for and install the library named Arduino_LSM9DS1 version 1.0.0.

Find LSM9DS1.cpp at /home/username/Arduino_LSM9DS1/src/LSM9DS1.cpp.

In the function named LSM9DS1Class::begin(), insert the following code at the end of the function before return.

// Enable FIFO (see docs https://www.st.com/resource/en/datasheet/DM00103319.pdf)
writeRegister(LSM9DS1_ADDRESS, 0x23, 0x02);
// Set continuous mode
writeRegister(LSM9DS1_ADDRESS, 0x2E, 0xC0);

In the function named LSM9DS1Class::accelerationAvailable(), replace the following code

if (readRegister(LSM9DS1_ADDRESS, LSM9DS1_STATUS_REG) & 0x01) {
return 1;
}

with

// Read FIFO_SRC. If any of the rightmost 8 bits have a value, there is data
if (readRegister(LSM9DS1_ADDRESS, 0x2F) & 63) {
return 1;
}

And finally save the file.

4. Load magic_wand from example.

File --> Examples --> TensorFlowLite --> magic_wand.

5. Make sure using correct device type and port.

Tools --> Board --> Aruino Nano 33 BLE

Tools --> Port --> /dev/ttyACM0 (on Ubuntu 16.04)

6. Run the application.

Finally, hit the upload button to compile and upload the code to the Arduino device. Once the upload is completed, you are able to see the LED begins flashing. Now open the Serial Monitor by Tools --> Serial Monitor, you will see the log. Please see more in our video.

Note:

When you upload the sketch, if you encounter Error opening serial port, follow the solution here: https://www.arduino.cc/en/Guide/Linux/

Code

arduino_main.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "main_functions.h"

// Arduino automatically calls the setup() and loop() functions in a sketch, so
// where other systems need their own main routine in this file, it can be left
// empty.
gesture_predictor.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "gesture_predictor.h"

#include "constants.h"

// How many times the most recent gesture has been matched in a row
int continuous_count = 0;
// The result of the last prediction
int last_predict = -1;

// Return the result of the last prediction
// 0: wing("W"), 1: ring("O"), 2: slope("angle"), 3: unknown
int PredictGesture(float* output) {
  // Find whichever output has a probability > 0.8 (they sum to 1)
  int this_predict = -1;
  for (int i = 0; i < 3; i++) {
    if (output[i] > 0.8) this_predict = i;
  }
  // No gesture was detected above the threshold
  if (this_predict == -1) {
    continuous_count = 0;
    last_predict = 3;
    return 3;
  }
  if (last_predict == this_predict) {
    continuous_count += 1;
  } else {
    continuous_count = 0;
  }
  last_predict = this_predict;
  // If we haven't yet had enough consecutive matches for this gesture,
  // report a negative result
  if (continuous_count < kConsecutiveInferenceThresholds[this_predict]) {
    return 3;
  }
  // Otherwise, we've seen a positive result, so clear all our variables
  // and report it
  continuous_count = 0;
  last_predict = -1;
  return this_predict;
}
output_handler.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_OUTPUT_HANDLER_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_OUTPUT_HANDLER_H_

#include "tensorflow/lite/c/c_api_internal.h"
#include "tensorflow/lite/experimental/micro/micro_error_reporter.h"

void HandleOutput(tflite::ErrorReporter* error_reporter, int kind);

#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_OUTPUT_HANDLER_H_
constants.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_CONSTANTS_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_CONSTANTS_H_

// The expected accelerometer data sample frequency
const float kTargetHz = 25;

// The number of expected consecutive inferences for each gesture type
extern const int kConsecutiveInferenceThresholds[3];
#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_CONSTANTS_H_
magic_wand.inoArduino
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include <TensorFlowLite.h>

#include "main_functions.h"

#include "accelerometer_handler.h"
#include "gesture_predictor.h"
#include "magic_wand_model_data.h"
#include "output_handler.h"
#include "tensorflow/lite/experimental/micro/kernels/micro_ops.h"
#include "tensorflow/lite/experimental/micro/micro_error_reporter.h"
#include "tensorflow/lite/experimental/micro/micro_interpreter.h"
#include "tensorflow/lite/experimental/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "tensorflow/lite/version.h"

// Globals, used for compatibility with Arduino-style sketches.
namespace {
tflite::ErrorReporter* error_reporter = nullptr;
const tflite::Model* model = nullptr;
tflite::MicroInterpreter* interpreter = nullptr;
TfLiteTensor* model_input = nullptr;
int input_length;

// Create an area of memory to use for input, output, and intermediate arrays.
// The size of this will depend on the model you're using, and may need to be
// determined by experimentation.
constexpr int kTensorArenaSize = 60 * 1024;
uint8_t tensor_arena[kTensorArenaSize];

// Whether we should clear the buffer next time we fetch data
bool should_clear_buffer = false;
}  // namespace

// The name of this function is important for Arduino compatibility.
void setup() {
  // Set up logging. Google style is to avoid globals or statics because of
  // lifetime uncertainty, but since this has a trivial destructor it's okay.
  static tflite::MicroErrorReporter micro_error_reporter;  // NOLINT
  error_reporter = &micro_error_reporter;

  // Map the model into a usable data structure. This doesn't involve any
  // copying or parsing, it's a very lightweight operation.
  model = tflite::GetModel(g_magic_wand_model_data);
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    error_reporter->Report(
        "Model provided is schema version %d not equal "
        "to supported version %d.",
        model->version(), TFLITE_SCHEMA_VERSION);
    return;
  }

  // Pull in only the operation implementations we need.
  // This relies on a complete list of all the ops needed by this graph.
  // An easier approach is to just use the AllOpsResolver, but this will
  // incur some penalty in code space for op implementations that are not
  // needed by this graph.
  static tflite::MicroMutableOpResolver micro_mutable_op_resolver;  // NOLINT
  micro_mutable_op_resolver.AddBuiltin(
      tflite::BuiltinOperator_DEPTHWISE_CONV_2D,
      tflite::ops::micro::Register_DEPTHWISE_CONV_2D());
  micro_mutable_op_resolver.AddBuiltin(
      tflite::BuiltinOperator_MAX_POOL_2D,
      tflite::ops::micro::Register_MAX_POOL_2D());
  micro_mutable_op_resolver.AddBuiltin(tflite::BuiltinOperator_CONV_2D,
                                       tflite::ops::micro::Register_CONV_2D());
  micro_mutable_op_resolver.AddBuiltin(
      tflite::BuiltinOperator_FULLY_CONNECTED,
      tflite::ops::micro::Register_FULLY_CONNECTED());
  micro_mutable_op_resolver.AddBuiltin(tflite::BuiltinOperator_SOFTMAX,
                                       tflite::ops::micro::Register_SOFTMAX());

  // Build an interpreter to run the model with
  static tflite::MicroInterpreter static_interpreter(
      model, micro_mutable_op_resolver, tensor_arena, kTensorArenaSize,
      error_reporter);
  interpreter = &static_interpreter;

  // Allocate memory from the tensor_arena for the model's tensors
  interpreter->AllocateTensors();

  // Obtain pointer to the model's input tensor
  model_input = interpreter->input(0);
  if ((model_input->dims->size != 4) || (model_input->dims->data[0] != 1) ||
      (model_input->dims->data[1] != 128) ||
      (model_input->dims->data[2] != kChannelNumber) ||
      (model_input->type != kTfLiteFloat32)) {
    error_reporter->Report("Bad input tensor parameters in model");
    return;
  }

  input_length = model_input->bytes / sizeof(float);

  TfLiteStatus setup_status = SetupAccelerometer(error_reporter);
  if (setup_status != kTfLiteOk) {
    error_reporter->Report("Set up failed\n");
  }
}

void loop() {
  // Attempt to read new data from the accelerometer
  bool got_data = ReadAccelerometer(error_reporter, model_input->data.f,
                                    input_length, should_clear_buffer);
  // Don't try to clear the buffer again
  should_clear_buffer = false;
  // If there was no new data, wait until next time
  if (!got_data) return;
  // Run inference, and report any error
  TfLiteStatus invoke_status = interpreter->Invoke();
  if (invoke_status != kTfLiteOk) {
    error_reporter->Report("Invoke failed on index: %d\n", begin_index);
    return;
  }
  // Analyze the results to obtain a prediction
  int gesture_index = PredictGesture(interpreter->output(0)->data.f);
  // Clear the buffer next time we read data
  should_clear_buffer = gesture_index < 3;
  // Produce an output
  HandleOutput(error_reporter, gesture_index);
}
LSM9DS1.cppC/C++
Modifed version of LSM9DS1.cpp. The original version has bugs as suggested by the book.
/*
  This file is part of the Arduino_LSM9DS1 library.
  Copyright (c) 2019 Arduino SA. All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "LSM9DS1.h"

#define LSM9DS1_ADDRESS            0x6b

#define LSM9DS1_WHO_AM_I           0x0f
#define LSM9DS1_CTRL_REG1_G        0x10
#define LSM9DS1_STATUS_REG         0x17
#define LSM9DS1_OUT_X_G            0x18
#define LSM9DS1_CTRL_REG6_XL       0x20
#define LSM9DS1_CTRL_REG8          0x22
#define LSM9DS1_OUT_X_XL           0x28

// magnetometer
#define LSM9DS1_ADDRESS_M          0x1e

#define LSM9DS1_CTRL_REG1_M        0x20
#define LSM9DS1_CTRL_REG2_M        0x21
#define LSM9DS1_CTRL_REG3_M        0x22
#define LSM9DS1_STATUS_REG_M       0x27
#define LSM9DS1_OUT_X_L_M          0x28

LSM9DS1Class::LSM9DS1Class(TwoWire& wire) :
  _wire(&wire)
{
}

LSM9DS1Class::~LSM9DS1Class()
{
}

int LSM9DS1Class::begin()
{
  _wire->begin();

  // reset
  writeRegister(LSM9DS1_ADDRESS, LSM9DS1_CTRL_REG8, 0x05);
  writeRegister(LSM9DS1_ADDRESS_M, LSM9DS1_CTRL_REG2_M, 0x0c);

  delay(10);

  if (readRegister(LSM9DS1_ADDRESS, LSM9DS1_WHO_AM_I) != 0x68) {
    end();

    return 0;
  }

  if (readRegister(LSM9DS1_ADDRESS_M, LSM9DS1_WHO_AM_I) != 0x3d) {
    end();

    return 0;
  }

  writeRegister(LSM9DS1_ADDRESS, LSM9DS1_CTRL_REG1_G, 0x78); // 119 Hz, 2000 dps, 16 Hz BW
  writeRegister(LSM9DS1_ADDRESS, LSM9DS1_CTRL_REG6_XL, 0x70); // 119 Hz, 4G

  writeRegister(LSM9DS1_ADDRESS_M, LSM9DS1_CTRL_REG1_M, 0xb4); // Temperature compensation enable, medium performance, 20 Hz
  writeRegister(LSM9DS1_ADDRESS_M, LSM9DS1_CTRL_REG2_M, 0x00); // 4 Gauss
  writeRegister(LSM9DS1_ADDRESS_M, LSM9DS1_CTRL_REG3_M, 0x00); // Continuous conversion mode

  // Enable FIFO (see docs https://www.st.com/resource/en/datasheet/DM00103319.pdf)
  writeRegister(LSM9DS1_ADDRESS, 0x23, 0x02);
  // Set continuous mode
  writeRegister(LSM9DS1_ADDRESS, 0x2E, 0xC0);
  
  return 1;
}

void LSM9DS1Class::end()
{
  writeRegister(LSM9DS1_ADDRESS_M, LSM9DS1_CTRL_REG3_M, 0x03);
  writeRegister(LSM9DS1_ADDRESS, LSM9DS1_CTRL_REG1_G, 0x00);
  writeRegister(LSM9DS1_ADDRESS, LSM9DS1_CTRL_REG6_XL, 0x00);

  _wire->end();
}

int LSM9DS1Class::readAcceleration(float& x, float& y, float& z)
{
  int16_t data[3];

  if (!readRegisters(LSM9DS1_ADDRESS, LSM9DS1_OUT_X_XL, (uint8_t*)data, sizeof(data))) {
    x = NAN;
    y = NAN;
    z = NAN;

    return 0;
  }

  x = data[0] * 4.0 / 32768.0;
  y = data[1] * 4.0 / 32768.0;
  z = data[2] * 4.0 / 32768.0;

  return 1;
}

int LSM9DS1Class::accelerationAvailable()
{
  //if (readRegister(LSM9DS1_ADDRESS, LSM9DS1_STATUS_REG) & 0x01) {
  //  return 1;
  //}

  // Read FIFO_SRC. If any of the rightmost 8 bits have a value, there is data
  if (readRegister(LSM9DS1_ADDRESS, 0x2F) & 63) {
     return 1;
  }

  return 0;
}

float LSM9DS1Class::accelerationSampleRate()
{
  return 119.0F;
}

int LSM9DS1Class::readGyroscope(float& x, float& y, float& z)
{
  int16_t data[3];

  if (!readRegisters(LSM9DS1_ADDRESS, LSM9DS1_OUT_X_G, (uint8_t*)data, sizeof(data))) {
    x = NAN;
    y = NAN;
    z = NAN;

    return 0;
  }

  x = data[0] * 2000.0 / 32768.0;
  y = data[1] * 2000.0 / 32768.0;
  z = data[2] * 2000.0 / 32768.0;

  return 1;
}

int LSM9DS1Class::gyroscopeAvailable()
{
  if (readRegister(LSM9DS1_ADDRESS, LSM9DS1_STATUS_REG) & 0x02) {
    return 1;
  }

  return 0;
}

float LSM9DS1Class::gyroscopeSampleRate()
{
  return 119.0F;
}

int LSM9DS1Class::readMagneticField(float& x, float& y, float& z)
{
  int16_t data[3];

  if (!readRegisters(LSM9DS1_ADDRESS_M, LSM9DS1_OUT_X_L_M, (uint8_t*)data, sizeof(data))) {
    x = NAN;
    y = NAN;
    z = NAN;

    return 0;
  }

  x = data[0] * 4.0 * 100.0 / 32768.0;
  y = data[1] * 4.0 * 100.0 / 32768.0;
  z = data[2] * 4.0 * 100.0 / 32768.0;

  return 1;
}

int LSM9DS1Class::magneticFieldAvailable()
{
  if (readRegister(LSM9DS1_ADDRESS_M, LSM9DS1_STATUS_REG_M) & 0x08) {
    return 1;
  }

  return 0;
}

float LSM9DS1Class::magneticFieldSampleRate()
{
  return 20.0;
}

int LSM9DS1Class::readRegister(uint8_t slaveAddress, uint8_t address)
{
  _wire->beginTransmission(slaveAddress);
  _wire->write(address);
  if (_wire->endTransmission() != 0) {
    return -1;
  }

  if (_wire->requestFrom(slaveAddress, 1) != 1) {
    return -1;
  }

  return _wire->read();
}

int LSM9DS1Class::readRegisters(uint8_t slaveAddress, uint8_t address, uint8_t* data, size_t length)
{
  _wire->beginTransmission(slaveAddress);
  _wire->write(0x80 | address);
  if (_wire->endTransmission(false) != 0) {
    return -1;
  }

  if (_wire->requestFrom(slaveAddress, length) != length) {
    return 0;
  }

  for (size_t i = 0; i < length; i++) {
    *data++ = _wire->read();
  }

  return 1;
}

int LSM9DS1Class::writeRegister(uint8_t slaveAddress, uint8_t address, uint8_t value)
{
  _wire->beginTransmission(slaveAddress);
  _wire->write(address);
  _wire->write(value);
  if (_wire->endTransmission() != 0) {
    return 0;
  }

  return 1;
}

#ifdef ARDUINO_ARDUINO_NANO33BLE
LSM9DS1Class IMU(Wire1);
#else
LSM9DS1Class IMU(Wire);
#endif
magic_wand_model_data.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// Automatically created from a TensorFlow Lite flatbuffer using the command:
// xxd -i magic_wand_model.tflite > magic_wand_model_data.cc
// See the README for a full description of the creation process.

#include "magic_wand_model_data.h"

// We need to keep the data array aligned on some architectures.
#ifdef __has_attribute
#define HAVE_ATTRIBUTE(x) __has_attribute(x)
#else
#define HAVE_ATTRIBUTE(x) 0
#endif
#if HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
#define DATA_ALIGN_ATTRIBUTE __attribute__((aligned(4)))
#else
#define DATA_ALIGN_ATTRIBUTE
#endif

const unsigned char g_magic_wand_model_data[] DATA_ALIGN_ATTRIBUTE = {
  0x18, 0x00, 0x00, 0x00, 0x54, 0x46, 0x4c, 0x33, 0x00, 0x00, 0x0e, 0x00,
  0x18, 0x00, 0x04, 0x00, 0x08, 0x00, 0x0c, 0x00, 0x10, 0x00, 0x14, 0x00,
  0x0e, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x18, 0x4c, 0x00, 0x00,
  0x0c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
  0x01, 0x00, 0x00, 0x00, 0x20, 0x44, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
  0x54, 0x4f, 0x43, 0x4f, 0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74,
  0x65, 0x64, 0x2e, 0x00, 0x11, 0x00, 0x00, 0x00, 0xf4, 0x43, 0x00, 0x00,
  0xa4, 0x43, 0x00, 0x00, 0x84, 0x43, 0x00, 0x00, 0x34, 0x43, 0x00, 0x00,
  0x2c, 0x43, 0x00, 0x00, 0x1c, 0x42, 0x00, 0x00, 0x14, 0x42, 0x00, 0x00,
  0x04, 0x0a, 0x00, 0x00, 0xd4, 0x09, 0x00, 0x00, 0xc4, 0x01, 0x00, 0x00,
  0xbc, 0x01, 0x00, 0x00, 0xb4, 0x01, 0x00, 0x00, 0xac, 0x01, 0x00, 0x00,
  0x1c, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
  0x04, 0x00, 0x00, 0x00, 0x24, 0xb6, 0xff, 0xff, 0x28, 0xb6, 0xff, 0xff,
  0x2c, 0xb6, 0xff, 0xff, 0x76, 0xb6, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
  0x80, 0x01, 0x00, 0x00, 0x13, 0x00, 0x8a, 0xbe, 0x50, 0x7c, 0x49, 0x3e,
  0xb4, 0x06, 0x5a, 0xbc, 0xa6, 0xf2, 0xa8, 0xbd, 0x73, 0x50, 0x62, 0x3c,
  0xdd, 0x0a, 0x4a, 0xbe, 0xe2, 0x77, 0x9c, 0x3e, 0x8b, 0xe0, 0xc7, 0xbd,
  0xb2, 0xfd, 0xf5, 0x3d, 0x13, 0xb1, 0xb2, 0xbe, 0xcd, 0x78, 0x5a, 0xbd,
  0xfb, 0x15, 0x4e, 0xbc, 0x58, 0x7b, 0x3b, 0x3e, 0x14, 0x4b, 0x22, 0xbc,
  0x7e, 0x44, 0xd2, 0x3d, 0xdc, 0xda, 0x72, 0x3c, 0x1a, 0x87, 0xd9, 0x3d,
  0x3e, 0xdc, 0x13, 0x3d, 0x01, 0x1e, 0x75, 0xbe, 0x3d, 0x4f, 0x6a, 0xbd,
  0xa6, 0x52, 0x54, 0xbe, 0xc7, 0x7f, 0x5f, 0xbe, 0x97, 0x5f, 0x35, 0xbc,
  0xc5, 0x84, 0x5b, 0xbe, 0x7c, 0xd5, 0x6f, 0xbd, 0x90, 0x9b, 0x30, 0xbd,
  0x52, 0x86, 0xec, 0xbc, 0xc0, 0x4e, 0x0b, 0xbf, 0xfc, 0x3d, 0xec, 0xbd,
  0x92, 0x71, 0x26, 0x3e, 0x34, 0x26, 0x33, 0x3d, 0x06, 0x68, 0xfc, 0xbd,
  0x54, 0x5f, 0x2f, 0xbd, 0xa2, 0xce, 0xdd, 0x3d, 0x83, 0x6a, 0x76, 0xbc,
  0x64, 0xba, 0x95, 0xbd, 0x44, 0x69, 0x09, 0x3e, 0xea, 0x7b, 0x08, 0x3e,
  0xec, 0x13, 0x9f, 0xbd, 0x80, 0x2a, 0x04, 0xbe, 0x64, 0xf5, 0x84, 0x3e,
  0x31, 0xf8, 0xb4, 0xbd, 0xfa, 0x18, 0xb3, 0xbd, 0x4b, 0x3d, 0xf9, 0xbc,
  0xee, 0x0e, 0x8f, 0xbd, 0x3b, 0x21, 0x39, 0xbc, 0x35, 0xa0, 0xbb, 0xbc,
  0xd5, 0x5f, 0xbe, 0xbd, 0x9e, 0xc4, 0x0b, 0x3d, 0x4a, 0x8d, 0x82, 0xbe,
  0x01, 0xfb, 0x19, 0xbd, 0xb0, 0x51, 0xae, 0x3c, 0xb5, 0xd8, 0x68, 0xbe,
  0x97, 0x45, 0x73, 0x3d, 0xc7, 0x33, 0x2a, 0x3e, 0x9f, 0x82, 0x09, 0x3e,
  0x32, 0x36, 0xba, 0xbd, 0x93, 0x0d, 0x7e, 0xbb, 0xc2, 0x5f, 0xa6, 0xbd,
  0x13, 0x20, 0x55, 0xbe, 0xbf, 0x03, 0x08, 0xbe, 0xeb, 0xe0, 0xa9, 0xbd,
  0xf6, 0x4a, 0xcc, 0xbd, 0x8f, 0xf6, 0x28, 0xbd, 0x29, 0xe0, 0x81, 0x3d,
  0x92, 0x9d, 0x65, 0xbd, 0xe3, 0xb6, 0x17, 0x3e, 0x53, 0x07, 0xa6, 0xbc,
  0xba, 0x44, 0x3c, 0xbb, 0x05, 0x63, 0x36, 0xbc, 0xe1, 0x45, 0x23, 0xbd,
  0x0e, 0x10, 0x08, 0x3d, 0xee, 0xe5, 0x77, 0x3e, 0xf2, 0xe4, 0x76, 0xbe,
  0x61, 0x45, 0xbc, 0x3d, 0xda, 0xeb, 0xe4, 0x3e, 0xd4, 0xe1, 0xbc, 0xbd,
  0x0e, 0x17, 0x9a, 0xbe, 0x2a, 0x52, 0xbf, 0xbe, 0x71, 0x90, 0x91, 0x3e,
  0xfb, 0xfa, 0x6b, 0xbd, 0xdb, 0x52, 0x68, 0x3e, 0x7f, 0xfb, 0x49, 0x3d,
  0xd7, 0x8a, 0x5a, 0x3d, 0x20, 0x58, 0x09, 0xbe, 0xc4, 0x74, 0xd7, 0x3d,
  0x3b, 0x3e, 0xe8, 0xbc, 0x45, 0x92, 0xe0, 0xbc, 0x6d, 0x8e, 0xb8, 0xbe,
  0x24, 0x52, 0x32, 0xbd, 0x6d, 0x5a, 0x85, 0x3e, 0xb4, 0xc1, 0xaf, 0xbc,
  0x0e, 0xdf, 0x1a, 0xbe, 0xc8, 0xd1, 0x8e, 0xbe, 0x95, 0xba, 0xb2, 0xbd,
  0xe6, 0x9d, 0x7e, 0x3d, 0xbc, 0xb7, 0xff, 0xff, 0xc0, 0xb7, 0xff, 0xff,
  0xc4, 0xb7, 0xff, 0xff, 0x0e, 0xb8, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
  0x00, 0x08, 0x00, 0x00, 0x65, 0x15, 0x07, 0x3e, 0x19, 0xc0, 0x05, 0xbe,
  0xcb, 0xe0, 0xb8, 0x3d, 0xbc, 0x81, 0x7d, 0xbd, 0xdb, 0xac, 0xcb, 0x3d,
  0x28, 0x09, 0xa9, 0x3e, 0x16, 0x58, 0x9d, 0xbe, 0x1e, 0xc4, 0xd2, 0xbd,
  0x87, 0x2e, 0xdb, 0x3d, 0xd2, 0xdc, 0x80, 0xbd, 0xdc, 0x90, 0x41, 0x3d,
  0xeb, 0x0b, 0x5a, 0xbe, 0x4a, 0x91, 0xa2, 0xbc, 0x93, 0xff, 0x81, 0xbb,
  0x5f, 0xb4, 0x8e, 0xbd, 0x88, 0xba, 0x5c, 0xbd, 0x7b, 0x71, 0xef, 0x3c,
  0x46, 0xe5, 0x4d, 0xbf, 0x3a, 0x1f, 0x96, 0xbd, 0x4d, 0x39, 0xa1, 0xbf,
  0xe4, 0x63, 0x25, 0xbe, 0xc1, 0x1b, 0xa9, 0xbd, 0xba, 0x02, 0x88, 0xbd,
  0xd8, 0xcf, 0x75, 0xbe, 0x53, 0x42, 0xfa, 0xbd, 0xdd, 0xc5, 0xa5, 0xbe,
  0x0a, 0x04, 0x21, 0xbe, 0xab, 0x3c, 0x88, 0xbf, 0x2e, 0x1f, 0x50, 0xbe,
  0xc8, 0xb7, 0xe2, 0xbd, 0x71, 0xed, 0xd5, 0x3e, 0x0c, 0xf3, 0x00, 0xbd,
  0xae, 0x1e, 0x3e, 0x3d, 0x29, 0xf0, 0x91, 0xbd, 0x72, 0xf6, 0x19, 0xbe,
  0x29, 0xb6, 0x28, 0xbd, 0x24, 0xa2, 0x03, 0xbe, 0xe9, 0xcc, 0x83, 0xbd,
  0x4a, 0x72, 0x17, 0x3d, 0xf7, 0xe0, 0xbe, 0xbc, 0xd8, 0x7d, 0x59, 0xbd,
  0xa1, 0xc0, 0x05, 0x3c, 0xf0, 0xcd, 0x51, 0xbe, 0xfd, 0xb6, 0x15, 0xbd,
  0xa1, 0x24, 0x0a, 0x3d, 0x9e, 0x14, 0x22, 0xbd, 0xb7, 0x88, 0x1a, 0x3f,
  0x61, 0x5e, 0x35, 0x3e, 0x90, 0x8c, 0x7c, 0xbc, 0x0d, 0x7a, 0x71, 0xbf,
  0x35, 0x85, 0xb8, 0xbe, 0x38, 0x20, 0x11, 0xbf, 0x30, 0x01, 0x62, 0xbf,
  0xce, 0x28, 0x64, 0xbf, 0xab, 0x4d, 0x87, 0xbd, 0x97, 0xbd, 0xeb, 0xbd,
  0xbd, 0x54, 0x3f, 0x3e, 0x91, 0x0b, 0x9f, 0x3e, 0x6b, 0x12, 0x5b, 0xbe,
  0x31, 0xa1, 0xf4, 0xbe, 0x37, 0xc2, 0x85, 0xbe, 0x8a, 0x6a, 0x61, 0xbe,
  0x7c, 0xa0, 0x46, 0xbc, 0x6b, 0x1e, 0x16, 0xbe, 0x8d, 0x2c, 0xae, 0xbd,
  0xbb, 0x9b, 0x20, 0xbd, 0x96, 0x53, 0x8c, 0xbd, 0xb6, 0x3a, 0x93, 0xbd,
  0xf8, 0x58, 0xb1, 0xbd, 0x46, 0xf3, 0xdd, 0xbd, 0x5f, 0x9b, 0xa1, 0xbe,
  0x67, 0x80, 0xb8, 0x3d, 0x77, 0x4f, 0xd4, 0xbc, 0xc9, 0x54, 0xba, 0x3e,
  0x1c, 0x0e, 0x20, 0xbd, 0xf5, 0x0c, 0x5f, 0x3e, 0x76, 0xbf, 0xfb, 0xbd,
  0xfd, 0xe5, 0xcf, 0xbd, 0xe5, 0xa7, 0x8a, 0xbe, 0x3e, 0x47, 0x5a, 0xbd,
  0x27, 0x5e, 0xe8, 0x3c, 0x4d, 0x54, 0xfc, 0x3c, 0x0b, 0x66, 0x4e, 0x3d,
  0x4f, 0x28, 0x98, 0x3d, 0x15, 0x91, 0x87, 0xbd, 0x57, 0x09, 0x44, 0xbd,
  0x98, 0xb6, 0x34, 0xbe, 0xe5, 0x89, 0x9e, 0x3d, 0xdf, 0x9a, 0xe4, 0x3b,
  0xb6, 0x3c, 0x2c, 0x3e, 0x1f, 0xe0, 0x7a, 0x3d, 0xab, 0xa4, 0x1a, 0x3e,
  0xea, 0x68, 0xdd, 0xbd, 0x60, 0x6a, 0xed, 0xbd, 0xf5, 0x22, 0x37, 0xbe,
  0x93, 0x1c, 0x81, 0x3e, 0xda, 0xdd, 0x2f, 0x3e, 0xfd, 0x91, 0x0b, 0xbc,
  0x9a, 0xce, 0xfc, 0xbd, 0x3a, 0x51, 0xf7, 0x3d, 0xe5, 0x05, 0x96, 0x3e,
  0x96, 0x11, 0x9f, 0xbd, 0x69, 0x79, 0xca, 0xbd, 0x6b, 0x20, 0x0d, 0x3d,
  0x83, 0x7f, 0x35, 0x3d, 0xce, 0x14, 0x5e, 0x3a, 0x37, 0xce, 0x5e, 0xbd,
  0xc5, 0xf1, 0x35, 0x3e, 0xc4, 0x9b, 0xc4, 0xbd, 0x85, 0xbc, 0x4b, 0xbe,
  0x89, 0x78, 0x9a, 0xbd, 0xcc, 0x0f, 0x96, 0x3e, 0xda, 0xe4, 0xee, 0xbd,
  0x7d, 0x4b, 0x7a, 0xbd, 0xb9, 0xc3, 0x0e, 0x3e, 0x6c, 0x9a, 0xbb, 0xbd,
  0xd0, 0xa2, 0x11, 0xbf, 0x00, 0xe5, 0x7a, 0xbe, 0xae, 0x1b, 0xd3, 0xbd,
  0x82, 0x2f, 0x48, 0x3d, 0xb3, 0x89, 0x4e, 0xbe, 0xd8, 0x30, 0x26, 0xbd,
  0xff, 0xa7, 0x03, 0x3e, 0xff, 0x72, 0x80, 0xbe, 0xf2, 0xe6, 0x90, 0xbe,
  0x44, 0xf8, 0x94, 0x3d, 0x3b, 0xe8, 0x8d, 0xbd, 0x09, 0xc6, 0x94, 0xbe,
  0x78, 0xfe, 0x78, 0x3d, 0x1a, 0x39, 0x44, 0xbe, 0xc2, 0x92, 0xf8, 0x3b,
  0x76, 0x1f, 0x18, 0xbe, 0x4b, 0xfb, 0xbe, 0xbd, 0xdc, 0x05, 0x18, 0x3f,
  0x3f, 0x5a, 0x93, 0xbe, 0x8c, 0xec, 0x94, 0xbd, 0x80, 0x00, 0x7b, 0xbd,
  0x83, 0x0d, 0x01, 0xbe, 0x88, 0x9a, 0x86, 0x3d, 0xae, 0x82, 0x25, 0xbe,
  0xe0, 0xc3, 0xe3, 0xbd, 0x80, 0xd8, 0x1a, 0xbe, 0xb9, 0x65, 0x9c, 0xbe,
  0x31, 0xae, 0x3d, 0xbe, 0x02, 0xa7, 0xfb, 0xbd, 0x1c, 0xf6, 0x85, 0xbe,
  0xe7, 0xe5, 0x56, 0x3d, 0xc4, 0xc3, 0x4b, 0x3e, 0x61, 0xca, 0x8f, 0xbe,
  0x41, 0xca, 0x0d, 0xbe, 0x71, 0x61, 0x85, 0xbe, 0x23, 0xcf, 0x05, 0x3d,
  0xe9, 0x93, 0xc8, 0xbd, 0x8a, 0xc2, 0xda, 0xbe, 0xdb, 0xbd, 0x0c, 0x3d,
  0x48, 0x7f, 0x5a, 0xbf, 0x79, 0x35, 0xbb, 0xbe, 0xe7, 0x31, 0x20, 0xbe,
  0x81, 0x36, 0x84, 0x3e, 0x36, 0x72, 0x1e, 0xbe, 0xd1, 0x0b, 0x56, 0xbd,
  0x92, 0xc1, 0x06, 0x3c, 0xab, 0x4d, 0x91, 0xbd, 0xe1, 0x1c, 0x1f, 0xbd,
  0xf7, 0x66, 0x72, 0x3e, 0x34, 0xbf, 0x57, 0x3c, 0xb9, 0x6d, 0xf9, 0x3d,
  0xec, 0xb4, 0xfe, 0xbc, 0xc1, 0x36, 0x5d, 0x3d, 0xef, 0x44, 0x2b, 0x3d,
  0xe3, 0x49, 0x80, 0xbc, 0xa4, 0xe2, 0x60, 0xbd, 0x16, 0xb8, 0xa9, 0xbc,
  0x1d, 0x4e, 0xa5, 0xbd, 0xe4, 0x9f, 0x54, 0x3e, 0x0f, 0xe1, 0x25, 0xbd,
  0xbf, 0x92, 0xe2, 0x3d, 0xaa, 0x39, 0x38, 0x3d, 0xb7, 0x42, 0xe7, 0x3d,
  0x3d, 0x38, 0x4a, 0x3d, 0x73, 0xbc, 0x52, 0xbe, 0xed, 0xb3, 0x24, 0xbe,
  0xba, 0x9a, 0xdd, 0xbe, 0xed, 0xfc, 0xa6, 0x3d, 0xf1, 0xb5, 0x0a, 0x3e,
  0x0d, 0x25, 0x15, 0xbd, 0xc1, 0xce, 0xed, 0xbd, 0xd8, 0x5d, 0x5d, 0xbd,
  0x2d, 0x15, 0x52, 0xbe, 0xa9, 0x58, 0x4b, 0xbe, 0x1c, 0x97, 0x9f, 0x3e,
  0x4d, 0x40, 0xba, 0xbd, 0x41, 0xba, 0x8a, 0x3d, 0xb8, 0x8d, 0x34, 0xbe,
  0x04, 0x75, 0xc9, 0xbd, 0x5e, 0x58, 0x99, 0xbd, 0xe0, 0xed, 0x47, 0xbe,
  0x83, 0xf7, 0x93, 0xbc, 0x67, 0x34, 0x49, 0xbe, 0x10, 0xbc, 0x5e, 0xbe,
  0x3c, 0xa1, 0xa6, 0x3d, 0x7d, 0xaf, 0x82, 0xbd, 0xdf, 0xf9, 0x34, 0xbd,
  0x5c, 0x02, 0x82, 0xbd, 0xb7, 0x0d, 0x90, 0xbd, 0x64, 0x2e, 0xd4, 0xbd,
  0x82, 0xea, 0xb3, 0xbd, 0x0d, 0xdd, 0x89, 0xbd, 0xf2, 0x85, 0xa4, 0x39,
  0x03, 0x77, 0xd3, 0xbd, 0x43, 0x9a, 0xbf, 0xbd, 0xce, 0xa8, 0xa7, 0xbd,
  0xa9, 0x42, 0x38, 0xbd, 0xe0, 0x11, 0x7e, 0xbd, 0x11, 0x56, 0x33, 0x3e,
  0x06, 0x51, 0x0f, 0xbd, 0x1c, 0x88, 0xf8, 0xbc, 0xf1, 0x03, 0xb2, 0x3e,
  0xdb, 0x70, 0x38, 0x3d, 0x72, 0x68, 0x71, 0xbd, 0x24, 0x2f, 0x01, 0xbd,
  0x5e, 0xc0, 0x37, 0x3d, 0x0e, 0xc6, 0xae, 0x3e, 0x80, 0x25, 0x2a, 0x3e,
  0x17, 0xee, 0x35, 0xbe, 0x58, 0x77, 0x22, 0x3c, 0xb0, 0x2b, 0x71, 0x3d,
  0x5e, 0x6f, 0x07, 0x3e, 0x61, 0x0b, 0x16, 0xbd, 0x49, 0x56, 0x8b, 0x3d,
  0x40, 0x4d, 0x83, 0xbe, 0x03, 0x90, 0x24, 0x3e, 0x90, 0x49, 0x15, 0xbd,
  0x65, 0xa5, 0xd2, 0xbd, 0x1e, 0x47, 0x60, 0x3e, 0x4e, 0x30, 0xa2, 0xbd,
  0x5a, 0xc3, 0xe6, 0x3c, 0x13, 0xd6, 0x00, 0x3e, 0x4e, 0x66, 0x35, 0xbe,
  0x8f, 0xb9, 0xc1, 0xbd, 0xd1, 0x6f, 0x90, 0x3e, 0x15, 0x80, 0x38, 0xbe,
  0xa1, 0x60, 0x37, 0xbe, 0x6b, 0x42, 0x03, 0xbe, 0x1e, 0xf1, 0x11, 0xbd,
  0x15, 0xf1, 0x0d, 0xbd, 0x92, 0x64, 0x37, 0xbe, 0xba, 0x45, 0x42, 0xbc,
  0xa3, 0x48, 0x3a, 0x3e, 0x26, 0x58, 0x4a, 0xbe, 0xa8, 0x08, 0x9b, 0xbe,
  0x04, 0x3a, 0xf8, 0xbd, 0xa7, 0x3d, 0x2f, 0xbd, 0x9f, 0x78, 0xd9, 0xbd,
  0xc0, 0x6b, 0xac, 0x3d, 0x8c, 0x68, 0xd9, 0xbb, 0x33, 0x7b, 0xf5, 0xbd,
  0x61, 0xeb, 0xd6, 0xbd, 0xf5, 0x3d, 0xe8, 0xbd, 0x0d, 0x30, 0xdc, 0xbd,
  0x5e, 0xcf, 0x5e, 0xbc, 0x32, 0x0e, 0x2b, 0x3d, 0x46, 0xad, 0x2b, 0x3c,
  0x19, 0x91, 0x17, 0xbe, 0x31, 0x1c, 0x28, 0xbd, 0xfc, 0xe5, 0x40, 0xbc,
  0x76, 0xe8, 0x1e, 0xbe, 0x00, 0x7f, 0xe1, 0xbc, 0x8f, 0xc2, 0xa9, 0x3d,
  0xd1, 0x05, 0x16, 0xbc, 0x94, 0xf8, 0x0f, 0x3e, 0xec, 0x92, 0x05, 0xbe,
  0x5d, 0xc2, 0x7f, 0x3d, 0x39, 0xdb, 0x83, 0xbc, 0xef, 0x1e, 0x27, 0xbe,
  0x70, 0xa7, 0xed, 0x3d, 0xc8, 0x28, 0x87, 0x3d, 0x95, 0xd5, 0x17, 0xbc,
  0x34, 0xba, 0xba, 0x3d, 0x47, 0xdf, 0xe5, 0xbd, 0x99, 0xa7, 0x70, 0x3e,
  0x05, 0x82, 0x59, 0x3d, 0x3a, 0x54, 0x01, 0xbe, 0xbb, 0x90, 0xa4, 0x3e,
  0x8b, 0x70, 0x82, 0x3d, 0x85, 0xf1, 0x3a, 0x3c, 0x13, 0xd2, 0xb8, 0xbb,
  0xd4, 0x79, 0x67, 0xbd, 0xe7, 0x66, 0x04, 0xbf, 0x00, 0x2a, 0xd4, 0xbd,
  0xef, 0xb8, 0xe8, 0x3d, 0x34, 0xc7, 0x37, 0xbf, 0x28, 0x13, 0x82, 0xbd,
  0x18, 0x6f, 0x8c, 0xbd, 0x5e, 0x9b, 0x8c, 0x3d, 0x0d, 0x39, 0x3d, 0xba,
  0x1c, 0x41, 0x40, 0xbf, 0x0d, 0x81, 0xbf, 0xbc, 0xcc, 0x20, 0x88, 0xbd,
  0x9e, 0x17, 0x32, 0xbf, 0xf5, 0x2c, 0xbb, 0xbc, 0xdf, 0x7c, 0x88, 0x3e,
  0xbc, 0xfa, 0x77, 0x3d, 0x09, 0x39, 0x47, 0x3d, 0xc2, 0x01, 0x6e, 0xbf,
  0xa1, 0x93, 0x46, 0xbe, 0xf5, 0x92, 0x9f, 0xbc, 0xc0, 0x5e, 0x02, 0xbf,
  0x74, 0x33, 0xab, 0x3d, 0x0d, 0x66, 0x5d, 0x3d, 0x02, 0x39, 0xbc, 0xbc,
  0xbe, 0x1d, 0x2a, 0x3d, 0x6d, 0x7b, 0x55, 0xbf, 0x34, 0xff, 0x4b, 0xbe,
  0xba, 0x10, 0x22, 0x3e, 0xdb, 0x9f, 0xf8, 0xbe, 0x6d, 0x59, 0x64, 0x3e,
  0x6c, 0x3f, 0x62, 0x3d, 0x11, 0xf8, 0x83, 0xbb, 0xb8, 0xf2, 0xf2, 0xbd,
  0xe1, 0xe8, 0xb1, 0xbc, 0xa0, 0xec, 0xfb, 0x3c, 0x06, 0x18, 0xb9, 0xbb,
  0x57, 0xb4, 0xf2, 0x3d, 0xb9, 0xd2, 0x24, 0xbe, 0x8e, 0x77, 0x84, 0xbd,
  0x45, 0xf8, 0x60, 0x3d, 0x4a, 0x83, 0x90, 0x3e, 0xee, 0x8d, 0xab, 0x3d,
  0x53, 0x05, 0xfc, 0x3d, 0xf3, 0xe0, 0x07, 0x3d, 0x82, 0x2c, 0xec, 0x3d,
  0x4c, 0x82, 0x5a, 0xbd, 0x6b, 0x30, 0xa1, 0xbd, 0x27, 0x70, 0x39, 0x3e,
  0x7e, 0xb3, 0x05, 0xbd, 0xe3, 0x2f, 0xf0, 0x3d, 0xc0, 0xdb, 0x7e, 0xbf,
  0xaf, 0xb2, 0xec, 0x3c, 0x4d, 0xe6, 0x7f, 0xbf, 0x60, 0xb0, 0xb0, 0xbe,
  0xa0, 0x89, 0xe1, 0xbd, 0xde, 0xdf, 0x65, 0xbb, 0xdf, 0xe8, 0xd4, 0xbd,
  0x33, 0xb0, 0x07, 0xbd, 0x65, 0xfe, 0x8d, 0x3d, 0xfc, 0xa0, 0xe5, 0x3c,
  0x5d, 0x9e, 0xc6, 0xbf, 0x48, 0x58, 0x1d, 0xbf, 0xde, 0x0a, 0x1b, 0xbd,
  0x3e, 0x08, 0x84, 0xbd, 0x4e, 0x3c, 0x90, 0xbe, 0x7f, 0x92, 0x4b, 0x3d,
  0x97, 0x3a, 0xa6, 0x3e, 0x60, 0x7c, 0xd5, 0x3c, 0xf3, 0x8f, 0x0d, 0xbd,
  0xe4, 0x0b, 0x16, 0x3e, 0x8e, 0x51, 0x8d, 0x3e, 0xb4, 0xab, 0x8c, 0xbd,
  0x1c, 0x39, 0xb4, 0x3d, 0x3e, 0x15, 0x97, 0x3c, 0x40, 0x4e, 0x7d, 0xbd,
  0x1f, 0x14, 0x49, 0x3c, 0x7b, 0x76, 0x19, 0x3c, 0xf0, 0x8e, 0xe2, 0xbc,
  0xbf, 0x43, 0x2f, 0xbd, 0x50, 0x19, 0x40, 0xbe, 0x1d, 0x4b, 0x08, 0x3d,
  0x35, 0x31, 0xd6, 0x3b, 0xf5, 0x60, 0x73, 0xbe, 0xd1, 0x7e, 0x1e, 0x3d,
  0xdc, 0xcb, 0x01, 0xbd, 0xf4, 0x76, 0x43, 0xbe, 0xf4, 0xf1, 0xaa, 0xbd,
  0x1a, 0x7c, 0x61, 0xbe, 0x5c, 0xe5, 0xe3, 0x3c, 0xca, 0x20, 0x1b, 0xbd,
  0x70, 0x90, 0xba, 0xbe, 0x85, 0xce, 0x8e, 0xbc, 0x65, 0x12, 0x92, 0xbe,
  0x43, 0x76, 0x95, 0xbe, 0x8e, 0xb3, 0xe0, 0xbd, 0xce, 0xd7, 0x67, 0xbd,
  0xf4, 0x59, 0x75, 0x3d, 0x63, 0x60, 0x48, 0xbd, 0x9e, 0x67, 0xb1, 0xbd,
  0xdd, 0x99, 0x7b, 0xbd, 0x11, 0x04, 0x11, 0xbd, 0xcb, 0x62, 0x0a, 0xbd,
  0x0a, 0x96, 0x3d, 0x3d, 0x89, 0xed, 0xb5, 0xbc, 0x4a, 0x5a, 0x5c, 0x3e,
  0x4d, 0x75, 0x42, 0x3c, 0xe6, 0x3d, 0x95, 0xbd, 0x30, 0x6e, 0x76, 0xbc,
  0x46, 0x76, 0x9c, 0xbd, 0xc1, 0xde, 0x3f, 0xbc, 0x61, 0xde, 0x86, 0x3d,
  0xda, 0x7a, 0x42, 0xbd, 0x3c, 0x07, 0x40, 0xbb, 0xd2, 0xda, 0x6c, 0x3d,
  0xda, 0x02, 0x8a, 0xbd, 0x8b, 0x01, 0x9b, 0xbd, 0xad, 0x5f, 0x96, 0xbd,
  0xa9, 0xa1, 0x22, 0xbc, 0x86, 0x14, 0x8d, 0xbd, 0xe2, 0x5a, 0x2b, 0xbd,
  0xcf, 0x71, 0x1c, 0xbd, 0x6b, 0x79, 0xe8, 0x3b, 0xb1, 0x03, 0x0f, 0xbd,
  0xb2, 0xcf, 0xc0, 0x3e, 0x69, 0xbf, 0x93, 0xbd, 0x90, 0x93, 0xcb, 0xbb,
  0xb3, 0x02, 0x63, 0x3e, 0xcd, 0x01, 0xfd, 0xbc, 0xee, 0x45, 0x89, 0xbd,
  0xda, 0x2c, 0x3f, 0x3f, 0xe6, 0xf6, 0x50, 0xbe, 0x93, 0x38, 0xd9, 0xbd,
  0x07, 0x39, 0xe3, 0xbe, 0x25, 0xe0, 0x14, 0xbd, 0xab, 0xcf, 0x9a, 0x3d,
  0x8a, 0xc9, 0x22, 0xbe, 0x71, 0x67, 0x9a, 0xbe, 0x4b, 0x9b, 0x9a, 0xbd,
  0x65, 0xcf, 0x3c, 0xbe, 0x21, 0xef, 0xa7, 0xbe, 0xaf, 0x6e, 0x2c, 0xbe,
  0x00, 0xc9, 0x3e, 0x3e, 0xa1, 0xcf, 0xf3, 0xbc, 0x6a, 0xfe, 0xc4, 0xbc,
  0x9c, 0x98, 0xd9, 0xbd, 0xa8, 0xd5, 0x15, 0xbe, 0xef, 0x18, 0x0c, 0xbe,
  0xcb, 0x6c, 0x7d, 0xbe, 0x1e, 0xdc, 0xee, 0x3d, 0xba, 0x96, 0x90, 0x3b,
  0xa4, 0x11, 0xad, 0xbd, 0xac, 0x6f, 0x2a, 0x3e, 0x79, 0xbb, 0xeb, 0x3d,
  0x4f, 0xf4, 0xa5, 0xbe, 0xff, 0x82, 0xa1, 0xbd, 0x6f, 0x36, 0x0e, 0xbe,
  0xb8, 0xe2, 0xaf, 0x3d, 0xed, 0x05, 0x26, 0xbd, 0x51, 0x5e, 0x0a, 0xbe,
  0x48, 0xaa, 0x18, 0x3d, 0x37, 0x93, 0x10, 0x3e, 0xd7, 0x45, 0xbd, 0xbc,
  0x16, 0x89, 0xcf, 0x3d, 0xd3, 0x17, 0x44, 0x3e, 0xdf, 0x89, 0x6e, 0xbd,
  0xb1, 0xc1, 0x9e, 0xbe, 0x9f, 0x9c, 0x48, 0xbe, 0x4f, 0x84, 0x6b, 0xbd,
  0xae, 0xed, 0x1b, 0x3e, 0x48, 0xb3, 0xef, 0xbc, 0x33, 0xb1, 0x9a, 0x3d,
  0x00, 0xf4, 0xfe, 0x3a, 0x45, 0x6e, 0x93, 0xbe, 0xfa, 0xcd, 0x18, 0xbe,
  0x0c, 0x06, 0x8f, 0xbd, 0xb9, 0x78, 0xda, 0xbc, 0x3a, 0x7f, 0x61, 0xbe,
  0xf4, 0x3e, 0x85, 0x3e, 0x92, 0x54, 0xc6, 0xbc, 0x92, 0xa3, 0xb2, 0x3d,
  0xda, 0xd8, 0x3f, 0xbe, 0x8f, 0x01, 0x43, 0x3e, 0xf1, 0x63, 0x0a, 0xbc,
  0xeb, 0xa8, 0x11, 0xbd, 0x48, 0xbe, 0xf0, 0xbe, 0xb6, 0x72, 0x25, 0x3e,
  0xe3, 0x2b, 0xcb, 0xbd, 0x55, 0x0e, 0x49, 0xbd, 0xd3, 0x04, 0x9f, 0x3c,
  0xf0, 0x94, 0xfa, 0x3d, 0x9e, 0xf1, 0x4e, 0x3c, 0xe4, 0x06, 0x12, 0xbe,
  0x13, 0x9b, 0x0b, 0xbe, 0xe3, 0x59, 0x36, 0xbe, 0x0f, 0x2a, 0x0d, 0x3c,
  0x26, 0x58, 0xef, 0xbd, 0x44, 0xe0, 0x20, 0xbe, 0xcd, 0xd4, 0x1c, 0xbe,
  0x2b, 0x21, 0xa2, 0xbd, 0x90, 0x76, 0x01, 0x3e, 0x13, 0xac, 0xfe, 0x3d,
  0x70, 0xec, 0xb9, 0xbe, 0x44, 0xde, 0x71, 0x3e, 0x04, 0xdd, 0x56, 0x3c,
  0xe1, 0xb1, 0x1b, 0xbe, 0xf5, 0x9e, 0xf3, 0xbd, 0x4b, 0xe2, 0xa6, 0xbc,
  0xc4, 0x85, 0xdc, 0xbd, 0xe0, 0x04, 0x24, 0x3e, 0x19, 0x78, 0x6e, 0xbe,
  0x5a, 0x56, 0xc2, 0x3d, 0x05, 0x9e, 0x4a, 0xbd, 0x89, 0x0e, 0x60, 0xbe,
  0x76, 0xd1, 0x3a, 0xbd, 0x69, 0xda, 0x15, 0x3d, 0x77, 0x91, 0xb2, 0xbe,
  0xbc, 0x64, 0xe1, 0xbd, 0x41, 0x8e, 0x86, 0xbd, 0x95, 0xf4, 0xb0, 0x3d,
  0xca, 0x6b, 0xd2, 0x3e, 0x85, 0xd7, 0xe5, 0xbd, 0x5b, 0x41, 0xb9, 0x3b,
  0xf3, 0xe7, 0x5d, 0x3d, 0x88, 0x1b, 0xd4, 0xbe, 0x41, 0xf2, 0x44, 0xbc,
  0x1a, 0xc0, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
  0x74, 0xf0, 0x28, 0xc0, 0xa1, 0x7a, 0x83, 0x3c, 0xde, 0x1a, 0x9d, 0xc0,
  0x0a, 0x33, 0xac, 0xbf, 0x7e, 0x4e, 0xb6, 0xbe, 0x86, 0xa2, 0xe1, 0xbf,
  0x43, 0xc5, 0x21, 0xbf, 0xd3, 0xea, 0x4d, 0xbf, 0x46, 0xc0, 0xff, 0xff,
  0x04, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x51, 0x65, 0x08, 0xbe,
  0x6a, 0x72, 0x8d, 0xbe, 0x28, 0xac, 0x14, 0x3d, 0xbb, 0xe8, 0xab, 0xbc,
  0x08, 0xce, 0xe4, 0x3d, 0x97, 0x8a, 0x3f, 0x3d, 0xb9, 0xb3, 0x98, 0xbd,
  0xff, 0xb0, 0x91, 0xbe, 0x04, 0x0e, 0x86, 0x3c, 0xa3, 0xc9, 0xc5, 0xbd,
  0xe2, 0x83, 0x5e, 0xbc, 0x68, 0xd2, 0xfd, 0x3a, 0x90, 0x76, 0xa7, 0xbd,
  0x75, 0x80, 0xcc, 0xbd, 0x7d, 0xe2, 0xa4, 0xbc, 0x60, 0x60, 0xb7, 0x3d,
  0x87, 0x7d, 0xe6, 0xbd, 0x02, 0xed, 0xf7, 0xbe, 0x7f, 0xb1, 0xa5, 0x3b,
  0x72, 0x82, 0xfd, 0xbd, 0x3a, 0x88, 0x8f, 0x3e, 0x59, 0x93, 0x3e, 0x3d,
  0xc7, 0xa3, 0xf5, 0xbe, 0xfe, 0xdb, 0x79, 0xbe, 0x20, 0x7c, 0x2d, 0xbd,
  0xcb, 0x1e, 0x08, 0x3e, 0x08, 0x4e, 0x8c, 0xbe, 0x5f, 0x57, 0x0f, 0xbe,
  0xf7, 0xe0, 0x48, 0xbe, 0xd5, 0x16, 0xa7, 0xbe, 0x30, 0xea, 0x47, 0xbd,
  0x3e, 0xe5, 0x01, 0x3e, 0x28, 0xbb, 0x9a, 0xbe, 0xa4, 0x1a, 0xae, 0xbe,
  0x19, 0x07, 0x00, 0x3c, 0x6f, 0x9b, 0xe0, 0xbd, 0x27, 0xba, 0x71, 0x3e,
  0x86, 0xa0, 0xa7, 0x3c, 0x95, 0xca, 0xf8, 0xbc, 0x5b, 0xf5, 0xe0, 0xbe,
  0xfb, 0x51, 0x8c, 0xbb, 0x9e, 0x2f, 0x52, 0x3d, 0x11, 0x1d, 0x07, 0xbe,
  0xed, 0xea, 0x0e, 0xbf, 0x52, 0x0f, 0xa3, 0xbe, 0x16, 0xd8, 0xb0, 0xbe,
  0xba, 0xf0, 0x85, 0xbd, 0x60, 0xc0, 0x31, 0x3e, 0xce, 0x94, 0xb5, 0x3d,
  0xd9, 0x06, 0xc2, 0xbd, 0xdd, 0xd7, 0x67, 0x3c, 0x5c, 0x4b, 0x85, 0xbe,
  0x62, 0xc3, 0x0b, 0x3e, 0x8a, 0xb4, 0x84, 0xbc, 0xa7, 0x1c, 0xe3, 0xbd,
  0xc4, 0x5f, 0x1f, 0xbf, 0x5c, 0xf8, 0x2d, 0xbc, 0x71, 0xad, 0x53, 0x3d,
  0xab, 0xd8, 0x45, 0xbe, 0xb4, 0x7d, 0xee, 0xbe, 0x17, 0x02, 0x9b, 0xbe,
  0x71, 0x8b, 0x32, 0xbe, 0xca, 0x90, 0x82, 0xbe, 0xa6, 0xa0, 0x54, 0x3d,
  0xbc, 0xd1, 0x1e, 0x3b, 0xbb, 0xb7, 0x21, 0x3d, 0x63, 0x9b, 0x25, 0x3c,
  0x33, 0xf6, 0x80, 0xbe, 0xc0, 0x78, 0xd8, 0xbd, 0xd1, 0xe1, 0x85, 0x3d,
  0x79, 0xc6, 0x4a, 0xbe, 0xf2, 0x30, 0xa5, 0xbe, 0x4a, 0x82, 0x5f, 0xbc,
  0x6d, 0xed, 0x27, 0xbe, 0x73, 0x70, 0x5d, 0xbd, 0x6c, 0xc1, 0x8b, 0xbe,
  0x8b, 0x5b, 0xd0, 0xbe, 0xa7, 0x56, 0xc6, 0xbe, 0x8b, 0xe3, 0xcd, 0xbd,
  0x21, 0x4a, 0x0a, 0xbf, 0x1e, 0x33, 0xbf, 0xbd, 0x2c, 0x16, 0x8f, 0xbe,
  0x4f, 0xdf, 0x3e, 0x3c, 0x6c, 0x99, 0x6e, 0xbe, 0x2d, 0xa3, 0x23, 0xbf,
  0xe4, 0x4a, 0x7f, 0xbd, 0x8b, 0xb0, 0x47, 0x3d, 0xa3, 0x4b, 0x06, 0xbf,
  0xec, 0x51, 0x9d, 0x3d, 0x6f, 0xff, 0xad, 0xbe, 0x2b, 0x11, 0x6c, 0xbe,
  0xe1, 0x3b, 0xc7, 0xbe, 0x88, 0x1c, 0x8b, 0xbe, 0xb9, 0x83, 0xe6, 0xbd,
  0xd8, 0xb8, 0xf9, 0xbd, 0xf1, 0x65, 0x39, 0xbf, 0x6c, 0x6f, 0x4a, 0x3c,
  0xaa, 0x1c, 0x81, 0xbe, 0xc8, 0x75, 0x2f, 0xbc, 0x48, 0x70, 0xe6, 0xbc,
  0x85, 0x30, 0x25, 0xbe, 0x66, 0x16, 0x10, 0xbe, 0xda, 0x33, 0x2e, 0xbd,
  0x8e, 0xf8, 0xa7, 0x3c, 0x93, 0x7d, 0x3b, 0x3d, 0x9e, 0x08, 0xeb, 0xbe,
  0xfd, 0x39, 0x1b, 0x3e, 0xce, 0xd4, 0xbd, 0x3d, 0xca, 0x9a, 0x25, 0xbe,
  0x0f, 0x1b, 0x56, 0xbe, 0x78, 0x2b, 0x3e, 0xbd, 0xee, 0xcd, 0x5c, 0xbe,
  0xe1, 0xbf, 0x4a, 0x3e, 0x29, 0x66, 0xd6, 0x3d, 0xad, 0x7c, 0x7e, 0x3d,
  0xf4, 0x45, 0xe1, 0xbc, 0xf3, 0x16, 0x72, 0x3e, 0xa5, 0x39, 0x22, 0xbd,
  0x09, 0x13, 0x12, 0xbd, 0x0c, 0xa7, 0xa3, 0x3c, 0x77, 0x0c, 0xa0, 0x3d,
  0xfb, 0x86, 0x83, 0xbe, 0xf9, 0x02, 0x13, 0x3d, 0x14, 0xf6, 0x10, 0x3e,
  0x2c, 0xd6, 0x83, 0xbb, 0x67, 0xda, 0x29, 0x3d, 0x2b, 0x11, 0xb6, 0xbd,
  0x1c, 0xb6, 0x96, 0xbc, 0x1a, 0xba, 0x47, 0x3e, 0x86, 0x86, 0x49, 0x3e,
  0xc1, 0x7f, 0xc5, 0x3c, 0x1c, 0xec, 0xb3, 0x3c, 0x6f, 0xc9, 0xb2, 0x3d,
  0x7b, 0xfd, 0x7c, 0x3c, 0x5b, 0x57, 0x51, 0x3d, 0xd1, 0x90, 0xf2, 0x3d,
  0xe2, 0x1f, 0x8e, 0xbd, 0x94, 0x45, 0xe2, 0xbd, 0x4f, 0x30, 0x38, 0x3d,
  0x0e, 0xfb, 0x70, 0x3d, 0xcf, 0x37, 0x09, 0x3d, 0xbd, 0xed, 0xb4, 0xba,
  0x83, 0x49, 0x89, 0xbc, 0xf3, 0xc2, 0x36, 0xbd, 0xf6, 0x2e, 0x4b, 0x3d,
  0x55, 0x1b, 0x4f, 0x3d, 0x01, 0xa4, 0x08, 0xbe, 0x6b, 0x3b, 0x6d, 0x3c,
  0x3c, 0xc8, 0x2e, 0x3e, 0x7e, 0x71, 0xd9, 0xbd, 0x35, 0x82, 0xe3, 0x3c,
  0xea, 0xcd, 0x15, 0x3d, 0x7e, 0xda, 0x5d, 0xbe, 0xb3, 0x5e, 0x8f, 0x3c,
  0x19, 0x9b, 0x17, 0x3e, 0xf5, 0x9c, 0x17, 0x3e, 0x64, 0x8d, 0xd2, 0xbd,
  0xfe, 0x03, 0xd2, 0x38, 0x78, 0x67, 0x1e, 0xbd, 0x1e, 0x84, 0x49, 0xbe,
  0x01, 0x92, 0xf5, 0xbb, 0xa8, 0x84, 0x64, 0x3d, 0x12, 0x45, 0x94, 0x3c,
  0xbe, 0xa5, 0x2b, 0xbc, 0x95, 0xc6, 0x95, 0xbd, 0xde, 0xce, 0x66, 0xbd,
  0xbd, 0x15, 0x5e, 0xbd, 0xe1, 0x2d, 0xcb, 0xbe, 0x6b, 0x78, 0xdc, 0x3d,
  0xb2, 0xb9, 0xaf, 0x3c, 0xe9, 0x5b, 0xcd, 0x3d, 0xee, 0xdb, 0x7a, 0x3d,
  0x54, 0x07, 0x3b, 0x3d, 0xd6, 0xc4, 0x3d, 0xbe, 0x3a, 0x39, 0x0f, 0xbe,
  0x66, 0x97, 0xe3, 0xbd, 0xfc, 0x19, 0x9a, 0xbd, 0x6e, 0x94, 0x2c, 0xbe,
  0x86, 0x80, 0x05, 0x3e, 0x84, 0xc6, 0x3b, 0xbc, 0xae, 0xea, 0xc2, 0x3d,
  0x8c, 0xf1, 0xb5, 0x3d, 0x80, 0xe5, 0x5f, 0xbd, 0xe6, 0x67, 0xc1, 0x3d,
  0xad, 0x07, 0xb3, 0x3c, 0x64, 0xb5, 0xf6, 0x3d, 0x34, 0xdd, 0xb1, 0x3e,
  0xb2, 0xa3, 0xb6, 0xbc, 0x85, 0x88, 0x2c, 0x3e, 0x50, 0x4a, 0xc0, 0xbe,
  0xbb, 0x1d, 0xd1, 0xbd, 0x71, 0x41, 0xd4, 0x3b, 0x80, 0xf4, 0x8b, 0xbd,
  0x28, 0x87, 0x11, 0x3e, 0xee, 0x2e, 0xc6, 0xbe, 0xca, 0x0d, 0x0a, 0x3d,
  0xbd, 0x9e, 0x89, 0x3d, 0x74, 0x21, 0xaa, 0xbd, 0x31, 0x04, 0x29, 0x3d,
  0xc1, 0xec, 0x3b, 0x3d, 0xa0, 0xdd, 0xe5, 0xbd, 0x2f, 0x36, 0xd0, 0x3d,
  0xc2, 0xc1, 0xa6, 0x3e, 0x55, 0x83, 0xf1, 0x3c, 0x73, 0x10, 0x48, 0x3e,
  0x88, 0x5a, 0xc5, 0xbc, 0x58, 0x8f, 0x33, 0x3d, 0x7f, 0x90, 0xd2, 0xbd,
  0x48, 0xf8, 0x2e, 0x3e, 0x93, 0x63, 0xb2, 0xbe, 0xf3, 0x64, 0x9f, 0xbf,
  0x3d, 0x5d, 0x74, 0xbe, 0x04, 0xac, 0x96, 0x3e, 0xad, 0x8d, 0xfc, 0xbd,
  0x32, 0xe0, 0x65, 0xbe, 0x16, 0x66, 0x1d, 0x3d, 0x08, 0xf3, 0x62, 0x3c,
  0xe5, 0x22, 0x15, 0x3f, 0x19, 0xc3, 0x9a, 0xbe, 0xf4, 0xee, 0x70, 0x3d,
  0x38, 0xa6, 0x91, 0x3e, 0x07, 0xc3, 0xe3, 0xbd, 0x3c, 0x7d, 0x94, 0xbc,
  0xe6, 0x5b, 0x0f, 0x3d, 0xd8, 0x13, 0x29, 0x3e, 0xec, 0x5f, 0xbb, 0x3e,
  0xbc, 0x9f, 0x47, 0x3d, 0x65, 0xe7, 0x86, 0x3e, 0xec, 0xbe, 0x18, 0x3e,
  0x00, 0xcc, 0x65, 0x3d, 0x74, 0x25, 0xa0, 0x3e, 0xbe, 0x34, 0x83, 0x3e,
  0xb7, 0x29, 0xd4, 0x3b, 0x0f, 0xab, 0x83, 0x3b, 0x1d, 0xa0, 0xe0, 0x3e,
  0xe6, 0x98, 0x49, 0x3e, 0x99, 0xa2, 0xda, 0x3e, 0xa0, 0x91, 0x91, 0x3c,
  0xf3, 0xb5, 0x67, 0x3e, 0x2c, 0x0b, 0x10, 0x3e, 0xb8, 0x50, 0xc5, 0x3e,
  0xa3, 0xbc, 0xb4, 0x3e, 0xe7, 0xab, 0x8c, 0xbd, 0xc3, 0x42, 0x52, 0x3d,
  0x36, 0xc7, 0x96, 0x3e, 0x80, 0x65, 0x7d, 0x3e, 0x93, 0xb5, 0x61, 0xbe,
  0x58, 0x0f, 0xc0, 0x3d, 0xa3, 0x92, 0xba, 0x39, 0x8c, 0xa3, 0x9b, 0xbd,
  0x90, 0x35, 0xaa, 0x3e, 0x1a, 0xd9, 0x13, 0x3f, 0xa5, 0xac, 0x30, 0x3e,
  0x40, 0x80, 0x65, 0xbe, 0x9f, 0xaa, 0xe4, 0x3d, 0x8d, 0x20, 0x2e, 0x3c,
  0x2b, 0x0a, 0xb6, 0xbd, 0xed, 0x8b, 0x68, 0x3e, 0x5d, 0x45, 0x3a, 0xbc,
  0xee, 0xda, 0x64, 0x3e, 0x35, 0x0f, 0xa7, 0x3d, 0x3e, 0x00, 0x5d, 0x3e,
  0x4a, 0xcb, 0x91, 0xbd, 0x58, 0x88, 0x0c, 0xbe, 0xbd, 0x7d, 0xd7, 0xbb,
  0x11, 0x70, 0xe2, 0xbd, 0x1e, 0x32, 0xc9, 0x3a, 0x1c, 0xa7, 0x6c, 0xbe,
  0x7e, 0x60, 0xec, 0x3d, 0x8d, 0xc8, 0xa2, 0xbe, 0x20, 0x9b, 0x04, 0x3e,
  0x51, 0xff, 0x84, 0xbe, 0xe6, 0x13, 0x96, 0x3c, 0x82, 0x00, 0x82, 0xbd,
  0x5e, 0x93, 0x60, 0x3c, 0x7f, 0xa2, 0xe0, 0x3c, 0xee, 0x3e, 0x00, 0xbe,
  0xbe, 0xd5, 0x85, 0x3e, 0xf6, 0xd6, 0xcb, 0x3d, 0x6d, 0x2f, 0x21, 0xbe,
  0x31, 0x8c, 0x07, 0x3d, 0xa3, 0x68, 0x89, 0x3b, 0x01, 0x37, 0x1c, 0xbe,
  0x34, 0x87, 0x98, 0xbd, 0xff, 0xae, 0x46, 0x3d, 0xf4, 0xc5, 0x91, 0xbe,
  0xd0, 0xc9, 0x39, 0xbd, 0x2e, 0xa1, 0x8d, 0xbe, 0x3d, 0x09, 0x8a, 0xbe,
  0x0d, 0x34, 0xc2, 0x3d, 0x59, 0x37, 0x83, 0x3c, 0xa2, 0x3d, 0x2f, 0x3e,
  0x0a, 0x47, 0x22, 0xbe, 0x5f, 0xa9, 0x21, 0x3d, 0xa8, 0x57, 0xe9, 0xbb,
  0x48, 0xf6, 0xe6, 0xbd, 0x1a, 0xa2, 0x79, 0x3c, 0xfc, 0x3a, 0x25, 0xbe,
  0xff, 0x7c, 0x29, 0x3d, 0x3a, 0xe3, 0x14, 0xbc, 0xf2, 0xa1, 0xeb, 0x3b,
  0xfa, 0xa1, 0x2f, 0xbe, 0xc3, 0xd9, 0x58, 0x3d, 0x17, 0x7b, 0xae, 0xbe,
  0xb6, 0xb7, 0x88, 0xbe, 0x83, 0xc0, 0xdc, 0xbd, 0x4e, 0xe1, 0x26, 0xbb,
  0x9b, 0x14, 0x5f, 0x3d, 0x03, 0x83, 0x6c, 0x3d, 0x2c, 0xac, 0x73, 0x3e,
  0x97, 0x00, 0x20, 0xbe, 0x84, 0x57, 0x09, 0xbe, 0x7c, 0x88, 0xec, 0x3d,
  0x92, 0xfa, 0x8a, 0x3d, 0xa4, 0xb5, 0x1d, 0xbd, 0x42, 0x73, 0xe6, 0xbc,
  0x7a, 0x13, 0x93, 0x3d, 0xaf, 0x27, 0x8b, 0xbe, 0x55, 0x63, 0xa9, 0xbc,
  0x87, 0x88, 0x6b, 0xbe, 0xea, 0x54, 0x79, 0xbe, 0x76, 0x8b, 0x2e, 0x3d,
  0x5e, 0x9c, 0x5f, 0x3a, 0xb7, 0x02, 0xfe, 0x3d, 0xdc, 0xc1, 0xf6, 0xbc,
  0xf8, 0x19, 0x3d, 0x3e, 0x14, 0x2b, 0x15, 0xbe, 0x04, 0x85, 0x47, 0xbe,
  0xbb, 0xd1, 0x24, 0xbd, 0x2e, 0x79, 0x94, 0x3d, 0xb1, 0xd1, 0x10, 0xbe,
  0xac, 0x70, 0x64, 0xbd, 0x7f, 0xa3, 0x7a, 0x3c, 0xf9, 0xd9, 0x2a, 0xbe,
  0x36, 0x5a, 0x9d, 0x3d, 0xb0, 0xeb, 0x1b, 0xbd, 0x55, 0xe9, 0x56, 0xbe,
  0x0b, 0x05, 0x22, 0xbe, 0xa1, 0xc7, 0x9e, 0xbd, 0x62, 0xaa, 0x0a, 0x39,
  0x77, 0x8f, 0x86, 0xbe, 0xe4, 0x24, 0xe2, 0x3d, 0x67, 0xb9, 0xa0, 0xbd,
  0xa2, 0xed, 0xdb, 0xbd, 0xd9, 0xde, 0x2a, 0x3d, 0xbb, 0x01, 0x9d, 0xba,
  0x9b, 0xff, 0x10, 0x3d, 0xfb, 0xe6, 0xd3, 0x3c, 0xfc, 0x63, 0x2a, 0x3d,
  0x44, 0x96, 0x1c, 0xbe, 0xbf, 0xdd, 0xb5, 0xbc, 0x7d, 0xca, 0x78, 0xbe,
  0x34, 0x8b, 0x36, 0xbe, 0x93, 0xd1, 0x98, 0xbc, 0x79, 0xd8, 0xd6, 0x3b,
  0x9c, 0xe9, 0x84, 0x3d, 0x76, 0xd6, 0x79, 0xbd, 0x52, 0x53, 0x3a, 0xbd,
  0xdf, 0x15, 0x18, 0xbd, 0x31, 0x0e, 0x2a, 0xbe, 0xc4, 0xac, 0x19, 0x3d,
  0xc7, 0x94, 0xa9, 0x3d, 0x2d, 0x01, 0x68, 0xbc, 0x05, 0x38, 0xbb, 0xbd,
  0xd4, 0xe5, 0x4a, 0x3d, 0x82, 0x7e, 0x29, 0xbe, 0xb7, 0x4a, 0x0b, 0xbd,
  0xae, 0x9a, 0x54, 0xbd, 0x0b, 0xf3, 0x7f, 0xbe, 0xfa, 0x90, 0x42, 0xbe,
  0x89, 0x13, 0x09, 0xbe, 0x3c, 0x22, 0x41, 0x3d, 0x44, 0xa9, 0x86, 0xbe,
  0x60, 0x6e, 0xda, 0x3d, 0x51, 0x3e, 0x1a, 0xbe, 0x88, 0x8f, 0x22, 0xbe,
  0xc7, 0xbb, 0x4f, 0x3d, 0x20, 0xcf, 0x21, 0x3e, 0xc0, 0xfc, 0xdc, 0xbd,
  0x5a, 0xe0, 0x13, 0xbe, 0x9f, 0xe7, 0x68, 0xbd, 0x67, 0x67, 0xa9, 0xbd,
  0xe3, 0x54, 0x63, 0x3d, 0x2c, 0x90, 0x0e, 0xbe, 0x0e, 0xcf, 0x02, 0x3c,
  0x6a, 0xf8, 0xf9, 0x3c, 0xff, 0x14, 0x6e, 0xbd, 0x73, 0x5b, 0x26, 0x3d,
  0x1b, 0x87, 0xea, 0xbd, 0x78, 0x86, 0xb2, 0x3c, 0x55, 0x66, 0x06, 0xbe,
  0x07, 0x7e, 0x10, 0xbe, 0x26, 0xf7, 0x7f, 0x3d, 0xcf, 0x1d, 0xfa, 0x3d,
  0xb3, 0x3b, 0x40, 0xbe, 0x8c, 0x81, 0x3e, 0x3c, 0xfb, 0xa5, 0x06, 0xbe,
  0xf0, 0x50, 0x78, 0xbd, 0xc1, 0x2e, 0x07, 0xbd, 0x70, 0x17, 0xb4, 0xbe,
  0x21, 0xcf, 0xb5, 0xbd, 0x29, 0x3e, 0xd2, 0xbc, 0x54, 0x68, 0x32, 0xbe,
  0x53, 0xb0, 0xbf, 0x3d, 0x5a, 0x5b, 0xba, 0x3d, 0x65, 0x81, 0xb1, 0xbd,
  0xc5, 0xb8, 0x2a, 0xbe, 0x4e, 0x76, 0x65, 0xbe, 0x0d, 0x31, 0x17, 0xbc,
  0x94, 0x64, 0x0b, 0x3e, 0xb2, 0x11, 0x37, 0xbe, 0x9b, 0xaa, 0xe0, 0xbc,
  0xed, 0x6e, 0x2c, 0xbc, 0xf1, 0x73, 0x49, 0xbe, 0xff, 0x4c, 0x7d, 0xbc,
  0x5c, 0xc4, 0xc3, 0xbd, 0xb5, 0x85, 0x01, 0xbe, 0xfa, 0x7d, 0xa8, 0xbd,
  0x46, 0xf8, 0xfd, 0xbd, 0x48, 0x17, 0x7e, 0xbc, 0x7c, 0xf9, 0x74, 0xbe,
  0xe9, 0x26, 0x02, 0xbc, 0x48, 0x50, 0x4b, 0xbd, 0xb3, 0x26, 0x63, 0xbe,
  0x28, 0x92, 0xa2, 0x3d, 0xef, 0xa5, 0x8b, 0x3d, 0x48, 0xae, 0x0f, 0xbe,
  0x59, 0xb5, 0x78, 0x3d, 0x50, 0xdc, 0xb1, 0x3d, 0x16, 0xc1, 0x3f, 0xbe,
  0x5d, 0x98, 0x9d, 0xbc, 0xd3, 0x51, 0x04, 0x3e, 0x6e, 0xa4, 0x74, 0x3b,
  0xe0, 0x11, 0xa8, 0x3e, 0xf7, 0xf2, 0x7b, 0xbd, 0xba, 0xb4, 0xfe, 0x3c,
  0x1f, 0xd5, 0x49, 0xbc, 0x9d, 0x07, 0x66, 0x3e, 0x5c, 0x6e, 0xc3, 0xbb,
  0x9c, 0x2d, 0x30, 0x3e, 0x3b, 0xb0, 0x96, 0x3d, 0x31, 0xf1, 0x22, 0xbe,
  0x8a, 0x02, 0x8b, 0x3e, 0x18, 0x91, 0x2c, 0x3d, 0x33, 0xe5, 0x18, 0x3e,
  0x71, 0x2f, 0x04, 0xbd, 0xcc, 0xd1, 0x23, 0x3f, 0x5b, 0x92, 0x16, 0x3e,
  0xb4, 0xae, 0x49, 0xbd, 0xf1, 0x8d, 0x0a, 0x3e, 0x9e, 0x4b, 0x74, 0x3a,
  0xa3, 0x6c, 0x53, 0x3d, 0xaf, 0x2e, 0x85, 0x3d, 0x57, 0x77, 0x62, 0x3d,
  0x70, 0x7b, 0xe9, 0xbd, 0x5c, 0x0c, 0x2b, 0xbd, 0xf4, 0x6e, 0x2a, 0xbc,
  0x57, 0xae, 0x03, 0xbe, 0x05, 0x7c, 0x6c, 0x3d, 0x02, 0x47, 0x86, 0x3c,
  0x5c, 0xe2, 0x02, 0xbc, 0x20, 0xf5, 0x3e, 0x3e, 0xf8, 0xb1, 0x92, 0x3d,
  0x3b, 0xa0, 0x86, 0xbc, 0x63, 0x6d, 0xa0, 0xbe, 0x35, 0x09, 0x42, 0x3e,
  0x8a, 0xe9, 0x90, 0xbc, 0x72, 0xd0, 0xe5, 0xbd, 0x4f, 0x52, 0x77, 0x3e,
  0x12, 0xab, 0xe1, 0xbd, 0x81, 0x2a, 0xd3, 0xbe, 0x38, 0x6b, 0x80, 0xbe,
  0xa1, 0xfa, 0x31, 0x3d, 0xd6, 0x96, 0x8b, 0xbd, 0xa3, 0x3c, 0x4d, 0xbe,
  0x3e, 0x26, 0x6b, 0x3c, 0x6a, 0x87, 0xd6, 0xbd, 0x88, 0x4a, 0xc1, 0xbb,
  0xd1, 0x25, 0xc2, 0x3c, 0xbe, 0x9e, 0x89, 0x3e, 0x4c, 0x00, 0xc6, 0xbe,
  0x80, 0x9e, 0x5b, 0xbd, 0x7f, 0x49, 0xc8, 0x3c, 0x9f, 0x06, 0x72, 0x3d,
  0xb7, 0x0d, 0x50, 0x3e, 0x3a, 0xe6, 0x43, 0xbd, 0x9a, 0x90, 0xbe, 0xbe,
  0xc6, 0x7a, 0x62, 0xbe, 0x97, 0x43, 0x47, 0xbd, 0x30, 0x6f, 0x86, 0xbc,
  0x72, 0x60, 0xb2, 0xbe, 0x21, 0x82, 0x95, 0xbe, 0xa8, 0xf2, 0x2f, 0xbe,
  0xa9, 0xb6, 0xb3, 0xbe, 0x92, 0xea, 0x9e, 0xbc, 0xd4, 0x68, 0x5f, 0x3d,
  0x16, 0xc7, 0xc6, 0xbe, 0x5b, 0xcc, 0x67, 0xbe, 0xf1, 0x96, 0xb3, 0x3c,
  0xbd, 0xd6, 0xad, 0xbc, 0x80, 0x17, 0x03, 0x3c, 0x07, 0x4c, 0x12, 0xbe,
  0xb7, 0x36, 0x26, 0xbf, 0xd1, 0x8a, 0xaf, 0xbe, 0x99, 0x6e, 0xab, 0xbc,
  0xe2, 0x91, 0x2e, 0x3d, 0xf2, 0x40, 0xa3, 0xbe, 0x42, 0x3e, 0xb7, 0xbe,
  0x33, 0xdf, 0xe4, 0xbd, 0xaa, 0xf5, 0x7b, 0xbe, 0x84, 0x23, 0xc7, 0x3a,
  0xe8, 0xfb, 0x64, 0x3c, 0x9b, 0xd5, 0xbc, 0x3c, 0x80, 0xed, 0x08, 0xbd,
  0x05, 0x00, 0x80, 0x3d, 0x9d, 0x1e, 0x2d, 0xbe, 0x5c, 0x74, 0x3e, 0x3e,
  0x0a, 0x27, 0x01, 0x3e, 0xc4, 0x8e, 0xe9, 0x3c, 0x55, 0xa2, 0x6c, 0x3d,
  0x97, 0x63, 0xb4, 0xbd, 0x7a, 0x18, 0xa9, 0xbd, 0x6b, 0xf8, 0x71, 0xbe,
  0xf5, 0x36, 0x21, 0xbf, 0xaf, 0x92, 0xa8, 0xbd, 0xea, 0xc5, 0x03, 0xbf,
  0xad, 0xec, 0x0d, 0xbd, 0x2d, 0xdb, 0xad, 0xbd, 0x98, 0x78, 0x34, 0xbe,
  0x92, 0x4f, 0xe5, 0x3e, 0x19, 0xb8, 0x59, 0xbb, 0x7a, 0x81, 0x67, 0xbe,
  0xd4, 0x5d, 0xc4, 0xbd, 0x08, 0x38, 0xdd, 0x3c, 0x38, 0xc2, 0x05, 0x3d,
  0x2d, 0x51, 0xbc, 0xbd, 0x7c, 0x64, 0xaf, 0xbc, 0x66, 0xf0, 0x6d, 0xbe,
  0x9f, 0x6b, 0x4b, 0x3d, 0xb9, 0xa3, 0x36, 0xbf, 0xb5, 0x35, 0x14, 0xbd,
  0x9b, 0x8f, 0xd5, 0xbe, 0xff, 0x9a, 0x11, 0x3d, 0x29, 0x0c, 0x97, 0xbc,
  0x5a, 0xc6, 0xb8, 0xbe, 0x7e, 0xab, 0xa5, 0xbe, 0x29, 0x5c, 0x9c, 0x3d,
  0xf5, 0x1d, 0xba, 0xbe, 0xbf, 0x29, 0x47, 0xbd, 0xa8, 0x68, 0xc7, 0xbd,
  0x5d, 0xa8, 0xb8, 0xbd, 0x2c, 0x5c, 0x3f, 0xbe, 0x19, 0xe4, 0x10, 0xbe,
  0x6a, 0xdd, 0x1e, 0xbe, 0x7f, 0xd5, 0x76, 0xbd, 0xa9, 0xfe, 0x16, 0xbf,
  0x87, 0x10, 0xad, 0xbc, 0x26, 0x05, 0x16, 0xbe, 0x34, 0xd5, 0x77, 0xbe,
  0x77, 0x94, 0xfb, 0x3d, 0xe4, 0x9d, 0x3b, 0x3d, 0x59, 0xa7, 0x9c, 0xbd,
  0x94, 0x91, 0x03, 0xbb, 0xd8, 0x57, 0xef, 0xbe, 0x1b, 0x23, 0xa0, 0x3d,
  0xb6, 0x7f, 0x69, 0xbd, 0xdb, 0x6f, 0xa0, 0xbc, 0x88, 0x2c, 0x77, 0xbd,
  0x0e, 0xb5, 0x4b, 0xbe, 0xa3, 0x71, 0xde, 0x3c, 0xe0, 0x46, 0x20, 0xbe,
  0xfd, 0xe2, 0x85, 0xbe, 0x1a, 0xe2, 0x8f, 0x3d, 0xd4, 0x21, 0x0b, 0xbf,
  0x61, 0x74, 0xc6, 0xbc, 0xdb, 0x3c, 0x9c, 0x3d, 0x13, 0xbe, 0x39, 0xbe,
  0x2b, 0x19, 0x4f, 0x3d, 0x65, 0x4b, 0x59, 0xbd, 0x0d, 0xa4, 0x47, 0xbe,
  0x3e, 0xad, 0x8e, 0x3e, 0xce, 0x5f, 0xe8, 0xbd, 0xf4, 0x82, 0xe7, 0xbd,
  0xec, 0x7b, 0xba, 0x3d, 0x16, 0x94, 0x9c, 0xbe, 0x45, 0x7a, 0x48, 0x3c,
  0x17, 0xd6, 0xad, 0xbe, 0x04, 0x6b, 0x14, 0x3e, 0xe6, 0x9c, 0x0a, 0x3e,
  0xea, 0xfe, 0x99, 0xbe, 0x4c, 0xe4, 0x3c, 0xbd, 0xfd, 0x98, 0x2e, 0x3e,
  0x31, 0xf3, 0x5b, 0x3e, 0x6c, 0xce, 0x5f, 0x3e, 0xd4, 0x35, 0xe9, 0xbb,
  0xb3, 0x51, 0x80, 0xbe, 0x9f, 0xde, 0x84, 0x3e, 0x5d, 0xaf, 0xd8, 0xba,
  0xbf, 0x58, 0x32, 0x3d, 0x96, 0xb7, 0x34, 0x3d, 0x75, 0x1d, 0x7b, 0xbe,
  0xd4, 0x3d, 0xd0, 0xbd, 0x51, 0xf9, 0xa0, 0xbd, 0x95, 0x7a, 0x31, 0x3d,
  0xba, 0x85, 0xb5, 0x3c, 0x5e, 0xe0, 0x39, 0xbe, 0x7d, 0xbc, 0xde, 0xbd,
  0xfc, 0x54, 0x57, 0x3d, 0x21, 0x22, 0x54, 0x3e, 0xf0, 0xab, 0x14, 0x3e,
  0x22, 0x50, 0xfd, 0xbd, 0x80, 0x95, 0x1d, 0xbe, 0x2b, 0x71, 0xb6, 0x3e,
  0x88, 0x87, 0x78, 0x3d, 0x75, 0xd9, 0xdc, 0x3d, 0xa8, 0x06, 0x33, 0x3d,
  0x08, 0xe0, 0xb9, 0xbd, 0x63, 0x1e, 0xfb, 0xbd, 0x0e, 0x1f, 0x99, 0x3c,
  0xa5, 0x91, 0xac, 0x3d, 0xd3, 0xf7, 0x65, 0x3d, 0xa4, 0x97, 0x6a, 0xbc,
  0xda, 0x99, 0xa2, 0xbd, 0x54, 0x1b, 0x43, 0x3d, 0xc9, 0xed, 0x1d, 0x3e,
  0x9f, 0x4e, 0x79, 0x3e, 0x06, 0x3b, 0x2e, 0x3c, 0x76, 0x00, 0x59, 0xbe,
  0x5b, 0x29, 0x66, 0x3e, 0xd2, 0xad, 0x86, 0xbb, 0xf1, 0x9c, 0xc3, 0x3d,
  0x39, 0x62, 0xe7, 0x3d, 0x48, 0x95, 0x14, 0x3e, 0x66, 0x7b, 0xb8, 0xbc,
  0x9e, 0xdb, 0x27, 0x3c, 0x08, 0xf3, 0x14, 0x3e, 0xcc, 0x20, 0x32, 0xbd,
  0x5b, 0xa5, 0x4b, 0xbc, 0xd1, 0xa4, 0x6c, 0xbd, 0x06, 0xee, 0x8d, 0x3d,
  0xde, 0x1a, 0x02, 0x3e, 0x48, 0x84, 0x05, 0x3e, 0x9f, 0xa2, 0x22, 0x3d,
  0xb4, 0xe8, 0x97, 0xbe, 0x9f, 0xae, 0x10, 0x3e, 0x40, 0x00, 0x44, 0x3d,
  0x15, 0xf7, 0x21, 0x3e, 0x63, 0x06, 0x8e, 0x3c, 0x19, 0x86, 0xca, 0x3d,
  0xbb, 0xa3, 0xa0, 0x3d, 0x66, 0x6f, 0x1b, 0x3e, 0xec, 0xb3, 0x1e, 0x3d,
  0x3e, 0x2f, 0x5a, 0xbc, 0x3b, 0x15, 0x01, 0xbe, 0x5a, 0x6c, 0x01, 0xbe,
  0xf2, 0xa8, 0x8b, 0xbe, 0xca, 0x27, 0x99, 0x3b, 0xf9, 0x1b, 0xf8, 0xba,
  0xd2, 0x64, 0x34, 0x3d, 0x22, 0xee, 0x28, 0xbd, 0x8c, 0xda, 0x16, 0xbe,
  0xca, 0xc6, 0x3e, 0xb9, 0x51, 0xc4, 0x88, 0x3e, 0xbc, 0x01, 0x08, 0x3e,
  0x89, 0xe1, 0x82, 0x3e, 0x02, 0x9a, 0x86, 0xbe, 0x72, 0x13, 0x0f, 0x3c,
  0xcb, 0x5d, 0x7d, 0xbc, 0xea, 0xe3, 0x89, 0xbd, 0xd7, 0xc3, 0x07, 0xbe,
  0x1a, 0xca, 0x47, 0xbd, 0x45, 0xab, 0x62, 0xbd, 0xce, 0x31, 0x2d, 0xbd,
  0x96, 0x59, 0xa4, 0x3d, 0xb1, 0xa1, 0x9a, 0x3b, 0x28, 0xf7, 0x8a, 0xbb,
  0xe3, 0xfe, 0xb6, 0x3c, 0x55, 0x09, 0x39, 0xbe, 0x58, 0xd0, 0xed, 0xbd,
  0xb7, 0x81, 0xc2, 0xbd, 0x7d, 0xa9, 0x20, 0xbe, 0x6a, 0xd7, 0x05, 0xbd,
  0x2c, 0x2e, 0x68, 0x3d, 0x1d, 0xba, 0x88, 0xbc, 0x19, 0x87, 0x4f, 0x3c,
  0x2b, 0xa2, 0x33, 0xbb, 0x32, 0x17, 0x00, 0xbe, 0x08, 0x41, 0xd8, 0x3c,
  0x80, 0x2c, 0x8d, 0x3d, 0xc9, 0x58, 0xcc, 0xbd, 0x33, 0x97, 0x0c, 0xbe,
  0xf5, 0x8b, 0x44, 0xbe, 0x45, 0xd4, 0x30, 0x3d, 0xe8, 0x83, 0xd0, 0x3c,
  0xf2, 0x86, 0x4b, 0x3d, 0xf3, 0xdb, 0x2d, 0x3c, 0x30, 0x12, 0xcc, 0xbc,
  0x30, 0x19, 0xaf, 0xbd, 0x17, 0xe9, 0xb9, 0x3d, 0xb7, 0x7c, 0xa8, 0x3d,
  0x5c, 0xb3, 0x76, 0xbd, 0x6a, 0xd0, 0xe2, 0xbd, 0x91, 0xb5, 0x08, 0xbd,
  0xe4, 0xcf, 0xee, 0xbd, 0xb0, 0x0a, 0xe5, 0xbd, 0x83, 0x2a, 0xd8, 0xbd,
  0x6e, 0x37, 0x59, 0xbe, 0x1c, 0xdf, 0x5e, 0xbd, 0x4f, 0xf7, 0x98, 0x3d,
  0xc3, 0x62, 0x42, 0x3a, 0x8c, 0x59, 0x06, 0xbe, 0xa0, 0x77, 0xd7, 0x3d,
  0x8a, 0x88, 0xb9, 0xbd, 0xa2, 0x69, 0xd4, 0x3d, 0xa4, 0x20, 0x9c, 0x3b,
  0x71, 0x43, 0xa1, 0xbd, 0x7a, 0xbf, 0x35, 0xbe, 0x97, 0xa2, 0x1f, 0x3d,
  0x47, 0x87, 0x25, 0xbc, 0x95, 0xd7, 0xa1, 0xbc, 0x7b, 0x9b, 0xd9, 0x3d,
  0xac, 0x3f, 0xd9, 0xbd, 0xcf, 0xe2, 0x90, 0x3d, 0x3b, 0x94, 0x3b, 0xbe,
  0x0f, 0x98, 0x24, 0xbe, 0x9e, 0x99, 0xb9, 0xbd, 0x97, 0xcf, 0xe6, 0x3d,
  0x22, 0x7a, 0xc6, 0x3d, 0x00, 0x6a, 0x36, 0xbe, 0x97, 0xdf, 0x90, 0xbc,
  0x8d, 0x8b, 0xc2, 0xbd, 0xef, 0x38, 0x21, 0xbe, 0x68, 0xc1, 0xc3, 0xbc,
  0x37, 0xc3, 0x1a, 0xbe, 0x07, 0x71, 0x85, 0xbd, 0xef, 0xae, 0x0b, 0xbe,
  0xda, 0xcc, 0x09, 0xbd, 0xe4, 0x36, 0x0c, 0xbd, 0xa8, 0x2e, 0x09, 0xbd,
  0xe4, 0x1a, 0x96, 0x3d, 0x7b, 0x8f, 0xf6, 0x3d, 0x69, 0xba, 0x83, 0xbd,
  0xbc, 0xb5, 0x90, 0x3d, 0xfd, 0x5b, 0x29, 0xbd, 0xac, 0xc7, 0x3d, 0x3c,
  0xa5, 0x08, 0x05, 0x3e, 0x55, 0x17, 0x95, 0x3d, 0x11, 0xf5, 0x08, 0xbd,
  0x52, 0xe8, 0x1f, 0xbe, 0xfb, 0x88, 0x18, 0xbd, 0x08, 0x10, 0x97, 0xbd,
  0x07, 0x59, 0x59, 0xbd, 0x12, 0xef, 0x0c, 0xbe, 0xb4, 0x09, 0x81, 0xbd,
  0xa8, 0xf3, 0x8e, 0xbd, 0x74, 0xc9, 0x8d, 0xbc, 0x28, 0x2f, 0x8b, 0x3d,
  0x24, 0xd0, 0x44, 0xbe, 0x29, 0x65, 0x37, 0xbe, 0x73, 0x3a, 0xc4, 0xbd,
  0x6c, 0xda, 0x05, 0xbe, 0x06, 0x3a, 0x40, 0x3c, 0xc7, 0x1e, 0x6b, 0x3d,
  0x1e, 0xc2, 0x55, 0x3d, 0xc3, 0x25, 0x36, 0xbe, 0x5f, 0x0f, 0x89, 0x3c,
  0xb9, 0x13, 0x40, 0xbe, 0x3e, 0x1c, 0x0e, 0xbd, 0x4d, 0x50, 0xbf, 0x3d,
  0xc2, 0x97, 0xa0, 0xbd, 0x35, 0x36, 0x37, 0xbe, 0xc5, 0x4a, 0x88, 0xbd,
  0xe9, 0x8c, 0x35, 0xbd, 0x1c, 0xb0, 0xa1, 0xbd, 0x94, 0x23, 0xc0, 0xbd,
  0x5c, 0xc9, 0xba, 0x3d, 0x11, 0x1e, 0x99, 0xbd, 0x9f, 0x76, 0x19, 0xbe,
  0xe7, 0xfe, 0x45, 0xbd, 0x25, 0x75, 0x55, 0xbd, 0x99, 0xd5, 0x04, 0xbd,
  0x4a, 0x14, 0xab, 0xbc, 0x29, 0xc6, 0x5e, 0xbd, 0xd4, 0xfe, 0x88, 0xbd,
  0xb4, 0xc3, 0x1b, 0xbe, 0xc5, 0x14, 0xb0, 0x3d, 0xe1, 0x04, 0x35, 0xbe,
  0x53, 0xe2, 0x49, 0xbe, 0x0b, 0xd9, 0xff, 0xb9, 0x87, 0xb6, 0x89, 0xbd,
  0xbd, 0x80, 0xcf, 0x3c, 0xf1, 0xa8, 0x05, 0xbd, 0x34, 0xc4, 0x17, 0xbe,
  0xc3, 0x8c, 0xd0, 0xbb, 0x12, 0x67, 0x21, 0xbd, 0x54, 0x5c, 0x0d, 0x3d,
  0xef, 0x00, 0x40, 0xbd, 0xeb, 0x1d, 0xbd, 0xbd, 0x98, 0xd9, 0x94, 0xbc,
  0xd2, 0x24, 0xbd, 0x3d, 0xbe, 0x85, 0xc4, 0xbd, 0x70, 0xf0, 0xb0, 0x3d,
  0x1c, 0x55, 0xf4, 0xbd, 0xe3, 0x60, 0x07, 0xbc, 0xd5, 0xf3, 0x8f, 0xbc,
  0x73, 0xac, 0xae, 0xbd, 0xc0, 0x55, 0x50, 0xbc, 0x32, 0xa0, 0x27, 0xbd,
  0x6a, 0x9c, 0xa6, 0x3d, 0x7a, 0x1e, 0xe7, 0x3d, 0x09, 0x5a, 0x0a, 0xbe,
  0xa2, 0xee, 0x91, 0xbd, 0x19, 0xd4, 0x12, 0x3a, 0xf2, 0x2b, 0x1a, 0xbd,
  0x58, 0x36, 0x61, 0x3d, 0x88, 0x27, 0xe5, 0xbd, 0xe1, 0x6e, 0x18, 0xbd,
  0xd3, 0xc5, 0x50, 0x3d, 0x49, 0xd7, 0xe3, 0xbd, 0x5c, 0xe9, 0x1f, 0xbe,
  0xe5, 0x12, 0x0a, 0xbe, 0x84, 0x7a, 0x04, 0xbe, 0x3a, 0x10, 0x5d, 0x3c,
  0x84, 0x7f, 0xc0, 0xbd, 0x9f, 0xd3, 0xa4, 0xbd, 0x26, 0xfc, 0x05, 0xbe,
  0xba, 0xff, 0x01, 0xbe, 0x1b, 0xbf, 0x54, 0xbc, 0x1f, 0x41, 0x63, 0xbe,
  0x97, 0x95, 0x70, 0xbd, 0x4b, 0x69, 0x0f, 0xbd, 0xe3, 0x8a, 0xc2, 0xbc,
  0x4c, 0xa2, 0x89, 0x3d, 0xaa, 0x69, 0xc0, 0x3d, 0x75, 0x2f, 0x7e, 0x3d,
  0x5b, 0x43, 0x61, 0xbe, 0x03, 0x02, 0xaa, 0xbc, 0x21, 0x53, 0x46, 0xbe,
  0xd9, 0x8b, 0x33, 0xbe, 0x69, 0x45, 0x12, 0xbc, 0xa1, 0x6f, 0x06, 0x3d,
  0x01, 0x50, 0xe5, 0xbc, 0x80, 0xe4, 0xb1, 0xbd, 0xf3, 0xd1, 0xa5, 0xbd,
  0x0e, 0x36, 0x98, 0xbd, 0x7a, 0xc6, 0x3d, 0x3d, 0x7d, 0x67, 0x42, 0xbe,
  0x5d, 0xb5, 0xcc, 0x3c, 0x69, 0xf6, 0x1c, 0x3d, 0x2b, 0xc6, 0x54, 0xba,
  0xd0, 0x1d, 0xf3, 0xbd, 0xb2, 0xe2, 0x1c, 0xbc, 0x8d, 0x7f, 0x0a, 0x3d,
  0x58, 0x09, 0x2a, 0xbe, 0xbc, 0x22, 0x70, 0xbe, 0x63, 0x6b, 0x00, 0xbe,
  0x8f, 0xb0, 0x2a, 0xbd, 0xab, 0x41, 0x6a, 0xbc, 0x74, 0x4c, 0xfe, 0xbd,
  0x26, 0xd0, 0x18, 0xbc, 0x5f, 0xa3, 0x1c, 0xbd, 0x24, 0x92, 0xfe, 0xbd,
  0x6f, 0x03, 0x12, 0xbe, 0xcc, 0x07, 0x6d, 0x3a, 0x38, 0xf9, 0xe7, 0x3c,
  0xab, 0x6a, 0xbe, 0xbd, 0x10, 0x01, 0x41, 0xbd, 0xfc, 0x0d, 0x14, 0xbe,
  0x20, 0x6f, 0x2f, 0xbe, 0x54, 0x18, 0x42, 0xbe, 0xab, 0x0c, 0xc9, 0x3b,
  0x90, 0x79, 0x8f, 0xbd, 0x8c, 0x1c, 0x60, 0x3c, 0x9e, 0x23, 0x39, 0x3d,
  0x7c, 0x18, 0x0f, 0xbe, 0xf4, 0x30, 0xd4, 0xbd, 0x4a, 0xe3, 0x2f, 0x3d,
  0x5d, 0x1c, 0xd9, 0x3c, 0x99, 0x4b, 0xa2, 0xbd, 0x52, 0x5f, 0x2b, 0xbe,
  0x8c, 0x1d, 0x75, 0x3d, 0xfb, 0x43, 0xff, 0xbc, 0x05, 0x2f, 0x89, 0xbd,
  0xbe, 0x2e, 0xd1, 0xbd, 0x67, 0x7c, 0x1b, 0xbe, 0x7f, 0xa6, 0xc6, 0xbd,
  0xc8, 0x57, 0x49, 0xbc, 0x9f, 0x9a, 0xc0, 0xbd, 0xba, 0x26, 0x25, 0xbd,
  0xa2, 0x48, 0xd8, 0xbd, 0xfd, 0xa8, 0x12, 0x3b, 0x27, 0x03, 0x06, 0xbd,
  0x99, 0xcb, 0x94, 0xbd, 0xd1, 0x34, 0x09, 0xbe, 0x6c, 0x75, 0x6f, 0xbc,
  0xe7, 0xa5, 0x2c, 0xbe, 0x6e, 0x39, 0xd1, 0xbc, 0xbd, 0x54, 0xe3, 0xbb,
  0x38, 0x4f, 0xf5, 0x3c, 0x8f, 0x18, 0xd4, 0x3c, 0x2b, 0x8c, 0xd3, 0x3d,
  0x23, 0x06, 0x0e, 0x3d, 0x45, 0x3d, 0x52, 0xbc, 0x06, 0x2e, 0x0a, 0xbc,
  0xb8, 0x33, 0x97, 0x3c, 0xaa, 0x6e, 0x06, 0xbe, 0xa0, 0x52, 0x39, 0x3e,
  0x2d, 0xea, 0xc7, 0x3c, 0x35, 0xa4, 0x6b, 0x3e, 0xa9, 0xec, 0xb4, 0x3c,
  0x3f, 0xec, 0xd9, 0x3c, 0xf2, 0x08, 0x89, 0x3d, 0xe9, 0x93, 0xb2, 0xbd,
  0xdb, 0xa2, 0xf2, 0xba, 0x80, 0xb6, 0x1d, 0xbd, 0x50, 0x87, 0xbf, 0xbd,
  0x4a, 0x4f, 0x88, 0x3e, 0x33, 0x4d, 0xa4, 0x3d, 0xe8, 0x46, 0x2f, 0xbe,
  0xd8, 0xde, 0x0f, 0x3e, 0x5b, 0xc0, 0x39, 0xbc, 0xd3, 0x54, 0xf7, 0xbc,
  0xaf, 0x0e, 0x13, 0x3e, 0x89, 0x58, 0x54, 0xbe, 0x3e, 0x50, 0x3e, 0x3c,
  0xa5, 0x50, 0x2f, 0xbe, 0x99, 0xa4, 0xe7, 0xbb, 0xbf, 0x57, 0xf2, 0xbc,
  0x48, 0xe2, 0x23, 0xbe, 0xda, 0x15, 0xfa, 0xbd, 0xac, 0xaa, 0x24, 0xbd,
  0x4d, 0x66, 0xf9, 0xbd, 0x31, 0x3e, 0x3e, 0x3e, 0xaa, 0x51, 0x3d, 0x3d,
  0x3d, 0x44, 0x68, 0xbe, 0x59, 0x7c, 0x93, 0xbe, 0xef, 0x7d, 0x79, 0x3c,
  0xcd, 0xe8, 0xae, 0x3c, 0xde, 0x1d, 0x31, 0x3e, 0xa8, 0xc9, 0x99, 0xbe,
  0xca, 0xba, 0xa3, 0xbd, 0x08, 0x18, 0x41, 0x3a, 0xf4, 0xdf, 0x9e, 0x3d,
  0x58, 0x94, 0xc4, 0xbc, 0x5e, 0x08, 0x50, 0xbe, 0x3f, 0x39, 0xf4, 0xbd,
  0x10, 0x83, 0x06, 0xbc, 0xae, 0x56, 0x77, 0xbe, 0x53, 0x59, 0x96, 0x3c,
  0x62, 0xcd, 0xbd, 0x3c, 0xd1, 0x5b, 0x92, 0xbe, 0x09, 0x3b, 0xa2, 0xbe,
  0x9b, 0x6a, 0x82, 0xbc, 0x53, 0x14, 0x40, 0xbd, 0x19, 0x68, 0xea, 0x3c,
  0x30, 0xe0, 0xac, 0xbe, 0xf4, 0x0d, 0x49, 0xbd, 0x5a, 0x9b, 0x1f, 0xbd,
  0x0b, 0x2f, 0x8f, 0xbd, 0x04, 0x54, 0x05, 0x3e, 0xdf, 0xcd, 0xab, 0xbe,
  0x4f, 0xbd, 0x62, 0xbe, 0x9b, 0x58, 0xc1, 0xbb, 0xf4, 0xba, 0x01, 0xbe,
  0x39, 0x4c, 0x05, 0xbe, 0xd3, 0xf4, 0x80, 0x3d, 0xec, 0x05, 0x39, 0xbf,
  0x7b, 0x41, 0x25, 0xbe, 0x57, 0xd3, 0xd2, 0xbd, 0xb8, 0x7a, 0xb4, 0xbd,
  0x93, 0x9a, 0xf4, 0x3d, 0x99, 0x32, 0xee, 0x3b, 0x26, 0x3c, 0x03, 0xbd,
  0x57, 0x1b, 0xb4, 0xbe, 0x4f, 0xfe, 0x21, 0xbe, 0x6f, 0x1f, 0xb2, 0x3c,
  0x5d, 0xb3, 0x5a, 0xbe, 0x99, 0x4e, 0x91, 0xbe, 0x90, 0x78, 0x83, 0xbc,
  0x3e, 0xa0, 0x39, 0xbe, 0x66, 0x25, 0x5a, 0x3e, 0x29, 0x09, 0x04, 0xbd,
  0xd7, 0x02, 0xbf, 0xbe, 0x83, 0x06, 0x10, 0xbe, 0xdf, 0xa1, 0x05, 0xbe,
  0x56, 0x60, 0x0b, 0xbd, 0xd6, 0xea, 0x8d, 0x3d, 0x3d, 0xcd, 0xac, 0xbe,
  0x05, 0xc3, 0xdf, 0x3c, 0x04, 0x87, 0xa8, 0xbe, 0x1f, 0xe7, 0x28, 0xbd,
  0xd1, 0xe5, 0xa9, 0xbc, 0xff, 0x7a, 0x1e, 0xbe, 0x4a, 0x57, 0xda, 0xbe,
  0x68, 0x43, 0xa2, 0x38, 0xbf, 0x6f, 0xc9, 0xbe, 0x5f, 0xe1, 0x07, 0xbd,
  0xa3, 0xdf, 0x2d, 0xbe, 0xad, 0x95, 0xdd, 0xbe, 0x28, 0xb9, 0x88, 0xbe,
  0x29, 0xb2, 0xca, 0xbd, 0x36, 0xbe, 0x55, 0x3c, 0x2c, 0x51, 0xec, 0x3a,
  0x0c, 0x61, 0x08, 0xbf, 0x2f, 0x85, 0xe1, 0xbd, 0x47, 0x9e, 0xc3, 0xbe,
  0x9b, 0x8f, 0x14, 0xbe, 0x7f, 0xea, 0x9d, 0xbe, 0xfd, 0xdd, 0x56, 0xbe,
  0x31, 0xc6, 0xc9, 0xbe, 0xf0, 0xb6, 0x29, 0xbc, 0xdc, 0xa8, 0x0a, 0xbf,
  0x32, 0x7d, 0xbc, 0x3d, 0x63, 0xe6, 0xb9, 0xbd, 0x0c, 0x53, 0x88, 0xbe,
  0x48, 0x6b, 0xb9, 0xbe, 0xa7, 0x7c, 0xa7, 0xbc, 0x06, 0x6e, 0x1e, 0x3e,
  0x83, 0x3e, 0x82, 0x3d, 0xbd, 0x5d, 0xf0, 0xbe, 0xf6, 0xfe, 0x82, 0xbe,
  0x7d, 0xa9, 0x4f, 0xbe, 0xb9, 0x06, 0x97, 0xbe, 0x40, 0xb4, 0xc4, 0xbe,
  0x70, 0xb4, 0x82, 0xbc, 0xe2, 0x0f, 0x6e, 0xbe, 0xa5, 0xf3, 0x0c, 0x3d,
  0x71, 0x95, 0xa4, 0xbe, 0xee, 0x3e, 0xa8, 0xbe, 0x31, 0xee, 0x35, 0xbd,
  0x58, 0x84, 0xfd, 0xbd, 0x42, 0x69, 0xc5, 0xbd, 0x50, 0x25, 0x8c, 0x3d,
  0x16, 0x21, 0x2f, 0xbd, 0xa0, 0x26, 0x84, 0x3d, 0xfd, 0xd8, 0xb9, 0xbe,
  0xf0, 0x13, 0x95, 0xbe, 0x14, 0x5b, 0x4d, 0xbe, 0x7a, 0x7f, 0x98, 0xbe,
  0x25, 0x1a, 0xd3, 0xbe, 0x94, 0xc8, 0x64, 0x3e, 0x1e, 0x87, 0xe0, 0x3e,
  0xcf, 0x06, 0xe4, 0x3c, 0xa2, 0xba, 0x48, 0x3e, 0xd1, 0xaa, 0x4f, 0xbf,
  0x13, 0xf7, 0x0c, 0xbd, 0x6e, 0x86, 0x17, 0xbd, 0xcb, 0x9e, 0x68, 0x3e,
  0xb7, 0x33, 0x0e, 0x3e, 0xc0, 0xc6, 0x69, 0xbe, 0x0c, 0x65, 0x92, 0x3d,
  0x8b, 0x10, 0x4d, 0x3d, 0x35, 0x32, 0xa4, 0xbd, 0x54, 0xee, 0x1d, 0x3e,
  0x75, 0x9e, 0x49, 0xbe, 0x68, 0x0f, 0xfe, 0xbd, 0x55, 0xbf, 0x1a, 0x3e,
  0x03, 0xb3, 0x91, 0x3e, 0xdb, 0x3e, 0xbf, 0x3c, 0xb2, 0xa4, 0x3c, 0x3d,
  0x8a, 0x24, 0x33, 0xbd, 0xdd, 0x8b, 0xe5, 0x3c, 0x84, 0x5a, 0x2e, 0x3c,
  0x16, 0x89, 0x1a, 0x3e, 0x10, 0xdc, 0x9e, 0x3d, 0x66, 0xf8, 0xf5, 0xbe,
  0x43, 0xb1, 0x54, 0x3e, 0x54, 0x91, 0xe8, 0x3d, 0x77, 0x2b, 0xf8, 0x3b,
  0x0d, 0x63, 0xc4, 0x3c, 0xdf, 0xd4, 0xad, 0xbd, 0xba, 0xea, 0xac, 0xbd,
  0x27, 0xb0, 0x47, 0xbd, 0x42, 0x6d, 0x0c, 0xbe, 0xa9, 0x41, 0x35, 0x3e,
  0xf0, 0xd6, 0xc7, 0xbc, 0xe0, 0x72, 0x8e, 0x3d, 0x82, 0xae, 0xb3, 0x3d,
  0x74, 0xc7, 0x73, 0x3d, 0x0e, 0x68, 0x89, 0x3d, 0x94, 0x54, 0x57, 0x3d,
  0x42, 0xc7, 0x6e, 0xbe, 0x00, 0x64, 0x18, 0x3e, 0x4c, 0xfd, 0x61, 0x3c,
  0x40, 0x0c, 0xe3, 0x3c, 0x89, 0x73, 0x51, 0xbd, 0x93, 0x1d, 0xba, 0xbb,
  0xff, 0xa0, 0xde, 0xbd, 0x05, 0x30, 0x53, 0xbd, 0xcc, 0x54, 0x62, 0xbd,
  0xa1, 0x56, 0x1b, 0xbe, 0x58, 0x30, 0x99, 0x3d, 0xf0, 0x2e, 0x2f, 0x3d,
  0xba, 0xca, 0x4b, 0xbd, 0x2d, 0xad, 0xa3, 0x3d, 0x55, 0xd0, 0x66, 0x3d,
  0x18, 0x06, 0x14, 0xbd, 0x99, 0x79, 0xdd, 0xbd, 0x3e, 0x3f, 0x13, 0x3e,
  0x15, 0x5a, 0x1f, 0x3d, 0x4b, 0x71, 0xf9, 0x3d, 0x2e, 0xe2, 0x10, 0x3d,
  0xd2, 0x3b, 0x61, 0x3e, 0x73, 0x71, 0x5c, 0x3e, 0xbe, 0xf0, 0xb5, 0x3d,
  0x37, 0x15, 0x91, 0xbe, 0x46, 0x10, 0xa2, 0xbf, 0xdf, 0x3d, 0x84, 0xbd,
  0xbf, 0x14, 0x1a, 0x3e, 0x89, 0x2f, 0xb0, 0xbd, 0xab, 0x5c, 0x10, 0xbe,
  0x27, 0x16, 0xab, 0xbd, 0x74, 0x92, 0x54, 0x3c, 0xb2, 0x2c, 0x0c, 0x3f,
  0x53, 0xb6, 0xd2, 0xbe, 0xeb, 0xa4, 0xc5, 0xbc, 0x68, 0xba, 0x64, 0x3e,
  0xae, 0xf3, 0xc3, 0x3c, 0x55, 0x18, 0x00, 0x3e, 0x97, 0x9f, 0x81, 0x3c,
  0x14, 0x50, 0xa0, 0xbd, 0x5e, 0x56, 0x70, 0xbe, 0x11, 0x21, 0x8e, 0x3d,
  0x22, 0x03, 0xa0, 0x3d, 0x35, 0x7a, 0x4c, 0x3e, 0x2d, 0xfe, 0x31, 0x3e,
  0xed, 0x55, 0x7b, 0xbe, 0x29, 0x99, 0x83, 0xbc, 0x3d, 0x90, 0x14, 0xbd,
  0x12, 0x63, 0xbd, 0xbd, 0x17, 0x0c, 0xb0, 0xbd, 0x20, 0x39, 0x13, 0x3d,
  0x6f, 0xbd, 0x04, 0x3d, 0x92, 0x58, 0x0f, 0xbe, 0xdf, 0xa2, 0xcb, 0xbc,
  0x31, 0xf9, 0x03, 0xbd, 0x53, 0x16, 0x13, 0xbf, 0x43, 0xf4, 0xa8, 0xbe,
  0xc0, 0x7c, 0x6d, 0x3d, 0x48, 0xc1, 0x83, 0xbe, 0x54, 0xd0, 0xcd, 0x3c,
  0xf2, 0x6b, 0x79, 0xbb, 0x94, 0x21, 0x3c, 0x3e, 0xe3, 0x7c, 0xdc, 0x3d,
  0x30, 0xd9, 0x8a, 0xbc, 0x99, 0x00, 0x63, 0x3d, 0xef, 0xab, 0x5d, 0xbe,
  0x50, 0x7b, 0x09, 0xbe, 0xb5, 0x1b, 0x4b, 0x3d, 0xd7, 0xba, 0x86, 0xbe,
  0xf3, 0xe5, 0x5f, 0xbc, 0xe5, 0x75, 0x81, 0xbc, 0x0f, 0x70, 0x83, 0x3e,
  0x30, 0xf5, 0x41, 0xbe, 0xf9, 0x35, 0x81, 0x3d, 0xaf, 0x07, 0x82, 0xbe,
  0xdc, 0xd6, 0x93, 0x3d, 0x76, 0xdf, 0xbf, 0x3c, 0x4c, 0x4d, 0x1d, 0x3e,
  0x94, 0x7c, 0x6f, 0x3e, 0xa7, 0x3a, 0xde, 0x3c, 0x39, 0xaf, 0x26, 0xbe,
  0xcc, 0x77, 0x0f, 0x3e, 0x13, 0xdb, 0xf9, 0xbd, 0x09, 0x17, 0xb1, 0x3d,
  0x80, 0x68, 0xc7, 0xbc, 0xec, 0x9d, 0xc7, 0xbd, 0x60, 0xc6, 0xf1, 0x3d,
  0x38, 0x4e, 0xba, 0x3d, 0x31, 0x3a, 0x76, 0x3e, 0xa3, 0x8a, 0x41, 0x3d,
  0xfe, 0x0a, 0x6b, 0xbe, 0x42, 0x2e, 0x69, 0x3e, 0x66, 0x24, 0x01, 0x3e,
  0x42, 0x97, 0x05, 0xbe, 0x76, 0x45, 0xa5, 0xbd, 0x0d, 0xa3, 0x20, 0xbe,
  0x48, 0xbb, 0x8a, 0xbe, 0xec, 0x1c, 0x25, 0xbb, 0x36, 0x80, 0x7c, 0x3d,
  0x5a, 0x73, 0x16, 0x3d, 0xc6, 0x28, 0x02, 0x3d, 0xb8, 0xe4, 0x40, 0xbe,
  0x35, 0x1b, 0x97, 0xbc, 0x4a, 0xb3, 0x7d, 0x3d, 0xd1, 0x9d, 0xcb, 0xba,
  0x6e, 0xf8, 0x60, 0xbd, 0x55, 0x8e, 0x2f, 0xbe, 0x87, 0xc2, 0x6e, 0x3e,
  0x8b, 0xc5, 0xac, 0x3c, 0x13, 0x8d, 0x8b, 0xbb, 0x7b, 0x4c, 0xf0, 0xbc,
  0xd9, 0x89, 0x33, 0xbe, 0x04, 0xd9, 0x5a, 0x3d, 0xad, 0x5a, 0x46, 0x3c,
  0x97, 0xe6, 0x08, 0x3e, 0xd7, 0x70, 0x90, 0x3c, 0x96, 0x8d, 0x37, 0xbe,
  0xe1, 0x25, 0x3f, 0xbd, 0x49, 0x98, 0x95, 0x3d, 0x1c, 0x55, 0x6d, 0x3d,
  0xdd, 0x08, 0x9c, 0x3e, 0x2b, 0x2d, 0xdc, 0x3d, 0x61, 0x8f, 0x8e, 0xbe,
  0x80, 0x66, 0x62, 0x3e, 0xa3, 0x09, 0xdc, 0x3d, 0xd9, 0x94, 0x07, 0x3e,
  0xa0, 0x7a, 0x32, 0xbd, 0x42, 0x14, 0x0a, 0xbe, 0xb3, 0xfa, 0x35, 0x3d,
  0xa2, 0x26, 0x1d, 0x3d, 0x35, 0xb7, 0x87, 0x3c, 0xc7, 0x87, 0xcd, 0x3d,
  0x5a, 0x7f, 0xd4, 0xbd, 0x63, 0x29, 0xfa, 0xbd, 0xfe, 0x64, 0xb1, 0x3d,
  0x2d, 0xfa, 0x31, 0x3e, 0xe3, 0x21, 0x9a, 0x3c, 0xbf, 0xd3, 0x5b, 0xbc,
  0xc5, 0xbe, 0x97, 0xbe, 0x9a, 0xe8, 0x72, 0x3e, 0xe4, 0x5a, 0xb8, 0xba,
  0x7f, 0x3c, 0xd3, 0xbb, 0xa2, 0x1e, 0x8a, 0x3c, 0xf1, 0xfd, 0x44, 0xbe,
  0x75, 0x23, 0x0b, 0x3e, 0x3b, 0xda, 0x06, 0xbd, 0x92, 0x2e, 0x84, 0x3d,
  0x2b, 0xa7, 0xd7, 0x3c, 0xb7, 0x45, 0x35, 0xbd, 0x47, 0x60, 0xd0, 0xbc,
  0xee, 0x6f, 0xc2, 0xbc, 0xd1, 0x2b, 0x36, 0x3e, 0x5e, 0x34, 0xbc, 0x3d,
  0x97, 0xa5, 0x65, 0x3d, 0xc9, 0x9d, 0x88, 0xbe, 0xad, 0x3a, 0x97, 0x3e,
  0x59, 0x30, 0x04, 0x3d, 0x89, 0x47, 0x9a, 0x3d, 0x56, 0xde, 0x5c, 0xbd,
  0x50, 0x0d, 0xdd, 0xbd, 0xf9, 0x43, 0xf1, 0xbd, 0xfb, 0xb6, 0xa7, 0xbd,
  0xcd, 0x08, 0xbd, 0x3d, 0x93, 0x12, 0x06, 0xbd, 0x1b, 0x59, 0xc3, 0xbd,
  0x8d, 0x84, 0xb1, 0xbd, 0xf2, 0x75, 0x3b, 0xbc, 0x9a, 0xe4, 0xeb, 0x3d,
  0x4d, 0xe4, 0x2f, 0x3e, 0xee, 0x7c, 0xc2, 0x3d, 0x15, 0xb6, 0xe1, 0xbe,
  0x04, 0x9a, 0x84, 0x3e, 0xc7, 0xd5, 0xd3, 0x3d, 0x11, 0xef, 0xca, 0x3d,
  0x03, 0xa5, 0x36, 0x3c, 0xa0, 0x78, 0x9c, 0xbd, 0x06, 0x60, 0xaa, 0xbc,
  0x72, 0xee, 0x5d, 0xbe, 0x50, 0xd1, 0x32, 0x3d, 0x58, 0x35, 0x23, 0xbc,
  0x20, 0xc3, 0xba, 0xbd, 0x23, 0x78, 0xed, 0xbd, 0xa1, 0xad, 0xc3, 0x3c,
  0xbf, 0xc2, 0x09, 0x3e, 0x55, 0x5f, 0x4e, 0x3e, 0xbe, 0x15, 0x1f, 0x3c,
  0x31, 0x20, 0xbc, 0xbe, 0xe1, 0x69, 0xce, 0x3e, 0xc1, 0x0b, 0x9d, 0x3d,
  0x61, 0xa0, 0xea, 0x3d, 0x37, 0x8f, 0x23, 0xbd, 0xd6, 0xfd, 0xec, 0xbd,
  0xd5, 0x39, 0xb9, 0xbd, 0x67, 0x21, 0x55, 0xbd, 0x02, 0x3b, 0x7d, 0x3c,
  0xbf, 0x75, 0x23, 0xbd, 0x94, 0xa6, 0xde, 0xbd, 0x05, 0x4d, 0x27, 0xbe,
  0x3b, 0xf9, 0x92, 0x3d, 0x70, 0x6e, 0x4f, 0x3e, 0xd3, 0x87, 0x62, 0x3e,
  0x4b, 0x0c, 0x15, 0x3d, 0x93, 0x56, 0x8a, 0xbe, 0xea, 0xa6, 0x8a, 0x3e,
  0xde, 0x06, 0xaf, 0xbd, 0xdf, 0x0b, 0xb7, 0x3d, 0x4e, 0x4a, 0x0d, 0xbd,
  0xd1, 0x4f, 0xbe, 0xbc, 0xb6, 0x01, 0x0e, 0xbe, 0x2d, 0x74, 0xf6, 0x3d,
  0xb0, 0xb8, 0xd9, 0x3d, 0xcf, 0xc4, 0x55, 0xbc, 0x1d, 0x55, 0xd6, 0xbd,
  0xfa, 0x1d, 0x12, 0xbe, 0xa9, 0x68, 0xde, 0x3d, 0xf6, 0x81, 0xa0, 0x3e,
  0x24, 0x3a, 0x8c, 0x3d, 0xbd, 0xa6, 0x84, 0x3d, 0x19, 0xaa, 0xe1, 0xbe,
  0x38, 0xde, 0x9e, 0x3c, 0x18, 0x62, 0xab, 0xbd, 0x8d, 0x5e, 0xcd, 0x3d,
  0x63, 0x0f, 0xc6, 0x3d, 0xcc, 0x70, 0x97, 0x3c, 0xbf, 0xc8, 0xf2, 0xbd,
  0x23, 0x59, 0x8d, 0xbd, 0x85, 0x7c, 0x25, 0x3e, 0xf8, 0x02, 0x30, 0xbd,
  0x45, 0xc0, 0x0f, 0xbe, 0x0e, 0xff, 0xfc, 0xbd, 0x6a, 0x25, 0x90, 0x3d,
  0xef, 0x19, 0x74, 0x3e, 0x89, 0x24, 0xc8, 0x3d, 0xa6, 0x66, 0x56, 0x3d,
  0xac, 0x62, 0xc8, 0xbd, 0x76, 0xfe, 0xff, 0xbd, 0xb4, 0x51, 0xd6, 0xbd,
  0xbd, 0xad, 0xf7, 0x3c, 0xcc, 0x95, 0xa1, 0x3d, 0xc3, 0xf8, 0xc9, 0x3d,
  0x59, 0x47, 0x25, 0xbf, 0xc4, 0xf0, 0xa5, 0xbd, 0x4e, 0x30, 0xaf, 0x3d,
  0x7d, 0x81, 0x3c, 0xbe, 0x9e, 0x67, 0xb5, 0xbc, 0x4e, 0xc0, 0x6c, 0xbe,
  0x9f, 0xcf, 0xe5, 0xbd, 0x4c, 0x11, 0x37, 0xbe, 0xd5, 0x39, 0x16, 0xbe,
  0xc5, 0xd9, 0x0e, 0x3e, 0x6c, 0x92, 0x03, 0x3c, 0xab, 0x34, 0xa3, 0xbd,
  0x50, 0xe0, 0x7d, 0xbe, 0x3c, 0x60, 0xf6, 0x3d, 0xc9, 0x51, 0xa8, 0xbe,
  0x30, 0x4f, 0x5a, 0x3e, 0x37, 0x97, 0x76, 0xbf, 0x7d, 0x59, 0x18, 0x3c,
  0xc1, 0xef, 0x3b, 0xbc, 0xd4, 0xe6, 0x8e, 0xbe, 0x89, 0xa1, 0x47, 0xbe,
  0x69, 0x10, 0xc7, 0xbe, 0x44, 0x38, 0xdd, 0xbe, 0x30, 0x7d, 0x5f, 0x3e,
  0xa4, 0xe6, 0x04, 0x3f, 0x40, 0xc8, 0x8b, 0x3d, 0xe2, 0x2b, 0xbb, 0x3e,
  0x0f, 0x74, 0xbd, 0x3d, 0x8b, 0x41, 0x8a, 0xbc, 0xc5, 0x27, 0x96, 0x3e,
  0x5d, 0x6c, 0x19, 0x3e, 0xb4, 0xb1, 0xea, 0x3d, 0x6b, 0x50, 0xe2, 0xbd,
  0xe8, 0xa0, 0xe1, 0x3e, 0x71, 0x0c, 0x20, 0x3d, 0xb3, 0x71, 0x56, 0x3e,
  0x59, 0x48, 0x24, 0x3f, 0xb2, 0xfa, 0x6e, 0x3d, 0xa7, 0x11, 0xe2, 0x3d,
  0x2b, 0xbc, 0x71, 0x3e, 0x2a, 0x4f, 0x39, 0x3f, 0xd0, 0xbf, 0x11, 0x3d,
  0xfb, 0x9b, 0x39, 0x3d, 0x94, 0x08, 0xab, 0x3e, 0xc6, 0x55, 0x23, 0x3e,
  0x10, 0xb4, 0x0c, 0xbe, 0x0b, 0x04, 0xd3, 0x3c, 0x6c, 0xb4, 0xc5, 0x3d,
  0x75, 0xfc, 0x80, 0xbe, 0xeb, 0x7c, 0x54, 0x3e, 0x52, 0x0d, 0x24, 0x3f,
  0x81, 0xd0, 0xda, 0x3d, 0x5c, 0xd6, 0x1f, 0x3e, 0xb8, 0x60, 0xf6, 0x3d,
  0x56, 0x7a, 0x01, 0x3c, 0xaa, 0x9c, 0x00, 0xbe, 0x36, 0x21, 0x38, 0xbe,
  0xe2, 0x0c, 0x12, 0xbe, 0xe4, 0xcf, 0x6a, 0x3e, 0x1f, 0x3f, 0x95, 0x3d,
  0x36, 0xd1, 0x54, 0x3e, 0xa8, 0xea, 0x2a, 0xbe, 0x21, 0x4f, 0x00, 0xbd,
  0xeb, 0xaf, 0x10, 0x3d, 0x34, 0xba, 0x53, 0xbe, 0xb1, 0xc6, 0x93, 0xbd,
  0x41, 0x20, 0x08, 0xbd, 0xd9, 0xe9, 0x81, 0x3d, 0xbd, 0x24, 0x93, 0xbe,
  0x4e, 0x30, 0xc7, 0x3d, 0xc5, 0x27, 0x44, 0xbd, 0xc1, 0xdc, 0x25, 0xbd,
  0xb4, 0x22, 0xb6, 0xbe, 0xb7, 0x4a, 0x43, 0xbd, 0x05, 0x6b, 0x46, 0x3d,
  0xb9, 0xa4, 0xcd, 0xbd, 0x6c, 0xdc, 0xa8, 0x3e, 0x61, 0x8e, 0xd6, 0xbd,
  0x9e, 0x80, 0x00, 0xbd, 0xa9, 0x33, 0x9f, 0xbd, 0x27, 0x49, 0x08, 0xbd,
  0x8e, 0xb7, 0xa7, 0xbc, 0xda, 0x62, 0xec, 0x3c, 0x5f, 0x7e, 0x06, 0x3d,
  0xee, 0xeb, 0xe8, 0xbd, 0x53, 0xbd, 0xef, 0x3d, 0x1e, 0x22, 0x15, 0xbe,
  0x23, 0x6f, 0x5f, 0xbe, 0xb1, 0x3c, 0x84, 0xbe, 0xec, 0x84, 0xbc, 0xbc,
  0x0a, 0xce, 0x08, 0x3c, 0x36, 0xff, 0x7b, 0xbd, 0xb1, 0xd0, 0x52, 0x3e,
  0x5a, 0xfe, 0x35, 0x3d, 0x1c, 0xd2, 0xd4, 0xbd, 0xc7, 0x53, 0x84, 0x3d,
  0x00, 0xb9, 0xa8, 0x3d, 0x3e, 0xd7, 0x96, 0x3d, 0xb4, 0x7f, 0x72, 0xbd,
  0x14, 0x36, 0x1a, 0x3d, 0x68, 0xa3, 0x95, 0xbe, 0xf9, 0xa2, 0xa9, 0x3d,
  0x08, 0xc6, 0xf4, 0xbd, 0x9a, 0xbd, 0x43, 0xbd, 0x6b, 0x8c, 0xe7, 0xbe,
  0x37, 0x84, 0x22, 0xbd, 0x06, 0x91, 0x48, 0xbd, 0x1a, 0xee, 0x75, 0x3e,
  0x14, 0xe4, 0xa1, 0x3d, 0xba, 0x02, 0x5c, 0xbd, 0x56, 0x29, 0xbe, 0xbc,
  0x45, 0x6b, 0x89, 0x3d, 0x37, 0xe9, 0x42, 0x3d, 0x3a, 0xdc, 0x2c, 0x3d,
  0x45, 0x30, 0x4a, 0xb9, 0xaa, 0xf3, 0x11, 0x3d, 0xe1, 0xad, 0x4e, 0xbe,
  0xc7, 0x41, 0xde, 0x3d, 0x5b, 0x07, 0x9c, 0xbe, 0x1c, 0x04, 0xd1, 0xbd,
  0xe6, 0x2d, 0xc6, 0xbc, 0x01, 0x35, 0x67, 0xbd, 0x42, 0xc5, 0xf5, 0x3c,
  0xbf, 0x95, 0x85, 0x3d, 0x7e, 0xf7, 0x00, 0x3e, 0xbe, 0x33, 0x89, 0xbd,
  0xeb, 0x9f, 0x41, 0xbd, 0x31, 0x36, 0x22, 0xbc, 0xa4, 0x37, 0x69, 0xbc,
  0xaa, 0xfa, 0x15, 0xbe, 0x1a, 0x91, 0x59, 0x3d, 0xf4, 0xf0, 0x59, 0xbd,
  0xd7, 0xda, 0x49, 0xbe, 0x8a, 0x21, 0xd5, 0x3d, 0x7e, 0x56, 0x7d, 0xbd,
  0x30, 0x2d, 0x01, 0xbe, 0x71, 0x1a, 0x2e, 0xbe, 0x53, 0xd8, 0xb7, 0xbd,
  0x64, 0x41, 0xcf, 0x3d, 0xa7, 0x59, 0x00, 0xbe, 0x2c, 0xb1, 0x09, 0x3e,
  0xdb, 0xd1, 0x02, 0xbe, 0x8a, 0xd5, 0xbb, 0xbd, 0xb0, 0xde, 0xb0, 0x3d,
  0x90, 0x25, 0x22, 0x3c, 0xbd, 0xc3, 0x84, 0xbd, 0x69, 0x9b, 0xbe, 0x3d,
  0x04, 0x9b, 0x92, 0xbb, 0x14, 0xad, 0x0f, 0xbe, 0x7f, 0x14, 0xa2, 0x3c,
  0x6f, 0xc6, 0xbf, 0xbd, 0xa9, 0xfa, 0xa2, 0xbe, 0x93, 0xae, 0x09, 0xbe,
  0x91, 0x2d, 0x0f, 0xbe, 0x9c, 0x2b, 0xf1, 0x3d, 0xc1, 0x6a, 0x06, 0xbe,
  0x05, 0xf1, 0x48, 0x3d, 0x89, 0x60, 0xe0, 0xbd, 0xe1, 0xf7, 0x0a, 0xbe,
  0x86, 0xf4, 0x42, 0x3d, 0x55, 0xb4, 0xa7, 0x3d, 0xbc, 0xa3, 0x8f, 0x3d,
  0xec, 0x59, 0xae, 0x3d, 0x6a, 0x78, 0x95, 0x3d, 0x57, 0x04, 0x78, 0xbe,
  0x85, 0x67, 0x57, 0x3d, 0x41, 0x8e, 0x9f, 0xbd, 0xa8, 0x5b, 0x38, 0xbe,
  0xb5, 0x5b, 0x99, 0xbe, 0x68, 0xda, 0x7c, 0xbe, 0xa3, 0x89, 0x26, 0x3e,
  0x6f, 0x72, 0x41, 0xbe, 0x4c, 0xee, 0x1b, 0xbb, 0x41, 0xbf, 0x65, 0xbe,
  0xe0, 0x10, 0xf5, 0xbd, 0x92, 0xa3, 0xd1, 0xbc, 0xf9, 0x87, 0xfe, 0x3d,
  0x66, 0xc3, 0x6b, 0xbd, 0xe5, 0x15, 0xa7, 0x3d, 0xc2, 0x28, 0x0d, 0x3d,
  0x5f, 0x68, 0x88, 0xbe, 0x55, 0x4d, 0x55, 0x3d, 0x43, 0x4a, 0xbb, 0xbd,
  0x7c, 0x92, 0x81, 0xbe, 0x0d, 0x1e, 0x49, 0xbe, 0x36, 0x38, 0x49, 0xbe,
  0x32, 0xe8, 0x8c, 0x3d, 0x11, 0x50, 0x36, 0xbe, 0xf6, 0x62, 0x15, 0xbd,
  0x1d, 0x0a, 0x81, 0xbe, 0x67, 0x2b, 0xe0, 0xbc, 0xe4, 0x14, 0x24, 0xbc,
  0xdf, 0x62, 0x1e, 0x3e, 0xc1, 0xc8, 0xda, 0xbd, 0x5e, 0x17, 0x0c, 0x3b,
  0x42, 0x5c, 0xbe, 0xbc, 0x32, 0x72, 0x2d, 0xbe, 0xb0, 0x84, 0x21, 0xbd,
  0xec, 0xb0, 0x5e, 0xbc, 0x5e, 0x31, 0x4e, 0xbe, 0xad, 0x07, 0x02, 0x3c,
  0x30, 0x64, 0x15, 0xbe, 0xb7, 0x44, 0x22, 0x3d, 0x6f, 0x13, 0x8a, 0x3d,
  0x26, 0x86, 0xe0, 0x3d, 0x43, 0x72, 0xa7, 0xbd, 0x07, 0x4c, 0x30, 0xbd,
  0x93, 0x3a, 0xc5, 0x3d, 0xc4, 0x9d, 0xa4, 0x3c, 0xde, 0x10, 0x80, 0xbe,
  0x64, 0x31, 0x12, 0xbc, 0x81, 0x40, 0x9d, 0xbd, 0x13, 0x7d, 0x4e, 0xbe,
  0x2a, 0x25, 0xf1, 0x3c, 0xe5, 0x22, 0x02, 0xbd, 0xff, 0x20, 0x44, 0xbe,
  0x0e, 0x32, 0xd5, 0xbc, 0xb5, 0x60, 0x63, 0xbd, 0xcf, 0xdd, 0xcf, 0xbc,
  0x13, 0x18, 0x81, 0xbe, 0xce, 0x00, 0x0a, 0x3e, 0x0d, 0x74, 0x27, 0x3d,
  0x7b, 0x28, 0xc7, 0xbd, 0xa2, 0xcc, 0x54, 0x3d, 0x6f, 0x0f, 0xad, 0xbe,
  0x63, 0x70, 0xf0, 0xbd, 0xaa, 0x4a, 0xe9, 0x3d, 0x5e, 0x29, 0x29, 0x3d,
  0x29, 0xd4, 0x06, 0xbe, 0xb4, 0x45, 0xc5, 0x3d, 0xe8, 0x20, 0x81, 0x3e,
  0x82, 0x91, 0xbb, 0x3d, 0x1d, 0x15, 0xa8, 0x3e, 0xd2, 0x6a, 0xa9, 0xbe,
  0x66, 0x78, 0x20, 0x3c, 0x03, 0xff, 0x78, 0xbd, 0xba, 0xdf, 0xe4, 0x3d,
  0x3c, 0x40, 0x4e, 0x3e, 0x46, 0x0d, 0x80, 0x3e, 0x06, 0x22, 0xdf, 0x3d,
  0x0d, 0x2e, 0x95, 0x3d, 0xf6, 0x29, 0x53, 0x3d, 0x8c, 0xa4, 0xa5, 0x3c,
  0x88, 0xaa, 0xb0, 0x3d, 0xbc, 0x7f, 0x97, 0xbc, 0xe3, 0xd6, 0x09, 0x3f,
  0xd9, 0x0e, 0x1f, 0x3e, 0x0a, 0x9d, 0xab, 0x3d, 0x2a, 0x87, 0xae, 0x3d,
  0xba, 0x72, 0xc1, 0xbd, 0x4f, 0xce, 0x07, 0xbe, 0x46, 0x31, 0x3a, 0xbe,
  0x81, 0x34, 0x14, 0x3d, 0x4a, 0x11, 0xa6, 0xbd, 0x56, 0x3c, 0x32, 0x3d,
  0xec, 0x1a, 0x55, 0xbe, 0x74, 0x5e, 0xbc, 0x3d, 0x37, 0xd1, 0x12, 0xbe,
  0xdd, 0x87, 0x10, 0xbd, 0xcb, 0xae, 0x2a, 0xbe, 0x28, 0xcd, 0x0e, 0xbd,
  0xb4, 0xce, 0xe7, 0xbc, 0x99, 0xde, 0x3c, 0xbe, 0x59, 0xf0, 0xf3, 0xbd,
  0xac, 0xed, 0x33, 0xbe, 0x48, 0x07, 0x97, 0xbc, 0xef, 0x69, 0x67, 0xbe,
  0x4d, 0x53, 0x2f, 0x3b, 0x4b, 0xb2, 0xa0, 0xbc, 0xd5, 0xc5, 0x93, 0x3d,
  0x03, 0x09, 0x29, 0x3d, 0x5b, 0x1c, 0x97, 0xbd, 0xc0, 0xee, 0x8a, 0xb8,
  0x5d, 0xe4, 0xcd, 0xbd, 0xbb, 0x6c, 0x51, 0x3c, 0x73, 0xce, 0x2c, 0xbd,
  0x2a, 0xd4, 0x17, 0xbe, 0xcc, 0x22, 0x07, 0xbd, 0x6a, 0x7c, 0x45, 0xbe,
  0xe7, 0xdc, 0xc5, 0xbd, 0xf6, 0x6f, 0xa4, 0x3d, 0xc6, 0xa5, 0x2e, 0xbe,
  0x5c, 0x03, 0x6e, 0xbe, 0x26, 0x5a, 0xf2, 0xbd, 0xe6, 0x73, 0x16, 0xbe,
  0x52, 0x75, 0xa9, 0x3a, 0xfe, 0xe5, 0x30, 0xbe, 0xb0, 0xe7, 0x02, 0x3d,
  0xc8, 0x3f, 0x90, 0xbd, 0xc0, 0xec, 0xaa, 0xbd, 0xfd, 0x46, 0x23, 0xbe,
  0xf6, 0x9d, 0xdf, 0xba, 0x01, 0x87, 0xa3, 0x3d, 0x5a, 0xa6, 0x45, 0xbc,
  0x3c, 0xd2, 0x80, 0x3d, 0x4a, 0x03, 0x3a, 0x3d, 0x00, 0xdb, 0xe9, 0xbd,
  0xf6, 0xe4, 0x6f, 0xbd, 0xdd, 0x5f, 0x82, 0x3d, 0xeb, 0x5c, 0x5a, 0x3d,
  0x98, 0x92, 0xe1, 0xbc, 0xe4, 0xfd, 0xe7, 0xbd, 0x4b, 0x54, 0xcb, 0xbd,
  0x30, 0x3b, 0x59, 0xbb, 0xe7, 0x1e, 0x9e, 0x3c, 0x55, 0x1f, 0x41, 0xbd,
  0x0b, 0x81, 0x31, 0xbd, 0x56, 0x18, 0x08, 0xbe, 0xb5, 0x8c, 0xcb, 0xbd,
  0x83, 0x5d, 0x8c, 0xbd, 0xd3, 0x43, 0x07, 0xbe, 0x3b, 0xb8, 0xe0, 0xbc,
  0x40, 0x1d, 0xa4, 0xbd, 0xc4, 0x96, 0xeb, 0xbd, 0xf6, 0x0b, 0x3a, 0x3d,
  0xad, 0xe7, 0x34, 0x3d, 0x8d, 0x48, 0x77, 0xbb, 0x6c, 0xe9, 0x85, 0x3d,
  0x6a, 0xe2, 0x11, 0x3d, 0xf8, 0x44, 0x29, 0x3d, 0xc5, 0xa3, 0xab, 0x3d,
  0x6e, 0xfe, 0x99, 0x3d, 0x31, 0xd2, 0x2f, 0xbe, 0x48, 0x56, 0xff, 0x3c,
  0x0d, 0x6c, 0x2b, 0xbe, 0xd3, 0x99, 0x93, 0xbd, 0x9e, 0xfc, 0xe4, 0xbd,
  0xb3, 0x52, 0x9f, 0x3d, 0xd2, 0x89, 0xb0, 0x3d, 0x3d, 0xfd, 0x53, 0x3d,
  0x5d, 0x0d, 0x52, 0xbe, 0x8e, 0xbd, 0x18, 0xbe, 0x2e, 0x74, 0x5e, 0xbb,
  0xcf, 0xbb, 0x81, 0x3c, 0x30, 0x87, 0x1b, 0xbe, 0x2c, 0xe5, 0x93, 0xbd,
  0xb3, 0x52, 0xb8, 0x3c, 0x39, 0x30, 0xee, 0xbd, 0xbf, 0xcb, 0xa0, 0xbc,
  0x08, 0xa0, 0x9a, 0x3c, 0xae, 0xd0, 0x2e, 0xbd, 0x48, 0xef, 0x62, 0xbd,
  0x79, 0xbe, 0xcb, 0xbd, 0xf1, 0xe5, 0x41, 0xbd, 0xfa, 0xd2, 0x1b, 0xbe,
  0xa8, 0x11, 0xaf, 0xbd, 0x51, 0xec, 0x85, 0xbc, 0x7b, 0x0b, 0x34, 0xbe,
  0x5a, 0x00, 0xaf, 0x3c, 0xf1, 0x1a, 0x4d, 0xbe, 0xa0, 0xf3, 0x8d, 0xbd,
  0x40, 0xb5, 0x60, 0xbe, 0xd8, 0xcd, 0x0f, 0xbe, 0xf5, 0x95, 0x43, 0xbe,
  0xff, 0x65, 0x3e, 0xbc, 0xf4, 0x00, 0x01, 0x3d, 0x78, 0xce, 0x1f, 0xbe,
  0x7b, 0x17, 0x00, 0x3c, 0xb7, 0x39, 0x2a, 0x3c, 0x11, 0x1b, 0xe5, 0xbd,
  0x6c, 0x62, 0xe7, 0xbc, 0xd9, 0x77, 0x18, 0xbe, 0x80, 0x9b, 0x39, 0xbc,
  0xf0, 0xea, 0x6a, 0xbd, 0xe3, 0xc0, 0xca, 0xbb, 0xb3, 0x49, 0xbf, 0xbd,
  0xc3, 0x76, 0x19, 0xbd, 0x69, 0x6b, 0x83, 0x3c, 0x1b, 0x3a, 0xc7, 0xbd,
  0x2d, 0x1e, 0x33, 0xbd, 0xcf, 0x7f, 0x75, 0x3d, 0x9b, 0x3e, 0xc6, 0xbd,
  0x81, 0xf1, 0xe6, 0xbd, 0xb9, 0x54, 0x9c, 0x3c, 0x3a, 0xe6, 0x16, 0xbe,
  0x76, 0x7f, 0xa7, 0xbc, 0x3e, 0x32, 0x27, 0xbe, 0x51, 0x02, 0xcc, 0xbd,
  0x80, 0x5b, 0x81, 0xbd, 0x9a, 0xef, 0x1e, 0x3d, 0x76, 0x21, 0xdc, 0xbd,
  0xdf, 0x2e, 0x03, 0xbd, 0x26, 0x4d, 0xe5, 0x3b, 0xb8, 0xa1, 0xbf, 0xbd,
  0x11, 0x21, 0xcb, 0x3c, 0x00, 0xbe, 0xbc, 0x3d, 0x69, 0x50, 0x65, 0xbd,
  0x87, 0x6c, 0x69, 0xbe, 0xa5, 0xdd, 0xb5, 0x3c, 0x79, 0x39, 0x13, 0x3d,
  0x25, 0xea, 0x11, 0xbe, 0x51, 0xa6, 0x45, 0xbe, 0xa3, 0x84, 0x07, 0xbe,
  0xe4, 0x77, 0x7e, 0xbd, 0x68, 0x04, 0xf7, 0xbc, 0x1c, 0x98, 0x2c, 0xbe,
  0x53, 0xfb, 0xae, 0xbd, 0x58, 0x42, 0x40, 0x3d, 0x70, 0x64, 0x8c, 0xbd,
  0x71, 0xd2, 0x22, 0xbe, 0x77, 0x7b, 0xd9, 0xbc, 0x62, 0x5a, 0x0d, 0x3d,
  0x3a, 0x08, 0x15, 0xbe, 0xee, 0x24, 0x3d, 0xbe, 0x0f, 0x4c, 0x2c, 0xbe,
  0xd4, 0x30, 0x01, 0xbe, 0x86, 0xb6, 0x09, 0xbe, 0x28, 0xcd, 0x8d, 0x3d,
  0xe7, 0x9a, 0x04, 0x3c, 0x71, 0xda, 0xe8, 0xbc, 0x64, 0x99, 0x8a, 0xbd,
  0x7f, 0x9d, 0xd7, 0xbd, 0xc6, 0x45, 0x84, 0xbd, 0x5e, 0xb6, 0xa2, 0xbd,
  0x2c, 0x3f, 0x51, 0xbe, 0x41, 0x3f, 0xf1, 0xbd, 0x90, 0x2e, 0xd8, 0x3c,
  0xfe, 0x52, 0x40, 0xbd, 0x26, 0x1b, 0x1d, 0xbd, 0x77, 0xdd, 0x57, 0xbe,
  0xeb, 0xfe, 0x06, 0x3d, 0x32, 0x96, 0x39, 0x3d, 0xf4, 0xb2, 0x26, 0xbe,
  0x1a, 0xc7, 0x10, 0xbe, 0x5c, 0xb8, 0xc0, 0xbc, 0x2a, 0x33, 0x3b, 0xbe,
  0xdd, 0x2a, 0xa8, 0xbd, 0xb7, 0xa2, 0x72, 0xbd, 0x3d, 0xdb, 0x11, 0x3d,
  0x7d, 0x46, 0x00, 0xbe, 0x08, 0xf0, 0x22, 0x3d, 0x69, 0xc7, 0x14, 0xbe,
  0xea, 0x65, 0xcb, 0xbc, 0xca, 0x9f, 0x9e, 0x3c, 0x28, 0x31, 0x09, 0xbd,
  0x19, 0x10, 0x11, 0xbd, 0xfb, 0xa9, 0x03, 0xbe, 0x30, 0x97, 0x2d, 0xbe,
  0xd9, 0x4c, 0x15, 0xbe, 0x29, 0x35, 0xf9, 0xbd, 0xdc, 0x4a, 0x3c, 0x3c,
  0x2f, 0x44, 0x42, 0xbe, 0x2f, 0x06, 0x67, 0xbd, 0xaa, 0x84, 0x26, 0xbe,
  0x1d, 0xd8, 0xd7, 0xbd, 0x84, 0x1a, 0x88, 0xbb, 0xb9, 0x0c, 0x3e, 0xbe,
  0x19, 0x38, 0x0a, 0xbe, 0xfe, 0x4b, 0xe1, 0xbd, 0x86, 0x7c, 0x47, 0xbe,
  0x33, 0x85, 0x7f, 0xbe, 0x54, 0x42, 0x67, 0xbc, 0xbd, 0xd5, 0x17, 0xbe,
  0x70, 0x39, 0xd2, 0xbc, 0x3d, 0x74, 0xbd, 0xbc, 0x38, 0x96, 0x0a, 0xbd,
  0xcc, 0x73, 0xf0, 0xbd, 0xd7, 0xd8, 0xea, 0x3c, 0xc4, 0xa0, 0x3c, 0xbe,
  0x95, 0x21, 0x2c, 0x3d, 0x81, 0xc3, 0x76, 0xbd, 0x0e, 0x36, 0xc5, 0xbd,
  0xff, 0xc4, 0xa0, 0x3d, 0x26, 0xaf, 0x06, 0xbe, 0x46, 0x2a, 0x32, 0xbe,
  0xc9, 0xd0, 0xda, 0xbc, 0xf2, 0x30, 0x83, 0xbe, 0x33, 0x66, 0x6d, 0xbe,
  0xda, 0x14, 0x90, 0xbd, 0xd5, 0xa5, 0x16, 0xbe, 0x5f, 0x41, 0x27, 0xbe,
  0x8f, 0x79, 0xbe, 0x3d, 0x9a, 0xa9, 0x80, 0xbb, 0x07, 0x53, 0x33, 0xbe,
  0x1e, 0xb8, 0x94, 0xbd, 0x6f, 0xe2, 0x78, 0x3d, 0xea, 0x83, 0x6d, 0x3d,
  0x07, 0x2d, 0x3a, 0xbe, 0x5c, 0x8f, 0xa4, 0xbc, 0xf2, 0xb9, 0xc8, 0xbd,
  0x49, 0x4a, 0x4c, 0x3c, 0x90, 0x69, 0xf4, 0x3c, 0xa4, 0xaa, 0x3e, 0xbe,
  0x82, 0x60, 0x27, 0xbe, 0xfa, 0x9c, 0x0f, 0x3d, 0xf9, 0x8b, 0x14, 0xbe,
  0xcf, 0x1c, 0xf6, 0xbd, 0x4f, 0x8a, 0x1a, 0x3d, 0x4d, 0xba, 0x4a, 0x3c,
  0x7b, 0x1b, 0x98, 0xbd, 0xfd, 0x3d, 0x64, 0x3d, 0x3e, 0x05, 0xc5, 0x3d,
  0x0d, 0x10, 0x43, 0xbe, 0x67, 0x2a, 0x06, 0xbe, 0x35, 0xd0, 0xbb, 0xba,
  0x3d, 0x6f, 0x64, 0xbe, 0xd1, 0x5c, 0xf4, 0x3d, 0x4c, 0x13, 0xde, 0xbd,
  0xa3, 0x5f, 0x93, 0x3d, 0xa3, 0x63, 0xaf, 0xbb, 0x8e, 0x60, 0x2c, 0xbe,
  0x65, 0xc6, 0x41, 0xbe, 0x4d, 0x16, 0x35, 0xbe, 0x94, 0xc7, 0x05, 0xbd,
  0x51, 0xfb, 0x28, 0xbe, 0x46, 0x77, 0xa9, 0x3d, 0x5c, 0xab, 0x97, 0x3b,
  0x69, 0x4f, 0x1d, 0xbd, 0x1a, 0x88, 0xa4, 0x3d, 0x33, 0x54, 0x55, 0x3d,
  0xb4, 0xee, 0x34, 0xbe, 0x5e, 0x36, 0x21, 0xbd, 0xc0, 0x7c, 0x9f, 0x3d,
  0xee, 0x60, 0x89, 0xbd, 0x15, 0x6c, 0xda, 0xbd, 0x49, 0x7c, 0xdd, 0xbd,
  0x09, 0x1d, 0x96, 0x3c, 0xaf, 0x78, 0x75, 0x3d, 0xb0, 0x39, 0xf1, 0xbc,
  0xed, 0x4c, 0xdf, 0x3d, 0x11, 0x86, 0x1e, 0x3d, 0x6c, 0xe4, 0x9c, 0x3c,
  0xe5, 0xb4, 0x59, 0x3d, 0xdb, 0x17, 0x46, 0x3d, 0x55, 0x72, 0x83, 0xbd,
  0xb2, 0xd9, 0x0f, 0xbe, 0x14, 0x59, 0x8f, 0x3d, 0x2f, 0xb2, 0x82, 0x3c,
  0x8e, 0x39, 0x1a, 0xbe, 0xfb, 0xf2, 0xb5, 0x3d, 0x6d, 0xd5, 0x18, 0xbe,
  0xe9, 0xc9, 0x6a, 0x3c, 0x5b, 0xc6, 0xfd, 0xbd, 0x89, 0x76, 0x47, 0x3d,
  0xf6, 0xb2, 0xec, 0x3d, 0xec, 0x11, 0x9d, 0xbb, 0x70, 0x17, 0x32, 0x3d,
  0x74, 0x8b, 0x33, 0xbe, 0x3d, 0xdd, 0x39, 0xbe, 0xe4, 0x72, 0xdd, 0xbd,
  0x25, 0x62, 0xe1, 0xbd, 0x13, 0x8e, 0x8e, 0xbd, 0x0e, 0xac, 0x34, 0xbe,
  0xc0, 0x99, 0xa1, 0xbd, 0x6f, 0x10, 0x01, 0x3e, 0x0e, 0xfa, 0x8a, 0xbd,
  0xa7, 0x54, 0x7b, 0xbd, 0x02, 0xc7, 0x96, 0x3d, 0x67, 0x2d, 0xc2, 0x3d,
  0x8c, 0x1b, 0x17, 0xbe, 0x11, 0xb8, 0xbb, 0x3d, 0xb6, 0xda, 0x0f, 0xbe,
  0x79, 0xf6, 0xd5, 0xbd, 0x5a, 0x07, 0x05, 0x3b, 0xfa, 0x57, 0x22, 0x3d,
  0x6c, 0x5e, 0x02, 0xbe, 0x28, 0x24, 0x0e, 0xbe, 0x85, 0xe6, 0x14, 0xbe,
  0xce, 0xf9, 0xcc, 0xbd, 0x33, 0xa4, 0x06, 0xbe, 0x50, 0xe2, 0x04, 0xbe,
  0xba, 0x6e, 0x7c, 0x3d, 0x6a, 0xd6, 0x42, 0xbd, 0x70, 0x7c, 0x11, 0xbe,
  0xc5, 0xd8, 0x31, 0xbd, 0x4e, 0x90, 0x82, 0x3d, 0xa9, 0x4a, 0x6b, 0x3d,
  0x7f, 0x66, 0x38, 0xbe, 0x3b, 0x46, 0xdc, 0x3c, 0x6d, 0x54, 0x2f, 0xbe,
  0xe4, 0x7f, 0x0b, 0xbe, 0x67, 0x89, 0xe5, 0xbc, 0x28, 0x6a, 0xea, 0xbc,
  0xb8, 0xfe, 0x09, 0x3d, 0x8c, 0xbc, 0xd0, 0xbd, 0xad, 0x2a, 0x96, 0x3c,
  0x59, 0x9d, 0x6e, 0x3c, 0x6b, 0xc1, 0x97, 0xbd, 0xec, 0xb2, 0x32, 0xbe,
  0x68, 0xd3, 0x55, 0xbc, 0xb2, 0x06, 0x85, 0xbd, 0xc2, 0x41, 0xb3, 0x3c,
  0x3c, 0x7a, 0x0c, 0x3e, 0xdb, 0x8e, 0x4e, 0xbe, 0x81, 0x14, 0x31, 0x3d,
  0xdf, 0x20, 0x02, 0x3d, 0xcd, 0xd8, 0x87, 0xbb, 0xa6, 0xc4, 0x96, 0x3d,
  0x54, 0x05, 0xa9, 0xbd, 0x6c, 0x25, 0x35, 0x3d, 0x54, 0x47, 0xfc, 0xbd,
  0x0c, 0x63, 0x5e, 0x3c, 0x4e, 0xba, 0xb7, 0xbd, 0x35, 0x29, 0x2b, 0x3d,
  0xd8, 0x7f, 0xf1, 0xbd, 0x9c, 0x72, 0x86, 0xbc, 0xdf, 0x27, 0x52, 0x3d,
  0x39, 0xf6, 0x5f, 0xbe, 0x88, 0xe8, 0x38, 0xbd, 0x0c, 0x0f, 0xc0, 0xbd,
  0x61, 0x89, 0xad, 0xbd, 0x52, 0x20, 0xf7, 0xbd, 0x1d, 0x27, 0x8f, 0xbc,
  0x0d, 0x3c, 0x2a, 0xbe, 0x4d, 0x7d, 0xc2, 0xbd, 0x22, 0x71, 0x63, 0x3d,
  0x61, 0x26, 0x23, 0xbe, 0x63, 0x66, 0x1c, 0xbe, 0x95, 0xb4, 0x24, 0xbe,
  0xd7, 0xc0, 0x81, 0x3d, 0xa3, 0xe1, 0xbd, 0x3d, 0x47, 0x07, 0x01, 0xbe,
  0x77, 0x65, 0x1e, 0x3d, 0x67, 0x0a, 0x2e, 0xbe, 0xa2, 0x00, 0xc4, 0xbd,
  0x32, 0xae, 0xee, 0x3c, 0x75, 0x02, 0x4a, 0xbe, 0x60, 0x10, 0x4e, 0x3d,
  0xe2, 0xd6, 0x3d, 0xbe, 0xb0, 0x8e, 0xc1, 0xbd, 0x8a, 0x54, 0xf0, 0xbd,
  0x57, 0x39, 0x1d, 0xbe, 0x3d, 0x31, 0xd6, 0x3d, 0x60, 0x95, 0x8e, 0xbc,
  0xb6, 0x30, 0xd8, 0xbd, 0xc6, 0x52, 0x32, 0xbd, 0xa3, 0xb9, 0xd3, 0xbd,
  0x54, 0x04, 0x9d, 0xbd, 0x02, 0x45, 0x86, 0xbd, 0x80, 0xdc, 0x85, 0xbb,
  0xf2, 0x22, 0x2e, 0xbe, 0x42, 0x66, 0xb7, 0x3d, 0x6f, 0x93, 0xb6, 0x3d,
  0x22, 0xa6, 0xd2, 0xbd, 0x1f, 0x71, 0x9c, 0xbd, 0xbd, 0xfc, 0x48, 0xbe,
  0x4e, 0xf8, 0xfc, 0xbd, 0x22, 0x9a, 0x80, 0xbd, 0xf6, 0x68, 0xee, 0xbc,
  0x3e, 0x77, 0x0f, 0xbe, 0x44, 0x8e, 0xe0, 0x3d, 0x2b, 0x6c, 0x8d, 0xbd,
  0x34, 0xd2, 0xfb, 0xbd, 0xcc, 0x74, 0x24, 0xbe, 0x89, 0x50, 0x1a, 0x3d,
  0x66, 0x7d, 0x93, 0xbd, 0x87, 0x48, 0x3b, 0xbe, 0xaa, 0xfc, 0x6e, 0xbd,
  0x84, 0x1c, 0xa0, 0x3c, 0xc5, 0x1e, 0x65, 0x3d, 0x54, 0xc3, 0x62, 0x3d,
  0x28, 0x65, 0xb0, 0x3b, 0x07, 0x6a, 0x24, 0xbe, 0xba, 0x8a, 0x21, 0x3d,
  0x17, 0xbe, 0x97, 0xbc, 0x30, 0x90, 0x86, 0xbd, 0x7a, 0xb4, 0xa1, 0xbd,
  0x4d, 0x41, 0x4a, 0xbd, 0x5b, 0x7d, 0x4c, 0xbe, 0x98, 0xb7, 0xa7, 0x3d,
  0xeb, 0x1c, 0xe9, 0xbc, 0x97, 0xc3, 0xd4, 0xbd, 0xdf, 0x53, 0x7b, 0x3a,
  0x15, 0x0f, 0x4a, 0xbe, 0x65, 0xf2, 0x0b, 0xbd, 0x9f, 0x21, 0x1a, 0x3b,
  0x8c, 0x7f, 0x0c, 0xbe, 0x50, 0x6a, 0xc8, 0x3a, 0x56, 0x93, 0xf9, 0xbd,
  0x99, 0x4f, 0x1a, 0xbe, 0x8c, 0x61, 0x1b, 0xbe, 0x02, 0x51, 0x5b, 0xbd,
  0x65, 0xa4, 0x1c, 0xbe, 0x37, 0x2c, 0x5e, 0xbc, 0x3c, 0x24, 0xfc, 0x3c,
  0x47, 0xb2, 0xe5, 0x3c, 0xd1, 0xc7, 0xcb, 0xbd, 0x88, 0xf1, 0x43, 0xbe,
  0xe7, 0xb5, 0xd2, 0x3d, 0xec, 0xa3, 0x57, 0xbe, 0x11, 0xe0, 0x30, 0xbb,
  0x3d, 0xf4, 0x37, 0xbe, 0x81, 0x9d, 0x2f, 0xbe, 0x38, 0x66, 0x3d, 0xbe,
  0xad, 0x19, 0x70, 0x3c, 0x02, 0x84, 0x85, 0x3c, 0x03, 0x25, 0x9c, 0x3d,
  0xde, 0x60, 0x19, 0xbe, 0xd9, 0xfa, 0xf1, 0x3d, 0xa4, 0xd6, 0x32, 0xbe,
  0x4c, 0x62, 0x30, 0xbe, 0x51, 0x28, 0x99, 0xbd, 0xe7, 0x54, 0x21, 0xbe,
  0x8b, 0x0c, 0x78, 0xbc, 0xcb, 0xe0, 0xf8, 0xbd, 0xbb, 0xd3, 0xe2, 0xbd,
  0xc4, 0xab, 0x4a, 0x3e, 0x19, 0x1b, 0x62, 0xbc, 0x27, 0x7a, 0x01, 0x3d,
  0xde, 0x47, 0xf7, 0x3d, 0x8b, 0x03, 0x56, 0x3d, 0x2d, 0x5f, 0x88, 0xbe,
  0xaa, 0x91, 0xc8, 0xba, 0xab, 0x3d, 0x25, 0xbd, 0xa8, 0x81, 0x11, 0xbd,
  0xdf, 0xea, 0xdc, 0x3d, 0x37, 0x3b, 0x58, 0x3d, 0x34, 0x29, 0x1f, 0xbe,
  0x81, 0x90, 0xc4, 0xbd, 0x7c, 0xf3, 0x6a, 0x3d, 0x55, 0x20, 0x20, 0xbe,
  0xd8, 0x9e, 0x4b, 0xbe, 0x4e, 0x38, 0x01, 0xbe, 0xba, 0x8f, 0x0e, 0x3d,
  0x57, 0xee, 0x41, 0xbe, 0x90, 0x1e, 0xef, 0x3d, 0x45, 0x4b, 0x68, 0xbd,
  0x28, 0xa9, 0x38, 0xbe, 0xdd, 0x77, 0x24, 0xbe, 0x05, 0x63, 0x04, 0xbd,
  0xd3, 0xab, 0xea, 0xbd, 0xbd, 0xa5, 0x70, 0xbe, 0xe1, 0xb1, 0x32, 0xbe,
  0xe3, 0xae, 0xe6, 0xbd, 0x64, 0xca, 0xa9, 0xbe, 0x9e, 0xbf, 0x22, 0xbe,
  0x39, 0xf0, 0x54, 0xbb, 0x1b, 0xcf, 0xc0, 0xbc, 0x95, 0x25, 0x9b, 0xbe,
  0xc6, 0xde, 0xb2, 0x3b, 0xcf, 0x3f, 0x40, 0xbd, 0xda, 0xf8, 0x09, 0xbe,
  0x1d, 0x7c, 0xdc, 0x3c, 0xe5, 0xbc, 0xc4, 0x3d, 0xa2, 0x1e, 0xd9, 0x3d,
  0x7d, 0x35, 0xc3, 0xbc, 0x9f, 0x5d, 0x63, 0xbe, 0x65, 0xb0, 0x30, 0xbd,
  0x6f, 0x1d, 0x97, 0xbe, 0xa3, 0xdd, 0x03, 0xbe, 0xa7, 0x47, 0x70, 0xbd,
  0x13, 0xac, 0xcb, 0x3c, 0xd3, 0xcb, 0xea, 0xbd, 0xb1, 0xdf, 0x4c, 0xbd,
  0x1d, 0x2a, 0x25, 0x3e, 0xdf, 0x50, 0x0e, 0x3d, 0xab, 0xd1, 0x8c, 0xbd,
  0x02, 0xcc, 0x40, 0xbd, 0x24, 0x27, 0x10, 0x3d, 0x75, 0x0e, 0x02, 0xbd,
  0x2c, 0xf4, 0x7d, 0xbd, 0x2e, 0xe5, 0x32, 0xbd, 0xbf, 0xf6, 0x65, 0xbe,
  0x3f, 0x1a, 0x37, 0xbd, 0x05, 0x73, 0x91, 0xbe, 0xa3, 0x40, 0x8a, 0xbc,
  0xc2, 0xd6, 0xc9, 0x3d, 0x21, 0x03, 0x92, 0xbd, 0x97, 0xea, 0x33, 0x3d,
  0xaa, 0x81, 0x68, 0x3b, 0x5b, 0x83, 0xc4, 0xbc, 0x0a, 0xa9, 0x25, 0x3d,
  0x9b, 0x2c, 0x25, 0xbe, 0x14, 0x3e, 0xac, 0x3c, 0xc1, 0x23, 0x08, 0xba,
  0x8b, 0x1e, 0xbc, 0x3d, 0x97, 0x46, 0x30, 0x3d, 0x26, 0x0d, 0x65, 0xbe,
  0xa6, 0x8a, 0x41, 0x3c, 0x15, 0xf2, 0xd3, 0xbd, 0xfa, 0xc8, 0xf3, 0xbd,
  0x5f, 0x15, 0x43, 0x3d, 0xd3, 0x93, 0x61, 0xbe, 0x92, 0x8b, 0xfa, 0xbc,
  0xba, 0x67, 0x25, 0x3d, 0x84, 0x5e, 0xdc, 0xbc, 0x84, 0x0d, 0x2f, 0xbe,
  0x88, 0x7b, 0x80, 0xbc, 0x5d, 0x24, 0x64, 0xbe, 0xc5, 0xec, 0xe4, 0x3e,
  0xeb, 0x0b, 0xda, 0x3d, 0xc1, 0xb1, 0x01, 0x3c, 0x6d, 0xb4, 0xd5, 0xbd,
  0xa8, 0xf8, 0x8c, 0xbe, 0x3c, 0x26, 0x2a, 0x3e, 0xe6, 0xc3, 0xaf, 0xbd,
  0xa2, 0x32, 0x8a, 0xbd, 0x72, 0x85, 0x25, 0x3e, 0x18, 0x8d, 0xa7, 0xbe,
  0x6a, 0xd1, 0xf4, 0xbd, 0x7b, 0xd8, 0x1c, 0x3e, 0x8f, 0xa7, 0xe6, 0x3d,
  0xba, 0xb7, 0xe9, 0x3d, 0x92, 0xff, 0x1b, 0x39, 0xd6, 0xeb, 0xa9, 0xbe,
  0x4e, 0x35, 0x89, 0x3e, 0x22, 0x86, 0xce, 0x3d, 0x91, 0x39, 0x39, 0x3d,
  0x89, 0x38, 0x7f, 0xbd, 0xbd, 0x81, 0x95, 0xbe, 0xc3, 0xfc, 0xa0, 0x3c,
  0x39, 0xdc, 0x59, 0x3d, 0xfc, 0x49, 0x82, 0xbd, 0x43, 0x94, 0xf6, 0x3d,
  0x8d, 0x26, 0x7e, 0xbe, 0x72, 0xaa, 0x00, 0xbd, 0x19, 0xc0, 0xd3, 0x3d,
  0x19, 0xf2, 0x31, 0x3e, 0x15, 0x09, 0x15, 0x3e, 0x8a, 0x23, 0x21, 0xbe,
  0x31, 0xea, 0x87, 0xbe, 0x97, 0x3c, 0x88, 0x3e, 0x95, 0x2e, 0xd4, 0xba,
  0xbf, 0x26, 0x22, 0x3e, 0x6f, 0x2e, 0xb6, 0x3b, 0x97, 0xfd, 0x6d, 0xbe,
  0xdb, 0x4a, 0x5d, 0xbc, 0x64, 0x0b, 0x07, 0xbd, 0xf0, 0x4f, 0xd2, 0x3d,
  0xf1, 0x6e, 0x08, 0x3e, 0x7a, 0xae, 0x2d, 0xbe, 0x17, 0xa3, 0x6d, 0x3b,
  0x20, 0xed, 0x04, 0x3e, 0x5a, 0xea, 0xcc, 0x3d, 0x25, 0x06, 0xa2, 0x3e,
  0x3a, 0x03, 0x3e, 0xbc, 0xa1, 0x25, 0x70, 0xbe, 0x87, 0x25, 0x77, 0x3e,
  0x5b, 0xc3, 0xb6, 0xbc, 0xae, 0xab, 0x0a, 0x3c, 0x11, 0x12, 0x9b, 0x3d,
  0xe4, 0x8b, 0x7a, 0xbd, 0xdc, 0x8e, 0x30, 0x3d, 0xd1, 0xa4, 0xe0, 0xbd,
  0x1f, 0xe5, 0x8a, 0x3d, 0xad, 0x0e, 0xdf, 0x3d, 0x20, 0x65, 0x9f, 0xbd,
  0xaf, 0xa1, 0x35, 0xbd, 0xa5, 0x64, 0xa8, 0x3d, 0x2c, 0x9f, 0x0e, 0x3e,
  0x0a, 0x1f, 0xbe, 0x3e, 0x56, 0xb8, 0x1c, 0xbd, 0xf3, 0xee, 0x84, 0xbe,
  0xb6, 0x05, 0x2b, 0x3e, 0xe0, 0x9a, 0x33, 0x3d, 0x02, 0x7f, 0xca, 0x3c,
  0x97, 0x85, 0xe2, 0x3c, 0x3a, 0xfa, 0xbb, 0x3d, 0x2c, 0x24, 0x0a, 0x3e,
  0x01, 0x6d, 0x53, 0x3d, 0xfb, 0xcf, 0xfd, 0x3d, 0x41, 0x61, 0x80, 0x3c,
  0x09, 0xb0, 0x69, 0x3d, 0x61, 0x38, 0x15, 0xbe, 0x97, 0x60, 0xf9, 0xbd,
  0xcd, 0xe6, 0x39, 0x3e, 0xb0, 0xae, 0x5e, 0x3e, 0x31, 0x32, 0x2a, 0x3c,
  0x9e, 0xa0, 0xa4, 0xbe, 0xcd, 0xb6, 0x2b, 0x3e, 0x07, 0xb6, 0x46, 0x3c,
  0x44, 0xa0, 0x2e, 0x3d, 0x68, 0x10, 0x6d, 0xbd, 0xe3, 0xce, 0xde, 0x3d,
  0xca, 0xbe, 0x04, 0x3e, 0x27, 0x2d, 0x11, 0x3e, 0x63, 0xca, 0x85, 0x3d,
  0x89, 0x51, 0xc7, 0xbd, 0x00, 0xdc, 0xa9, 0x3c, 0xeb, 0x09, 0x6e, 0xbe,
  0x9f, 0x97, 0x86, 0xbe, 0xfa, 0x44, 0xe9, 0xba, 0x05, 0x4f, 0xfe, 0xbd,
  0x44, 0x2e, 0xd3, 0xba, 0x90, 0x31, 0xac, 0xbe, 0x4b, 0x71, 0xbc, 0xbe,
  0x9c, 0x9e, 0x3e, 0xbe, 0x7e, 0x25, 0x6a, 0x3d, 0x1e, 0xbc, 0x39, 0xbe,
  0x16, 0xcb, 0x10, 0x3e, 0x8a, 0x63, 0x30, 0xbe, 0x8e, 0x13, 0x21, 0xbe,
  0xd8, 0x96, 0xf3, 0xbd, 0x85, 0xba, 0x0c, 0xbe, 0xc9, 0xd6, 0x97, 0xbe,
  0xd1, 0xa0, 0x14, 0xbe, 0xd3, 0x16, 0xa8, 0xbe, 0x6c, 0x1a, 0xa5, 0xbe,
  0x6b, 0x6f, 0x81, 0xbd, 0xcb, 0x80, 0xc5, 0x3d, 0x71, 0xfe, 0x0b, 0xbd,
  0x32, 0x87, 0xbe, 0xbe, 0x0b, 0x64, 0x0f, 0xbe, 0xe7, 0x2f, 0x3c, 0xbe,
  0xc1, 0xe2, 0x28, 0xbd, 0xa4, 0x5c, 0xd8, 0x3d, 0xfc, 0x5f, 0xc1, 0xbe,
  0x95, 0x90, 0x9e, 0xbe, 0x17, 0xfb, 0xad, 0xbd, 0x91, 0x30, 0xec, 0xbd,
  0xaf, 0xbf, 0x43, 0x3c, 0xdd, 0x67, 0x55, 0xbe, 0xf9, 0x25, 0x8c, 0x3e,
  0x1b, 0x3c, 0x0b, 0xbe, 0x0b, 0x35, 0x85, 0xbe, 0x7c, 0xc2, 0x3f, 0x3e,
...

This file has been truncated, please download it to see its full contents.
arduino_output_handler.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "output_handler.h"

#include "Arduino.h"

void HandleOutput(tflite::ErrorReporter* error_reporter, int kind) {
  // The first time this method runs, set up our LED
  static bool is_initialized = false;
  if (!is_initialized) {
    pinMode(LED_BUILTIN, OUTPUT);
    is_initialized = true;
  }
  // Toggle the LED every time an inference is performed
  static int count = 0;
  ++count;
  if (count & 1) {
    digitalWrite(LED_BUILTIN, HIGH);
  } else {
    digitalWrite(LED_BUILTIN, LOW);
  }
  // Print some ASCII art for each gesture
  if (kind == 0) {
    error_reporter->Report(
        "WING:\n\r*         *         *\n\r *       * *       "
        "*\n\r  *     *   *     *\n\r   *   *     *   *\n\r    * *       "
        "* *\n\r     *         *\n\r");
  } else if (kind == 1) {
    error_reporter->Report(
        "RING:\n\r          *\n\r       *     *\n\r     *         *\n\r "
        "   *           *\n\r     *         *\n\r       *     *\n\r      "
        "    *\n\r");
  } else if (kind == 2) {
    error_reporter->Report(
        "SLOPE:\n\r        *\n\r       *\n\r      *\n\r     *\n\r    "
        "*\n\r   *\n\r  *\n\r * * * * * * * *\n\r");
  }
}
magic_wand_model_data.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// This is a standard TensorFlow Lite model file that has been converted into a
// C data array, so it can be easily compiled into a binary for devices that
// don't have a file system. It was created using the command:
// xxd -i magic_wand_model.tflite > magic_wand_model_data.cc

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAGIC_WAND_MODEL_DATA_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAGIC_WAND_MODEL_DATA_H_

extern const unsigned char g_magic_wand_model_data[];
extern const int g_magic_wand_model_data_len;

#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAGIC_WAND_MODEL_DATA_H_
arduino_accelerometer_handler.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "accelerometer_handler.h"

#include <Arduino.h>
#include <Arduino_LSM9DS1.h>

#include "constants.h"

// A buffer holding the last 200 sets of 3-channel values
float save_data[600] = {0.0};
// Most recent position in the save_data buffer
int begin_index = 0;
// True if there is not yet enough data to run inference
bool pending_initial_data = true;
// How often we should save a measurement during downsampling
int sample_every_n;
// The number of measurements since we last saved one
int sample_skip_counter = 1;

TfLiteStatus SetupAccelerometer(tflite::ErrorReporter* error_reporter) {
  // Wait until we know the serial port is ready
  while (!Serial) {
  }

  // Switch on the IMU
  if (!IMU.begin()) {
    error_reporter->Report("Failed to initialize IMU");
    return kTfLiteError;
  }

  // Determine how many measurements to keep in order to
  // meet kTargetHz
  float sample_rate = IMU.accelerationSampleRate();
  sample_every_n = static_cast<int>(roundf(sample_rate / kTargetHz));

  error_reporter->Report("Magic starts!");

  return kTfLiteOk;
}

bool ReadAccelerometer(tflite::ErrorReporter* error_reporter, float* input,
                       int length, bool reset_buffer) {
  // Clear the buffer if required, e.g. after a successful prediction
  if (reset_buffer) {
    memset(save_data, 0, 600 * sizeof(float));
    begin_index = 0;
    pending_initial_data = true;
  }
  // Keep track of whether we stored any new data
  bool new_data = false;
  // Loop through new samples and add to buffer
  while (IMU.accelerationAvailable()) {
    float x, y, z;
    // Read each sample, removing it from the device's FIFO buffer
    if (!IMU.readAcceleration(x, y, z)) {
      error_reporter->Report("Failed to read data");
      break;
    }
    // Throw away this sample unless it's the nth
    if (sample_skip_counter != sample_every_n) {
      sample_skip_counter += 1;
      continue;
    }
    // Write samples to our buffer, converting to milli-Gs
    // and flipping y and x order for compatibility with
    // model (sensor orientation is different on Arduino
    // Nano BLE Sense compared with SparkFun Edge)
    save_data[begin_index++] = y * 1000;
    save_data[begin_index++] = x * 1000;
    save_data[begin_index++] = z * 1000;
    // Since we took a sample, reset the skip counter
    sample_skip_counter = 1;
    // If we reached the end of the circle buffer, reset
    if (begin_index >= 600) {
      begin_index = 0;
    }
    new_data = true;
  }

  // Skip this round if data is not ready yet
  if (!new_data) {
    return false;
  }

  // Check if we are ready for prediction or still pending more initial data
  if (pending_initial_data && begin_index >= 200) {
    pending_initial_data = false;
  }

  // Return if we don't have enough data
  if (pending_initial_data) {
    return false;
  }

  // Copy the requested number of bytes to the provided input tensor
  for (int i = 0; i < length; ++i) {
    int ring_array_index = begin_index + i - length;
    if (ring_array_index < 0) {
      ring_array_index += 600;
    }
    input[i] = save_data[ring_array_index];
  }

  return true;
}
arduino_constants.cppC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "constants.h"

// The number of expected consecutive inferences for each gesture type.
// Established with the Arduino Nano 33 BLE Sense.
const int kConsecutiveInferenceThresholds[3] = {8, 5, 4};
gesture_predictor.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_GESTURE_PREDICTOR_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_GESTURE_PREDICTOR_H_

extern int PredictGesture(float* output);

#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_GESTURE_PREDICTOR_H_
accelerometer_handler.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_ACCELEROMETER_HANDLER_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_ACCELEROMETER_HANDLER_H_

#define kChannelNumber 3

#include "tensorflow/lite/c/c_api_internal.h"
#include "tensorflow/lite/experimental/micro/micro_error_reporter.h"

extern int begin_index;
extern TfLiteStatus SetupAccelerometer(tflite::ErrorReporter* error_reporter);
extern bool ReadAccelerometer(tflite::ErrorReporter* error_reporter,
                              float* input, int length, bool reset_buffer);

#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_ACCELEROMETER_HANDLER_H_
main_functions.hC/C++
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#ifndef TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAIN_FUNCTIONS_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAIN_FUNCTIONS_H_

// Initializes all data needed for the example. The name is important, and needs
// to be setup() for Arduino compatibility.
void setup();

// Runs one iteration of data gathering and inference. This should be called
// repeatedly from the application code. The name needs to be loop() for Arduino
// compatibility.
void loop();

#endif  // TENSORFLOW_LITE_EXPERIMENTAL_MICRO_EXAMPLES_MAGIC_WAND_MAIN_FUNCTIONS_H_

Schematics

Schematics
The structure of the application.
Schematics 0xxs4ip3yf

Comments

Team 182

Default
Yumeng Liu
  • 1 project
  • 0 followers
Default
Xinyu Wu
  • 1 project
  • 0 followers
Default
Jiarong Xing
  • 1 project
  • 0 followers

Published on

December 15, 2019

Members who respect this project

DefaultDefault

and 2 others

See similar projects
you might like

Similar projects you might like

Magic Arduino Ball

Project showcase by Ruben Zilzer

  • 2,511 views
  • 1 comment
  • 6 respects

Magic Cauldron

Project showcase by Ian McKay

  • 7,017 views
  • 3 comments
  • 21 respects

Magic Projector (A Romantic One)

Project tutorial by Arturo Rosete

  • 2,203 views
  • 2 comments
  • 7 respects

Ask the Magic 8 Ball!

Project tutorial by College Bound

  • 3,568 views
  • 5 comments
  • 10 respects

Magic in the Bedroom

Project in progress by Randa El Ali and Jesse Laprad

  • 2,891 views
  • 0 comments
  • 4 respects

Magic Eyes

Project tutorial by Ayush Aggarwal

  • 1,201 views
  • 0 comments
  • 4 respects
Add projectSign up / Login